def test_calc_surfs_per_vol_vol():
"""Tests part of the calc_surfs_per_vol function"""
three_vols = df.DagmcFile(test_env['three_vols'])
vol = three_vols.entityset_ranges['volumes'][0]
three_vols_query = dq.DagmcQuery(three_vols, vol)
three_vols_query.calc_surfs_per_vol()
assert(sorted(three_vols_query._vol_data['surf_per_vol']) == [6])
def test_get_meshset_by_id():
"""
Tests the get_meshset_by_id function given valid dim and id
"""
three_vols = df.DagmcFile(test_env['single_cube'])
test_pass = np.full(3, False)
# get volume 0
exp = three_vols._my_moab_core.get_entities_by_type_and_tag(
three_vols.root_set, types.MBENTITYSET,
three_vols.dagmc_tags['geom_dim'], [3])[0]
obs = three_vols.get_meshset_by_id('volumes', ids=[1])
if obs == exp:
test_pass[0] = True
obs_singular = three_vols.get_meshset_by_id('volume', ids=[1])
obs_upper = three_vols.get_meshset_by_id('Volumes', ids=[1])
obs_integer = three_vols.get_meshset_by_id(3, ids=[1])
if obs == obs_singular == obs_upper == obs_integer:
test_pass[1] = True
# get volumes 0, 1
exp = list(
three_vols._my_moab_core.get_entities_by_type_and_tag(
three_vols.root_set, types.MBENTITYSET,
three_vols.dagmc_tags['geom_dim'], [3])[0:2])
obs = three_vols.get_meshset_by_id('volumes', ids=[1, 2])
if obs == exp:
test_pass[2] = True
assert (all(test_pass))
def test_get_entities_rootset():
"""Tests the get_entities function for rootset
"""
three_vols = df.DagmcFile(test_env['three_vols'])
three_vols_query = dq.DagmcQuery(three_vols, three_vols.root_set)
exp = list(three_vols.entityset_ranges['surfaces'])
assert(three_vols_query.meshset_lst == exp)
def test_calc_tris_per_surf_vol():
"""Tests part of the calc_tris_per_surf function"""
three_vols = df.DagmcFile(test_env['three_vols'])
vol = three_vols.entityset_ranges['volumes'][0]
three_vols_query = dq.DagmcQuery(three_vols, vol)
three_vols_query.calc_tris_per_surf()
assert(sorted(three_vols_query._surf_data['tri_per_surf']) == list(np.full(6,2)))
def test_calc_tris_per_vert_surf():
"""Tests the calc_tris_per_vert function for surface meshset
"""
three_vols = df.DagmcFile(test_env['three_vols'])
surf = three_vols.entityset_ranges['surfaces'][0]
three_vols_query = dq.DagmcQuery(three_vols, surf)
three_vols_query.calc_tris_per_vert()
assert(sorted(three_vols_query._vert_data['tri_per_vert']) == [4, 4, 5, 5])
def test_calc_tris_per_vert_vol():
"""Tests part of the calc_tris_per_vert function"""
three_vols = df.DagmcFile(test_env['three_vols'])
vol = three_vols.entityset_ranges['volumes'][0]
three_vols_query = dq.DagmcQuery(three_vols, vol)
three_vols_query.calc_tris_per_vert()
assert(sorted(three_vols_query._vert_data['tri_per_vert']) == [
4, 4, 4, 4, 5, 5, 5, 5])
def test_get_entities_vol():
"""Tests the get_entities function for volume meshset
"""
three_vols = df.DagmcFile(test_env['three_vols'])
vol = three_vols.entityset_ranges['volumes'][0]
three_vols_query = dq.DagmcQuery(three_vols, vol)
exp = list(three_vols._my_moab_core.get_child_meshsets(vol))
assert(three_vols_query.meshset_lst == exp)
def test_get_entities_surf():
"""Tests the get_entities function for surface meshset
"""
three_vols = df.DagmcFile(test_env['three_vols'])
surf = three_vols.entityset_ranges['surfaces'][0]
three_vols_query = dq.DagmcQuery(three_vols, surf)
exp = [surf]
assert(three_vols_query.meshset_lst == exp)
def test_get_tris_rootset():
"""Tests the tris variable given the rootset
"""
three_vols = df.DagmcFile(test_env['three_vols'])
three_vols_query = dq.DagmcQuery(three_vols, three_vols.root_set)
obs_tris = three_vols_query.tris
exp_tris = three_vols._my_moab_core.get_entities_by_type(
three_vols.root_set, types.MBTRI)
assert(sorted(obs_tris) == sorted(exp_tris))
def test_calc_area_triangle_vol():
"""Tests part of the calc_area_triangle function
"""
three_vols = df.DagmcFile(test_env['three_vols'])
vol = three_vols.entityset_ranges['volumes'][0]
three_vols_query = dq.DagmcQuery(three_vols, vol)
three_vols_query.calc_area_triangle()
np.testing.assert_almost_equal(
list(three_vols_query._tri_data['area']), list(np.full(12, 50)))
def test_coarseness():
"""Tests the calc coarseness function
"""
three_vols = df.DagmcFile(test_env['three_vols'])
vol = three_vols.entityset_ranges['volumes'][0]
three_vols_query = dq.DagmcQuery(three_vols, vol)
three_vols_query.calc_coarseness()
np.testing.assert_almost_equal(
list(three_vols_query._surf_data['coarseness']), list(np.full(6, 0.02)))
def test_set_dagmc_tags():
"""
Tests different aspects of the set_dagmc_tags function
"""
single_cube = df.DagmcFile(test_env['single_cube'])
assert (len(single_cube.dagmc_tags) == 3)
assert (single_cube.dagmc_tags['category'])
assert (single_cube.dagmc_tags['geom_dim'])
assert (single_cube.dagmc_tags['global_id'])
def test_get_entities_vol_and_surf():
"""Tests the get_entities function for a list of volume and surface meshsets
"""
three_vols = df.DagmcFile(test_env['three_vols'])
surf = three_vols.entityset_ranges['surfaces'][7]
vol = three_vols.entityset_ranges['volumes'][0]
three_vols_query = dq.DagmcQuery(three_vols, [surf, vol])
exp = list(list(three_vols._my_moab_core.get_child_meshsets(vol)) + [surf])
assert(three_vols_query.meshset_lst == exp)
def test_get_tris_surf():
"""Tests the tris variable for surface meshset
"""
three_vols = df.DagmcFile(test_env['three_vols'])
surf = three_vols.entityset_ranges['surfaces'][0]
three_vols_query = dq.DagmcQuery(three_vols, surf)
obs_tris = three_vols_query.tris
exp_tris = three_vols._my_moab_core.get_entities_by_type(
surf, types.MBTRI)
assert(sorted(obs_tris) == sorted(exp_tris))
def test_calc_triangle_aspect_ratio_vol():
"""Tests part of the calc_triangle_aspect_ratio function
"""
three_vols = df.DagmcFile(test_env['three_vols'])
vol = three_vols.entityset_ranges['volumes'][0]
three_vols_query = dq.DagmcQuery(three_vols, vol)
three_vols_query.calc_triangle_aspect_ratio()
exp = (10*10*10*np.sqrt(2))/(8*5*np.sqrt(2)*5*np.sqrt(2)*(10-5*np.sqrt(2)))
np.testing.assert_almost_equal(
list(three_vols_query._tri_data['aspect_ratio']), list(np.full(12, exp)))
def test_get_meshset_by_id_empty_id():
"""
Tests the get_meshset_by_id function given no id
"""
three_vols = df.DagmcFile(test_env['three_vols'])
exp = list(
three_vols._my_moab_core.get_entities_by_type_and_tag(
three_vols.root_set, types.MBENTITYSET,
three_vols.dagmc_tags['geom_dim'], [3]))
# When no id is passed in, get_meshset_by_id() function should return all the meshsets
# of the given dimension.
obs = three_vols.get_meshset_by_id('volumes', ids=[])
assert (obs == exp)
def test_rationalize_meshset_rootset_in_list():
"""Tests the rationalize_meshset function for a list containing rootset
"""
test_pass = np.full(2, False)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
three_vols = df.DagmcFile(test_env['three_vols'])
vert = three_vols.entityset_ranges['nodes'][0]
three_vols_query = dq.DagmcQuery(three_vols, [three_vols.root_set, vert])
exp = list(three_vols.entityset_ranges['surfaces'])
if len(w) == 0:
test_pass[0] = True
test_pass[1] = (three_vols_query.meshset_lst == exp)
assert(all(test_pass))
def test_update_tri_data():
"""Tests the upadte_tri_data function
"""
three_vols = df.DagmcFile(test_env['three_vols'])
surf = three_vols.entityset_ranges['surfaces'][0]
three_vols_query = dq.DagmcQuery(three_vols, surf)
three_vols_query.calc_triangle_aspect_ratio()
exp_tar = (10*10*10*np.sqrt(2))/(8*5*np.sqrt(2)
* 5*np.sqrt(2)*(10-5*np.sqrt(2)))
np.testing.assert_almost_equal(
list(three_vols_query._tri_data['aspect_ratio']), list(np.full(2, exp_tar)))
three_vols_query.calc_area_triangle()
np.testing.assert_almost_equal(
list(three_vols_query._tri_data['area']), list(np.full(2, 50)))
def test_set_entityset_ranges():
"""
Tests different aspects of the set_entityset_ranges function
"""
single_cube = df.DagmcFile(test_env['single_cube'])
test_pass = np.full(len(single_cube.entityset_types), False)
for dimension, set_type in single_cube.entityset_types.items():
type_range = list(
single_cube._my_moab_core.get_entities_by_type_and_tag(
single_cube.root_set, types.MBENTITYSET,
single_cube.dagmc_tags['geom_dim'], [dimension]))
test_pass[dimension] = (
type_range == single_cube.entityset_ranges[set_type])
assert (all(test_pass))
def test_set_dimension_meshset():
"""
Tests different aspects of the set_dimension_meshset function
"""
test_pass = np.full(2, False)
single_cube = df.DagmcFile(test_env['single_cube'])
mb_entityset = single_cube._my_moab_core.get_entities_by_type(
single_cube.root_set, types.MBENTITYSET)
dim_list = ['nodes', 'curves', 'surfaces', 'volumes']
test_pass[0] = (sorted(single_cube.dim_dict.keys()) == sorted(dim_list))
# dimension meshsets are the last len(entityset_ranges) elements in mb_entityset
num_dim_ms = len(single_cube.entityset_ranges)
test_pass[1] = (sorted(single_cube.dim_dict.values()) == list(
mb_entityset[-num_dim_ms:]))
assert (all(test_pass))
def test_get_tris_vol():
"""Tests the tris variable for volume meshset
"""
three_vols = df.DagmcFile(test_env['three_vols'])
vol = three_vols.entityset_ranges['volumes'][0]
three_vols_query = dq.DagmcQuery(three_vols, vol)
obs_tris = three_vols_query.tris
exp_tris = []
meshset_lst = []
surfs = three_vols._my_moab_core.get_child_meshsets(vol)
meshset_lst.extend(surfs)
for item in meshset_lst:
exp_tris.extend(
three_vols._my_moab_core.get_entities_by_type(item, types.MBTRI))
assert(sorted(obs_tris) == sorted(exp_tris))
def test_duplicate_calc(function, message):
"""Tests the case where calc_tris_per_vert() is called on the same meshset for multiple times
"""
test_pass = np.full(2, False)
three_vols = df.DagmcFile(test_env['three_vols'])
surf = three_vols.entityset_ranges['surfaces'][0]
three_vols_query = dq.DagmcQuery(three_vols, surf)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
eval('three_vols_query.' + function)
eval('three_vols_query.' + function)
if len(w) == 1:
test_pass[0] = True
if message in str(w[-1].message):
test_pass[1] = True
assert(all(test_pass))
def test_pandas_data_frame():
"""Tests the initialization of pandas data frames
"""
single_cube = df.DagmcFile(test_env['single_cube'])
single_cube_query = dq.DagmcQuery(single_cube)
exp_vert_data = pd.DataFrame()
assert(single_cube_query._vert_data.equals(exp_vert_data))
exp_tri_data = pd.DataFrame()
assert(single_cube_query._tri_data.equals(exp_tri_data))
exp_surf_data = pd.DataFrame()
assert(single_cube_query._surf_data.equals(exp_surf_data))
exp_vol_data = pd.DataFrame()
assert(single_cube_query._vol_data.equals(exp_vol_data))
def test_get_meshset_by_id_invalid_dim():
"""
Tests the get_meshset_by_id function given invalid dim
"""
three_vols = df.DagmcFile(test_env['three_vols'])
test_pass = np.full(3, False)
exp = []
with warnings.catch_warnings(record=True) as w:
obs = three_vols.get_meshset_by_id('vertices', ids=[])
warnings.simplefilter('always')
if obs == exp:
test_pass[0] = True
if len(w) == 1:
test_pass[1] = True
if 'Invalid dim!' in str(w[-1].message):
test_pass[2] = True
assert (all(test_pass))
def test_set_native_ranges():
"""Tests set_native_ranges
"""
single_cube = df.DagmcFile(test_env['single_cube'])
test_pass = np.full(len(single_cube.entity_types), False)
for i, native_range_type in enumerate(single_cube.entity_types):
entity_range = single_cube._my_moab_core.get_entities_by_type(
single_cube.root_set, native_range_type)
if native_range_type == types.MBENTITYSET:
# dimension meshsets are of type MBENTITYSE but not in native_ranges
num_dim_ms = len(single_cube.entityset_ranges)
test_pass[i] = (entity_range[:-num_dim_ms] ==
single_cube.native_ranges[native_range_type])
else:
test_pass[i] = (
entity_range == single_cube.native_ranges[native_range_type])
assert (all(test_pass))
def test_calc_surfs_per_vol_no_vol_meshset():
"""Tests the calc_surfs_per_vol function when no volume is given in the meshset:
"""
test_pass = np.full(3, False)
three_vols = df.DagmcFile(test_env['three_vols'])
surf = three_vols.entityset_ranges['surfaces'][0]
three_vols_query = dq.DagmcQuery(three_vols, surf)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
three_vols_query.calc_surfs_per_vol()
if len(w) == 1:
test_pass[0] = True
if 'Volume list is empty.' in str(w[0].message):
test_pass[1] = True
if len(three_vols_query._vol_data) == 0:
test_pass[2] = True
assert(all(test_pass))
def test_roughness():
"""Tests the calc roughness function, __calc_average_roughness() function
and __calc_tri_roughness() function.
"""
test_pass = np.full(3, False)
pyramid = df.DagmcFile(test_env['pyramid'])
pyramid_query = dq.DagmcQuery(pyramid)
pyramid_query.calc_roughness()
gc_top = 2.0*np.pi-4*np.pi/3.0
gc_bottom = 2.0*np.pi-2*np.pi/3.0-np.pi/2.0
d_bottom = [1.0/np.tan(np.pi/3.0),
0.5*(1.0/np.tan(np.pi/3.0)+1.0/np.tan(np.pi/4.0)), 0]
lr_bottom = []
lr_top = np.abs(gc_top - gc_bottom)
lr_bottom.append(np.abs(gc_bottom - \
(d_bottom[0]*gc_top+2*d_bottom[1]*gc_bottom) \
/(d_bottom[0]+2*d_bottom[1])))
lr_bottom.append(np.abs(gc_bottom - \
(d_bottom[0]*gc_top+2*d_bottom[1]*gc_bottom+d_bottom[2]*gc_bottom) \
/(d_bottom[0]+2*d_bottom[1]+d_bottom[2])))
exp = [lr_bottom[0],lr_bottom[0],lr_bottom[1],lr_bottom[1],lr_top]
obs = sorted(list(pyramid_query._vert_data['roughness']))
test_pass[0] = np.allclose(obs,exp)
# test the __calc_average_roughness function
side_length = 5.0
s_top = 4*(np.sqrt(3)/4*side_length**2)/3.0
s_bottom = [(side_length**2/2.0+2*(np.sqrt(3)/4*side_length**2))/3.0,
(side_length**2+2*(np.sqrt(3)/4*side_length**2))/3.0]
num = lr_top*s_top+ \
2*lr_bottom[0]*s_bottom[0] + \
2*lr_bottom[1]*s_bottom[1]
denom = s_top+sum(s_bottom)*2
exp = num/denom
obs = pyramid_query._global_averages['roughness_ave']
test_pass[1] = np.allclose([obs],[exp])
#test the __calc_tri_roughness function
tri_roughness = [(lr_bottom[0]+lr_bottom[1]+lr_top)/3.0, (lr_bottom[0]*2+lr_bottom[1])/3.0]
exp = [tri_roughness[0]] * 4 + [tri_roughness[1]] * 2
obs = pyramid_query._tri_data['roughness']
test_pass[2] = np.allclose(sorted(obs), sorted(exp))
assert(all(test_pass))
def test_get_meshset_by_id_out_of_range_dim():
"""
Tests the get_meshset_by_id function given id not in the dim
"""
three_vols = df.DagmcFile(test_env['three_vols'])
test_pass = np.full(3, False)
exp = []
with warnings.catch_warnings(record=True) as w:
obs = three_vols.get_meshset_by_id('volumes', ids=[4])
warnings.simplefilter('always')
if obs == exp:
test_pass[0] = True
if len(w) == 1:
test_pass[1] = True
if 'ID is not in the given dimension range! Empty list will be returned.' in str(
w[-1].message):
test_pass[2] = True
assert (all(test_pass))
def test_get_entities_incorrect_dim():
"""Tests the get_entities function given incorrect dimension
"""
test_pass = np.full(3, False)
three_vols = df.DagmcFile(test_env['three_vols'])
# check if __get_tris function generates warning for meshset with invalid dimension
vert = three_vols.entityset_ranges['nodes'][0]
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
three_vols_query = dq.DagmcQuery(three_vols, vert)
if len(w) == 2:
test_pass[0] = True
if 'Meshset is not a volume nor a surface!' in str(w[0].message) and \
'Specified meshset(s) are not surfaces or ' + \
'volumes. Rootset will be used by default.' in str(w[-1].message):
test_pass[1] = True
exp = list(three_vols.entityset_ranges['surfaces'])
test_pass[2] = (three_vols_query.meshset_lst == exp)
assert(all(test_pass))
def test_load_file():
"""Tests loading file and check the values of all the variables that are
set in the constructor
"""
single_cube = df.DagmcFile(test_env['single_cube'])
assert (single_cube.root_set == 0)
