def main(kf, description, mesh_size):
mesh_kwargs = {}
mesh_kwargs["mesh_size"] = {
"mode": "constant",
"value": mesh_size,
"bound_value": mesh_size,
}
domain = {"xmin": 0, "xmax": 1, "ymin": 0, "ymax": 1}
if_coarse = True
folder = "example_5_1_1_" + description
file_name = "network_geiger.csv"
write_network(file_name)
gb = importer.from_csv(file_name, mesh_kwargs, domain)
gb.compute_geometry()
g_fine = gb.get_grids(lambda g: g.dim == gb.dim_max())[0].copy()
if if_coarse:
partition = co.create_aggregations(gb)
partition = co.reorder_partition(partition)
co.generate_coarse_grid(gb, partition)
gb.assign_node_ordering()
# Assign parameters
add_data(gb, domain, kf)
# Choose and define the solvers and coupler
solver = dual.DualVEMMixDim("flow")
A, b = solver.matrix_rhs(gb)
up = sps.linalg.spsolve(A, b)
solver.split(gb, "up", up)
gb.add_node_props(["discharge", "pressure", "P0u"])
solver.extract_u(gb, "up", "discharge")
solver.extract_p(gb, "up", "pressure")
solver.project_u(gb, "discharge", "P0u")
exporter.export_vtk(gb, "vem", ["pressure", "P0u"], folder=folder, binary=False)
if if_coarse:
partition = partition[gb.grids_of_dimension(gb.dim_max())[0]]
p = np.array([d["pressure"] for g, d in gb if g.dim == gb.dim_max()]).ravel()
data = {"partition": partition, "pressure": p[partition]}
exporter.export_vtk(g_fine, "sub_grid", data, binary=False, folder=folder)
print("diam", gb.diameter(lambda g: g.dim == gb.dim_max()))
print("num_cells 2d", gb.num_cells(lambda g: g.dim == 2))
print("num_cells 1d", gb.num_cells(lambda g: g.dim == 1))
#------------------------------------------------------------------------------#
Nx = Ny = 20
#g = structured.CartGrid([Nx, Ny], [1, 1])
g = simplex.StructuredTriangleGrid([Nx, Ny], [1, 1])
R = cg.rot(np.pi / 4., [1, 0, 0])
g.nodes = np.dot(R, g.nodes)
g.compute_geometry(is_embedded=True)
#co.coarsen(g, 'by_volume')
# Assign parameters
data = add_data(g)
# Choose and define the solvers
solver = dual.DualVEM('flow')
A, b = solver.matrix_rhs(g, data)
up = sps.linalg.spsolve(A, b)
u = solver.extract_u(g, up)
p = solver.extract_p(g, up)
P0u = solver.project_u(g, u, data)
diam = np.amax(g.cell_diameters())
print("h=", diam, "- err(p)=", error_p(g, p))
exporter.export_vtk(g, 'vem', {"p": p, "P0u": P0u}, folder='vem')
#------------------------------------------------------------------------------#
# Assign parameters
add_data(gb, domain)
# Choose and define the solvers and coupler
solver = dual.DualVEMMixDim("flow")
A, b = solver.matrix_rhs(gb)
up = sps.linalg.spsolve(A, b)
solver.split(gb, "up", up)
gb.add_node_props(["discharge", 'pressure', "P0u"])
solver.extract_u(gb, "up", "discharge")
solver.extract_p(gb, "up", 'pressure')
solver.project_u(gb, "discharge", "P0u")
exporter.export_vtk(gb, 'vem', ['pressure', "P0u"], folder='example_5_1_2')
# This part is very slow and not optimized, it's just to obtain the plots once.
b_box = gb.bounding_box()
N_pts = 1000
y_range = np.linspace(b_box[0][1] + tol, b_box[1][1] - tol, N_pts)
pts = np.stack((625 * np.ones(N_pts), y_range, np.zeros(N_pts)))
values = plot_over_line(gb, pts, 'pressure', tol)
arc_length = y_range - b_box[0][1]
np.savetxt("example_5_1_2/vem_x_625.csv", (arc_length, values))
x_range = np.linspace(b_box[0][0] + tol, b_box[1][0] - tol, N_pts)
pts = np.stack((x_range, 500 * np.ones(N_pts), np.zeros(N_pts)))
values = plot_over_line(gb, pts, 'pressure', tol)
darcy.extract_u(gb, "up", "discharge")
darcy.extract_p(gb, "up", 'pressure')
darcy.project_u(gb, "discharge", "P0u")
# compute the flow rate
total_flow_rate = 0
for g, d in gb:
bound_faces = g.tags['domain_boundary_faces'].nonzero()[0]
if bound_faces.size != 0:
bound_face_centers = g.face_centers[:, bound_faces]
left = bound_face_centers[0, :] < domain['xmin'] + tol
flow_rate = d['discharge'][bound_faces[left]]
total_flow_rate += np.sum(flow_rate)
exporter.export_vtk(gb,
'darcy', ['pressure', "P0u"],
folder=export_folder,
binary=False)
#################################################################
physics = 'transport'
advection = upwind.UpwindMixDim(physics)
mass = mass_matrix.MassMatrixMixDim(physics)
invMass = mass_matrix.InvMassMatrixMixDim(physics)
# Assign parameters
add_data_advection(gb, domain, tol)
gb.add_node_prop('deltaT', prop=deltaT)
U, rhs_u = advection.matrix_rhs(gb)
solver_source = vem_source.IntegralMixedDim('flow')
A_source, b_source = solver_source.matrix_rhs(gb)
up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source)
darcy.split(gb, "up", up)
gb.add_node_props(['pressure', "P0u"])
for g, d in gb:
discharge = darcy.discr.extract_u(g, d["up"])
d['discharge'] = discharge
d['pressure'] = darcy.discr.extract_p(g, d["up"])
d["P0u"] = darcy.discr.project_u(g, discharge, d)
if do_save:
exporter.export_vtk(gb, 'darcy', ['pressure', "P0u"], folder=export_folder)
#################################################################
for g, d in gb:
g.face_tags = d['face_tags']
physics = 'transport'
advection = upwind.UpwindMixedDim(physics)
diffusion = tpfa.TpfaMixedDim(physics)
# Assign parameters
add_data_advection_diffusion(gb, domain, tol)
U, rhs_u = advection.matrix_rhs(gb)
D, rhs_d = diffusion.matrix_rhs(gb)
#------------------------------------------------------------------------------#
mesh_kwargs = {}
mesh_kwargs['mesh_size'] = {'mode': 'constant', 'value': 10, 'bound_value': 10}
domain = {'xmin': 0, 'xmax': 700, 'ymin': 0, 'ymax': 600}
gb = importer.from_csv('network.csv', mesh_kwargs, domain)
gb.compute_geometry()
co.coarsen(gb, 'by_volume')
gb.assign_node_ordering()
internal_flag = FaceTag.FRACTURE
[g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb]
exporter.export_vtk(gb, 'grid', folder='vem')
# Assign parameters
add_data(gb, domain)
# Choose and define the solvers and coupler
solver_flow = vem_dual.DualVEMMixDim('flow')
A_flow, b_flow = solver_flow.matrix_rhs(gb)
solver_source = vem_source.IntegralMixDim('flow')
A_source, b_source = solver_source.matrix_rhs(gb)
up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source)
solver.split(gb, "up", up)
gb.add_node_props(["discharge", 'pressure', "P0u"])
"value": 0.25,
"bound_value": 1
}
file_name = "dfn_square.fab"
file_intersections = "traces_square.dat"
gb = importer.dfn_3d_from_fab(file_name,
file_intersections,
tol=1e-5,
**mesh_kwargs)
gb.remove_nodes(lambda g: g.dim == 0)
gb.compute_geometry()
# co.coarsen(gb, 'by_volume')
gb.assign_node_ordering()
exporter.export_vtk(gb, "grid", folder="vem")
# Assign parameters
add_data(gb, tol)
# Choose and define the solvers and coupler
solver = dual.DualVEMDFN(gb.dim_max(), "flow")
A, b = solver.matrix_rhs(gb)
up = sps.linalg.spsolve(A, b)
solver.split(gb, "up", up)
gb.add_node_props(["discharge", "pressure", "P0u", "err"])
solver.extract_u(gb, "up", "discharge")
solver.extract_p(gb, "up", "pressure")
solver.project_u(gb, "discharge", "P0u")
export_every = 2
step_to_export = np.empty(0)
print("Start the time loop")
print(deltaT, deltaT_r)
while i * deltaT <= T:
# Update the solution
print("Solve the current state (", i * deltaT, ",", T, ")")
conc = invM.dot((M_minus_U).dot(conc) + rhs)
coupler_solver.split(gb, "conc", conc)
if i % export_every == 0:
print("Export the solution of the current state")
export_vtk(gb,
file_name, ["conc"],
time_step=i_export,
folder="simu")
step_to_export = np.r_[step_to_export, i]
i_export += 1
i += 1
export_pvd(gb, file_name, step_to_export * deltaT, folder="simu")
step_to_export = np.empty(0)
i, i_export = 0, 0
while i * deltaT_r <= T:
# Update the solution
conc_r = invM_r.dot((M_minus_U_r).dot(conc_r) + rhs_r)
# Assign parameters
add_data(gb, domain)
# Choose and define the solvers and coupler
solver = dual.DualVEMMixDim("flow")
A, b = solver.matrix_rhs(gb)
up = sps.linalg.spsolve(A, b)
solver.split(gb, "up", up)
gb.add_node_props(["discharge", "pressure", "P0u"])
solver.extract_u(gb, "up", "discharge")
solver.extract_p(gb, "up", "pressure")
solver.project_u(gb, "discharge", "P0u")
exporter.export_vtk(gb, "vem", ["pressure", "P0u"], folder="example_5_1_2")
# This part is very slow and not optimized, it's just to obtain the plots once.
b_box = gb.bounding_box()
N_pts = 1000
y_range = np.linspace(b_box[0][1] + tol, b_box[1][1] - tol, N_pts)
pts = np.stack((625 * np.ones(N_pts), y_range, np.zeros(N_pts)))
values = plot_over_line(gb, pts, "pressure", tol)
arc_length = y_range - b_box[0][1]
np.savetxt("example_5_1_2/vem_x_625.csv", (arc_length, values))
x_range = np.linspace(b_box[0][0] + tol, b_box[1][0] - tol, N_pts)
pts = np.stack((x_range, 500 * np.ones(N_pts), np.zeros(N_pts)))
values = plot_over_line(gb, pts, "pressure", tol)
def darcy_dualVEM_coupling_example2(**kwargs):
#######################
# Simple 2d Darcy problem with known exact solution
#######################
np.set_printoptions(linewidth=999999, threshold=np.nan, precision=16)
f_1 = np.array([[-1, 1, 1, -1], [0, 0, 0, 0], [-1, -1, 1, 1]])
f_2 = np.array([[0, 0, 0, 0], [-1, 1, 1, -1], [-1.5, -1.5, .8, .8]])
domain = {
"xmin": -2,
"xmax": 2,
"ymin": -2,
"ymax": 2,
"zmin": -2,
"zmax": 2
}
kwargs = {
"mesh_size_frac": .25,
"mesh_size_bound": 10,
"mesh_size_min": .02,
"gmsh_path": "~/gmsh/bin/gmsh",
}
gb = meshing.simplex_grid([f_1, f_2], domain, **kwargs)
gb.remove_nodes(lambda g: g.dim == gb.dim_max())
# It's not really working now the coarsening part with the gb
# for g, _ in gb:
# if g.dim != 1:
# part = create_partition(tpfa_matrix(g))
# gb.change_nodes({g: generate_coarse_grid(g, part)})
#
# gb.compute_geometry(is_starshaped=True)
print([g.num_faces for g, _ in gb])
gb.assign_node_ordering()
if kwargs["visualize"]:
plot_grid(gb, info="f", alpha=0)
gb.add_node_props(["perm", "source", "bc", "bc_val"])
for g, d in gb:
kxx = np.ones(g.num_cells)
d["perm"] = tensor.SecondOrderTensor(g.dim, kxx)
d["source"] = np.zeros(g.num_cells)
b_faces = g.tags["domain_boundary_faces"].nonzero()[0]
b_faces_dir = b_faces[np.bitwise_or(g.face_centers[1, b_faces] == -1,
g.face_centers[0, b_faces] == -1)]
b_faces_dir_cond = g.face_centers[0, b_faces_dir]
b_faces_neu = np.setdiff1d(b_faces, b_faces_dir, assume_unique=True)
b_faces = np.hstack((b_faces_dir, b_faces_neu))
b_faces_label = np.hstack(
(["dir"] * b_faces_dir.size, ["neu"] * b_faces_neu.size))
d["bc"] = bc.BoundaryCondition(g, b_faces, b_faces_label)
d["bc_val"] = {
"dir": b_faces_dir_cond,
"neu": np.zeros(b_faces_neu.size)
}
gb.add_edge_prop("kn")
for e, d in gb.edges_props():
g_l = gb.sorted_nodes_of_edge(e)[0]
c = g_l.cell_centers[2, :] > -0.5
d["kn"] = np.ones(g_l.num_cells) + c.astype("float") * (-1 + 1e-2)
solver = dual.DualVEM()
coupling_conditions = dual_coupling.DualCoupling(solver)
solver_coupler = coupler.Coupler(solver, coupling_conditions)
A, b = solver_coupler.matrix_rhs(gb)
up = sps.linalg.spsolve(A, b)
solver_coupler.split(gb, "up", up)
gb.add_node_props(["u", "pressure", "P0u"])
for g, d in gb:
d["u"] = solver.extractU(g, d["up"])
d["pressure"] = solver.extractP(g, d["up"])
d["P0u"] = solver.projectU(g, d["u"], d)
if kwargs["visualize"]:
plot_grid(gb, "pressure", "P0u")
export_vtk(gb, "grid", ["pressure", "P0u"])
diffusion = second_order_tensor.SecondOrderTensorTensor(g.dim, kxx)
f = np.ones(g.num_cells) * g.cell_volumes
data = {'beta_n': beta_n, 'bc': bnd, 'bc_val': bnd_val, 'k': diffusion,
'f': f}
return data
#------------------------------------------------------------------------------#
# the f is considered twice, we guess that non-homogeneous Neumann as well.
Nx = Ny = 20
g = structured.CartGrid([Nx, Ny], [1, 1])
g.compute_geometry()
advection = upwind.Upwind()
diffusion = tpfa.Tpfa()
# Assign parameters
data = add_data(g, advection)
U, rhs_u = advection.matrix_rhs(g, data)
D, rhs_d = diffusion.matrix_rhs(g, data)
theta = sps.linalg.spsolve(D + U, rhs_u + rhs_d)
exporter.export_vtk(g, "advection_diffusion", {"theta": theta})
# The p_reduced only has pressures for the cells of grids of dim>0, so
# should be plotted on a grid where the 0d has been removed:
gb_r, _ = gb.duplicate_without_dimension(0)
# Add the solutions to data fields in the grid buckets
gb.add_node_props(['pressure', "p_condensation"])
gb_r.add_node_props(["p_reduced"])
solver.split(gb, "p_condensation", p_full_condensation)
solver.split(gb_r, "p_reduced", p_reduced)
solver.split(gb, 'pressure', p)
max_p, min_p, normalization, error_norm = np.zeros(1), np.zeros(1), 0, 0
for g, d in gb:
p1, p2 = d['pressure'], d["p_condensation"]
error_norm += sum(
np.power(p1 - p2, 2) * g.cell_volumes * d['param'].apertures)
normalization += sum(g.cell_volumes)
max_p = np.array(np.amax(np.concatenate((max_p, p1)), axis=0), ndmin=1)
min_p = np.array(np.amin(np.concatenate((min_p, p1)), axis=0), ndmin=1)
error_norm = np.power(error_norm / normalization, .5) / (max_p - min_p)
print('The error of the condensation compared to the full method is ',
error_norm)
assert error_norm < 1e-3
export_vtk(gb, "grid_mpfa", ['pressure', "p_condensation"], folder="simu")
export_vtk(gb_r, "grid_mpfa_r", ["p_reduced"], folder="simu")
solver_source = vem_source.DualSourceMixedDim("flow", coupling=[None])
A_source, b_source = solver_source.matrix_rhs(gb)
up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source)
darcy.split(gb, "up", up)
gb.add_node_props(["pressure", "P0u"])
for g, d in gb:
discharge = darcy.discr.extract_u(g, d["up"])
d["discharge"] = discharge
d["pressure"] = darcy.discr.extract_p(g, d["up"])
d["P0u"] = darcy.discr.project_u(g, discharge, d)
if do_save:
exporter.export_vtk(gb, "darcy", ["pressure", "P0u"], folder=export_folder)
#################################################################
physics = "transport"
advection = upwind.UpwindMixedDim(physics)
diffusion = tpfa.TpfaMixedDim(physics)
# Assign parameters
add_data_advection_diffusion(gb, domain, tol)
U, rhs_u = advection.matrix_rhs(gb)
D, rhs_d = diffusion.matrix_rhs(gb)
theta = sps.linalg.spsolve(D + U, rhs_u + rhs_d)
diffusion.split(gb, "temperature", theta)
d['param'].set_discharge(d['u'])
d['pressure'] = darcy.discr.extract_p(g, d["up"])
d["P0u"] = darcy.discr.project_u(g, d['u'], d)
# compute the flow rate
total_flow_rate = 0
for g, d in gb:
bound_faces = g.tags['domain_boundary_faces'].nonzero()[0]
if bound_faces.size != 0:
bound_face_centers = g.face_centers[:, bound_faces]
left = bound_face_centers[0, :] < domain['xmin'] + tol
flow_rate = d['u'][bound_faces[left]]
total_flow_rate += np.sum(flow_rate)
print("total flow rate", total_flow_rate)
exporter.export_vtk(gb, 'darcy', ['pressure', "P0u"], folder=export_folder)
#################################################################
physics = 'transport'
advection = upwind.UpwindMixedDim(physics)
diffusion = tpfa.TpfaMixedDim(physics)
mass = mass_matrix.MassMatrixMixedDim(physics)
invMass = mass_matrix.InvMassMatrixMixedDim(physics)
# Assign parameters
add_data_advection_diffusion(gb, domain, tol, a)
T = 1
deltaT = 0.01
gb.add_node_prop('deltaT', prop=deltaT)
def main(kf, description, mesh_size):
mesh_kwargs = {}
mesh_kwargs['mesh_size'] = {
'mode': 'constant',
'value': mesh_size,
'bound_value': mesh_size
}
domain = {'xmin': 0, 'xmax': 1, 'ymin': 0, 'ymax': 1}
if_coarse = True
folder = 'example_5_1_1_' + description
file_name = 'network_geiger.csv'
write_network(file_name)
gb = importer.from_csv(file_name, mesh_kwargs, domain)
gb.compute_geometry()
g_fine = gb.get_grids(lambda g: g.dim == gb.dim_max())[0].copy()
if if_coarse:
partition = co.create_aggregations(gb)
partition = co.reorder_partition(partition)
co.generate_coarse_grid(gb, partition)
gb.assign_node_ordering()
internal_flag = FaceTag.FRACTURE
[g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb]
# Assign parameters
add_data(gb, domain, kf)
# Choose and define the solvers and coupler
solver = dual.DualVEMMixDim('flow')
A, b = solver.matrix_rhs(gb)
up = sps.linalg.spsolve(A, b)
solver.split(gb, "up", up)
gb.add_node_props(["discharge", 'pressure', "P0u"])
solver.extract_u(gb, "up", "discharge")
solver.extract_p(gb, "up", 'pressure')
solver.project_u(gb, "discharge", "P0u")
exporter.export_vtk(gb,
'vem', ['pressure', "P0u"],
folder=folder,
binary=False)
if if_coarse:
partition = partition[gb.grids_of_dimension(gb.dim_max())[0]]
p = np.array([d['pressure'] for g, d in gb
if g.dim == gb.dim_max()]).ravel()
data = {'partition': partition, 'pressure': p[partition]}
exporter.export_vtk(g_fine,
'sub_grid',
data,
binary=False,
folder=folder)
print("diam", gb.diameter(lambda g: g.dim == gb.dim_max()))
print("num_cells 2d", gb.num_cells(lambda g: g.dim == 2))
print("num_cells 1d", gb.num_cells(lambda g: g.dim == 1))
# ------------------------------------------------------------------------------#
Nx = Ny = 20
# g = structured.CartGrid([Nx, Ny], [1, 1])
g = simplex.StructuredTriangleGrid([Nx, Ny], [1, 1])
R = cg.rot(np.pi / 4.0, [1, 0, 0])
g.nodes = np.dot(R, g.nodes)
g.compute_geometry()
# co.coarsen(g, 'by_volume')
# Assign parameters
data = add_data(g)
# Choose and define the solvers
solver = dual.DualVEM("flow")
A, b = solver.matrix_rhs(g, data)
up = sps.linalg.spsolve(A, b)
u = solver.extract_u(g, up)
p = solver.extract_p(g, up)
P0u = solver.project_u(g, u, data)
diam = np.amax(g.cell_diameters())
print("h=", diam, "- err(p)=", error_p(g, p))
exporter.export_vtk(g, "vem", {"p": p, "P0u": P0u}, folder="vem")
# ------------------------------------------------------------------------------#
def darcy_dualVEM_coupling_example2(**kwargs):
#######################
# Simple 2d Darcy problem with known exact solution
#######################
np.set_printoptions(linewidth=999999, threshold=np.nan, precision=16)
f_1 = np.array([[-1, 1, 1, -1], [0, 0, 0, 0], [-1, -1, 1, 1]])
f_2 = np.array([[0, 0, 0, 0], [-1, 1, 1, -1], [-1.5, -1.5, .8, .8]])
domain = {'xmin': -2, 'xmax': 2, 'ymin': -2, 'ymax': 2, 'zmin': -2, 'zmax':
2}
# mesh_size = {'mode': 'constant', 'value': 0.5, 'bound_value': 1}
mesh_size = {'mode': 'constant', 'value': 5, 'bound_value': 10}
mesh_size = {'mode': 'constant', 'value': 0.25, 'bound_value': 10}
kwargs['mesh_size'] = mesh_size
kwargs['gmsh_path'] = '~/gmsh/bin/gmsh'
gb = meshing.simplex_grid([f_1, f_2], domain, **kwargs)
gb.remove_nodes(lambda g: g.dim == gb.dim_max())
# It's not really working now the coarsening part with the gb
# for g, _ in gb:
# if g.dim != 1:
# part = create_partition(tpfa_matrix(g))
# gb.change_nodes({g: generate_coarse_grid(g, part)})
#
# gb.compute_geometry(is_starshaped=True)
print([g.num_faces for g, _ in gb])
gb.assign_node_ordering()
# Need to remove the boundary flag explicity from the fracture face,
# because of the mix formulation
internal_flag = FaceTag.FRACTURE
[g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag)
for g, _ in gb if g.dim == gb.dim_max()]
if kwargs['visualize']:
plot_grid(gb, info="f", alpha=0)
gb.add_node_props(['perm', 'source', 'bc', 'bc_val'])
for g, d in gb:
kxx = np.ones(g.num_cells)
d['perm'] = tensor.SecondOrder(g.dim, kxx)
d['source'] = np.zeros(g.num_cells)
b_faces = g.get_boundary_faces()
b_faces_dir = b_faces[np.bitwise_or(g.face_centers[1, b_faces] == -1,
g.face_centers[0, b_faces] == -1)]
b_faces_dir_cond = g.face_centers[0, b_faces_dir]
b_faces_neu = np.setdiff1d(b_faces, b_faces_dir, assume_unique=True)
b_faces = np.hstack((b_faces_dir, b_faces_neu))
b_faces_label = np.hstack((['dir'] * b_faces_dir.size,
['neu'] * b_faces_neu.size))
d['bc'] = bc.BoundaryCondition(g, b_faces, b_faces_label)
d['bc_val'] = {'dir': b_faces_dir_cond,
'neu': np.zeros(b_faces_neu.size)}
gb.add_edge_prop('kn')
for e, d in gb.edges_props():
g_l = gb.sorted_nodes_of_edge(e)[0]
c = g_l.cell_centers[2, :] > -0.5
d['kn'] = (np.ones(g_l.num_cells) + c.astype('float') * (-1 + 1e-2))
solver = dual.DualVEM()
coupling_conditions = dual_coupling.DualCoupling(solver)
solver_coupler = coupler.Coupler(solver, coupling_conditions)
A, b = solver_coupler.matrix_rhs(gb)
up = sps.linalg.spsolve(A, b)
solver_coupler.split(gb, "up", up)
gb.add_node_props(["u", 'pressure', "P0u"])
for g, d in gb:
d["u"] = solver.extractU(g, d["up"])
d['pressure'] = solver.extractP(g, d["up"])
d["P0u"] = solver.projectU(g, d["u"], d)
if kwargs['visualize']:
plot_grid(gb, 'pressure', "P0u")
export_vtk(gb, "grid", ['pressure', "P0u"])
darcy.extract_u(gb, "up", "discharge")
darcy.extract_p(gb, "up", "pressure")
darcy.project_u(gb, "discharge", "P0u")
# compute the flow rate
total_flow_rate = 0
for g, d in gb:
bound_faces = g.tags["domain_boundary_faces"].nonzero()[0]
if bound_faces.size != 0:
bound_face_centers = g.face_centers[:, bound_faces]
left = bound_face_centers[0, :] < domain["xmin"] + tol
flow_rate = d["discharge"][bound_faces[left]]
total_flow_rate += np.sum(flow_rate)
exporter.export_vtk(gb,
"darcy", ["pressure", "P0u"],
folder=export_folder,
binary=False)
#################################################################
physics = "transport"
advection = upwind.UpwindMixDim(physics)
mass = mass_matrix.MassMatrixMixDim(physics)
invMass = mass_matrix.InvMassMatrixMixDim(physics)
# Assign parameters
add_data_advection(gb, domain, tol)
gb.add_node_prop("deltaT", prop=deltaT)
U, rhs_u = advection.matrix_rhs(gb)
"zmax": 5500,
}
mesh_kwargs["domain"] = domain
print("create soultz grid")
gb = soultz_grid.create_grid(**mesh_kwargs)
gb.compute_geometry()
if if_coarse:
pp.coarsening.coarsen(gb, "by_volume")
gb.assign_node_ordering()
print("solve Darcy problem")
for g, d in gb:
d["cell_id"] = np.arange(g.num_cells)
exporter.export_vtk(gb, "grid", ["cell_id"], folder=export_folder)
# Choose and define the solvers and coupler
darcy = dual.DualVEMMixDim("flow")
# Assign parameters
add_data_darcy(gb, domain, tol)
A, b = darcy.matrix_rhs(gb)
up = sps.linalg.spsolve(A, b)
darcy.split(gb, "up", up)
gb.add_node_props(["pressure", "P0u", "discharge"])
darcy.extract_u(gb, "up", "discharge")
darcy.extract_p(gb, "up", "pressure")
