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_large_iterator(self):
print "building large mesh"
big = ScdMesh(range(1,100), range(101,200), range(201,300))
print "iterating (1)"
for i in big.iterateHex():
pass
print "iterating (2)"
for i in big.iterateHex( 'yzx' ):
pass
def test_get_divs(self):
x = [1, 2.5, 4, 6.9]
y = [-12, -10, -.5]
z = [100, 200]
sm = ScdMesh( x, y, z )
self.assertEqual( sm.getDivisions('x'), x )
self.assertEqual( sm.getDivisions('y'), y )
self.assertEqual( sm.getDivisions('z'), z )
def setUp(self):
self.mesh = iMesh.Mesh()
self.sm = ScdMesh( range(10,15), # i = 0,1,2,3
range(21,25), # j = 0,1,2
range(31,34), # k = 0,1
self.mesh )
self.I = range(0,4)
self.J = range(0,3)
self.K = range(0,2)
def test_get_hex(self):
# mesh with valid i values 0-4, j values 0-3, k values 0-2
sm = ScdMesh( range(11,16), range(21,25), range(31,34) )
def check( e ):
self.assertTrue( isinstance(e, iBase.Entity) )
check(sm.getHex(0, 0, 0))
check(sm.getHex(1, 1, 1))
check(sm.getHex(3, 0, 0))
check(sm.getHex(3, 2, 1))
self.assertRaises(ScdMeshError, sm.getHex, -1,-1,-1)
self.assertRaises(ScdMeshError, sm.getHex, 4, 0, 0)
self.assertRaises(ScdMeshError, sm.getHex, 0, 3, 0)
self.assertRaises(ScdMeshError, sm.getHex, 0, 0, 2)
def test_get_vtx(self):
# mesh with valid i values 0-4, j values 0-3, k values 0-2
x_range = numpy.array(range(10,15),dtype=numpy.float64)
y_range = numpy.array(range(21,24),dtype=numpy.float64)
z_range = numpy.array(range(31,33),dtype=numpy.float64)
sm = ScdMesh( x_range, y_range, z_range, self.mesh )
for i,x in enumerate(x_range):
for j,y in enumerate(y_range):
for k,z in enumerate(z_range):
vtx = sm.getVtx(i,j,k)
vcoord = self.mesh.getVtxCoords( vtx )
self.assertTrue( all( vcoord == [x,y,z]) )
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):
#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():
"""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 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():
"""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_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 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 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 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():
"""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 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 create_ww_mesh(flux_mesh, e_group_names):
"""
This function reads a flux mesh and returns a weight window mesh tagged with
all zeros in every energy group. This is used for the intial MAGIC weight
window generation, for which no preexisting weight window mesh is given.
Parameters
----------
flux_mesh : ScdMesh
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).
e_group_names : vector of energy names
In the form X_group_YYY or X_group_total.
"""
ww_mesh = ScdMesh(flux_mesh.getDivisions('x'),\
flux_mesh.getDivisions('y'),\
flux_mesh.getDivisions('z'))
# create ww tags
for e_group_name in e_group_names:
ww_tag = ww_mesh.imesh.createTag('ww_{0}'.format(e_group_name), 1,
float)
for voxel in ww_mesh.iterateHex('xyz'):
ww_tag[voxel] = 0
# create e_upper_bound tags
e_upper_bounds = \
flux_mesh.imesh.getTagHandle("E_upper_bounds")[flux_mesh.imesh.rootSet]
if isinstance(e_upper_bounds, float):
e_upper_bounds = [e_upper_bounds]
e_tag = ww_mesh.imesh.createTag("E_upper_bounds", len(e_upper_bounds),
float)
e_tag[ww_mesh.imesh.rootSet] = \
flux_mesh.imesh.getTagHandle("E_upper_bounds")[flux_mesh.imesh.rootSet]
# create particle tag
particle = flux_mesh.imesh.getTagHandle("particle")[
flux_mesh.imesh.rootSet]
particle_tag = ww_mesh.imesh.createTag("particle", 1, int)
particle_tag[ww_mesh.imesh.rootSet] = particle
return ww_mesh
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 cartesian(wwinp):
"""This function reads in a Cartesian WWINP file and returns a structured
mesh tagged with weight window lower bounds.
Parameters
----------
wwinp : file name
The weight window input file to create a mesh from.
"""
print "Parsing Cartesian WWINP"
particle_identifier = linecache.getline(wwinp, 1).split()[2]
if particle_identifier == '1':
particle = 'n'
elif particle_identifier =='2':
particle = 'p'
# collect easy to parse energy group and mesh sized info
num_e_bins = int(linecache.getline(wwinp, 2).split()[-1])
# total number of fine mesh points
nfx, nfy, nfz = \
[int(float(x)) for x in linecache.getline(wwinp, 3).split()[0:3]]
x0, y0, z0 = [float(x) for x in linecache.getline(wwinp, 3).split()[3:6]]
# number of course points
ncx, ncy, ncz = \
[int(float(x)) for x in linecache.getline(wwinp, 4).split()[0:3]]
# get the x, y, and z bounds
x_bounds, x_last_line = block_2_bounds(wwinp, 5, ncx)
y_bounds, y_last_line = block_2_bounds(wwinp, x_last_line + 1, ncy)
z_bounds, z_last_line = block_2_bounds(wwinp, y_last_line + 1, ncz)
# create structured mesh these bounds
sm = ScdMesh(x_bounds, y_bounds, z_bounds)
# Find the first line of WW values by counting through the e_bin values
# until the expected number of e_bins is reached
# Then create a root level tag with energy the energy bounds.
e_upper_bounds = []
line_num = z_last_line + 1
while len(e_upper_bounds) < num_e_bins:
e_upper_bounds += \
[float(x) for x in linecache.getline(wwinp, line_num).split()]
line_num += 1
ww_first_line = line_num
# tag structured mesh with WW values
tag_mesh(sm, wwinp, ww_first_line, num_e_bins, nfx*nfy*nfz, particle)
# tag root level of sm with energy bounds
tag_e_bin = sm.imesh.createTag("E_upper_bounds", len(e_upper_bounds), float)
tag_e_bin[sm.imesh.rootSet] = e_upper_bounds
return sm
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 create_ww_mesh(flux_mesh, e_group_names):
"""
This function reads a flux mesh and returns a weight window mesh tagged with
all zeros in every energy group. This is used for the intial MAGIC weight
window generation, for which no preexisting weight window mesh is given.
Parameters
----------
flux_mesh : ScdMesh
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).
e_group_names : vector of energy names
In the form X_group_YYY or X_group_total.
"""
ww_mesh = ScdMesh(flux_mesh.getDivisions('x'),\
flux_mesh.getDivisions('y'),\
flux_mesh.getDivisions('z'))
# create ww tags
for e_group_name in e_group_names:
ww_tag = ww_mesh.imesh.createTag('ww_{0}'.format(e_group_name), 1, float)
for voxel in ww_mesh.iterateHex('xyz'):
ww_tag[voxel] = 0
# create e_upper_bound tags
e_upper_bounds = \
flux_mesh.imesh.getTagHandle("E_upper_bounds")[flux_mesh.imesh.rootSet]
if isinstance(e_upper_bounds, float):
e_upper_bounds = [e_upper_bounds]
e_tag = ww_mesh.imesh.createTag("E_upper_bounds", len(e_upper_bounds), float)
e_tag[ww_mesh.imesh.rootSet] = \
flux_mesh.imesh.getTagHandle("E_upper_bounds")[flux_mesh.imesh.rootSet]
# create particle tag
particle = flux_mesh.imesh.getTagHandle("particle")[flux_mesh.imesh.rootSet]
particle_tag = ww_mesh.imesh.createTag("particle", 1, int)
particle_tag[ww_mesh.imesh.rootSet] = particle
return ww_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 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_unequal_grid_size(self):
"""Test creating an mmgrid on a mesh with uneven grid spacing"""
grid_side = [-3, 0, .1, .2, 3]
sm = ScdMesh(*([grid_side] * 3))
grid = mmgrid.mmGrid(sm)
grid.generate(5) #, True)
for ijk, x in numpy.ndenumerate(grid.grid):
self.assertAlmostEqual(sum(x['mats']),
1.0,
msg='Normality at ijk={0}:\n'
' sum({1}) = {2} != 1.0'.format(
ijk, x['mats'], sum(x['mats'])))
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_mmgrid_generate(self):
grid_side = [-5, -3.75, -2.5, -1.25, 0, 1.25, 2.5, 3.75, 5]
sm = ScdMesh(*([grid_side] * 3))
grid = mmgrid.mmGrid(sm)
grid.generate(2, True)
for ijk, x in numpy.ndenumerate(grid.grid):
self.assertAlmostEqual(sum(x['mats']),
1.0,
msg='Normality at ijk={0}:\n'
' sum({1}) = {2} != 1.0'.format(
ijk, x['mats'], sum(x['mats'])))
grid.create_tags()
def test_rayframes(self):
# a mesh with divisions at -1, 0, and 1 for all three dimensions
sm = ScdMesh(*([(-1, 0, 1)] * 3))
mg = mmgrid.mmGrid(sm)
squares = [(-1, 0, -1, 0), (-1, 0, 0, 1), (0, 1, -1, 0), (0, 1, 0, 1)]
ijks = [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1]]
for (ijk, ab), ab_test, ijk_test in itertools.izip_longest(
mg._rayframe('x'), squares, ijks):
self.assertEqual(ab, ab_test)
self.assertEqual(ijk, ijk_test)
def test_hex_volume(self):
sm = ScdMesh( [0,1,3], [-3,-2,0], [12,13,15] )
self.assertEqual( sm.getHexVolume(0,0,0), 1 )
self.assertEqual( sm.getHexVolume(1,0,0), 2 )
self.assertEqual( sm.getHexVolume(0,1,0), 2 )
self.assertEqual( sm.getHexVolume(1,1,0), 4 )
self.assertEqual( sm.getHexVolume(1,1,1), 8 )
ijk_all = itertools.product(*([[0,1]]*3))
for V, ijk in itertools.izip_longest(sm.iterateHexVolumes(), ijk_all):
self.assertEqual( V, sm.getHexVolume(*ijk) )
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(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():
""" """
# 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 )
class ScdMeshIterateTest(unittest.TestCase):
def setUp(self):
self.mesh = iMesh.Mesh()
self.sm = ScdMesh( range(10,15), # i = 0,1,2,3
range(21,25), # j = 0,1,2
range(31,34), # k = 0,1
self.mesh )
self.I = range(0,4)
self.J = range(0,3)
self.K = range(0,2)
def test_bad_iterates(self):
self.assertRaises( ScdMeshError, self.sm.iterateHex, 'abc' )
self.assertRaises( TypeError, self.sm.iterateHex, 12 )
self.assertRaises( ScdMeshError, self.sm.iterateHex, 'xxyz' )
self.assertRaises( ScdMeshError, self.sm.iterateHex, 'yyx' )
self.assertRaises( ScdMeshError, self.sm.iterateHex, 'xyz',z=[0,1,2] )
def test_iterate_3d(self):
# use izip_longest in the lockstep iterations below; this will catch any
# situations where one iterator turns out to be longer than expected.
izip = itertools.izip_longest
it = self.sm.scdset.iterate( iBase.Type.region,
iMesh.Topology.hexahedron )
print "testing zyx"
# Test the zyx order, which is default; it should be equivalent
# to the standard imesh iterator
for it_x, sm_x in izip( it, self.sm.iterateHex() ):
self.assertEqual( it_x, sm_x )
print "testing xyz"
all_indices_zyx = itertools.product( self.I, self.J, self.K )
# Test the xyz order, the default from original mmGridGen
for ijk_index, sm_x in izip( all_indices_zyx,
self.sm.iterateHex('xyz') ):
self.assertEqual( self.sm.getHex(*ijk_index), sm_x )
def tuple_sort( collection, indices ):
# sorting function for order test
def t( tup ):
# sort this 3-tuple according to the order of x, y, and z in indices
return ( tup['xyz'.find(indices[0])]*100 +
tup['xyz'.find(indices[1])]*10 +
tup['xyz'.find(indices[2])] )
return sorted( collection, key = t )
def test_order( order, *args, **kw ):
print 'testing',order
all_indices = itertools.product(*args)
for ijk_index, sm_x in izip( tuple_sort(all_indices, order),
self.sm.iterateHex(order,**kw) ):
self.assertEqual(self.sm.getHex(*ijk_index), sm_x)
test_order( 'yxz', self.I, self.J, self.K )
test_order( 'yzx', self.I, self.J, self.K )
test_order( 'xzy', self.I, self.J, self.K )
test_order( 'zxy', self.I, self.J, self.K )
# Specify z=[1] to iterator
test_order( 'xyz', self.I, self.J, [1], z=[1] )
# Specify y=2 to iterator
test_order( 'zyx', self.I, [2], self.K, y=2 )
# specify x and y both to iterator
test_order( 'yzx', [1,2,3],self.J[:-1], self.K, y=self.J[:-1], x=[1,2,3] )
def test_iterate_2d(self):
def test_order( iter1, iter2 ):
for i1, i2 in itertools.izip_longest( iter1, iter2 ):
self.assertEqual( i1, i2 )
test_order( self.sm.iterateHex('yx'), self.sm.iterateHex('zyx', z=[0] ) )
test_order( self.sm.iterateHex('yx',z=1), self.sm.iterateHex('zyx',z=[1]) )
test_order( self.sm.iterateHex('yx',z=1), self.sm.iterateHex('yzx',z=[1]) )
test_order( self.sm.iterateHex('zy',x=[3]), self.sm.iterateHex('zxy',x=3) )
# Cannot iterate over multiple z's without specifing z order
self.assertRaises( ScdMeshError, self.sm.iterateHex, 'yx', z=[0,1] )
def test_iterate_1d(self):
def test_equal( ijk_list, miter ):
for ijk, i in itertools.izip_longest( ijk_list, miter ):
self.assertEqual( self.sm.getHex(*ijk), i )
test_equal( [[0,0,0],[0,0,1]],
self.sm.iterateHex('z') )
test_equal( [[0,1,1],[0,2,1]],
self.sm.iterateHex('y', y=[1,2], z=1) )
test_equal( [[2,0,0],[2,1,0],[2,2,0]],
self.sm.iterateHex('y', x=2) )
test_equal( [[0,0,0],[1,0,0],[2,0,0]],
self.sm.iterateHex('x', x=[0,1,2]) )
def test_vtx_iterator(self):
#use vanilla izip as we'll test using non-equal-length iterators
izip = itertools.izip
sm = self.sm
it = sm.scdset.iterate(iBase.Type.vertex, iMesh.Topology.point)
# test the default order
for (it_x, sm_x) in itertools.izip_longest( it, sm.iterateVtx('zyx') ):
self.assertEqual(it_x,sm_x)
# Do the same again, but use an arbitrary kwarg to iterateVtx to prevent optimization from kicking in
it.reset()
for (it_x, sm_x) in itertools.izip_longest( it, sm.iterateVtx('zyx', no_opt=True) ):
self.assertEqual(it_x,sm_x)
it.reset()
for (it_x, sm_x) in izip( it, sm.iterateVtx('yx',z=sm.dims[2])):
self.assertEqual(it_x,sm_x)
it.reset()
for (it_x, sm_x) in izip( it, sm.iterateVtx('x')):
self.assertEqual(it_x,sm_x)
def setUp(self):
self.sm = ScdMesh.fromFile(meshfile)
def test_create_by_set(self):
a = self.mesh.createStructuredMesh( [0,0,0,1,1,1],
i=[1,2], j=[1,2], k=[1,2],
create_set=True )
sm = ScdMesh.fromEntSet( self.mesh, a )
self.assertEqual( sm.dims, (0,0,0,1,1,1) )
def test_create(self):
sm = ScdMesh( range(1,5), range(1,4), range(1,3), self.mesh )
self.assertEqual( sm.dims, (0,0,0,3,2,1) )
def test_mmgrid_create(self):
sm = ScdMesh(*([(-1, 0, 1)] * 3))
grid = mmgrid.mmGrid(sm)
self.assertEqual(grid.grid.shape, (2, 2, 2))
self.assertEqual(grid.grid[0, 0, 0]['mats'].shape, (3, ))
self.assertEqual(grid.grid[0, 0, 0]['errs'].shape, (3, ))
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)
