def main(kf, description, mesh_size): mesh_kwargs = {} mesh_kwargs["mesh_size"] = { "mode": "constant", "value": mesh_size, "bound_value": mesh_size, } domain = {"xmin": 0, "xmax": 1, "ymin": 0, "ymax": 1} if_coarse = True folder = "example_5_1_1_" + description file_name = "network_geiger.csv" write_network(file_name) gb = importer.from_csv(file_name, mesh_kwargs, domain) gb.compute_geometry() g_fine = gb.get_grids(lambda g: g.dim == gb.dim_max())[0].copy() if if_coarse: partition = co.create_aggregations(gb) partition = co.reorder_partition(partition) co.generate_coarse_grid(gb, partition) gb.assign_node_ordering() # Assign parameters add_data(gb, domain, kf) # 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") solver.project_u(gb, "discharge", "P0u") exporter.export_vtk(gb, "vem", ["pressure", "P0u"], folder=folder, binary=False) if if_coarse: partition = partition[gb.grids_of_dimension(gb.dim_max())[0]] p = np.array([d["pressure"] for g, d in gb if g.dim == gb.dim_max()]).ravel() data = {"partition": partition, "pressure": p[partition]} exporter.export_vtk(g_fine, "sub_grid", data, binary=False, folder=folder) print("diam", gb.diameter(lambda g: g.dim == gb.dim_max())) print("num_cells 2d", gb.num_cells(lambda g: g.dim == 2)) print("num_cells 1d", gb.num_cells(lambda g: g.dim == 1))
#------------------------------------------------------------------------------# Nx = Ny = 20 #g = structured.CartGrid([Nx, Ny], [1, 1]) g = simplex.StructuredTriangleGrid([Nx, Ny], [1, 1]) R = cg.rot(np.pi / 4., [1, 0, 0]) g.nodes = np.dot(R, g.nodes) g.compute_geometry(is_embedded=True) #co.coarsen(g, 'by_volume') # Assign parameters data = add_data(g) # Choose and define the solvers solver = dual.DualVEM('flow') A, b = solver.matrix_rhs(g, data) up = sps.linalg.spsolve(A, b) u = solver.extract_u(g, up) p = solver.extract_p(g, up) P0u = solver.project_u(g, u, data) diam = np.amax(g.cell_diameters()) print("h=", diam, "- err(p)=", error_p(g, p)) exporter.export_vtk(g, 'vem', {"p": p, "P0u": P0u}, folder='vem') #------------------------------------------------------------------------------#
# 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') solver.project_u(gb, "discharge", "P0u") exporter.export_vtk(gb, 'vem', ['pressure', "P0u"], folder='example_5_1_2') # This part is very slow and not optimized, it's just to obtain the plots once. b_box = gb.bounding_box() N_pts = 1000 y_range = np.linspace(b_box[0][1] + tol, b_box[1][1] - tol, N_pts) pts = np.stack((625 * np.ones(N_pts), y_range, np.zeros(N_pts))) values = plot_over_line(gb, pts, 'pressure', tol) arc_length = y_range - b_box[0][1] np.savetxt("example_5_1_2/vem_x_625.csv", (arc_length, values)) x_range = np.linspace(b_box[0][0] + tol, b_box[1][0] - tol, N_pts) pts = np.stack((x_range, 500 * np.ones(N_pts), np.zeros(N_pts))) values = plot_over_line(gb, pts, 'pressure', tol)
darcy.extract_u(gb, "up", "discharge") darcy.extract_p(gb, "up", 'pressure') darcy.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) exporter.export_vtk(gb, 'darcy', ['pressure', "P0u"], folder=export_folder, binary=False) ################################################################# physics = 'transport' advection = upwind.UpwindMixDim(physics) mass = mass_matrix.MassMatrixMixDim(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)
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) darcy.split(gb, "up", up) gb.add_node_props(['pressure', "P0u"]) for g, d in gb: discharge = darcy.discr.extract_u(g, d["up"]) d['discharge'] = discharge d['pressure'] = darcy.discr.extract_p(g, d["up"]) d["P0u"] = darcy.discr.project_u(g, discharge, d) if do_save: exporter.export_vtk(gb, 'darcy', ['pressure', "P0u"], folder=export_folder) ################################################################# for g, d in gb: g.face_tags = d['face_tags'] physics = 'transport' advection = upwind.UpwindMixedDim(physics) diffusion = tpfa.TpfaMixedDim(physics) # Assign parameters add_data_advection_diffusion(gb, domain, tol) U, rhs_u = advection.matrix_rhs(gb) D, rhs_d = diffusion.matrix_rhs(gb)
#------------------------------------------------------------------------------# mesh_kwargs = {} mesh_kwargs['mesh_size'] = {'mode': 'constant', 'value': 10, 'bound_value': 10} 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() internal_flag = FaceTag.FRACTURE [g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb] exporter.export_vtk(gb, 'grid', folder='vem') # Assign parameters add_data(gb, domain) # Choose and define the solvers and coupler solver_flow = vem_dual.DualVEMMixDim('flow') A_flow, b_flow = solver_flow.matrix_rhs(gb) solver_source = vem_source.IntegralMixDim('flow') A_source, b_source = solver_source.matrix_rhs(gb) up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source) solver.split(gb, "up", up) gb.add_node_props(["discharge", 'pressure', "P0u"])
"value": 0.25, "bound_value": 1 } file_name = "dfn_square.fab" file_intersections = "traces_square.dat" gb = importer.dfn_3d_from_fab(file_name, file_intersections, tol=1e-5, **mesh_kwargs) gb.remove_nodes(lambda g: g.dim == 0) gb.compute_geometry() # co.coarsen(gb, 'by_volume') gb.assign_node_ordering() exporter.export_vtk(gb, "grid", folder="vem") # Assign parameters add_data(gb, tol) # Choose and define the solvers and coupler solver = dual.DualVEMDFN(gb.dim_max(), "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", "err"]) solver.extract_u(gb, "up", "discharge") solver.extract_p(gb, "up", "pressure") solver.project_u(gb, "discharge", "P0u")
export_every = 2 step_to_export = np.empty(0) print("Start the time loop") print(deltaT, deltaT_r) while i * deltaT <= T: # Update the solution print("Solve the current state (", i * deltaT, ",", T, ")") conc = invM.dot((M_minus_U).dot(conc) + rhs) coupler_solver.split(gb, "conc", conc) if i % export_every == 0: print("Export the solution of the current state") export_vtk(gb, file_name, ["conc"], time_step=i_export, folder="simu") step_to_export = np.r_[step_to_export, i] i_export += 1 i += 1 export_pvd(gb, file_name, step_to_export * deltaT, folder="simu") step_to_export = np.empty(0) i, i_export = 0, 0 while i * deltaT_r <= T: # Update the solution conc_r = invM_r.dot((M_minus_U_r).dot(conc_r) + rhs_r)
# 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") solver.project_u(gb, "discharge", "P0u") exporter.export_vtk(gb, "vem", ["pressure", "P0u"], folder="example_5_1_2") # This part is very slow and not optimized, it's just to obtain the plots once. b_box = gb.bounding_box() N_pts = 1000 y_range = np.linspace(b_box[0][1] + tol, b_box[1][1] - tol, N_pts) pts = np.stack((625 * np.ones(N_pts), y_range, np.zeros(N_pts))) values = plot_over_line(gb, pts, "pressure", tol) arc_length = y_range - b_box[0][1] np.savetxt("example_5_1_2/vem_x_625.csv", (arc_length, values)) x_range = np.linspace(b_box[0][0] + tol, b_box[1][0] - tol, N_pts) pts = np.stack((x_range, 500 * np.ones(N_pts), np.zeros(N_pts))) values = plot_over_line(gb, pts, "pressure", tol)
def darcy_dualVEM_coupling_example2(**kwargs): ####################### # Simple 2d Darcy problem with known exact solution ####################### np.set_printoptions(linewidth=999999, threshold=np.nan, precision=16) f_1 = np.array([[-1, 1, 1, -1], [0, 0, 0, 0], [-1, -1, 1, 1]]) f_2 = np.array([[0, 0, 0, 0], [-1, 1, 1, -1], [-1.5, -1.5, .8, .8]]) domain = { "xmin": -2, "xmax": 2, "ymin": -2, "ymax": 2, "zmin": -2, "zmax": 2 } kwargs = { "mesh_size_frac": .25, "mesh_size_bound": 10, "mesh_size_min": .02, "gmsh_path": "~/gmsh/bin/gmsh", } gb = meshing.simplex_grid([f_1, f_2], domain, **kwargs) gb.remove_nodes(lambda g: g.dim == gb.dim_max()) # It's not really working now the coarsening part with the gb # for g, _ in gb: # if g.dim != 1: # part = create_partition(tpfa_matrix(g)) # gb.change_nodes({g: generate_coarse_grid(g, part)}) # # gb.compute_geometry(is_starshaped=True) print([g.num_faces for g, _ in gb]) gb.assign_node_ordering() if kwargs["visualize"]: plot_grid(gb, info="f", alpha=0) gb.add_node_props(["perm", "source", "bc", "bc_val"]) for g, d in gb: kxx = np.ones(g.num_cells) d["perm"] = tensor.SecondOrderTensor(g.dim, kxx) d["source"] = np.zeros(g.num_cells) b_faces = g.tags["domain_boundary_faces"].nonzero()[0] b_faces_dir = b_faces[np.bitwise_or(g.face_centers[1, b_faces] == -1, g.face_centers[0, b_faces] == -1)] b_faces_dir_cond = g.face_centers[0, b_faces_dir] b_faces_neu = np.setdiff1d(b_faces, b_faces_dir, assume_unique=True) b_faces = np.hstack((b_faces_dir, b_faces_neu)) b_faces_label = np.hstack( (["dir"] * b_faces_dir.size, ["neu"] * b_faces_neu.size)) d["bc"] = bc.BoundaryCondition(g, b_faces, b_faces_label) d["bc_val"] = { "dir": b_faces_dir_cond, "neu": np.zeros(b_faces_neu.size) } gb.add_edge_prop("kn") for e, d in gb.edges_props(): g_l = gb.sorted_nodes_of_edge(e)[0] c = g_l.cell_centers[2, :] > -0.5 d["kn"] = np.ones(g_l.num_cells) + c.astype("float") * (-1 + 1e-2) solver = dual.DualVEM() coupling_conditions = dual_coupling.DualCoupling(solver) solver_coupler = coupler.Coupler(solver, coupling_conditions) A, b = solver_coupler.matrix_rhs(gb) up = sps.linalg.spsolve(A, b) solver_coupler.split(gb, "up", up) gb.add_node_props(["u", "pressure", "P0u"]) for g, d in gb: d["u"] = solver.extractU(g, d["up"]) d["pressure"] = solver.extractP(g, d["up"]) d["P0u"] = solver.projectU(g, d["u"], d) if kwargs["visualize"]: plot_grid(gb, "pressure", "P0u") export_vtk(gb, "grid", ["pressure", "P0u"])
diffusion = second_order_tensor.SecondOrderTensorTensor(g.dim, kxx) f = np.ones(g.num_cells) * g.cell_volumes data = {'beta_n': beta_n, 'bc': bnd, 'bc_val': bnd_val, 'k': diffusion, 'f': f} return data #------------------------------------------------------------------------------# # the f is considered twice, we guess that non-homogeneous Neumann as well. Nx = Ny = 20 g = structured.CartGrid([Nx, Ny], [1, 1]) g.compute_geometry() advection = upwind.Upwind() diffusion = tpfa.Tpfa() # Assign parameters data = add_data(g, advection) U, rhs_u = advection.matrix_rhs(g, data) D, rhs_d = diffusion.matrix_rhs(g, data) theta = sps.linalg.spsolve(D + U, rhs_u + rhs_d) exporter.export_vtk(g, "advection_diffusion", {"theta": theta})
# 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"]) solver.split(gb, "p_condensation", p_full_condensation) solver.split(gb_r, "p_reduced", p_reduced) solver.split(gb, 'pressure', p) max_p, min_p, normalization, error_norm = np.zeros(1), np.zeros(1), 0, 0 for g, d in gb: p1, p2 = d['pressure'], d["p_condensation"] error_norm += sum( np.power(p1 - p2, 2) * g.cell_volumes * d['param'].apertures) normalization += sum(g.cell_volumes) max_p = np.array(np.amax(np.concatenate((max_p, p1)), axis=0), ndmin=1) min_p = np.array(np.amin(np.concatenate((min_p, p1)), axis=0), ndmin=1) error_norm = np.power(error_norm / normalization, .5) / (max_p - min_p) print('The error of the condensation compared to the full method is ', error_norm) assert error_norm < 1e-3 export_vtk(gb, "grid_mpfa", ['pressure', "p_condensation"], folder="simu") export_vtk(gb_r, "grid_mpfa_r", ["p_reduced"], folder="simu")
solver_source = vem_source.DualSourceMixedDim("flow", coupling=[None]) A_source, b_source = solver_source.matrix_rhs(gb) up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source) darcy.split(gb, "up", up) gb.add_node_props(["pressure", "P0u"]) for g, d in gb: discharge = darcy.discr.extract_u(g, d["up"]) d["discharge"] = discharge d["pressure"] = darcy.discr.extract_p(g, d["up"]) d["P0u"] = darcy.discr.project_u(g, discharge, d) if do_save: exporter.export_vtk(gb, "darcy", ["pressure", "P0u"], folder=export_folder) ################################################################# physics = "transport" advection = upwind.UpwindMixedDim(physics) diffusion = tpfa.TpfaMixedDim(physics) # Assign parameters add_data_advection_diffusion(gb, domain, tol) U, rhs_u = advection.matrix_rhs(gb) D, rhs_d = diffusion.matrix_rhs(gb) theta = sps.linalg.spsolve(D + U, rhs_u + rhs_d) diffusion.split(gb, "temperature", theta)
d['param'].set_discharge(d['u']) d['pressure'] = darcy.discr.extract_p(g, d["up"]) d["P0u"] = darcy.discr.project_u(g, d['u'], d) # 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['u'][bound_faces[left]] total_flow_rate += np.sum(flow_rate) print("total flow rate", total_flow_rate) exporter.export_vtk(gb, 'darcy', ['pressure', "P0u"], folder=export_folder) ################################################################# physics = 'transport' advection = upwind.UpwindMixedDim(physics) diffusion = tpfa.TpfaMixedDim(physics) mass = mass_matrix.MassMatrixMixedDim(physics) invMass = mass_matrix.InvMassMatrixMixedDim(physics) # Assign parameters add_data_advection_diffusion(gb, domain, tol, a) T = 1 deltaT = 0.01 gb.add_node_prop('deltaT', prop=deltaT)
def main(kf, description, mesh_size): mesh_kwargs = {} mesh_kwargs['mesh_size'] = { 'mode': 'constant', 'value': mesh_size, 'bound_value': mesh_size } domain = {'xmin': 0, 'xmax': 1, 'ymin': 0, 'ymax': 1} if_coarse = True folder = 'example_5_1_1_' + description file_name = 'network_geiger.csv' write_network(file_name) gb = importer.from_csv(file_name, mesh_kwargs, domain) gb.compute_geometry() g_fine = gb.get_grids(lambda g: g.dim == gb.dim_max())[0].copy() if if_coarse: partition = co.create_aggregations(gb) partition = co.reorder_partition(partition) co.generate_coarse_grid(gb, partition) 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 = 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') solver.project_u(gb, "discharge", "P0u") exporter.export_vtk(gb, 'vem', ['pressure', "P0u"], folder=folder, binary=False) if if_coarse: partition = partition[gb.grids_of_dimension(gb.dim_max())[0]] p = np.array([d['pressure'] for g, d in gb if g.dim == gb.dim_max()]).ravel() data = {'partition': partition, 'pressure': p[partition]} exporter.export_vtk(g_fine, 'sub_grid', data, binary=False, folder=folder) print("diam", gb.diameter(lambda g: g.dim == gb.dim_max())) print("num_cells 2d", gb.num_cells(lambda g: g.dim == 2)) print("num_cells 1d", gb.num_cells(lambda g: g.dim == 1))
# ------------------------------------------------------------------------------# Nx = Ny = 20 # g = structured.CartGrid([Nx, Ny], [1, 1]) g = simplex.StructuredTriangleGrid([Nx, Ny], [1, 1]) R = cg.rot(np.pi / 4.0, [1, 0, 0]) g.nodes = np.dot(R, g.nodes) g.compute_geometry() # co.coarsen(g, 'by_volume') # Assign parameters data = add_data(g) # Choose and define the solvers solver = dual.DualVEM("flow") A, b = solver.matrix_rhs(g, data) up = sps.linalg.spsolve(A, b) u = solver.extract_u(g, up) p = solver.extract_p(g, up) P0u = solver.project_u(g, u, data) diam = np.amax(g.cell_diameters()) print("h=", diam, "- err(p)=", error_p(g, p)) exporter.export_vtk(g, "vem", {"p": p, "P0u": P0u}, folder="vem") # ------------------------------------------------------------------------------#
def darcy_dualVEM_coupling_example2(**kwargs): ####################### # Simple 2d Darcy problem with known exact solution ####################### np.set_printoptions(linewidth=999999, threshold=np.nan, precision=16) f_1 = np.array([[-1, 1, 1, -1], [0, 0, 0, 0], [-1, -1, 1, 1]]) f_2 = np.array([[0, 0, 0, 0], [-1, 1, 1, -1], [-1.5, -1.5, .8, .8]]) domain = {'xmin': -2, 'xmax': 2, 'ymin': -2, 'ymax': 2, 'zmin': -2, 'zmax': 2} # mesh_size = {'mode': 'constant', 'value': 0.5, 'bound_value': 1} mesh_size = {'mode': 'constant', 'value': 5, 'bound_value': 10} mesh_size = {'mode': 'constant', 'value': 0.25, 'bound_value': 10} kwargs['mesh_size'] = mesh_size kwargs['gmsh_path'] = '~/gmsh/bin/gmsh' gb = meshing.simplex_grid([f_1, f_2], domain, **kwargs) gb.remove_nodes(lambda g: g.dim == gb.dim_max()) # It's not really working now the coarsening part with the gb # for g, _ in gb: # if g.dim != 1: # part = create_partition(tpfa_matrix(g)) # gb.change_nodes({g: generate_coarse_grid(g, part)}) # # gb.compute_geometry(is_starshaped=True) print([g.num_faces for g, _ in gb]) gb.assign_node_ordering() # Need to remove the boundary flag explicity from the fracture face, # because of the mix formulation internal_flag = FaceTag.FRACTURE [g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb if g.dim == gb.dim_max()] if kwargs['visualize']: plot_grid(gb, info="f", alpha=0) gb.add_node_props(['perm', 'source', 'bc', 'bc_val']) for g, d in gb: kxx = np.ones(g.num_cells) d['perm'] = tensor.SecondOrder(g.dim, kxx) d['source'] = np.zeros(g.num_cells) b_faces = g.get_boundary_faces() b_faces_dir = b_faces[np.bitwise_or(g.face_centers[1, b_faces] == -1, g.face_centers[0, b_faces] == -1)] b_faces_dir_cond = g.face_centers[0, b_faces_dir] b_faces_neu = np.setdiff1d(b_faces, b_faces_dir, assume_unique=True) b_faces = np.hstack((b_faces_dir, b_faces_neu)) b_faces_label = np.hstack((['dir'] * b_faces_dir.size, ['neu'] * b_faces_neu.size)) d['bc'] = bc.BoundaryCondition(g, b_faces, b_faces_label) d['bc_val'] = {'dir': b_faces_dir_cond, 'neu': np.zeros(b_faces_neu.size)} gb.add_edge_prop('kn') for e, d in gb.edges_props(): g_l = gb.sorted_nodes_of_edge(e)[0] c = g_l.cell_centers[2, :] > -0.5 d['kn'] = (np.ones(g_l.num_cells) + c.astype('float') * (-1 + 1e-2)) solver = dual.DualVEM() coupling_conditions = dual_coupling.DualCoupling(solver) solver_coupler = coupler.Coupler(solver, coupling_conditions) A, b = solver_coupler.matrix_rhs(gb) up = sps.linalg.spsolve(A, b) solver_coupler.split(gb, "up", up) gb.add_node_props(["u", 'pressure', "P0u"]) for g, d in gb: d["u"] = solver.extractU(g, d["up"]) d['pressure'] = solver.extractP(g, d["up"]) d["P0u"] = solver.projectU(g, d["u"], d) if kwargs['visualize']: plot_grid(gb, 'pressure', "P0u") export_vtk(gb, "grid", ['pressure', "P0u"])
darcy.extract_u(gb, "up", "discharge") darcy.extract_p(gb, "up", "pressure") darcy.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) exporter.export_vtk(gb, "darcy", ["pressure", "P0u"], folder=export_folder, binary=False) ################################################################# physics = "transport" advection = upwind.UpwindMixDim(physics) mass = mass_matrix.MassMatrixMixDim(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)
"zmax": 5500, } mesh_kwargs["domain"] = domain print("create soultz grid") gb = soultz_grid.create_grid(**mesh_kwargs) gb.compute_geometry() if if_coarse: pp.coarsening.coarsen(gb, "by_volume") gb.assign_node_ordering() print("solve Darcy problem") for g, d in gb: d["cell_id"] = np.arange(g.num_cells) exporter.export_vtk(gb, "grid", ["cell_id"], folder=export_folder) # 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") darcy.extract_p(gb, "up", "pressure")