def test_range_methods(): mb = core.Core() coord = np.array((1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6), dtype='float64') range_a = mb.create_vertices(coord) coord = np.array((2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7), dtype='float64') range_b = mb.create_vertices(coord) CHECK_EQ(range_a.all_of_dimension(0), True) CHECK_EQ(range_b.all_of_dimension(0), True) CHECK_EQ(range_a.all_of_dimension(1), False) CHECK_EQ(range_b.all_of_dimension(1), False) CHECK_EQ(range_a.num_of_dimension(0), range_a.size()) CHECK_EQ(range_b.num_of_dimension(0), range_b.size()) CHECK_EQ(range_a.num_of_dimension(1), 0) CHECK_EQ(range_b.num_of_dimension(1), 0) CHECK_EQ(range_a.num_of_type(types.MBVERTEX), range_a.size()) CHECK_EQ(range_b.num_of_type(types.MBVERTEX), range_b.size()) range_intersect = intersect(range_a, range_b) CHECK_EQ(range_intersect.size(), 0) range_unite = unite(range_a, range_b) CHECK_EQ(range_unite.size(), 12) range_subtract = subtract(range_a, range_b) CHECK_EQ(range_subtract.size(), range_a.size()) range_a.erase(range_a[0]) CHECK_EQ(range_a.size(), 5) all_verts = mb.get_entities_by_type(0, types.MBVERTEX) CHECK_EQ(all_verts.size(), 12) range_intersect = intersect(all_verts, range_a) CHECK_EQ(range_intersect.size(), 5) range_intersect = intersect(all_verts, range_b) CHECK_EQ(range_intersect.size(), 6) range_unite = unite(all_verts, range_a) CHECK_EQ(range_unite.size(), 12) range_unite = unite(all_verts, range_b) CHECK_EQ(range_unite.size(), 12) range_subtract = subtract(all_verts, range_a) CHECK_EQ(range_subtract.size(), 7) range_subtract = subtract(all_verts, range_b) CHECK_EQ(range_subtract.size(), 6) range_a.merge(range_b) CHECK_EQ(range_a.size(), 11)
def get_OP2_ADM(mesh, n1, n2): OP3 = mesh.matrices['OP2_AMS'].copy() nivel_0 = mesh.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([L3_ID_tag]), np.array([1])) nivel_1 = mesh.mb.get_entities_by_type_and_tag(mesh.mv, types.MBHEX, np.array([L3_ID_tag]), np.array([2])) nivel_0_e_1 = rng.unite(nivel_0, nivel_1) nivel_0v = mesh.mb.get_entities_by_type_and_tag(mesh.mv, types.MBHEX, np.array([L3_ID_tag]), np.array([1])) nivel_0_e_1_v = rng.unite(nivel_0v, nivel_1) IDs_AMS1 = mesh.mb.tag_get_data(mesh.tags['FINE_TO_PRIMAL1_CLASSIC'], nivel_0_e_1_v, flat=True) OP3[IDs_AMS1] = sp.csc_matrix((1, OP3.shape[1])) IDs_ADM_2 = mesh.mb.tag_get_data(L2_ID_tag, mesh.wirebasket_elems[1][3], flat=True) IDs_AMS_2 = mesh.mb.tag_get_data(mesh.tags['FINE_TO_PRIMAL2_CLASSIC'], mesh.wirebasket_elems[1][3], flat=True) lp = IDs_AMS_2 cp = IDs_ADM_2 dp = np.repeat(1, len(lp)) permutc = sp.csc_matrix((dp, (lp, cp)), shape=(len(mesh.wirebasket_elems[1][3]), n2)) opad3 = OP3 * permutc IDs_ADM_1 = mesh.mb.tag_get_data(L1_ID_tag, vertices, flat=True) IDs_AMS_1 = mesh.mb.tag_get_data(mesh.tags['FINE_TO_PRIMAL1_CLASSIC'], mesh.wirebasket_elems[0][3], flat=True) lp = IDs_ADM_1 cp = IDs_AMS_1 dp = np.repeat(1, len(lp)) permutl = sp.csc_matrix((dp, (lp, cp)), shape=(n1, len(vertices))) opad3 = permutl * opad3 m = sp.find(opad3) l1 = m[0] c1 = m[1] d1 = m[2] ID_global1 = mesh.mb.tag_get_data(L1_ID_tag, nivel_0_e_1, flat=True) IDs_ADM1 = mesh.mb.tag_get_data(L2_ID_tag, nivel_0_e_1, flat=True) l1 = np.concatenate([l1, ID_global1]) c1 = np.concatenate([c1, IDs_ADM1]) d1 = np.concatenate([d1, np.ones(len(nivel_0_e_1))]) opad3 = sp.csc_matrix((d1, (l1, c1)), shape=(n1, n2)) return opad3
def adjs(self, range,x): rnb = rng.Range() #import pdb; pdb.set_trace() it = ([self.mb.get_adjacencies(el, x) for el in range]) for el in it: rnb = rng.unite(rnb, el) return rnb
def write_geometry(self, sname, sdir): """Writes out the geometry stored in memory. Input: ------ sname: string, name of file to save written file sdir: string, absolute path for writing file """ # only write out volumes and surfaces that were not deleted vol_list = [] surf_list = [] for isovol in self.isovol_meshsets.keys(): vol_list.append(isovol[1]) surf_list.extend(self.isovol_meshsets[isovol]['surfs_EH']) # convert to ranges and unite all_meshsets = unite(Range(set(vol_list)), Range(set(surf_list))) # check file extension of save name: ext = sname.split(".")[-1] if ext.lower() not in ['h5m', 'vtk']: warnings.warn("File extension {} ".format(ext) + " not recognized. File will be saved as type .h5m.") sname = sname.split(".")[0] + ".h5m" # save the file save_location = sdir + "/" + sname self.mb.write_file(save_location, all_meshsets) print("Geometry file written to {}.".format(save_location))
def all_coarse_neighbors(self): trange = rng.Range() for el in self.coarse_neighbors_dic.values(): trange = rng.unite(trange, el) if self.is_on_father_boundary: trange = rng.subtract(trange, self.coarse_neighbors_dic[max(self.coarse_neighbors_dic.keys())]) return self.read(trange)
def SetLv0(self): wells = self.dfw.get_all_wells() cent_wells = np.array( [self.gen_lv.mtu.get_average_position([v]) for v in wells]) vols_lv_0 = rng.Range() vols_lv_0 = rng.unite(vols_lv_0, wells) for well, cent in zip(wells, cent_wells): dists = self.gen_lv.vols_centroids - cent dists = np.array(list(map(CalculateDistance, dists))) dists = dists < self.rs[0] vols = np.array(self.gen_lv.all_volumes)[dists] if len(vols) > 0: vols_lv_0 = rng.unite(vols_lv_0, rng.Range(vols)) self.gen_lv.mb.tag_set_data(self.level_tag, vols_lv_0, np.repeat(0, len(vols_lv_0)))
def find_boundary_elements(self): #self.mtu = topo_util.MeshTopoUtil(self.mb) rnb = rng.Range() it = ([self.mtu.get_bridge_adjacencies(el, 2,3) for el in self.faces]) for el in it: rnb = rng.unite(rnb, el) return rnb
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=s = rng.unite(self.all_coarse_neighbors_range,el) self.elements_in_coarse_neighborhood = GetItem(self._elements_in_coarse_neighborhood)
def organize_OP1_ADM_v2(self): PAD = self.OP1_AMS torganize = time.time() OP4 = PAD.copy() mver = M1.mb.create_meshset() M1.mb.add_entities(mver, vertices) vnv1 = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([L3_ID_tag]), np.array([2])) vnv2 = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([L3_ID_tag]), np.array([3])) vs = rng.unite(vnv1, vnv2) IDs_AMS_vs = M1.mb.tag_get_data(M1.ID_reordenado_tag, vs, flat=True) IDs_ADM_vs = IDs_AMS_vs lines = IDs_ADM_vs cols = IDs_AMS_vs data = np.ones(len(lines)) permut_elim = csc_matrix( (data, (lines, cols)), shape=(len(M1.all_volumes), len(M1.all_volumes))) IDs_AMS_vert = M1.mb.tag_get_data(fine_to_primal1_classic_tag, vertices, flat=True) IDs_ADM_vert = M1.mb.tag_get_data(L1_ID_tag, vertices, flat=True) lines = IDs_AMS_vert cols = IDs_ADM_vert data = np.ones(len(lines)) permut = csc_matrix((data, (lines, cols)), shape=(len(vertices), n1)) vnv0 = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([L3_ID_tag]), np.array([1])) IDs_ADM_vnv0 = M1.mb.tag_get_data(M1.ID_reordenado_tag, vnv0, flat=True) IDs_AMS_vnv0 = M1.mb.tag_get_data(L1_ID_tag, vnv0, flat=True) lines = IDs_ADM_vnv0 cols = IDs_AMS_vnv0 data = np.ones(len(lines)) somar = csc_matrix((data, (lines, cols)), shape=(len(M1.all_volumes), n1)) operador1 = permut_elim * PAD * permut + somar #print(time.time()-torganize,"organize novo!!!") return operador1
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 generate_adm_mesh(self, mesh, SOL_ADM_f): n1 = 0 n2 = 0 aux = 0 meshset_by_L2 = self.meshset_by_L2 D1_tag = mesh.tags['d1'] finos = list(mesh.volumes_f) intermediarios = mesh.intermediarios L1_ID_tag = mesh.tags['l1_ID'] L2_ID_tag = mesh.tags['l2_ID'] L3_ID_tag = mesh.tags['NIVEL_ID'] ares2_tag = self.ares2_tag ares6_tag = self.ares6_tag ares4_tag = self.ares4_tag ares9_tag = self.ares9_tag for m2 in meshset_by_L2: tem_poço_no_vizinho = False meshset_by_L1 = mesh.mb.get_child_meshsets(m2) for m1 in meshset_by_L1: elem_by_L1 = mesh.mb.get_entities_by_handle(m1) ver_1 = mesh.mb.get_entities_by_type_and_tag( m1, types.MBHEX, np.array([D1_tag]), np.array([3])) ver_1 = rng.unite( ver_1, mesh.mb.get_entities_by_type_and_tag( m1, types.MBTET, np.array([D1_tag]), np.array([3]))) if ver_1[0] in finos: aux = 1 tem_poço_no_vizinho = True else: viz_vertice = mesh.mtu.get_bridge_adjacencies(ver_1, 2, 3) k_vert = float( mesh.mb.tag_get_data(mesh.tags['PERM'], ver_1)[:, 0]) k_viz = mesh.mb.tag_get_data(mesh.tags['PERM'], viz_vertice)[:, 0] # raz=float(mesh.mb.tag_get_data(raz_tag,ver_1)) perm1 = mesh.mb.tag_get_data(mesh.tags['PERM'], elem_by_L1) med1_x = sum(perm1[:, 0]) / len(perm1[:, 0]) med1_y = sum(perm1[:, 4]) / len(perm1[:, 4]) med1_z = sum(perm1[:, 8]) / len(perm1[:, 8]) gids_primal = mesh.mb.tag_get_data( mesh.tags['ID_reord_tag'], elem_by_L1) press_primal = SOL_ADM_f[gids_primal] ares = mesh.mb.get_entities_by_type_and_tag( m1, types.MBHEX, np.array([D1_tag]), np.array([2])) viz_ares = mesh.mtu.get_bridge_adjacencies(ares, 2, 3) ares_m = mesh.mb.create_meshset() mesh.mb.add_entities(ares_m, viz_ares) viz_ares_ares = mesh.mb.get_entities_by_type_and_tag( ares_m, types.MBHEX, np.array([D1_tag]), np.array([2])) ares = viz_ares_ares viz_ares = mesh.mtu.get_bridge_adjacencies(ares, 2, 3) ares_m = mesh.mb.create_meshset() mesh.mb.add_entities(ares_m, viz_ares) viz_ares_ares = mesh.mb.get_entities_by_type_and_tag( ares_m, types.MBHEX, np.array([D1_tag]), np.array([2])) viz_ares_ver = mesh.mb.get_entities_by_type_and_tag( ares_m, types.MBHEX, np.array([D1_tag]), np.array([3])) viz_ares_fac = mesh.mb.get_entities_by_type_and_tag( ares_m, types.MBHEX, np.array([D1_tag]), np.array([1])) viz_ares_ares = rng.unite(viz_ares_ares, viz_ares_ver) viz_ares_ares = rng.unite(viz_ares_ares, ver_1) viz_ares_ares = rng.unite(viz_ares_ares, viz_ares_fac) ares = viz_ares_ares k_ares_max = mesh.mb.tag_get_data(mesh.tags['PERM'], ares)[:, 0].max() k_ares_min = mesh.mb.tag_get_data(mesh.tags['PERM'], ares)[:, 0].min() r_k_are_ver = float((k_ares_max - k_ares_min) / k_vert) #mesh.mb.tag_set_data(ares_tag, ares, np.repeat(r_k_are_ver,len(ares))) r_k_are_ver = float(mesh.mb.tag_get_data(ares2_tag, ver_1)) # var=float(mesh.mb.tag_get_data(var_tag,ver_1)) # var2=float(mesh.mb.tag_get_data(var2_tag,ver_1)) # ar=float(mesh.mb.tag_get_data(ares_tag,ver_1)) # ar3=float(mesh.mb.tag_get_data(ares3_tag,ver_1)) ar4 = mesh.mb.tag_get_data(ares4_tag, mesh.mtu.get_bridge_adjacencies( elem_by_L1, 2, 3), flat=True).max() #ar5=float(mesh.mb.tag_get_data(ares5_tag,ver_1)) ar6 = float(mesh.mb.tag_get_data(ares6_tag, ver_1)) viz_meshset = mesh.mtu.get_bridge_adjacencies( elem_by_L1, 2, 3) so_viz = rng.subtract(viz_meshset, elem_by_L1) m7 = max(mesh.mb.tag_get_data(ares6_tag, so_viz, flat=True)) # m8=max(mesh.mb.tag_get_data(var_tag,so_viz,flat=True)) # a7=ar6/var # a8=ar4*(1+a7)**3 a9 = float(mesh.mb.tag_get_data(ares9_tag, ver_1)) # mesh.mb.tag_set_data(ares7_tag,ver_1,a7) # mesh.mb.tag_set_data(ares8_tag,elem_by_L1,np.repeat(ar4/a9,len(elem_by_L1))) mesh.mb.tag_set_data(ares9_tag, elem_by_L1, np.repeat(a9, len(elem_by_L1))) # max_grad=get_max_grad(m1) # mesh.mb.tag_set_data(grad_tag,elem_by_L1,np.repeat(max_grad/grad_p_res,len(elem_by_L1))) #if med1_x<val_barreira or med1_x>val_canal or raz>raz_lim or var<1 or r_k_are_ver>100 or (max_grad>20*grad_p_res and (r_k_are_ver>200 or var2>10000)) or (max_grad>5*grad_p_res and r_k_are_ver>10000) or (max_grad>20*grad_p_res and var<15) or (max_grad>50*grad_p_res and var<25) or ar>1000: #if med1_x<val_barreira or med1_x>val_canal or raz>raz_lim or (max_grad>35*grad_p_res and (r_k_are_ver>500 or var<2 or (r_k_are_ver>100 and ar>5)) or ar3>3) or (max_grad>20*grad_p_res and (r_k_are_ver>400 or ar>100 or var2>200)) or var<1 or (r_k_are_ver>5000 and var<2) or r_k_are_ver>10000: #if med1_x<val_barreira or med1_x>val_canal or (ar3>20 and var<1) or (r_k_are_ver>10000 and ar4>0.01) or (ar4>0.05 and (ar3>2 or r_k_are_ver>100 or ar>20 or var<3 or med1_x<vt)) or (r_k_are_ver>2000 and var<4) or ar5<30: #if (ar5<50 and ar4>0.5) or (ar5<40 and ar4>0.4) or (ar5<30 and ar4>0.3) or var<1 or ar6<20: # bom _______ or ((ar5<30 or var<5) and ar4>0.01) #if ar4>0.2 or (ar6<200 and ar4>0.2) or (ar6<80 and ar4>0.05) or ((var<10 and a8>10) and ar4>0.04) or ar6<20 or var<1 or a8>100 or (a7>0.5 and ar4>0.02) or a7>1: #if (ar4/a9>0.02 and (ar6<40 or a9<0.05 or r_k_are_ver>10000)) or (ar4/a9>0.04 and (ar6<40 or a9<0.1 or r_k_are_ver>5000)) or (ar4/a9>0.2 and (ar6<300 or a9<0.3 or r_k_are_ver>1000)) or (ar4/a9>0.3 and (ar6<400 or a9<0.5 or r_k_are_ver>500)):#excelente #if (ar4/a9>0.02 and (ar6<40 or a9<0.05 or r_k_are_ver>10000)) or (ar4/a9>0.04 and (ar6<40 or a9<0.1 or r_k_are_ver>5000)) or (ar4/a9>0.1 and (ar6<100 and a9<0.4 or r_k_are_ver>100)) or (ar4/a9>0.2 and (ar6<300 and a9<0.3 and r_k_are_ver>1000)) or (ar4/a9>0.25 and (ar6<400 or a9<0.5 or r_k_are_ver>500)):#excelente if (ar4 / a9 > 0.02 and (ar6 < 40 or a9 < 0.05 or r_k_are_ver > 10000)) or ( ar4 / a9 > 0.04 and (ar6 < 40 or a9 < 0.1 or r_k_are_ver > 5000)) or ( ar4 / a9 > 0.1 and (ar6 < 100 and a9 < 0.4 and r_k_are_ver > 100) ) or (ar4 / a9 > 0.2 and (ar6 < 300 and a9 < 0.3 and r_k_are_ver > 1000)) or (ar4 / a9 > 0.25 and (ar6 < 400 or a9 < 0.5 or r_k_are_ver > 500)): #if ar>20 or r_k_are_ver>2000: aux = 1 tem_poço_no_vizinho = True if ver_1[0] in intermediarios: tem_poço_no_vizinho = True if aux == 1: aux = 0 for elem in elem_by_L1: n1 += 1 n2 += 1 mesh.mb.tag_set_data(L1_ID_tag, elem, n1) mesh.mb.tag_set_data(L2_ID_tag, elem, n2) mesh.mb.tag_set_data(L3_ID_tag, elem, 1) finos.append(elem) if tem_poço_no_vizinho == False: elem_by_L2 = mesh.mb.get_entities_by_handle(m2) vers = mesh.mb.get_entities_by_type_and_tag( m2, types.MBHEX, np.array([D1_tag]), np.array([3])) r_k_are_ver = mesh.mb.tag_get_data(ares2_tag, vers, flat=True) if max(r_k_are_ver) > 1000: tem_poço_no_vizinho = True if tem_poço_no_vizinho: for m1 in meshset_by_L1: elem_by_L1 = mesh.mb.get_entities_by_handle(m1) n1 += 1 n2 += 1 t = 1 ver_1 = mesh.mb.get_entities_by_type_and_tag( m1, types.MBHEX, np.array([D1_tag]), np.array([3])) ver_1 = rng.unite( ver_1, mesh.mb.get_entities_by_type_and_tag( m1, types.MBTET, np.array([D1_tag]), np.array([3]))) if ver_1[0] not in finos: mesh.mb.tag_set_data(L1_ID_tag, elem_by_L1, np.repeat(n1, len(elem_by_L1))) mesh.mb.tag_set_data(L2_ID_tag, elem_by_L1, np.repeat(n2, len(elem_by_L1))) mesh.mb.tag_set_data(L3_ID_tag, elem_by_L1, np.repeat(2, len(elem_by_L1))) t = 0 n1 -= t n2 -= t else: n2 += 1 for m1 in meshset_by_L1: elem_by_L1 = mesh.mb.get_entities_by_handle(m1) n1 += 1 mesh.mb.tag_set_data(L2_ID_tag, elem_by_L1, np.repeat(n2, len(elem_by_L1))) mesh.mb.tag_set_data(L1_ID_tag, elem_by_L1, np.repeat(n1, len(elem_by_L1))) mesh.mb.tag_set_data(L3_ID_tag, elem_by_L1, np.repeat(3, len(elem_by_L1))) tags = [L1_ID_tag, L2_ID_tag] for tag in tags: try: all_gids = mesh.mb.tag_get_data(tag, mesh.all_volumes, flat=True) except: pdb.set_trace() minim = min(all_gids) all_gids -= minim mesh.mb.tag_set_data(tag, mesh.all_volumes, all_gids) return n1, n2
def geracao_adm1_mesh(mesh): n1 = 0 n2 = 0 aux = 0 var_tag = mesh.mb.tag_get_handle("var", 1, types.MB_TYPE_DOUBLE, types.MB_TAG_SPARSE, True) mesh.tags['var'] = var_tag vertices = mesh.wirebasket_elems[0][3] gids = mesh.mb.tag_get_data(mesh.tags['ID_reord_tag'], vertices, flat=True) diagon = np.array( abs(mesh.matrices['Tf'][gids].min(axis=1)).toarray().transpose()[0]) mesh.mb.tag_set_data(var_tag, vertices, diagon) meshset_by_L2 = mesh.mb.get_child_meshsets(mesh.L2_meshset) for m2 in meshset_by_L2: tem_poço_no_vizinho = False meshset_by_L1 = mesh.mb.get_child_meshsets(m2) for m1 in meshset_by_L1: elem_by_L1 = mesh.mb.get_entities_by_handle(m1) ver_1 = mesh.mb.get_entities_by_type_and_tag( m1, types.MBHEX, np.array([D1_tag]), np.array([3])) ver_1 = rng.unite( ver_1, mesh.mb.get_entities_by_type_and_tag(m1, types.MBTET, np.array([D1_tag]), np.array([3]))) if ver_1[0] in finos: aux = 1 tem_poço_no_vizinho = True else: # viz_vertice=mesh.mtu.get_bridge_adjacencies(ver_1,2,3) # k_vert=float(mesh.mb.tag_get_data(mesh.perm_tag,ver_1)[:,0]) # k_viz=mesh.mb.tag_get_data(mesh.perm_tag,viz_vertice)[:,0] # raz=float(mesh.mb.tag_get_data(raz_tag,ver_1)) perm1 = mesh.mb.tag_get_data(mesh.tags['PERM'], elem_by_L1) med1_x = sum(perm1[:, 0]) / len(perm1[:, 0]) # med1_y=sum(perm1[:,4])/len(perm1[:,4]) # med1_z=sum(perm1[:,8])/len(perm1[:,8]) # gids_primal=mesh.mb.tag_get_data(mesh.ID_reordenado_tag,elem_by_L1) # press_primal=SOL_ADM_f[gids_primal] # ares=mesh.mb.get_entities_by_type_and_tag(m1, types.MBHEX, np.array([D1_tag]), np.array([2])) # # viz_ares=mesh.mtu.get_bridge_adjacencies(ares,2,3) # ares_m=mesh.mb.create_meshset() # mesh.mb.add_entities(ares_m,viz_ares) # viz_ares_ares=mesh.mb.get_entities_by_type_and_tag(ares_m, types.MBHEX, np.array([D1_tag]), np.array([2])) # ares=viz_ares_ares # # viz_ares=mesh.mtu.get_bridge_adjacencies(ares,2,3) # ares_m=mesh.mb.create_meshset() # mesh.mb.add_entities(ares_m,viz_ares) # viz_ares_ares=mesh.mb.get_entities_by_type_and_tag(ares_m, types.MBHEX, np.array([D1_tag]), np.array([2])) # viz_ares_ver=mesh.mb.get_entities_by_type_and_tag(ares_m, types.MBHEX, np.array([D1_tag]), np.array([3])) # viz_ares_fac=mesh.mb.get_entities_by_type_and_tag(ares_m, types.MBHEX, np.array([D1_tag]), np.array([1])) # viz_ares_ares=rng.unite(viz_ares_ares,viz_ares_ver) # viz_ares_ares=rng.unite(viz_ares_ares,ver_1) # viz_ares_ares=rng.unite(viz_ares_ares,viz_ares_fac) # ares=viz_ares_ares # k_ares_max=mesh.mb.tag_get_data(mesh.perm_tag,ares)[:,0].max() # k_ares_min=mesh.mb.tag_get_data(mesh.perm_tag,ares)[:,0].min() # r_k_are_ver=float((k_ares_max-k_ares_min)/k_vert) #mesh.mb.tag_set_data(ares_tag, ares, np.repeat(r_k_are_ver,len(ares))) r_k_are_ver = float(mesh.mb.tag_get_data(ares2_tag, ver_1)) # # # var = float(mesh.mb.tag_get_data(var_tag, ver_1)) # var2=float(mesh.mb.tag_get_data(var2_tag,ver_1)) # ar=float(mesh.mb.tag_get_data(ares_tag,ver_1)) # ar3=float(mesh.mb.tag_get_data(ares3_tag,ver_1)) # ar4=mesh.mb.tag_get_data(ares4_tag,mesh.mtu.get_bridge_adjacencies(elem_by_L1,2,3),flat=True).max() # #ar5=float(mesh.mb.tag_get_data(ares5_tag,ver_1)) # ar6=float(mesh.mb.tag_get_data(ares6_tag,ver_1)) # # viz_meshset=mesh.mtu.get_bridge_adjacencies(elem_by_L1,2,3) # so_viz=rng.subtract(viz_meshset,elem_by_L1) # m7=max(mesh.mb.tag_get_data(ares6_tag,so_viz,flat=True)) # m8=max(mesh.mb.tag_get_data(var_tag,so_viz,flat=True)) # a7=ar6/var # a8=ar4*(1+a7)**3 # if first: # a9=1.0 # else: # a9=float(mesh.mb.tag_get_data(ares9_tag,ver_1)) # mesh.mb.tag_set_data(ares7_tag,ver_1,a7) # mesh.mb.tag_set_data(ares8_tag,elem_by_L1,np.repeat(ar4/a9,len(elem_by_L1))) # mesh.mb.tag_set_data(ares9_tag,elem_by_L1,np.repeat(a9,len(elem_by_L1))) # # if first: # max_grad=0 # else: # max_grad=get_max_grad(m1) # mesh.mb.tag_set_data(grad_tag,elem_by_L1,np.repeat(max_grad/grad_p_res,len(elem_by_L1))) # # # if med1_x < val_barreira or med1_x > val_canal or var < 1 or r_k_are_ver > 100: aux = 1 tem_poço_no_vizinho = True if ver_1[0] in intermediarios: tem_poço_no_vizinho = True if aux == 1: aux = 0 for elem in elem_by_L1: n1 += 1 n2 += 1 mesh.mb.tag_set_data(L1_ID_tag, elem, n1) mesh.mb.tag_set_data(L2_ID_tag, elem, n2) mesh.mb.tag_set_data(L3_ID_tag, elem, 1) finos.append(elem) if tem_poço_no_vizinho == False: elem_by_L2 = mesh.mb.get_entities_by_handle(m2) if first: max_grad = 0 else: max_grad = get_max_grad(m2) vers = mesh.mb.get_entities_by_type_and_tag( m2, types.MBHEX, np.array([D1_tag]), np.array([3])) r_k_are_ver = mesh.mb.tag_get_data(ares2_tag, vers, flat=True) if max_grad > 3 * grad_p_res or max(r_k_are_ver) > 1000: tem_poço_no_vizinho = True if tem_poço_no_vizinho: for m1 in meshset_by_L1: elem_by_L1 = mesh.mb.get_entities_by_handle(m1) n1 += 1 n2 += 1 t = 1 ver_1 = mesh.mb.get_entities_by_type_and_tag( m1, types.MBHEX, np.array([D1_tag]), np.array([3])) ver_1 = rng.unite( ver_1, mesh.mb.get_entities_by_type_and_tag( m1, types.MBTET, np.array([D1_tag]), np.array([3]))) if ver_1[0] not in finos: mesh.mb.tag_set_data(L1_ID_tag, elem_by_L1, np.repeat(n1, len(elem_by_L1))) mesh.mb.tag_set_data(L2_ID_tag, elem_by_L1, np.repeat(n2, len(elem_by_L1))) mesh.mb.tag_set_data(L3_ID_tag, elem_by_L1, np.repeat(2, len(elem_by_L1))) t = 0 n1 -= t n2 -= t else: n2 += 1 for m1 in meshset_by_L1: elem_by_L1 = mesh.mb.get_entities_by_handle(m1) n1 += 1 mesh.mb.tag_set_data(L2_ID_tag, elem_by_L1, np.repeat(n2, len(elem_by_L1))) mesh.mb.tag_set_data(L1_ID_tag, elem_by_L1, np.repeat(n1, len(elem_by_L1))) mesh.mb.tag_set_data(L3_ID_tag, elem_by_L1, np.repeat(3, len(elem_by_L1))) tags = [L1_ID_tag, L2_ID_tag] for tag in tags: try: all_gids = mesh.mb.tag_get_data(tag, mesh.all_volumes, flat=True) except: pdb.set_trace() minim = min(all_gids) all_gids -= minim mesh.mb.tag_set_data(tag, mesh.all_volumes, all_gids) return n1, n2
def set_contraste(mesh): mesh.perm_tag = mesh.tags['PERM'] meshset_by_L2 = mesh.mb.get_child_meshsets(mesh.L2_meshset) max1 = 0 for m2 in meshset_by_L2: meshset_by_L1 = mesh.mb.get_child_meshsets(m2) for m1 in meshset_by_L1: ver_1 = mesh.mb.get_entities_by_type_and_tag( m1, types.MBHEX, np.array([D1_tag]), np.array([3])) viz_vert = mesh.mtu.get_bridge_adjacencies(ver_1, 1, 3) k_vert = mesh.mb.tag_get_data(mesh.perm_tag, ver_1)[:, 0] facs_ver1 = mesh.mtu.get_bridge_adjacencies(ver_1, 2, 2) max_r = 0 vers = [] # somak=0 for f in facs_ver1: viz_facs = mesh.mtu.get_bridge_adjacencies(f, 2, 3) ares_m = mesh.mb.create_meshset() mesh.mb.add_entities(ares_m, viz_facs) ares = mesh.mb.get_entities_by_type_and_tag( ares_m, types.MBHEX, np.array([D1_tag]), np.array([2])) if len(ares) > 0: viz_ares = mesh.mtu.get_bridge_adjacencies(ares, 2, 3) ares_m = mesh.mb.create_meshset() mesh.mb.add_entities(ares_m, viz_ares) ares_com_novas = mesh.mb.get_entities_by_type_and_tag( ares_m, types.MBHEX, np.array([D1_tag]), np.array([2])) novas_ares = rng.subtract(ares_com_novas, ares) ares = rng.unite(ares, novas_ares) for i in range(20): viz_ares = mesh.mtu.get_bridge_adjacencies( novas_ares, 2, 3) ares_m = mesh.mb.create_meshset() mesh.mb.add_entities(ares_m, viz_ares) ares_com_novas = mesh.mb.get_entities_by_type_and_tag( ares_m, types.MBHEX, np.array([D1_tag]), np.array([2])) novas_ares = rng.subtract(ares_com_novas, ares) ares = rng.unite(ares, novas_ares) if len(novas_ares) == 0: break a1 = ares gids_ares = mesh.mb.tag_get_data(mesh.tags['ID_reord_tag'], a1, flat=True) facs_ares = mesh.mtu.get_bridge_adjacencies(a1, 2, 2) # somak+= sum(mesh.mb.tag_get_data(mesh.k_eq_tag,facs_ares,flat=True))/k_vert ares = mesh.mtu.get_bridge_adjacencies(ares, 2, 3) ares_m = mesh.mb.create_meshset() mesh.mb.add_entities(ares_m, ares) verts = mesh.mb.get_entities_by_type_and_tag( ares_m, types.MBHEX, np.array([D1_tag]), np.array([3])) ares_ares = verts = mesh.mb.get_entities_by_type_and_tag( ares_m, types.MBHEX, np.array([D1_tag]), np.array([2])) v_verts = mesh.mtu.get_bridge_adjacencies(verts, 2, 3) ares_ares = rng.unite(ares_ares, verts) ares = rng.unite(ares, v_verts) k_ares_max = mesh.mb.tag_get_data(mesh.perm_tag, ares)[:, 0].max() k_ares_min = mesh.mb.tag_get_data(mesh.perm_tag, ares)[:, 0].min() # k_ares_med=sum(mesh.mb.tag_get_data(mesh.perm_tag,a1)[:,0])/len(ares) ver_2 = np.uint64(rng.subtract(verts, ver_1)) k_ver2 = mesh.mb.tag_get_data(mesh.perm_tag, ver_2)[0][0] vers.append(ver_2) perm_ares = mesh.mb.tag_get_data(mesh.perm_tag, ares)[:, 0] try: r_ver = mesh.mb.tag_get_data(ares2_tag, ver_1) r_k_are_ver = float( max((k_ares_max - k_ares_min) / min(k_vert, k_ver2), r_ver)) except: r_k_are_ver = float( (k_ares_max - k_ares_min) / min(k_vert, k_ver2)) r_k_are_ver = max(r_k_are_ver, max(k_vert, k_ver2) / perm_ares.min()) r_k_are_ver = max(r_k_are_ver, perm_ares.max() / min(k_vert, k_ver2)) if r_k_are_ver > max_r: max_r = r_k_are_ver #mesh.mb.tag_set_data(ares2_tag, ares, np.repeat(float((k_ares_max-k_ares_min)/k_vert),len(ares))) mesh.mb.tag_set_data(ares2_tag, ver_1, r_k_are_ver) perm_viz = mesh.mb.tag_get_data(mesh.tags['PERM'], viz_vert)[:, 0] # raz=float(k_vert/perm_viz.min()) # mesh.mb.tag_set_data(raz_tag, ver_1,raz) # mesh.mb.tag_set_data(var_tag, ver_1,var) # mesh.mb.tag_set_data(var2_tag, ver_1,somak) if max_r > 200: for v in vers: try: r_ver = mesh.mb.tag_get_data(ares2_tag, v) except: r_ver = 0 #mesh.mb.tag_set_data(ares2_tag, v,float(max(max_r/4,r_ver))) #k_ver2=mesh.mb.tag_get_data(mesh.perm_tag,ver_2)[:,0] #try: # r_ver=mesh.mb.tag_get_data(ares2_tag,ver_2) # r_k_are_ver=float(max((k_ares_max-k_ares_min)/k_ver2,r_ver)) #except: # r_k_are_ver=float((k_ares_max-k_ares_min)/k_ver2) #mesh.mb.tag_set_data(ares2_tag, ver_2,r_k_are_ver) del mesh.perm_tag
M1.mb.add_entities(intermediarios_meshset, intermediarios) M1.mb.tag_set_data(M1.intermediarios_tag, 0, intermediarios_meshset) print("definiu volumes na malha fina") pocos = M1.mb.get_entities_by_handle(pocos_meshset) volumes_d = M1.mb.get_entities_by_type_and_tag(M1.root_set, types.MBHEX, np.array([M1.press_value_tag]), np.array([None])) volumes_n = M1.mb.get_entities_by_type_and_tag(M1.root_set, types.MBHEX, np.array([M1.vazao_value_tag]), np.array([None])) finos_meshset = M1.mb.create_meshset() M1.mb.add_entities(finos_meshset, rng.unite(volumes_d, volumes_n)) M1.mb.add_entities(finos_meshset, pocos) M1.mb.add_entities(finos_meshset, finos) M1.mb.tag_set_data(M1.finos_tag, 0, finos_meshset) print("definiu poços") xmin = xmin_2 xmax = xmax_2 ymin = ymin_2 ymax = ymax_2 zmin = zmin_2 zmax = zmax_2 #------------------------------------------------------------------------------- # Criação do vetor que define a "grade" que separa os volumes da malha grossa
#for e in all_volumes: # centroid=M1.mtu.get_average_position([e]) # # Cent_wells -> Lista com o centroide de cada completação # for c in Cent_wels: # dx=(centroid[0]-c[0])**2 # dy=(centroid[1]-c[1])**2 # dz=(centroid[2]-c[2])**2 # distancia=dx+dy+dz # if dx<r0**2 and dy<r0**2 and dz<r0**2: # finos.append(e) # if dx<dx0/4+.1 and dy<dy0/4+.1 and dz<dz0/4+.1: # M1.mb.add_entities(pocos_meshset,[e]) # if distancia<r1**2 and dx<r1**2/2: # intermediarios.append(e) M1.mb.tag_set_data(M1.finos_tag, 0,pocos_meshset) finos=list(rng.unite(volumes_d,volumes_n)) print("definiu volumes na malha fina") pocos=M1.mb.get_entities_by_handle(pocos_meshset) finos_meshset = M1.mb.create_meshset() print("definiu poços") #------------------------------------------------------------------------------- #Determinação das dimensões do reservatório e dos volumes das malhas intermediária e grossa for v in M1.all_nodes: # M1.all_nodes -> todos os vértices da malha fina c=M1.mb.get_coords([v]) # Coordenadas de um nó if c[0]>xmax: xmax=c[0] if c[0]<xmin: xmin=c[0] if c[1]>ymax: ymax=c[1]
def generate_adm_mesh_v2(self, mb, all_volumes, loop=0): nn = len(all_volumes) map_volumes = dict(zip(all_volumes, range(nn))) list_L1_ID = np.zeros(nn, dtype=np.int32) list_L2_ID = list_L1_ID.copy() list_L3_ID = list_L1_ID.copy() L2_meshset = self.L2_meshset finos = mb.tag_get_data(self.tags['finos'], 0, flat=True)[0] finos = mb.get_entities_by_handle(finos) print(len(finos), 'tamanho finos 1\n') # intermediarios = self.intermediarios # intermediarios = rng.subtract(intermediarios, finos) # intermediarios2 = self.mtu.get_bridge_adjacencies(finos, 2, 3) # intermediarios2 = rng.subtract(intermediarios2, finos) # intermediarios = rng.unite(intermediarios, intermediarios2) ###################################################################### # ni = ID do elemento no nível i aux = 0 meshset_by_L2 = mb.get_child_meshsets(self.L2_meshset) print('\n') print("INICIOU GERAÇÃO DA MALHA ADM") print('\n') tempo0_ADM = time.time() t0 = tempo0_ADM for m1 in self.meshsets_nv1: elem_by_L1 = mb.get_entities_by_handle(m1) intersect1 = rng.intersect(elem_by_L1, finos) nn1 = len(intersect1) if nn1 > 0: finos = rng.unite(finos, elem_by_L1) print(len(finos), 'tamanho finos 2\n') intermediarios = rng.Range(np.array(self.intermediarios)) intermediarios2 = self.mtu.get_bridge_adjacencies(finos, 2, 3) intermediarios = rng.unite(intermediarios, intermediarios2) intermediarios = rng.subtract(intermediarios, finos) print(len(intermediarios), 'tamanho intermediarios 1\n') for m2 in self.meshsets_nv2: elem_by_L2 = mb.get_entities_by_handle(m2) intersect1 = rng.intersect(elem_by_L2, intermediarios) nn1 = len(intersect1) if nn1 > 0: intermediarios = rng.unite(intermediarios, elem_by_L2) print(len(intermediarios), 'tamanho intermediarios 2\n') print(len(finos) + len(intermediarios), '\n') print(len(all_volumes), '\n') import pdb pdb.set_trace() # elems_nv3 = rng.subtract(all_volumes, rng.unite(intermediarios, finos)) n1 = 0 n2 = 0 for m2 in self.meshsets_nv2: verif_nv3 = True verif_nv2 = False verif_nv1 = False elems_tot = [] meshset_by_L1 = mb.get_child_meshsets(m2) for m1 in meshset_by_L1: elem_by_L1 = mb.get_entities_by_handle(m1) ids_local_volumes = np.array( list((map_volumes[v] for v in elem_by_L1))) intersect1 = rng.intersect(elem_by_L1, finos) nn1 = len(intersect1) if nn1 > 0: verif_nv3 = False verif_nv1 = True ids_l1 = np.arange(n1, n1 + nn1) ids_l2 = np.arange(n2, n2 + nn1) list_L1_ID[ids_local_volumes] = ids_l1 list_L2_ID[ids_local_volumes] = ids_l2 list_L3_ID[ids_local_volumes] = np.repeat( 1, len(elem_by_L1)) elems_tot += list(elem_by_L1) n1 += nn1 n2 += nn1 continue intersect1 = rng.intersect(elem_by_L1, intermediarios) nn1 = len(intersect1) if nn1 > 0: verif_nv3 = False verif_nv2 = True ids_l1 = np.repeat(n1 + 1, len(elem_by_L1)) ids_l2 = np.repeat(n2 + 1, len(elem_by_L1)) list_L1_ID[ids_local_volumes] = ids_l1 list_L2_ID[ids_local_volumes] = ids_l2 list_L3_ID[ids_local_volumes] = np.repeat( 2, len(elem_by_L1)) elems_tot += list(elem_by_L1) n1 += 1 n2 += 1 continue elems_tot = rng.Range(elems_tot) elem_by_L2 = mb.get_entities_by_handle(m2) sub1 = rng.subtract(elem_by_L2, elems_tot) nn2 = len(sub1) if verif_nv3: for m1 in meshset_by_L1: elem_by_L1 = mb.get_entities_by_handle(m1) ids_local_volumes = np.array( list((map_volumes[v] for v in elem_by_L1))) ids_l1 = np.repeat(n1 + 1, len(elem_by_L1)) list_L1_ID[ids_local_volumes] = ids_l1 n1 += 1 ids_local_volumes = np.array( list((map_volumes[v] for v in elem_by_L2))) ids_l2 = np.repeat(n2 + 1, len(elem_by_L2)) list_L2_ID[ids_local_volumes] = ids_l2 list_L3_ID[ids_local_volumes] = np.repeat(3, len(elem_by_L2)) n2 += 1 continue if verif_nv2: for m1 in meshset_by_L1: elem_by_L1 = mb.get_entities_by_handle(m1) intersect1 = rng.intersect(elem_by_L1, elems_tot) nn1 = len(intersect1) if nn1 > 0: continue ids_local_volumes = np.array( list((map_volumes[v] for v in elem_by_L1))) ids_l1 = np.repeat(n1 + 1, len(elem_by_L1)) ids_l2 = np.repeat(n2 + 1, len(elem_by_L1)) list_L1_ID[ids_local_volumes] = ids_l1 list_L2_ID[ids_local_volumes] = ids_l2 list_L3_ID[ids_local_volumes] = np.repeat( 2, len(elem_by_L1)) elems_tot += list(elem_by_L1) n1 += 1 n2 += 1 continue if verif_nv1: for m1 in meshset_by_L1: elem_by_L1 = mb.get_entities_by_handle(m1) intersect1 = rng.intersect(elem_by_L1, elems_tot) nn1 = len(intersect1) if nn1 > 0: continue ids_local_volumes = np.array( list((map_volumes[v] for v in elem_by_L1))) ids_l1 = np.arange(n1, n1 + nn1) ids_l2 = np.repeat(n2, n2 + nn1) list_L1_ID[ids_local_volumes] = ids_l1 list_L2_ID[ids_local_volumes] = ids_l2 list_L3_ID[ids_local_volumes] = np.repeat( 1, len(elem_by_L1)) n1 += nn1 n2 += nn1 continue mb.tag_set_data(self.tags['l1_ID'], all_volumes, list_L1_ID) mb.tag_set_data(self.tags['l2_ID'], all_volumes, list_L2_ID) mb.tag_set_data(self.tags['l3_ID'], all_volumes, list_L3_ID)
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 topology(self, MM, lx, ly, lz, Lx, Ly, Lz): t0 = time.time() local_id_int_tag = MM.mb.tag_get_handle("local_id_internos", 1, types.MB_TYPE_INTEGER, types.MB_TAG_SPARSE, True) local_id_fac_tag = MM.mb.tag_get_handle("local_fac_internos", 1, types.MB_TYPE_INTEGER, types.MB_TAG_SPARSE, True) MM.mb.tag_set_data( local_id_int_tag, MM.all_volumes, np.repeat(len(MM.all_volumes) + 1, len(MM.all_volumes))) MM.mb.tag_set_data( local_id_fac_tag, MM.all_volumes, np.repeat(len(MM.all_volumes) + 1, len(MM.all_volumes))) self.tags['local_id_internos'] = local_id_int_tag self.tags['local_fac_internos'] = local_id_fac_tag sgids = 0 li = [] ci = [] di = [] cont = 0 intern_adjs_by_dual = [] faces_adjs_by_dual = [] dual_1_meshset = MM.mb.create_meshset() tag_dual_1_meshset = MM.mb.tag_get_handle('DUAL_1_MESHSET', 1, types.MB_TYPE_HANDLE, types.MB_TAG_MESH, True) MM.mb.tag_set_data(tag_dual_1_meshset, 0, dual_1_meshset) self.tags['DUAL_1_MESHSET'] = tag_dual_1_meshset D_x = self.D_x D_y = self.D_y D_z = self.D_z lxd1 = self.lxd1 lyd1 = self.lyd1 lzd1 = self.lzd1 D1_tag = self.tags['d1'] all_centroids = MM.all_centroids # for i in range(len(lxd1)-1): # x0=lxd1[i] # x1=lxd1[i+1] # for j in range(len(lyd1)-1): # y0=lyd1[j] # y1=lyd1[j+1] # for k in range(len(lzd1)-1): # z0=lzd1[k] # z1=lzd1[k+1] # tb=time.time() # box_dual_1=np.array([[x0-0.01,y0-0.01,z0-0.01],[x1+0.01,y1+0.01,z1+0.01]]) # vols=get_box(MM.all_volumes, all_centroids, box_dual_1, False) # tipo=MM.mb.tag_get_data(D1_tag,vols,flat=True) # inter=rng.Range(np.array(vols)[np.where(tipo==0)[0]]) # # MM.mb.tag_set_data(local_id_int_tag,inter,range(len(inter))) # add_topology(MM, inter,local_id_int_tag,intern_adjs_by_dual) # # fac=rng.Range(np.array(vols)[np.where(tipo==1)[0]]) # fac_centroids=np.array([MM.mtu.get_average_position([f]) for f in fac]) # # box_faces_x=np.array([[x0-lx/2,y0-ly/2,z0-lz/2],[x0+lx/2,y1+ly/2,z1+lz/2]]) # box_faces_y=np.array([[x0-lx/2,y0-ly/2,z0-lz/2],[x1+lx/2,y0+ly/2,z1+lz/2]]) # box_faces_z=np.array([[x0-lx/2,y0-ly/2,z0-lz/2],[x1+lx/2,y1+ly/2,z0+lz/2]]) # # faces_x=get_box(fac, fac_centroids, box_faces_x, False) # # faces_y=get_box(fac, fac_centroids, box_faces_y, False) # f1=rng.unite(faces_x,faces_y) # # faces_z=get_box(fac, fac_centroids, box_faces_z, False) # f1=rng.unite(f1,faces_z) # # if i==len(lxd1)-2: # box_faces_x2=np.array([[x1-lx/2,y0-ly/2,z0-lz/2],[x1+lx/2,y1+ly/2,z1+lz/2]]) # faces_x2=get_box(fac, fac_centroids, box_faces_x2, False) # f1=rng.unite(f1,faces_x2) # # if j==len(lyd1)-2: # box_faces_y2=np.array([[x0-lx/2,y1-ly/2,z0-lz/2],[x1+lx/2,y1+ly/2,z1+lz/2]]) # faces_y2=get_box(fac, fac_centroids, box_faces_y2, False) # f1=rng.unite(f1,faces_y2) # # if k==len(lzd1)-2: # box_faces_z2=np.array([[x0-lx/2,y0-ly/2,z1-lz/2],[x1+lx/2,y1+ly/2,z1+lz/2]]) # faces_z2=get_box(fac, fac_centroids, box_faces_z2, False) # f1=rng.unite(f1,faces_z2) # # sgids+=len(f1) # MM.mb.tag_set_data(local_id_fac_tag,f1,range(len(f1))) # add_topology(MM, f1,local_id_fac_tag,faces_adjs_by_dual) # t1 = time.time() # dt = t1-t0 # print(time.time()-t0,"criou meshset") xmin = 0.0 ymin = 0.0 zmin = 0.0 xmax = Lx ymax = Ly zmax = Lz for i in range(len(lxd1) - 1): x0 = lxd1[i] x1 = lxd1[i + 1] box_x = np.array([[x0 - 0.01, ymin, zmin], [x1 + 0.01, ymax, zmax]]) vols_x = get_box(MM.all_volumes, all_centroids, box_x, False) x_centroids = np.array( [MM.mtu.get_average_position([v]) for v in vols_x]) for j in range(len(lyd1) - 1): y0 = lyd1[j] y1 = lyd1[j + 1] box_y = np.array([[x0 - 0.01, y0 - 0.01, zmin], [x1 + 0.01, y1 + 0.01, zmax]]) vols_y = get_box(vols_x, x_centroids, box_y, False) y_centroids = np.array( [MM.mtu.get_average_position([v]) for v in vols_y]) for k in range(len(lzd1) - 1): z0 = lzd1[k] z1 = lzd1[k + 1] tb = time.time() box_dual_1 = np.array([[x0 - 0.01, y0 - 0.01, z0 - 0.01], [x1 + 0.01, y1 + 0.01, z1 + 0.01]]) vols = get_box(vols_y, y_centroids, box_dual_1, False) tipo = MM.mb.tag_get_data(D1_tag, vols, flat=True) inter = rng.Range(np.array(vols)[np.where(tipo == 0)[0]]) MM.mb.tag_set_data(local_id_int_tag, inter, range(len(inter))) add_topology(MM, inter, local_id_int_tag, intern_adjs_by_dual) fac = rng.Range(np.array(vols)[np.where(tipo == 1)[0]]) fac_centroids = np.array( [MM.mtu.get_average_position([f]) for f in fac]) box_faces_x = np.array( [[x0 - lx / 2, y0 - ly / 2, z0 - lz / 2], [x0 + lx / 2, y1 + ly / 2, z1 + lz / 2]]) box_faces_y = np.array( [[x0 - lx / 2, y0 - ly / 2, z0 - lz / 2], [x1 + lx / 2, y0 + ly / 2, z1 + lz / 2]]) box_faces_z = np.array( [[x0 - lx / 2, y0 - ly / 2, z0 - lz / 2], [x1 + lx / 2, y1 + ly / 2, z0 + lz / 2]]) faces_x = get_box(fac, fac_centroids, box_faces_x, False) faces_y = get_box(fac, fac_centroids, box_faces_y, False) f1 = rng.unite(faces_x, faces_y) faces_z = get_box(fac, fac_centroids, box_faces_z, False) f1 = rng.unite(f1, faces_z) if i == len(lxd1) - 2: box_faces_x2 = np.array( [[x1 - lx / 2, y0 - ly / 2, z0 - lz / 2], [x1 + lx / 2, y1 + ly / 2, z1 + lz / 2]]) faces_x2 = get_box(fac, fac_centroids, box_faces_x2, False) f1 = rng.unite(f1, faces_x2) if j == len(lyd1) - 2: box_faces_y2 = np.array( [[x0 - lx / 2, y1 - ly / 2, z0 - lz / 2], [x1 + lx / 2, y1 + ly / 2, z1 + lz / 2]]) faces_y2 = get_box(fac, fac_centroids, box_faces_y2, False) f1 = rng.unite(f1, faces_y2) if k == len(lzd1) - 2: box_faces_z2 = np.array( [[x0 - lx / 2, y0 - ly / 2, z1 - lz / 2], [x1 + lx / 2, y1 + ly / 2, z1 + lz / 2]]) faces_z2 = get_box(fac, fac_centroids, box_faces_z2, False) f1 = rng.unite(f1, faces_z2) sgids += len(f1) MM.mb.tag_set_data(local_id_fac_tag, f1, range(len(f1))) add_topology(MM, f1, local_id_fac_tag, faces_adjs_by_dual) print(time.time() - t0, "criou meshset") self.intern_adjs_by_dual = intern_adjs_by_dual self.faces_adjs_by_dual = faces_adjs_by_dual
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 refine_surfaces(filename, df, sf, output, keep): """For a given isogeom file, iterate through each surface applying the refinement factors specified. A new geometry file will be written out that has gone through the specified refinement. Inputs: ------- filename: string, name of the HDF5 (.h5m) isogeometry file to to be refined. df: float or None, factor for target reduction in the decimation process. Must be between 0 and 1. If set to None, no decimation will be applied. A higher value indicates a greater reduction in the number of surface triangles. sf: float or None, smoothing factor for the smoothing process. Must be between 0 and 1. If set to None, no smoothing will be applied. A higher value indicates more smoothing. output: string, name of output file to be written after the refinement process keep: bool, if set to True, the temporary surface files written to disk during the process will not be deleted. Return: ------- None """ # load as a moab instance mb = core.Core() mb.load_file(filename) rs = mb.get_root_set() # get necessary tag information dim_tag = mb.tag_get_handle('GEOM_DIMENSION', size=1, tag_type=types.MB_TYPE_INTEGER, storage_type=types.MB_TAG_SPARSE, create_if_missing=False) surf_tag = mb.tag_get_handle('SURF_TYPE', size=32, tag_type=types.MB_TYPE_OPAQUE, storage_type=types.MB_TAG_SPARSE, create_if_missing=False) # get all surfaces all_surfs = mb.get_entities_by_type_and_tag(rs, types.MBENTITYSET, dim_tag, [2]) # get data tag if present on the triangles (for rewriting viz data later) data_tag = get_viz_info(mb, all_surfs[0]) # iterate over all surfaces refining one at a time for surf in all_surfs: print('Refining surface {}'.format(surf)) # get surface type (interior or exterior) surf_type = mb.tag_get_data(surf_tag, surf) # get all triangles and vertices (these will be replaced) tris = mb.get_entities_by_type(surf, types.MBTRI) verts = mb.get_entities_by_type(surf, types.MBVERTEX) # write surface to .vtk file to use in vtk fname = 'tmp_{}.vtk'.format(surf) mb.write_file(fname, [surf]) # apply vtk filters outfile = apply_filters(fname, df, sf, surf_type) # read in vtk file again new_surf = mb.create_meshset() mb.load_file(outfile, new_surf) # get all triangles and vertices on new surf tris_new = mb.get_entities_by_type(new_surf, types.MBTRI) verts_new = mb.get_entities_by_type(new_surf, types.MBVERTEX) # remove old tris/verts from surfs and vols mb.remove_entities(surf, tris) mb.remove_entities(surf, verts) vols = mb.get_parent_meshsets(surf) for vol in vols: mb.remove_entities(vol, tris) mb.remove_entities(vol, verts) mb.add_entities(surf, tris_new) mb.add_entities(surf, verts_new) # get value of data tag on surface & tag new triangles if data_tag is not None: data_val = mb.tag_get_data(data_tag, surf)[0][0] vals = np.full(len(tris_new), data_val) mb.tag_set_data(data_tag, tris_new, vals) # delete temporary files if not keep: os.remove(fname) os.remove(outfile) # write full geometry - only the necessary entities print("Writing refined geometry") all_vols = mb.get_entities_by_type_and_tag( rs, types.MBENTITYSET, dim_tag, [3]) all_sets = rng.unite(all_vols, all_surfs) # check file extension of save name: ext = output.split(".")[-1] if ext.lower() not in ['h5m', 'vtk']: warnings.warn("File extension {} ".format(ext) + " not recognized. File will be saved as type .h5m.") output = output.split(".")[0] + ".h5m" mb.write_file(output, all_sets)
#del(LIN) #del(DAT) OP_ADM_2 = csc_matrix((data, (lines, cols)), shape=(n1, n2)) OP2 = P2.copy() ta2 = time.time() vm = mb.create_meshset() mb.add_entities(vm, vertices) v_nivel_0 = mb.get_entities_by_type_and_tag(vm, types.MBHEX, np.array([L3_ID_tag]), np.array([1])) v_nivel_1 = mb.get_entities_by_type_and_tag(vm, types.MBHEX, np.array([L3_ID_tag]), np.array([2])) v_n0e1 = rng.unite(v_nivel_0, v_nivel_1) ID_class = mb.tag_get_data(fine_to_primal1_classic_tag, v_n0e1, flat=True) OP2[ID_class] = csc_matrix((1, OP2.shape[1])) nivel_0 = mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([L3_ID_tag]), np.array([1])) nivel_1 = mb.get_entities_by_type_and_tag(vm, types.MBHEX, np.array([L3_ID_tag]), np.array([2])) n0e1 = rng.unite(nivel_0, nivel_1) IDs_ADM1 = mb.tag_get_data(L1_ID_tag, n0e1, flat=True) IDs_ADM2 = mb.tag_get_data(L2_ID_tag, n0e1, flat=True) lines = IDs_ADM1 cols = IDs_ADM2 data = np.repeat(1, len(lines)) IDs_AMS2 = mb.tag_get_data(fine_to_primal2_classic_tag, ver, flat=True)
fac = rng.Range(np.array(vols)[np.where(tipo == 1)[0]]) fac_centroids = np.array( [MM.mtu.get_average_position([f]) for f in fac]) box_faces_x = np.array([[x0 - lx / 2, y0 - ly / 2, z0 - lz / 2], [x0 + lx / 2, y1 + ly / 2, z1 + lz / 2]]) box_faces_y = np.array([[x0 - lx / 2, y0 - ly / 2, z0 - lz / 2], [x1 + lx / 2, y0 + ly / 2, z1 + lz / 2]]) box_faces_z = np.array([[x0 - lx / 2, y0 - ly / 2, z0 - lz / 2], [x1 + lx / 2, y1 + ly / 2, z0 + lz / 2]]) faces_x = get_box(fac, fac_centroids, box_faces_x, False) faces_y = get_box(fac, fac_centroids, box_faces_y, False) f1 = rng.unite(faces_x, faces_y) faces_z = get_box(fac, fac_centroids, box_faces_z, False) f1 = rng.unite(f1, faces_z) if i == len(lxd1) - 2: box_faces_x2 = np.array( [[x1 - lx / 2, y0 - ly / 2, z0 - lz / 2], [x1 + lx / 2, y1 + ly / 2, z1 + lz / 2]]) faces_x2 = get_box(fac, fac_centroids, box_faces_x2, False) f1 = rng.unite(f1, faces_x2) if j == len(lyd1) - 2: box_faces_y2 = np.array( [[x0 - lx / 2, y1 - ly / 2, z0 - lz / 2], [x1 + lx / 2, y1 + ly / 2, z1 + lz / 2]])
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")
# volumes finos por neumann volumes_fn = [] for i in bvfn: volumes_fn += list(get_box(all_volumes, all_centroids, i, False)) volumes_fn = rng.Range(volumes_fn) # volumes_fn = get_box(all_volumes, all_centroids, bvfn, False) # volumes finos por Dirichlet volumes_fd = [] for i in bvfd: volumes_fd += list(get_box(all_volumes, all_centroids, i, False)) volumes_fd = rng.Range(volumes_fd) # volumes_fd = get_box(all_volumes, all_centroids, bvfd, False) volumes_f = rng.unite(volumes_fn, volumes_fd) np.save('volumes_f', np.array(volumes_f)) D1_tag = mb.tag_get_handle('d1') D2_tag = mb.tag_get_handle('d2') 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 = np.array([mtu.get_average_position([v]) for v in vertices]) # volumes intermediarios por neumann volumes_in = [] for i in bvin: volumes_in += list(get_box(vertices, all_vertex_centroids, i, False))
def get_all_wells(): vols1 = DefineWells.get_volumes_neumann() vols2 = DefineWells.get_volumes_dirichlet() return rng.unite(vols1, vols2)