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")