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 __init__(self,
gb,
physics='transport',
time_step=1.0,
end_time=1.0,
**kwargs):
self._gb = gb
self.is_GridBucket = isinstance(self._gb, GridBucket)
self.physics = physics
self._data = kwargs.get('data', dict())
self._time_step = time_step
self._end_time = end_time
self._set_data()
self._solver = self.solver()
self._solver.parameters['store_results'] = False
file_name = kwargs.get('file_name', str(physics))
folder_name = kwargs.get('folder_name', 'results')
logger.info('Create exporter')
tic = time.time()
self.exporter = Exporter(self._gb, file_name, folder_name)
logger.info('Done. Elapsed time: ' + str(time.time() - tic))
self.x_name = 'solution'
self._time_disc = self.time_disc()
def __init__(self, gb, data, physics='mechanics', **kwargs):
self.physics = physics
self._gb = gb
if not isinstance(self._gb, Grid):
raise ValueError('StaticModel only defined for Grid class')
self._data = data
self.lhs = []
self.rhs = []
self.x = []
file_name = kwargs.get('file_name', physics)
folder_name = kwargs.get('folder_name', 'results')
tic = time.time()
logger.info('Create exporter')
self.exporter = Exporter(self._gb, file_name, folder_name)
logger.info('Elapsed time: ' + str(time.time() - tic))
self._stress_disc = self.stress_disc()
self.displacement_name = 'displacement'
self.frac_displacement_name = 'frac_displacement'
self.is_factorized = False
def test_upwind_example1(self, if_export=False):
#######################
# Simple 2d upwind problem with implicit Euler scheme in time
#######################
T = 1
Nx, Ny = 10, 1
g = structured.CartGrid([Nx, Ny], [1, 1])
g.compute_geometry()
advect = upwind.Upwind("transport")
param = Parameters(g)
dis = advect.discharge(g, [1, 0, 0])
b_faces = g.get_all_boundary_faces()
bc = BoundaryCondition(g, b_faces, ["dir"] * b_faces.size)
bc_val = np.hstack(([1], np.zeros(g.num_faces - 1)))
param.set_bc("transport", bc)
param.set_bc_val("transport", bc_val)
data = {"param": param, "discharge": dis}
data["deltaT"] = advect.cfl(g, data)
U, rhs = advect.matrix_rhs(g, data)
M, _ = mass_matrix.MassMatrix().matrix_rhs(g, data)
conc = np.zeros(g.num_cells)
# Perform an LU factorization to speedup the solver
IE_solver = sps.linalg.factorized((M + U).tocsc())
# Loop over the time
Nt = int(T / data["deltaT"])
time = np.empty(Nt)
folder = "example1"
save = Exporter(g, "conc_IE", folder)
for i in np.arange(Nt):
# Update the solution
# Backward and forward substitution to solve the system
conc = IE_solver(M.dot(conc) + rhs)
time[i] = data["deltaT"] * i
if if_export:
save.write_vtk({"conc": conc}, time_step=i)
if if_export:
save.write_pvd(time)
known = np.array([
0.99969927,
0.99769441,
0.99067741,
0.97352474,
0.94064879,
0.88804726,
0.81498958,
0.72453722,
0.62277832,
0.51725056,
])
assert np.allclose(conc, known)
def __init__(self, gb, data, physics="mechanics", **kwargs):
self.physics = physics
self._gb = gb
if not isinstance(self._gb, Grid):
raise ValueError("StaticModel only defined for Grid class")
self._data = data
self.lhs = []
self.rhs = []
self.x = []
file_name = kwargs.get("file_name", physics)
folder_name = kwargs.get("folder_name", "results")
tic = time.time()
logger.info("Create exporter")
self.exporter = Exporter(self._gb, file_name, folder_name)
logger.info("Elapsed time: " + str(time.time() - tic))
self._stress_disc = self.stress_disc()
self.displacement_name = "displacement"
self.frac_displacement_name = "frac_displacement"
self.is_factorized = False
def main(id_problem, is_coarse=False, tol=1e-5, if_export=False):
gb = example_1_create_grid.create(0.5 / float(id_problem), tol)
if is_coarse:
co.coarsen(gb, 'by_tpfa')
folder_export = "example_1_vem_coarse/"
else:
folder_export = "example_1_vem/"
file_name_error = folder_export + "vem_error.txt"
if if_export:
save = Exporter(gb, "vem", folder_export)
example_1_data.assign_frac_id(gb)
# Assign parameters
example_1_data.add_data(gb, tol)
# Choose and define the solvers and coupler
solver_flow = vem_dual.DualVEMDFN(gb.dim_max(), 'flow')
A_flow, b_flow = solver_flow.matrix_rhs(gb)
solver_source = vem_source.DualSourceDFN(gb.dim_max(), 'flow')
A_source, b_source = solver_source.matrix_rhs(gb)
up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source)
solver_flow.split(gb, "up", up)
gb.add_node_props(["discharge", 'pressure', "P0u", "err"])
solver_flow.extract_u(gb, "up", "discharge")
solver_flow.extract_p(gb, "up", 'pressure')
solver_flow.project_u(gb, "discharge", "P0u")
only_max_dim = lambda g: g.dim == gb.dim_max()
diam = gb.diameter(only_max_dim)
error_pressure = example_1_data.error_pressure(gb, "p")
error_discharge = example_1_data.error_discharge(gb, "P0u")
print("h=", diam, "- err(p)=", error_pressure, "- err(P0u)=",
error_discharge)
error_pressure = example_1_data.error_pressure(gb, 'pressure')
with open(file_name_error, 'a') as f:
info = str(gb.num_cells(only_max_dim)) + " " +\
str(gb.num_cells(only_max_dim)) + " " +\
str(error_pressure) + " " +\
str(error_discharge) + " " +\
str(gb.num_faces(only_max_dim)) + "\n"
f.write(info)
if if_export:
save.write_vtk(['pressure', "err", "P0u"])
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_vem_coarse_" + str(mesh_size) + "/" +
str(id_problem) + "/")
file_export = "vem"
gb = example_2_3_create_grid.create(id_problem,
is_coarse=True,
mesh_size=mesh_size,
tol=tol)
internal_flag = FaceTag.FRACTURE
[g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb]
# Assign parameters
example_2_3_data.add_data(gb, tol)
# Choose and define the solvers and coupler
solver_flow = vem_dual.DualVEMDFN(gb.dim_max(), "flow")
A_flow, b_flow = solver_flow.matrix_rhs(gb)
solver_source = vem_source.IntegralDFN(gb.dim_max(), "flow")
A_source, b_source = solver_source.matrix_rhs(gb)
up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source)
solver_flow.split(gb, "up", up)
gb.add_node_props(["discharge", "p", "P0u"])
solver_flow.extract_u(gb, "up", "discharge")
solver_flow.extract_p(gb, "up", "p")
solver_flow.project_u(gb, "discharge", "P0u")
if if_export:
save = Exporter(gb, file_export, folder_export)
save.write_vtk(["p", "P0u"])
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
diam, flow_rate = example_2_3_data.compute_flow_rate_vem(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'))
co.coarsen(gb, 'by_volume')
folder_export = './example_4_vem_coarse_' + grid_name + '_' + direction + '/'
domain = {
'xmin': -800,
'xmax': 600,
'ymin': 100,
'ymax': 1500,
'zmin': -100,
'zmax': 1000
}
internal_flag = FaceTag.FRACTURE
[g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb]
example_4_data.add_data(gb, domain, direction, tol)
# Choose and define the solvers and coupler
solver_flow = vem_dual.DualVEMDFN(gb.dim_max(), 'flow')
A_flow, b_flow = solver_flow.matrix_rhs(gb)
solver_source = vem_source.IntegralDFN(gb.dim_max(), 'flow')
A_source, b_source = solver_source.matrix_rhs(gb)
up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source)
solver_flow.split(gb, "up", up)
gb.add_node_props(["discharge", "p", "P0u"])
solver_flow.extract_u(gb, "up", "discharge")
solver_flow.extract_p(gb, "up", "p")
solver_flow.project_u(gb, "discharge", "P0u")
save = Exporter(gb, file_export, folder_export)
save.write_vtk(["p", "P0u"])
# compute the flow rate
diam, flow_rate = example_4_data.compute_flow_rate_vem(
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 test_upwind_example0(self, if_export=False):
#######################
# Simple 2d upwind problem with explicit Euler scheme in time
#######################
T = 1
Nx, Ny = 4, 1
g = structured.CartGrid([Nx, Ny], [1, 1])
g.compute_geometry()
advect = upwind.Upwind("transport")
param = Parameters(g)
dis = advect.discharge(g, [1, 0, 0])
b_faces = g.get_all_boundary_faces()
bc = BoundaryCondition(g, b_faces, ['dir'] * b_faces.size)
bc_val = np.hstack(([1], np.zeros(g.num_faces - 1)))
param.set_bc("transport", bc)
param.set_bc_val("transport", bc_val)
data = {'param': param, 'discharge': dis}
data['deltaT'] = advect.cfl(g, data)
U, rhs = advect.matrix_rhs(g, data)
OF = advect.outflow(g, data)
M, _ = mass_matrix.MassMatrix().matrix_rhs(g, data)
conc = np.zeros(g.num_cells)
M_minus_U = M - U
invM, _ = mass_matrix.InvMassMatrix().matrix_rhs(g, data)
# Loop over the time
Nt = int(T / data['deltaT'])
time = np.empty(Nt)
folder = 'example0'
production = np.zeros(Nt)
save = Exporter(g, "conc_EE", folder)
for i in np.arange(Nt):
# Update the solution
production[i] = np.sum(OF.dot(conc))
conc = invM.dot((M_minus_U).dot(conc) + rhs)
time[i] = data['deltaT'] * i
if if_export:
save.write_vtk({"conc": conc}, time_step=i)
if if_export:
save.write_pvd(time)
known = 1.09375
assert np.sum(production) == known
def solve_tpfa(gb, folder):
# Choose and define the solvers and coupler
solver_flow = tpfa.TpfaMixedDim("flow")
A_flow, b_flow = solver_flow.matrix_rhs(gb)
solver_source = source.IntegralMixedDim("flow")
A_source, b_source = solver_source.matrix_rhs(gb)
p = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source)
solver_flow.split(gb, "pressure", p)
save = Exporter(gb, "sol", folder=folder)
save.write_vtk(["pressure"])
def solve_p1(gb, folder, return_only_matrix=False):
# Choose and define the solvers and coupler
solver_flow = pp.P1MixedDim("flow")
A_flow, b_flow = solver_flow.matrix_rhs(gb)
A = A_flow
if return_only_matrix:
return A, mortar_dof_size(A, gb, solver_flow)
p = sps.linalg.spsolve(A, b_flow)
solver_flow.split(gb, "pressure", p)
save = Exporter(gb, "sol", folder=folder, simplicial=True)
save.write_vtk("pressure", point_data=True)
def main(id_problem, tol=1e-5, N_pts=1000, if_export=False):
mesh_size = 0.15
folder_export = 'example_2_1_vem_coarse_' + str(mesh_size) + '/' + str(
id_problem) + "/"
file_export = 'vem'
gb = example_2_1_create_grid.create(id_problem,
is_coarse=True,
mesh_size=mesh_size,
tol=tol)
internal_flag = FaceTag.FRACTURE
[g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb]
# Assign parameters
example_2_1_data.add_data(gb, tol)
# Choose and define the solvers and coupler
solver_flow = vem_dual.DualVEMDFN(gb.dim_max(), 'flow')
A_flow, b_flow = solver_flow.matrix_rhs(gb)
solver_source = vem_source.DualSourceDFN(gb.dim_max(), 'flow')
A_source, b_source = solver_source.matrix_rhs(gb)
up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source)
solver_flow.split(gb, "up", up)
gb.add_node_props(["discharge", 'pressure', "P0u"])
solver_flow.extract_u(gb, "up", "discharge")
solver_flow.extract_p(gb, "up", 'pressure')
solver_flow.project_u(gb, "discharge", "P0u")
if if_export:
save = Exporter(gb, file_export, folder_export)
save.write_vtk(['pressure', "P0u"])
b_box = gb.bounding_box()
z_range = np.linspace(b_box[0][2] + tol, b_box[1][2] - tol, 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
diam, flow_rate = example_2_1_data.compute_flow_rate_vem(gb, tol)
np.savetxt(folder_export + "flow_rate.txt", (diam, flow_rate))
def solve_rt0(gb, folder):
# Choose and define the solvers and coupler
solver_flow = rt0.RT0MixedDim("flow")
A_flow, b_flow = solver_flow.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)
solver_flow.split(gb, "up", up)
solver_flow.extract_p(gb, "up", "pressure")
save = Exporter(gb, "sol", folder=folder)
save.write_vtk(["pressure"])
def solve_rt0(gb, folder, return_only_matrix=False):
# Choose and define the solvers and coupler
solver_flow = pp.RT0MixedDim("flow")
A_flow, b_flow = solver_flow.matrix_rhs(gb)
A = A_flow
if return_only_matrix:
return A, mortar_dof_size(A, gb, solver_flow)
up = sps.linalg.spsolve(A, b_flow)
solver_flow.split(gb, "up", up)
solver_flow.extract_p(gb, "up", "pressure")
save = Exporter(gb, "sol", folder=folder)
save.write_vtk(["pressure"])
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, is_coarse=False, tol=1e-5, N_pts=1000, if_export=False):
folder_export = "example_2_2_vem/" + str(id_problem) + "/"
file_export = "vem"
gb = example_2_2_create_grid.create(id_problem,
is_coarse=is_coarse,
tol=tol)
# Assign parameters
example_2_2_data.add_data(gb, tol)
# Choose and define the solvers and coupler
solver_flow = vem_dual.DualVEMDFN(gb.dim_max(), "flow")
A_flow, b_flow = solver_flow.matrix_rhs(gb)
solver_source = vem_source.DualSourceDFN(gb.dim_max(), "flow")
A_source, b_source = solver_source.matrix_rhs(gb)
up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source)
solver_flow.split(gb, "up", up)
gb.add_node_props(["discharge", "pressure", "P0u"])
solver_flow.extract_u(gb, "up", "discharge")
solver_flow.extract_p(gb, "up", "pressure")
solver_flow.project_u(gb, "discharge", "P0u")
if if_export:
save = Exporter(gb, file_export, folder_export)
save.write_vtk(["pressure", "P0u"])
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
diam, flow_rate = example_2_2_data.compute_flow_rate_vem(gb, tol)
np.savetxt(folder_export + "flow_rate.txt", (diam, flow_rate))
def main(kf, description, is_coarse=False, if_export=False):
mesh_kwargs = {}
mesh_kwargs['mesh_size'] = {
'mode': 'constant',
'value': 0.045,
'bound_value': 0.045
}
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()
if is_coarse:
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]
# Assign parameters
add_data(gb, domain, kf)
# Choose and define the solvers and coupler
solver_flow = vem_dual.DualVEMMixedDim('flow')
A_flow, b_flow = solver_flow.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)
solver_flow.split(gb, "up", up)
gb.add_node_props(["discharge", 'pressure', "P0u"])
solver_flow.extract_u(gb, "up", "discharge")
solver_flow.extract_p(gb, "up", 'pressure')
solver_flow.project_u(gb, "discharge", "P0u")
if if_export:
save = Exporter(gb, "vem", folder="vem_" + description)
save.write_vtk(['pressure', "P0u"])
def __init__(self, gb, data=None, physics='flow', **kwargs):
self.physics = physics
self._gb = gb
self.is_GridBucket = isinstance(self._gb, GridBucket)
self._data = data
self.lhs = []
self.rhs = []
self.x = []
file_name = kwargs.get('file_name', physics)
folder_name = kwargs.get('folder_name', 'results')
mesh_kw = kwargs.get('mesh_kw', {})
tic = time.time()
logger.info('Create exporter')
self.exporter = Exporter(self._gb, file_name, folder_name, **mesh_kw)
logger.info('Elapsed time: ' + str(time.time() - tic))
self._flux_disc = self.flux_disc()
self._source_disc = self.source_disc()
def __init__(self, gb, data=None, physics="flow", **kwargs):
self.physics = physics
self._gb = gb
self.is_GridBucket = isinstance(self._gb, GridBucket)
self._data = data
self.lhs = []
self.rhs = []
self.x = []
file_name = kwargs.get("file_name", physics)
folder_name = kwargs.get("folder_name", "results")
mesh_kw = kwargs.get("mesh_kw", {})
tic = time.time()
logger.info("Create exporter")
self.exporter = Exporter(self._gb, file_name, folder_name, **mesh_kw)
logger.info("Elapsed time: " + str(time.time() - tic))
self._flux_disc = self.flux_disc()
self._source_disc = self.source_disc()
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 main(id_problem, tol=1e-5, if_export=False):
folder_export = "example_1_tpfa/"
file_name_error = folder_export + "tpfa_error.txt"
gb = example_1_create_grid.create(0.5 / float(id_problem), tol)
if if_export:
save = Exporter(gb, "tpfa", folder_export)
example_1_data.assign_frac_id(gb)
# Assign parameters
example_1_data.add_data(gb, tol)
# Choose and define the solvers and coupler
solver_flow = tpfa.TpfaDFN(gb.dim_max(), "flow")
A_flow, b_flow = solver_flow.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_flow + A_source, b_flow + b_source)
solver_flow.split(gb, "pressure", p)
def only_max_dim(g):
return g.dim == gb.dim_max()
diam = gb.diameter(only_max_dim)
error_pressure = example_1_data.error_pressure(gb, "pressure")
print("h=", diam, "- err(p)=", error_pressure)
with open(file_name_error, "a") as f:
info = (str(gb.num_cells(only_max_dim)) + " " +
str(gb.num_cells(only_max_dim)) + " " + str(error_pressure) +
"\n")
f.write(info)
if if_export:
save.write_vtk(["pressure", "err"])
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 __init__(self, gb, data, physics="slip", **kwargs):
self.physics = physics
if isinstance(gb, GridBucket):
raise ValueError("FrictionSlip excpected a Grid, not a GridBucket")
self._gb = gb
self._data = data
file_name = kwargs.get("file_name", physics)
folder_name = kwargs.get("folder_name", "results")
tic = time.time()
logger.info("Create exporter")
self.exporter = Exporter(self._gb, file_name, folder_name)
logger.info("Elapsed time: " + str(time.time() - tic))
self.x = np.zeros((3, gb.num_faces))
self.d_n = np.zeros(gb.num_faces)
self.is_slipping = np.zeros(gb.num_faces, dtype=np.bool)
self.slip_name = "slip_distance"
self.aperture_name = "aperture_change"
def __init__(self, gb, data, physics='slip', **kwargs):
self.physics = physics
if isinstance(gb, GridBucket):
raise ValueError('FrictionSlip excpected a Grid, not a GridBucket')
self._gb = gb
self._data = data
file_name = kwargs.get('file_name', physics)
folder_name = kwargs.get('folder_name', 'results')
tic = time.time()
logger.info('Create exporter')
self.exporter = Exporter(self._gb, file_name, folder_name)
logger.info('Elapsed time: ' + str(time.time() - tic))
self.x = np.zeros((3, gb.num_faces))
self.d_n = np.zeros(gb.num_faces)
self.is_slipping = np.zeros(gb.num_faces, dtype=np.bool)
self.slip_name = 'slip_distance'
self.aperture_name = 'aperture_change'
def test_upwind_example2(self, if_export=False):
#######################
# Simple 2d upwind problem with explicit Euler scheme in time coupled with
# a Darcy problem
#######################
T = 2
Nx, Ny = 10, 10
folder = 'example2'
def funp_ex(pt):
return -np.sin(pt[0]) * np.sin(pt[1]) - pt[0]
g = structured.CartGrid([Nx, Ny], [1, 1])
g.compute_geometry()
param = Parameters(g)
# Permeability
perm = tensor.SecondOrderTensor(g.dim, kxx=np.ones(g.num_cells))
param.set_tensor("flow", perm)
# Source term
param.set_source("flow", np.zeros(g.num_cells))
# Boundaries
b_faces = g.get_all_boundary_faces()
bc = BoundaryCondition(g, b_faces, ['dir'] * b_faces.size)
bc_val = np.zeros(g.num_faces)
bc_val[b_faces] = funp_ex(g.face_centers[:, b_faces])
param.set_bc("flow", bc)
param.set_bc_val("flow", bc_val)
# Darcy solver
data = {'param': param}
solver = vem_dual.DualVEM("flow")
D_flow, b_flow = solver.matrix_rhs(g, data)
solver_source = vem_source.DualSource('flow')
D_source, b_source = solver_source.matrix_rhs(g, data)
up = sps.linalg.spsolve(D_flow + D_source, b_flow + b_source)
p, u = solver.extract_p(g, up), solver.extract_u(g, up)
P0u = solver.project_u(g, u, data)
save = Exporter(g, "darcy", folder)
if if_export:
save.write_vtk({'pressure': p, "P0u": P0u})
# Discharge
dis = u
# Boundaries
bc = BoundaryCondition(g, b_faces, ['dir'] * b_faces.size)
bc_val = np.hstack(([1], np.zeros(g.num_faces - 1)))
param.set_bc("transport", bc)
param.set_bc_val("transport", bc_val)
data = {'param': param, 'discharge': dis}
# Advect solver
advect = upwind.Upwind("transport")
U, rhs = advect.matrix_rhs(g, data)
data['deltaT'] = advect.cfl(g, data)
M, _ = mass_matrix.MassMatrix().matrix_rhs(g, data)
conc = np.zeros(g.num_cells)
M_minus_U = M - U
invM, _ = mass_matrix.InvMassMatrix().matrix_rhs(g, data)
# Loop over the time
Nt = int(T / data['deltaT'])
time = np.empty(Nt)
save.change_name("conc_darcy")
for i in np.arange(Nt):
# Update the solution
conc = invM.dot((M_minus_U).dot(conc) + rhs)
time[i] = data['deltaT'] * i
if if_export:
save.write_vtk({"conc": conc}, time_step=i)
if if_export:
save.write_pvd(time)
known = \
np.array([9.63168200e-01, 8.64054875e-01, 7.25390695e-01,
5.72228235e-01, 4.25640080e-01, 2.99387331e-01,
1.99574336e-01, 1.26276876e-01, 7.59011550e-02,
4.33431230e-02, 3.30416807e-02, 1.13058617e-01,
2.05372538e-01, 2.78382057e-01, 3.14035373e-01,
3.09920132e-01, 2.75024694e-01, 2.23163145e-01,
1.67386939e-01, 1.16897527e-01, 1.06111312e-03,
1.11951850e-02, 3.87907727e-02, 8.38516119e-02,
1.36617802e-01, 1.82773271e-01, 2.10446545e-01,
2.14651936e-01, 1.97681518e-01, 1.66549151e-01,
3.20751341e-05, 9.85780113e-04, 6.07062715e-03,
1.99393042e-02, 4.53237556e-02, 8.00799828e-02,
1.17199623e-01, 1.47761481e-01, 1.64729339e-01,
1.65390555e-01, 9.18585872e-07, 8.08267622e-05,
8.47227168e-04, 4.08879583e-03, 1.26336029e-02,
2.88705048e-02, 5.27841497e-02, 8.10459333e-02,
1.07956484e-01, 1.27665318e-01, 2.51295298e-08,
6.29844122e-06, 1.09361990e-04, 7.56743783e-04,
3.11384414e-03, 9.04446601e-03, 2.03443897e-02,
3.75208816e-02, 5.89595194e-02, 8.11457277e-02,
6.63498510e-10, 4.73075468e-07, 1.33728945e-05,
1.30243418e-04, 7.01905707e-04, 2.55272292e-03,
6.96686157e-03, 1.52290448e-02, 2.78607282e-02,
4.40402650e-02, 1.71197497e-11, 3.47118057e-08,
1.57974045e-06, 2.13489614e-05, 1.48634295e-04,
6.68104990e-04, 2.18444135e-03, 5.58646819e-03,
1.17334966e-02, 2.09744728e-02, 4.37822313e-13,
2.52373622e-09, 1.83589660e-07, 3.40553325e-06,
3.02948532e-05, 1.66504215e-04, 6.45119867e-04,
1.90731440e-03, 4.53436628e-03, 8.99977737e-03,
1.12627412e-14, 1.84486857e-10, 2.13562387e-08,
5.39492977e-07, 6.08223906e-06, 4.05535296e-05,
1.84731221e-04, 6.25871542e-04, 1.66459389e-03,
3.59980231e-03])
assert np.allclose(conc, known)
gb.add_node_props(["p", "P0u", "discharge"])
solver_flow.extract_u(gb, "up", "discharge")
solver_flow.extract_p(gb, "up", "p")
solver_flow.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)
save = Exporter(gb, "darcy", export_folder, binary=False)
save.write_vtk(["p", "P0u"])
#################################################################
physics = "transport"
advection = upwind.UpwindMixedDim(physics)
mass = mass_matrix.MassMatrixMixedDim(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)
gb.add_node_props(["p", "P0u", "discharge"])
solver_flow.extract_u(gb, "up", "discharge")
solver_flow.extract_p(gb, "up", "p")
solver_flow.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)
save = Exporter(gb, 'darcy', export_folder, binary=False)
save.write_vtk(["p", "P0u"])
#################################################################
physics = 'transport'
advection = upwind.UpwindMixedDim(physics)
mass = mass_matrix.MassMatrixMixedDim(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)