def set_dirichlet_boundary_conditions(self, bc_func, dirichlet_faces=None): if dirichlet_faces is None: all_faces = self.mb.get_entities_by_dimension(0, 2) dirichlet_faces = [face for face in all_faces \ if len(self.mtu.get_bridge_adjacencies(face, 2, 3)) < 2] self.mb.tag_set_data(self.dirichlet_tag, dirichlet_faces, np.zeros(len(dirichlet_faces))) dirichlet_nodes = self.mtu.get_bridge_adjacencies( rng.Range(dirichlet_faces), 2, 0) dirichlet_nodes_coords = self.mb.get_coords(dirichlet_nodes).reshape( len(dirichlet_nodes), 3) bc_values = [ bc_func(node[0], node[1], node[2]) for node in dirichlet_nodes_coords ] self.mb.tag_set_data(self.dirichlet_tag, dirichlet_nodes, bc_values)
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[:]) 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 = ([ 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 ]
def bridge_adjacencies(self, handle, dim): # lacks support for indexing with multiple numbers if dim == 3: all_bridge = [ self.mtu.get_bridge_adjacencies(el, 2, 3) for el in handle ] else: all_bridge = [ self.mtu.get_bridge_adjacencies(el, 1, 2) for el in handle ] inside_meshset = self.mb.get_entities_by_handle(self.root_set) all_brige_in_meshset = np.array([ rng.intersect(el_handle, inside_meshset) for el_handle in all_bridge ]) size_brige = np.array( [len(el_handle) for el_handle in all_brige_in_meshset]) handles = np.asarray(handle)[size_brige == 1].astype("uint") return rng.Range(handles)
def get_boundary_of_volumes(mb, elements): """ input: mb: core of pymoab elements: meshset or elements of the mesh output: boundary of meshset or elements """ faces = UtilsPymoab.get_faces(mb, elements) bound_faces = [] for face in faces: elems = mb.get_adjacencies(face, 3) if len(elems) < 2: bound_faces.append(face) elif elems[0] in elements and elems[1] not in elements: bound_faces.append(face) elif elems[1] in elements and elems[0] not in elements: bound_faces.append(face) return rng.Range(bound_faces)
def find_simple_bad(self): index = 0 point_type = np.concatenate((np.array([-1]), self.point_type)) missing = self.find_missing_nodes() coord = self.mb.get_coords(self.nodes).reshape(-1,3)] remov = rng.Range() while not self.condition(): index = index + 1 connect = self.connectivities(self.boundary_elements, 4) all_tetra_ref = np.arange(connect.shape[0]) flag = point_type[connect] for el in missing: tetra_analize = np.any(np.isin(connect, el), axis=1) np.unique(connect[tetra_analize]) tet_coord = (connect[tetra_analize] - np.ones(connect[tetra_analize].shape)).astype("uint64") #tet_coord1 = (connect - np.ones(connect.shape)).astype("uint64") vol_tetra = volume_p(coord[tet_coord]) removable = self.select(self.boundary_elements, all_tetra_ref[tetra_analize][vol_tetra == vol_tetra.min()][0]) remov = rng.unite(remov,removable) self.create_vtk() import pdb; pdb.set_trace() self.remove_vol(removable)
def set_neumann_boundary_conditions(self, grad_u, neumann_faces=None): C = CoordSys3D('C') if neumann_faces is None: all_faces = self.mb.get_entities_by_dimension(0, 2) neumann_faces = [face for face in all_faces \ if len(self.mtu.get_bridge_adjacencies(face, 2, 3)) < 2] bc_values = [] for face in neumann_faces: I, J, K = self.mtu.get_bridge_adjacencies(face, 2, 0) avg_pos = self.mtu.get_average_position([I, J, K]) JI = self.mb.get_coords([I]) - self.mb.get_coords([J]) JK = self.mb.get_coords([K]) - self.mb.get_coords([J]) normal_area_vec = np.cross(JI, JK) normal_area_vec /= norm(normal_area_vec) grad_u_face = np.array(grad_u.subs({C.x: avg_pos[0], \ C.y: avg_pos[1], \ C.z: avg_pos[2]}), dtype=float).reshape(3) bc_values.append(np.dot(grad_u_face, normal_area_vec)) self.mb.tag_set_data(self.neumann_tag, neumann_faces, bc_values) neumann_nodes = self.mtu.get_bridge_adjacencies( rng.Range(neumann_faces), 2, 0) self.mb.tag_set_data(self.neumann_tag, neumann_nodes, np.zeros(len(neumann_nodes)))
def enhance(self, i, general): self.coarse_neighbors_dic = {} if self.vID == 0: self.coarse_neighbors_dic = { key[1]: value for key, value in general.nodes_neighbors.items() if key[0] == i } elif self.vID == 1: self.coarse_neighbors_dic = { key[1]: value for key, value in general.edges_neighbors.items() if key[0] == i } elif self.vID == 2: self.coarse_neighbors_dic = { key[1]: value for key, value in general.faces_neighbors.items() if key[0] == i } elif self.vID == 3: self.coarse_neighbors_dic = { key[1]: value for key, value in general.volumes_neighbors.items() if key[0] == i } self.coarse_neighbors = np.array([ key for key, value in self.coarse_neighbors_dic.items() if not value.empty() ]) self.all_coarse_neighbors_range = rng.Range() for el in self.coarse_neighbors_dic.values(): self.all_coarse_neighbors_range = rng.unite( self.all_coarse_neighbors_range, el) self.elements_in_coarse_neighborhood = GetItem( self._elements_in_coarse_neighborhood)
#box_volumes_n = np.array([np.array([y2, y2, y2]), np.array([y0, y0, y0])]) tio=time.time() box_volumes_d = np.array([np.array([0.0, 0.0, 0.0]), np.array([y1, y0, y0])]) box_volumes_n = np.array([np.array([y2, 0.0, 0.0]), np.array([y0, y0, y0])]) # volumes com pressao prescrita inds0 = np.where(all_centroids[:,0] > box_volumes_d[0,0])[0] inds1 = np.where(all_centroids[:,1] > box_volumes_d[0,1])[0] inds2 = np.where(all_centroids[:,2] > box_volumes_d[0,2])[0] c1 = set(inds0) & set(inds1) & set(inds2) inds0 = np.where(all_centroids[:,0] < box_volumes_d[1,0])[0] inds1 = np.where(all_centroids[:,1] < box_volumes_d[1,1])[0] inds2 = np.where(all_centroids[:,2] < box_volumes_d[1,2])[0] c2 = set(inds0) & set(inds1) & set(inds2) inds_vols_d = list(c1 & c2) volumes_d = rng.Range(np.array(M1.all_volumes)[inds_vols_d]) # volumes com vazao prescrita inds0 = np.where(all_centroids[:,0] > box_volumes_n[0,0])[0] inds1 = np.where(all_centroids[:,1] > box_volumes_n[0,1])[0] inds2 = np.where(all_centroids[:,2] > box_volumes_n[0,2])[0] c1 = set(inds0) & set(inds1) & set(inds2) inds0 = np.where(all_centroids[:,0] < box_volumes_n[1,0])[0] inds1 = np.where(all_centroids[:,1] < box_volumes_n[1,1])[0] inds2 = np.where(all_centroids[:,2] < box_volumes_n[1,2])[0] c2 = set(inds0) & set(inds1) & set(inds2) inds_vols_n = list(c1 & c2) volumes_n = rng.Range(np.array(M1.all_volumes)[inds_vols_n]) inds_pocos = inds_vols_d + inds_vols_n Cent_wels = all_centroids[inds_pocos]
w = data_loaded['Wells_structured'][well] if w['type_region'] == 'box': box_volumes = np.array( [np.array(w['region1']), np.array(w['region2'])]) inds0 = np.where(all_centroids[:, 0] > box_volumes[0, 0])[0] inds1 = np.where(all_centroids[:, 1] > box_volumes[0, 1])[0] inds2 = np.where(all_centroids[:, 2] > box_volumes[0, 2])[0] c1 = set(inds0) & set(inds1) & set(inds2) inds0 = np.where(all_centroids[:, 0] < box_volumes[1, 0])[0] inds1 = np.where(all_centroids[:, 1] < box_volumes[1, 1])[0] inds2 = np.where(all_centroids[:, 2] < box_volumes[1, 2])[0] c2 = set(inds0) & set(inds1) & set(inds2) inds_vols = list(c1 & c2) inds_wells += inds_vols volumes = rng.Range(np.array(M1.all_volumes)[inds_vols]) else: raise NameError("Defina o tipo de regiao em type_region: 'box'") value = float(w['value']) if w['type_prescription'] == 'dirichlet': if gravity == False: pressao = np.repeat(value, len(volumes)) else: z_elems_d = -1 * np.array( [M1.mtu.get_average_position([v])[2] for v in volumes]) delta_z = z_elems_d + Lz pressao = M1.gama * (delta_z) + press
def select(self, range, vec): return rng.Range(np.array(range)[vec])
def range_merge(*args): range_merged = rng.Range() for arg in args: range_merged.merge(arg) return range_merged
def get_op_adm_nv1(mb, all_volumes, map_wire_lv0, OP1, vertex_elems): nc_primal_tag_1 = mb.tag_get_handle('NC_PRIMAL_1') lv1_id_tag = mb.tag_get_handle(ProlongationTPFA3D.name_l1_id) level_tag = mb.tag_get_handle(ProlongationTPFA3D.name_l3_id) vertex_elems = rng.Range(vertex_elems) elems_nv0 = mb.get_entities_by_type_and_tag(mb.get_root_set(), types.MBHEX, level_tag, np.array([1])) ids_adm_nv1_elems_nv0 = mb.tag_get_data(lv1_id_tag, elems_nv0, flat=True) ids_wirebasket_elems_nv0 = np.array( [map_wire_lv0[v] for v in elems_nv0]) ids_adm_lv1 = mb.tag_get_data(lv1_id_tag, all_volumes, flat=True) max_id_lv1 = ids_adm_lv1.max() n = len(all_volumes) OP_adm_nv1 = sp.lil_matrix((n, max_id_lv1 + 1)) meshsets = mb.get_entities_by_type_and_tag(mb.get_root_set(), types.MBENTITYSET, np.array([nc_primal_tag_1]), np.array([None])) x = ids_wirebasket_elems_nv0 for meshset in meshsets: elems = mb.get_entities_by_handle(meshset) vertex = rng.intersect(elems, vertex_elems) id_lv1_vertex = mb.tag_get_data(lv1_id_tag, vertex, flat=True)[0] # inter = rng.intersect(elems_nv0, elems) # # if len(inter) > 0: # # continue nc = mb.tag_get_data(nc_primal_tag_1, meshset, flat=True)[0] # col_op = OP1[:,nc] # indices = sp.find(col_op) indices = sp.find(OP1[:, nc]) y = indices[0] vals = indices[2] # xy = np.intersect1d(x, y) # if len(xy) > 0: # retirar = [] # for i in xy: # inds = np.where(y == i)[0][0] # retirar.append(inds) # # retirar = np.array(retirar) # y = np.delete(y, retirar) # vals = np.delete(vals, retirar) # # col_op_adm = mb.tag_get_data(lv1_id_tag, elems, flat=True)[0] col_op_adm = id_lv1_vertex col_op_adm = np.repeat(col_op_adm, len(y)) OP_adm_nv1[y, col_op_adm] = vals for i in ids_wirebasket_elems_nv0: OP_adm_nv1[i] = np.zeros(max_id_lv1 + 1) OP_adm_nv1[ids_wirebasket_elems_nv0, ids_adm_nv1_elems_nv0] = np.ones(len(ids_adm_nv1_elems_nv0)) return OP_adm_nv1
inds_wells = [] for well in data_loaded['Wells_structured']: w = data_loaded['Wells_structured'][well] if w['type_region'] == 'box': box_volumes = np.array([np.array(w['region1']), np.array(w['region2'])]) inds0 = np.where(all_centroids[:,0] > box_volumes[0,0])[0] inds1 = np.where(all_centroids[:,1] > box_volumes[0,1])[0] inds2 = np.where(all_centroids[:,2] > box_volumes[0,2])[0] c1 = set(inds0) & set(inds1) & set(inds2) inds0 = np.where(all_centroids[:,0] < box_volumes[1,0])[0] inds1 = np.where(all_centroids[:,1] < box_volumes[1,1])[0] inds2 = np.where(all_centroids[:,2] < box_volumes[1,2])[0] c2 = set(inds0) & set(inds1) & set(inds2) inds_vols = list(c1 & c2) inds_wells += inds_vols volumes = rng.Range(np.array(all_volumes)[inds_vols]) else: raise NameError("Defina o tipo de regiao em type_region: 'box'") value = float(w['value']) if w['type_prescription'] == 'dirichlet': bvd.append(box_volumes) volumes_d += list(volumes) if gravity == False: pressao = np.repeat(value, len(volumes)) else: z_elems_d = -1*mb.tag_get_data(cent_tag, volumes)[:,2] delta_z = z_elems_d + Lz pressao = gama*(delta_z) + value
def GenerateLv1(self, tag_primal, tag_lv_id, level, centroid_tag): vols_lv_0 = self.gen_lv.mb.get_entities_by_type_and_tag( self.gen_lv.mb.get_root_set(), types.MBHEX, np.array([self.level_tag]), np.array([level - 1])) n1 = len(vols_lv_0) ms0 = set() ms_current = set() meshsets_current_level = self.gen_lv.mb.get_entities_by_type_and_tag( self.gen_lv.mb.get_root_set(), types.MBENTITYSET, np.array([tag_primal]), np.array([None])) centroids = self.gen_lv.mb.tag_get_data(centroid_tag, meshsets_current_level) ## verificando quais volumes permanecem no nivel anterior for meshset in meshsets_current_level: elems_in_meshset = self.gen_lv.mb.get_entities_by_handle(meshset) inter = rng.intersect(elems_in_meshset, vols_lv_0) if len(inter) > 0: ms0.add(meshset) self.meshsets_with_levels.add(meshset) self.gen_lv.mb.tag_set_data( self.level_tag, elems_in_meshset, np.repeat(level - 1, len(elems_in_meshset))) vols_lv_0 = rng.unite(vols_lv_0, elems_in_meshset) self.elems_with_level = rng.Range(vols_lv_0) ## verificando quais volumes sao vizinhos dos do nivel anterior ms2 = [] for meshset in ms0: vizs = utpy.get_meshsets_viz_vertex(self.gen_lv.mb, meshset, meshsets_current_level) for m in vizs: if m in ms0: continue elems = self.gen_lv.mb.get_entities_by_handle(m) self.meshsets_with_levels.add(m) self.gen_lv.mb.tag_set_data(self.level_tag, elems, np.repeat(level, len(elems))) ms2.append(m) self.elems_with_level = rng.unite(self.elems_with_level, elems) centroids2 = self.gen_lv.mb.tag_get_data(centroid_tag, ms2) ################################################################################ ## verificando quais volumes que ficam no nivel atual dada uma certa distancia ## obs: descomentar # for meshset, centroid in zip(ms2, centroids2): # dists = centroids - centroid # dists = np.array(list(map(CalculateDistance, dists))) # dists = dists < self.rs[level] # meshsets = np.array(meshsets_current_level)[dists] # if len(meshsets) > 0: # for m in meshsets: # if m in ms2 or m in ms0: # continue # self.meshsets_with_levels.add(m) # elems = self.gen_lv.mb.get_entities_by_handle(m) # self.gen_lv.mb.tag_set_data(self.level_tag, elems, np.repeat(level, len(elems))) # self.elems_with_level = rng.unite(self.elems_with_level, elems) ################################################################################## # n = len(vols_lv_0) # self.gen_lv.mb.tag_set_data(tag_lv_id, vols_lv_0, np.arange(0, n)) ################################################################ n = 0 for m in meshsets_current_level: elems = self.gen_lv.mb.get_entities_by_handle(m) if m in ms0: n2 = len(elems) self.gen_lv.mb.tag_set_data(tag_lv_id, elems, np.arange(n, n + n2)) n += n2 else: self.gen_lv.mb.tag_set_data(tag_lv_id, elems, np.repeat(n, len(elems))) n += 1
def __call__(self, item): tmp = self.dic[item] el_list = rng.Range() for e in tmp: el_list.insert(e[0]) return self.fun(self.tag, el_list)
def find_coarse_neighbours2(self): self.all_nodes_neighbors = rng.Range() self.all_edges_neighbors = rng.Range() self.all_faces_neighbors = rng.Range() self.all_volumes_neighbors = rng.Range() self._faces_neighbors = lil_matrix( (self.num_coarse, self.num_coarse + 1), dtype=np.uint32) self._edges_neighbors = lil_matrix( (self.num_coarse, self.num_coarse + 1), dtype=np.uint32) self._nodes_neighbors = lil_matrix( (self.num_coarse, self.num_coarse + 1), dtype=np.uint32) self.faces_connectivities = lil_matrix( (self.num_coarse, self.num_coarse + 1), dtype=np.bool) self.edges_connectivities = lil_matrix( (self.num_coarse, self.num_coarse + 1), dtype=np.bool) self.nodes_connectivities = lil_matrix( (self.num_coarse, self.num_coarse + 1), dtype=np.bool) faces_array = self.M.core.internal_faces.get_array() adj_array = self.mb.get_ord_adjacencies(faces_array, 3)[0] tg = self.mb.tag_get_handle('Partition') boundaries = self.M.core.boundary_faces.get_array() boundary_vol = self.M.core.mb.get_ord_adjacencies(boundaries, 3)[0] self.all_volumes_neighbors.insert(boundary_vol) self.all_faces_neighbors.insert(boundaries) parts = self.mb.tag_get_data(tg, adj_array).reshape(-1, 2) boundary_parts = self.mb.tag_get_data(tg, boundary_vol, flat=True) indx = np.where(parts[:, 0] != parts[:, 1])[0] parts = parts[indx] inters_faces = faces_array[indx] self._faces, self.num_internal_faces = self.M.core.mb.get_interface_faces2( self.faces_connectivities, parts, inters_faces, boundaries, boundary_parts, self.num_coarse, self._faces_neighbors) print('Matrix of coarse faces adjacencies created') if (inters_faces.size == 0): inters_edges = np.array([], dtype=np.uint64) indx = np.array([], dtype=np.int64) coarse_jagged = np.array([], dtype=np.uint64) else: self.all_faces_neighbors.insert(inters_faces) self.all_volumes_neighbors.insert( adj_array.reshape(-1, 2)[indx].ravel()) inters_edges = np.unique( self.mb.get_ord_adjacencies(inters_faces, 1)[0]) self.all_edges_neighbors.insert(inters_edges) aux_tuple = self.M.core.mb.get_ord_adjacencies(inters_edges, 3) temp_jagged = np.delete( np.array(np.split(aux_tuple[0], aux_tuple[1]), dtype=object), -1) jagged_index = np.array( [temp_jagged[i].size for i in range(temp_jagged.shape[0])], dtype=np.int32) jagged_index = np.cumsum(jagged_index, dtype=np.int32)[:-1] coarse_array = self.M.core.mb.tag_get_data( tg, np.concatenate(temp_jagged), flat=True) coarse_jagged = np.array(np.split(coarse_array, jagged_index), dtype=object) coarse_jagged = np.array([ np.unique(coarse_jagged[i]) for i in range(coarse_jagged.shape[0]) ], dtype=object) indx = np.array([ coarse_jagged[i].size > 2 for i in range(coarse_jagged.shape[0]) ]) boundaries = self.M.core.boundary_edges.get_array() self.all_edges_neighbors.insert(boundaries) aux_tuple = self.M.core.mb.get_ord_adjacencies(boundaries, 3) temp_jagged = np.delete( np.array(np.split(aux_tuple[0], aux_tuple[1]), dtype=object), -1) jagged_index = np.array( [temp_jagged[i].size for i in range(temp_jagged.shape[0])], dtype=np.int32) jagged_index = np.cumsum(jagged_index, dtype=np.int32)[:-1] boundary_parts = self.M.core.mb.tag_get_data( tg, np.concatenate(temp_jagged), flat=True) boundary_parts = np.array(np.split(boundary_parts, jagged_index), dtype=object) boundary_parts = np.array([ np.unique(boundary_parts[i]).astype(np.int32) for i in range(boundary_parts.shape[0]) ], dtype=np.object) self._edges, self.num_internal_edges = self.M.core.mb.get_interface_entities2( self.edges_connectivities, inters_edges, coarse_jagged, indx, boundaries, boundary_parts, self.num_coarse, self._edges_neighbors) print('Matrix of coarse edges adjacencies created') if (inters_faces.size == 0): inters_nodes = np.array([], dtype=np.uint64) indx = np.array([], dtype=np.int64) coarse_jagged = np.array([], dtype=np.uint64) else: inters_nodes = np.unique( self.mb.get_ord_adjacencies(inters_faces, 0)[0]) self.all_nodes_neighbors.insert(inters_nodes) aux_tuple = self.M.core.mb.get_ord_adjacencies(inters_nodes, 3) temp_jagged = np.delete( np.array(np.split(aux_tuple[0], aux_tuple[1]), dtype=object), -1) jagged_index = np.array( [temp_jagged[i].size for i in range(temp_jagged.shape[0])], dtype=np.int32) jagged_index = np.cumsum(jagged_index, dtype=np.int32)[:-1] coarse_array = self.M.core.mb.tag_get_data( tg, np.concatenate(temp_jagged), flat=True) coarse_jagged = np.array(np.split(coarse_array, jagged_index), dtype=object) coarse_jagged = np.array([ np.unique(coarse_jagged[i]) for i in range(coarse_jagged.shape[0]) ], dtype=object) indx = np.array([ coarse_jagged[i].size > 2 for i in range(coarse_jagged.shape[0]) ]) boundaries = self.M.core.boundary_nodes.get_array() self.all_nodes_neighbors.insert(boundaries) aux_tuple = self.M.core.mb.get_ord_adjacencies(boundaries, 3) temp_jagged = np.delete( np.array(np.split(aux_tuple[0], aux_tuple[1]), dtype=object), -1) jagged_index = np.array( [temp_jagged[i].size for i in range(temp_jagged.shape[0])], dtype=np.int32) jagged_index = np.cumsum(jagged_index, dtype=np.int32)[:-1] boundary_parts = self.M.core.mb.tag_get_data( tg, np.concatenate(temp_jagged), flat=True) boundary_parts = np.array(np.split(boundary_parts, jagged_index), dtype=object) boundary_parts = np.array([ np.unique(boundary_parts[i]) for i in range(boundary_parts.shape[0]) ], dtype=object) self._nodes, self.num_internal_nodes = self.M.core.mb.get_interface_entities2( self.nodes_connectivities, inters_nodes, coarse_jagged, indx, boundaries, boundary_parts, self.num_coarse, self._nodes_neighbors) print('Matrix of coarse nodes adjacencies created') self._faces_neighbors = self._faces_neighbors.tocsr() self._edges_neighbors = self._edges_neighbors.tocsr() self._nodes_neighbors = self._nodes_neighbors.tocsr() self.faces_connectivities = self.faces_connectivities.tocsr() self.edges_connectivities = self.edges_connectivities.tocsr() self.nodes_connectivities = self.nodes_connectivities.tocsr() self.connectivities = (self.nodes_connectivities, self.edges_connectivities, self.faces_connectivities) return
def calculate_pcorr(self, elems_in_meshset, vertice, faces_boundary, faces, k): mb = self.mb mobi_in_faces_tag = self.tags['MOBI_IN_FACES'] pms_tag = self.tags['PMS2'] s_grav_tag = self.tags['S_GRAV'] pcorr_tag = self.tags['PCORR2'] allmobis = mb.tag_get_data(mobi_in_faces_tag, faces, flat=True) try: vols3 = self.mtu.get_bridge_adjacencies(faces_boundary, 2, 3) except: import pdb pdb.set_trace() vols_inter = rng.subtract(vols3, elems_in_meshset) pms_vols3 = self.mb.tag_get_data(pms_tag, vols3, flat=True) map_pms_vols3 = dict(zip(vols3, pms_vols3)) del pms_vols3 volumes_2 = self.mtu.get_bridge_adjacencies(elems_in_meshset, 2, 3) if self.gravity: s_gravs = mb.tag_get_data(s_grav_tag, faces, flat=True) else: s_gravs = np.zeros(len(faces)) n = len(elems_in_meshset) map_local = dict(zip(elems_in_meshset, range(n))) lines = [] cols = [] data = [] b = np.zeros(n) Adjs = [self.mb.get_adjacencies(face, 3) for face in faces] faces_in = rng.subtract(faces, faces_boundary) map_id_faces = dict(zip(faces, range(len(faces)))) for face in faces_in: id_face = map_id_faces[face] mobi = allmobis[id_face] s_g = -s_gravs[id_face] id_face = map_id_faces[face] elem0 = Adjs[id_face][0] elem1 = Adjs[id_face][1] id0 = map_local[elem0] id1 = map_local[elem1] b[id0] += s_g b[id1] -= s_g lines += [id0, id1] cols += [id1, id0] data += [mobi, mobi] for face in faces_boundary: id_face = map_id_faces[face] mobi = allmobis[id_face] s_g = -s_gravs[id_face] elem0 = Adjs[id_face][0] elem1 = Adjs[id_face][1] vvv = True try: id = map_local[elem0] except KeyError: id = map_local[elem1] vvv = False flux = -(map_pms_vols3[elem1] - map_pms_vols3[elem0]) * mobi if vvv: b[id] += s_g + flux else: b[id] -= s_g + flux T = sp.csc_matrix((data, (lines, cols)), shape=(n, n)) T = T.tolil() d1 = np.array(T.sum(axis=1)).reshape(1, n)[0] * (-1) T.setdiag(d1) d_vols = rng.Range(vertice) map_values = dict( zip(d_vols, mb.tag_get_data(pms_tag, d_vols, flat=True))) T, b = oth.set_boundary_dirichlet_matrix(map_local, map_values, b, T) x = oth.get_solution(T, b) mb.tag_set_data(pcorr_tag, elems_in_meshset, x)
def main(): global nx, ny, nz, dx, dy, dz, num_elements # Getting user input for number of elements and size in each axis. if len(sys.argv) == 7: nx = int(sys.argv[1]) ny = int(sys.argv[3]) nz = int(sys.argv[5]) dx = float(sys.argv[2]) dy = float(sys.argv[4]) dz = float(sys.argv[6]) dim = 2 num_elements = nx*ny*nz num_vertex = (nx+1)*(ny+1)*(nz+1) else: print("Not enough arguments") return # New instance of MOAB Core mbcore = core.Core() # Initializing array with vertices coordinates. The array looks like # [x y z x y z ...]. print("Creating vertices coordinates") ts = time.time() vertex_coords = np.zeros(num_vertex*3) for i in range(num_vertex): vertex_coords[3*i] = (i % (nx+1))*dx vertex_coords[3*i+1] = ((i // (nx+1)) % (ny+1))*dy vertex_coords[3*i+2] = ((i // ((nx+1)*(ny+1))) % (nz+1))*dz print("Done\nTime elapsed: {0}\n".format(time.time() - ts)) # Create entity handles for the vertices. vertex_handles = mbcore.create_vertices(vertex_coords) # Getting the connectivity of each element, i.e., the vertices that make up # an element. print("Creating connectivity") ts = time.time() mesh_connectivity = create_mesh_connectivity(vertex_handles, vertex_coords) print("Done\nTime elapsed: {0}\n".format(time.time() - ts)) # Creates the element corresponding to each connectivity. print("Creating element handles") ts = time.time() elem_handles = rng.Range([mbcore.create_element(types.MBHEX, x) for x in mesh_connectivity]) print("Done\nTime elapsed: {0}\n".format(time.time() - ts)) # Setting up tags for permeability and centroid coordinates for each element. print("Creating and setting tags") ts = time.time() centroid_tag = mbcore.tag_get_handle('Centroid', 3, types.MB_TYPE_DOUBLE, \ types.MB_TAG_DENSE, True) permeability_tag = mbcore.tag_get_handle('Permeability', 3, types.MB_TYPE_DOUBLE, \ types.MB_TAG_DENSE, True) dirichlet_tag = mbcore.tag_get_handle('DirichletBC', 1, types.MB_TYPE_DOUBLE, \ types.MB_TAG_DENSE, True) neumann_tag = mbcore.tag_get_handle('NeumannBC', 1, types.MB_TYPE_DOUBLE, \ types.MB_TAG_DENSE, True) centroid_coord = np.array([[vertex_coords[3*int(v[0]-1)] + (dx/2), \ vertex_coords[3*int(v[0]-1)+1] + (dy/2), \ vertex_coords[3*int(v[0]-1)+2] + (dz/2)] \ for v in mesh_connectivity]) permeability = np.array([[1.0,1.0,1.0] for i in range(num_elements)]) mbcore.tag_set_data(centroid_tag, elem_handles, centroid_coord) mbcore.tag_set_data(permeability_tag, elem_handles, permeability) print("Done\nTime elapsed: {0}\n".format(time.time() - ts)) print("Writing .h5m file") mbcore.write_file("tpfa_mesh.h5m") ts = time.time() print("Done\nTime elapsed: {0}\n".format(time.time() - ts))
def get_OP_adm_nv2(mb, all_volumes, wirebasket_ids_nv1, OP_AMS2, L1_ID_tag, L2_ID_tag, L3_ID_tag, primal_id_tag1, primal_id_tag2): # elems_nv0 = mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([L3_ID_tag]), np.array([1])) # elems_nv1 = mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([L3_ID_tag]), np.array([2])) # elems_nv2 = rng.subtract(all_volumes, rng.unite(elems_nv0, elems_nv1)) # verts_nv2 = rng.subtract(elems_verts_nv2, elems_nv0) all_ids_adm_nv1 = np.unique(mb.tag_get_data(L1_ID_tag, all_volumes, flat=True)) all_ids_adm_nv2 = np.unique(mb.tag_get_data(L2_ID_tag, all_volumes, flat=True)) OP_adm_nv2 = sp.lil_matrix((len(all_ids_adm_nv1), len(all_ids_adm_nv2))) meshsets_nv2 = mb.get_entities_by_type_and_tag(0, types.MBENTITYSET, np.array([primal_id_tag2]), np.array([None])) meshsets_nv1_que_estao_no_nv2 = [] id_adm_lv2_dos_meshsets_nv1_que_estao_no_nv2 = [] id_adm_lv1_dos_meshsets_nv1_que_estao_no_nv2 = [] todos_meshsets_que_estao_no_nivel_1 = [] ids_adm_nv1_de_todos_meshsets_que_estao_no_nivel_1 = [] for m2 in meshsets_nv2: childs = mb.get_child_meshsets(m2) for m in childs: # mb.add_parent_meshset(m, m2) elems = mb.get_entities_by_handle(m) id_adm_nv1 = np.unique(mb.tag_get_data(L1_ID_tag, elems, flat=True)) if len(id_adm_nv1) > 1: continue todos_meshsets_que_estao_no_nivel_1.append(m) ids_adm_nv1_de_todos_meshsets_que_estao_no_nivel_1.append(id_adm_nv1[0]) elems = mb.get_entities_by_handle(m2) id_lv2 = np.unique(mb.tag_get_data(L2_ID_tag, elems, flat=True)) if len(id_lv2) > 1: continue meshsets_nv1_que_estao_no_nv2.append(childs) id_adm_lv2_dos_meshsets_nv1_que_estao_no_nv2.append(id_lv2[0]) ids_adm_lv1 = [] for m in childs: elems_1 = mb.get_entities_by_handle(m) id_adm_lv1 = np.unique(mb.tag_get_data(L1_ID_tag, elems_1, flat=True)) ids_adm_lv1.append(id_adm_lv1) id_adm_lv1_dos_meshsets_nv1_que_estao_no_nv2.append(ids_adm_lv1[:]) ncs_de_todos_meshsets_que_estao_no_nivel_1 = mb.tag_get_data(primal_id_tag1, todos_meshsets_que_estao_no_nivel_1, flat=True) map_ncs_de_todos_meshsets_que_estao_no_nivel_1_in_id_adm_1 = dict(zip(ncs_de_todos_meshsets_que_estao_no_nivel_1, ids_adm_nv1_de_todos_meshsets_que_estao_no_nivel_1)) map_todos_meshsets_que_estao_no_nivel_1_in_id_adm_1 = dict(zip(todos_meshsets_que_estao_no_nivel_1, ids_adm_nv1_de_todos_meshsets_que_estao_no_nivel_1)) nc_vertex_elems = wirebasket_ids_nv1[3] meshsets_vertex_elems_nv1 = [mb.get_entities_by_type_and_tag( mb.get_root_set(), types.MBENTITYSET, np.array([primal_id_tag1]), np.array([i]))[0] for i in nc_vertex_elems] vertices_pi_chapeu = [] ids_lv2_vertices_pi_chapeu = [] for m in meshsets_vertex_elems_nv1: if m in todos_meshsets_que_estao_no_nivel_1: vertices_pi_chapeu.append(m) elems = mb.get_entities_by_handle(m) id_lv2_adm = np.unique(mb.tag_get_data(L2_ID_tag, elems, flat=True)) ids_lv2_vertices_pi_chapeu.append(id_lv2_adm) for i, m in enumerate(vertices_pi_chapeu): id_adm_lv2_vertice = ids_lv2_vertices_pi_chapeu[i] parent_meshset = mb.get_parent_meshsets(m) nc2 = mb.tag_get_data(primal_id_tag2, parent_meshset, flat=True)[0] col_op2 = OP_AMS2[:,nc2] indices = sp.find(col_op2) nc_vert_pi_chapeu_nv1 = mb.tag_get_data(primal_id_tag1, m, flat=True)[0] # print(indices) # print(nc_vert_pi_chapeu_nv1) # import pdb; pdb.set_trace() lines = [] vals = [] for j, ind in enumerate(indices[0]): if ind not in ncs_de_todos_meshsets_que_estao_no_nivel_1: continue id_adm_nv1 = map_ncs_de_todos_meshsets_que_estao_no_nivel_1_in_id_adm_1[ind] lines.append(id_adm_nv1) vals.append(indices[2][j]) col = np.repeat(id_adm_lv2_vertice, len(vals)).astype(np.int32) lines = np.array(lines).astype(np.int32) vals = np.array(vals) OP_adm_nv2[lines, col] = vals todos = rng.Range(todos_meshsets_que_estao_no_nivel_1) for meshsets in meshsets_nv1_que_estao_no_nv2: todos = rng.subtract(todos, meshsets) for m in todos: elems = mb.get_entities_by_handle(m) id_adm_2 = np.unique(mb.tag_get_data(L2_ID_tag, elems, flat=True))[0] id_adm_1 = map_todos_meshsets_que_estao_no_nivel_1_in_id_adm_1[m] OP_adm_nv2[id_adm_1] = np.zeros(len(all_ids_adm_nv2)) OP_adm_nv2[id_adm_1, id_adm_2] = 1.0 elems_nv0 = mb.get_entities_by_type_and_tag( mb.get_root_set(), types.MBHEX, np.array([L3_ID_tag]), np.array([1])) ids_adm_lv2_elems_nv0 = mb.tag_get_data(L2_ID_tag, elems_nv0, flat=True) ids_adm_lv1_elems_nv0 = mb.tag_get_data(L1_ID_tag, elems_nv0, flat=True) OP_adm_nv2[ids_adm_lv1_elems_nv0, ids_adm_lv2_elems_nv0] = np.ones(len(elems_nv0)) return OP_adm_nv2
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")
def get_or_nv1(mb, op, map_wirebasket, wirebasket_numbers): name_primal_tag_level = Restriction.name_primal_tag + str(1) name_fine_to_primal_tag_level = Restriction.name_fine_to_primal_tag[ 0] + str(1) + Restriction.name_fine_to_primal_tag[1] primal_tag = mb.tag_get_handle(name_primal_tag_level) fine_to_primal_tag = mb.tag_get_handle(name_fine_to_primal_tag_level) d2_tag = mb.tag_get_handle(Restriction.name_d2_tag) ni = wirebasket_numbers[0] nf = wirebasket_numbers[1] ne = wirebasket_numbers[2] nv = wirebasket_numbers[3] vertex_elems = rng.Range([ item[0] for item in map_wirebasket.items() if item[1] >= ni + nf + ne ]) meshsets = mb.get_entities_by_type_and_tag(mb.get_root_set(), types.MBENTITYSET, np.array([primal_tag]), np.array([None])) map_meshset_in_nc = [] name_nc_primal_tag = Restriction.name_nc_primal + str(1) nc_primal_tag = mb.tag_get_handle(name_nc_primal_tag, 1, types.MB_TYPE_INTEGER, types.MB_TAG_SPARSE, True) OR = sp.lil_matrix((op.shape[1], op.shape[0])) interns = [] faces = [] edges = [] verts = [] map_nc_in_dual = {} for m in meshsets: elems = mb.get_entities_by_handle(m) vertex = rng.intersect(elems, vertex_elems) if len(vertex) != 1: print('erro') import pdb pdb.set_trace() vertex = vertex[0] gids = [map_wirebasket[v] for v in elems] gid = map_wirebasket[vertex] line_op = op[gid] indice = sp.find(line_op) if len(indice[1]) != 1: print('erro') import pdb pdb.set_trace() col = indice[1][0] map_meshset_in_nc.append(col) ones = np.ones(len(elems)) OR[col, gids] = ones val_d2 = list(set(mb.tag_get_data(d2_tag, elems, flat=True))) if len(val_d2) > 1: print('erro') import pdb pdb.set_trace() val_d2 = val_d2[0] map_nc_in_dual[col] = val_d2 if val_d2 == 0: interns.append(col) elif val_d2 == 1: faces.append(col) elif val_d2 == 2: edges.append(col) elif val_d2 == 3: verts.append(col) else: raise ValueError('Erro no valor de d2_tag') mb.tag_set_data(nc_primal_tag, meshsets, map_meshset_in_nc) map_meshset_in_nc = dict(zip(np.array(meshsets), map_meshset_in_nc)) # ids_nv1 = sorted(map_meshset_in_nc) wirebasket_numbers_nv1 = [ len(interns), len(faces), len(edges), len(verts) ] wirebasket_ord = interns + faces + edges + verts map_nc_in_wirebasket_id = dict( zip(wirebasket_ord, range(len(wirebasket_ord)))) ######################################################### # debug # nni = len(interns) # nnf = nni + len(faces) # nne = nnf + len(edges) # nnv = nne + len(verts) # # nc_vertex_elems = np.array(wirebasket_ord[nne:nnv], dtype=np.uint64) # meshsets_vertex_elems_nv1 = [mb.get_entities_by_type_and_tag( # mb.get_root_set(), types.MBENTITYSET, np.array([nc_primal_tag]), # np.array([i]))[0] for i in nc_vertex_elems] # meshsets_vertex_elems_nv1 = rng.Range(meshsets_vertex_elems_nv1) # # cont = 0 # for m in meshsets_vertex_elems_nv1: # nc = mb.tag_get_data(nc_primal_tag, m, flat=True)[0] # elems = mb.get_entities_by_handle(m) # val_d2 = np.unique(mb.tag_get_data(d2_tag, elems, flat=True)) # print(val_d2) # print(nc) # print(nc in nc_vertex_elems) # print('\n') # if val_d2[0] != 3: # print('erro') # import pdb; pdb.set_trace() # if cont == 10: # cont = 0 # import pdb; pdb.set_trace() # cont+=1 # # print('saiu or1') # import pdb; pdb.set_trace() ###################################################################### # ids_wirebasket = np.arange(len(wirebasket_ord)) # map_ids_nv1_in_wirebasket = dict(zip(wirebasket_ord, ids_wirebasket)) return OR, wirebasket_ord, wirebasket_numbers_nv1, map_meshset_in_nc, map_nc_in_wirebasket_id
def set_area(self): gids_volumes = self.mb.tag_get_data(self.tags['GIDV'], self.all_volumes, flat=True) map_volumes = dict(zip(self.all_volumes, gids_volumes)) areas = np.zeros(len(self.all_faces)) normais = np.zeros((len(self.all_faces), 3)) Adjs = [self.mb.get_adjacencies(f, 3) for f in self.all_faces] vertss = [ self.mtu.get_bridge_adjacencies(f, 2, 0) for f in self.all_faces ] lim = 1e-9 bound_faces = self.mb.create_meshset() bfs = [] for i, f in enumerate(self.all_faces): elems = Adjs[i] if len(elems) < 2: bfs.append(f) verts = vertss[i] coords = self.mb.get_coords(verts).reshape([len(verts), 3]) mins = coords.min(axis=0) maxs = coords.max(axis=0) dx, dy, dz = np.absolute(maxs - mins) if dx < lim: dx = 1.0 if dy < lim: dy = 1.0 if dz < lim: dz = 1.0 area = dx * dy * dz areas[i] = area if len(elems) > 1: id0 = map_volumes[elems[0]] id1 = map_volumes[elems[1]] cent0 = self.all_centroids[id0] cent1 = self.all_centroids[id1] direction = cent1 - cent0 norma = np.linalg.norm(direction) uni = np.absolute(direction / norma) normais[i] = uni else: p0 = coords[0] p1 = coords[1] p2 = coords[2] direction = np.cross(p0 - p1, p0 - p2) norma = np.linalg.norm(direction) uni = np.absolute(direction / norma) normais[i] = uni self.mb.tag_set_data(self.tags['AREA'], self.all_faces, areas) self.mb.tag_set_data(self.tags['NORMAL'], self.all_faces, normais) bfs = rng.Range(bfs) self.mb.add_entities(bound_faces, bfs) self.mb.tag_set_data(self.tags['BOUND_FACES'], 0, bound_faces) self.bound_faces = bfs self.faces_in = rng.subtract(self.all_faces, bfs) self.Adjs_in = np.array( [np.array(self.mb.get_adjacencies(f, 3)) for f in self.faces_in]) Adjs_d = self.Adjs_in[:, 1] Adjs_e = self.Adjs_in[:, 0] os.chdir(flying_dir) np.save('Adjs_d', Adjs_d) np.save('Adjs_e', Adjs_e)
cent_tag = mb.tag_get_handle('CENT') D1_tag = mb.tag_get_handle('d1') D2_tag = mb.tag_get_handle('d2') dirichlet_tag = mb.tag_get_handle('P') neumann_tag = mb.tag_get_handle('Q') intermediarios_tag = mb.tag_get_handle('intermediarios') intermediarios = mb.tag_get_data(intermediarios_tag, 0, flat=True)[0] intermediarios = mb.get_entities_by_handle(intermediarios) volumes_d = mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([dirichlet_tag]), np.array([None])) volumes_n = mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([neumann_tag]), np.array([None])) volumes_f = rng.Range(np.load('volumes_f.npy')) finos = list(rng.unite(rng.unite(volumes_d, volumes_n), volumes_f)) vertices = mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]), np.array([3])) vertices = rng.unite( vertices, mb.get_entities_by_type_and_tag(0, types.MBTET, np.array([D1_tag]), np.array([3]))) all_vertex_centroids = mb.tag_get_data(cent_tag, vertices) L1_ID_tag = mb.tag_get_handle("l1_ID") L2_ID_tag = mb.tag_get_handle("l2_ID") L3_ID_tag = mb.tag_get_handle("NIVEL_ID")
def main(): global nx, ny, nz, dx, dy, dz, dim, num_elements # Tratamento da entrada. O número de dimensões da malha é determinado a partir # da quantidade de argumentos. if len(sys.argv) == 7: nx = int(sys.argv[1]) ny = int(sys.argv[3]) nz = int(sys.argv[5]) dx = float(sys.argv[2]) dy = float(sys.argv[4]) dz = float(sys.argv[6]) dim = 2 num_elements = nx * ny * nz num_vertex = (nx + 1) * (ny + 1) * (nz + 1) else: print("Not enough arguments") return # Criando instância da classe Core que gerencias as operações na malha. mbcore = core.Core() # Inicializando o vetor de coordenadas dos vértices. vertex_coords = np.zeros(num_vertex * 3) for i in range(num_vertex): vertex_coords[3 * i] = (i % (nx + 1)) * dx vertex_coords[3 * i + 1] = ((i // (nx + 1)) % (ny + 1)) * dy vertex_coords[3 * i + 2] = ((i // ((nx + 1) * (ny + 1))) % (nz + 1)) * dz # O método create_vertices cria os handles associados a cada coordenada em vertex_coords vertex_handles = mbcore.create_vertices(vertex_coords) # Em mesh_connectivity são aramazenados os conjuntos de vértices que compõem um elemento, # ou seja, determina a conectividade dos vértices na malha. print("Creating connectivity") mesh_connectivity = create_mesh_connectivity(vertex_handles, vertex_coords) print("Done") for m in mesh_connectivity: print(m) return # De posse da conectividade da malha, criamos os elementos um a um. A troca de valores # nas duas primeiras linhas do laço são necessárias devido a forma como o MOAB interpreta # a malha e as adjacências dos elementos. elem_handles = rng.Range() for c in mesh_connectivity: c[2], c[3] = c[3], c[2] c[6], c[7] = c[7], c[6] temp = mbcore.create_element(types.MBHEX, c) elem_handles.insert(temp) # Incialização da matriz de conectividade. (Neste caso, a conectividade é em # relação aos elementos, ou seja, quais elementos são vizinhos.) connectivity = np.zeros((num_elements, num_elements), dtype=np.bool_) # Encontrando adjacências para preencher a matriz de conectividade adjacencies = [mbcore.get_adjacencies(e, dim, True) for e in elem_handles] # Para cada adjacência diferente, verifica-se se existem uma fronteira compartilhada. # Caso positivo, os dois elementos são vizinhos e isto é indicado em connectivity. i, j = 0, 0 for a in adjacencies: for b in adjacencies: if b != a: intersection = rng.intersect(a, b) if not intersection.empty(): connectivity[i][j] = 1 connectivity[j][i] = 1 j += 1 j = 0 i += 1 # Determinando as coordenadas do centroide de cada elemento e aramazenando-as em tags. # Uma tag é um valor associado a cada elemento. Aqui, cada elemento possui duas tags: uma # que armazena o valor das coordenadas do centroide e outra que armazena a permeabilidade. centroid_tag = mbcore.tag_get_handle('centroid', 3, types.MB_TYPE_DOUBLE, types.MB_TAG_DENSE, True) permeability_tag = mbcore.tag_get_handle('permeability', 1, types.MB_TYPE_DOUBLE, types.MB_TAG_DENSE, True) for e in elem_handles: elem_vertex = mbcore.get_connectivity(e) centroid_coord = get_centroid_coords( mbcore.get_coords([elem_vertex[0]])) mbcore.tag_set_data(centroid_tag, e, centroid_coord) mbcore.tag_set_data(permeability_tag, e, np.array([1], dtype=np.float_)) mbcore.write_file("tpfa_mesh.h5m") print("New h5m file created")
def find_coarse_neighbours(self): self.connectivities = np.zeros( (self.num_coarse, self.num_coarse + 1, 3)).astype('bool') self.nodes_neighbors = np.zeros((self.num_coarse, self.num_coarse + 1), dtype=object) self.edges_neighbors = np.zeros((self.num_coarse, self.num_coarse + 1), dtype=object) self.faces_neighbors = np.zeros((self.num_coarse, self.num_coarse + 1), dtype=object) self.nodes_neighbors[:], self.edges_neighbors[:], self.faces_neighbors[:] = None, None, None self._nodes = list() self._faces = list() self._edges = list() self.all_nodes_neighbors = rng.Range() self.all_edges_neighbors = rng.Range() self.all_faces_neighbors = rng.Range() self.all_volumes_neighbors = rng.Range() #print(self.all_nodes_neighbors, self.all_edges_neighbors, self.all_faces_neighbors) # import pdb; pdb.set_trace() node_count, edge_count, face_count = 0, 0, 0 for x in range(self.num_coarse): for y in range(x + 1, self.num_coarse): node_intersect = rng.intersect( self.elements[x].core.boundary_nodes, self.elements[y].core.boundary_nodes) if not node_intersect.empty(): self._nodes.append(node_intersect) #self._nodes = np.append(self._nodes,node_intersect) self.nodes_neighbors[x, y], self.nodes_neighbors[ y, x], = node_count, node_count self.connectivities[x, y, 0], self.connectivities[y, x, 0] = True, True node_count += 1 [ self.all_nodes_neighbors.insert(e) for e in node_intersect ] edges_intersect = rng.intersect( self.elements[x].core.boundary_edges, self.elements[y].core.boundary_edges) if not edges_intersect.empty(): self._edges.append(edges_intersect) # self._edges = np.append(self._edges,edges_intersect) self.edges_neighbors[x, y], self.edges_neighbors[ y, x] = edge_count, edge_count self.connectivities[x, y, 1], self.connectivities[y, x, 1] = True, True edge_count += 1 [ self.all_edges_neighbors.insert(e) for e in edges_intersect ] faces_intersect = rng.intersect( self.elements[x].core.boundary_faces, self.elements[y].core.boundary_faces) if not faces_intersect.empty(): self._faces.append(faces_intersect) #self._faces = np.append(self._faces,faces_intersect) self.faces_neighbors[x, y], self.faces_neighbors[ y, x] = face_count, face_count self.connectivities[x, y, 2], self.connectivities[y, x, 2] = True, True face_count += 1 [ self.all_faces_neighbors.insert(e) for e in faces_intersect ] self.num_internal_nodes = node_count self.num_internal_edges = edge_count self.num_internal_faces = face_count for x in range(self.num_coarse): # fix the interesection - second variable poorly choosen node_intersect = rng.subtract(self.elements[x].core.boundary_nodes, self.all_nodes_neighbors) if not node_intersect.empty(): self._nodes.append(node_intersect) self.nodes_neighbors[x, -1] = node_count self.connectivities[x, -1, 0] = True node_count += 1 edge_intersect = rng.subtract(self.elements[x].core.boundary_edges, self.all_edges_neighbors) if not edge_intersect.empty(): self._edges.append(edge_intersect) self.edges_neighbors[x, -1] = edge_count self.connectivities[x, -1, 1] = True edge_count += 1 face_intersect = rng.subtract(self.elements[x].core.boundary_faces, self.all_faces_neighbors) if not face_intersect.empty(): self._faces.append(face_intersect) self.faces_neighbors[x, -1] = face_count self.connectivities[x, -1, 2] = True face_count += 1
def mount_local_problem(self, map_local, faces_in=None): """ retorna os indices: linha, coluna, valor, sz sz = tamanho da matriz input: map_local: dicionario onde keys = volumes e values = id local faces_in: faces internas do conjunto de volumes output: inds: """ elements = rng.Range(list(map_local.keys())) n = len(elements) if faces_in == None: # faces = utpy.get_all_faces(OtherUtils.mb, rng.Range(elements)) # bound_faces = utpy.get_boundary_of_volumes(OtherUtils.mb, elements) # faces = rng.subtract(faces, bound_faces) faces = rng.subtract( utpy.get_faces(self.mb, rng.Range(elements)), utpy.get_boundary_of_volumes(self.mb, elements)) else: faces = faces_in keqs = mb.tag_get_data(self.list_tags[0], faces, flat=True) elems = [self.mb.get_adjacencies(face) for face in faces] s_gravs = self.mb.tag_get_data(self.list_tags[1], faces, flat=True) dict_keq = dict(zip(faces, keqs)) dict_elems = dict(zip(faces, elems)) dict_s_grav = dict(zip(faces, s_gravs)) linesM = np.array([]) colsM = np.array([]) valuesM = np.array([]) linesM2 = np.array([]) valuesM2 = np.array([]) szM = [n, n] b = np.zeros(n) s = np.zeros(n) for face in faces: elems = dict_elems[face] keq = dict_keq[face] s_grav = dict_s_grav[face] linesM = np.append(linesM, [map_local[elems[0]], map_local[elems[1]]]) colsM = np.append(colsM, [map_local[elems[1]], map_local[elems[0]]]) valuesM = np.append(valuesM, [-keq, -keq]) ind0 = np.where(linesM2 == map_local[elems[0]]) if len(ind0[0]) == 0: linesM2 = np.append(linesM2, map_local[elems[0]]) valuesM2 = np.append(valuesM2, [keq]) else: valuesM2[ind0[0]] += keq ind1 = np.where(linesM2 == map_local[elems[1]]) if len(ind1[0]) == 0: linesM2 = np.append(linesM2, map_local[elems[1]]) valuesM2 = np.append(valuesM2, [keq]) else: valuesM2[ind1[0]] += keq s[map_local[elems[0]]] += s_grav s[map_local[elems[1]]] -= s_grav linesM = np.append(linesM, linesM2) colsM = np.append(colsM, linesM2) valuesM = np.append(valuesM, valuesM2) linesM = linesM.astype(np.int32) colsM = colsM.astype(np.int32) inds = np.array([linesM, colsM, valuesM, szM, False, False]) if self.gravity == True: return inds, s else: return inds, b
def get_op_adm_nv2(mb, OP2, wirebasket_ord_1, wirebasket_numbers_1, map_nc_in_wirebasket_id_1, all_volumes): nc_primal_tag_1 = mb.tag_get_handle('NC_PRIMAL_1') nc_primal_tag_2 = mb.tag_get_handle('NC_PRIMAL_2') d2_tag = mb.tag_get_handle(ProlongationTPFA3D.name_d2_tag) map_wirebasket_id_in_nc_1 = {} for i, j in map_nc_in_wirebasket_id_1.items(): map_wirebasket_id_in_nc_1[j] = i meshsets_nv2 = np.array( mb.get_entities_by_type_and_tag(mb.get_root_set(), types.MBENTITYSET, np.array([nc_primal_tag_2]), np.array([None]))) lv1_id_tag = mb.tag_get_handle(ProlongationTPFA3D.name_l1_id) lv2_id_tag = mb.tag_get_handle(ProlongationTPFA3D.name_l2_id) level_tag = mb.tag_get_handle(ProlongationTPFA3D.name_l3_id) all_ids_nv1 = np.unique( mb.tag_get_data(lv1_id_tag, all_volumes, flat=True)) all_ids_nv2 = np.unique( mb.tag_get_data(lv2_id_tag, all_volumes, flat=True)) OP_adm_nv2 = sp.lil_matrix((len(all_ids_nv1), len(all_ids_nv2))) meshsets_nv1_que_estao_no_nv2 = [] id_adm_lv2_dos_meshsets_nv1_que_estao_no_nv2 = [] id_adm_lv1_dos_meshsets_nv1_que_estao_no_nv2 = [] todos_meshsets_que_estao_no_nivel_1 = [] ids_adm_nv1_de_todos_meshsets_que_estao_no_nivel_1 = [] for m2 in meshsets_nv2: childs = mb.get_child_meshsets(m2) for m in childs: mb.add_parent_meshset(m, m2) elems = mb.get_entities_by_handle(m) id_adm_nv1 = np.unique( mb.tag_get_data(lv1_id_tag, elems, flat=True)) if len(id_adm_nv1) > 1: continue todos_meshsets_que_estao_no_nivel_1.append(m) ids_adm_nv1_de_todos_meshsets_que_estao_no_nivel_1.append( id_adm_nv1[0]) elems = mb.get_entities_by_handle(m2) id_lv2 = np.unique(mb.tag_get_data(lv2_id_tag, elems, flat=True)) if len(id_lv2) > 1: continue meshsets_nv1_que_estao_no_nv2.append(childs) id_adm_lv2_dos_meshsets_nv1_que_estao_no_nv2.append(id_lv2[0]) ids_adm_lv1 = [] for m in childs: elems_1 = mb.get_entities_by_handle(m) id_adm_lv1 = np.unique( mb.tag_get_data(lv1_id_tag, elems_1, flat=True)) ids_adm_lv1.append(id_adm_lv1) id_adm_lv1_dos_meshsets_nv1_que_estao_no_nv2.append(ids_adm_lv1[:]) ncs_de_todos_meshsets_que_estao_no_nivel_1 = mb.tag_get_data( nc_primal_tag_1, todos_meshsets_que_estao_no_nivel_1, flat=True) map_ncs_de_todos_meshsets_que_estao_no_nivel_1_in_id_adm_1 = dict( zip(ncs_de_todos_meshsets_que_estao_no_nivel_1, ids_adm_nv1_de_todos_meshsets_que_estao_no_nivel_1)) map_todos_meshsets_que_estao_no_nivel_1_in_id_adm_1 = dict( zip(todos_meshsets_que_estao_no_nivel_1, ids_adm_nv1_de_todos_meshsets_que_estao_no_nivel_1)) # import pdb; pdb.set_trace() # print(meshsets_nv1_que_estao_no_nv2) # print(id_adm_lv1_dos_meshsets_nv1_que_estao_no_nv2) # print(id_adm_lv2_dos_meshsets_nv1_que_estao_no_nv2) # print(todos_meshsets_que_estao_no_nivel_1) # print(ids_adm_nv1_de_todos_meshsets_que_estao_no_nivel_1) # import pdb; pdb.set_trace() nni = wirebasket_numbers_1[0] nnf = nni + wirebasket_numbers_1[1] nne = nnf + wirebasket_numbers_1[2] nnv = nne + wirebasket_numbers_1[3] nc_vertex_elems = np.array(wirebasket_ord_1[nne:nnv], dtype=np.uint64) meshsets_vertex_elems_nv1 = [ mb.get_entities_by_type_and_tag(mb.get_root_set(), types.MBENTITYSET, np.array([nc_primal_tag_1]), np.array([i]))[0] for i in nc_vertex_elems ] cont = 0 vertices_pi_chapeu = [] ids_lv2_vertices_pi_chapeu = [] for m in meshsets_vertex_elems_nv1: if m in todos_meshsets_que_estao_no_nivel_1: vertices_pi_chapeu.append(m) elems = mb.get_entities_by_handle(m) id_lv2_adm = np.unique( mb.tag_get_data(lv2_id_tag, elems, flat=True)) ids_lv2_vertices_pi_chapeu.append(id_lv2_adm) # meshsets_vertex_elems_nv1 = rng.Range(meshsets_vertex_elems_nv1) # nc_vertex_elems = mb.tag_get_data(nc_primal_tag_1, meshsets_vertex_elems_nv1, flat=True) for i, m in enumerate(vertices_pi_chapeu): id_adm_lv2_vertice = ids_lv2_vertices_pi_chapeu[i] parent_meshset = mb.get_parent_meshsets(m) nc2 = mb.tag_get_data(nc_primal_tag_2, parent_meshset, flat=True)[0] col_op2 = OP2[:, nc2] indices = sp.find(col_op2) lines = [] vals = [] for j, ind in enumerate(indices[0]): nc_1 = map_wirebasket_id_in_nc_1[ind] if nc_1 not in ncs_de_todos_meshsets_que_estao_no_nivel_1: continue id_adm_nv1 = map_ncs_de_todos_meshsets_que_estao_no_nivel_1_in_id_adm_1[ nc_1] lines.append(id_adm_nv1) vals.append(indices[2][j]) col = np.repeat(id_adm_lv2_vertice, len(vals)).astype(np.int32) lines = np.array(lines).astype(np.int32) vals = np.array(vals) OP_adm_nv2[lines, col] = vals todos = rng.Range(todos_meshsets_que_estao_no_nivel_1) for meshsets in meshsets_nv1_que_estao_no_nv2: todos = rng.subtract(todos, meshsets) for m in todos: elems = mb.get_entities_by_handle(m) id_adm_2 = np.unique(mb.tag_get_data(lv2_id_tag, elems, flat=True))[0] id_adm_1 = map_todos_meshsets_que_estao_no_nivel_1_in_id_adm_1[m] OP_adm_nv2[id_adm_1] = np.zeros(len(all_ids_nv2)) OP_adm_nv2[id_adm_1, id_adm_2] = 1.0 elems_nv0 = mb.get_entities_by_type_and_tag(mb.get_root_set(), types.MBHEX, np.array([level_tag]), np.array([1])) ids_adm_lv2_elems_nv0 = mb.tag_get_data(lv2_id_tag, elems_nv0, flat=True) ids_adm_lv1_elems_nv0 = mb.tag_get_data(lv1_id_tag, elems_nv0, flat=True) OP_adm_nv2[ids_adm_lv1_elems_nv0, ids_adm_lv2_elems_nv0] = np.ones(len(elems_nv0)) return OP_adm_nv2
#rng.subtract(rng.Range(vertice),viz_vert) for v in viz_vert: cent = MM.mtu.get_average_position( [np.uint64(v)]) if (cent[2] - cent_v[2] ) < 0.01 and r: # and v in faces1: new_vertices.append(v) adjs_new_vertices = [ MM.mtu.get_bridge_adjacencies(v, 2, 3) for v in new_vertices ] new_faces = [] for conj in adjs_new_vertices: v = rng.intersect(rng.Range(internos1), conj) if len(v) > 0: new_faces.append(np.uint64(v)) for f in new_faces: try: vfd = 0 #MM.mb.tag_set_data(D1_tag, f,np.repeat(1,len(f))) except: import pdb pdb.set_trace() #MM.mb.tag_set_data(D1_tag, new_vertices,np.repeat(2,len(new_vertices))) MM.mb.tag_set_data(primal_id_tag1, l1_meshset, nc1) nc1 += 1 MM.mb.add_child_meshset(l2_meshset, l1_meshset) #-------------------------------------------------------------------------------
# volumes_d = [] # volumes_n = [] all_boundary_faces = M1.mb.tag_get_data(M1.all_faces_boundary_tag, 0, flat=True) all_boundary_faces = M1.mb.get_entities_by_handle(all_boundary_faces) # for v in all_volumes: # #v = M1.mtu.get_bridge_adjacencies(f,2,3) # if Min_Max(v)[0]-0.00001<xmin and Min_Max(v)[2]+0.00001<(ymin+ymax)/2: # volumes_d.append(v) # wells.append(v) # elif Min_Max(v)[1]+0.00001>xmin+Lx: # volumes_n.append(v) # wells.append(v) volumes_d = rng.Range(volumes_d) if M1.gravity == False: pressao = np.repeat(press, len(volumes_d)) # # colocar gravidade elif M1.gravity == True: z_elems_d = -1*np.array([M1.mtu.get_average_position([v])[2] for v in volumes_d]) delta_z = z_elems_d + Lz pressao = M1.gama*(delta_z) + press ############################################### else: print("Defina se existe gravidade (True) ou nao (False)") raise ValueError('erro em gravity') volumes_d = list(volumes_d) M1.mb.add_entities(dirichlet_meshset, volumes_d)
def create_wells(self): self.wells_injector = self.mb.create_meshset() self.wells_producer = self.mb.create_meshset() self.mb.tag_set_data(self.tags['WELLS_PRODUCER'], 0, self.wells_producer) self.mb.tag_set_data(self.tags['WELLS_INJECTOR'], 0, self.wells_injector) all_centroids = self.mb.tag_get_data(self.tags['CENT'], self.all_volumes) Lz = self.Lz data_loaded = self.data_loaded gravity = data_loaded['gravity'] all_volumes = self.all_volumes gama = self.gama bvd = [] bvn = [] mb = self.mb volumes_d = [] volumes_n = [] inds_wells = [] for well in data_loaded['Wells_structured']: w = data_loaded['Wells_structured'][well] if w['type_region'] == 'box': box_volumes = np.array( [np.array(w['region1']), np.array(w['region2'])]) inds0 = np.where(all_centroids[:, 0] > box_volumes[0, 0])[0] inds1 = np.where(all_centroids[:, 1] > box_volumes[0, 1])[0] inds2 = np.where(all_centroids[:, 2] > box_volumes[0, 2])[0] c1 = set(inds0) & set(inds1) & set(inds2) inds0 = np.where(all_centroids[:, 0] < box_volumes[1, 0])[0] inds1 = np.where(all_centroids[:, 1] < box_volumes[1, 1])[0] inds2 = np.where(all_centroids[:, 2] < box_volumes[1, 2])[0] c2 = set(inds0) & set(inds1) & set(inds2) inds_vols = list(c1 & c2) inds_wells += inds_vols volumes = rng.Range(np.array(all_volumes)[inds_vols]) else: raise NameError( "Defina o tipo de regiao em type_region: 'box'") value = float(w['value']) if w['type_prescription'] == 'dirichlet': bvd.append(box_volumes) volumes_d += list(volumes) if gravity == False: pressao = np.repeat(value, len(volumes)) else: z_elems_d = -1 * mb.tag_get_data(self.tags['CENT'], volumes)[:, 2] delta_z = z_elems_d + Lz pressao = gama * (delta_z) + value mb.tag_set_data(self.tags['P'], volumes, pressao) elif w['type_prescription'] == 'neumann': volumes_n += list(volumes) bvn.append(box_volumes) value = value / len(volumes) if w['type_well'] == 'producer': value = -value mb.tag_set_data(self.tags['Q'], volumes, np.repeat(value, len(volumes))) else: raise NameError( "type_prescription == 'neumann' or 'dirichlet'") if w['type_well'] == 'injector': mb.add_entities(self.wells_injector, volumes) else: mb.add_entities(self.wells_producer, volumes)