def test_wwinp_to_h5m():
thisdir = os.path.dirname(__file__)
wwinp = os.path.join(thisdir, "files_test_wwinp_to_h5m/wwinp_test.e")
output = os.path.join(os.getcwd(), "wwinp_mesh.h5m")
if output in os.listdir("."):
os.remove(output)
wwinp_to_h5m.cartesian(wwinp, output)
with open(output) as f:
written = f.read()
expected_sm = ScdMesh.fromFile(os.path.join(thisdir, "files_test_wwinp_to_h5m/expected_wwinp_mesh.h5m"))
written_sm = ScdMesh.fromFile(output)
for x in range(0, 5):
for y in range(0, 6):
for z in range(0, 10):
expected_voxel = expected_sm.getHex(x, y, z)
expected = expected_sm.imesh.getTagHandle("ww_n_group_001")[expected_voxel]
written_voxel = written_sm.getHex(x, y, z)
written = written_sm.imesh.getTagHandle("ww_n_group_001")[written_voxel]
assert_equal(written, expected)
os.remove(output)
def test_wwinp_to_h5m():
wwinp = 'files_test_wwinp_to_h5m/wwinp_test.txt'
output = 'wwinp_mesh.h5m'
if output in os.listdir('.'):
os.remove(output)
wwinp_to_h5m.cartesian(wwinp, output)
with open(output) as f:
written = f.read()
expected_sm = ScdMesh.fromFile('files_test_wwinp_to_h5m/expected_wwinp_mesh.h5m')
written_sm = ScdMesh.fromFile(output)
for x in range(0,5):
for y in range(0,6):
for z in range(0,10):
expected_voxel = expected_sm.getHex(x,y,z)
expected = expected_sm.imesh.getTagHandle('ww_n_group_001')[expected_voxel]
written_voxel = written_sm.getHex(x,y,z)
written = written_sm.imesh.getTagHandle('ww_n_group_001')[written_voxel]
assert_equal(written, expected)
os.remove(output)
def test_wwinp_to_h5m_1D_p():
thisdir = os.path.dirname(__file__)
wwinp = os.path.join(thisdir, 'files_test_wwinp_to_h5m/1D_p.e')
expected_file = os.path.join(thisdir, 'files_test_wwinp_to_h5m/expected_ww_mesh_1D_p.h5m')
written_sm = wwinp_to_h5m.cartesian(wwinp)
expected_sm = ScdMesh.fromFile(expected_file)
#verify weight window lower bounds are the same
for x in range(0,1):
for y in range(0,1):
for z in range(0,9):
expected_voxel = expected_sm.getHex(x,y,z)
expected = expected_sm.imesh.getTagHandle('ww_n_group_001')[expected_voxel]
written_voxel = written_sm.getHex(x,y,z)
written = written_sm.imesh.getTagHandle('ww_n_group_001')[written_voxel]
assert_equal(written, expected)
#verify correct particle identifier
assert_equal(written_sm.imesh.getTagHandle('particle')[written_sm.imesh.rootSet], 1)
#verify correct energy upper bounds
expected_E = 100
written_E = written_sm.imesh.getTagHandle('E_upper_bounds')[written_sm.imesh.rootSet]
assert_equal(written_E, expected_E)
def main():
"""ACTION: Method defines an option parser and handles command-line
usage of this module.
REQUIRES: command line arguments to be passed - otherwise prints help
information.
"""
usage = "usage: %prog ENERGY_FILE MESH_FILE [options] \n\n" \
"ENERGY_FILE is a list of the energy bins for each photon energy " \
"group, with a single energy per line. MESH_FILE is the MOAB " \
"mesh that will store the contents of ENERGY_FILE in the tag " \
"'PHTN_ERGS'."
parser = OptionParser(usage)
(options, args) = parser.parse_args()
fr = open(args[0])
sm = ScdMesh.fromFile(args[1])
# Call the method to read fr and tag mesh
read_and_tag_phtn_ergs(fr, sm)
mesh.save(args[1])
fr.close()
return 1
def main( arguments = None ):
#Instatiate options parser
parser = OptionParser\
(usage='%prog <ww mesh> [options]')
parser.add_option('-o', dest='output_name', default='wwinp.out',\
help='Name of WWINP output file, default=%default')
parser.add_option('-t', action='store_true', dest='totals_bool',\
default=False, \
help='If multiple energy groups exist, only use Total \
default=%default')
(opts, args) = parser.parse_args( arguments )
if len(args) != 1:
parser.error\
( '\nNeed exactly 1 argument: <ww mesh>' )
# load mesh
ww_mesh = ScdMesh.fromFile(args[0])
write_wwinp(ww_mesh, opts.totals_bool, opts.output_name)
print "\tWrote WWINP file '{0}'".format(opts.output_name)
print "Complete"
def main():
"""Method defines an option parser and handles command-line
usage of this module.
Notes
-----
Requires command line arguments to be passed - otherwise prints help
information.
"""
usage = "usage: %prog input-h5m-file [options] arg"
parser = OptionParser(usage)
# Input and mesh file names
parser.add_option("-o","--output",action="store",dest="output", \
default="gammas",help="Option specifies the name of the 'gammas'" \
"file. Default: %default")
#
(options, args) = parser.parse_args()
# Create ScdMesh object, which also loads 'meshfile' into mesh.
sm = ScdMesh.fromFile(args[0])
gen_gammas_file_from_h5m(sm, options.output)
return 1
def test_wwinp_to_h5m_3D_n():
thisdir = os.path.dirname(__file__)
wwinp = os.path.join(thisdir, 'files_test_wwinp_to_h5m/3D_n.e')
expected_file = os.path.join(
thisdir, 'files_test_wwinp_to_h5m/expected_ww_mesh_3D_n.h5m')
written_sm = wwinp_to_h5m.cartesian(wwinp)
expected_sm = ScdMesh.fromFile(expected_file)
#verify weight window lower bounds are the same
for x in range(0, 14):
for y in range(0, 8):
for z in range(0, 6):
for e_group in range(1, 8):
expected_voxel = expected_sm.getHex(x, y, z)
expected = expected_sm.imesh.getTagHandle(
'ww_n_group_00{0}'.format(e_group))[expected_voxel]
written_voxel = written_sm.getHex(x, y, z)
written = written_sm.imesh.getTagHandle(
'ww_n_group_00{0}'.format(e_group))[written_voxel]
assert_equal(written, expected)
#verify correct particle identifier
assert_equal(
written_sm.imesh.getTagHandle('particle')[written_sm.imesh.rootSet], 1)
#verify correct energy upper bounds
expected_E = [1E-9, 1E-8, 1E-7, 1E-6, 1E-5, 1E-4, 1E-3]
written_E = written_sm.imesh.getTagHandle('E_upper_bounds')[
written_sm.imesh.rootSet]
for i in range(0, len(expected_E)):
assert_equal(written_E[i], expected_E[i])
def test_wwinp_to_h5m_1D_p():
thisdir = os.path.dirname(__file__)
wwinp = os.path.join(thisdir, 'files_test_wwinp_to_h5m/1D_p.e')
expected_file = os.path.join(
thisdir, 'files_test_wwinp_to_h5m/expected_ww_mesh_1D_p.h5m')
written_sm = wwinp_to_h5m.cartesian(wwinp)
expected_sm = ScdMesh.fromFile(expected_file)
#verify weight window lower bounds are the same
for x in range(0, 1):
for y in range(0, 1):
for z in range(0, 9):
expected_voxel = expected_sm.getHex(x, y, z)
expected = expected_sm.imesh.getTagHandle(
'ww_n_group_001')[expected_voxel]
written_voxel = written_sm.getHex(x, y, z)
written = written_sm.imesh.getTagHandle(
'ww_n_group_001')[written_voxel]
assert_equal(written, expected)
#verify correct particle identifier
assert_equal(
written_sm.imesh.getTagHandle('particle')[written_sm.imesh.rootSet], 1)
#verify correct energy upper bounds
expected_E = 100
written_E = written_sm.imesh.getTagHandle('E_upper_bounds')[
written_sm.imesh.rootSet]
assert_equal(written_E, expected_E)
def main(arguments=None):
#Instatiate options parser
parser = OptionParser\
(usage='%prog <ww mesh> [options]')
parser.add_option('-o', dest='output_name', default='wwinp.out',\
help='Name of WWINP output file, default=%default')
parser.add_option('-t', action='store_true', dest='totals_bool',\
default=False, \
help='If multiple energy groups exist, only use Total \
default=%default' )
(opts, args) = parser.parse_args(arguments)
if len(args) != 1:
parser.error\
( '\nNeed exactly 1 argument: <ww mesh>' )
# load mesh
ww_mesh = ScdMesh.fromFile(args[0])
write_wwinp(ww_mesh, opts.totals_bool, opts.output_name)
print "\tWrote WWINP file '{0}'".format(opts.output_name)
print "Complete"
def test_h5m_to_wwinp_3D_n():
thisdir = os.path.dirname(__file__)
ww_sm_filename = os.path.join(
thisdir, 'files_test_wwinp_to_h5m/expected_ww_mesh_3D_n.h5m')
ww_sm = ScdMesh.fromFile(ww_sm_filename)
output = os.path.join(os.getcwd(), 'test.e')
expected_output = os.path.join(thisdir, 'files_test_wwinp_to_h5m/3D_n.e')
if output in os.listdir('.'):
os.remove(output)
totals_bool = False
h5m_to_wwinp.write_wwinp(ww_sm, totals_bool, output)
with open(output) as f:
written = f.readlines()
with open(expected_output) as f:
expected = f.readlines()
# check to make sure the first line is the same except for the date
assert_equal(written[0].split()[:-2], expected[0].split()[:-2])
# check to make sure files are the same length
assert_equal(len(written), len(expected))
# check to make sure the rest of the lines have the same values
# since the number formats are different, float comparisons are used
for i in range(1, len(expected)):
for j in range(0, len(expected[i].split())):
assert_equal(float(written[i].split()[j]),
float(expected[i].split()[j]))
os.remove(output)
def main():
"""ACTION: Method defines an option parser and handles command-line
usage of this module.
REQUIRES: command line arguments to be passed - otherwise prints help
information.
"""
usage = "usage: %prog ENERGY_FILE MESH_FILE [options] \n\n" \
"ENERGY_FILE is a list of the energy bins for each photon energy " \
"group, with a single energy per line. MESH_FILE is the MOAB " \
"mesh that will store the contents of ENERGY_FILE in the tag " \
"'PHTN_ERGS'."
parser = OptionParser(usage)
(options, args) = parser.parse_args()
fr = open(args[0])
sm = ScdMesh.fromFile(args[1])
# Call the method to read fr and tag mesh
read_and_tag_phtn_ergs(fr, sm)
sm.scdset.save(args[1])
fr.close()
return 1
def main():
"""Method defines an option parser and handles command-line
usage of this module.
Notes
-----
Requires command line arguments to be passed - otherwise prints help
information.
"""
usage = "usage: %prog input-h5m-file [options] arg"
parser = OptionParser(usage)
# Input and mesh file names
parser.add_option("-o","--output",action="store",dest="output", \
default="gammas",help="Option specifies the name of the 'gammas'" \
"file. Default: %default")
#
(options, args) = parser.parse_args()
# Create ScdMesh object, which also loads 'meshfile' into mesh.
sm = ScdMesh.fromFile(args[0])
gen_gammas_file_from_h5m(sm, options.output)
return 1
def test_wwinp_to_h5m_3D_n():
thisdir = os.path.dirname(__file__)
wwinp = os.path.join(thisdir, 'files_test_wwinp_to_h5m/3D_n.e')
expected_file = os.path.join(thisdir, 'files_test_wwinp_to_h5m/expected_ww_mesh_3D_n.h5m')
written_sm = wwinp_to_h5m.cartesian(wwinp)
expected_sm = ScdMesh.fromFile(expected_file)
#verify weight window lower bounds are the same
for x in range(0,14):
for y in range(0,8):
for z in range(0,6):
for e_group in range(1, 8):
expected_voxel = expected_sm.getHex(x,y,z)
expected = expected_sm.imesh.getTagHandle('ww_n_group_00{0}'.format(e_group))[expected_voxel]
written_voxel = written_sm.getHex(x,y,z)
written = written_sm.imesh.getTagHandle('ww_n_group_00{0}'.format(e_group))[written_voxel]
assert_equal(written, expected)
#verify correct particle identifier
assert_equal(written_sm.imesh.getTagHandle('particle')[written_sm.imesh.rootSet], 1)
#verify correct energy upper bounds
expected_E = [1E-9, 1E-8, 1E-7, 1E-6, 1E-5, 1E-4, 1E-3]
written_E = written_sm.imesh.getTagHandle('E_upper_bounds')[written_sm.imesh.rootSet]
for i in range(0, len(expected_E)):
assert_equal(written_E[i], expected_E[i])
def test_h5m_to_wwinp_3D_n():
thisdir = os.path.dirname(__file__)
ww_sm_filename = os.path.join(thisdir, 'files_test_wwinp_to_h5m/expected_ww_mesh_3D_n.h5m')
ww_sm = ScdMesh.fromFile(ww_sm_filename)
output = os.path.join(os.getcwd(), 'test.e')
expected_output = os.path.join(thisdir, 'files_test_wwinp_to_h5m/3D_n.e')
if output in os.listdir('.'):
os.remove(output)
totals_bool = False
h5m_to_wwinp.write_wwinp(ww_sm, totals_bool, output)
with open(output) as f:
written = f.readlines()
with open(expected_output) as f:
expected = f.readlines()
# check to make sure the first line is the same except for the date
assert_equal(written[0].split()[:-2], expected[0].split()[:-2])
# check to make sure files are the same length
assert_equal(len(written), len(expected))
# check to make sure the rest of the lines have the same values
# since the number formats are different, float comparisons are used
for i in range(1, len(expected)):
for j in range(0, len(expected[i].split())):
assert_equal(float(written[i].split()[j]), float(expected[i].split()[j]))
os.remove(output)
def main( arguments = None ) :
# Instantiate option parser
parser = OptionParser\
(usage='%prog <meshtal_file> <normalization_factor> [options]')
parser.add_option('-o', dest='mesh_output', default='flux_mesh.h5m',\
help = 'Name of mesh output file, default=%default.\
For meshtal files with multiple tallies,\
if the -o flag is used all tallies must be named,\
with file names seperated by commas and no spaces\
(e.g. "tally14.h5m,tally24.h5m,tally34.h5m")')
parser.add_option('-n', dest='norm', default=None,
help='Normalization factor, default=%default,\
For meshtal files with multiple tallies, if the -n\
flag is used, a normalization factor must be\
specified for all tallies, seperated by commas but \
not spaces (eg. -n 1.1,2.2,3.3) ')
parser.add_option('-m', dest='smesh_filename', default=None,
help='Preexisting mesh on which to tag fluxes')
(opts, args) = parser.parse_args(arguments)
#if len(args) != 2 :
# parser.error('\nNeed 1 argument: meshtal file')
print "\n\nRunning read_meshtal.py"
tally_numbers, tally_lines = find_tallies(args[1])
print "Number of tallies found: {0}\nTally number(s): {1}" \
.format(len(tally_numbers), tally_numbers)
# Parse input from options parser, generate default values
if opts.norm :
norm = opts.norm.split(',')
else :
norm = [1]*len(tally_numbers)
if opts.mesh_output !='flux_mesh.h5m' :
mesh_output = opts.mesh_output.split(',')
else:
mesh_output = []
for n in range(0, len(tally_numbers)) :
if len(tally_numbers) == 1 :
mesh_output.append('flux_mesh.h5m')
else :
mesh_output.append('flux_mesh_tally{0}.h5m'.format(tally_numbers[n]))
# Convert each tally to h5m and name accordingly
for n in range(0,len(tally_numbers)) :
print "\nNow parsing tally number {0}".format(tally_numbers[n])
if opts.smesh_filename:
alt_sm = ScdMesh.fromFile(opts.smesh_filename)
sm = read_meshtal(args[1], tally_lines[n], float(norm[n]), smesh=alt_sm)
else:
sm = read_meshtal(args[1], tally_lines[n],float(norm[n]))
sm.scdset.save(mesh_output[n])
print "\tSaved tally {0} as {1}".format(tally_numbers[n], mesh_output[n])
print "\nStructured mesh tagging complete\n\n"
def test_vox_cum(self):
"""Verify gammas file for voxel sampling with cumulative bins"""
self.meshfile = meshfile_g
self.sm = ScdMesh.fromFile(self.meshfile)
write_gammas.gen_gammas_file_from_h5m(self.sm,
outfile,
cumulative=True)
self.compare_gammas(outfile, gammas7)
def test_uni_seq_bias(self):
"""Verify gammas file for uniform sampling with sequential bins and biasing"""
self.meshfile = meshfile_g
self.sm = ScdMesh.fromFile(self.meshfile)
write_gammas.gen_gammas_file_from_h5m(self.sm,
outfile,
sampling='u',
do_bias=True)
self.compare_gammas(outfile, gammas2)
def write_magic(flux_mesh_filename, ww_inp_mesh_filename, totals_bool, \
null_value, output_mesh, tolerance):
"""
This function takes the filename of the flux mesh and optional wieght window
mesh, as well necessary parameter, sends them to the magic funtion and
writes the resulting wieght window mesh.
Parameters
----------
flux_mesh_filename: ScdMesh file name.
A ScdMesh tagged with fluxes in the form X_group_YYY and or
X_group_total. Addition required tags are "particle" (1 for n, 2 for p)
and E_group_bounds (vector of energy upper bounds).
totals_bool : True or False
Determines whether magic will be applied to individual energy group
(False), or the total group (True)
null_value : float
The weight window lower bound value that is assigned to voxels where the
relative error on flux exceeds the tolerance. This is only done for
initial weight window lower bound generation, not subsequent iterations.
output_mesh : string
Filename of output mesh
tolerance: float
The maximum relative error allowable for the MAGIC algorithm to create
a weight window lower bound for for a given voxel for the intial weight
window lower bound generation, or overwrite preexisting weight window
lower bounds for subsequent iterations.
ww_inp_mesh_filename : ScdMesh file name
A preexisting weight window mesh to apply MAGIC to.
"""
flux_mesh = ScdMesh.fromFile(flux_mesh_filename)
if ww_inp_mesh_filename != None:
ww_inp_mesh = ScdMesh.fromFile(ww_inp_mesh_filename)
else:
ww_inp_mesh = None
ww_mesh = magic(flux_mesh, totals_bool, null_value, tolerance, ww_inp_mesh)
ww_mesh.scdset.save(output_mesh)
print "\tWrote WW mesh file '{0}'".format(output_mesh)
def write_magic(flux_mesh_filename, ww_inp_mesh_filename, totals_bool, \
null_value, output_mesh, tolerance):
"""
This function takes the filename of the flux mesh and optional wieght window
mesh, as well necessary parameter, sends them to the magic funtion and
writes the resulting wieght window mesh.
Parameters
----------
flux_mesh_filename: ScdMesh file name.
A ScdMesh tagged with fluxes in the form X_group_YYY and or
X_group_total. Addition required tags are "particle" (1 for n, 2 for p)
and E_group_bounds (vector of energy upper bounds).
totals_bool : True or False
Determines whether magic will be applied to individual energy group
(False), or the total group (True)
null_value : float
The weight window lower bound value that is assigned to voxels where the
relative error on flux exceeds the tolerance. This is only done for
initial weight window lower bound generation, not subsequent iterations.
output_mesh : string
Filename of output mesh
tolerance: float
The maximum relative error allowable for the MAGIC algorithm to create
a weight window lower bound for for a given voxel for the intial weight
window lower bound generation, or overwrite preexisting weight window
lower bounds for subsequent iterations.
ww_inp_mesh_filename : ScdMesh file name
A preexisting weight window mesh to apply MAGIC to.
"""
flux_mesh = ScdMesh.fromFile(flux_mesh_filename)
if ww_inp_mesh_filename != None:
ww_inp_mesh = ScdMesh.fromFile(ww_inp_mesh_filename)
else:
ww_inp_mesh = None
ww_mesh = magic(flux_mesh, totals_bool, null_value, tolerance, ww_inp_mesh)
ww_mesh.scdset.save(output_mesh)
print "\tWrote WW mesh file '{0}'".format(output_mesh)
def main():
"""Method defines an option parser and handles command-line
usage of this module.
Notes
-----
Requires command line arguments to be passed - otherwise prints help
information.
"""
usage = "usage: %prog [options] arg"
parser = OptionParser(usage)
# Input and mesh file names
parser.add_option("-p","--phtn",action="store",dest="phtnsrcfile", \
default=False,help="The photon source strengths are read from" \
"FILENAME.")
parser.add_option("-m","--mesh",action="store",dest="meshfile", \
default="",help="file to write source information to, or" \
" file name for saving a modified mesh.")
# Other options
parser.add_option("-i","--isotope",action="store",dest="isotope", \
default="TOTAL",help="The isotope string identifier or 'TOTAL'. "\
"Default: %default")
parser.add_option("-c","--coolingstep",action="store",dest="coolingstep", \
default=0,help="The cooling step number or string identifier. " \
"(0 is first cooling step) Default: %default")
parser.add_option("-r","--retag",action="store_true",dest="retag", \
default=False,help="Option enables retagging of .h5m meshes. " \
"Default: %default")
parser.add_option("-t","--totals",action="store_true",dest="totals", \
default=False,help="Option enables adding the total photon " \
"source strength for all energy groups as a tag for each voxel. " \
"Default: %default")
(options, args) = parser.parse_args()
# Open an ScdMesh and then call read_to_h5m
try:
mesh = ScdMesh.fromFile(options.meshfile)
except ScdMeshError:
mesh = iMesh.Mesh()
mesh.load(options.meshfile)
read_to_h5m( \
options.phtnsrcfile, mesh, options.isotope, \
options.coolingstep, options.retag, options.totals)
if isinstance(mesh, ScdMesh):
mesh.imesh.save(options.meshfile)
else:
mesh.save(options.meshfile)
return 1
def magic(flux_h5m, ww_mesh, total_bool, null_value, output, output_mesh, tolerance):
"""Runs magic.py from as a module
"""
flux_mesh = ScdMesh.fromFile(flux_h5m)
ww_mesh, e_groups = magic_wwinp(flux_mesh, ww_mesh, total_bool, null_value, tolerance)
if output_mesh != 'None':
ww_mesh.scdset.save(output_mesh)
write_wwinp(ww_mesh, e_groups, output)
def main( arguments = None ) :
#Instantiate option parser
parser = OptionParser\
(usage='%prog <meshtal_file> <normalization_factor> [options]')
parser.add_option('-o', dest='mesh_output', default=None,\
help = 'Name of mesh output file, default=%default')
parser.add_option('-n', dest='norm', default=None,
help = 'Normalization factor, default=%default')
parser.add_option('-m', dest='smesh_filename', default=None,
help='Preexisting mesh on which to tag fluxes')
(opts, args) = parser.parse_args(arguments)
#if len(args) != 2 :
# parser.error('\nNeed 1 argument: meshtal file')
print "\n\nRunning read_meshtal.py"
tally_numbers, tally_lines = find_tallies(args[1])
print 'Number of tallies found: {0}\nTally number(s): {1}'\
.format(len(tally_numbers), tally_numbers)
# Parse input from options parser, generate default values
if opts.norm :
norm = opts.norm.split(',')
else :
norm=[1]*len(tally_numbers)
if opts.mesh_output :
mesh_output = opts.mesh_output.split(',')
else:
mesh_output=[]
for n in range(0, len(tally_numbers)) :
if len(tally_numbers) == 1 :
mesh_output.append('flux_mesh.h5m')
else :
mesh_output.append('flux_mesh_tally{0}.h5m'.format(tally_numbers[n]))
# Convert each tally to h5m and name accordingly
for n in range(0,len(tally_numbers)) :
print "\nNow parsing tally number {0}".format(tally_numbers[n])
if opts.smesh_filename:
alt_sm = ScdMesh.fromFile(opts.smesh_filename)
sm = read_meshtal(args[1], tally_lines[n], float(norm[n]), smesh=alt_sm)
else:
sm = read_meshtal(args[1], tally_lines[n],float(norm[n]))
sm.scdset.save(mesh_output[n])
print "\tSaved tally {0} as {1}".format(tally_numbers[n], mesh_output[n])
print '\nStructured mesh tagging complete\n\n'
def test_magic_it_0_1_group():
thisdir = os.path.dirname(__file__)
flux_sm_filename = os.path.join(thisdir, "files_test_magic/iteration_0_flux_1_group.h5m")
flux_sm = ScdMesh.fromFile(flux_sm_filename)
expected_sm_filename = os.path.join(thisdir, "files_test_magic/iteration_0_magic_1_group.h5m")
expected_sm = ScdMesh.fromFile(expected_sm_filename)
totals_bool = False
null_value = 1e-3
tolerance = 0.2
written_sm = magic.magic(flux_sm, totals_bool, null_value, tolerance)
# verify weight window lower bounds are the same
for x in range(0, 3):
for y in range(0, 3):
for z in range(0, 3):
expected_voxel = expected_sm.getHex(x, y, z)
expected = expected_sm.imesh.getTagHandle("ww_n_group_001")[expected_voxel]
written_voxel = written_sm.getHex(x, y, z)
written = written_sm.imesh.getTagHandle("ww_n_group_001")[written_voxel]
assert_equal(written, expected)
def test_magic_it_0_1_group():
thisdir = os.path.dirname(__file__)
flux_sm_filename = os.path.join(thisdir, 'files_test_magic/iteration_0_flux_1_group.h5m')
flux_sm = ScdMesh.fromFile(flux_sm_filename)
expected_sm_filename = os.path.join(thisdir, 'files_test_magic/iteration_0_magic_1_group.h5m')
expected_sm = ScdMesh.fromFile(expected_sm_filename)
totals_bool = False
null_value = 1E-3
tolerance = 0.2
written_sm = magic.magic(flux_sm, totals_bool, null_value, tolerance)
#verify weight window lower bounds are the same
for x in range(0,3):
for y in range(0,3):
for z in range(0,3):
expected_voxel = expected_sm.getHex(x,y,z)
expected = expected_sm.imesh.getTagHandle('ww_n_group_001')[expected_voxel]
written_voxel = written_sm.getHex(x,y,z)
written = written_sm.imesh.getTagHandle('ww_n_group_001')[written_voxel]
assert_equal(written, expected)
def test_create_by_file(self):
filename = os.path.join(os.path.dirname(__file__), 'h5m_files/grid543.h5m')
sm = ScdMesh.fromFile(filename)
self.assertEqual( sm.dims, (1, 11, -5, 5, 14, -3) )
# This mesh is interesting because the i/j/k space is not numbered from zero
# Check that divisions are correct
self.assertEqual( sm.getDivisions('x'), range(1,6) )
self.assertEqual( sm.getDivisions('y'), [1.0, 5.0, 10.0, 15.0] )
self.assertEqual( sm.getDivisions('z'), [-10.0, 2.0, 12.0] )
# loading a test file without structured mesh metadata should raise an error
filename2 = os.path.join(os.path.dirname(__file__), 'files_scdmesh_test/test_matFracs.h5m')
self.assertRaises( ScdMeshError, ScdMesh.fromFile, filename2 )
def handle_meshtal(meshtal_file, gen_mmgrid, datafile, isscd=True):
"""Read MCNP meshtal file and tag mesh
Parameters
----------
mesh : ScdMesh or iMesh.Mesh()
Mesh object to be tagged.
gen_mmgrid : boolean
Whether to generate a new macromaterials grid
datafile : string
File/path to mesh file to be created/loaded/tagged.
isscd : boolean
If True, handle geometry as a structured mesh. Otherwise mesh is
assumed to be unstructured and unstructured mesh tally results are
assumed to exist on the mesh (Error raised if tag TALLY_TAG is missing).
"""
if not isscd: # is unstructured
mesh = iMesh.Mesh()
mesh.load(datafile)
try:
mesh.getTagHandle("TALLY_TAG")
except iBase.TagNotFoundError as e:
print "Missing tag 'TALLY_TAG' suggests that '{0}' is missing " \
"unstructured mesh tally information.".format(datafile)
raise e
return mesh
print "Loading mesh tally file `{0}'".format(meshtal_file)
tally_numbers, tally_lines = find_tallies(meshtal_file)
# If not regenerating the mmGrid info, attempt to load existing datafile
if gen_mmgrid == False:
print "Attempting to re-use existing ScdMesh file '{0}'".format(
datafile)
alt_sm = ScdMesh.fromFile(datafile) # Note: ray tracing is done later
try:
mesh = read_meshtal(meshtal_file, tally_lines[0], mesh=alt_sm)
except ScdMeshError:
print "ERROR:"
print "Existing mesh in '{0}' does not match mesh in '{1}'. " \
"Set the 'gen_mmgrid' option to True in your 'r2s.cfg' " \
"file.".format(datafile, meshtal_file)
else:
print "Creating ScdMesh file '{0}' from scratch.".format(datafile)
mesh = read_meshtal(meshtal_file, tally_lines[0])
return mesh
def handle_meshtal(meshtal_file, gen_mmgrid, datafile, isscd=True):
"""Read MCNP meshtal file and tag mesh
Parameters
----------
mesh : ScdMesh or iMesh.Mesh()
Mesh object to be tagged.
gen_mmgrid : boolean
Whether to generate a new macromaterials grid
datafile : string
File/path to mesh file to be created/loaded/tagged.
isscd : boolean
If True, handle geometry as a structured mesh. Otherwise mesh is
assumed to be unstructured and unstructured mesh tally results are
assumed to exist on the mesh (Error raised if tag TALLY_TAG is missing).
"""
if not isscd: # is unstructured
mesh = iMesh.Mesh()
mesh.load(datafile)
try:
mesh.getTagHandle("TALLY_TAG")
except iBase.TagNotFoundError as e:
print "Missing tag 'TALLY_TAG' suggests that '{0}' is missing " "unstructured mesh tally information.".format(
datafile
)
raise e
return mesh
print "Loading mesh tally file `{0}'".format(meshtal_file)
tally_numbers, tally_lines = find_tallies(meshtal_file)
# If not regenerating the mmGrid info, attempt to load existing datafile
if gen_mmgrid == False:
print "Attempting to re-use existing ScdMesh file '{0}'".format(datafile)
alt_sm = ScdMesh.fromFile(datafile) # Note: ray tracing is done later
try:
mesh = read_meshtal(meshtal_file, tally_lines[0], mesh=alt_sm)
except ScdMeshError:
print "ERROR:"
print "Existing mesh in '{0}' does not match mesh in '{1}'. " "Set the 'gen_mmgrid' option to True in your 'r2s.cfg' " "file.".format(
datafile, meshtal_file
)
else:
print "Creating ScdMesh file '{0}' from scratch.".format(datafile)
mesh = read_meshtal(meshtal_file, tally_lines[0])
return mesh
def main(arguments=None):
parser = OptionParser\
(usage='%prog structured_mesh x_value y_value z_value tag_name')
#parser.add_option('-o', dest='fluxin_name', default='ALARAflux.in',\
# help='Name of ALARA fluxin output file, default=%default')
(opts, args) = parser.parse_args(arguments)
if len(args) != 6:
parser.error\
( '\nNeed exactly 5 arguments: run with -h flag for usage' )
#Load Structured mesh from file
sm = ScdMesh.fromFile(args[1])
print_value(sm, int(args[2]), int(args[3]), int(args[4]), args[5])
def main():
"""Method defines an option parser and handles command-line
usage of this module.
Notes
-----
Requires command line arguments to be passed - otherwise prints help
information.
"""
usage = "Usage: %prog INPUTFILE [options]\n\n" \
"INPUTFILE is the MCNP or DAG-MCNP input deck that is to be " \
"modified. \nUse the -d option for DAG-MCNP files."
parser = OptionParser(usage)
# Output file name, and toggle for DAG-MCNP problems
parser.add_option("-o","--output",action="store",dest="outputfile", \
default="", help="Filename to write modified MCNP input to." \
" Default is to append input filename with '_p'.")
parser.add_option("-d","--dagmc",action="store_true",dest="dagmc", \
default=False, help="Add flag to parse file like a DAG-MCNP file " \
"(which has only title card and block 3 cards). Default: %default")
parser.add_option("-m","--mesh",action="store",dest="fmesh", \
default=None, help="Add meshtally (fmesh card), with mesh taken " \
"from a .h5m or .vtk file that is supplied with this option.")
(options, args) = parser.parse_args()
if len(args):
x = ModMCNPforPhotons(args[0], options.dagmc)
x.read()
x.convert()
if options.fmesh != None:
smesh = ScdMesh.fromFile(options.fmesh)
x.add_fmesh_from_scdmesh(smesh)
x.write_deck(options.outputfile)
else:
print "An input file must be specified as the first argument to use " \
"this script.\nSee the -h option for more information."
return 1
def main(arguments=None):
parser = OptionParser\
(usage='%prog structured_mesh x_value y_value z_value tag_name')
#parser.add_option('-o', dest='fluxin_name', default='ALARAflux.in',\
# help='Name of ALARA fluxin output file, default=%default')
(opts, args) = parser.parse_args( arguments )
if len(args) != 6 :
parser.error\
( '\nNeed exactly 5 arguments: run with -h flag for usage' )
#Load Structured mesh from file
sm=ScdMesh.fromFile(args[1])
print_value(sm, int(args[2]), int(args[3]), int(args[4]), args[5])
def main():
""" """
# Instatiate options parser
parser = OptionParser\
(usage='%prog <structured mesh> [options]')
parser.add_option('-b', action='store_true', dest='backward_bool',\
default=False, \
help='Print to ALARA fluxin in fluxes in decreasing energy. ' \
'Default=%default')
parser.add_option('-o', dest='fluxin_name', default='ALARAflux.in',\
help='Name of ALARA fluxin output file, default=%default')
(opts, args) = parser.parse_args()
if len(args) != 2:
parser.error\
( '\nNeed exactly 1 argument: structured mesh file' )
# Load Structured mesh from file
sm = ScdMesh.fromFile(args[1])
write_alara_fluxin( opts.fluxin_name, sm, opts.backward_bool )
def test_vox_seq(self):
"""Verify gammas file for voxel sampling with sequential bins"""
self.meshfile = meshfile_g
self.sm = ScdMesh.fromFile(self.meshfile)
write_gammas.gen_gammas_file_from_h5m(self.sm, outfile)
self.compare_gammas(outfile, gammas5)
def setUp(self):
os.system("cp " + meshfile_orig + " " + meshfile)
self.sm = ScdMesh.fromFile(meshfile)
def setUp(self):
self.sm = ScdMesh.fromFile(meshfile)
def test_uni_cum(self):
"""Verify gammas file for uniform sampling with cumulative bins"""
self.meshfile = meshfile_g
self.sm = ScdMesh.fromFile(self.meshfile)
write_gammas.gen_gammas_file_from_h5m(self.sm, outfile, sampling='u', cumulative=True)
self.compare_gammas(outfile, gammas3)
def handle_phtn_data(datafile, phtn_src, opt_isotope, opt_cooling, \
opt_sampling, opt_bias, opt_cumulative, cust_ergbins,
resample, uni_resamp_all, gammas="gammas"):
"""Loads phtn_src data, tags this to mesh, and generates 'gammas' file.
Parameters
----------
datafile : string
Path to structured mesh file (e.g. .h5m file)
phtn_src : string
Path to phtn_src file
opt_isotope : string
The isotope identifier as listed in phtn_src file
opt_cooling : int or string
The cooling step, either as a numeric index (from 0) or a string
identifier as listed in phtn_src file
opt_sampling : ['v', 'u']
Type of sampling to generate the 'gammas' file for; v=voxel; u=uniform
opt_bias : boolean
If true, look for bias values on the mesh and include them in 'gammas'
opt_cumulative : boolean
If true, write energy bins' relative probabilities cumulatively
cust_ergbins : boolean
If true, look for custom energy bins on the mesh and include them in
'gammas'
resample : boolean
If true, 'r' flag is added to gammas, and resampling of particles
starting in void regions of voxels is enabled.
uni_resamp_all : boolean
If true, 'a' flag is added to gammas, and particles starting in void
regions of voxels, during uniform sampling, are resampled over the
entire problem, rather than resampling just the voxel. This has the
potential to result in an unfair game.
gammas : string (optional)
File name for 'gammas' file. Defaults to 'gammas'.
Returns
-------
mesh : ScdMesh object or iMesh.Mesh object
MOAB mesh object
Notes
-----
Only creates gammas file if mesh is an ScdMesh.
"""
print "Loading step one data file '{0}'".format(datafile)
try:
mesh = ScdMesh.fromFile(datafile)
except ScdMeshError:
mesh = iMesh.Mesh()
mesh.load(datafile)
# Tagging mesh
print "Reading ALARA photon source '{0}'".format(phtn_src)
read_alara_phtn.read_to_h5m(phtn_src, mesh, isotope=opt_isotope, \
coolingstep=opt_cooling, retag=True, totals=True)
print "Saving photon source information to '{0}'".format(datafile)
if isinstance(mesh, ScdMesh):
mesh.imesh.save(datafile)
with open(phtn_src, 'r') as fr:
try:
coolingstepstring = read_alara_phtn.get_cooling_step_name( \
opt_cooling, fr)[0]
except ValueError:
coolingstepstring = opt_cooling
print "Writing gammas file"
write_gammas.gen_gammas_file_from_h5m(mesh, outfile=gammas, \
sampling=opt_sampling, do_bias=opt_bias, \
cumulative=opt_cumulative, cust_ergbins=cust_ergbins, \
resample=resample, uni_resamp_all=uni_resamp_all, \
coolingstep=coolingstepstring, isotope=opt_isotope)
else:
voxels = list(mesh.iterate(iBase.Type.region, iMesh.Topology.all))
write_gammas.calc_total_source_strength(mesh, voxels)
mesh.save(datafile)
print "\n"
return mesh
# Use default
param_list.append( param[1])
(gen_mmgrid, mmgrid_rays, opt_step2setup) = param_list
###########################
# Do step 1
print "Loading mesh tally file `{0}'".format(meshtal_file)
tally_numbers, tally_lines = find_tallies(meshtal_file)
# If not regenerating the mmGrid info, attempt to load existing datafile
if gen_mmgrid == False:
print "Attempting to re-use existing ScdMesh file '{0}'".format(datafile)
alt_sm = ScdMesh.fromFile(datafile)
try:
smesh = read_meshtal(meshtal_file, tally_lines[0], smesh=alt_sm)
except ScdMeshError:
print "ERROR:"
print "Existing mesh in '{0}' does not match mesh in '{1}'. Set the " \
"'gen_mmgrid' option to True in your 'r2s.cfg' file.".format( \
datafile, meshtal_file)
sys.exit()
else:
smesh = read_meshtal(meshtal_file, tally_lines[0])
print "Loading geometry file `{0}'".format(mcnp_geom)
mmgrid.load_geom(mcnp_geom)
# Do ray tracing to create macromaterials, if enabled.
def test_vox_seq_bias(self):
"""Verify gammas file for voxel sampling with sequential bins and biasing"""
self.meshfile = meshfile_g
self.sm = ScdMesh.fromFile(self.meshfile)
write_gammas.gen_gammas_file_from_h5m(self.sm, outfile, do_bias=True)
self.compare_gammas(outfile, gammas6)
def main():
# TODO: How to handle non-structured meshes from the command line...
mesh = ScdMesh.fromFile(sys.argv[1])
write_alara_geom("alara_geom", mesh)
def test_vow_cum_bias(self):
"""Verify gammas file for voxel sampling with cumulative bins and biasing"""
self.meshfile = meshfile_g
self.sm = ScdMesh.fromFile(self.meshfile)
write_gammas.gen_gammas_file_from_h5m(self.sm, outfile, do_bias=True, cumulative=True)
self.compare_gammas(outfile, gammas8)
def test_uni_seq(self):
"""Verify gammas file for uniform sampling with sequential bins"""
self.meshfile = meshfile_g
self.sm = ScdMesh.fromFile(self.meshfile)
write_gammas.gen_gammas_file_from_h5m(self.sm, outfile, sampling='u')
self.compare_gammas(outfile, gammas1)
def magic_wwinp(flux_mesh, ww_mesh='None', total_bool=False, null_value=0, tolerance=0.1):
"""This function reads in a flux mesh and a ww mesh as well as relevant paramters
then the magic method is applied and a newly tagged flux is returned.
"""
# find meshtal type
tag_names = []
for tag in flux_mesh.imesh.getAllTags(flux_mesh.getHex(0,0,0)):
tag_names.append(tag.name)
if 'n_group_001' in tag_names or 'n_group_total' in tag_names:
particle = 'n'
elif 'p_group_001' in tag_names or 'p_group_total' in tag_names:
particle = 'p'
else:
print >>sys.stderr, 'Tag X_group_YYY or X_group_total not found'
sys.exit(1)
# find number of e_groups
num_e_groups = find_num_e_groups(flux_mesh, particle)
if total_bool == False:
e_groups = ['{0:03d}'.format(x) for x in range(1, num_e_groups + 1)]
print "\tGenerating WW for {0} energy groups".format(num_e_groups)
else:
e_groups = ['total']
print "\tGenerating WW for Total energy group"
# find the max flux value for each e_group, store in vector
max_fluxes = find_max_fluxes(flux_mesh, particle, e_groups, total_bool)
if ww_mesh == 'None':
print "\tNo WW mesh file supplied; generating one based on meshtal"
ww_bool = False # mesh file NOT preexisting
# create a mesh with the same dimensions as flux_mesh
ww_mesh = ScdMesh(flux_mesh.getDivisions('x'),\
flux_mesh.getDivisions('y'),\
flux_mesh.getDivisions('z'))
# create a tag for each energy group
for e_group in e_groups:
group_name = "ww_{0}_group_{1}".format(particle, e_group)
ww_mesh.imesh.createTag(group_name, 1, float)
# create energy bounds
tag_e_groups = ww_mesh.imesh.createTag("e_groups", len(e_groups), float)
if e_groups != ['total']:
tag_e_groups[ww_mesh.imesh.rootSet] = \
flux_mesh.imesh.getTagHandle("e_groups")[flux_mesh.imesh.rootSet]
else:
tag_e_groups[ww_mesh.imesh.rootSet] = 1E36 # usual MCNP value
else:
ww_bool = True # mesh file preexisting
# make sure the supplied meshes have the same dimenstions
ww_mesh = ScdMesh.fromFile(ww_mesh)
try:
for i in ('x', 'y', 'z'):
flux_mesh.getDivisions(i) == ww_mesh.getDivisions(i)
except:
print >>sys.stderr, 'Mismatched dimensions on WWINP and flux meshes'
sys.exit(1)
print "\tSupplied meshes confirmed to have same dimensions"
# iterate through all voxels
flux_voxels = flux_mesh.iterateHex('xyz')
ww_voxels = ww_mesh.iterateHex('xyz')
for (flux_voxel, ww_voxel) in zip(flux_voxels, ww_voxels):
for i, e_group in enumerate(e_groups):
flux = flux_mesh.imesh.getTagHandle(\
'{0}_group_{1}'.format(particle, e_group))[flux_voxel]
error = flux_mesh.imesh.getTagHandle(\
'{0}_group_{1}_error'.format(particle, e_group))[flux_voxel]
if ((ww_bool == False and error != 0.0) \
or (0.0 < error and error < tolerance)):
if ww_bool == True:
if ww_mesh.imesh.getTagHandle('ww_{0}_group_{1}'\
.format(particle, e_group))[ww_voxel] != -1:
ww_mesh.imesh.getTagHandle('ww_{0}_group_{1}'\
.format(particle, e_group))[ww_voxel]\
= flux/(2*max_fluxes[i]) # apply magic method
else:
ww_mesh.imesh.getTagHandle(\
'ww_{0}_group_{1}'.format(particle, e_group))[ww_voxel]\
= flux/(2*max_fluxes[i]) # apply magic method
elif ww_bool == False and error == 0.0 :
ww_mesh.imesh.getTagHandle(\
'ww_{0}_group_{1}'.format(particle, e_group))[ww_voxel]\
= null_value
return ww_mesh, e_groups
def main():
mesh = ScdMesh.fromFile( sys.argv[1] )
write_alara_geom( 'alara_geom', mesh )
def setUp(self):
filename = os.path.join(thisdir, 'h5m_files/grid543.h5m')
self.sm = ScdMesh.fromFile(filename)
def setUp(self):
os.system("cp " + meshfile_orig + " " + meshfile)
self.sm = ScdMesh.fromFile(meshfile)
read_alara_phtn.read_to_h5m(inputfile, self.sm)
def setUp(self):
os.system("cp " + meshfile_orig + " " + meshfile)
self.sm = ScdMesh.fromFile(meshfile)
read_alara_phtn.read_to_h5m(inputfile, self.sm)
def main(arguments=None):
# Instantiate option parser
parser = OptionParser\
(usage='%prog <meshtal_file> <normalization_factor> [options]')
parser.add_option('-o', dest='mesh_output', default='flux_mesh.h5m',\
help = 'Name of mesh output file, default=%default.\
For meshtal files with multiple tallies,\
if the -o flag is used all tallies must be named,\
with file names seperated by commas and no spaces\
(e.g. "tally14.h5m,tally24.h5m,tally34.h5m")' )
parser.add_option('-n',
dest='norm',
default=None,
help='Normalization factor, default=%default,\
For meshtal files with multiple tallies, if the -n\
flag is used, a normalization factor must be\
specified for all tallies, seperated by commas but \
not spaces (eg. -n 1.1,2.2,3.3) ')
parser.add_option('-m',
dest='smesh_filename',
default=None,
help='Preexisting mesh on which to tag fluxes')
(opts, args) = parser.parse_args(arguments)
#if len(args) != 2 :
# parser.error('\nNeed 1 argument: meshtal file')
print "\n\nRunning read_meshtal.py"
tally_numbers, tally_lines = find_tallies(args[1])
print "Number of tallies found: {0}\nTally number(s): {1}" \
.format(len(tally_numbers), tally_numbers)
# Parse input from options parser, generate default values
if opts.norm:
norm = opts.norm.split(',')
else:
norm = [1] * len(tally_numbers)
if opts.mesh_output != 'flux_mesh.h5m':
mesh_output = opts.mesh_output.split(',')
else:
mesh_output = []
for n in range(0, len(tally_numbers)):
if len(tally_numbers) == 1:
mesh_output.append('flux_mesh.h5m')
else:
mesh_output.append('flux_mesh_tally{0}.h5m'.format(
tally_numbers[n]))
# Convert each tally to h5m and name accordingly
for n in range(0, len(tally_numbers)):
print "\nNow parsing tally number {0}".format(tally_numbers[n])
if opts.smesh_filename:
alt_sm = ScdMesh.fromFile(opts.smesh_filename)
sm = read_meshtal(args[1],
tally_lines[n],
float(norm[n]),
smesh=alt_sm)
else:
sm = read_meshtal(args[1], tally_lines[n], float(norm[n]))
sm.scdset.save(mesh_output[n])
print "\tSaved tally {0} as {1}".format(tally_numbers[n],
mesh_output[n])
print "\nStructured mesh tagging complete\n\n"
#####################################################################
# Look for and open configuration file for r2s workflow
cfgfile = 'r2s.cfg'
if len(sys.argv) > 1:
cfgfile = sys.argv[1]
config = ConfigParser.SafeConfigParser()
config.read(cfgfile)
# Required input file from config file
datafile = get_input_file(config, 'step1_datafile')
# Read in the mesh
smesh = ScdMesh.fromFile(datafile)
# Get the Tag object called PHTN_BIAS
try:
bias_tag = smesh.imesh.createTag("PHTN_BIAS",1,"d")
except iBase.TagAlreadyExistsError:
print "Tag already exists. Tags are being overwritten."
bias_tag = smesh.imesh.getTagHandle("PHTN_BIAS")
# Calculate the center of all voxels in the problem and store in a list
centers = calc_centers_list(smesh)
# EXAMPLE OF MATH FOR DISTANCE BASED BIASING:
# This for loop calculates and tags the bias values.
# In this example, based on the voxel's distance from the plane y == -20
# we assign a bias value between 1 and (maxBias+1).
def main():
# TODO: How to handle non-structured meshes from the command line...
mesh = ScdMesh.fromFile(sys.argv[1])
write_alara_geom("alara_geom", mesh)
def setUp(self):
os.system("cp " + meshfile_orig + " " + meshfile)
self.sm = ScdMesh.fromFile(meshfile)