def main(id_problem, tol=1e-5, N_pts=1000, if_export=False):
folder_export = 'example_2_2_tpfa/' + str(id_problem) + "/"
file_export = 'tpfa'
gb = example_2_2_create_grid.create(id_problem, tol=tol)
# Assign parameters
example_2_2_data.add_data(gb, tol)
# Choose and define the solvers and coupler
solver_flux = tpfa.TpfaDFN(gb.dim_max(), 'flow')
A_flux, b_flux = solver_flux.matrix_rhs(gb)
solver_source = source.IntegralDFN(gb.dim_max(), 'flow')
A_source, b_source = solver_source.matrix_rhs(gb)
p = sps.linalg.spsolve(A_flux + A_source, b_flux + b_source)
solver_flux.split(gb, 'pressure', p)
if if_export:
save = Exporter(gb, file_export, folder_export)
save.write_vtk(['pressure'])
b_box = gb.bounding_box()
y_range = np.linspace(b_box[0][1] + tol, b_box[1][1] - tol, N_pts)
pts = np.stack((1.5 * np.ones(N_pts), y_range, 0.5 * np.ones(N_pts)))
values = example_2_2_data.plot_over_line(gb, pts, 'pressure', tol)
arc_length = y_range - b_box[0][1]
np.savetxt(folder_export + "plot_over_line.txt", (arc_length, values))
# compute the flow rate
fvutils.compute_discharges(gb, 'flow')
diam, flow_rate = example_2_2_data.compute_flow_rate(gb, tol)
np.savetxt(folder_export + "flow_rate.txt", (diam, flow_rate))
def discharge(self, discharge_name='discharge'):
if self.is_GridBucket:
fvutils.compute_discharges(self.grid(), self.physics,
p_name=self.pressure_name)
else:
fvutils.compute_discharges(self.grid(), self.physics,
self.pressure_name,
self._data)
def test_compute_discharge_mono_grid(self):
g = structured.CartGrid([1, 1])
flux = sps.csc_matrix((4, 1))
bound_flux = sps.csc_matrix(
np.array([[0, 0, 0, 3], [5, 0, 0, 0], [1, 0, 0, 0], [3, 0, 0, 0]]))
data = {"param": Parameters(g)}
bc_val = np.array([1, 2, 3, 4])
data["param"].set_bc_val("flow", bc_val)
data["flux"] = flux
data["bound_flux"] = bound_flux
data["pressure"] = np.array([3.14])
fvutils.compute_discharges(g, data=data)
dis = data["discharge"]
dis_true = flux * data["pressure"] + bound_flux * bc_val
self.assertTrue(np.allclose(dis, dis_true))
def test_compute_discharge_mono_grid():
g = structured.CartGrid([1, 1])
flux = sps.csc_matrix((4, 1))
bound_flux = sps.csc_matrix(
np.array([[0, 0, 0, 3], [5, 0, 0, 0], [1, 0, 0, 0], [3, 0, 0, 0]]))
data = {'param': Parameters(g)}
bc_val = np.array([1, 2, 3, 4])
data['param'].set_bc_val('flow', bc_val)
data['flux'] = flux
data['bound_flux'] = bound_flux
data['pressure'] = np.array([3.14])
fvutils.compute_discharges(g, data=data)
dis = data['discharge']
dis_true = flux * data['pressure'] + bound_flux * bc_val
assert np.allclose(dis, dis_true)
def solve_elliptic_problem(gb):
for g, d in gb:
if g.dim == 2:
d['param'].set_source('flow', source(g, 0.0))
dir_bound = np.argwhere(g.has_face_tag(FaceTag.DOMAIN_BOUNDARY))
bc_cond = bc.BoundaryCondition(g, dir_bound, ['dir'] * dir_bound.size)
d['param'].set_bc('flow', bc_cond)
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)
flux = elliptic.EllipticModel(gb)
p = flux.solve()
flux.split('pressure')
fvutils.compute_discharges(gb)
def solve_elliptic_problem(gb):
for g, d in gb:
if g.dim == 2:
d['param'].set_source('flow', source(g, 0.0))
dir_bound = g.tags['domain_boundary_faces'].nonzero()[0]
bc_cond = bc.BoundaryCondition(g, dir_bound, ['dir'] * dir_bound.size)
d['param'].set_bc('flow', bc_cond)
gb.add_edge_props('param')
for e, d in gb.edges():
g_h = gb.nodes_of_edge(e)[1]
d['param'] = Parameters(g_h)
flux = elliptic.EllipticModel(gb)
p = flux.solve()
flux.split('pressure')
fvutils.compute_discharges(gb)
def main(id_problem, tol=1e-5, N_pts=1000, if_export=False):
mesh_size = 0.025 # 0.01 0.05
folder_export = 'example_2_3_tpfa_' + str(mesh_size) + '/' + str(
id_problem) + "/"
file_export = 'tpfa'
gb = example_2_3_create_grid.create(id_problem,
mesh_size=mesh_size,
tol=tol)
# Assign parameters
example_2_3_data.add_data(gb, tol)
# Choose and define the solvers and coupler
solver_flux = tpfa.TpfaDFN(gb.dim_max(), 'flow')
A_flux, b_flux = solver_flux.matrix_rhs(gb)
solver_source = source.IntegralDFN(gb.dim_max(), 'flow')
A_source, b_source = solver_source.matrix_rhs(gb)
p = sps.linalg.spsolve(A_flux + A_source, b_flux + b_source)
solver_flux.split(gb, "p", p)
if if_export:
save = Exporter(gb, file_export, folder_export)
save.write_vtk(["p"])
b_box = gb.bounding_box()
y_range = np.linspace(b_box[0][1] + tol, b_box[1][1] - tol, N_pts)
pts = np.stack((0.35 * np.ones(N_pts), y_range, np.zeros(N_pts)))
values = example_2_3_data.plot_over_line(gb, pts, 'p', tol)
arc_length = y_range - b_box[0][1]
np.savetxt(folder_export + "plot_over_line.txt", (arc_length, values))
# compute the flow rate
fvutils.compute_discharges(gb, 'flow')
diam, flow_rate = example_2_3_data.compute_flow_rate(gb, tol)
np.savetxt(folder_export + "flow_rate.txt", (diam, flow_rate))
# compute the number of cells
num_cells = gb.num_cells(lambda g: g.dim == 2)
with open(folder_export + "cells.txt", "w") as f:
f.write(str(num_cells))
def main(grid_name, direction):
file_export = "solution"
tol = 1e-4
folder_grids = "/home/elle/Dropbox/Work/tipetut/"
gb = pickle.load(open(folder_grids + grid_name, "rb"))
folder_export = "./example_4_tpfa_" + grid_name + "_" + direction + "/"
domain = {
"xmin": -800,
"xmax": 600,
"ymin": 100,
"ymax": 1500,
"zmin": -100,
"zmax": 1000,
}
example_4_data.add_data(gb, domain, direction, tol)
# Choose and define the solvers and coupler
solver_flux = tpfa.TpfaDFN(gb.dim_max(), "flow")
A_flux, b_flux = solver_flux.matrix_rhs(gb)
solver_source = source.IntegralDFN(gb.dim_max(), "flow")
A_source, b_source = solver_source.matrix_rhs(gb)
p = sps.linalg.spsolve(A_flux + A_source, b_flux + b_source)
solver_flux.split(gb, "p", p)
save = Exporter(gb, file_export, folder_export)
save.write_vtk(["p"])
# compute the flow rate
fvutils.compute_discharges(gb, "flow")
diam, flow_rate = example_4_data.compute_flow_rate(gb, direction, domain,
tol)
np.savetxt(folder_export + "flow_rate.txt", (diam, flow_rate))
# compute the number of cells
num_cells = gb.num_cells(lambda g: g.dim == 2)
with open(folder_export + "cells.txt", "w") as f:
f.write(str(num_cells))
def main(grid_name, direction):
file_export = 'solution'
tol = 1e-4
folder_grids = '/home/elle/Dropbox/Work/tipetut/'
gb = pickle.load(open(folder_grids + grid_name, 'rb'))
folder_export = './example_4_mpfa_' + grid_name + '_' + direction + '/'
domain = {
'xmin': -800,
'xmax': 600,
'ymin': 100,
'ymax': 1500,
'zmin': -100,
'zmax': 1000
}
example_4_data.add_data(gb, domain, direction, tol)
# Choose and define the solvers and coupler
solver_flux = mpfa.MpfaDFN(gb.dim_max(), 'flow')
A_flux, b_flux = solver_flux.matrix_rhs(gb)
solver_source = source.IntegralDFN(gb.dim_max(), 'flow')
A_source, b_source = solver_source.matrix_rhs(gb)
p = sps.linalg.spsolve(A_flux + A_source, b_flux + b_source)
solver_flux.split(gb, "p", p)
save = Exporter(gb, file_export, folder_export)
save.write_vtk(["p"])
# compute the flow rate
fvutils.compute_discharges(gb, 'flow')
diam, flow_rate = example_4_data.compute_flow_rate(gb, direction, domain,
tol)
np.savetxt(folder_export + "flow_rate.txt", (diam, flow_rate))
# compute the number of cells
num_cells = gb.num_cells(lambda g: g.dim == 2)
with open(folder_export + "cells.txt", "w") as f:
f.write(str(num_cells))
def main(id_problem, tol=1e-5, N_pts=1000, if_export=False):
mesh_size = 0.425
folder_export = "example_2_1_mpfa_" + str(mesh_size) + "/" + str(
id_problem) + "/"
file_export = "mpfa"
gb = example_2_1_create_grid.create(id_problem,
mesh_size=mesh_size,
tol=tol)
# Assign parameters
example_2_1_data.add_data(gb, tol)
# Choose and define the solvers and coupler
solver_flux = mpfa.MpfaDFN(gb.dim_max(), "flow")
A_flux, b_flux = solver_flux.matrix_rhs(gb)
solver_source = source.IntegralDFN(gb.dim_max(), "flow")
A_source, b_source = solver_source.matrix_rhs(gb)
p = sps.linalg.spsolve(A_flux + A_source, b_flux + b_source)
solver_flux.split(gb, "pressure", p)
if if_export:
save = Exporter(gb, file_export, folder_export)
save.write_vtk(["pressure"])
b_box = gb.bounding_box()
z_range = np.linspace(b_box[0][2], b_box[1][2], N_pts)
pts = np.stack((0.5 * np.ones(N_pts), 0.5 * np.ones(N_pts), z_range))
values = example_2_1_data.plot_over_line(gb, pts, "pressure", tol)
arc_length = z_range - b_box[0][2]
np.savetxt(folder_export + "plot_over_line.txt", (arc_length, values))
# compute the flow rate
fvutils.compute_discharges(gb, "flow")
diam, flow_rate = example_2_1_data.compute_flow_rate(gb, tol)
np.savetxt(folder_export + "flow_rate.txt", (diam, flow_rate))
def discharge(self, d_name='discharge', p_name='pressure'):
self.pressure(p_name)
fvutils.compute_discharges(self.grid(), d_name=d_name, p_name=p_name)
def test_upwind_2d_1d_cross_with_elimination(self):
"""
Simplest possible elimination scenario, one 0d-grid removed. Check on upwind
matrix, rhs, solution and time step estimate. Full solution included
(as comments) for comparison purposes if test breaks.
"""
f1 = np.array([[0, 1], [.5, .5]])
f2 = np.array([[.5, .5], [0, 1]])
domain = {'xmin': 0, 'ymin': 0, 'xmax': 1, 'ymax': 1}
mesh_size = 0.4
mesh_kwargs = {}
mesh_kwargs['mesh_size'] = {
'mode': 'constant',
'value': mesh_size,
'bound_value': mesh_size
}
gb = meshing.cart_grid([f1, f2], [2, 2], **{'physdims': [1, 1]})
#gb = meshing.simplex_grid( [f1, f2],domain,**mesh_kwargs)
gb.compute_geometry()
gb.assign_node_ordering()
# Enforce node orderning because of Python 3.5 and 2.7.
# Don't do it in general.
cell_centers_1 = np.array([[7.50000000e-01, 2.500000000e-01],
[5.00000000e-01, 5.00000000e-01],
[-5.55111512e-17, 5.55111512e-17]])
cell_centers_2 = np.array([[5.00000000e-01, 5.00000000e-01],
[7.50000000e-01, 2.500000000e-01],
[-5.55111512e-17, 5.55111512e-17]])
for g, d in gb:
if g.dim == 1:
if np.allclose(g.cell_centers, cell_centers_1):
d['node_number'] = 1
elif np.allclose(g.cell_centers, cell_centers_2):
d['node_number'] = 2
else:
raise ValueError('Grid not found')
tol = 1e-3
solver = tpfa.TpfaMixedDim()
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)
kxx = np.ones(g.num_cells) * np.power(1e3, g.dim < gb.dim_max())
p = tensor.SecondOrder(3, kxx, kyy=kxx, kzz=kxx)
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)
# Transport:
source = g.cell_volumes * a_dim
param.set_source("transport", source)
bound_faces = g.get_boundary_faces()
bound_face_centers = g.face_centers[:, bound_faces]
left = bound_face_centers[0, :] < tol
right = bound_face_centers[0, :] > 1 - tol
bottom = bound_face_centers[1, :] < tol
top = bound_face_centers[1, :] > 1 - tol
labels = np.array(['neu'] * bound_faces.size)
labels[np.logical_or(np.logical_or(left, right),
np.logical_or(top, bottom))] = ['dir']
bc_val = np.zeros(g.num_faces)
#bc_dir = bound_faces[np.logical_or(left, right)]
#bc_val[bc_dir] = 1
param.set_bc('transport',
bc.BoundaryCondition(g, bound_faces, labels))
param.set_bc_val('transport', 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)
_, p_red, _, _ = condensation.solve_static_condensation(A,
rhs,
gb,
dim=0)
dim_to_remove = 0
gb_r, elimination_data = gb.duplicate_without_dimension(dim_to_remove)
condensation.compute_elimination_fluxes(gb, gb_r, elimination_data)
solver.split(gb_r, "pressure", p_red)
# fvutils.compute_discharges(gb)
fvutils.compute_discharges(gb_r)
#------Transport------#
advection_discr = upwind.Upwind(physics="transport")
advection_coupling_conditions = upwind.UpwindCoupling(advection_discr)
advection_coupler = coupler.Coupler(advection_discr,
advection_coupling_conditions)
U_r, rhs_u_r = advection_coupler.matrix_rhs(gb_r)
_, rhs_src_r = IntegralMixedDim(physics='transport').matrix_rhs(gb_r)
rhs_u_r = rhs_u_r + rhs_src_r
deltaT = np.amin(
gb_r.apply_function(advection_discr.cfl,
advection_coupling_conditions.cfl).data)
theta_r = sps.linalg.spsolve(U_r, rhs_u_r)
U_known, rhs_known, theta_known, deltaT_known = known_for_elimination()
tol = 1e-7
assert (np.isclose(deltaT, deltaT_known, tol, tol))
assert ((np.amax(np.absolute(U_r - U_known))) < tol)
assert ((np.amax(np.absolute(rhs_u_r - rhs_known))) < tol)
assert ((np.amax(np.absolute(theta_r - theta_known))) < tol)
def discharge(self, d_name="discharge", p_name="pressure"):
self.pressure(p_name)
fvutils.compute_discharges(self.grid(), d_name=d_name, p_name=p_name)
def test_tpfa_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 = tpfa.TpfaMixedDim(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.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)
def test_tpfa_fluxes_2d_1d_cross_with_elimination(self):
f1 = np.array([[0, 1], [.5, .5]])
f2 = np.array([[.5, .5], [0, 1]])
domain = {'xmin': 0, 'ymin': 0, 'xmax': 1, 'ymax': 1}
mesh_size = 0.4
mesh_kwargs = {}
mesh_kwargs['mesh_size'] = {
'mode': 'constant',
'value': mesh_size,
'bound_value': mesh_size
}
gb = meshing.cart_grid([f1, f2], [2, 2], **{'physdims': [1, 1]})
#gb = meshing.simplex_grid( [f1, f2],domain,**mesh_kwargs)
gb.compute_geometry()
gb.assign_node_ordering()
# Enforce node orderning because of Python 3.5 and 2.7.
# Don't do it in general.
cell_centers_1 = np.array([[7.50000000e-01, 2.500000000e-01],
[5.00000000e-01, 5.00000000e-01],
[-5.55111512e-17, 5.55111512e-17]])
cell_centers_2 = np.array([[5.00000000e-01, 5.00000000e-01],
[7.50000000e-01, 2.500000000e-01],
[-5.55111512e-17, 5.55111512e-17]])
for g, d in gb:
if g.dim == 1:
if np.allclose(g.cell_centers, cell_centers_1):
d['node_number'] = 1
elif np.allclose(g.cell_centers, cell_centers_2):
d['node_number'] = 2
else:
raise ValueError('Grid not found')
tol = 1e-3
solver = tpfa.TpfaMixedDim('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)
kxx = np.ones(g.num_cells) * np.power(1e3, g.dim < gb.dim_max())
p = tensor.SecondOrder(3, kxx, kyy=kxx, kzz=kxx)
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)
p = sps.linalg.spsolve(A, rhs)
p_cond, p_red, _, _ = condensation.solve_static_condensation(\
A, rhs, gb, dim=0)
solver.split(gb, "p_cond", p_cond)
solver.split(gb, "pressure", p)
# Make a copy of the grid bucket without the 0d grid
dim_to_remove = 0
gb_r, elimination_data = gb.duplicate_without_dimension(dim_to_remove)
# Compute the flux discretization on the new edges
condensation.compute_elimination_fluxes(gb, gb_r, elimination_data)
# Compute the discharges from the flux discretizations and computed pressures
solver.split(gb_r, "pressure", p_red)
fvutils.compute_discharges(gb)
fvutils.compute_discharges(gb_r)
# Known discharges
d_0, d_1, d_2 = fluxes_2d_1d_cross_with_elimination()
# Check node fluxes, ...
rtol = 1e-6
atol = rtol
for g, 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)
if d['node_number'] == 2:
assert np.allclose(d['discharge'], d_2, rtol, atol)
for g, d in gb_r:
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)
if d['node_number'] == 2:
assert np.allclose(d['discharge'], d_2, rtol, atol)
# ... edge fluxes ...
d_01, d_10, d_02, d_20, d_13, d_23 = coupling_fluxes_2d_1d_cross_no_el(
)
for e, data in gb.edges_props():
g1, g2 = gb.sorted_nodes_of_edge(e)
pa = data['param']
node_numbers = gb.nodes_prop([g2, g1], 'node_number')
if pa is not None:
if node_numbers == (0, 1):
assert np.allclose( data['discharge'], d_01, rtol, atol) or \
np.allclose( data['discharge'], d_10, rtol, atol)
if node_numbers == (0, 2):
assert np.allclose( data['discharge'], d_02, rtol, atol) or \
np.allclose( data['discharge'], d_20, rtol, atol)
if node_numbers == (1, 3):
assert np.allclose(data['discharge'], d_13, rtol, atol)
if node_numbers == (2, 3):
assert np.allclose(data['discharge'], d_23, rtol, atol)
d_11, d_21, d_22 = coupling_fluxes_2d_1d_cross_with_el()
for e, data in gb_r.edges_props():
g1, g2 = gb_r.sorted_nodes_of_edge(e)
pa = data['param']
node_numbers = gb_r.nodes_prop([g2, g1], 'node_number')
if pa is not None:
if node_numbers == (0, 1):
assert np.allclose( data['discharge'], d_01, rtol, atol) or \
np.allclose( data['discharge'], d_10, rtol, atol)
if node_numbers == (0, 2):
assert np.allclose( data['discharge'], d_02, rtol, atol) or \
np.allclose( data['discharge'], d_20, rtol, atol)
if node_numbers == (1, 1):
assert np.allclose(data['discharge'], d_11, rtol, atol)
if node_numbers == (2, 1):
assert np.allclose(data['discharge'], d_21, rtol, atol)
if node_numbers == (2, 2):
assert np.allclose(data['discharge'], d_22, rtol, atol)
# ... and pressures
tol = 1e-10
assert ((np.amax(np.absolute(p - p_cond))) < tol)
assert (np.sum(
error.error_L2(g, d['pressure'], d['p_cond'])
for g, d in gb) < tol)
edge_params(gb)
gb_el, el_data = gb.duplicate_without_dimension(1)
problem = FlowModel(gb)
problem_el = FlowModel(gb_el, el='_el')
Both = BothProblems(problem, problem_el)
k_h = 10**4
k_v = 10**-4
p, p_el = Both.solve(k_h, k_v)
problem.flux_disc().split(gb, 'pressure', p)
problem_el.flux_disc().split(gb_el, 'pressure', p_el)
Both.save()
SC.compute_elimination_fluxes(gb, gb_el, el_data)
compute_discharges(gb_el)
compute_discharges(gb)
assign_data(gb, TransportData, 'transport_data')
transport_problem = TransportSolver(gb)
sol = transport_problem.solve()
ndof_el = problem_el.flux_disc().ndof(gb_el)
assign_data(gb_el, TransportData, 'transport_data')
transport_problem_el = TransportSolver(gb_el, el='_el')
sol_el = transport_problem_el.solve()
t = sol['transport']
t_el = sol_el['transport']
transport_problem.split(x_name='solution')
transport_problem.save(['solution'])
