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
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.0 / 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
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:
MI = self._fastInnerProduct(projType, prop, invProp=invProp, invMat=invMat)
if tensorType == 0:
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 = self.dim * Av.T * V * ones
elif invMat and invProp:
dMdprop = self.dim * Utils.sdiag(MI.diagonal()**2) * Av.T * V * ones * Utils.sdiag(1./prop**2)
if tensorType == 1:
Av = getattr(self, 'ave'+projType+'2CC')
V = Utils.sdiag(self.vol)
if not invMat and not invProp:
dMdprop = self.dim * Av.T * V
elif invMat and invProp:
dMdprop = self.dim * Utils.sdiag(MI.diagonal()**2) * Av.T * V * Utils.sdiag(1./prop**2)
if tensorType == 2: # anisotropic
Av = getattr(self, 'ave'+projType+'2CCV')
V = sp.kron(sp.identity(self.dim), Utils.sdiag(self.vol))
if not invMat and not invProp:
dMdprop = Av.T * V
elif invMat and invProp:
dMdprop = Utils.sdiag(MI.diagonal()**2) * Av.T * V * Utils.sdiag(1./prop**2)
if dMdprop is not None:
def innerProductDeriv(v=None):
if v is None:
print 'Depreciation Warning: TensorMesh.innerProductDeriv. You should be supplying a vector. Use: sdiag(u)*dMdprop'
return dMdprop
return Utils.sdiag(v) * dMdprop
return innerProductDeriv
else:
return None
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.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)
if prop.size == self.nC:
Av = getattr(self, 'ave' + projType + '2CC')
Vprop = self.vol * Utils.mkvc(prop)
M = self.dim * Utils.sdiag(Av.T * Vprop)
elif prop.size == self.nC * self.dim:
Av = getattr(self, 'ave' + projType + '2CCV')
V = sp.kron(sp.identity(self.dim), 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
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.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)
if prop.size == self.nC:
Av = getattr(self, 'ave'+projType+'2CC')
Vprop = self.vol * Utils.mkvc(prop)
M = self.dim * Utils.sdiag(Av.T * Vprop)
elif prop.size == self.nC*self.dim:
Av = getattr(self, 'ave'+projType+'2CCV')
V = sp.kron(sp.identity(self.dim), 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
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:
MI = self._fastInnerProduct(projType,
prop,
invProp=invProp,
invMat=invMat)
if tensorType == 0:
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 = self.dim * Av.T * V * ones
elif invMat and invProp:
dMdprop = self.dim * Utils.sdiag(
MI.diagonal()**2) * Av.T * V * ones * Utils.sdiag(
1. / prop**2)
if tensorType == 1:
Av = getattr(self, 'ave' + projType + '2CC')
V = Utils.sdiag(self.vol)
if not invMat and not invProp:
dMdprop = self.dim * Av.T * V
elif invMat and invProp:
dMdprop = self.dim * Utils.sdiag(
MI.diagonal()**2) * Av.T * V * Utils.sdiag(1. / prop**2)
if tensorType == 2: # anisotropic
Av = getattr(self, 'ave' + projType + '2CCV')
V = sp.kron(sp.identity(self.dim), Utils.sdiag(self.vol))
if not invMat and not invProp:
dMdprop = Av.T * V
elif invMat and invProp:
dMdprop = Utils.sdiag(MI.diagonal()**
2) * Av.T * V * Utils.sdiag(1. / prop**2)
if dMdprop is not None:
def innerProductDeriv(v=None):
if v is None:
print 'Depreciation Warning: TensorMesh.innerProductDeriv. You should be supplying a vector. Use: sdiag(u)*dMdprop'
return dMdprop
return Utils.sdiag(v) * dMdprop
return innerProductDeriv
else:
return None
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 _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