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