def getError(self): #Test function phi = lambda x: np.cos(np.pi * x[:, 0]) * np.cos(np.pi * x[:, 1]) j_funX = lambda x: -np.pi * np.sin(np.pi * x[:, 0]) * np.cos(np.pi * x[:, 1]) j_funY = lambda x: -np.pi * np.cos(np.pi * x[:, 0]) * np.sin(np.pi * x[:, 1]) q_fun = lambda x: -2 * (np.pi**2) * phi(x) xc_ana = phi(self.M.gridCC) q_ana = q_fun(self.M.gridCC) jX_ana = j_funX(self.M.gridFx) jY_ana = j_funY(self.M.gridFy) j_ana = np.r_[jX_ana, jY_ana] #TODO: Check where our boundary conditions are CCx or Nx # fxm,fxp,fym,fyp = self.M.faceBoundaryInd # gBFx = self.M.gridFx[(fxm|fxp),:] # gBFy = self.M.gridFy[(fym|fyp),:] fxm, fxp, fym, fyp = self.M.cellBoundaryInd gBFx = self.M.gridCC[(fxm | fxp), :] gBFy = self.M.gridCC[(fym | fyp), :] bc = phi(np.r_[gBFx, gBFy]) # P = sp.csr_matrix(([-1,1],([0,self.M.nF-1],[0,1])), shape=(self.M.nF, 2)) P, Pin, Pout = self.M.getBCProjWF('dirichlet') Mc = self.M.getFaceInnerProduct() McI = utils.sdInv(self.M.getFaceInnerProduct()) G = -self.M.faceDiv.T * utils.sdiag(self.M.vol) D = self.M.faceDiv j = McI * (G * xc_ana + P * bc) q = D * j # self.M.plotImage(j, 'FxFy', show_it=True) # Rearrange if we know q to solve for x A = D * McI * G rhs = q_ana - D * McI * P * bc if self.myTest == 'j': err = np.linalg.norm((j - j_ana), np.inf) elif self.myTest == 'q': err = np.linalg.norm((q - q_ana), np.inf) elif self.myTest == 'xc': xc = Solver(A) * (rhs) err = np.linalg.norm((xc - xc_ana), np.inf) elif self.myTest == 'xcJ': xc = Solver(A) * (rhs) j = McI * (G * xc + P * bc) err = np.linalg.norm((j - j_ana), np.inf) return err
def getError(self): #Test function phi = lambda x: np.cos(0.5 * np.pi * x) j_fun = lambda x: -0.5 * np.pi * np.sin(0.5 * np.pi * x) q_fun = lambda x: -0.25 * (np.pi**2) * np.cos(0.5 * np.pi * x) xc_ana = phi(self.M.gridCC) q_ana = q_fun(self.M.gridCC) j_ana = j_fun(self.M.gridFx) #TODO: Check where our boundary conditions are CCx or Nx vecN = self.M.vectorNx vecC = self.M.vectorCCx phi_bc = phi(vecC[[0, -1]]) j_bc = j_fun(vecN[[0, -1]]) P, Pin, Pout = self.M.getBCProjWF([['dirichlet', 'neumann']]) Mc = self.M.getFaceInnerProduct() McI = utils.sdInv(self.M.getFaceInnerProduct()) V = utils.sdiag(self.M.vol) G = -Pin.T * Pin * self.M.faceDiv.T * V D = self.M.faceDiv j = McI * (G * xc_ana + P * phi_bc) q = V * D * Pin.T * Pin * j + V * D * Pout.T * j_bc # Rearrange if we know q to solve for x A = V * D * Pin.T * Pin * McI * G rhs = V * q_ana - V * D * Pin.T * Pin * McI * P * phi_bc - V * D * Pout.T * j_bc # A = D*McI*G # rhs = q_ana - D*McI*P*phi_bc if self.myTest == 'j': err = np.linalg.norm((Pin * j - Pin * j_ana), np.inf) elif self.myTest == 'q': err = np.linalg.norm((q - V * q_ana), np.inf) elif self.myTest == 'xc': #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol=1e-6) err = np.linalg.norm((xc - xc_ana), np.inf) if info > 0: print('Solve does not work well') print('ACCURACY', np.linalg.norm(utils.mkvc(A * xc) - rhs)) elif self.myTest == 'xcJ': #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol=1e-6) j = McI * (G * xc + P * phi_bc) err = np.linalg.norm((Pin * j - Pin * j_ana), np.inf) if info > 0: print('Solve does not work well') print('ACCURACY', np.linalg.norm(utils.mkvc(A * xc) - rhs)) return err
def _getInnerProduct(self, projType, prop=None, invProp=False, invMat=False, doFast=True): """get the inner product matrix Parameters ---------- str : projType 'F' for faces 'E' for edges numpy.ndarray : prop material property (tensor properties are possible) at each cell center (nC, (1, 3, or 6)) bool : invProp inverts the material property bool : invMat inverts the matrix bool : doFast do a faster implementation if available. Returns ------- scipy.sparse.csr_matrix M, the inner product matrix (nE, nE) """ assert projType in ['F', 'E'], "projType must be 'F' for faces or 'E' for edges" fast = None if hasattr(self, '_fastInnerProduct') and doFast: fast = self._fastInnerProduct(projType, prop=prop, invProp=invProp, invMat=invMat) if fast is not None: return fast if invProp: prop = invPropertyTensor(self, prop) tensorType = TensorType(self, prop) Mu = makePropertyTensor(self, prop) Ps = self._getInnerProductProjectionMatrices(projType, tensorType) A = np.sum([P.T * Mu * P for P in Ps]) if invMat and tensorType < 3: A = sdInv(A) elif invMat and tensorType == 3: raise Exception('Solver needed to invert A.') return A
def getError(self): #Test function phi = lambda x: np.cos(np.pi * x) j_fun = lambda x: -np.pi * np.sin(np.pi * x) q_fun = lambda x: -(np.pi**2) * np.cos(np.pi * x) xc_ana = phi(self.M.gridCC) q_ana = q_fun(self.M.gridCC) j_ana = j_fun(self.M.gridFx) #TODO: Check where our boundary conditions are CCx or Nx # vec = self.M.vectorNx vec = self.M.vectorCCx phi_bc = phi(vec[[0, -1]]) j_bc = j_fun(vec[[0, -1]]) P, Pin, Pout = self.M.getBCProjWF([['dirichlet', 'dirichlet']]) Mc = self.M.getFaceInnerProduct() McI = utils.sdInv(self.M.getFaceInnerProduct()) V = utils.sdiag(self.M.vol) G = -Pin.T * Pin * self.M.faceDiv.T * V D = self.M.faceDiv j = McI * (G * xc_ana + P * phi_bc) q = V * D * Pin.T * Pin * j + V * D * Pout.T * j_bc # Rearrange if we know q to solve for x A = V * D * Pin.T * Pin * McI * G rhs = V * q_ana - V * D * Pin.T * Pin * McI * P * phi_bc - V * D * Pout.T * j_bc # A = D*McI*G # rhs = q_ana - D*McI*P*phi_bc if self.myTest == 'j': err = np.linalg.norm((j - j_ana), np.inf) elif self.myTest == 'q': err = np.linalg.norm((q - V * q_ana), np.inf) elif self.myTest == 'xc': #TODO: fix the null space solver = SolverCG(A, maxiter=1000) xc = solver * (rhs) print('ACCURACY', np.linalg.norm(utils.mkvc(A * xc) - rhs)) err = np.linalg.norm((xc - xc_ana), np.inf) elif self.myTest == 'xcJ': #TODO: fix the null space xc = Solver(A) * (rhs) print(np.linalg.norm(utils.mkvc(A * xc) - rhs)) j = McI * (G * xc + P * phi_bc) err = np.linalg.norm((j - j_ana), np.inf) return err
def getError(self): #Test function phi = lambda x: np.cos(0.5 * np.pi * x[:, 0]) * np.cos(0.5 * np.pi * x[:, 1]) j_funX = lambda x: -0.5 * np.pi * np.sin( 0.5 * np.pi * x[:, 0]) * np.cos(0.5 * np.pi * x[:, 1]) j_funY = lambda x: -0.5 * np.pi * np.cos( 0.5 * np.pi * x[:, 0]) * np.sin(0.5 * np.pi * x[:, 1]) q_fun = lambda x: -2 * ((0.5 * np.pi)**2) * phi(x) xc_ana = phi(self.M.gridCC) q_ana = q_fun(self.M.gridCC) jX_ana = j_funX(self.M.gridFx) jY_ana = j_funY(self.M.gridFy) j_ana = np.r_[jX_ana, jY_ana] #TODO: Check where our boundary conditions are CCx or Nx cxm, cxp, cym, cyp = self.M.cellBoundaryInd fxm, fxp, fym, fyp = self.M.faceBoundaryInd gBFx = self.M.gridFx[(fxm | fxp), :] gBFy = self.M.gridFy[(fym | fyp), :] gBCx = self.M.gridCC[(cxm | cxp), :] gBCy = self.M.gridCC[(cym | cyp), :] phi_bc = phi(np.r_[gBCx, gBCy]) j_bc = np.r_[j_funX(gBFx), j_funY(gBFy)] # P = sp.csr_matrix(([-1,1],([0,self.M.nF-1],[0,1])), shape=(self.M.nF, 2)) P, Pin, Pout = self.M.getBCProjWF([['dirichlet', 'neumann'], ['dirichlet', 'neumann']]) Mc = self.M.getFaceInnerProduct() McI = utils.sdInv(self.M.getFaceInnerProduct()) V = utils.sdiag(self.M.vol) G = -Pin.T * Pin * self.M.faceDiv.T * V D = self.M.faceDiv j = McI * (G * xc_ana + P * phi_bc) q = V * D * Pin.T * Pin * j + V * D * Pout.T * j_bc # Rearrange if we know q to solve for x A = V * D * Pin.T * Pin * McI * G rhs = V * q_ana - V * D * Pin.T * Pin * McI * P * phi_bc - V * D * Pout.T * j_bc if self.myTest == 'j': err = np.linalg.norm((Pin * j - Pin * j_ana), np.inf) elif self.myTest == 'q': err = np.linalg.norm((q - V * q_ana), np.inf) elif self.myTest == 'xc': #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol=1e-6) err = np.linalg.norm((xc - xc_ana), np.inf) if info > 0: print('Solve does not work well') print('ACCURACY', np.linalg.norm(utils.mkvc(A * xc) - rhs)) elif self.myTest == 'xcJ': #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol=1e-6) j = McI * (G * xc + P * phi_bc) err = np.linalg.norm((Pin * j - Pin * j_ana), np.inf) if info > 0: print('Solve does not work well') print('ACCURACY', np.linalg.norm(utils.mkvc(A * xc) - rhs)) return err
def _fastInnerProduct( self, projType, prop=None, invProp=False, invMat=False ): """ Fast version of getFaceInnerProduct. This does not handle the case of a full tensor prop. :param numpy.array prop: material property (tensor properties are possible) at each cell center (nC, (1, 3, or 6)) :param str projType: 'E' or 'F' :param bool returnP: returns the projection matrices :param bool invProp: inverts the material property :param bool invMat: inverts the matrix :rtype: scipy.sparse.csr_matrix :return: M, the inner product matrix (nF, nF) """ assert projType in ['F', 'E'], ( "projType must be 'F' for faces or 'E' for edges" ) if prop is None: prop = np.ones(self.nC) if invProp: prop = 1./prop if utils.isScalar(prop): prop = prop*np.ones(self.nC) # number of elements we are averaging (equals dim for regular # meshes, but for cyl, where we use symmetry, it is 1 for edge # variables and 2 for face variables) if self._meshType == 'CYL': n_elements = np.sum(getattr(self, 'vn'+projType).nonzero()) else: n_elements = self.dim # Isotropic? or anisotropic? if prop.size == self.nC: Av = getattr(self, 'ave'+projType+'2CC') Vprop = self.vol * utils.mkvc(prop) M = n_elements * utils.sdiag(Av.T * Vprop) elif prop.size == self.nC*self.dim: Av = getattr(self, 'ave'+projType+'2CCV') # if cyl, then only certain components are relevant due to symmetry # for faces, x, z matters, for edges, y (which is theta) matters if self._meshType == 'CYL': if projType == 'E': prop = prop[:, 1] # this is the action of a projection mat elif projType == 'F': prop = prop[:, [0, 2]] V = sp.kron(sp.identity(n_elements), utils.sdiag(self.vol)) M = utils.sdiag(Av.T * V * utils.mkvc(prop)) else: return None if invMat: return utils.sdInv(M) else: return M