def get_faces_in_intersection_between_volumes(mb, elements1, elements2):
"""
Retorna as faces na interseccao entre dois ranges de volumes ou dois meshsets
"""
bound_faces1 = UtilsPymoab.get_boundary_of_volumes(mb, elements1)
bound_faces2 = UtilsPymoab.get_boundary_of_volumes(mb, elements2)
return rng.intersect(bound_faces1, bound_faces2)
def calculate_pcorr(self, elements, vertex_elem, pcorr_tag, pms_tag, keq_tag, faces, boundary_faces, volumes_d, volumes_n):
map_local = dict(zip(elems, range(len(elems))))
n = len(elems)
T = sp.lil_matrix((n, n))
b = np.zeros(n)
for i, face in enumerate(faces):
elems = self.mb.get_adjacencies(face, 3)
keq, s_grav, elems = self.get_mobi_by_face_quad_bif(face, keq_tag)
if face in boundary_faces:
p = self.mb.tag_get_data(pms_tag, elems, flat=True)
flux = (p[1] - p[0])*keq
if self.gravity == True:
flux += s_grav
b[map_local[elems[0]]] += flux
b[map_local[elems[1]]] -= flux
continue
T[map_local[elems[0]], map_local[elems[1]]] = -keq
T[map_local[elems[1]], map_local[elems[0]]] = -keq
T[map_local[elems[0]], map_local[elems[0]]] += keq
T[map_local[elems[1]], map_local[elems[1]]] += keq
T[map_local[vertex], map_local[vertex]] = 1
p = self.mb.tag_get_data(pms_tag, vertex, flat=True)[0]
b[map_local[vertex]] = p
bound1 = rng.intersect(elems, volumes_d)
bound1 = rng.subtract(bound1, vertex)
if len(bound1) > 0:
ids = np.array([map_local[v] for v in bound1])
T[ids] = sp.lil_matrix((len(ids), n))
T[ids, ids] = np.ones(len(ids))
ps = self.mb.tag_get_data(pms_tag, bound1, flat=True)
b[ids] = ps
bound2 = rng.intersect(elems, volumes_n)
bound2 = rng.subtract(bound2, vertex)
if len(bound2) > 0:
ids = np.array([map_local[v] for v in bound2])
qs = self.mb.tag_get_data(self.list_tags[3], bound2, flat=True)
b[ids] += qs
x = linalg.spsolve(T, b)
self.mb.tag_set_data(pcorr_tag, elements, x)
def __init__(self, father_core, num, coarse_vec):
self.father_core = father_core
self.dimension = father_core.dimension
self.mb = father_core.mb
self.level = father_core.level + 1
self.coarse_num = num
self.father_root_set = father_core.root_set
self.root_set = self.mb.create_meshset(types.MESHSET_TRACK_OWNER)
self.mtu = father_core.mtu
self.handleDic = father_core.handleDic
if self.dimension == 3:
self.all_volumes = father_core.all_volumes[coarse_vec]
self.all_faces = self.mb.get_adjacencies(self.all_volumes,
2,
False,
op_type=types.UNION)
self.all_edges = self.mb.get_adjacencies(self.all_volumes,
1,
False,
op_type=types.UNION)
self.all_nodes = self.mb.get_adjacencies(self.all_volumes,
0,
False,
op_type=types.UNION)
elif self.dimension == 2:
self.all_volumes = rng.Range()
self.all_faces = father_core.all_faces[coarse_vec]
self.all_edges = self.access_handle(self.all_faces)
self.all_nodes = rng.Range(self.mb.get_connectivity(
self.all_faces))
self.mb.add_entities(self.root_set, self.all_volumes)
self.mb.add_entities(self.root_set, self.all_faces)
self.mb.add_entities(self.root_set, self.all_edges)
self.mb.add_entities(self.root_set, self.all_nodes)
all_entities = self.mb.get_entities_by_handle(self.root_set)
[
self.boundary_nodes, self.boundary_edges, self.boundary_faces,
self.boundary_volumes
] = self.skinner_operation()
self.internal_nodes = rng.subtract(self.all_nodes, self.boundary_nodes)
self.internal_edges = rng.subtract(self.all_edges, self.boundary_edges)
self.internal_faces = rng.subtract(self.all_faces, self.boundary_faces)
self.internal_volumes = rng.subtract(self.all_volumes,
self.boundary_volumes)
if self.level == 1:
self.id_name = "LOCAL_ID_L" + str(self.level) + "-" + str(
self.coarse_num)
self.father_id_name = self.father_core.id_name
else:
self.father_id_name = self.father_core.id_name
self.id_name = self.father_id_name + str("L") + str(
self.level) + "-" + str(self.coarse_num)
self.init_id()
self.flag_dic = {
key: [rng.intersect(all_entities, el) for el in value]
for (key, value) in father_core.flag_dic.items()
}
def skinner_operation(self):
skin = sk.Skinner(self.mb)
print("Entering skinner test")
if self.dimension == 3:
faces_on_skin_handles = skin.find_skin(self.root_set,
self.all_volumes[:])
edges_on_skin_handles = self.access_handle(faces_on_skin_handles)
nodes_on_skin_handles = self.access_handle(edges_on_skin_handles)
nodes_in_volumes = ([
self.mb.get_adjacencies(el_handle, 0)
for el_handle in self.all_volumes
])
check_volumes = ([
rng.intersect(el_handle, nodes_on_skin_handles)
for el_handle in nodes_in_volumes
])
external_volumes_index = np.array([
el_handle.empty() for el_handle in check_volumes
]).astype(bool)
volumes_on_skin_handles = self.range_index(
np.bitwise_not(external_volumes_index), self.all_volumes)
elif self.dimension == 2:
edges_on_skin_handles = skin.find_skin(self.root_set,
self.all_faces[:])
nodes_on_skin_handles = self.access_handle(edges_on_skin_handles)
nodes_in_faces = ([
self.mb.get_adjacencies(el_handle, 0)
for el_handle in self.all_faces
])
check_faces = np.asarray([
rng.intersect(el_handle, nodes_on_skin_handles)
for el_handle in nodes_in_faces
])
external_faces_index = np.array(
[el_handle.empty() for el_handle in check_faces]).astype(bool)
faces_on_skin_handles = self.range_index(
np.bitwise_not(external_faces_index), self.all_faces)
volumes_on_skin_handles = rng.Range()
print("Skinning Operation Successful")
return [
nodes_on_skin_handles, edges_on_skin_handles,
faces_on_skin_handles, volumes_on_skin_handles
]
def get_meshsets_viz_face(mb, meshset, meshsets):
result = []
bound_faces = UtilsPymoab.get_boundary_of_volumes(mb, meshset)
for m in meshsets:
bound_faces_m = UtilsPymoab.get_boundary_of_volumes(mb, m)
inter = rng.intersect(bound_faces, bound_faces_m)
if np.allclose(np.array(inter), np.array(bound_faces)):
result.append(m)
return rng.Range(result)
def set_faces_in_boundary_by_meshsets(mb, mtu, meshsets,
faces_boundary_meshset_tag, M):
all_faces_on_boundary = mb.create_meshset()
meshsets = list(meshsets)
n = len(meshsets)
ms0 = set()
# for m1 in meshsets:
# ms0.add(m1)
# cont = 0
# elems1 = mb.get_entities_by_handle(m1)
# faces1 = mtu.get_bridge_adjacencies(elems1, 2, 2)
# for m2 in meshsets:
# if m2 in ms0:
# continue
# elems2 = mb.get_entities_by_handle(m2)
# faces2 = mtu.get_bridge_adjacencies(elems2, 2, 2)
# intersect = rng.intersect(faces1, faces2)
# if len(intersect) < 1:
# continue
# cont+=1
# mb.add_entities(all_faces_on_boundary, intersect)
# print(cont)
# if cont > 3:
# print(i)
# print(cont)
# import pdb; pdb.set_trace()
# import pdb; pdb.set_trace()
for m1 in meshsets:
cont = 0
elems1 = mb.get_entities_by_handle(m1)
faces1 = mtu.get_bridge_adjacencies(elems1, 3, 2)
# for face in faces1:
# elems = mb.get_adjacencies(face, 3)
# if len(elems) < 2:
# continue
# if elems[0] in elems1 and elems[1] in elems1:
# continue
# mb.add_entities(all_faces_on_boundary, rng.Range(face))
elems2 = mtu.get_bridge_adjacencies(elems1, 2, 3)
elems3 = rng.subtract(elems2, elems1)
try:
faces3 = mtu.get_bridge_adjacencies(elems3, 3, 2)
faces_cont = rng.intersect(faces3, faces1)
except Exception as e:
faces_cont = faces1
mb.add_entities(all_faces_on_boundary, faces_cont)
mb.tag_set_data(faces_boundary_meshset_tag, M.core.root_set,
all_faces_on_boundary)
def find_coarse_neighbours(self, coarse_list):
self.nodes_neighbors = {}
self.edges_neighbors = {}
self.faces_neighbors = {}
self.volumes_neighbors = {}
self.all_nodes_neighbors = rng.Range()
self.all_edges_neighbors = rng.Range()
self.all_faces_neighbors = rng.Range()
self.all_volumes_neighbors = rng.Range()
for x in range(self.num_coarse):
for y in range(x + 1, self.num_coarse):
self.nodes_neighbors[x, y] = rng.intersect(
coarse_list[x].core.boundary_nodes,
coarse_list[y].core.boundary_nodes)
self.nodes_neighbors[y, x] = self.nodes_neighbors[x, y]
temp = self.nodes_neighbors[x, y]
[self.all_nodes_neighbors.insert(e) for e in temp]
self.edges_neighbors[x, y] = rng.intersect(
coarse_list[x].core.boundary_edges,
coarse_list[y].core.boundary_edges)
self.edges_neighbors[y, x] = self.edges_neighbors[x, y]
temp = self.edges_neighbors[x, y]
[self.all_edges_neighbors.insert(e) for e in temp]
self.faces_neighbors[x, y] = rng.intersect(
coarse_list[x].core.boundary_faces,
coarse_list[y].core.boundary_faces)
self.faces_neighbors[y, x] = self.faces_neighbors[x, y]
temp = self.faces_neighbors[x, y]
[self.all_faces_neighbors.insert(e) for e in temp]
self.volumes_neighbors[x, y] = rng.intersect(
coarse_list[x].core.boundary_volumes,
coarse_list[y].core.boundary_volumes)
self.volumes_neighbors[y, x] = self.volumes_neighbors[x, y]
temp = self.volumes_neighbors[x, y]
[self.all_volumes_neighbors.insert(e) for e in temp]
def skinner_operation(self):
self.skin = sk.Skinner(self.mb)
if self.dimension == 3:
faces_on_skin_handles = self.skin.find_skin(0, self.all_volumes)
edges_on_skin_handles = self.mtu.get_bridge_adjacencies(
faces_on_skin_handles, 2, 1)
nodes_on_skin_handles = self.mtu.get_bridge_adjacencies(
faces_on_skin_handles, 2, 0)
volumes_on_skin_handles = rng.intersect(
self.mtu.get_bridge_adjacencies(faces_on_skin_handles, 0, 3),
self.all_volumes)
elif self.dimension == 2:
edges_on_skin_handles = self.skin.find_skin(0, self.all_faces)
nodes_on_skin_handles = self.mtu.get_bridge_adjacencies(
edges_on_skin_handles, 1, 0)
faces_on_skin_handles = rng.intersect(
self.mtu.get_bridge_adjacencies(edges_on_skin_handles, 0, 2),
self.all_faces)
volumes_on_skin_handles = self.mtu.get_bridge_adjacencies(
edges_on_skin_handles, 0, 3)
return [
nodes_on_skin_handles, edges_on_skin_handles,
faces_on_skin_handles, volumes_on_skin_handles
]
def bridge_adjacencies(self, index, interface, target):
# lacks support for indexing with multiple numbers
range_vec = self.create_range_vec(index)
all_bridge = [
self.mtu.get_bridge_adjacencies(el_handle, self.num[interface],
self.num[target])
for el_handle in self.range_index(range_vec)
]
inside_meshset = self.mb.get_entities_by_handle(self.meshset)
all_brige_in_meshset = [
rng.intersect(el_handle, inside_meshset)
for el_handle in all_bridge
]
all_briges_in_meshset_id = np.array(
[self.read(el_handle) for el_handle in all_brige_in_meshset])
return all_briges_in_meshset_id
def remove_vol(self, element):
tetra_remove = rng.intersect(self.all_elements, element)
tetra_remaining = rng.subtract(self.all_elements, tetra_remove)
#import pdb; pdb.set_trace()
faces = rng.subtract(self.adjs(tetra_remove, 2), self.adjs(tetra_remaining,2))
edges = rng.subtract(self.adjs(tetra_remove, 1), self.adjs(tetra_remaining,1))
nodes = rng.subtract(self.adjs(tetra_remove, 0), self.adjs(tetra_remaining,0))
self.mb.delete_entity(tetra_remove)
self.mb.delete_entity(faces)
self.mb.delete_entity(edges)
self.mb.delete_entity(nodes)
self.all_elements = self.mb.get_entities_by_dimension(0, 3)
self.nodes = self.mb.get_entities_by_dimension(0, 0)
self.faces = self.skinner(self.all_elements)
self.boundary_nodes = self.find_boundary_nodes()
self.boundary_elements = self.find_boundary_elements()
def get_meshsets_viz_vertex(mb, meshset, meshsets):
result = set()
bound_faces = UtilsPymoab.get_boundary_of_volumes(mb, meshset)
verts0 = rng.Range(mb.get_connectivity(bound_faces))
for m in meshsets:
if m == meshset:
continue
bound_faces = UtilsPymoab.get_boundary_of_volumes(mb, m)
verts1 = rng.Range(mb.get_connectivity(bound_faces))
inter = rng.intersect(verts0, verts1)
if len(inter) > 0:
result.add(m)
return (rng.Range(result))
def bridge_adjacencies(self, handle, dim):
# lacks support for indexing with multiple numbers
if dim == 3:
all_bridge = [
self.mtu.get_bridge_adjacencies(el, 2, 3) for el in handle
]
else:
all_bridge = [
self.mtu.get_bridge_adjacencies(el, 1, 2) for el in handle
]
inside_meshset = self.mb.get_entities_by_handle(self.root_set)
all_brige_in_meshset = np.array([
rng.intersect(el_handle, inside_meshset)
for el_handle in all_bridge
])
size_brige = np.array(
[len(el_handle) for el_handle in all_brige_in_meshset])
handles = np.asarray(handle)[size_brige == 1].astype("uint")
return rng.Range(handles)
def get_or_adm_nv1(mb, all_volumes, map_wire_lv0):
nc_primal_tag_1 = mb.tag_get_handle('NC_PRIMAL_1')
lv1_id_tag = mb.tag_get_handle(Restriction.name_l1_id)
level_tag = mb.tag_get_handle(Restriction.name_l3_id)
elems_nv0 = mb.get_entities_by_type_and_tag(mb.get_root_set(),
types.MBHEX, level_tag,
np.array([1]))
ids_adm_nv1_elems_nv0 = mb.tag_get_data(lv1_id_tag,
elems_nv0,
flat=True)
ids_wirebasket_elems_nv0 = np.array(
[map_wire_lv0[v] for v in elems_nv0])
ids_adm_lv1 = mb.tag_get_data(lv1_id_tag, all_volumes, flat=True)
max_id_lv1 = ids_adm_lv1.max()
n = len(all_volumes)
OR_adm_nv1 = sp.lil_matrix((max_id_lv1 + 1, n))
OR_adm_nv1[ids_adm_nv1_elems_nv0, ids_wirebasket_elems_nv0] = np.ones(
len(ids_adm_nv1_elems_nv0))
meshsets = mb.get_entities_by_type_and_tag(mb.get_root_set(),
types.MBENTITYSET,
np.array([nc_primal_tag_1]),
np.array([None]))
for meshset in meshsets:
elems = mb.get_entities_by_handle(meshset)
inter = rng.intersect(elems_nv0, elems)
if len(inter) > 0:
continue
# nc = mb.tag_get_data(nc_primal_tag_1, meshset, flat=True)[0]
line_or_adm = mb.tag_get_data(lv1_id_tag, elems, flat=True)
cols_or_adm = np.array([map_wire_lv0[v] for v in elems])
OR_adm_nv1[line_or_adm, cols_or_adm] = np.ones(len(cols_or_adm))
return OR_adm_nv1
def bridge_adjacencies(self, index, interface, target):
"""
Get the adjacencies of a set of entities (or a single entity) connected through an especific interface.
-- Example --
volumes_ids = M.volumes.all
volumes_adjacencies = M.volumes.bridge_adjacencies(M.volumes.all, 2, 3)
-- Parameters --
index : integer
Indexes of entity or entities to get adjacent entities from.
interface : integer
Dimension of the interface entities.
target : integer
Dimension of the target entities.
--Returns--
An array containing the indexes of adjacents entities
"""
# lacks support for indexing with multiple numbers
range_vec = self.create_range_vec(index)
all_bridge = [
self.mtu.get_bridge_adjacencies(el_handle, self.num[interface],
self.num[target])
for el_handle in self.range_index(range_vec)
]
inside_meshset = self.mb.get_entities_by_handle(self.meshset)
all_brige_in_meshset = [
rng.intersect(el_handle, inside_meshset)
for el_handle in all_bridge
]
all_briges_in_meshset_id = np.array(
[self.read(el_handle) for el_handle in all_brige_in_meshset])
return all_briges_in_meshset_id
def calc_pcorr_nv(self, vertices_nv, k, tag_primal_classic):
tags_1 = self.tags
mb = self.mb
mtu = self.mtu
boundary_faces = self.all_boundary_faces
bound_faces_nv = self.bound_faces_nv
for vert in vertices_nv:
t00 = time.time()
primal_id = mb.tag_get_data(tag_primal_classic, vert, flat=True)[0]
elems_in_meshset = mb.get_entities_by_type_and_tag(
0, types.MBHEX, np.array([tag_primal_classic]),
np.array([primal_id]))
faces = mtu.get_bridge_adjacencies(elems_in_meshset, 3, 2)
faces = rng.subtract(faces, boundary_faces)
faces_boundary = rng.intersect(faces, bound_faces_nv[k])
if len(faces_boundary) < 1:
import pdb
pdb.set_trace()
t01 = time.time()
t02 = time.time()
self.calculate_pcorr(elems_in_meshset, vert, faces_boundary, faces,
k)
self.set_flux_pms_meshsets(elems_in_meshset, faces, faces_boundary)
def get_op_adm_nv1(mb, all_volumes, map_wire_lv0, OP1, vertex_elems):
nc_primal_tag_1 = mb.tag_get_handle('NC_PRIMAL_1')
lv1_id_tag = mb.tag_get_handle(ProlongationTPFA3D.name_l1_id)
level_tag = mb.tag_get_handle(ProlongationTPFA3D.name_l3_id)
vertex_elems = rng.Range(vertex_elems)
elems_nv0 = mb.get_entities_by_type_and_tag(mb.get_root_set(),
types.MBHEX, level_tag,
np.array([1]))
ids_adm_nv1_elems_nv0 = mb.tag_get_data(lv1_id_tag,
elems_nv0,
flat=True)
ids_wirebasket_elems_nv0 = np.array(
[map_wire_lv0[v] for v in elems_nv0])
ids_adm_lv1 = mb.tag_get_data(lv1_id_tag, all_volumes, flat=True)
max_id_lv1 = ids_adm_lv1.max()
n = len(all_volumes)
OP_adm_nv1 = sp.lil_matrix((n, max_id_lv1 + 1))
meshsets = mb.get_entities_by_type_and_tag(mb.get_root_set(),
types.MBENTITYSET,
np.array([nc_primal_tag_1]),
np.array([None]))
x = ids_wirebasket_elems_nv0
for meshset in meshsets:
elems = mb.get_entities_by_handle(meshset)
vertex = rng.intersect(elems, vertex_elems)
id_lv1_vertex = mb.tag_get_data(lv1_id_tag, vertex, flat=True)[0]
# inter = rng.intersect(elems_nv0, elems)
# # if len(inter) > 0:
# # continue
nc = mb.tag_get_data(nc_primal_tag_1, meshset, flat=True)[0]
# col_op = OP1[:,nc]
# indices = sp.find(col_op)
indices = sp.find(OP1[:, nc])
y = indices[0]
vals = indices[2]
# xy = np.intersect1d(x, y)
# if len(xy) > 0:
# retirar = []
# for i in xy:
# inds = np.where(y == i)[0][0]
# retirar.append(inds)
#
# retirar = np.array(retirar)
# y = np.delete(y, retirar)
# vals = np.delete(vals, retirar)
#
# col_op_adm = mb.tag_get_data(lv1_id_tag, elems, flat=True)[0]
col_op_adm = id_lv1_vertex
col_op_adm = np.repeat(col_op_adm, len(y))
OP_adm_nv1[y, col_op_adm] = vals
for i in ids_wirebasket_elems_nv0:
OP_adm_nv1[i] = np.zeros(max_id_lv1 + 1)
OP_adm_nv1[ids_wirebasket_elems_nv0,
ids_adm_nv1_elems_nv0] = np.ones(len(ids_adm_nv1_elems_nv0))
return OP_adm_nv1
def run_2(t):
print('entrou run2')
tini = time.time()
elems_nv0 = mb.get_entities_by_type_and_tag(0, types.MBHEX,
np.array([tags_1['l3_ID']]),
np.array([1]))
# vertices_nv1 = rng.subtract(sol_adm.vertices, elems_nv0)
vertices_nv1 = mb.get_entities_by_type_and_tag(meshset_vertices,
types.MBHEX,
np.array([tags_1['l3_ID']]),
np.array([2]))
k = 0
cont = 0
for vert in vertices_nv1:
t00 = time.time()
primal_id = mb.tag_get_data(tags_1['FINE_TO_PRIMAL1_CLASSIC'],
vert,
flat=True)[0]
elems_in_meshset = mb.get_entities_by_type_and_tag(
0, types.MBHEX, np.array([tags_1['FINE_TO_PRIMAL1_CLASSIC']]),
np.array([primal_id]))
faces = mtu.get_bridge_adjacencies(elems_in_meshset, 3, 2)
faces = rng.subtract(faces, boundary_faces)
faces_boundary = rng.intersect(faces, bound_faces_nv[k])
t01 = time.time()
t02 = time.time()
bif_utils.calculate_pcorr(mb, elems_in_meshset, vert, faces_boundary,
faces, tags_1['PCORR2'], tags_1['PMS2'],
sol_adm.volumes_d, sol_adm.volumes_n, tags_1)
# bif_utils.calculate_pcorr_v4(elems_in_meshset, tags_1['PCORR2'], tags_1)
t03 = time.time()
bif_utils.set_flux_pms_meshsets(elems_in_meshset, faces,
faces_boundary, tags_1['PMS2'],
tags_1['PCORR2'])
t04 = time.time()
dt0 = t01 - t00
dt1 = t03 - t02
dt2 = t04 - t03
dtt = t04 - t01
# print(f'tempo total {dtt}')
# print(f'tempo hd {dt0}')
# print(f'tempo pcorr {dt1}')
# print(f'tempo fluxo_ms {dt2} \n')
vertices_nv2 = mb.get_entities_by_type_and_tag(meshset_vertices_nv2,
types.MBHEX,
np.array([tags_1['l3_ID']]),
np.array([3]))
t0 = time.time()
k = 1
for vert in vertices_nv2:
primal_id = mb.tag_get_data(tags_1['FINE_TO_PRIMAL2_CLASSIC'],
vert,
flat=True)[0]
elems_in_meshset = mb.get_entities_by_type_and_tag(
0, types.MBHEX, np.array([tags_1['FINE_TO_PRIMAL2_CLASSIC']]),
np.array([primal_id]))
faces = mtu.get_bridge_adjacencies(elems_in_meshset, 3, 2)
faces = rng.subtract(faces, boundary_faces)
faces_boundary = rng.intersect(faces, bound_faces_nv[k])
bif_utils.calculate_pcorr(mb, elems_in_meshset, vert, faces_boundary,
faces, tags_1['PCORR2'], tags_1['PMS2'],
sol_adm.volumes_d, sol_adm.volumes_n, tags_1)
# bif_utils.calculate_pcorr_v4(elems_in_meshset, tags_1['PCORR2'], tags_1)
bif_utils.set_flux_pms_meshsets(elems_in_meshset, faces,
faces_boundary, tags_1['PMS2'],
tags_1['PCORR2'])
t1 = time.time()
dt = t1 - t0
# print(f'tempo nv2 fluxo {dt}\n')
faces = mtu.get_bridge_adjacencies(elems_nv0, 3, 2)
faces = rng.subtract(faces, boundary_faces)
# bif_utils.set_flux_pms_elems_nv0(elems_nv0, faces, tags_1['PMS1'])
t0 = time.time()
bif_utils.set_flux_pms_elems_nv0(elems_nv0, faces, tags_1['PMS2'])
t1 = time.time()
dt = t1 - t0
tend = time.time()
dtt = tend - tini
# print(f'tempo nv0 fluxo {dt}\n')
bif_utils.calc_cfl(faces_in)
bif_utils.verificar_cfl(all_volumes, loop)
print(f'tempo total: {dtt}')
print('saiu run2')
def find_coarse_neighbours(self):
self.connectivities = np.zeros(
(self.num_coarse, self.num_coarse + 1, 3)).astype('bool')
self.nodes_neighbors = np.zeros((self.num_coarse, self.num_coarse + 1),
dtype=object)
self.edges_neighbors = np.zeros((self.num_coarse, self.num_coarse + 1),
dtype=object)
self.faces_neighbors = np.zeros((self.num_coarse, self.num_coarse + 1),
dtype=object)
self.nodes_neighbors[:], self.edges_neighbors[:], self.faces_neighbors[:] = None, None, None
self._nodes = list()
self._faces = list()
self._edges = list()
self.all_nodes_neighbors = rng.Range()
self.all_edges_neighbors = rng.Range()
self.all_faces_neighbors = rng.Range()
self.all_volumes_neighbors = rng.Range()
#print(self.all_nodes_neighbors, self.all_edges_neighbors, self.all_faces_neighbors)
# import pdb; pdb.set_trace()
node_count, edge_count, face_count = 0, 0, 0
for x in range(self.num_coarse):
for y in range(x + 1, self.num_coarse):
node_intersect = rng.intersect(
self.elements[x].core.boundary_nodes,
self.elements[y].core.boundary_nodes)
if not node_intersect.empty():
self._nodes.append(node_intersect)
#self._nodes = np.append(self._nodes,node_intersect)
self.nodes_neighbors[x, y], self.nodes_neighbors[
y, x], = node_count, node_count
self.connectivities[x, y,
0], self.connectivities[y, x,
0] = True, True
node_count += 1
[
self.all_nodes_neighbors.insert(e)
for e in node_intersect
]
edges_intersect = rng.intersect(
self.elements[x].core.boundary_edges,
self.elements[y].core.boundary_edges)
if not edges_intersect.empty():
self._edges.append(edges_intersect)
# self._edges = np.append(self._edges,edges_intersect)
self.edges_neighbors[x, y], self.edges_neighbors[
y, x] = edge_count, edge_count
self.connectivities[x, y,
1], self.connectivities[y, x,
1] = True, True
edge_count += 1
[
self.all_edges_neighbors.insert(e)
for e in edges_intersect
]
faces_intersect = rng.intersect(
self.elements[x].core.boundary_faces,
self.elements[y].core.boundary_faces)
if not faces_intersect.empty():
self._faces.append(faces_intersect)
#self._faces = np.append(self._faces,faces_intersect)
self.faces_neighbors[x, y], self.faces_neighbors[
y, x] = face_count, face_count
self.connectivities[x, y,
2], self.connectivities[y, x,
2] = True, True
face_count += 1
[
self.all_faces_neighbors.insert(e)
for e in faces_intersect
]
self.num_internal_nodes = node_count
self.num_internal_edges = edge_count
self.num_internal_faces = face_count
for x in range(self.num_coarse):
# fix the interesection - second variable poorly choosen
node_intersect = rng.subtract(self.elements[x].core.boundary_nodes,
self.all_nodes_neighbors)
if not node_intersect.empty():
self._nodes.append(node_intersect)
self.nodes_neighbors[x, -1] = node_count
self.connectivities[x, -1, 0] = True
node_count += 1
edge_intersect = rng.subtract(self.elements[x].core.boundary_edges,
self.all_edges_neighbors)
if not edge_intersect.empty():
self._edges.append(edge_intersect)
self.edges_neighbors[x, -1] = edge_count
self.connectivities[x, -1, 1] = True
edge_count += 1
face_intersect = rng.subtract(self.elements[x].core.boundary_faces,
self.all_faces_neighbors)
if not face_intersect.empty():
self._faces.append(face_intersect)
self.faces_neighbors[x, -1] = face_count
self.connectivities[x, -1, 2] = True
face_count += 1
def get_or_nv1(mb, op, map_wirebasket, wirebasket_numbers):
name_primal_tag_level = Restriction.name_primal_tag + str(1)
name_fine_to_primal_tag_level = Restriction.name_fine_to_primal_tag[
0] + str(1) + Restriction.name_fine_to_primal_tag[1]
primal_tag = mb.tag_get_handle(name_primal_tag_level)
fine_to_primal_tag = mb.tag_get_handle(name_fine_to_primal_tag_level)
d2_tag = mb.tag_get_handle(Restriction.name_d2_tag)
ni = wirebasket_numbers[0]
nf = wirebasket_numbers[1]
ne = wirebasket_numbers[2]
nv = wirebasket_numbers[3]
vertex_elems = rng.Range([
item[0] for item in map_wirebasket.items()
if item[1] >= ni + nf + ne
])
meshsets = mb.get_entities_by_type_and_tag(mb.get_root_set(),
types.MBENTITYSET,
np.array([primal_tag]),
np.array([None]))
map_meshset_in_nc = []
name_nc_primal_tag = Restriction.name_nc_primal + str(1)
nc_primal_tag = mb.tag_get_handle(name_nc_primal_tag, 1,
types.MB_TYPE_INTEGER,
types.MB_TAG_SPARSE, True)
OR = sp.lil_matrix((op.shape[1], op.shape[0]))
interns = []
faces = []
edges = []
verts = []
map_nc_in_dual = {}
for m in meshsets:
elems = mb.get_entities_by_handle(m)
vertex = rng.intersect(elems, vertex_elems)
if len(vertex) != 1:
print('erro')
import pdb
pdb.set_trace()
vertex = vertex[0]
gids = [map_wirebasket[v] for v in elems]
gid = map_wirebasket[vertex]
line_op = op[gid]
indice = sp.find(line_op)
if len(indice[1]) != 1:
print('erro')
import pdb
pdb.set_trace()
col = indice[1][0]
map_meshset_in_nc.append(col)
ones = np.ones(len(elems))
OR[col, gids] = ones
val_d2 = list(set(mb.tag_get_data(d2_tag, elems, flat=True)))
if len(val_d2) > 1:
print('erro')
import pdb
pdb.set_trace()
val_d2 = val_d2[0]
map_nc_in_dual[col] = val_d2
if val_d2 == 0:
interns.append(col)
elif val_d2 == 1:
faces.append(col)
elif val_d2 == 2:
edges.append(col)
elif val_d2 == 3:
verts.append(col)
else:
raise ValueError('Erro no valor de d2_tag')
mb.tag_set_data(nc_primal_tag, meshsets, map_meshset_in_nc)
map_meshset_in_nc = dict(zip(np.array(meshsets), map_meshset_in_nc))
# ids_nv1 = sorted(map_meshset_in_nc)
wirebasket_numbers_nv1 = [
len(interns), len(faces),
len(edges), len(verts)
]
wirebasket_ord = interns + faces + edges + verts
map_nc_in_wirebasket_id = dict(
zip(wirebasket_ord, range(len(wirebasket_ord))))
#########################################################
# debug
# nni = len(interns)
# nnf = nni + len(faces)
# nne = nnf + len(edges)
# nnv = nne + len(verts)
#
# nc_vertex_elems = np.array(wirebasket_ord[nne:nnv], dtype=np.uint64)
# meshsets_vertex_elems_nv1 = [mb.get_entities_by_type_and_tag(
# mb.get_root_set(), types.MBENTITYSET, np.array([nc_primal_tag]),
# np.array([i]))[0] for i in nc_vertex_elems]
# meshsets_vertex_elems_nv1 = rng.Range(meshsets_vertex_elems_nv1)
#
# cont = 0
# for m in meshsets_vertex_elems_nv1:
# nc = mb.tag_get_data(nc_primal_tag, m, flat=True)[0]
# elems = mb.get_entities_by_handle(m)
# val_d2 = np.unique(mb.tag_get_data(d2_tag, elems, flat=True))
# print(val_d2)
# print(nc)
# print(nc in nc_vertex_elems)
# print('\n')
# if val_d2[0] != 3:
# print('erro')
# import pdb; pdb.set_trace()
# if cont == 10:
# cont = 0
# import pdb; pdb.set_trace()
# cont+=1
#
# print('saiu or1')
# import pdb; pdb.set_trace()
######################################################################
# ids_wirebasket = np.arange(len(wirebasket_ord))
# map_ids_nv1_in_wirebasket = dict(zip(wirebasket_ord, ids_wirebasket))
return OR, wirebasket_ord, wirebasket_numbers_nv1, map_meshset_in_nc, map_nc_in_wirebasket_id
meshsets_nv1 = M1.mb.get_entities_by_type_and_tag(0, types.MBENTITYSET,
np.array([primal_id_tag1]),
np.array([None]))
meshsets_nv2 = M1.mb.get_entities_by_type_and_tag(0, types.MBENTITYSET,
np.array([primal_id_tag2]),
np.array([None]))
#
# vertices=M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]), np.array([3]))
vertices = all_vertex_d1
M1.mb.tag_set_data(fine_to_primal1_classic_tag, vertices,
np.arange(0, len(vertices)))
for meshset in meshsets_nv1:
elems = M1.mb.get_entities_by_handle(meshset)
vert = rng.intersect(elems, vertices)
nc = M1.mb.tag_get_data(fine_to_primal1_classic_tag, vert, flat=True)[0]
M1.mb.tag_set_data(fine_to_primal1_classic_tag, elems,
np.repeat(nc, len(elems)))
M1.mb.tag_set_data(primal_id_tag1, meshset, nc)
internos = M1.mb.get_entities_by_type_and_tag(0,
types.MBHEX, np.array([D1_tag]),
np.array([0]))
faces = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]),
np.array([1]))
arestas = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX,
np.array([D1_tag]), np.array([2]))
vertices = M1.mb.get_entities_by_type_and_tag(0,
types.MBHEX, np.array([D1_tag]),
np.array([3]))
def DefineBoxesLvs(self):
key_lvs = self.kkeys[1]
key_ls = self.kkeys[2]
Ls = []
n = len(self.info[key_lvs])
comps = []
for k in self.info[key_lvs]:
l = self.info[key_lvs][k][key_ls]
Ls.append(l[:])
self.Ls = Ls
name_tag_primals = 'PRIMALS_NV_'
name_tag_fine_to_primal = 'FINE_TO_PRIMAL_NV_'
name_centroid_tag = 'CENTROID_NV_'
all_names_primals_tags = []
all_primals_tags = []
all_fine_to_primal_tags = []
all_centroids_tag = []
for i in range(n):
name_tag = name_tag_primals + str(i + 1)
name_fine_to_primal = name_tag_fine_to_primal + str(i + 1)
name_centroid = name_centroid_tag + str(i + 1)
all_names_primals_tags.append(name_tag)
primal_tag = self.mb.tag_get_handle(name_tag, 1,
types.MB_TYPE_INTEGER,
types.MB_TAG_SPARSE, True)
fine_to_primal_tag = self.mb.tag_get_handle(
name_fine_to_primal, 1, types.MB_TYPE_INTEGER,
types.MB_TAG_SPARSE, True)
centroid_tag = self.mb.tag_get_handle(name_centroid, 3,
types.MB_TYPE_DOUBLE,
types.MB_TAG_SPARSE, True)
all_centroids_tag.append(centroid_tag)
all_fine_to_primal_tags.append(fine_to_primal_tag)
all_primals_tags.append(primal_tag)
boxes = self.CreateBoxes(Ls[i])
self.CreateMeshsetsPrimals(boxes, primal_tag, fine_to_primal_tag,
centroid_tag)
###########################################################
### esse passo so eh necessario para malhas nao estruturadas
### verifica se existe elementos da malha fina em mais de um volume da malha grossa
######## meshsets = self.mb.get_entities_by_type_and_tag(
######## self.root_set, types.MBENTITYSET, np.array([primal_tag]),
######## np.array([None]))
########
######## boundary = self.sk.find_geometric_skin(self.all_volumes[0])
######## print(boundary)
######## import pdb; pdb.set_trace()
# m0 = set()
# for m in meshsets:
# elems0 = self.mb.get_entities_by_handle(m)
# for m2 in meshsets:
# if m2 in m0:
# continue
# elems2 = self.mb.get_entities_by_handle(m2)
# inter = rng.intersect(elems0, elems2)
#
# if len(inter) > 0:
# for elem in inter:
# ind = np.where(np.array(self.all_volumes) == elem)[0]
# cent_elem = self.vols_centroids[ind]
# cent_m = self.mb.tag_get_data(centroid_tag, m, flat=True)
# cent_m2 = self.mb.tag_get_data(centroid_tag, m2, flat=True)
# dist_m = np.linalg.norm(cent_elem - cent_m)
# dist_m2 = np.linalg.norm(cent_elem - cent_m2)
# if dist_m < dist_m2:
# self.mb.remove_entities(m2, elem)
# else:
# self.mb.remove_entities(m, elem)
#
# m0.add(m)
#################################################################################
self.tags_primals = all_primals_tags
# self.all_names_primals_tags = all_names_primals_tags
self.all_centroids_tag = all_centroids_tag
self.all_fine_to_primal_tags = all_fine_to_primal_tags
all_primals_tags.reverse() # cls.mtu = topo_util.MeshTopoUtil(mb)
all_names_primals_tags.reverse()
for i in range(n - 1):
primal_tag = all_primals_tags[i]
name_primal_tag = all_names_primals_tags[i]
primal_tag_nv0 = all_primals_tags[i - 1]
name_primal_tag_nv0 = all_names_primals_tags[i - 1]
meshsets = self.mb.get_entities_by_type_and_tag(
self.root_set, types.MBENTITYSET, np.array([primal_tag]),
np.array([None]))
meshsets_nv0 = self.mb.get_entities_by_type_and_tag(
self.root_set, types.MBENTITYSET, np.array([primal_tag_nv0]),
np.array([None]))
ms0 = set()
for m1 in meshsets:
cont = 0
for m0 in meshsets_nv0:
if m0 in ms0:
continue
elems_m1 = self.mb.get_entities_by_handle(m1)
elems_m0 = self.mb.get_entities_by_handle(m0)
inter = rng.intersect(elems_m1, elems_m0)
if len(inter) > 0:
if np.allclose(np.array(elems_m0), np.array(inter)):
ms0.add(m0)
self.mb.add_child_meshset(m1, m0)
else:
raise RuntimeError(
'Tamanho das malhas nao compativel')
#rng.subtract(rng.Range(vertice),viz_vert)
for v in viz_vert:
cent = MM.mtu.get_average_position(
[np.uint64(v)])
if (cent[2] - cent_v[2]
) < 0.01 and r: # and v in faces1:
new_vertices.append(v)
adjs_new_vertices = [
MM.mtu.get_bridge_adjacencies(v, 2, 3)
for v in new_vertices
]
new_faces = []
for conj in adjs_new_vertices:
v = rng.intersect(rng.Range(internos1), conj)
if len(v) > 0:
new_faces.append(np.uint64(v))
for f in new_faces:
try:
vfd = 0
#MM.mb.tag_set_data(D1_tag, f,np.repeat(1,len(f)))
except:
import pdb
pdb.set_trace()
#MM.mb.tag_set_data(D1_tag, new_vertices,np.repeat(2,len(new_vertices)))
MM.mb.tag_set_data(primal_id_tag1, l1_meshset, nc1)
nc1 += 1
MM.mb.add_child_meshset(l2_meshset, l1_meshset)
#-------------------------------------------------------------------------------
def main():
global nx, ny, nz, dx, dy, dz, dim, num_elements
# Tratamento da entrada. O número de dimensões da malha é determinado a partir
# da quantidade de argumentos.
if len(sys.argv) == 7:
nx = int(sys.argv[1])
ny = int(sys.argv[3])
nz = int(sys.argv[5])
dx = float(sys.argv[2])
dy = float(sys.argv[4])
dz = float(sys.argv[6])
dim = 2
num_elements = nx * ny * nz
num_vertex = (nx + 1) * (ny + 1) * (nz + 1)
else:
print("Not enough arguments")
return
# Criando instância da classe Core que gerencias as operações na malha.
mbcore = core.Core()
# Inicializando o vetor de coordenadas dos vértices.
vertex_coords = np.zeros(num_vertex * 3)
for i in range(num_vertex):
vertex_coords[3 * i] = (i % (nx + 1)) * dx
vertex_coords[3 * i + 1] = ((i // (nx + 1)) % (ny + 1)) * dy
vertex_coords[3 * i + 2] = ((i // ((nx + 1) * (ny + 1))) %
(nz + 1)) * dz
# O método create_vertices cria os handles associados a cada coordenada em vertex_coords
vertex_handles = mbcore.create_vertices(vertex_coords)
# Em mesh_connectivity são aramazenados os conjuntos de vértices que compõem um elemento,
# ou seja, determina a conectividade dos vértices na malha.
print("Creating connectivity")
mesh_connectivity = create_mesh_connectivity(vertex_handles, vertex_coords)
print("Done")
for m in mesh_connectivity:
print(m)
return
# De posse da conectividade da malha, criamos os elementos um a um. A troca de valores
# nas duas primeiras linhas do laço são necessárias devido a forma como o MOAB interpreta
# a malha e as adjacências dos elementos.
elem_handles = rng.Range()
for c in mesh_connectivity:
c[2], c[3] = c[3], c[2]
c[6], c[7] = c[7], c[6]
temp = mbcore.create_element(types.MBHEX, c)
elem_handles.insert(temp)
# Incialização da matriz de conectividade. (Neste caso, a conectividade é em
# relação aos elementos, ou seja, quais elementos são vizinhos.)
connectivity = np.zeros((num_elements, num_elements), dtype=np.bool_)
# Encontrando adjacências para preencher a matriz de conectividade
adjacencies = [mbcore.get_adjacencies(e, dim, True) for e in elem_handles]
# Para cada adjacência diferente, verifica-se se existem uma fronteira compartilhada.
# Caso positivo, os dois elementos são vizinhos e isto é indicado em connectivity.
i, j = 0, 0
for a in adjacencies:
for b in adjacencies:
if b != a:
intersection = rng.intersect(a, b)
if not intersection.empty():
connectivity[i][j] = 1
connectivity[j][i] = 1
j += 1
j = 0
i += 1
# Determinando as coordenadas do centroide de cada elemento e aramazenando-as em tags.
# Uma tag é um valor associado a cada elemento. Aqui, cada elemento possui duas tags: uma
# que armazena o valor das coordenadas do centroide e outra que armazena a permeabilidade.
centroid_tag = mbcore.tag_get_handle('centroid', 3, types.MB_TYPE_DOUBLE,
types.MB_TAG_DENSE, True)
permeability_tag = mbcore.tag_get_handle('permeability', 1,
types.MB_TYPE_DOUBLE,
types.MB_TAG_DENSE, True)
for e in elem_handles:
elem_vertex = mbcore.get_connectivity(e)
centroid_coord = get_centroid_coords(
mbcore.get_coords([elem_vertex[0]]))
mbcore.tag_set_data(centroid_tag, e, centroid_coord)
mbcore.tag_set_data(permeability_tag, e, np.array([1],
dtype=np.float_))
mbcore.write_file("tpfa_mesh.h5m")
print("New h5m file created")
def __init__(self, coords, elements, neighbors, center):
#super(DelaunayView, self).__init__()
self.mb = core.Core()
self.mtu = topo_util.MeshTopoUtil(self.mb)
skin = sk.Skinner(self.mb)
verts = self.mb.create_vertices(coords)
rs = self.mb.get_root_set()
#import pdb; pdb.set_trace()
#import pdb; pdb.set_trace()
elements = elements + np.ones(elements.shape)
tag_handle = self.mb.tag_get_handle("Teste", 1, types.MB_TYPE_INTEGER, types.MB_TAG_DENSE, create_if_missing = True)
for el in elements:
tetra = self.mb.create_element(types.MBTET, el.ravel().astype("uint64"))
#self.mtu.construct_aentities(verts)
elements = self.mb.get_entities_by_dimension(0, 3)
for index,el in enumerate(elements):
self.mb.tag_set_data(tag_handle,el,index)
#import pdb; pdb.set_trace()
bfaces = skin.find_skin(0, elements)
print(bfaces)
adj = np.array([(self.mb.get_connectivity(bface)) for bface in bfaces])
adj = adj.reshape((len(adj), 3)).astype(int) - np.ones(adj.shape)
missing = np.setdiff1d(np.where(~np.isin(neighbors,adj)), center)
import pdb; pdb.set_trace()
# finding boundary tetrahedron
self.mb.write_file("delaunay01.vtk")
emp = rng.Range()
boundary_tetrahedron = rng.Range()
for el in elements:
boundary_intersect = rng.intersect(bfaces, self.mb.get_adjacencies(el, 2))
if boundary_intersect is not emp:
boundary_tetrahedron = rng.unite(boundary_tetrahedron, rng.Range(el))
# for el in elements:
# #import pdb; pdb.set_trace()
# local = rng.Range(el)
# boundary_intersect = rng.intersect(bfaces, self.mb.get_adjacencies(local, 2))
# if boundary_intersect is not emp:
# # import pdb; pdb.set_trace()
# face_con = self.mb.get_adjacencies(boundary_intersect,0)
# el_con = self.mb.get_adjacencies(local, 0)
# #import pdb; pdb.set_trace()
# inside_node = int(rng.subtract(el_con, face_con)[0] - 1)
#
# #inside_node = int(np.setdiff1d(el_con, face_con)[0] - 1)
# #import pdb; pdb.set_trace()
# #check if inside node is missing
# is_missing = bool(np.isin(inside_node, missing))
# if is_missing is True:
# boundary_tetrahedron = rng.unite(boundary_tetrahedron, local)
#import pdb; pdb.set_trace()
for el in boundary_tetrahedron:
self.mb.tag_set_data(tag_handle,el,2)
print(self.mb.get_connectivity(el))
#print(boundary_tetrahedron)
import pdb; pdb.set_trace()
#self.mb.delete_entity(boundary_tetrahedron)
print(boundary_tetrahedron)
self.mb.write_file("delaunay02.vtk")
def GenerateLv1(self, tag_primal, tag_lv_id, level, centroid_tag):
vols_lv_0 = self.gen_lv.mb.get_entities_by_type_and_tag(
self.gen_lv.mb.get_root_set(), types.MBHEX,
np.array([self.level_tag]), np.array([level - 1]))
n1 = len(vols_lv_0)
ms0 = set()
ms_current = set()
meshsets_current_level = self.gen_lv.mb.get_entities_by_type_and_tag(
self.gen_lv.mb.get_root_set(), types.MBENTITYSET,
np.array([tag_primal]), np.array([None]))
centroids = self.gen_lv.mb.tag_get_data(centroid_tag,
meshsets_current_level)
## verificando quais volumes permanecem no nivel anterior
for meshset in meshsets_current_level:
elems_in_meshset = self.gen_lv.mb.get_entities_by_handle(meshset)
inter = rng.intersect(elems_in_meshset, vols_lv_0)
if len(inter) > 0:
ms0.add(meshset)
self.meshsets_with_levels.add(meshset)
self.gen_lv.mb.tag_set_data(
self.level_tag, elems_in_meshset,
np.repeat(level - 1, len(elems_in_meshset)))
vols_lv_0 = rng.unite(vols_lv_0, elems_in_meshset)
self.elems_with_level = rng.Range(vols_lv_0)
## verificando quais volumes sao vizinhos dos do nivel anterior
ms2 = []
for meshset in ms0:
vizs = utpy.get_meshsets_viz_vertex(self.gen_lv.mb, meshset,
meshsets_current_level)
for m in vizs:
if m in ms0:
continue
elems = self.gen_lv.mb.get_entities_by_handle(m)
self.meshsets_with_levels.add(m)
self.gen_lv.mb.tag_set_data(self.level_tag, elems,
np.repeat(level, len(elems)))
ms2.append(m)
self.elems_with_level = rng.unite(self.elems_with_level, elems)
centroids2 = self.gen_lv.mb.tag_get_data(centroid_tag, ms2)
################################################################################
## verificando quais volumes que ficam no nivel atual dada uma certa distancia
## obs: descomentar
# for meshset, centroid in zip(ms2, centroids2):
# dists = centroids - centroid
# dists = np.array(list(map(CalculateDistance, dists)))
# dists = dists < self.rs[level]
# meshsets = np.array(meshsets_current_level)[dists]
# if len(meshsets) > 0:
# for m in meshsets:
# if m in ms2 or m in ms0:
# continue
# self.meshsets_with_levels.add(m)
# elems = self.gen_lv.mb.get_entities_by_handle(m)
# self.gen_lv.mb.tag_set_data(self.level_tag, elems, np.repeat(level, len(elems)))
# self.elems_with_level = rng.unite(self.elems_with_level, elems)
##################################################################################
# n = len(vols_lv_0)
# self.gen_lv.mb.tag_set_data(tag_lv_id, vols_lv_0, np.arange(0, n))
################################################################
n = 0
for m in meshsets_current_level:
elems = self.gen_lv.mb.get_entities_by_handle(m)
if m in ms0:
n2 = len(elems)
self.gen_lv.mb.tag_set_data(tag_lv_id, elems,
np.arange(n, n + n2))
n += n2
else:
self.gen_lv.mb.tag_set_data(tag_lv_id, elems,
np.repeat(n, len(elems)))
n += 1
def GenerateOthersLevels(self, tag_primal, tag_lv_id, level, centroid_tag,
fine_to_primal_tag):
meshsets_current_level = self.gen_lv.mb.get_entities_by_type_and_tag(
self.gen_lv.mb.get_root_set(), types.MBENTITYSET,
np.array([tag_primal]), np.array([None]))
centroids = self.gen_lv.mb.tag_get_data(centroid_tag,
meshsets_current_level)
ms0 = set(
) # meshsets locais que permanecem no nivel local caso nao haja mais niveis
ms02 = set()
## verificando quais volumes permanecem no nivel anterior
for meshset in meshsets_current_level:
# childs = self.gen_lv.mb.get_child_meshsets(meshset)
elements_in_meshset = self.gen_lv.mb.get_entities_by_handle(
meshset)
inter1 = rng.intersect(elements_in_meshset, self.elems_with_level)
if len(inter1) == 0:
ms0.add(meshset)
continue
elif len(inter1) == len(elements_in_meshset):
ms02.add(meshset)
continue
else:
# len(inter1) > 0 and len(inter1) < len(elements_in_meshset):
elements_for_set_level = rng.subtract(elements_in_meshset,
inter1)
self.gen_lv.mb.tag_set_data(
self.level_tag, elements_for_set_level,
np.repeat(level - 1, len(elements_for_set_level)))
self.elems_with_level = rng.unite(self.elems_with_level,
elements_for_set_level)
ms02.add(meshset)
#################################################################################
## verificando quais volumes sao vizinhos dos do nivel anterior
elements_level_ant = self.gen_lv.mb.get_entities_by_type_and_tag(
self.gen_lv.mb.get_root_set(), types.MBHEX,
np.array([self.level_tag]), np.array([level - 1]))
adjs = self.gen_lv.mtu.get_bridge_adjacencies(elements_level_ant, 2, 3)
adjs = rng.subtract(adjs, self.elems_with_level)
ms = set()
ms2 = []
for adj in adjs:
if adj in ms:
continue
nc = self.gen_lv.mb.tag_get_data(fine_to_primal_tag,
adj,
flat=True)[0]
elements = self.gen_lv.mb.get_entities_by_type_and_tag(
self.gen_lv.mb.get_root_set(), types.MBHEX,
np.array([fine_to_primal_tag]), np.array([nc]))
meshset = self.gen_lv.mb.get_entities_by_type_and_tag(
self.gen_lv.mb.get_root_set(), types.MBENTITYSET,
np.array([fine_to_primal_tag]), np.array([nc]))
ms0 = ms0 - set(meshset)
ms = ms | set(elements)
ms2.append(meshset)
ms02.add(meshset)
self.gen_lv.mb.tag_set_data(self.level_tag, elements,
np.repeat(level, len(elements)))
############################################################################################
# centroids2 = self.gen_lv.mb.tag_get_data(centroid_tag, ms2)
# ###############################################################################
# # verificando quais volumes que ficam no nivel atual dada uma certa distancia
# # obs: descomentar
# for meshset, centroid in zip(ms2, centroids2):
# dists = centroids - centroid
# dists = np.array(list(map(CalculateDistance, dists)))
# dists = dists < self.rs[level]
# meshsets = np.array(meshsets_current_level)[dists]
# if len(meshsets) > 0:
# for m in meshsets:
# if m in ms02:
# continue
# elems = self.gen_lv.mb.get_entities_by_handle(m)
# if set(elems).issubset(set(self.elems_with_level)):
# continue
# else:
# self.gen_lv.mb.tag_set_data(self.level_tag, elems, np.repeat(level, len(elems)))
# self.elems_with_level = rng.unite(self.elems_with_level, elems)
# ms02.add(m)
# #################################################################################
# n = len(vols_lv_0)
# self.gen_lv.mb.tag_set_data(tag_lv_id, vols_lv_0, np.arange(0, n))
################################################################
if level == len(self.gen_lv.tags_primals) and len(
self.elems_with_level) < len(self.gen_lv.all_volumes):
for m in ms0:
elements = self.gen_lv.mb.tag_get_handle(m)
self.gen_lv.mb.tag_set_data(self.level_tag, elements,
np.repeat(level, len(elements)))
self.elems_with_level = rng.unite(self.elems_with_level,
elements)
ms = set()
n = 0
for elem in self.elems_with_level:
if elem in ms:
continue
lev = self.gen_lv.mb.tag_get_data(self.level_tag, elem,
flat=True)[0]
if lev == 0:
self.gen_lv.mb.tag_set_data(tag_lv_id, elem, n)
ms.add(elem)
# n+=1
else:
nc = self.gen_lv.mb.tag_get_data(
self.gen_lv.all_fine_to_primal_tags[lev - 1],
elem,
flat=True)[0]
elems = self.gen_lv.mb.get_entities_by_type_and_tag(
self.gen_lv.mb.get_root_set(), types.MBHEX,
np.array([self.gen_lv.all_fine_to_primal_tags[lev - 1]]),
np.array([nc]))
self.gen_lv.mb.tag_set_data(tag_lv_id, elems,
np.repeat(n, len(elems)))
ms = ms | set(elems)
# n+=1
n += 1
def __init__(self, data_loaded, Adjs, all_centroids, all_faces_in,
all_kharm, all_volumes, injectors, producers, tags, mb,
volumes_d, volumes_n, ler_anterior, mtu,
wirebasket_elems_nv1):
self.cfl_ini = 0.5
self.mi_w = float(data_loaded['dados_bifasico']['mi_w'])
self.mi_o = float(data_loaded['dados_bifasico']['mi_o'])
self.gama_w = float(data_loaded['dados_bifasico']['gama_w'])
self.gama_o = float(data_loaded['dados_bifasico']['gama_o'])
self.Sor = float(data_loaded['dados_bifasico']['Sor'])
self.Swc = float(data_loaded['dados_bifasico']['Swc'])
self.nw = float(data_loaded['dados_bifasico']['nwater'])
self.no = float(data_loaded['dados_bifasico']['noil'])
self.loops = int(data_loaded['dados_bifasico']['loops'])
self.total_time = float(data_loaded['dados_bifasico']['total_time'])
self.gravity = data_loaded['gravity']
# ler_anterior = data_loaded['ler_anterior']
self.Adjs = Adjs
self.tags = tags
self.all_centroids = mb.tag_get_data(tags['CENT'], all_volumes)
self.all_faces_in = all_faces_in
self.all_kharm = all_kharm
self.map_volumes = dict(zip(all_volumes, range(len(all_volumes))))
self.map_faces_in = dict(zip(all_faces_in, range(len(all_faces_in))))
self.all_volumes = all_volumes
self.wells_injector = injectors
self.wells_producer = producers
self.ids0 = mb.tag_get_data(tags['ID_reord_tag'],
np.array(Adjs[:, 0]),
flat=True)
self.ids1 = mb.tag_get_data(tags['ID_reord_tag'],
np.array(Adjs[:, 1]),
flat=True)
self.ids_volsd = mb.tag_get_data(tags['ID_reord_tag'],
volumes_d,
flat=True)
self.values_d = mb.tag_get_data(tags['P'], volumes_d, flat=True)
self.ids_volsn = mb.tag_get_data(tags['ID_reord_tag'],
volumes_n,
flat=True)
self.values_n = mb.tag_get_data(tags['Q'], volumes_n, flat=True)
self.phis = mb.tag_get_data(tags['PHI'], all_volumes, flat=True)
self.faces_volumes = [
rng.intersect(mtu.get_bridge_adjacencies(v, 3, 2), all_faces_in)
for v in all_volumes
]
self.mb = mb
self.ids_reord = self.mb.tag_get_data(self.tags['ID_reord_tag'],
self.all_volumes,
flat=True)
self.map_global = dict(zip(self.all_volumes, self.ids_reord))
self.wirebasket_elems_nv1 = wirebasket_elems_nv1
self.mtu = mtu
v0 = all_volumes[0]
points = mtu.get_bridge_adjacencies(v0, 3, 0)
coords = mb.tag_get_data(tags['NODES'], points)
maxs = coords.max(axis=0)
mins = coords.min(axis=0)
hs = maxs - mins
self.hs = hs
self.Areas = np.array([hs[1] * hs[2], hs[0] * hs[2], hs[0] * hs[1]])
vol = hs[0] * hs[1] * hs[2]
mb.tag_set_data(tags['VOLUME'], all_volumes,
np.repeat(vol, len(all_volumes)))
historico = np.array([
'vpi', 'tempo_decorrido', 'prod_agua', 'prod_oleo', 'wor', 'dt',
'loop'
])
np.save('historico', historico)
self.delta_t = 0.0
self.Vs = mb.tag_get_data(tags['VOLUME'], all_volumes, flat=True)
self.V_total = float((self.Vs * self.phis).sum())
self.vpi = 0.0
self.hist2 = []
self.load_sats_ini(mb, tags['SAT'])
if ler_anterior:
self.load_infos()
else:
self.set_lamb()
self.set_mobi_faces_ini()
pass
def calc_cfl(self, all_faces_in):
"""
cfl usando fluxo em cada volume
"""
lim_sup = 1e20
self.cfl = self.cfl_ini
self.all_faces_in = all_faces_in
qs = self.mb.tag_get_data(self.flux_in_faces_tag,
all_faces_in,
flat=True)
dfdss = self.mb.tag_get_data(self.dfds_tag, all_faces_in, flat=True)
Adjs = [self.mb.get_adjacencies(face, 3) for face in all_faces_in]
all_volumes = self.mtu.get_bridge_adjacencies(all_faces_in, 2, 3)
delta_ts = np.zeros(len(all_volumes))
faces_volumes = [
self.mtu.get_bridge_adjacencies(v, 3, 2) for v in all_volumes
]
phis = self.mb.tag_get_data(self.phi_tag, all_volumes, flat=True)
Vs = self.mb.tag_get_data(self.volume_tag, all_volumes, flat=True)
map_faces = dict(zip(all_faces_in, range(len(all_faces_in))))
# self.delta_t = self.cfl*(self.fimin*self.Vmin)/float(qmax*dfdsmax)
for i, v in enumerate(all_volumes):
V = Vs[i]
phi = phis[i]
if phi == 0:
delta_ts[i] = lim_sup
continue
faces = faces_volumes[i]
faces = rng.intersect(all_faces_in, faces)
ids_faces = [map_faces[f] for f in faces]
q_faces = qs[ids_faces]
dfdss_faces = dfdss[ids_faces]
qmax = q_faces.max()
ind = np.where(q_faces == qmax)[0]
dfds = dfdss_faces[ind][0]
if dfds == 0.0:
dt1 = lim_sup
else:
qmax = abs(qmax)
dt1 = self.cfl * (phi * V) / float(qmax * dfds)
if dt1 < 0:
print('erro')
import pdb
pdb.set_trace()
dfds_max = dfdss_faces.max()
if dfds_max == 0:
dt2 = dt1
else:
ind = np.where(dfdss_faces == dfds_max)[0]
q2 = abs(q_faces[ind][0])
dt2 = self.cfl * (phi * V) / float(q2 * dfds_max)
if dt2 < 0:
print('erro')
import pdb
pdb.set_trace()
delta_ts[i] = min([dt1, dt2])
if delta_ts[i] > self.delta_t_min:
pass
# delta_ts[i] = self.delta_t_min
self.delta_t = delta_ts.min()
self.flux_total_prod = self.mb.tag_get_data(self.total_flux_tag,
self.wells_producer,
flat=True).sum()
self.flux_total_producao = self.flux_total_prod
for adj in adjs:
nc_adj = M1.mb.tag_get_data(fine_to_primal1_classic_tag, adj, flat=True)[0]
if nc_adj == nc or nc_adj in past_list_nc_adj or nc_adj in past_list_nc:
continue
past_list_nc_adj.add(nc_adj)
faces_boundary_nc_adj = all_faces_boundary_nv1[nc_adj]
meshset_adj = list(M1.mb.get_entities_by_type_and_tag(
M1.root_set, types.MBENTITYSET, np.array([primal_id_tag1]),
np.array([nc_adj])))[0]
all_adjs = M1.mb.get_entities_by_handle(meshset_adj)
all_faces_nc = M1.mtu.get_bridge_adjacencies(elems, 3, 2)
all_faces_nc_adj = M1.mtu.get_bridge_adjacencies(all_adjs, 3, 2)
intersect_faces = rng.intersect(all_faces_nc, all_faces_nc_adj)
M1.mb.add_entities(faces_boundary_nc, intersect_faces)
M1.mb.add_entities(faces_boundary_nc_adj, intersect_faces)
neigh_meshsets[nc].append(nc_adj)
neigh_meshsets[nc_adj].append(nc)
past_list_nc.add(nc)
neighs_nc = np.array(neigh_meshsets[nc])
kk = len(neighs_nc)
if kk < 6:
neighs_nc = np.append(neighs_nc, np.repeat(-1, 6-kk))
M1.mb.tag_set_data(neigh_volumes_nv1_tag, meshset, neighs_nc)
for nc in neigh_meshsets.keys():
meshset = list(M1.mb.get_entities_by_type_and_tag(
faces = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX, np.array([D1_tag]),
np.array([1]))
arestas = M1.mb.get_entities_by_type_and_tag(0, types.MBHEX,
np.array([D1_tag]), np.array([2]))
vertices = M1.mb.get_entities_by_type_and_tag(0,
types.MBHEX, np.array([D1_tag]),
np.array([3]))
elems_wirebasket = np.array(
list(internos) + list(faces) + list(arestas) + list(vertices))
M1.mb.tag_set_data(fine_to_primal1_classic_tag, vertices,
np.arange(0, len(vertices)))
for meshset in meshsets_nv1:
elems = M1.mb.get_entities_by_handle(meshset)
vert = rng.intersect(elems, vertices)
nc = M1.mb.tag_get_data(fine_to_primal1_classic_tag, vert, flat=True)[0]
M1.mb.tag_set_data(fine_to_primal1_classic_tag, elems,
np.repeat(nc, len(elems)))
M1.mb.tag_set_data(primal_id_tag1, meshset, nc)
ni = len(internos)
nf = len(faces)
na = len(arestas)
nv = len(vertices)
tmod2 = time.time()
nni = ni
nnf = nni + nf
nne = nnf + na
nnv = nne + nv
