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 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 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
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 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
