def get_faces_in_intersection_between_volumes(mb, elements1, elements2): """ Retorna as faces na interseccao entre dois ranges de volumes ou dois meshsets """ bound_faces1 = UtilsPymoab.get_boundary_of_volumes(mb, elements1) bound_faces2 = UtilsPymoab.get_boundary_of_volumes(mb, elements2) return rng.intersect(bound_faces1, bound_faces2)
def calculate_pcorr(self, elements, vertex_elem, pcorr_tag, pms_tag, keq_tag, faces, boundary_faces, volumes_d, volumes_n): map_local = dict(zip(elems, range(len(elems)))) n = len(elems) T = sp.lil_matrix((n, n)) b = np.zeros(n) for i, face in enumerate(faces): elems = self.mb.get_adjacencies(face, 3) keq, s_grav, elems = self.get_mobi_by_face_quad_bif(face, keq_tag) if face in boundary_faces: p = self.mb.tag_get_data(pms_tag, elems, flat=True) flux = (p[1] - p[0])*keq if self.gravity == True: flux += s_grav b[map_local[elems[0]]] += flux b[map_local[elems[1]]] -= flux continue T[map_local[elems[0]], map_local[elems[1]]] = -keq T[map_local[elems[1]], map_local[elems[0]]] = -keq T[map_local[elems[0]], map_local[elems[0]]] += keq T[map_local[elems[1]], map_local[elems[1]]] += keq T[map_local[vertex], map_local[vertex]] = 1 p = self.mb.tag_get_data(pms_tag, vertex, flat=True)[0] b[map_local[vertex]] = p bound1 = rng.intersect(elems, volumes_d) bound1 = rng.subtract(bound1, vertex) if len(bound1) > 0: ids = np.array([map_local[v] for v in bound1]) T[ids] = sp.lil_matrix((len(ids), n)) T[ids, ids] = np.ones(len(ids)) ps = self.mb.tag_get_data(pms_tag, bound1, flat=True) b[ids] = ps bound2 = rng.intersect(elems, volumes_n) bound2 = rng.subtract(bound2, vertex) if len(bound2) > 0: ids = np.array([map_local[v] for v in bound2]) qs = self.mb.tag_get_data(self.list_tags[3], bound2, flat=True) b[ids] += qs x = linalg.spsolve(T, b) self.mb.tag_set_data(pcorr_tag, elements, x)
def __init__(self, father_core, num, coarse_vec): self.father_core = father_core self.dimension = father_core.dimension self.mb = father_core.mb self.level = father_core.level + 1 self.coarse_num = num self.father_root_set = father_core.root_set self.root_set = self.mb.create_meshset(types.MESHSET_TRACK_OWNER) self.mtu = father_core.mtu self.handleDic = father_core.handleDic if self.dimension == 3: self.all_volumes = father_core.all_volumes[coarse_vec] self.all_faces = self.mb.get_adjacencies(self.all_volumes, 2, False, op_type=types.UNION) self.all_edges = self.mb.get_adjacencies(self.all_volumes, 1, False, op_type=types.UNION) self.all_nodes = self.mb.get_adjacencies(self.all_volumes, 0, False, op_type=types.UNION) elif self.dimension == 2: self.all_volumes = rng.Range() self.all_faces = father_core.all_faces[coarse_vec] self.all_edges = self.access_handle(self.all_faces) self.all_nodes = rng.Range(self.mb.get_connectivity( self.all_faces)) self.mb.add_entities(self.root_set, self.all_volumes) self.mb.add_entities(self.root_set, self.all_faces) self.mb.add_entities(self.root_set, self.all_edges) self.mb.add_entities(self.root_set, self.all_nodes) all_entities = self.mb.get_entities_by_handle(self.root_set) [ self.boundary_nodes, self.boundary_edges, self.boundary_faces, self.boundary_volumes ] = self.skinner_operation() self.internal_nodes = rng.subtract(self.all_nodes, self.boundary_nodes) self.internal_edges = rng.subtract(self.all_edges, self.boundary_edges) self.internal_faces = rng.subtract(self.all_faces, self.boundary_faces) self.internal_volumes = rng.subtract(self.all_volumes, self.boundary_volumes) if self.level == 1: self.id_name = "LOCAL_ID_L" + str(self.level) + "-" + str( self.coarse_num) self.father_id_name = self.father_core.id_name else: self.father_id_name = self.father_core.id_name self.id_name = self.father_id_name + str("L") + str( self.level) + "-" + str(self.coarse_num) self.init_id() self.flag_dic = { key: [rng.intersect(all_entities, el) for el in value] for (key, value) in father_core.flag_dic.items() }
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 get_meshsets_viz_face(mb, meshset, meshsets): result = [] bound_faces = UtilsPymoab.get_boundary_of_volumes(mb, meshset) for m in meshsets: bound_faces_m = UtilsPymoab.get_boundary_of_volumes(mb, m) inter = rng.intersect(bound_faces, bound_faces_m) if np.allclose(np.array(inter), np.array(bound_faces)): result.append(m) return rng.Range(result)
def set_faces_in_boundary_by_meshsets(mb, mtu, meshsets, faces_boundary_meshset_tag, M): all_faces_on_boundary = mb.create_meshset() meshsets = list(meshsets) n = len(meshsets) ms0 = set() # for m1 in meshsets: # ms0.add(m1) # cont = 0 # elems1 = mb.get_entities_by_handle(m1) # faces1 = mtu.get_bridge_adjacencies(elems1, 2, 2) # for m2 in meshsets: # if m2 in ms0: # continue # elems2 = mb.get_entities_by_handle(m2) # faces2 = mtu.get_bridge_adjacencies(elems2, 2, 2) # intersect = rng.intersect(faces1, faces2) # if len(intersect) < 1: # continue # cont+=1 # mb.add_entities(all_faces_on_boundary, intersect) # print(cont) # if cont > 3: # print(i) # print(cont) # import pdb; pdb.set_trace() # import pdb; pdb.set_trace() for m1 in meshsets: cont = 0 elems1 = mb.get_entities_by_handle(m1) faces1 = mtu.get_bridge_adjacencies(elems1, 3, 2) # for face in faces1: # elems = mb.get_adjacencies(face, 3) # if len(elems) < 2: # continue # if elems[0] in elems1 and elems[1] in elems1: # continue # mb.add_entities(all_faces_on_boundary, rng.Range(face)) elems2 = mtu.get_bridge_adjacencies(elems1, 2, 3) elems3 = rng.subtract(elems2, elems1) try: faces3 = mtu.get_bridge_adjacencies(elems3, 3, 2) faces_cont = rng.intersect(faces3, faces1) except Exception as e: faces_cont = faces1 mb.add_entities(all_faces_on_boundary, faces_cont) mb.tag_set_data(faces_boundary_meshset_tag, M.core.root_set, all_faces_on_boundary)
def find_coarse_neighbours(self, coarse_list): self.nodes_neighbors = {} self.edges_neighbors = {} self.faces_neighbors = {} self.volumes_neighbors = {} self.all_nodes_neighbors = rng.Range() self.all_edges_neighbors = rng.Range() self.all_faces_neighbors = rng.Range() self.all_volumes_neighbors = rng.Range() for x in range(self.num_coarse): for y in range(x + 1, self.num_coarse): self.nodes_neighbors[x, y] = rng.intersect( coarse_list[x].core.boundary_nodes, coarse_list[y].core.boundary_nodes) self.nodes_neighbors[y, x] = self.nodes_neighbors[x, y] temp = self.nodes_neighbors[x, y] [self.all_nodes_neighbors.insert(e) for e in temp] self.edges_neighbors[x, y] = rng.intersect( coarse_list[x].core.boundary_edges, coarse_list[y].core.boundary_edges) self.edges_neighbors[y, x] = self.edges_neighbors[x, y] temp = self.edges_neighbors[x, y] [self.all_edges_neighbors.insert(e) for e in temp] self.faces_neighbors[x, y] = rng.intersect( coarse_list[x].core.boundary_faces, coarse_list[y].core.boundary_faces) self.faces_neighbors[y, x] = self.faces_neighbors[x, y] temp = self.faces_neighbors[x, y] [self.all_faces_neighbors.insert(e) for e in temp] self.volumes_neighbors[x, y] = rng.intersect( coarse_list[x].core.boundary_volumes, coarse_list[y].core.boundary_volumes) self.volumes_neighbors[y, x] = self.volumes_neighbors[x, y] temp = self.volumes_neighbors[x, y] [self.all_volumes_neighbors.insert(e) for e in temp]
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 ]
def bridge_adjacencies(self, index, interface, target): # lacks support for indexing with multiple numbers range_vec = self.create_range_vec(index) all_bridge = [ self.mtu.get_bridge_adjacencies(el_handle, self.num[interface], self.num[target]) for el_handle in self.range_index(range_vec) ] inside_meshset = self.mb.get_entities_by_handle(self.meshset) all_brige_in_meshset = [ rng.intersect(el_handle, inside_meshset) for el_handle in all_bridge ] all_briges_in_meshset_id = np.array( [self.read(el_handle) for el_handle in all_brige_in_meshset]) return all_briges_in_meshset_id
def remove_vol(self, element): tetra_remove = rng.intersect(self.all_elements, element) tetra_remaining = rng.subtract(self.all_elements, tetra_remove) #import pdb; pdb.set_trace() faces = rng.subtract(self.adjs(tetra_remove, 2), self.adjs(tetra_remaining,2)) edges = rng.subtract(self.adjs(tetra_remove, 1), self.adjs(tetra_remaining,1)) nodes = rng.subtract(self.adjs(tetra_remove, 0), self.adjs(tetra_remaining,0)) self.mb.delete_entity(tetra_remove) self.mb.delete_entity(faces) self.mb.delete_entity(edges) self.mb.delete_entity(nodes) self.all_elements = self.mb.get_entities_by_dimension(0, 3) self.nodes = self.mb.get_entities_by_dimension(0, 0) self.faces = self.skinner(self.all_elements) self.boundary_nodes = self.find_boundary_nodes() self.boundary_elements = self.find_boundary_elements()
def get_meshsets_viz_vertex(mb, meshset, meshsets): result = set() bound_faces = UtilsPymoab.get_boundary_of_volumes(mb, meshset) verts0 = rng.Range(mb.get_connectivity(bound_faces)) for m in meshsets: if m == meshset: continue bound_faces = UtilsPymoab.get_boundary_of_volumes(mb, m) verts1 = rng.Range(mb.get_connectivity(bound_faces)) inter = rng.intersect(verts0, verts1) if len(inter) > 0: result.add(m) return (rng.Range(result))
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_or_adm_nv1(mb, all_volumes, map_wire_lv0): nc_primal_tag_1 = mb.tag_get_handle('NC_PRIMAL_1') lv1_id_tag = mb.tag_get_handle(Restriction.name_l1_id) level_tag = mb.tag_get_handle(Restriction.name_l3_id) 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) OR_adm_nv1 = sp.lil_matrix((max_id_lv1 + 1, n)) OR_adm_nv1[ids_adm_nv1_elems_nv0, ids_wirebasket_elems_nv0] = np.ones( len(ids_adm_nv1_elems_nv0)) meshsets = mb.get_entities_by_type_and_tag(mb.get_root_set(), types.MBENTITYSET, np.array([nc_primal_tag_1]), np.array([None])) for meshset in meshsets: elems = mb.get_entities_by_handle(meshset) inter = rng.intersect(elems_nv0, elems) if len(inter) > 0: continue # nc = mb.tag_get_data(nc_primal_tag_1, meshset, flat=True)[0] line_or_adm = mb.tag_get_data(lv1_id_tag, elems, flat=True) cols_or_adm = np.array([map_wire_lv0[v] for v in elems]) OR_adm_nv1[line_or_adm, cols_or_adm] = np.ones(len(cols_or_adm)) return OR_adm_nv1
def bridge_adjacencies(self, index, interface, target): """ Get the adjacencies of a set of entities (or a single entity) connected through an especific interface. -- Example -- volumes_ids = M.volumes.all volumes_adjacencies = M.volumes.bridge_adjacencies(M.volumes.all, 2, 3) -- Parameters -- index : integer Indexes of entity or entities to get adjacent entities from. interface : integer Dimension of the interface entities. target : integer Dimension of the target entities. --Returns-- An array containing the indexes of adjacents entities """ # lacks support for indexing with multiple numbers range_vec = self.create_range_vec(index) all_bridge = [ self.mtu.get_bridge_adjacencies(el_handle, self.num[interface], self.num[target]) for el_handle in self.range_index(range_vec) ] inside_meshset = self.mb.get_entities_by_handle(self.meshset) all_brige_in_meshset = [ rng.intersect(el_handle, inside_meshset) for el_handle in all_bridge ] all_briges_in_meshset_id = np.array( [self.read(el_handle) for el_handle in all_brige_in_meshset]) return all_briges_in_meshset_id
def calc_pcorr_nv(self, vertices_nv, k, tag_primal_classic): tags_1 = self.tags mb = self.mb mtu = self.mtu boundary_faces = self.all_boundary_faces bound_faces_nv = self.bound_faces_nv for vert in vertices_nv: t00 = time.time() primal_id = mb.tag_get_data(tag_primal_classic, vert, flat=True)[0] elems_in_meshset = mb.get_entities_by_type_and_tag( 0, types.MBHEX, np.array([tag_primal_classic]), np.array([primal_id])) faces = mtu.get_bridge_adjacencies(elems_in_meshset, 3, 2) faces = rng.subtract(faces, boundary_faces) faces_boundary = rng.intersect(faces, bound_faces_nv[k]) if len(faces_boundary) < 1: import pdb pdb.set_trace() t01 = time.time() t02 = time.time() self.calculate_pcorr(elems_in_meshset, vert, faces_boundary, faces, k) self.set_flux_pms_meshsets(elems_in_meshset, faces, faces_boundary)
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
def run_2(t): print('entrou run2') tini = time.time() elems_nv0 = mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([tags_1['l3_ID']]), np.array([1])) # vertices_nv1 = rng.subtract(sol_adm.vertices, elems_nv0) vertices_nv1 = mb.get_entities_by_type_and_tag(meshset_vertices, types.MBHEX, np.array([tags_1['l3_ID']]), np.array([2])) k = 0 cont = 0 for vert in vertices_nv1: t00 = time.time() primal_id = mb.tag_get_data(tags_1['FINE_TO_PRIMAL1_CLASSIC'], vert, flat=True)[0] elems_in_meshset = mb.get_entities_by_type_and_tag( 0, types.MBHEX, np.array([tags_1['FINE_TO_PRIMAL1_CLASSIC']]), np.array([primal_id])) faces = mtu.get_bridge_adjacencies(elems_in_meshset, 3, 2) faces = rng.subtract(faces, boundary_faces) faces_boundary = rng.intersect(faces, bound_faces_nv[k]) t01 = time.time() t02 = time.time() bif_utils.calculate_pcorr(mb, elems_in_meshset, vert, faces_boundary, faces, tags_1['PCORR2'], tags_1['PMS2'], sol_adm.volumes_d, sol_adm.volumes_n, tags_1) # bif_utils.calculate_pcorr_v4(elems_in_meshset, tags_1['PCORR2'], tags_1) t03 = time.time() bif_utils.set_flux_pms_meshsets(elems_in_meshset, faces, faces_boundary, tags_1['PMS2'], tags_1['PCORR2']) t04 = time.time() dt0 = t01 - t00 dt1 = t03 - t02 dt2 = t04 - t03 dtt = t04 - t01 # print(f'tempo total {dtt}') # print(f'tempo hd {dt0}') # print(f'tempo pcorr {dt1}') # print(f'tempo fluxo_ms {dt2} \n') vertices_nv2 = mb.get_entities_by_type_and_tag(meshset_vertices_nv2, types.MBHEX, np.array([tags_1['l3_ID']]), np.array([3])) t0 = time.time() k = 1 for vert in vertices_nv2: primal_id = mb.tag_get_data(tags_1['FINE_TO_PRIMAL2_CLASSIC'], vert, flat=True)[0] elems_in_meshset = mb.get_entities_by_type_and_tag( 0, types.MBHEX, np.array([tags_1['FINE_TO_PRIMAL2_CLASSIC']]), np.array([primal_id])) faces = mtu.get_bridge_adjacencies(elems_in_meshset, 3, 2) faces = rng.subtract(faces, boundary_faces) faces_boundary = rng.intersect(faces, bound_faces_nv[k]) bif_utils.calculate_pcorr(mb, elems_in_meshset, vert, faces_boundary, faces, tags_1['PCORR2'], tags_1['PMS2'], sol_adm.volumes_d, sol_adm.volumes_n, tags_1) # bif_utils.calculate_pcorr_v4(elems_in_meshset, tags_1['PCORR2'], tags_1) bif_utils.set_flux_pms_meshsets(elems_in_meshset, faces, faces_boundary, tags_1['PMS2'], tags_1['PCORR2']) t1 = time.time() dt = t1 - t0 # print(f'tempo nv2 fluxo {dt}\n') faces = mtu.get_bridge_adjacencies(elems_nv0, 3, 2) faces = rng.subtract(faces, boundary_faces) # bif_utils.set_flux_pms_elems_nv0(elems_nv0, faces, tags_1['PMS1']) t0 = time.time() bif_utils.set_flux_pms_elems_nv0(elems_nv0, faces, tags_1['PMS2']) t1 = time.time() dt = t1 - t0 tend = time.time() dtt = tend - tini # print(f'tempo nv0 fluxo {dt}\n') bif_utils.calc_cfl(faces_in) bif_utils.verificar_cfl(all_volumes, loop) print(f'tempo total: {dtt}') print('saiu run2')
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 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
meshsets_nv1 = M1.mb.get_entities_by_type_and_tag(0, types.MBENTITYSET, np.array([primal_id_tag1]), np.array([None])) meshsets_nv2 = M1.mb.get_entities_by_type_and_tag(0, types.MBENTITYSET, np.array([primal_id_tag2]), np.array([None])) # # vertices=M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]), np.array([3])) vertices = all_vertex_d1 M1.mb.tag_set_data(fine_to_primal1_classic_tag, vertices, np.arange(0, len(vertices))) for meshset in meshsets_nv1: elems = M1.mb.get_entities_by_handle(meshset) vert = rng.intersect(elems, vertices) nc = M1.mb.tag_get_data(fine_to_primal1_classic_tag, vert, flat=True)[0] M1.mb.tag_set_data(fine_to_primal1_classic_tag, elems, np.repeat(nc, len(elems))) M1.mb.tag_set_data(primal_id_tag1, meshset, nc) internos = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]), np.array([0])) faces = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]), np.array([1])) arestas = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]), np.array([2])) vertices = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]), np.array([3]))
def DefineBoxesLvs(self): key_lvs = self.kkeys[1] key_ls = self.kkeys[2] Ls = [] n = len(self.info[key_lvs]) comps = [] for k in self.info[key_lvs]: l = self.info[key_lvs][k][key_ls] Ls.append(l[:]) self.Ls = Ls name_tag_primals = 'PRIMALS_NV_' name_tag_fine_to_primal = 'FINE_TO_PRIMAL_NV_' name_centroid_tag = 'CENTROID_NV_' all_names_primals_tags = [] all_primals_tags = [] all_fine_to_primal_tags = [] all_centroids_tag = [] for i in range(n): name_tag = name_tag_primals + str(i + 1) name_fine_to_primal = name_tag_fine_to_primal + str(i + 1) name_centroid = name_centroid_tag + str(i + 1) all_names_primals_tags.append(name_tag) primal_tag = self.mb.tag_get_handle(name_tag, 1, types.MB_TYPE_INTEGER, types.MB_TAG_SPARSE, True) fine_to_primal_tag = self.mb.tag_get_handle( name_fine_to_primal, 1, types.MB_TYPE_INTEGER, types.MB_TAG_SPARSE, True) centroid_tag = self.mb.tag_get_handle(name_centroid, 3, types.MB_TYPE_DOUBLE, types.MB_TAG_SPARSE, True) all_centroids_tag.append(centroid_tag) all_fine_to_primal_tags.append(fine_to_primal_tag) all_primals_tags.append(primal_tag) boxes = self.CreateBoxes(Ls[i]) self.CreateMeshsetsPrimals(boxes, primal_tag, fine_to_primal_tag, centroid_tag) ########################################################### ### esse passo so eh necessario para malhas nao estruturadas ### verifica se existe elementos da malha fina em mais de um volume da malha grossa ######## meshsets = self.mb.get_entities_by_type_and_tag( ######## self.root_set, types.MBENTITYSET, np.array([primal_tag]), ######## np.array([None])) ######## ######## boundary = self.sk.find_geometric_skin(self.all_volumes[0]) ######## print(boundary) ######## import pdb; pdb.set_trace() # m0 = set() # for m in meshsets: # elems0 = self.mb.get_entities_by_handle(m) # for m2 in meshsets: # if m2 in m0: # continue # elems2 = self.mb.get_entities_by_handle(m2) # inter = rng.intersect(elems0, elems2) # # if len(inter) > 0: # for elem in inter: # ind = np.where(np.array(self.all_volumes) == elem)[0] # cent_elem = self.vols_centroids[ind] # cent_m = self.mb.tag_get_data(centroid_tag, m, flat=True) # cent_m2 = self.mb.tag_get_data(centroid_tag, m2, flat=True) # dist_m = np.linalg.norm(cent_elem - cent_m) # dist_m2 = np.linalg.norm(cent_elem - cent_m2) # if dist_m < dist_m2: # self.mb.remove_entities(m2, elem) # else: # self.mb.remove_entities(m, elem) # # m0.add(m) ################################################################################# self.tags_primals = all_primals_tags # self.all_names_primals_tags = all_names_primals_tags self.all_centroids_tag = all_centroids_tag self.all_fine_to_primal_tags = all_fine_to_primal_tags all_primals_tags.reverse() # cls.mtu = topo_util.MeshTopoUtil(mb) all_names_primals_tags.reverse() for i in range(n - 1): primal_tag = all_primals_tags[i] name_primal_tag = all_names_primals_tags[i] primal_tag_nv0 = all_primals_tags[i - 1] name_primal_tag_nv0 = all_names_primals_tags[i - 1] meshsets = self.mb.get_entities_by_type_and_tag( self.root_set, types.MBENTITYSET, np.array([primal_tag]), np.array([None])) meshsets_nv0 = self.mb.get_entities_by_type_and_tag( self.root_set, types.MBENTITYSET, np.array([primal_tag_nv0]), np.array([None])) ms0 = set() for m1 in meshsets: cont = 0 for m0 in meshsets_nv0: if m0 in ms0: continue elems_m1 = self.mb.get_entities_by_handle(m1) elems_m0 = self.mb.get_entities_by_handle(m0) inter = rng.intersect(elems_m1, elems_m0) if len(inter) > 0: if np.allclose(np.array(elems_m0), np.array(inter)): ms0.add(m0) self.mb.add_child_meshset(m1, m0) else: raise RuntimeError( 'Tamanho das malhas nao compativel')
#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) #-------------------------------------------------------------------------------
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 __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 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 GenerateOthersLevels(self, tag_primal, tag_lv_id, level, centroid_tag, fine_to_primal_tag): 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) ms0 = set( ) # meshsets locais que permanecem no nivel local caso nao haja mais niveis ms02 = set() ## verificando quais volumes permanecem no nivel anterior for meshset in meshsets_current_level: # childs = self.gen_lv.mb.get_child_meshsets(meshset) elements_in_meshset = self.gen_lv.mb.get_entities_by_handle( meshset) inter1 = rng.intersect(elements_in_meshset, self.elems_with_level) if len(inter1) == 0: ms0.add(meshset) continue elif len(inter1) == len(elements_in_meshset): ms02.add(meshset) continue else: # len(inter1) > 0 and len(inter1) < len(elements_in_meshset): elements_for_set_level = rng.subtract(elements_in_meshset, inter1) self.gen_lv.mb.tag_set_data( self.level_tag, elements_for_set_level, np.repeat(level - 1, len(elements_for_set_level))) self.elems_with_level = rng.unite(self.elems_with_level, elements_for_set_level) ms02.add(meshset) ################################################################################# ## verificando quais volumes sao vizinhos dos do nivel anterior elements_level_ant = 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])) adjs = self.gen_lv.mtu.get_bridge_adjacencies(elements_level_ant, 2, 3) adjs = rng.subtract(adjs, self.elems_with_level) ms = set() ms2 = [] for adj in adjs: if adj in ms: continue nc = self.gen_lv.mb.tag_get_data(fine_to_primal_tag, adj, flat=True)[0] elements = self.gen_lv.mb.get_entities_by_type_and_tag( self.gen_lv.mb.get_root_set(), types.MBHEX, np.array([fine_to_primal_tag]), np.array([nc])) meshset = self.gen_lv.mb.get_entities_by_type_and_tag( self.gen_lv.mb.get_root_set(), types.MBENTITYSET, np.array([fine_to_primal_tag]), np.array([nc])) ms0 = ms0 - set(meshset) ms = ms | set(elements) ms2.append(meshset) ms02.add(meshset) self.gen_lv.mb.tag_set_data(self.level_tag, elements, np.repeat(level, len(elements))) ############################################################################################ # 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 ms02: # continue # elems = self.gen_lv.mb.get_entities_by_handle(m) # if set(elems).issubset(set(self.elems_with_level)): # continue # else: # 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) # ms02.add(m) # ################################################################################# # n = len(vols_lv_0) # self.gen_lv.mb.tag_set_data(tag_lv_id, vols_lv_0, np.arange(0, n)) ################################################################ if level == len(self.gen_lv.tags_primals) and len( self.elems_with_level) < len(self.gen_lv.all_volumes): for m in ms0: elements = self.gen_lv.mb.tag_get_handle(m) self.gen_lv.mb.tag_set_data(self.level_tag, elements, np.repeat(level, len(elements))) self.elems_with_level = rng.unite(self.elems_with_level, elements) ms = set() n = 0 for elem in self.elems_with_level: if elem in ms: continue lev = self.gen_lv.mb.tag_get_data(self.level_tag, elem, flat=True)[0] if lev == 0: self.gen_lv.mb.tag_set_data(tag_lv_id, elem, n) ms.add(elem) # n+=1 else: nc = self.gen_lv.mb.tag_get_data( self.gen_lv.all_fine_to_primal_tags[lev - 1], elem, flat=True)[0] elems = self.gen_lv.mb.get_entities_by_type_and_tag( self.gen_lv.mb.get_root_set(), types.MBHEX, np.array([self.gen_lv.all_fine_to_primal_tags[lev - 1]]), np.array([nc])) self.gen_lv.mb.tag_set_data(tag_lv_id, elems, np.repeat(n, len(elems))) ms = ms | set(elems) # n+=1 n += 1
def __init__(self, data_loaded, Adjs, all_centroids, all_faces_in, all_kharm, all_volumes, injectors, producers, tags, mb, volumes_d, volumes_n, ler_anterior, mtu, wirebasket_elems_nv1): self.cfl_ini = 0.5 self.mi_w = float(data_loaded['dados_bifasico']['mi_w']) self.mi_o = float(data_loaded['dados_bifasico']['mi_o']) self.gama_w = float(data_loaded['dados_bifasico']['gama_w']) self.gama_o = float(data_loaded['dados_bifasico']['gama_o']) self.Sor = float(data_loaded['dados_bifasico']['Sor']) self.Swc = float(data_loaded['dados_bifasico']['Swc']) self.nw = float(data_loaded['dados_bifasico']['nwater']) self.no = float(data_loaded['dados_bifasico']['noil']) self.loops = int(data_loaded['dados_bifasico']['loops']) self.total_time = float(data_loaded['dados_bifasico']['total_time']) self.gravity = data_loaded['gravity'] # ler_anterior = data_loaded['ler_anterior'] self.Adjs = Adjs self.tags = tags self.all_centroids = mb.tag_get_data(tags['CENT'], all_volumes) self.all_faces_in = all_faces_in self.all_kharm = all_kharm self.map_volumes = dict(zip(all_volumes, range(len(all_volumes)))) self.map_faces_in = dict(zip(all_faces_in, range(len(all_faces_in)))) self.all_volumes = all_volumes self.wells_injector = injectors self.wells_producer = producers self.ids0 = mb.tag_get_data(tags['ID_reord_tag'], np.array(Adjs[:, 0]), flat=True) self.ids1 = mb.tag_get_data(tags['ID_reord_tag'], np.array(Adjs[:, 1]), flat=True) self.ids_volsd = mb.tag_get_data(tags['ID_reord_tag'], volumes_d, flat=True) self.values_d = mb.tag_get_data(tags['P'], volumes_d, flat=True) self.ids_volsn = mb.tag_get_data(tags['ID_reord_tag'], volumes_n, flat=True) self.values_n = mb.tag_get_data(tags['Q'], volumes_n, flat=True) self.phis = mb.tag_get_data(tags['PHI'], all_volumes, flat=True) self.faces_volumes = [ rng.intersect(mtu.get_bridge_adjacencies(v, 3, 2), all_faces_in) for v in all_volumes ] self.mb = mb self.ids_reord = self.mb.tag_get_data(self.tags['ID_reord_tag'], self.all_volumes, flat=True) self.map_global = dict(zip(self.all_volumes, self.ids_reord)) self.wirebasket_elems_nv1 = wirebasket_elems_nv1 self.mtu = mtu v0 = all_volumes[0] points = mtu.get_bridge_adjacencies(v0, 3, 0) coords = mb.tag_get_data(tags['NODES'], points) maxs = coords.max(axis=0) mins = coords.min(axis=0) hs = maxs - mins self.hs = hs self.Areas = np.array([hs[1] * hs[2], hs[0] * hs[2], hs[0] * hs[1]]) vol = hs[0] * hs[1] * hs[2] mb.tag_set_data(tags['VOLUME'], all_volumes, np.repeat(vol, len(all_volumes))) historico = np.array([ 'vpi', 'tempo_decorrido', 'prod_agua', 'prod_oleo', 'wor', 'dt', 'loop' ]) np.save('historico', historico) self.delta_t = 0.0 self.Vs = mb.tag_get_data(tags['VOLUME'], all_volumes, flat=True) self.V_total = float((self.Vs * self.phis).sum()) self.vpi = 0.0 self.hist2 = [] self.load_sats_ini(mb, tags['SAT']) if ler_anterior: self.load_infos() else: self.set_lamb() self.set_mobi_faces_ini() pass
def calc_cfl(self, all_faces_in): """ cfl usando fluxo em cada volume """ lim_sup = 1e20 self.cfl = self.cfl_ini self.all_faces_in = all_faces_in qs = self.mb.tag_get_data(self.flux_in_faces_tag, all_faces_in, flat=True) dfdss = self.mb.tag_get_data(self.dfds_tag, all_faces_in, flat=True) Adjs = [self.mb.get_adjacencies(face, 3) for face in all_faces_in] all_volumes = self.mtu.get_bridge_adjacencies(all_faces_in, 2, 3) delta_ts = np.zeros(len(all_volumes)) faces_volumes = [ self.mtu.get_bridge_adjacencies(v, 3, 2) for v in all_volumes ] phis = self.mb.tag_get_data(self.phi_tag, all_volumes, flat=True) Vs = self.mb.tag_get_data(self.volume_tag, all_volumes, flat=True) map_faces = dict(zip(all_faces_in, range(len(all_faces_in)))) # self.delta_t = self.cfl*(self.fimin*self.Vmin)/float(qmax*dfdsmax) for i, v in enumerate(all_volumes): V = Vs[i] phi = phis[i] if phi == 0: delta_ts[i] = lim_sup continue faces = faces_volumes[i] faces = rng.intersect(all_faces_in, faces) ids_faces = [map_faces[f] for f in faces] q_faces = qs[ids_faces] dfdss_faces = dfdss[ids_faces] qmax = q_faces.max() ind = np.where(q_faces == qmax)[0] dfds = dfdss_faces[ind][0] if dfds == 0.0: dt1 = lim_sup else: qmax = abs(qmax) dt1 = self.cfl * (phi * V) / float(qmax * dfds) if dt1 < 0: print('erro') import pdb pdb.set_trace() dfds_max = dfdss_faces.max() if dfds_max == 0: dt2 = dt1 else: ind = np.where(dfdss_faces == dfds_max)[0] q2 = abs(q_faces[ind][0]) dt2 = self.cfl * (phi * V) / float(q2 * dfds_max) if dt2 < 0: print('erro') import pdb pdb.set_trace() delta_ts[i] = min([dt1, dt2]) if delta_ts[i] > self.delta_t_min: pass # delta_ts[i] = self.delta_t_min self.delta_t = delta_ts.min() self.flux_total_prod = self.mb.tag_get_data(self.total_flux_tag, self.wells_producer, flat=True).sum() self.flux_total_producao = self.flux_total_prod
for adj in adjs: nc_adj = M1.mb.tag_get_data(fine_to_primal1_classic_tag, adj, flat=True)[0] if nc_adj == nc or nc_adj in past_list_nc_adj or nc_adj in past_list_nc: continue past_list_nc_adj.add(nc_adj) faces_boundary_nc_adj = all_faces_boundary_nv1[nc_adj] meshset_adj = list(M1.mb.get_entities_by_type_and_tag( M1.root_set, types.MBENTITYSET, np.array([primal_id_tag1]), np.array([nc_adj])))[0] all_adjs = M1.mb.get_entities_by_handle(meshset_adj) all_faces_nc = M1.mtu.get_bridge_adjacencies(elems, 3, 2) all_faces_nc_adj = M1.mtu.get_bridge_adjacencies(all_adjs, 3, 2) intersect_faces = rng.intersect(all_faces_nc, all_faces_nc_adj) M1.mb.add_entities(faces_boundary_nc, intersect_faces) M1.mb.add_entities(faces_boundary_nc_adj, intersect_faces) neigh_meshsets[nc].append(nc_adj) neigh_meshsets[nc_adj].append(nc) past_list_nc.add(nc) neighs_nc = np.array(neigh_meshsets[nc]) kk = len(neighs_nc) if kk < 6: neighs_nc = np.append(neighs_nc, np.repeat(-1, 6-kk)) M1.mb.tag_set_data(neigh_volumes_nv1_tag, meshset, neighs_nc) for nc in neigh_meshsets.keys(): meshset = list(M1.mb.get_entities_by_type_and_tag(
faces = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]), np.array([1])) arestas = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]), np.array([2])) vertices = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]), np.array([3])) elems_wirebasket = np.array( list(internos) + list(faces) + list(arestas) + list(vertices)) M1.mb.tag_set_data(fine_to_primal1_classic_tag, vertices, np.arange(0, len(vertices))) for meshset in meshsets_nv1: elems = M1.mb.get_entities_by_handle(meshset) vert = rng.intersect(elems, vertices) nc = M1.mb.tag_get_data(fine_to_primal1_classic_tag, vert, flat=True)[0] M1.mb.tag_set_data(fine_to_primal1_classic_tag, elems, np.repeat(nc, len(elems))) M1.mb.tag_set_data(primal_id_tag1, meshset, nc) ni = len(internos) nf = len(faces) na = len(arestas) nv = len(vertices) tmod2 = time.time() nni = ni nnf = nni + nf nne = nnf + na nnv = nne + nv