Esempio n. 1
0
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)
Esempio n. 2
0
    def skinner_operation(self):
        skin = sk.Skinner(self.mb)
        print("Entering skinner test")

        if self.dimension == 3:
            faces_on_skin_handles = skin.find_skin(self.root_set, self.all_volumes[:])
            # pdb.set_trace()
            edges_on_skin_handles = self.access_handle(faces_on_skin_handles)
            nodes_on_skin_handles = self.access_handle(edges_on_skin_handles)

            nodes_in_volumes = ([self.mb.get_adjacencies(el_handle,0) for el_handle in self.all_volumes])
            check_volumes = np.asarray([rng.intersect(el_handle,nodes_on_skin_handles) for el_handle in nodes_in_volumes])
            external_volumes_index = np.array([el_handle.empty() for el_handle in check_volumes]).astype(bool)
            volumes_on_skin_handles = self.range_index(np.bitwise_not(external_volumes_index),self.all_volumes)


        elif self.dimension == 2:
            edges_on_skin_handles = skin.find_skin(self.root_set, self.all_faces[:])
            nodes_on_skin_handles = self.access_handle(edges_on_skin_handles)
            nodes_in_faces = ([self.mb.get_adjacencies(el_handle,0) for el_handle in self.all_faces])
            check_faces= np.asarray([rng.intersect(el_handle,nodes_on_skin_handles) for el_handle in nodes_in_faces])
            external_faces_index = np.array([el_handle.empty() for el_handle in check_faces]).astype(bool)
            faces_on_skin_handles = self.range_index(np.bitwise_not(external_faces_index),self.all_faces)
            volumes_on_skin_handles = rng.Range()

        print("Skinning Operation Successful")
        return [nodes_on_skin_handles, edges_on_skin_handles, faces_on_skin_handles, volumes_on_skin_handles]
Esempio n. 3
0
    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
Esempio n. 4
0
    def skinner_operation(self):
        self.skin = sk.Skinner(self.mb)
        print("Entering skinner test")

        if self.all_volumes.empty() and self.dimension == 3:
            raise ValueError("Empty volumes range for a tridimensional mesh.")

        if self.dimension == 3:
            faces_on_skin_handles = self.skin.find_skin(
                self.root_set, self.all_volumes)
            edges_on_skin_handles = self.mtu.get_bridge_adjacencies(
                faces_on_skin_handles, 2, 1)
            nodes_on_skin_handles = self.mtu.get_bridge_adjacencies(
                faces_on_skin_handles, 2, 0)
            volumes_on_skin_handles = self.mtu.get_bridge_adjacencies(
                faces_on_skin_handles, 0, 3)
        elif self.dimension == 2:
            edges_on_skin_handles = self.skin.find_skin(
                self.root_set, self.all_faces)
            nodes_on_skin_handles = self.mtu.get_bridge_adjacencies(
                edges_on_skin_handles, 1, 0)
            faces_on_skin_handles = self.mtu.get_bridge_adjacencies(
                edges_on_skin_handles, 0, 2)
            volumes_on_skin_handles = self.mtu.get_bridge_adjacencies(
                edges_on_skin_handles, 0, 3)  #empty

        print("Skinning Operation Successful")
        return [
            nodes_on_skin_handles, edges_on_skin_handles,
            faces_on_skin_handles, volumes_on_skin_handles
        ]
Esempio n. 5
0
    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}')
Esempio n. 6
0
 def __init__(self, coords, elements, neighbors, center):
     self.mb = core.Core()
     self.mtu = topo_util.MeshTopoUtil(self.mb)
     skin = sk.Skinner(self.mb)
     verts = self.mb.create_vertices(coords)
     import pdb; pdb.set_trace()
     rs = self.mb.get_root_set()
     #import pdb; pdb.set_trace()
     #import pdb; pdb.set_trace()
     import pdb; pdb.set_trace()
     elements = elements + np.ones(elements.shape)
     tag_handle = self.mb.tag_get_handle("Teste", 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.construct_aentities(verts)
     elements = self.mb.get_entities_by_dimension(0, 3)
     for index,el in enumerate(elements):
         self.mb.tag_set_data(tag_handle,el,index)
     self.mb.write_file("delaunayVIEW.vtk")
Esempio n. 7
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)
Esempio n. 8
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)

    mskn = skinner.Skinner(mb)

    rs = mb.get_root_set()
    skin_verts = mskn.find_geometric_skin(rs)

    CHECK_EQ(len(skin_verts), 8)
Esempio n. 9
0
 def skinner_operation(self):
     self.skin = sk.Skinner(self.mb)
     if self.dimension == 3:
         faces_on_skin_handles = self.skin.find_skin(0, self.all_volumes)
         edges_on_skin_handles = self.mtu.get_bridge_adjacencies(
             faces_on_skin_handles, 2, 1)
         nodes_on_skin_handles = self.mtu.get_bridge_adjacencies(
             faces_on_skin_handles, 2, 0)
         volumes_on_skin_handles = rng.intersect(
             self.mtu.get_bridge_adjacencies(faces_on_skin_handles, 0, 3),
             self.all_volumes)
     elif self.dimension == 2:
         edges_on_skin_handles = self.skin.find_skin(0, self.all_faces)
         nodes_on_skin_handles = self.mtu.get_bridge_adjacencies(
             edges_on_skin_handles, 1, 0)
         faces_on_skin_handles = rng.intersect(
             self.mtu.get_bridge_adjacencies(edges_on_skin_handles, 0, 2),
             self.all_faces)
         volumes_on_skin_handles = self.mtu.get_bridge_adjacencies(
             edges_on_skin_handles, 0, 3)
     return [
         nodes_on_skin_handles, edges_on_skin_handles,
         faces_on_skin_handles, volumes_on_skin_handles
     ]
Esempio n. 10
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)
pdb.set_trace()
#skin_verts2 = mskn.find_geometric_skin(rs)


#     CHECK_EQ(len(skin_verts), 8)
#
skin_edges = mskn.find_skin(rs, quads, False, False)
CHECK_EQ(len(skin_edges), 8)

# if __name__ == "__main__":
#     tests = [
Esempio n. 11
0
    def __init__(self, coords, elements, neighbors, center):
        #super(DelaunayView, self).__init__()
        self.mb = core.Core()
        self.mtu = topo_util.MeshTopoUtil(self.mb)
        skin = sk.Skinner(self.mb)
        verts = self.mb.create_vertices(coords)
        rs = self.mb.get_root_set()
        #import pdb; pdb.set_trace()
        #import pdb; pdb.set_trace()
        elements = elements + np.ones(elements.shape)

        tag_handle = self.mb.tag_get_handle("Teste", 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.construct_aentities(verts)
        elements = self.mb.get_entities_by_dimension(0, 3)

        for index,el in enumerate(elements):
            self.mb.tag_set_data(tag_handle,el,index)
        #import pdb; pdb.set_trace()
        bfaces = skin.find_skin(0, elements)
        print(bfaces)
        adj = np.array([(self.mb.get_connectivity(bface)) for bface in bfaces])
        adj = adj.reshape((len(adj), 3)).astype(int) - np.ones(adj.shape)
        missing = np.setdiff1d(np.where(~np.isin(neighbors,adj)), center)
        import pdb; pdb.set_trace()
        # finding boundary tetrahedron
        self.mb.write_file("delaunay01.vtk")
        emp = rng.Range()
        boundary_tetrahedron = rng.Range()
        for el in elements:
            boundary_intersect = rng.intersect(bfaces, self.mb.get_adjacencies(el, 2))
            if boundary_intersect is not emp:
                boundary_tetrahedron = rng.unite(boundary_tetrahedron, rng.Range(el))


        # for el in elements:
        #     #import pdb; pdb.set_trace()
        #     local = rng.Range(el)
        #     boundary_intersect = rng.intersect(bfaces, self.mb.get_adjacencies(local, 2))
        #     if boundary_intersect is not emp:
        #         # import pdb; pdb.set_trace()
        #         face_con = self.mb.get_adjacencies(boundary_intersect,0)
        #         el_con = self.mb.get_adjacencies(local, 0)
        #             #import pdb; pdb.set_trace()
        #         inside_node = int(rng.subtract(el_con, face_con)[0] - 1)
        #
        #         #inside_node = int(np.setdiff1d(el_con, face_con)[0] - 1)
        #         #import pdb; pdb.set_trace()
        #         #check if inside node is missing
        #         is_missing = bool(np.isin(inside_node, missing))
        #         if is_missing is True:
        #             boundary_tetrahedron = rng.unite(boundary_tetrahedron, local)
                #import pdb; pdb.set_trace()


        for el in boundary_tetrahedron:
            self.mb.tag_set_data(tag_handle,el,2)
            print(self.mb.get_connectivity(el))
        #print(boundary_tetrahedron)
        import pdb; pdb.set_trace()

        #self.mb.delete_entity(boundary_tetrahedron)
        print(boundary_tetrahedron)
        self.mb.write_file("delaunay02.vtk")
Esempio n. 12
0
 def skinner(self, range):
     skin = sk.Skinner(self.mb)
     return skin.find_skin(self.rs,range)
Esempio n. 13
0
def laplacian_smooth(mb, maxiter):
    """Generates a uniform grid in a moab instance (mb) meshset which is representative of the yt grid dataset (ds)"""

    #create a meshset for this grid
    rs = mb.get_root_set()
    ldim = 3
    for idim in [3, 2, 1]:
        if len(mb.get_entities_by_dimension(rs, idim)) > 0:
            ldim = idim
            melems = mb.get_entities_by_dimension(rs, 2)
            break

    mverts = mb.get_entities_by_dimension(rs, 0)

    print("The " + str(ldim) + "-d mesh contains " + str(mverts.size()) +
          " vertices and " + str(melems.size()) + " elements!")

    # Compute the skin and fix the boundary vertices - these should not be moved
    sknr = skinner.Skinner(mb)
    skin_verts = sknr.find_skin(rs, melems, True, False)
    print("Found " + str(skin_verts.size()) + " boundary vertices in the mesh")

    # Now let us set the new "smoothed" coordinate to the vertex
    oldvtxcoords = mb.get_coords(mverts)
    # size of coords: (3 * mverts.size())
    newvtxcoords = np.copy(oldvtxcoords)

    mtu = topo_util.MeshTopoUtil(mb)
    iter = 0
    while iter < maxiter:
        ivtx = 0
        print('Laplacian smoothing iteration: ' + str(iter))
        for vtx in mverts:
            if vtx in skin_verts:
                ivtx += 1
                continue

            # Not a fixed node - lets apply our smoothing algorithm
            adjs = mtu.get_bridge_adjacencies(vtx, bridge_dim=ldim, to_dim=0)
            vtxcoords = mb.get_coords(adjs)
            avgcoords = np.zeros(3)
            i = 0
            while i < len(adjs):

                avgcoords[0] += vtxcoords[i * 3 + 0]
                avgcoords[1] += vtxcoords[i * 3 + 1]
                avgcoords[2] += vtxcoords[i * 3 + 2]
                i += 1

            avgcoords /= i
            newvtxcoords[ivtx * 3 + 0] = avgcoords[0]
            newvtxcoords[ivtx * 3 + 1] = avgcoords[1]
            newvtxcoords[ivtx * 3 + 2] = avgcoords[2]
            ivtx += 1

        # Now let us set the new "smoothed" coordinate to the vertex
        mb.set_coords(mverts, newvtxcoords)

        coorderr = np.linalg.norm(newvtxcoords - oldvtxcoords)
        print("\t L_2 Error in iterate = %.6e" % coorderr)
        oldvtxcoords = np.copy(newvtxcoords)
        iter += 1

    #return the grid meshset
    return rs