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