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 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(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 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 create(id_problem, is_coarse=False, mesh_size=0.05, tol=1e-5):
folder = '/home/elle/Dropbox/Work/tipetut/test2/X_geometry/'
file_name = folder + 'DFN_' + str(id_problem) + '.fab'
file_intersections = folder + 'TRACES_' + str(id_problem) + '.dat'
mesh_kwargs = {}
mesh_kwargs['mesh_size'] = {'mode': 'constant',
'value': mesh_size, # 0.05 0.15 0.425
'bound_value': 1}
gb = importer.read_dfn(file_name, file_intersections, tol=tol, **mesh_kwargs)
gb.remove_nodes(lambda g: g.dim == 0)
gb.compute_geometry()
if is_coarse:
co.coarsen(gb, 'by_volume')
gb.assign_node_ordering()
return gb
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 create(id_problem, is_coarse=False, mesh_size=0.09, tol=1e-5):
folder = "/home/elle/Dropbox/Work/tipetut/test2/complex_geometry/"
file_name = folder + "DFN_" + str(id_problem) + ".fab"
file_intersections = folder + "TRACES_" + str(id_problem) + ".dat"
mesh_kwargs = {
"mesh_size_frac": mesh_size,
"mesh_size_min": mesh_size / 20
}
gb = importer.dfn_3d_from_fab(file_name,
file_intersections,
tol=tol,
**mesh_kwargs)
gb.remove_nodes(lambda g: g.dim == 0)
gb.compute_geometry()
if is_coarse:
co.coarsen(gb, "by_volume")
gb.assign_node_ordering()
return gb
def create(id_problem, is_coarse=False, mesh_size=0.05, tol=1e-5):
folder = "/home/elle/Dropbox/Work/tipetut/test2/simple_geometry/"
file_name = folder + "DFN_" + str(id_problem) + ".fab"
file_intersections = folder + "TRACES_" + str(id_problem) + ".dat"
mesh_kwargs = {}
mesh_kwargs["mesh_size"] = {
"mode": "constant",
"value": mesh_size, # 0.05 0.15 0.425
"bound_value": 1,
}
gb = importer.dfn_3d_from_fab(file_name, file_intersections, tol=tol, **mesh_kwargs)
gb.remove_nodes(lambda g: g.dim == 0)
gb.compute_geometry()
if is_coarse:
co.coarsen(gb, "by_volume")
gb.assign_node_ordering()
return gb
tol = 1e-4
export_folder = "example_5_2_2"
T = 40 * np.pi * 1e7
Nt = 20 # 10 20 40 80 160 320 640 1280 2560 5120 - 100000
deltaT = T / Nt
export_every = 1
if_coarse = True
mesh_kwargs = {"mesh_size_frac": 500, "mesh_size_min": 20}
domain = {"xmin": 0, "xmax": 700, "ymin": 0, "ymax": 600}
gb = importer.from_csv("network.csv", mesh_kwargs, domain)
gb.compute_geometry()
if if_coarse:
co.coarsen(gb, "by_volume")
gb.assign_node_ordering()
# 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")
break
is_found[mask] = check
values[mask[check]] = d[name][c]
return values
##------------------------------------------------------------------------------#
tol = 1e-4
mesh_kwargs = {'mesh_size_frac': 500, 'mesh_size_min': 20}
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()
# 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')
