def test_upwind_2d_simplex_surf_discharge_negative(self): g = simplex.StructuredTriangleGrid([2, 1], [1, 1]) R = cg.rot(-np.pi / 5., [1, 1, -1]) g.nodes = np.dot(R, g.nodes) g.compute_geometry(is_embedded=True) solver = upwind.Upwind() param = Parameters(g) dis = solver.discharge(g, np.dot(R, [-1, 0, 0])) bf = g.tags['domain_boundary_faces'].nonzero()[0] bc = BoundaryCondition(g, bf, bf.size * ['neu']) param.set_bc(solver, bc) data = {'param': param, 'discharge': dis} M = solver.matrix_rhs(g, data)[0].todense() deltaT = solver.cfl(g, data) M_known = np.array([[1, 0, 0, -1], [-1, 0, 0, 0], [0, 0, 1, 0], [0, 0, -1, 1]]) deltaT_known = 1 / 6 rtol = 1e-15 atol = rtol assert np.allclose(M, M_known, rtol, atol) assert np.allclose(deltaT, deltaT_known, rtol, atol)
def anisotropy(gb, deg, yfactor): """ Set anisotropic permeability in the 2d matrix. """ for g, d in gb: # Get rotational tensor R perm_x = 1 perm_y = 1 / yfactor perm_z = 1 rad = deg * np.pi / 180 v = np.array([0, 0, 1]) R = cg.rot(rad, v) # Set up orthogonal tensor and rotate it k_orth = np.array([[perm_x, 0, 0], [0, perm_y, 0], [0, 0, perm_z]]) k = np.dot(np.dot(R, k_orth), R.T) kf = np.ones(g.num_cells) kxx = kf * k[0, 0] kyy = kf * k[1, 1] kxy = kf * k[0, 1] kxz = kf * k[0, 2] kyz = kf * k[1, 2] kzz = kf * k[2, 2] k_frac = 1e4 kxx[fracture_cells] = k_frac kyy[fracture_cells] = k_frac kzz[fracture_cells] = k_frac kxy[fracture_cells] = 0 kxz[fracture_cells] = 0 kyz[fracture_cells] = 0 perm = tensor.SecondOrderTensor( 3, kxx=kxx, kyy=kyy, kzz=kzz, kxy=kxy, kxz=kxz, kyz=kyz ) d["param"].set_tensor("flow", perm)
def anisotropy(gb, deg, yfactor): """ Set anisotropic permeability in the 2d matrix. """ for g, d in gb: if g.dim == 2: # Get rotational tensor R perm_x = 1 perm_y = 1 / yfactor perm_z = 1 rad = deg * np.pi / 180 v = np.array([0, 0, 1]) R = cg.rot(rad, v) # Set up orthogonal tensor and rotate it k_orth = np.array([[perm_x, 0, 0], [0, perm_y, 0], [0, 0, perm_z]]) k = np.dot(np.dot(R, k_orth), R.T) kf = np.ones(g.num_cells) kxx = kf * k[0, 0] kyy = kf * k[1, 1] kxy = kf * k[0, 1] kxz = kf * k[0, 2] kyz = kf * k[1, 2] kzz = kf * k[2, 2] perm = tensor.SecondOrder(3, kxx=kxx, kyy=kyy, kzz=kzz, kxy=kxy, kxz=kxz, kyz=kyz) d['param'].set_tensor('flow', perm) d['hybrid_correction'] = True
def main(N): Nx = Ny = N #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_flow = vem_dual.DualVEM('flow') A_flow, b_flow = solver_flow.matrix_rhs(g, data) solver_source = vem_source.Integral('flow') A_source, b_source = solver_source.matrix_rhs(g, data) up = sps.linalg.spsolve(A_flow + A_source, b_flow + b_source) u = solver_flow.extract_u(g, up) p = solver_flow.extract_p(g, up) P0u = solver_flow.project_u(g, u, data) diam = np.amax(g.cell_diameters()) return diam, error_p(g, p)
def anisotropy(g, deg, yfactor): """ Set anisotropic permeability in the 2d matrix. """ # Get rotational tensor R k = 1e3 perm_x = k perm_y = k / yfactor perm_z = k rad = deg * np.pi / 180 v = np.array([0, 0, 1]) R = cg.rot(rad, v) # Set up orthogonal permeability tensor and rotate it k_orth = np.array([[perm_x, 0, 0], [0, perm_y, 0], [0, 0, perm_z]]) k = np.dot(np.dot(R, k_orth), R.T) kf = np.ones(g.num_cells) kxx = kf * k[0, 0] kyy = kf * k[1, 1] kxy = kf * k[0, 1] kxz = kf * k[0, 2] kyz = kf * k[1, 2] kzz = kf * k[2, 2] perm = tensor.SecondOrderTensor(3, kxx=kxx, kyy=kyy, kzz=kzz, kxy=kxy, kxz=kxz, kyz=kyz) return perm
def test_upwind_2d_simplex_surf_discharge_positive(self): g = simplex.StructuredTriangleGrid([2, 1], [1, 1]) R = cg.rot(np.pi / 2., [1, 1, 0]) g.nodes = np.dot(R, g.nodes) g.compute_geometry() solver = upwind.Upwind() param = Parameters(g) dis = solver.discharge(g, np.dot(R, [1, 0, 0])) bf = g.tags["domain_boundary_faces"].nonzero()[0] bc = BoundaryCondition(g, bf, bf.size * ["neu"]) param.set_bc(solver, bc) data = {"param": param, "discharge": dis} M = solver.matrix_rhs(g, data)[0].todense() deltaT = solver.cfl(g, data) M_known = np.array([[1, -1, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1], [-1, 0, 0, 1]]) deltaT_known = 1 / 6 rtol = 1e-15 atol = rtol self.assertTrue(np.allclose(M, M_known, rtol, atol)) self.assertTrue(np.allclose(deltaT, deltaT_known, rtol, atol))
def rotate_fracture(frac, vec, angle, exposure): """ Rotate a fracture along a specified strike vector, and centered on a given point on the fracture surface. Modification of the fracture coordinates is done in place. TODO: Move this to the fracture itself? Parameters: frac (Fracture): To be rotated. Points are modified in-place. vec (np.array-like): Rotation will be around this vector. ang (double). Rotation angle. Measured in radians. exposure (np.array-like): Point on the strike vector, rotation will be centered around the line running through this point. """ vec = np.asarray(vec) exposure = np.asarray(exposure) if vec.size == 2: vec = np.append(vec, 0) if exposure.size == 2: exposure = np.append(exposure, 0) exposure = exposure.reshape((3, 1)) rot = cg.rot(angle, vec) p = frac.p frac.p = exposure + rot.dot(p - exposure) frac.points_2_ccw() frac.compute_centroid() frac.compute_normal()
def test_upwind_2d_cart_surf_discharge_negative(self): g = structured.CartGrid([3, 2], [1, 1]) R = cg.rot(np.pi/6., [1,1,0]) g.nodes = np.dot(R, g.nodes) g.compute_geometry(is_embedded=True) solver = upwind.Upwind() param = Parameters(g) dis = solver.discharge(g, np.dot(R, [-1, 0, 0])) bf = g.get_boundary_faces() bc = BoundaryCondition(g, bf, bf.size * ['neu']) param.set_bc(solver, bc) data = {'param': param, 'discharge': dis} M = solver.matrix_rhs(g, data)[0].todense() deltaT = solver.cfl(g, data) M_known = 0.5 * np.array([[ 0,-1, 0, 0, 0, 0], [ 0, 1,-1, 0, 0, 0], [ 0, 0, 1, 0, 0, 0], [ 0, 0, 0, 0,-1, 0], [ 0, 0, 0, 0, 1,-1], [ 0, 0, 0, 0, 0, 1]]) deltaT_known = 1/6 rtol = 1e-15 atol = rtol assert np.allclose(M, M_known, rtol, atol) assert np.allclose(deltaT, deltaT_known, rtol, atol)
def darcy_dualVEM_example2(**kwargs): ####################### # Simple 2d Darcy problem on a surface with known exact solution ####################### Nx = Ny = 25 g = simplex.StructuredTriangleGrid([Nx, Ny], [1, 1]) R = cg.rot(np.pi / 6., [0, 1, 1]) g.nodes = np.dot(R, g.nodes) g.compute_geometry() T = cg.tangent_matrix(g.nodes) kxx = np.ones(g.num_cells) perm = tensor.SecondOrderTensor(g.dim, kxx) def funP_ex(pt): return np.pi * pt[0] - 6 * pt[1] + np.exp(1) * pt[2] - 4 def funU_ex(pt): return np.dot(T, [-np.pi, 6, -np.exp(1)]) def fun(pt): return 0 f = np.array([fun(pt) for pt in g.cell_centers.T]) b_faces = g.get_all_boundary_faces() bnd = bc.BoundaryCondition(g, b_faces, ["dir"] * b_faces.size) bnd_val = np.zeros(g.num_faces) bnd_val[b_faces] = funP_ex(g.face_centers[:, b_faces]) solver = dual.DualVEM() data = {"perm": perm, "source": f, "bc": bnd, "bc_val": bnd_val} D, rhs = solver.matrix_rhs(g, data) up = sps.linalg.spsolve(D, rhs) u, p = solver.extract_u(g, up), solver.extract_p(g, up) P0u = solver.project_u(g, u) if kwargs["visualize"]: plot_grid(g, p, P0u) p_ex = error.interpolate(g, funP_ex) u_ex = error.interpolate(g, funU_ex) errors = np.array( [error.error_L2(g, p, p_ex), error.error_L2(g, P0u, u_ex)]) errors_known = np.array([0, 0]) assert np.allclose(errors, errors_known)
def main(N): Nx = Ny = N #g = structured.CartGrid([Nx, Ny], [1, 1]) g = simplex.StructuredTriangleGrid([Nx, Ny], [1, 1]) R = cg.rot(np.pi / 2., [1, 0, 0]) g.nodes = np.dot(R, g.nodes) g.compute_geometry(is_embedded=True) # Assign parameters data = add_data(g) # Choose and define the solvers solver = mpfa.Mpfa('flow') A, b_flux = solver.matrix_rhs(g, data) _, b_source = source.Integral('flow').matrix_rhs(g, data) p = sps.linalg.spsolve(A, b_flux + b_source) diam = np.amax(g.cell_diameters()) return diam, error_p(g, p)
# ------------------------------------------------------------------------------# def error_p(g, p): sol = np.array([solution(*pt) for pt in g.cell_centers.T]) return np.sqrt(np.sum(np.power(np.abs(p - sol), 2) * g.cell_volumes)) # ------------------------------------------------------------------------------# 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)