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)
