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_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_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 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_iterables(): 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) 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.0] try: mb.tag_set_data(int_tag, verts, int_data) except: pass else: print("Shouldn't be here. Test fails.") raise (AssertionError) #now set with valid data and check int_data = [1, 2, 3] mb.tag_set_data(int_tag, verts, int_data) return_data = mb.tag_get_data(int_tag, verts) CHECK_EQ(return_data[0], int_data[0]) CHECK_EQ(return_data[1], int_data[1]) CHECK_EQ(return_data[2], int_data[2]) #insert false vertex handle (not even correct type verts = [verts[0], 23, verts[1]] try: mb.tag_set_data(int_tag, verts, [1, 2, 3]) except: pass else: print("Shouldn't be here. Test fails.") raise (AssertionError) #insert correct type, but non-existant handle verts = [verts[0], int(23), verts[1]] try: mb.tag_set_data(int_tag, verts, [1, 2, 3]) except: pass else: print("Shouldn't be here. Test fails.") raise (AssertionError)
def test_delete_mesh(): mb = core.Core() mb.create_vertices(np.ones(9)) rs = mb.get_root_set() ents = mb.get_entities_by_handle(rs) CHECK_EQ(len(ents), 3) # now delete all mesh entities mb.delete_mesh() ents = mb.get_entities_by_handle(rs) CHECK_EQ(len(ents), 0)
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]) # test for passing entity handle (non-iterable) ret_coords = mb.get_coords(verts[0]) CHECK_EQ(ret_coords[0], coords[0]) CHECK_EQ(ret_coords[1], coords[1]) CHECK_EQ(ret_coords[2], coords[2])
def test_opaque_tag(): mb = core.Core() vh = vertex_handle(mb) tag_length = 6 test_tag = mb.tag_get_handle("Test", tag_length, types.MB_TYPE_OPAQUE, types.MB_TAG_DENSE, True) test_val = 'four' 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.nbytes, tag_length * bytes_per_char_) CHECK_EQ(data[0], test_val)
def test_create_element_iterable(): mb = core.Core() coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64') verts = mb.create_vertices(coords) CHECK_EQ(3, len(verts)) #create tri using verts as a Range tris = mb.create_element(types.MBTRI, verts) #create another with the same vertices but in a list tri_verts = [verts[0], verts[1], verts[2]] tris = mb.create_element(types.MBTRI, verts) #make sure the right number of triangles is in the instance rs = mb.get_root_set() all_tris = mb.get_entities_by_type(rs, types.MBTRI) CHECK_EQ(len(all_tris), 2)
def test_create_elements(): mb = core.Core() coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64') verts = mb.create_vertices(coords) CHECK_EQ(len(verts), 3) #create elements verts = np.array(((verts[0], verts[1], verts[2]), ), dtype='uint64') tris = mb.create_elements(types.MBTRI, verts) CHECK_EQ(len(tris), 1) #check that the element is there via GLOBAL_ID tag global_id_tag = mb.tag_get_handle("GLOBAL_ID", 1, types.MB_TYPE_INTEGER, types.MB_TAG_DENSE, True) tri_id = mb.tag_get_data(global_id_tag, tris) CHECK_EQ(len(tri_id), 1) CHECK_EQ(tri_id[0], 0)
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_tag_list(): mb = core.Core() vh = vertex_handle(mb) tag_length = 6 test_tag = mb.tag_get_handle("Test", tag_length, types.MB_TYPE_OPAQUE, types.MB_TAG_DENSE, True) test_val = 'four' test_tag_data = np.array((test_val, )) # convert vertex handle Range to a list vh = list(vh) 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.nbytes, tag_length) CHECK_EQ(data[0], test_val) CHECK_EQ(data.dtype, '|S' + str(tag_length))
def test_tag_root_set(): # make sure that the root set can be tagged with data mb = core.Core() test_tag = mb.tag_get_handle("Test", 1, types.MB_TYPE_DOUBLE, types.MB_TAG_DENSE, True) root_set = mb.get_root_set() test_tag_data = np.array((4., )) mb.tag_set_data(test_tag, root_set, test_tag_data) data = mb.tag_get_data(test_tag, root_set, flat=True) CHECK_EQ(len(data), 1) CHECK_EQ(data[0], test_tag_data[0]) mb.tag_delete_data(test_tag, root_set)
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)
def test_get_bridge_adjacencies(): mb = core.Core() coords = np.array((0,0,0,1,0,0,1,1,1),dtype='float64') verts = mb.create_vertices(coords) CHECK_EQ(len(verts), 3) conn = np.array(((verts[0],verts[1],verts[2]),),dtype='uint64') tris = mb.create_elements(types.MBTRI, conn) mtu = topo_util.MeshTopoUtil(mb) rs = mb.get_root_set() tris = mb.get_entities_by_dimension(rs, 2) CHECK_EQ(len(tris), 1) adj_verts = mtu.get_bridge_adjacencies(tris, 0, 0, 1) CHECK_ITER_EQ(adj_verts,verts)
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_get_entities_by_handle(): mb = core.Core() coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64') verts = mb.create_vertices(coords) ms = mb.create_meshset() mb.add_entities(ms, verts) ret_verts = mb.get_entities_by_handle(ms, False) for i in range(len(verts)): CHECK_EQ(ret_verts[i], verts[i])
def test_set_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) coords += 1.0 # Shift x/y/z coordinates by 1.0 mb.set_coords(verts, coords) ret_coords2 = mb.get_coords(verts) for i in range(len(coords)): CHECK_EQ(ret_coords[i], ret_coords2[i] - 1.0)
def test_get_geometric_skin(): mb = core.Core() 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) # create a geometric set for the quads surf_set = mb.create_meshset() geom_tag = mb.tag_get_handle(types.GEOM_DIMENSION_TAG_NAME, 1, types.MB_TYPE_INTEGER, types.MB_TAG_SPARSE, create_if_missing = True) mb.tag_set_data(geom_tag, surf_set, 2) # place 2-D entities in this set mb.add_entities(surf_set, verts) mb.add_entities(surf_set, quads) # create a dummy volume set vol_set = mb.create_meshset() mb.tag_set_data(geom_tag, vol_set, 3) # set surface to volume parent-child relationship mb.add_parent_meshset(surf_set, vol_set) mskn = skinner.Skinner(mb) rs = mb.get_root_set() skin = mskn.find_geometric_skin(rs) CHECK_EQ(skin.num_of_type(types.MBVERTEX), 8) CHECK_EQ(skin.num_of_type(types.MBQUAD), 4)
def test_create_elements_iterable(): mb = core.Core() #create some vertices for triangle 1 coords1 = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64') verts1 = mb.create_vertices(coords1) CHECK_EQ(len(verts1), 3) #create some more vertices for triangle 2 coords2 = np.array((1, 2, 3, 4, 5, 6, 1, 1, 1), dtype='float64') verts2 = mb.create_vertices(coords2) CHECK_EQ(len(verts2), 3) tri_verts = [[verts1[0], verts1[1], verts1[2]], [verts2[0], verts2[1], verts2[2]]] tris = mb.create_elements(types.MBTRI, tri_verts) CHECK_EQ(len(tris), 2) tri_verts = [verts1, verts2] tris = mb.create_elements(types.MBTRI, tri_verts) CHECK_EQ(len(tris), 2) #make sure the right number of triangles is in the instance rs = mb.get_root_set() all_tris = mb.get_entities_by_type(rs, types.MBTRI) CHECK_EQ(len(all_tris), 4)
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 evaluate_sequence(box): bmin = box.box_min() bmax = box.box_max() start_vert = box.start_vertex() CHECK_TYPE(start_vert, _eh_py_type) for i in range(bmin[0], bmax[0]): for j in range(bmin[1], bmax[1]): for k in range(bmin[2], bmax[2]): #compute value of start vert this_vert = start_vert + (i - bmin[0]) + (j - bmin[1]) * ( bmax[0] - bmin[0] + 1) + (k - bmin[2]) * ( bmax[1] - bmin[1] + 1) * (bmax[0] - bmin[0] + 1) temp_vert = box.get_vertex([i, j, k]) CHECK_TYPE(temp_vert, _eh_py_type) CHECK_EQ(temp_vert, this_vert) temp_vert2 = box.get_vertex(HomCoord([i, j, k])) CHECK_TYPE(temp_vert2, _eh_py_type) CHECK_EQ(temp_vert, this_vert) CHECK_EQ(box.get_params(this_vert), [i, j, k]) CHECK_EQ(box.contains(i, j, k), True) start_elem = box.start_element() CHECK_TYPE(start_elem, _eh_py_type) for i in range(bmin[0], bmax[0] - 1): for j in range(bmin[1], bmax[1] - 1): for k in range(bmin[2], bmax[2] - 1): #compute value of start elem this_elem = start_elem + (i - bmin[0]) + (j - bmin[1]) * ( bmax[0] - bmin[0]) + (k - bmin[2]) * ( bmax[1] - bmin[1]) * (bmax[0] - bmin[0]) temp_elem = box.get_element([i, j, k]) CHECK_TYPE(temp_elem, _eh_py_type) CHECK_EQ(temp_elem, this_elem) temp_elem2 = box.get_element(HomCoord([i, j, k])) CHECK_TYPE(temp_elem2, _eh_py_type) CHECK_EQ(temp_elem, this_elem) CHECK_EQ(box.get_params(temp_elem), [i, j, k]) CHECK_EQ(box.contains(i, j, k), True)
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 conn = np.array(((verts[0], verts[1], verts[2]), ), dtype='uint64') tris = mb.create_elements(types.MBTRI, conn) #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(adjs.all_of_type(types.MBVERTEX)) #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) CHECK(adjs.all_of_type(types.MBEDGE)) adjs = mb.get_adjacencies(tris[0], 0, False) CHECK_EQ(len(adjs), 3) # create another triangle (with reverse normal) new_coords = np.array((2, 2, 2, 3, 5, 3), dtype='float64') new_verts = mb.create_vertices(new_coords) # create a new triangle that shares a vertex with the first new_tri_conn = np.array(((verts[2], new_verts[0], new_verts[1]), ), dtype='uint64') tris.merge(mb.create_elements(types.MBTRI, new_tri_conn)) # confirm that we can get the adjacency intersection of the two triangles adjs = mb.get_adjacencies(tris, 0, False) CHECK_EQ(len(adjs), 1) CHECK(adjs.all_of_type(types.MBVERTEX)) adjs = mb.get_adjacencies(tris, 1, False) CHECK_EQ(len(adjs), 0) CHECK(adjs.all_of_type(types.MBEDGE)) # now check that we can get the union of the two triangle adjacencies adjs = mb.get_adjacencies(tris, 0, False, types.UNION) CHECK_EQ(len(adjs), 5) CHECK(adjs.all_of_type(types.MBVERTEX)) # sanity check for number of edges adjs = mb.get_adjacencies(tris[1], 1, False, types.UNION) CHECK_EQ(len(adjs), 0)
def test_set_conn(): mb = core.Core() coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64') verts = mb.create_vertices(coords) #create element verts = np.array(((verts[0], verts[1], verts[2]), ), dtype='uint64') tri = mb.create_elements(types.MBTRI, verts) # make new verts to set new connectivity verts_new = mb.create_vertices(coords) mb.set_connectivity(tri[0], verts_new) # get the adjacencies of the triangle (vertices) conn = mb.get_connectivity(tri) # check the returned EHs match the new vertices entity handles CHECK_EQ(list(conn), list(verts_new))
def test_set_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) coords += 1.0 # Shift x/y/z coordinates by 1.0 mb.set_coords(verts, coords) ret_coords2 = mb.get_coords(verts) for i in range(len(coords)): CHECK_EQ(ret_coords[i], ret_coords2[i] - 1.0) # check that setting with a single eh is ok coord = np.array((5, 5, 5), dtype='float64') mb.set_coords(verts[0], coord) ret_coords3 = mb.get_coords(verts[0]) CHECK_ITER_EQ(ret_coords3, coord)
def test_vec_tags(): mb = core.Core() coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64') verts = mb.create_vertices(coords) int_vec_test_tag = mb.tag_get_handle("IntegerVecTestTag", 3, types.MB_TYPE_INTEGER, types.MB_TAG_DENSE, True) dbl_vec_test_tag = mb.tag_get_handle("DoubleVecTestTag", 3, types.MB_TYPE_DOUBLE, types.MB_TAG_DENSE, True) opaque_vec_test_tag = mb.tag_get_handle("OPTag", 10, types.MB_TYPE_OPAQUE, types.MB_TAG_DENSE, True) #should be able to successfully tag using a 2-D array int_vec_test_tag_values = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) dbl_vec_test_tag_values = np.array([[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]]) opaque_vec_test_tag_values = np.array([["One"], ["Two"], ["Three"]]) mb.tag_set_data(int_vec_test_tag, verts, int_vec_test_tag_values) mb.tag_set_data(dbl_vec_test_tag, verts, dbl_vec_test_tag_values) mb.tag_set_data(opaque_vec_test_tag, verts, opaque_vec_test_tag_values) #or a 1-D array int_vec_test_tag_values_flat = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8]) dbl_vec_test_tag_values_flat = np.array( [9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0]) opaque_vec_test_tag_values_flat = np.array(["One", "Two", "Three"]) mb.tag_set_data(int_vec_test_tag, verts, int_vec_test_tag_values) mb.tag_set_data(dbl_vec_test_tag, verts, dbl_vec_test_tag_values) mb.tag_set_data(opaque_vec_test_tag, verts, opaque_vec_test_tag_values_flat) #these values should then be able to be retrieved as a 2-D array returned_int_test_tag_values = mb.tag_get_data(int_vec_test_tag, verts) CHECK_EQ(returned_int_test_tag_values, int_vec_test_tag_values) returned_dbl_test_tag_values = mb.tag_get_data(dbl_vec_test_tag, verts) CHECK_EQ(returned_dbl_test_tag_values, dbl_vec_test_tag_values) returned_opaque_test_tag_values = mb.tag_get_data(opaque_vec_test_tag, verts) CHECK_EQ(returned_opaque_test_tag_values, opaque_vec_test_tag_values) #or as a 1-D array returned_int_test_tag_values = mb.tag_get_data(int_vec_test_tag, verts, flat=True) CHECK_EQ(returned_int_test_tag_values, int_vec_test_tag_values_flat) returned_dbl_test_tag_values = mb.tag_get_data(dbl_vec_test_tag, verts, flat=True) CHECK_EQ(returned_dbl_test_tag_values, dbl_vec_test_tag_values_flat) returned_opaque_test_tag_values = mb.tag_get_data(opaque_vec_test_tag, verts, flat=True) CHECK_EQ(returned_opaque_test_tag_values, opaque_vec_test_tag_values_flat)
def check_sequence(box, imin, jmin, kmin, imax, jmax, kmax): bmin = box.box_min() CHECK_EQ(bmin.i(), imin) CHECK_EQ(bmin.j(), jmin) CHECK_EQ(bmin.k(), kmin) bmax = box.box_max() CHECK_EQ(bmax.i(), imax) CHECK_EQ(bmax.j(), jmax) CHECK_EQ(bmax.k(), kmax) bsize = box.box_size() CHECK_EQ((bmax - bmin + HomCoord([1, 1, 1, 0])), bsize)