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'])