SimPEG.regularization.SmoothnessSecondOrder#
- class SimPEG.regularization.SmoothnessSecondOrder(mesh, orientation='x', reference_model_in_smooth=False, **kwargs)[source]#
Bases:
SmoothnessFirstOrder
Second-order smoothness (flatness) least-squares regularization.
SmoothnessSecondOrder
regularization is used to ensure that values in the recovered model have small second-order spatial derivatives. When a reference model is included, the regularization preserves second-order smoothness within the reference model along the direction specified (x, y or z). Optionally, custom cell weights can be used to control the degree of smoothness being enforced throughout different regions the model.See the Notes section below for a comprehensive description.
- Parameters:
- mesh
discretize.base.BaseMesh
mesh
The mesh on which the regularization is discretized.
- orientation{‘x’, ‘y’, ‘z’}
The direction along which smoothness is enforced.
- active_cells
None
, (n_cells
, )numpy.ndarray
of
bool Boolean array defining the set of
RegularizationMesh
cells that are active in the inversion. IfNone
, all cells are active.- mapping
None
,SimPEG.maps.BaseMap
The mapping from the model parameters to the active cells in the inversion. If
None
, the mapping is the identity map.- reference_model
None
, (n_param
, )numpy.ndarray
Reference model. If
None
, the reference model in the inversion is set to the starting model. To include the reference model in the regularization, the reference_model_in_smooth property must be set toTrue
.- reference_model_in_smoothbool,
optional
Whether to include the reference model in the smoothness regularization.
- units
None
,str
Units for the model parameters. Some regularization classes behave differently depending on the units; e.g. ‘radian’.
- weights
None
,dict
Weight multipliers to customize the least-squares function. Each key points to a (n_cells, ) numpy.ndarray that is defined on the
regularization.RegularizationMesh
.
- mesh
Notes
We define the regularization function (objective function) for second-order smoothness along the x-direction as:
\[\phi (m) = \int_\Omega \, w(r) \, \bigg [ \frac{\partial^2 m}{\partial x^2} \bigg ]^2 \, dv\]where \(m(r)\) is the model and \(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 expressed in linear form as:
\[\phi (\mathbf{m}) = \sum_i \tilde{w}_i \, \bigg | \, \frac{\partial^2 m_i}{\partial x^2} \, \bigg |^2\]where \(m_i \in \mathbf{m}\) are the discrete model parameter values defined on the mesh 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. This is equivalent to an objective function of the form:
\[\phi (\mathbf{m}) = \big \| \mathbf{W \, L_x \, m } \, \big \|^2\]where
\(\mathbf{L_x}\) is a second-order derivative operator with respect to \(x\), and
\(\mathbf{W}\) is the weighting matrix.
Reference model in smoothness:
Second-order smoothness within a discrete reference model \(\mathbf{m}^{(ref)}\) can be preserved by including the reference model the smoothness regularization function. In this case, the objective function becomes:
\[\phi (\mathbf{m}) = \Big \| \mathbf{W L_x} \big [ \mathbf{m} - \mathbf{m}^{(ref)} \big ] \Big \|^2\]This functionality is used by setting a reference model with the reference_model property, and by setting the reference_model_in_smooth parameter to
True
.Custom weights and the weighting matrix:
Let \(\mathbf{w_1, \; w_2, \; w_3, \; ...}\) each represent an optional set of custom cell weights. The weighting applied within the objective function is given by:
\[\mathbf{\tilde{w}} = \mathbf{v} \odot \prod_j \mathbf{w_j}\]where \(\mathbf{v}\) are the cell volumes. The weighting matrix used to apply the weights 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 an (n_cells, )numpy.ndarray
. The weights can be set all at once during instantiation with the weights keyword argument as follows:>>> reg = SmoothnessSecondOrder(mesh, weights={'weights_1': array_1, 'weights_2': array_2})
or set after instantiation using the set_weights method:
>>> reg.set_weights(weights_1=array_1, weights_2=array_2})
Attributes
Weighting matrix.
Active cells defined on the regularization mesh.
Partial cell gradient operator.
Deprecated property for 'volume' and user defined weights.
active_cells.indActive has been deprecated.
Mapping from the inversion model parameters to the regularization mesh.
The model parameters.
reference_model.mref has been deprecated.
Number of model parameters.
Direction along which smoothness is enforced.
The parent objective function
Reference model.
regularization_mesh.regmesh has been deprecated.
Regularization mesh.
Units for the model parameters.
Return the keys for the existing cell weights
reference_model_in_smooth
Methods
__call__
(m)Evaluate the regularization function for the model provided.
deriv
(m)Gradient of the regularization function evaluated for the model provided.
deriv2
(m[, v])Hessian of the regularization function evaluated for the model provided.
f_m
(m)Evaluate the regularization kernel function.
f_m_deriv
(m)Derivative of the regularization kernel function.
get_weights
(key)Cell weights for a given key.
map_class
alias of
IdentityMap
remove_weights
(key)Removes the weights for the key provided.
set_weights
(**weights)Adds (or updates) the specified weights to the regularization.
test
([x, num])Run a convergence test on both the first and second derivatives.