class SimPEG.regularization.CrossReferenceRegularization(mesh, ref_dir, active_cells=None, mapping=None, weights=None, **kwargs)[source]#

Bases: Smallness, BaseVectorRegularization

Cross reference regularization for models representing vector quantities.

CrossReferenceRegularization encourages the vectors in the recovered model to be oriented in the same directions as the vector in a reference vector model. The regularization function (objective function) constrains the inversion by penalizing the magnitude of the-cross product of the vector model with a reference vector model. The cross product, and therefore the objective function, is minimized when vectors in the model and reference vector model are parallel (or anti-parallel) to each other. And it is maximized when the vectors are perpendicular to each other. The reference vector model can be set using a single vector, or by defining a vector for each mesh cell.

meshdiscretize.base.BaseMesh, RegularizationMesh

The mesh defining the model discretization.

ref_dir(mesh.dim,) array_like or (mesh.dim, n_active) array_like

The reference direction model. This can be either a constant vector applied to every model cell, or different for every active model cell.

active_cellsindex_array, optional

Boolean array or an array of active indices indicating the active cells of the inversion domain mesh.

mappingSimPEG.maps.IdentityMap, optional

An optional linear mapping that would go from the model space to the space where the cross-product is enforced.

weightsdict of [str: array_like], optional

Any cell based weights for the regularization. Note if given a weight that is (n_cells, dim), meaning it is dependent on the vector component, it will compute the geometric mean of the component weights per cell and use that as a weight.


Arguments passed on to the parent classes: Smallness and BaseVectorRegularization.


Consider the case where the model is a vector quantity \(\vec{m}(r)\). The regularization function (objective function) for cross-reference regularization is given by:

\[\phi (\vec{m}) = \frac{1}{2} \int_\Omega \, \vec{w}(r) \, \cdot \, \Big [ \vec{m}(r) \, \times \, \vec{m}^{(ref)}(r) \Big ]^2 \, dv\]

where \(\vec{m}^{(ref)}(r)\) is the reference model vector and \(\vec{w}(r)\) is a user-defined weighting function.

For implementation within SimPEG, the regularization function and its variables must be discretized onto a mesh. The discretized approximation for the regularization function (objective function) is given by:

\[\phi (\vec{m}) \approx \frac{1}{2} \sum_i \tilde{w}_i \, \cdot \, \Big | \vec{m}_i \, \times \, \vec{m}_i^{(ref)} \Big |^2\]

where \(\tilde{m}_i \in \mathbf{m}\) are the model vectors at cell centers and \(\tilde{w}_i \in \mathbf{\tilde{w}}\) are amalgamated weighting constants that 1) account for cell dimensions in the discretization and 2) apply any user-defined weighting.

In practice, the model is a discrete vector of the form:

\[\begin{split}\mathbf{m} = \begin{bmatrix} \mathbf{m_p} \\ \mathbf{m_s} \\ \mathbf{m_t} \end{bmatrix}\end{split}\]

where \(\mathbf{m_p}\), \(\mathbf{m_s}\) and \(\mathbf{m_t}\) represent vector components in the primary, secondary and tertiary directions at cell centers, respectively. The cross product between \(\mathbf{m}\) and a similar reference vector \(\mathbf{m^{(ref)}}\) (set with ref_dir) is a linear operation of the form:

\[\begin{split}\mathbf{m} \times \mathbf{m^{ref}} = \mathbf{X m} = \begin{bmatrix} \mathbf{0} & -\boldsymbol{\Lambda_s} & \boldsymbol{\Lambda_t} \\ \boldsymbol{\Lambda_p} & \mathbf{0} & -\boldsymbol{\Lambda_t} \\ -\boldsymbol{\Lambda_p} & \boldsymbol{\Lambda_s} & \mathbf{0} \end{bmatrix} \! \begin{bmatrix} \mathbf{m_p} \\ \mathbf{m_s} \\ \mathbf{m_t} \end{bmatrix}\end{split}\]

where \(\mathbf{X}\) is a linear operator that applies the cross-product on \(\mathbf{m}\), \(\mathbf{W}\) is the weighting matrix, and:

\[\boldsymbol{\Lambda_j} = \textrm{diag} \Big ( \mathbf{m_j^{(ref)}} \Big ) \;\;\;\; \textrm{for} \; j=p,s,t\]

The discrete regularization function in linear form can ultimately be expressed as:

\[\phi (\mathbf{m}) = \frac{1}{2} \Big \| \mathbf{W X m} \, \Big \|^2\]

Custom weights and the weighting matrix:

Let \(\mathbf{w_1, \; w_2, \; w_3, \; ...}\) each represent an optional set of custom cell weights. Each individual set of cell weights acts independently on the the directional components of the cross-product and is a discrete vector of the form:

\[\begin{split}\mathbf{w_j} = \begin{bmatrix} \mathbf{w_p} \\ \mathbf{w_s} \\ \mathbf{w_t} \end{bmatrix}\end{split}\]

The weighting applied within the objective function is given by:

\[\mathbf{\tilde{w}} = \big ( \mathbf{e_3 \otimes v} ) \odot \prod_j \mathbf{w_j}\]


  • \(\mathbf{e_3}\) is a vector of ones of length 3,

  • \(\otimes\) is the Kronecker product, and

  • \(\mathbf{v}\) are the cell volumes.

The weighting matrix used to apply the weights in the regularization function is given by:

\[\mathbf{W} = \textrm{diag} \Big ( \, \mathbf{\tilde{w}}^{1/2} \Big )\]

Each set of custom cell weights is stored within a dict as a list of (n_cells, ) numpy.ndarray. The weights can be set all at once during instantiation with the weights keyword argument as follows:

>>> reg = CrossReferenceRegularization(
>>>     mesh, weights={'weights_1': array_1, 'weights_2': array_2}
>>> )

where array_1 and array_2 are (n_cells, dim) numpy.ndarray. Weights can also be set after instantiation using the set_weights method:

>>> reg.set_weights(weights_1=array_1, weights_2=array_2})

The default weights that account for cell dimensions in the regularization are accessed via:

>>> reg.get_weights('volume')



Weighting matrix.


The reference direction model.



Evaluate the regularization kernel function.


Derivative of the regularization kernel function.