def main(coarse):
tol = 1e-6
problem_kwargs = {}
problem_kwargs['file_name'] = 'solution'
if coarse:
problem_kwargs['folder_name'] = 'vem_coarse'
else:
problem_kwargs['folder_name'] = 'vem'
h = 0.08
grid_kwargs = {}
grid_kwargs['mesh_size'] = {
'mode': 'constant',
'value': h,
'bound_value': h,
'tol': tol
}
file_dfm = 'dfm.csv'
gb, domain = importer.dfm_3d_from_csv(file_dfm, tol, **grid_kwargs)
gb.compute_geometry()
if coarse:
coarsening.coarsen(gb, 'by_volume')
gb.add_node_props(['face_tags'])
for g, d in gb:
d['face_tags'] = g.face_tags.copy()
internal_flag = FaceTag.FRACTURE
[g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb]
problem = elliptic.DualEllipticModel(gb, **problem_kwargs)
# Assign parameters
add_data(gb, domain, tol)
problem.solve()
problem.split()
problem.pressure('pressure')
problem.discharge('discharge')
problem.project_discharge('P0u')
problem.save(['pressure', 'P0u', 'frac_num'])
for g, d in gb:
g.face_tags = d['face_tags']
problem_kwargs['file_name'] = 'transport'
for g, d in gb:
d['problem'] = AdvectiveModelData(g, d, domain, tol)
advective = AdvectiveModel(gb, **problem_kwargs)
advective.solve()
advective.save()
def test_elliptic_uniform_flow_cart(self):
gb = setup_2d_1d([10, 10])
problem = elliptic.DualEllipticModel(gb)
problem.solve()
problem.split()
problem.pressure('pressure')
for g, d in gb:
pressure = d['pressure']
p_analytic = g.cell_centers[1]
p_diff = pressure - p_analytic
assert np.max(np.abs(p_diff)) < 0.0004
def test_elliptic_dirich_neumann_source_sink_cart(self):
gb = setup_3d(np.array([4, 4, 4]), simplex_grid=False)
problem = elliptic.DualEllipticModel(gb)
problem.solve()
problem.split()
problem.pressure('pressure')
for g, d in gb:
if g.dim == 3:
p_ref = elliptic_dirich_neumann_source_sink_cart_ref_3d()
assert np.allclose(d['pressure'], p_ref)
if g.dim == 0:
p_ref = [-260.13394502]
assert np.allclose(d['pressure'], p_ref)
return gb
def test_elliptic_uniform_flow_simplex(self):
"""
Unstructured simplex grid. Note that the solution depends
on the grid quality. Also sensitive to the way in which
the tpfa half transmissibilities are computed.
"""
gb = setup_2d_1d(np.array([10, 10]), simplex_grid=True)
problem = elliptic.DualEllipticModel(gb)
problem.solve()
problem.split()
problem.pressure('pressure')
for g, d in gb:
pressure = d['pressure']
p_analytic = g.cell_centers[1]
p_diff = pressure - p_analytic
assert np.max(np.abs(p_diff)) < 0.0004
def main(coarse):
tol = 1e-6
problem_kwargs = {}
problem_kwargs["file_name"] = "solution"
if coarse:
problem_kwargs["folder_name"] = "vem_coarse"
else:
problem_kwargs["folder_name"] = "vem"
h = 0.08
grid_kwargs = {}
grid_kwargs["mesh_size"] = {
"mode": "constant",
"value": h,
"bound_value": h,
"tol": tol,
}
file_dfm = "dfm.csv"
gb, domain = importer.dfm_3d_from_csv(file_dfm, tol, **grid_kwargs)
gb.compute_geometry()
if coarse:
coarsening.coarsen(gb, "by_volume")
problem = elliptic.DualEllipticModel(gb, **problem_kwargs)
# Assign parameters
add_data(gb, domain, tol)
problem.solve()
problem.split()
problem.pressure("pressure")
problem.discharge("discharge")
problem.project_discharge("P0u")
problem.save(["pressure", "P0u", "frac_num"])
problem_kwargs["file_name"] = "transport"
for g, d in gb:
d["problem"] = AdvectiveModelData(g, d, domain, tol)
advective = AdvectiveModel(gb, **problem_kwargs)
advective.solve()
advective.save()
def main():
gb = create_porepy_grid.create(mesh_size=0.01)
# Assign parameters
domain = gb.bounding_box(as_dict=True)
kf = 1e-4
add_data(gb, domain, kf)
# Choose and define the solvers and coupler
problem = elliptic.DualEllipticModel(gb)
problem.solve()
problem.split()
problem.pressure('pressure')
problem.project_discharge('P0u')
problem.save(["pressure", "P0u"])
def test_mono_equals_multi(self):
"""
test that the mono_dimensional elliptic solver gives the same answer as
the grid bucket elliptic
"""
g = CartGrid([10, 10])
g.compute_geometry()
gb = meshing.cart_grid([], [10, 10])
param_g = Parameters(g)
def bc_val(g):
left = g.face_centers[0] < 1e-6
right = g.face_centers[0] > 10 - 1e-6
bc_val = np.zeros(g.num_faces)
bc_val[left] = -1
bc_val[right] = 1
return bc_val
def bc_labels(g):
bound_faces = g.get_boundary_faces()
bound_face_centers = g.face_centers[:, bound_faces]
left = bound_face_centers[0] < 1e-6
right = bound_face_centers[0] > 10 - 1e-6
labels = np.array(['neu'] * bound_faces.size)
labels[np.logical_or(right, left)] = 'dir'
bc_labels = bc.BoundaryCondition(g, bound_faces, labels)
return bc_labels
param_g.set_bc_val('flow', bc_val(g))
param_g.set_bc('flow', bc_labels(g))
gb.add_node_props(['param'])
for sub_g, d in gb:
d['param'] = Parameters(sub_g)
d['param'].set_bc_val('flow', bc_val(sub_g))
d['param'].set_bc('flow', bc_labels(sub_g))
problem_mono = elliptic.DualEllipticModel(g, {'param': param_g})
problem_mult = elliptic.DualEllipticModel(gb)
up_mono = problem_mono.solve()
up_mult = problem_mult.solve()
assert np.allclose(up_mono, up_mult)
g_gb = next(problem_mult.grid().nodes())
problem_mono.pressure('pressure')
problem_mult.split()
problem_mult.pressure('pressure')
assert np.allclose(problem_mono.data()['pressure'],
problem_mult.grid().node_prop(g_gb, 'pressure'))
problem_mono.discharge('u')
problem_mult.discharge('u')
assert np.allclose(problem_mono.data()['u'],
problem_mult.grid().node_prop(g_gb, 'u'))
problem_mono.project_discharge('P0u')
problem_mult.project_discharge('P0u')
problem_mono.save(['pressure', 'P0u'])
problem_mult.save(['pressure', 'P0u'])
assert np.allclose(problem_mono.data()['P0u'],
problem_mult.grid().node_prop(g_gb, 'P0u'))
d["frac_num"] = g.frac_num * np.ones(g.num_cells)
else:
d["frac_num"] = -1 * np.ones(g.num_cells)
# Assign coupling permeability, the aperture is read from the lower dimensional grid
gb.add_edge_prop("kn")
for e, d in gb.edges_props():
mg = d["mortar_grid"]
g_l = gb.sorted_nodes_of_edge(e)[0]
aperture = gb.node_prop(g_l, "param").get_aperture()
d["kn"] = data_problem["kf"] / (mg.low_to_mortar_int * aperture)
# Create the problem and solve it. Export the pressure and projected velocity for visualization.
if VEM:
problem = elliptic.DualEllipticModel(gb)
up = problem.solve()
problem.split(gb)
problem.pressure()
problem.save("pressure")
else:
problem = elliptic.EllipticModel(gb)
problem.solve()
problem.split()
problem.pressure("pressure")
problem.save(["pressure", "frac_num", "low_zones"])
# problem.discharge('discharge')
# problem.project_discharge('P0u')
# problem.save(['pressure', 'P0u', 'frac_num', 'low_zones'])
def test_mono_equals_multi(self):
"""
test that the mono_dimensional elliptic solver gives the same answer as
the grid bucket elliptic
"""
g = CartGrid([10, 10])
g.compute_geometry()
gb = meshing.cart_grid([], [10, 10])
param_g = Parameters(g)
def bc_val(g):
left = g.face_centers[0] < 1e-6
right = g.face_centers[0] > 10 - 1e-6
bc_val = np.zeros(g.num_faces)
bc_val[left] = -1
bc_val[right] = 1
return bc_val
def bc_labels(g):
bound_faces = g.tags["domain_boundary_faces"].nonzero()[0]
bound_face_centers = g.face_centers[:, bound_faces]
left = bound_face_centers[0] < 1e-6
right = bound_face_centers[0] > 10 - 1e-6
labels = np.array(["neu"] * bound_faces.size)
labels[np.logical_or(right, left)] = "dir"
bc_labels = bc.BoundaryCondition(g, bound_faces, labels)
return bc_labels
param_g.set_bc_val("flow", bc_val(g))
param_g.set_bc("flow", bc_labels(g))
gb.add_node_props(["param"])
for sub_g, d in gb:
d["param"] = Parameters(sub_g)
d["param"].set_bc_val("flow", bc_val(sub_g))
d["param"].set_bc("flow", bc_labels(sub_g))
problem_mono = elliptic.DualEllipticModel(g, {"param": param_g})
problem_mult = elliptic.DualEllipticModel(gb)
up_mono = problem_mono.solve()
up_mult = problem_mult.solve()
self.assertTrue(np.allclose(up_mono, up_mult))
g_gb = next(problem_mult.grid().nodes())
problem_mono.pressure("pressure")
problem_mult.split()
problem_mult.pressure("pressure")
self.assertTrue(
np.allclose(problem_mono.data()["pressure"], g_gb[1]["pressure"]))
problem_mono.discharge("u")
problem_mult.discharge("u")
self.assertTrue(np.allclose(problem_mono.data()["u"], g_gb[1]["u"]))
problem_mono.project_discharge("P0u")
problem_mult.project_discharge("P0u")
problem_mono.save(["pressure", "P0u"])
problem_mult.save(["pressure", "P0u"])
self.assertTrue(np.allclose(problem_mono.data()["P0u"],
g_gb[1]["P0u"]))
