def dotest(MYSOLVER, multi=False, A=None, **solverOpts): if A is None: h1 = np.ones(10) * 100. h2 = np.ones(10) * 100. h3 = np.ones(10) * 100. h = [h1, h2, h3] M = TensorMesh(h) D = M.faceDiv G = -M.faceDiv.T Msig = M.getFaceInnerProduct() A = D * Msig * G A[-1, -1] *= 1 / M.vol[ -1] # remove the constant null space from the matrix else: M = Mesh.TensorMesh([A.shape[0]]) Ainv = MYSOLVER(A, **solverOpts) if multi: e = np.ones(M.nC) else: e = np.ones((M.nC, numRHS)) rhs = A * e x = Ainv * rhs Ainv.clean() return np.linalg.norm(e - x, np.inf)
def dotest(MYSOLVER, multi=False, A=None, **solverOpts): if A is None: h1 = np.ones(10)*100. h2 = np.ones(10)*100. h3 = np.ones(10)*100. h = [h1,h2,h3] M = TensorMesh(h) D = M.faceDiv G = -M.faceDiv.T Msig = M.getFaceInnerProduct() A = D*Msig*G A[-1,-1] *= 1/M.vol[-1] # remove the constant null space from the matrix else: M = Mesh.TensorMesh([A.shape[0]]) Ainv = MYSOLVER(A, **solverOpts) if multi: e = np.ones(M.nC) else: e = np.ones((M.nC, numRHS)) rhs = A * e x = Ainv * rhs Ainv.clean() return np.linalg.norm(e-x,np.inf)
# # **With the operators constructed below, you can compute all of the # aforementioned inner products.** # # Make basic mesh h = np.ones(10) mesh = TensorMesh([h, h, h]) sig = np.random.rand(mesh.nC) # isotropic Sig = np.random.rand(mesh.nC, 6) # anisotropic # Inner product matricies Mc = sdiag(mesh.vol * sig) # Inner product matrix (centers) # Mn = mesh.getNodalInnerProduct(sig) # Inner product matrix (nodes) (*functionality pending*) Me = mesh.getEdgeInnerProduct(sig) # Inner product matrix (edges) Mf = mesh.getFaceInnerProduct(sig) # Inner product matrix for tensor (faces) # Differential operators Gne = mesh.nodalGrad # Nodes to edges gradient mesh.setCellGradBC(['neumann', 'dirichlet', 'neumann']) # Set boundary conditions Gcf = mesh.cellGrad # Cells to faces gradient D = mesh.faceDiv # Faces to centers divergence Cef = mesh.edgeCurl # Edges to faces curl Cfe = mesh.edgeCurl.T # Faces to edges curl # EXAMPLE: (u, sig*Curl*v) fig = plt.figure(figsize=(9, 5)) ax1 = fig.add_subplot(121) ax1.spy(Mf * Cef, markersize=0.5)
import numpy as np from discretize.utils import sdiag ############################################### # # Solving the Problem # ------------------- # # Create a tensor mesh h = np.ones(75) mesh = TensorMesh([h, h], 'CC') # Create system DIV = mesh.faceDiv # Faces to cell centers divergence Mf_inv = mesh.getFaceInnerProduct(invMat=True) Mc = sdiag(mesh.vol) A = Mc * DIV * Mf_inv * DIV.T * Mc # Define RHS (charge distributions at cell centers) xycc = mesh.gridCC kneg = (xycc[:, 0] == -10) & (xycc[:, 1] == 0) # -ve charge distr. at (-10, 0) kpos = (xycc[:, 0] == 10) & (xycc[:, 1] == 0) # +ve charge distr. at (10, 0) rho = np.zeros(mesh.nC) rho[kneg] = -1 rho[kpos] = 1 # LU factorization and solve AinvM = SolverLU(A) phi = AinvM * rho
# Evaluate inner-product using edge-defined discrete variables vx = fcn_x(mesh.gridEx, sig) vy = fcn_y(mesh.gridEy, sig) v = np.r_[vx, vy] Me = mesh.getEdgeInnerProduct() # Edge inner product matrix ipe = np.dot(v, Me * v) # Evaluate inner-product using face-defined discrete variables vx = fcn_x(mesh.gridFx, sig) vy = fcn_y(mesh.gridFy, sig) v = np.r_[vx, vy] Mf = mesh.getFaceInnerProduct() # Edge inner product matrix ipf = np.dot(v, Mf * v) # The analytic solution of (v, v) ipt = np.pi * sig**2 # Plot the vector function fig = plt.figure(figsize=(5, 5)) ax = fig.add_subplot(111) mesh.plotImage(v, ax=ax, vType='F', view='vec', streamOpts={ 'color': 'w',
u = 10.0 * np.r_[ux, uy] # Maximum velocity is 10 m/s # Define vector q where s0 = 1 in our analytic source term xycc = mesh.gridCC k = (xycc[:, 0] == 0) & (xycc[:, 1] == -15) # source at (0, -15) q = np.zeros(mesh.nC) q[k] = 1 # Define diffusivity within each cell a = mkvc(8.0 * np.ones(mesh.nC)) # Define the matrix M Afc = mesh.dim * mesh.aveF2CC # modified averaging operator to sum dot product Mf_inv = mesh.getFaceInnerProduct(invMat=True) Mc = sdiag(mesh.vol) Mc_inv = sdiag(1 / mesh.vol) Mf_alpha_inv = mesh.getFaceInnerProduct(a, invProp=True, invMat=True) mesh.setCellGradBC(["neumann", "neumann"]) # Set Neumann BC G = mesh.cellGrad D = mesh.faceDiv M = -D * Mf_alpha_inv * G * Mc + Afc * sdiag(u) * Mf_inv * G * Mc # Set time stepping, initial conditions and final matricies dt = 0.02 # Step width p = np.zeros(mesh.nC) # Initial conditions p(t=0)=0
# where the inner product matrix contains a significant number of non-diagonal # entries. # # Create a single 3D cell h = np.ones(1) mesh = TensorMesh([h, h, h]) # Define 6 constitutive parameters for the cell sig1, sig2, sig3, sig4, sig5, sig6 = 6, 5, 4, 3, 2, 1 # Isotropic case sig = sig1 * np.ones((1, 1)) sig_tensor_1 = np.diag(sig1 * np.ones(3)) Me1 = mesh.getEdgeInnerProduct(sig) # Edges inner product matrix Mf1 = mesh.getFaceInnerProduct(sig) # Faces inner product matrix # Diagonal anisotropic sig = np.c_[sig1, sig2, sig3] sig_tensor_2 = np.diag(np.array([sig1, sig2, sig3])) Me2 = mesh.getEdgeInnerProduct(sig) Mf2 = mesh.getFaceInnerProduct(sig) # Full anisotropic sig = np.c_[sig1, sig2, sig3, sig4, sig5, sig6] sig_tensor_3 = np.diag(np.array([sig1, sig2, sig3])) sig_tensor_3[(0, 1), (1, 0)] = sig4 sig_tensor_3[(0, 2), (2, 0)] = sig5 sig_tensor_3[(1, 2), (2, 1)] = sig6 Me3 = mesh.getEdgeInnerProduct(sig) Mf3 = mesh.getFaceInnerProduct(sig)
# for quantities living on cell faces, e.g.: # # .. math:: # (\vec{u} , \nabla \phi) \approx \mathbf{u^T M_f G_c \phi} # # Make basic mesh h = np.ones(10) mesh = TensorMesh([h, h, h]) # Items required to perform u.T*(Me*Gn*phi) Me = mesh.getEdgeInnerProduct() # Basic inner product matrix (edges) Gn = mesh.nodalGrad # Nodes to edges gradient # Items required to perform u.T*(Mf*Gc*phi) Mf = mesh.getFaceInnerProduct() # Basic inner product matrix (faces) mesh.setCellGradBC(["neumann", "dirichlet", "neumann"]) # Set boundary conditions Gc = mesh.cellGrad # Cells to faces gradient # Plot Sparse Representation fig = plt.figure(figsize=(5, 6)) ax1 = fig.add_subplot(121) ax1.spy(Me * Gn, markersize=0.5) ax1.set_title("Me*Gn") ax2 = fig.add_subplot(122) ax2.spy(Mf * Gc, markersize=0.5) ax2.set_title("Mf*Gc")