def Wsmooth(self): """Full smoothness regularization matrix W""" if getattr(self, "_Wsmooth", None) is None: wlist = (self.Wx,) if self.regmesh.dim > 1: wlist += (self.Wy,) if self.regmesh.dim > 2: wlist += (self.Wz,) self._Wsmooth = sp.vstack(wlist) return self._Wsmooth
def Wsmooth(self): """Full smoothness regularization matrix W""" if getattr(self, '_Wsmooth', None) is None: wlist = (self.Wx, ) if self.regmesh.dim > 1: wlist += (self.Wy, ) if self.regmesh.dim > 2: wlist += (self.Wz, ) self._Wsmooth = sp.vstack(wlist) return self._Wsmooth
def test_invXXXBlockDiagonal(self): a = [np.random.rand(5, 1) for i in range(4)] B = inv2X2BlockDiagonal(*a) A = sp.vstack((sp.hstack((sdiag(a[0]), sdiag(a[1]))), sp.hstack((sdiag(a[2]), sdiag(a[3]))))) Z2 = B*A - sp.identity(10) self.assertTrue(np.linalg.norm(Z2.todense().ravel(), 2) < TOL) a = [np.random.rand(5, 1) for i in range(9)] B = inv3X3BlockDiagonal(*a) A = sp.vstack((sp.hstack((sdiag(a[0]), sdiag(a[1]), sdiag(a[2]))), sp.hstack((sdiag(a[3]), sdiag(a[4]), sdiag(a[5]))), sp.hstack((sdiag(a[6]), sdiag(a[7]), sdiag(a[8]))))) Z3 = B*A - sp.identity(15) self.assertTrue(np.linalg.norm(Z3.todense().ravel(), 2) < TOL)
def test_invXXXBlockDiagonal(self): a = [np.random.rand(5, 1) for i in range(4)] B = inv2X2BlockDiagonal(*a) A = sp.vstack((sp.hstack( (sdiag(a[0]), sdiag(a[1]))), sp.hstack( (sdiag(a[2]), sdiag(a[3]))))) Z2 = B * A - sp.identity(10) self.assertTrue(np.linalg.norm(Z2.todense().ravel(), 2) < TOL) a = [np.random.rand(5, 1) for i in range(9)] B = inv3X3BlockDiagonal(*a) A = sp.vstack((sp.hstack((sdiag(a[0]), sdiag(a[1]), sdiag(a[2]))), sp.hstack((sdiag(a[3]), sdiag(a[4]), sdiag(a[5]))), sp.hstack((sdiag(a[6]), sdiag(a[7]), sdiag(a[8]))))) Z3 = B * A - sp.identity(15) self.assertTrue(np.linalg.norm(Z3.todense().ravel(), 2) < TOL)
def W(self): """Full regularization matrix W""" if getattr(self, "_W", None) is None: wlist = (self.Wsmall, self.Wsmooth) self._W = sp.vstack(wlist) return self._W
def _fastInnerProductDeriv(self, projType, prop, invProp=False, invMat=False): """ :param str projType: 'E' or 'F' :param TensorType tensorType: type of the tensor :param bool invProp: inverts the material property :param bool invMat: inverts the matrix :rtype: function :return: dMdmu, the derivative of the inner product matrix """ assert projType in ['F', 'E'], ("projType must be 'F' for faces or 'E'" " for edges") tensorType = Utils.TensorType(self, prop) dMdprop = None if invMat or invProp: MI = self._fastInnerProduct(projType, prop, invProp=invProp, invMat=invMat) # 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 if tensorType == 0: # isotropic, constant Av = getattr(self, 'ave'+projType+'2CC') V = Utils.sdiag(self.vol) ones = sp.csr_matrix((np.ones(self.nC), (range(self.nC), np.zeros(self.nC))), shape=(self.nC, 1)) if not invMat and not invProp: dMdprop = n_elements * Av.T * V * ones elif invMat and invProp: dMdprop = n_elements * (Utils.sdiag(MI.diagonal()**2) * Av.T * V * ones * Utils.sdiag(1./prop**2)) elif invProp: dMdprop = n_elements * Av.T * V * Utils.sdiag(- 1./prop**2) elif invMat: dMdprop = n_elements * (Utils.sdiag(- MI.diagonal()**2) * Av.T * V) elif tensorType == 1: # isotropic, variable in space Av = getattr(self, 'ave'+projType+'2CC') V = Utils.sdiag(self.vol) if not invMat and not invProp: dMdprop = n_elements * Av.T * V elif invMat and invProp: dMdprop = n_elements * (Utils.sdiag(MI.diagonal()**2) * Av.T * V * Utils.sdiag(1./prop**2)) elif invProp: dMdprop = n_elements * Av.T * V * Utils.sdiag(-1./prop**2) elif invMat: dMdprop = n_elements * (Utils.sdiag(- MI.diagonal()**2) * Av.T * V) elif tensorType == 2: # anisotropic Av = getattr(self, 'ave'+projType+'2CCV') V = sp.kron(sp.identity(self.dim), Utils.sdiag(self.vol)) if self._meshType == 'CYL': Zero = sp.csr_matrix((self.nC, self.nC)) Eye = sp.eye(self.nC) if projType == 'E': P = sp.hstack([Zero, Eye, Zero]) # print P.todense() elif projType == 'F': P = sp.vstack([sp.hstack([Eye, Zero, Zero]), sp.hstack([Zero, Zero, Eye])]) # print P.todense() else: P = sp.eye(self.nC*self.dim) if not invMat and not invProp: dMdprop = Av.T * P * V elif invMat and invProp: dMdprop = (Utils.sdiag(MI.diagonal()**2) * Av.T * P * V * Utils.sdiag(1./prop**2)) elif invProp: dMdprop = Av.T * P * V * Utils.sdiag(-1./prop**2) elif invMat: dMdprop = Utils.sdiag(- MI.diagonal()**2) * Av.T * P * V if dMdprop is not None: def innerProductDeriv(v=None): if v is None: warnings.warn("Depreciation Warning: " "TensorMesh.innerProductDeriv." " You should be supplying a vector. " "Use: sdiag(u)*dMdprop", FutureWarning) return dMdprop return Utils.sdiag(v) * dMdprop return innerProductDeriv else: return None
def W(self): """Full regularization matrix W""" if getattr(self, '_W', None) is None: wlist = (self.Wsmall, self.Wsmooth) self._W = sp.vstack(wlist) return self._W
def _fastInnerProductDeriv(self, projType, prop, invProp=False, invMat=False): """ :param str projType: 'E' or 'F' :param TensorType tensorType: type of the tensor :param bool invProp: inverts the material property :param bool invMat: inverts the matrix :rtype: function :return: dMdmu, the derivative of the inner product matrix """ assert projType in ["F", "E"], "projType must be 'F' for faces or 'E'" " for edges" tensorType = Utils.TensorType(self, prop) dMdprop = None if invMat or invProp: MI = self._fastInnerProduct(projType, prop, invProp=invProp, invMat=invMat) # 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 if tensorType == 0: # isotropic, constant Av = getattr(self, "ave" + projType + "2CC") V = Utils.sdiag(self.vol) ones = sp.csr_matrix((np.ones(self.nC), (range(self.nC), np.zeros(self.nC))), shape=(self.nC, 1)) if not invMat and not invProp: dMdprop = n_elements * Av.T * V * ones elif invMat and invProp: dMdprop = n_elements * ( Utils.sdiag(MI.diagonal() ** 2) * Av.T * V * ones * Utils.sdiag(1.0 / prop ** 2) ) elif invProp: dMdprop = n_elements * Av.T * V * Utils.sdiag(-1.0 / prop ** 2) elif invMat: dMdprop = n_elements * (Utils.sdiag(-MI.diagonal() ** 2) * Av.T * V) elif tensorType == 1: # isotropic, variable in space Av = getattr(self, "ave" + projType + "2CC") V = Utils.sdiag(self.vol) if not invMat and not invProp: dMdprop = n_elements * Av.T * V elif invMat and invProp: dMdprop = n_elements * (Utils.sdiag(MI.diagonal() ** 2) * Av.T * V * Utils.sdiag(1.0 / prop ** 2)) elif invProp: dMdprop = n_elements * Av.T * V * Utils.sdiag(-1.0 / prop ** 2) elif invMat: dMdprop = n_elements * (Utils.sdiag(-MI.diagonal() ** 2) * Av.T * V) elif tensorType == 2: # anisotropic Av = getattr(self, "ave" + projType + "2CCV") V = sp.kron(sp.identity(self.dim), Utils.sdiag(self.vol)) if self._meshType == "CYL": Zero = sp.csr_matrix((self.nC, self.nC)) Eye = sp.eye(self.nC) if projType == "E": P = sp.hstack([Zero, Eye, Zero]) # print(P.todense()) elif projType == "F": P = sp.vstack([sp.hstack([Eye, Zero, Zero]), sp.hstack([Zero, Zero, Eye])]) # print(P.todense()) else: P = sp.eye(self.nC * self.dim) if not invMat and not invProp: dMdprop = Av.T * P * V elif invMat and invProp: dMdprop = Utils.sdiag(MI.diagonal() ** 2) * Av.T * P * V * Utils.sdiag(1.0 / prop ** 2) elif invProp: dMdprop = Av.T * P * V * Utils.sdiag(-1.0 / prop ** 2) elif invMat: dMdprop = Utils.sdiag(-MI.diagonal() ** 2) * Av.T * P * V if dMdprop is not None: def innerProductDeriv(v=None): if v is None: warnings.warn( "Depreciation Warning: " "TensorMesh.innerProductDeriv." " You should be supplying a vector. " "Use: sdiag(u)*dMdprop", FutureWarning, ) return dMdprop return Utils.sdiag(v) * dMdprop return innerProductDeriv else: return None
def Pxxx(xEdge, yEdge, zEdge): self.number() xP = self._getEdgeP(xEdge, yEdge, zEdge) yP = self._getEdgeP(yEdge, xEdge, zEdge) zP = self._getEdgeP(zEdge, xEdge, yEdge) return sp.vstack((xP, yP, zP))
def Pxxx(xFace, yFace, zFace): self.number() xP = self._getFaceP(xFace, yFace, zFace) yP = self._getFaceP(yFace, xFace, zFace) zP = self._getFaceP(zFace, xFace, yFace) return sp.vstack((xP, yP, zP))
def Pxx(xEdge, yEdge): self.number() xP = self._getEdgeP(xEdge, yEdge, None) yP = self._getEdgeP(yEdge, xEdge, None) return sp.vstack((xP, yP))
def Pxx(xFace, yFace): self.number() xP = self._getFaceP(xFace, yFace, None) yP = self._getFaceP(yFace, xFace, None) return sp.vstack((xP, yP))