SimPEG.regularization.WeightedLeastSquares#

class SimPEG.regularization.WeightedLeastSquares(mesh, active_cells=None, alpha_s=1.0, alpha_x=None, alpha_y=None, alpha_z=None, alpha_xx=0.0, alpha_yy=0.0, alpha_zz=0.0, length_scale_x=None, length_scale_y=None, length_scale_z=None, mapping=None, reference_model=None, reference_model_in_smooth=False, weights=None, **kwargs)[source]#

Bases: SimPEG.objective_function.ComboObjectiveFunction

Weighted least squares measure on model smallness and smoothness.

L2 regularization with both smallness and smoothness (first order derivative) contributions.

Parameters

meshdiscretize.base.BaseMesh: The mesh on which the model parameters are defined. This is used for constructing difference operators for the smoothness terms.
active_cellsarray_like of bool or int, optional: List of active cell indices, or a mesh.n_cells boolean array describing active cells.
alpha_sfloat, optional: Smallness weight
alpha_x, alpha_y, alpha_zfloat or None, optional: First order smoothness weights for the respective dimensions. None implies setting these weights using the length_scale parameters.
alpha_xx, alpha_yy, alpha_zzfloat, optional: Second order smoothness weights for the respective dimensions.
length_scale_x, length_scale_y, length_scale_zfloat, optional: First order smoothness length scales for the respective dimensions.
mappingSimPEG.maps.IdentityMap, optional: A mapping to apply to the model before regularization.
reference_modelarray_like, optional
reference_model_in_smoothbool, optional: Whether to include the reference model in the smoothness terms.
weightsNone, array_like, or dict or array_like, optional: User defined weights. It is recommended to interact with weights using the get_weights, set_weights functionality.

Notes

The function defined here approximates:

ϕ_{m} (m) = α_{s} ‖ W_{s} (m - m_{ref}) ‖^{2} + α_{x} ‖ W_{x} \frac{\partial}{\partial x} (m - m_{ref}) ‖^{2} + α_{y} ‖ W_{y} \frac{\partial}{\partial y} (m - m_{ref}) ‖^{2} + α_{z} ‖ W_{z} \frac{\partial}{\partial z} (m - m_{ref}) ‖^{2}

Note if the key word argument reference_model_in_smooth is False, then mref is not included in the smoothness contribution.

If length scales are used to set the smoothness weights, alphas are respectively set internally using: >>> alpha_x = (length_scale_x * min(mesh.edge_lengths)) ** 2

Attributes

`active_cells`	Indices of active cells in the mesh
`alpha_s`	smallness weight
`alpha_x`	weight for the first x-derivative
`alpha_xx`	weight for the second x-derivative
`alpha_y`	weight for the first y-derivative
`alpha_yy`	weight for the second y-derivative
`alpha_z`	weight for the first z-derivative
`alpha_zz`	weight for the second z-derivative
`indActive`	active_cells.indActive has been deprecated.
`length_scale_x`	Constant multiplier of the base length scale on model gradients along x.
`length_scale_y`	Constant multiplier of the base length scale on model gradients along y.
`length_scale_z`	Constant multiplier of the base length scale on model gradients along z.
`mapping`	Mapping applied to the model values
`model`	Physical property model
`mref`	reference_model.mref has been deprecated.
`multipliers`	Factors that multiply the objective functions that are summed together to build to composite regularization
`nP`	number of model parameters
`reference_model`	Reference physical property model
`reference_model_in_smooth`	Use the reference model in the model gradient penalties.
`regularization_mesh`	Regularization mesh
`units`	Specify the model units.