def flux_disc(self):
if self.mp:
return mpfa.MpfaMixedDim(physics=self.physics)
elif self.mix:
return MixedDiscretization(self.physics)
else:
return tpfa.TpfaMixedDim(physics=self.physics)
def test_mpfa_matching_grids_refine_1d_no_flow(self):
gb = self.set_grids(N=[1, 2], num_nodes_mortar=2, num_nodes_1d=3)
self.set_param_flow(gb, no_flow=True)
solver_flow = mpfa.MpfaMixedDim("flow")
A_flow, b_flow = solver_flow.matrix_rhs(gb)
p = sps.linalg.spsolve(A_flow, b_flow)
self.assertTrue(np.all(p[:4] == 1))
self.assertTrue(np.all(p[4:] == 0))
def test_mpfa_matching_grids_refine_mortar_no_flow(self):
gb = self.set_grids(N=[1, 2], num_nodes_mortar=3, num_nodes_1d=2)
self.set_param_flow(gb, no_flow=True)
solver_flow = mpfa.MpfaMixedDim("flow")
A_flow, b_flow = solver_flow.matrix_rhs(gb)
for e, d in gb.edges():
mg = d["mortar_grid"]
p = sps.linalg.spsolve(A_flow, b_flow)
self.assertTrue(np.all(p[:3] == 1))
self.assertTrue(np.all(p[3:] == 0))
def test_mpfa_matching_grids_refine_2d_uniform_flow(self):
kn = 1e4
gb = self.set_grids(N=[2, 2], num_nodes_mortar=2, num_nodes_1d=2)
self.set_param_flow(gb, no_flow=False, kn=kn)
solver_flow = mpfa.MpfaMixedDim("flow")
A_flow, b_flow = solver_flow.matrix_rhs(gb)
p = sps.linalg.spsolve(A_flow, b_flow)
solver_flow.split(gb, "pressure", p)
g_2d = gb.grids_of_dimension(2)[0]
p_2d = gb.node_props(g_2d, "pressure")
# NOTE: This will not be entirely correct due to impact of normal permeability at fracture
self.assertTrue(np.allclose(p_2d, g_2d.cell_centers[1], rtol=1e-4))
g_1d = gb.grids_of_dimension(1)[0]
p_1d = gb.node_props(g_1d, "pressure")
# NOTE: This will not be entirely correct,
self.assertTrue(np.allclose(p_1d, g_1d.cell_centers[1]))
def main(kf, description, multi_point, if_export=False):
# Define the geometry and produce the meshes
mesh_kwargs = {}
mesh_size = 0.045
mesh_kwargs['mesh_size'] = {
'mode': 'constant',
'value': mesh_size,
'bound_value': mesh_size
}
domain = {'xmin': 0, 'xmax': 1, 'ymin': 0, 'ymax': 1}
file_name = 'network_geiger.csv'
write_network(file_name)
gb = importer.dfm_2d_from_csv(file_name, mesh_kwargs, domain)
gb.compute_geometry()
gb.assign_node_ordering()
# Assign parameters
add_data(gb, domain, kf, mesh_size)
# Choose discretization and define the solver
if multi_point:
solver = mpfa.MpfaMixedDim('flow')
else:
solver = tpfa.TpfaMixedDim('flow')
# Discretize
A, b = solver.matrix_rhs(gb)
# Solve the linear system
p = sps.linalg.spsolve(A, b)
# Store the solution
gb.add_node_props(['pressure'])
solver.split(gb, 'pressure', p)
if if_export:
save = Exporter(gb, "fv", folder="fv_" + description)
save.write_vtk(['pressure'])
def flux_disc(self):
return mpfa.MpfaMixedDim(physics=self.physics)
def flux_disc(self):
if self.multi_point:
return mpfa.MpfaMixedDim(physics=self.physics)
else:
return tpfa.TpfaMixedDim(physics=self.physics)
f_set = [f_1, f_2]
domain = {
'xmin': -1,
'xmax': 1,
'ymin': -1,
'ymax': 1
} # , 'zmin': -1, 'zmax': 1}
gb = meshing.simplex_grid(f_set, domain)
gb.assign_node_ordering()
# Assign parameters
add_data(gb)
# Choose and define the solvers and coupler
solver = mpfa.MpfaMixedDim()
A, b = solver.matrix_rhs(gb)
p = sps.linalg.spsolve(A.copy(), b)
# Solve the problem without 0d grids.
eliminate_dim = 0
p_full_condensation, p_reduced, _, _ = condensation.solve_static_condensation(
A, b, gb, eliminate_dim)
# 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"])
def run_mpfa(self, gb):
solver_flow = mpfa.MpfaMixedDim("flow")
A_flow, b_flow = solver_flow.matrix_rhs(gb)
p = sps.linalg.spsolve(A_flow, b_flow)
solver_flow.split(gb, "pressure", p)
def test_mpfa_fluxes_2d_1d_left_right_dir_neu(self):
"""
Grid: 2 x 2 cells in matrix + 2 cells in the fracture from left to right.
Dirichlet + inflow + no-flow, conductive fracture.
Tests pressure solution and fluxes.
"""
f = np.array([[0, 1], [.5, .5]])
gb = meshing.cart_grid([f], [2, 2], **{'physdims': [1, 1]})
gb.compute_geometry()
gb.assign_node_ordering()
tol = 1e-3
solver = mpfa.MpfaMixedDim(physics='flow')
gb.add_node_props(['param'])
a = 1e-2
for g, d in gb:
param = Parameters(g)
a_dim = np.power(a, gb.dim_max() - g.dim)
aperture = np.ones(g.num_cells) * a_dim
param.set_aperture(aperture)
p = tensor.SecondOrder(
3,
np.ones(g.num_cells) * np.power(1e-3, g.dim < gb.dim_max()))
param.set_tensor('flow', p)
bound_faces = g.get_boundary_faces()
bound_face_centers = g.face_centers[:, bound_faces]
right = bound_face_centers[0, :] > 1 - tol
left = bound_face_centers[0, :] < tol
labels = np.array(['neu'] * bound_faces.size)
labels[right] = ['dir']
bc_val = np.zeros(g.num_faces)
bc_dir = bound_faces[right]
bc_neu = bound_faces[left]
bc_val[bc_dir] = g.face_centers[0, bc_dir]
bc_val[bc_neu] = -g.face_areas[bc_neu] * a_dim
param.set_bc('flow', bc.BoundaryCondition(g, bound_faces, labels))
param.set_bc_val('flow', bc_val)
d['param'] = param
gb.add_edge_prop('param')
for e, d in gb.edges_props():
g_h = gb.sorted_nodes_of_edge(e)[1]
d['param'] = Parameters(g_h)
A, rhs = solver.matrix_rhs(gb)
p = sps.linalg.spsolve(A, rhs)
solver.solver.split(gb, "pressure", p)
fvutils.compute_discharges(gb)
p_known = np.array([
1.7574919, 1.25249747, 1.7574919, 1.25249747, 1.25250298,
1.80993337
])
# Known discharges
d_0, d_1 = fluxes_2d_1d_left_right_dir_neu()
rtol = 1e-6
atol = rtol
for _, d in gb:
if d['node_number'] == 0:
assert np.allclose(d['discharge'], d_0, rtol, atol)
if d['node_number'] == 1:
assert np.allclose(d['discharge'], d_1, rtol, atol)
assert np.allclose(p, p_known, rtol, atol)
