def test_load_mesh():
mb = core.Core()
try:
mb.load_file("cyl_grps.h5m")
except:
try:
print("""
WARNING: .h5m file load failed. If hdf5 support is enabled in this
build there could be a problem.
""")
mb.load_file("cyl_grps.vtk")
except:
raise (IOError, "Failed to load MOAB file.")
#load into file_set
mb1 = core.Core()
file_set = mb1.create_meshset()
try:
mb1.load_file("cyl_grps.h5m", file_set)
except:
try:
print("""
WARNING: .h5m file load failed. If hdf5 support is enabled in this
build there could be a problem.
""")
mb1.load_file("cyl_grps.vtk", file_set)
except:
raise (IOError, "Failed to load MOAB file.")
ents = mb1.get_entities_by_type(file_set, types.MBMAXTYPE)
CHECK_NOT_EQ(len(ents), 0)
def __init__(self, nx, ny, nz, dx, dy, dz, num_elements):
self.dx = dx
self.dy = dy
self.dz = dz
self.num_elements = num_elements
self.nx = nx
self.ny = ny
self.nz = nz
self.mbcore = core.Core(
) # Criando instância da classe Core que gerencias as operações na malha
num_vertex = (nx + 1) * (ny + 1) * (nz + 1)
print("Creating vertices coordinates")
self.vertex_coords = np.zeros(num_vertex * 3)
for i in range(num_vertex):
self.vertex_coords[3 * i] = (i % (nx + 1)) * dx
self.vertex_coords[3 * i + 1] = ((i // (nx + 1)) % (ny + 1)) * dy
self.vertex_coords[3 * i + 2] = ((i // ((nx + 1) * (ny + 1))) %
(nz + 1)) * dz
self.vertex_handles = self.mbcore.create_vertices(
self.vertex_coords) # Criando os handles dos vértices
print("Creating connectivity")
self.mesh_connectivity = self.create_mesh_connectivity()
print("Creating element handles")
self.elem_handles = rng.Range([
self.mbcore.create_element(types.MBHEX, x)
for x in self.mesh_connectivity
])
self.write_files()
def test_write_ents():
try:
mb = core.Core()
vs = mb.create_vertices(np.ones(3))
mb.write_file("ents.h5m", vs)
except (IOError):
pass
def test_tag_shallow_copy():
"""
Tests that PyMOAB will handle the passing of a shallow-copy numpy expression
appropriately
"""
mb = core.Core()
vh = vertex_handle(mb)
test_tag = mb.tag_get_handle("Test", 5, types.MB_TYPE_DOUBLE, True,
types.MB_TAG_SPARSE)
test_val = np.array([1., 2., 3., 4., 5.])
mb.tag_set_data(test_tag, vh, test_val)
# some other large numpy array
external_data = np.ones((5, 10))
external_data[0, :] = np.linspace(1, 10, 10)
external_data[1, :] = np.linspace(1, 10, 10)
external_data[2, :] = np.linspace(1, 10, 10)
external_data[3, :] = np.linspace(1, 10, 10)
external_data[4, :] = np.linspace(1, 10, 10)
# slice data (shallow copy, unevaluated)
data_slice = external_data[:, 0]
# update data
mb.tag_set_data(test_tag, vh, data_slice)
expected_data = np.array([1., 1., 1., 1., 1.])
actual_data = mb.tag_get_data(test_tag, vh, flat=True)
CHECK_ITER_EQ(actual_data, expected_data)
def __init__(self):
os.chdir(input_dir)
with open("input_mesh_generator.yaml", 'r') as stream:
data_loaded_mesh = yaml.load(stream)
# data_loaded = yaml.load(stream, Loader=yaml.FullLoader)
# data_loaded = yaml.full_load(stream)
with open("input_wells.yaml", 'r') as stream:
data_loaded_wells = yaml.load(stream)
# data_loaded = yaml.load(stream, Loader=yaml.FullLoader)
# data_loaded = yaml.full_load(stream)
self.data_loaded = data_loaded_mesh
file_name = data_loaded_mesh['file_name']
self.file_name = file_name
# self.Lz = float(data_loaded_mesh['mesh_size'][2])
name_mesh = file_name + '_wells.h5m'
self.mb = core.Core()
self.mtu = topo_util.MeshTopoUtil(self.mb)
mesh_file = name_mesh
os.chdir(flying_dir)
self.mb.load_file(mesh_file)
names_tags = np.load('tags_wells.npy')
self.tags = utpy.get_all_tags_2(self.mb, names_tags)
self.all_nodes, self.all_edges, self.all_faces, self.all_volumes = utpy.get_all_entities(
self.mb)
import pdb
pdb.set_trace()
def __init__(self, mesh_file=None, dim=3):
self.dimension = dim
self.mb = core.Core()
self.mtu = topo_util.MeshTopoUtil(self.mb)
if mesh_file is not None:
self.mb.load_file(mesh_file)
self.run()
def __init__(self, inputname_dict, inputname_h5m):
global kkeys
self.__verif = False
self.kkeys = kkeys
os.chdir('configs')
with open(inputname_dict, 'r') as stream:
self.info = yaml.load(stream)
os.chdir('..')
self.Ltot = self.info[self.kkeys[0]]['L']
self.mb = core.Core()
self.mb.load_file(inputname_h5m)
self.mtu = topo_util.MeshTopoUtil(self.mb)
self.sk = skinner.Skinner(self.mb)
self.root_set = self.mb.get_root_set()
self.all_volumes = self.mb.get_entities_by_dimension(self.root_set, 3)
# e_tags = self.mb.tag_get_tags_on_entity(self.all_volumes[0])
# print(e_tags)
# import pdb; pdb.set_trace()
self.all_nodes = self.mb.get_entities_by_dimension(0, 0)
self.mtu.construct_aentities(self.all_nodes)
self.all_faces = self.mb.get_entities_by_dimension(self.root_set, 2)
self.all_edges = self.mb.get_entities_by_dimension(self.root_set, 1)
self.vols_centroids = np.array(
[self.mtu.get_average_position([v]) for v in self.all_volumes])
self.ns = (len(self.all_volumes))
self.gravity = self.info[key_gravity]
self.DefineLenghtNv0()
self.__verif = True
def load_adm_mesh():
n_levels = 3
parent_dir = os.path.dirname(os.path.abspath(__file__))
parent_parent_dir = os.path.dirname(parent_dir)
input_dir = os.path.join(parent_parent_dir, 'input')
flying_dir = os.path.join(parent_parent_dir, 'flying')
bifasico_dir = os.path.join(flying_dir, 'bifasico')
utils_dir = os.path.join(parent_parent_dir, 'utils')
processor_dir = os.path.join(parent_parent_dir, 'processor')
os.chdir(input_dir)
with open("inputs.yaml", 'r') as stream:
data_loaded = yaml.load(stream)
# data_loaded = yaml.load(stream, Loader=yaml.FullLoader)
# data_loaded = yaml.full_load(stream)
input_file = data_loaded['input_file']
ext_h5m_adm = input_file + '_malha_adm.h5m'
ADM = data_loaded['ADM']
tempos_impr = data_loaded['tempos_vpi_impressao']
contar_loop = data_loaded['contar_loop']
contar_tempo = data_loaded['contar_tempo']
imprimir_sempre = data_loaded['imprimir_sempre']
mb = core.Core()
mtu = topo_util.MeshTopoUtil(mb)
os.chdir(flying_dir)
mb.load_file(ext_h5m_adm)
list_names_tags = np.load('list_names_tags.npy')
# list_names_tags = np.delete(list_names_tags, np.where(list_names_tags == 'L_TOT')[0])
# names_tags_with_level = np.load('names_tags_with_level.npy')
tags_1 = get_all_tags_2(mb, list_names_tags)
os.chdir(parent_dir)
return mb, mtu, tags_1, input_file, ADM, tempos_impr, contar_loop, contar_tempo, imprimir_sempre
def __init__(self, coords, elements, point_type, center):
self.mb = core.Core()
#self.point_type = np.concatenate((np.array([-1]), point_type))
self.point_type = point_type
verts = self.mb.create_vertices(coords)
self.rs = self.mb.get_root_set()
elements = elements + np.ones(elements.shape)
self.tag_handle = self.mb.tag_get_handle("Teste", 1, types.MB_TYPE_INTEGER, types.MB_TAG_DENSE, create_if_missing = True)
self.tag_node = self.mb.tag_get_handle("Nodes", 1, types.MB_TYPE_INTEGER, types.MB_TAG_DENSE, create_if_missing = True)
for el in elements:
tetra = self.mb.create_element(types.MBTET, el.ravel().astype("uint64"))
# self.mtu = topo_util.MeshTopoUtil(self.mb)
# self.mtu.construct_aentities(verts)
#self.mtu.construct_aentities(verts)
#self.elements = self.mb.get_entities_by_dimension(0, 3)
self.mtu = topo_util.MeshTopoUtil(self.mb)
self.all_elements = self.mb.get_entities_by_dimension(0, 3)
self.nodes = self.mb.get_entities_by_dimension(0, 0)
self.faces = self.skinner(self.all_elements)
self.boundary_nodes = self.find_boundary_nodes()
self.boundary_elements = self.find_boundary_elements()
self.desired_bnodes = np.array(self.nodes)[self.point_type == 0]
self.find_simple_bad()
#self.select(self.boundary_nodes)
#self.remove_vol(self.all_elements[0:120])
#self.find_bad_vol()
#import pdb; pdb.set_trace()
#self.smooth()
#import pdb; pdb.set_trace()
self.create_vtk()
def __init__(self, filename):
self.mb = core.Core()
self.root_set = self.mb.get_root_set()
self.load_mesh(filename)
self.error_tag = self.mb.tag_get_handle("error", 1,
types.MB_TYPE_DOUBLE,
types.MB_TAG_SPARSE, True)
self.node_pressure_tag = self.mb.tag_get_handle(
"node_pressure", 1, types.MB_TYPE_DOUBLE, types.MB_TAG_SPARSE,
True)
self.ref_degree_tag = self.mb.tag_get_handle("ref_degree", 1,
types.MB_TYPE_DOUBLE,
types.MB_TAG_SPARSE, True)
self.degree_id_tag = self.mb.tag_get_handle("ref_degree", 1,
types.MB_TYPE_DOUBLE,
types.MB_TAG_SPARSE, True)
self.hanging_nodes_tag = self.mb.tag_get_handle(
"hanging_nodes", 1, types.MB_TYPE_HANDLE, types.MB_TAG_MESH, True)
self.full_edges_tag = self.mb.tag_get_handle("full_edges", 1,
types.MB_TYPE_HANDLE,
types.MB_TAG_MESH, True)
self.hang_nodes = set()
def main():
args = parse_arguments()
# Load the mesh file.
mb = core.Core()
mb.load_file(args.meshfile)
# Retrieve the lists of scalar and vector tags on the mesh.
try:
elements, scal_tags, vec_tags = get_tag_lists(mb, args.element)
except LookupError as e:
sys.exit(str(e))
# Warn the user if the mesh file does not contain at least one vector tag.
if len(vec_tags) < 1:
raise ValueError(
"WARNING: This mesh file did not contain any vector tags on {} elements."
.format(args.element))
# Create a directory to store vector tag expansion files.
try:
dir_name = create_directory(args.dirname, args.overwrite)
os.mkdir(dir_name)
except OSError:
pass
# Expand each vector tag present in the mesh.
for tag in vec_tags:
expand_vec_tag(mb, elements, scal_tags, tag, dir_name)
def test_range_methods():
mb = core.Core()
coord = np.array((1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6),
dtype='float64')
range_a = mb.create_vertices(coord)
coord = np.array((2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7),
dtype='float64')
range_b = mb.create_vertices(coord)
CHECK_EQ(range_a.all_of_dimension(0), True)
CHECK_EQ(range_b.all_of_dimension(0), True)
CHECK_EQ(range_a.all_of_dimension(1), False)
CHECK_EQ(range_b.all_of_dimension(1), False)
CHECK_EQ(range_a.num_of_dimension(0), range_a.size())
CHECK_EQ(range_b.num_of_dimension(0), range_b.size())
CHECK_EQ(range_a.num_of_dimension(1), 0)
CHECK_EQ(range_b.num_of_dimension(1), 0)
CHECK_EQ(range_a.num_of_type(types.MBVERTEX), range_a.size())
CHECK_EQ(range_b.num_of_type(types.MBVERTEX), range_b.size())
range_intersect = intersect(range_a, range_b)
CHECK_EQ(range_intersect.size(), 0)
range_unite = unite(range_a, range_b)
CHECK_EQ(range_unite.size(), 12)
range_subtract = subtract(range_a, range_b)
CHECK_EQ(range_subtract.size(), range_a.size())
range_a.erase(range_a[0])
CHECK_EQ(range_a.size(), 5)
all_verts = mb.get_entities_by_type(0, types.MBVERTEX)
CHECK_EQ(all_verts.size(), 12)
range_intersect = intersect(all_verts, range_a)
CHECK_EQ(range_intersect.size(), 5)
range_intersect = intersect(all_verts, range_b)
CHECK_EQ(range_intersect.size(), 6)
range_unite = unite(all_verts, range_a)
CHECK_EQ(range_unite.size(), 12)
range_unite = unite(all_verts, range_b)
CHECK_EQ(range_unite.size(), 12)
range_subtract = subtract(all_verts, range_a)
CHECK_EQ(range_subtract.size(), 7)
range_subtract = subtract(all_verts, range_b)
CHECK_EQ(range_subtract.size(), 6)
range_a.merge(range_b)
CHECK_EQ(range_a.size(), 11)
def __init__(self):
shutil.rmtree(flying_dir)
os.makedirs(flying_dir)
self.__verif = True
with open("input_mesh_generator.yaml", 'r') as stream:
data_loaded = yaml.load(stream)
# data_loaded = yaml.load(stream, Loader=yaml.FullLoader)
# data_loaded = yaml.full_load(stream)
with open("input_wells.yaml", 'r') as stream:
data_wells = yaml.load(stream)
# data_loaded = yaml.load(stream, Loader=yaml.FullLoader)
# data_loaded = yaml.full_load(stream)
self.data_loaded = data_loaded
self.tags = dict()
self.mb = core.Core()
self.mtu = topo_util.MeshTopoUtil(self.mb)
self.nblocks = data_loaded['nblocks']
self.mesh_size = data_loaded['mesh_size']
self.blocksize = self.mesh_size / self.nblocks
hx = self.blocksize[0]
hy = self.blocksize[1]
hz = self.blocksize[2]
self.Area = np.array([hy * hz, hx * hz, hy * hx])
self.mi = data_wells['dados_monofasico']['mi']
self.gama = data_wells['dados_monofasico']['gama']
def persistent_load(self, pid):
type_tag = pid[0]
if type_tag == "core":
if self.mb is None:
mb = core.Core()
mb.load_file(f'{self.file_name}.h5m')
self.mb = mb
return self.mb
elif type_tag == "mtu":
if self.mb is None:
raise pickle.UnpicklingError("core is missing")
if self.mtu is None:
mtu = topo_util.MeshTopoUtil(self.mb)
return self.mtu
elif type_tag == "skinner":
if self.mb is None:
raise pickle.UnpicklingError("core is missing")
if self.skinner is None:
self.skinner = skinner.Skinner(self.mb)
return self.skinner
elif type_tag == "range":
r = rng.Range(pid[1])
return r
elif type_tag == "tag":
if self.mb is None:
raise pickle.UnpicklingError("core is missing")
return self.mb.tag_get_handle(pid[1])
else:
print()
raise pickle.UnpicklingError(
f'unsupported persistent object {pid}')
def test_entity_handle_tags():
# make sure that the root set can be tagged with data
mb = core.Core()
eh_tag = mb.tag_get_handle("Test", 1, types.MB_TYPE_HANDLE,
types.MB_TAG_SPARSE, True)
dbl_tag = mb.tag_get_handle("Dbl", 1, types.MB_TYPE_DOUBLE,
types.MB_TAG_DENSE, True)
meshset_a = mb.create_meshset()
meshset_b = mb.create_meshset()
# tag meshset a with meshset b
mb.tag_set_data(eh_tag, meshset_a, meshset_b)
# tag meshset b with a double value
val = 16.0
mb.tag_set_data(dbl_tag, meshset_b, val)
eh = mb.tag_get_data(eh_tag, meshset_a)
CHECK_EQ(eh, meshset_b)
dbl_val = mb.tag_get_data(dbl_tag, eh)
CHECK_EQ(dbl_val, val)
eh = mb.tag_get_data(eh_tag, meshset_a, flat=True)[0]
CHECK_EQ(eh, meshset_b)
dbl_val = mb.tag_get_data(dbl_tag, eh, flat=True)[0]
CHECK_EQ(dbl_val, val)
def test_get_skin():
mb = core.Core()
rs = mb.get_root_set()
coords = np.array([[0,0,0], [1,0,0], [2,0,0],
[0,1,0], [1,1,0], [2,1,0],
[0,2,0], [1,2,0], [2,2,0]],dtype='float64')
verts = mb.create_vertices(coords)
verts = np.array((verts[0:8]),dtype='uint64')
connect = np.array([[1, 2, 5, 4],
[2, 3, 6, 5],
[4, 5, 8, 7],
[5, 6, 9, 8]],dtype='uint64')
quads = mb.create_elements(types.MBQUAD,connect)
nelems = mb.get_entities_by_dimension(rs, 2)
CHECK_EQ(len(nelems), 4)
mb.write_file('quads_test.vtk')
mskn = skinner.Skinner(mb)
skin_verts = mskn.find_skin(rs, quads, True, False)
CHECK_EQ(len(skin_verts), 8)
skin_edges = mskn.find_skin(rs, quads, False, False)
CHECK_EQ(len(skin_edges), 8)
def py_mb_convert(file_location, file_extension):
"""
Convert files from one format to another with PyMOAB.
Input:
______
file_location: str
User supplied file location.
file_extension: str
User supplied file format to convert to, including '.'
Returns:
________
new_file_name: str
The new file name with the specified extension.
"""
# Load the file to be converted.
mb = core.Core()
mb.load_file(file_location)
# Isolate the file name from string containing the file location.
input_file = file_location.split("/")
file_name = '.'.join(input_file[-1].split(".")[:-1])
new_file_name = file_name + file_extension
# Write the new file with the user supplied extension.
mb.write_file(new_file_name)
return new_file_name
def __init__(self, mesh_file, dim=3):
self.dimension = dim
self.mb = core.Core()
self.root_set = self.mb.get_root_set()
self.mtu = topo_util.MeshTopoUtil(self.mb)
self.mb.load_file(mesh_file)
self.all_volumes = self.mb.get_entities_by_dimension(0, 3)
self.all_nodes = self.mb.get_entities_by_dimension(0, 0)
self.mtu.construct_aentities(self.all_nodes)
self.all_faces = self.mb.get_entities_by_dimension(0, 2)
self.all_edges = self.mb.get_entities_by_dimension(0, 1)
self.handleDic = {}
[self.boundary_nodes, self.boundary_edges, self.boundary_faces, self.boundary_volumes] = self.skinner_operation()
self.internal_nodes = rng.subtract(self.all_nodes, self.boundary_nodes)
self.internal_edges = rng.subtract(self.all_edges, self.boundary_edges)
self.internal_faces = rng.subtract(self.all_faces, self.boundary_faces)
self.internal_volumes = rng.subtract(self.all_volumes, self.boundary_volumes)
self.init_id()
self.check_integrity()
self.create_id_visualization()
# self.flag_dic = {}
[self.flag_list, self.flag_dic] = self.read_flags()
self.create_flag_visualization()
# swtich on/off
self.parallel_meshset = self.create_parallel_meshset()
self.create_parallel_visualization()
def test_meshql(self):
dsl = DSL(MoabTemplateManager(),
MeshQLContract(MeshQLImplementation()), MoabMeta())
mb = core.Core()
mb.load_file('cube_small.h5m')
with dsl.root() as root:
ents = root.ByEnt(3)\
.ByAdj(2, 3)\
.Map(SetScalar(1.0))\
.ByAdj(2, 3).Map(SetScalar(1.0))\
.Reduce(Sum(initial_value=0.0)).Reduce(Sum(initial_value=0.0)).Reduce(Sum(initial_value=0.0))\
.Store("TEST_TAG")
#one = vols_adj_ents(Map, mapping_function=PutScalar(value=1.0))
#count = one(Reduce, reducing_function=Sum(initial_value=0.0))
#count2 = count(Reduce, reducing_function=Sum(initial_value=0.0))
root.expr.export_tree('res1.png')
t0 = time.time()
for i in range(1000):
dsl.get_built_module().execute(mb)
print(f'{(time.time() - t0)/1000}')
def __init__(self, filename, populate=False):
"""Constructor
inputs
------
filename : name of the file
populate : boolean value that determines whether or not to populate the data
outputs
-------
none
"""
# read file
self._my_moab_core = core.Core()
self._my_moab_core.load_file(filename)
self.root_set = self._my_moab_core.get_root_set()
self.entity_types = [types.MBVERTEX, types.MBTRI, types.MBENTITYSET]
self.entityset_types = {
0: 'nodes',
1: 'curves',
2: 'surfaces',
3: 'volumes'
}
self.native_ranges = {}
self.__set_native_ranges()
self.dagmc_tags = {}
self.__set_dagmc_tags()
self.entityset_ranges = {}
self.__set_entityset_ranges()
self.dim_dict = {}
self.__set_dimension_meshset()
def __init__(self):
global parent_parent_dir, mesh_dir
self.dimension = 3
self.mb = core.Core()
self.root_set = self.mb.get_root_set()
self.mtu = topo_util.MeshTopoUtil(self.mb)
with open("inputs.yaml", 'r') as stream:
data_loaded = yaml.load(stream)
input_name = data_loaded['input_name']
ext_msh = mesh_dir + '/' + input_name + '.msh'
self.ext_out = input_name + '_out_initial_mesh3D'
self.ext_out_h5m = self.ext_out + '.h5m'
self.mb.load_file(ext_msh)
self.all_volumes = self.mb.get_entities_by_dimension(0, self.dimension)
self.all_nodes = self.mb.get_entities_by_dimension(0, 0)
self.mtu.construct_aentities(self.all_nodes)
self.all_faces = self.mb.get_entities_by_dimension(0, 2)
lx = data_loaded['lx']
ly = data_loaded['ly']
lz = data_loaded['lz']
self.hs = [lx, ly, lz]
self.Areas = np.array([ly * lz, lx * lz, lx * ly])
self.mi = 1.0
self.data = dict()
self.entities = dict()
self.tags = dict()
self.tags_to_infos = dict()
self.entities_to_tags = dict()
def test_get_conn():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
#create elements
verts = np.array(((verts[0], verts[1], verts[2]), ), dtype='uint64')
tris = mb.create_elements(types.MBTRI, verts)
#get the adjacencies of the triangle of dim 1 (should return the vertices)
conn = mb.get_connectivity(tris, 0, False)
CHECK_EQ(len(conn), 3)
#check that the entities are of the correct type
for c in conn:
type = mb.type_from_handle(c)
assert type is types.MBVERTEX
conn = mb.get_connectivity(tris[0])
CHECK_EQ(len(conn), 3)
CHECK_EQ(conn, verts)
conn = mb.get_connectivity(Range(tris))
CHECK_EQ(len(conn), 3)
CHECK_EQ(conn, verts)
msh = mb.create_meshset()
try:
mb.get_connectivity(msh)
except IndexError:
pass
else:
print("Shouldn't be here. Test fails.")
raise (IndexErrorx)
def test_unordered_tagging():
mb = core.Core()
# 1-D iterable
coords = [0., 0., 0., 1., 0., 0., 1., 1., 1.]
verts = mb.create_vertices(coords)
CHECK_EQ(len(verts), 3)
# 2-D iterable w/ len 3 entries
coords = [[0., 0., 0.], [1., 0., 0.], [1., 1., 1.]]
verts = mb.create_vertices(coords)
CHECK_EQ(len(verts), 3)
#create a tag
int_tag = mb.tag_get_handle("IntTag", 1, types.MB_TYPE_INTEGER,
types.MB_TAG_DENSE, True)
#try to set data with bad array (contains int)
int_data = [1, 2, 3]
# tag ordered vertices with value
mb.tag_set_data(int_tag, verts, int_data)
reordered_verts = [verts[1], verts[2], verts[0]]
reordered_data = [int_data[1], int_data[2], int_data[0]]
# check that data array is correct for reordered vertex handles
data = mb.tag_get_data(int_tag, reordered_verts)
CHECK_EQ(data, reordered_data)
def test_get_coords():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
ret_coords = mb.get_coords(verts)
for i in range(len(coords)):
CHECK_EQ(ret_coords[i], coords[i])
def test_adj():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
#create elements
verts = np.array(((verts[0], verts[1], verts[2]), ), dtype='uint64')
tris = mb.create_elements(types.MBTRI, verts)
#get the adjacencies of the triangle of dim 1 (should return the vertices)
adjs = mb.get_adjacencies(tris, 0, False)
CHECK_EQ(len(adjs), 3)
#check that the entities are of the correct type
for adj in adjs:
type = mb.type_from_handle(adj)
assert type is types.MBVERTEX
#now get the edges and ask MOAB to create them for us
adjs = mb.get_adjacencies(tris, 1, True)
CHECK_EQ(len(adjs), 3)
for adj in adjs:
ent_type = mb.type_from_handle(adj)
CHECK_EQ(ent_type, types.MBEDGE)
adjs = mb.get_adjacencies(tris[0], 0, False)
CHECK_EQ(len(adjs), 3)
def test_tag_delete():
mb = core.Core()
vh = vertex_handle(mb)
test_tag = mb.tag_get_handle("Test", 1, types.MB_TYPE_INTEGER, True,
types.MB_TAG_SPARSE)
test_val = 4
test_tag_data = np.array((test_val, ))
mb.tag_set_data(test_tag, vh, test_tag_data)
mb.tag_delete_data(test_tag, vh)
try:
mb.tag_get_data(test_tag, vh)
raised = False
except RuntimeError as e:
er_val = e.args[0].error_value
raised = True
CHECK_EQ(raised, True)
CHECK_EQ(er_val, types.MB_TAG_NOT_FOUND)
mb.tag_delete(test_tag)
try:
mb.tag_get_data(test_tag, vh)
raised = False
except RuntimeError as e:
er_val = e.args[0].error_value
raised = True
CHECK_EQ(raised, True)
CHECK_EQ(er_val, types.MB_TAG_NOT_FOUND)
def test_integer_tag():
mb = core.Core()
vh = vertex_handle(mb)
test_tag = mb.tag_get_handle("Test", 1, types.MB_TYPE_INTEGER,
types.MB_TAG_DENSE, True)
test_val = 4
test_tag_data = np.array((test_val, ))
mb.tag_set_data(test_tag, vh, test_tag_data)
data = mb.tag_get_data(test_tag, vh)
CHECK_EQ(len(data), 1)
CHECK_EQ(data[0], test_val)
CHECK_EQ(data.dtype, 'int32')
#set tag data for single handle (non-iterable)
new_test_value = 36
mb.tag_set_data(test_tag, vh[0], new_test_value)
data = mb.tag_get_data(test_tag, vh[0])
CHECK_EQ(len(data), 1)
CHECK_EQ(new_test_value, data[0])
CHECK_EQ(data.dtype, 'int32')
tags = mb.tag_get_tags_on_entity(vh[0])
assert len(tags) > 0
def test_get_entities_by_dimension():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
rs = mb.get_root_set()
ret_verts = mb.get_entities_by_dimension(rs, 0)
for i in range(len(verts)):
CHECK_EQ(ret_verts[i], verts[i])
def test_meshsets():
mb = core.Core()
parent_set = mb.create_meshset()
for i in range(5):
a = mb.create_meshset()
mb.add_child_meshset(parent_set, a)
children = mb.get_child_meshsets(parent_set)
CHECK_EQ(len(children), 5)
def test_tag_properties():
mb = core.Core()
tag_size = 16
test_tag = mb.tag_get_handle("Test", tag_size, types.MB_TYPE_INTEGER,
types.MB_TAG_DENSE, True)
CHECK_EQ(test_tag.get_length(), tag_size)
