pygimli.frameworks

Unified and method independent inversion frameworks.

Overview

Functions

fit(funct, data[, err])	Generic function fitter.
harmfit(y[, x, error, nc, resample, window, ...])	GIMLi-based curve-fit by harmonic functions.
harmfitNative(y[, x, nc, xc, error, err])	Python-based curve-fit by harmonic functions.
lineSearch(inv, dm[, method])	Carry out line search.
resolutionMatrix(inv[, returnRD])	Formal model (and data) resolution matrix (MCM) from inversion.

Classes

Block1DInversion([fop])	Inversion of layered models (including layer thickness).
Block1DModelling([nPara, nLayers])	General forward operator for 1D layered models.
HarmFunctor(A, coeff, xmin, xSpan)	Functor for harmonic functions plus offset and drift.
Inversion	alias of ClassicInversion
JointModelling(fopList)	Cumulative (joint) forward operator.
JointPetroInversionManager(petros, mgrs)	Joint inversion targeting at the same parameter through petrophysics.
LCInversion([fop])	Quasi-2D Laterally constrained inversion (LCI) framework.
LCModelling(fop, **kwargs)	2D Laterally constrained (LC) modelling.
LSQRInversion(*args, **kwargs)	LSQR solver based inversion
LinearModelling(A)	Modelling class for linearized problems with a given matrix.
MarquardtInversion([fop])	Marquardt scheme, i.e. local damping with decreasing strength.
MeshMethodManager(**kwargs)	Method manager for mesh-based modelling and inversion.
MeshModelling(**kwargs)	Modelling class with a mesh discretization.
MethodManager([fop, fw, data])	General manager to maintenance a measurement method.
MethodManager1d([fop])	Method Manager base class for managers on a 1d discretization.
Modelling(**kwargs)	Abstract Forward Operator.
MultiFrameModelling(modellingOperator[, scalef])	Full frame (multiple fop parallel) forward modelling.
ParameterInversionManager([funct, fop])	Framework to invert unconstrained parameters.
ParameterModelling([funct])	Model with symbolic parameter names instead of numbers.
PetroInversionManager(petro[, mgr])	Class for petrophysical inversion (s.
PetroModelling(fop, petro, **kwargs)	Combine petrophysical relation with the modelling class f(p).
PriorModelling([mesh, pos])	Forward operator for grabbing values out of a mesh (prior data).

Functions

pygimli.frameworks.fit(funct, data, err=None, **kwargs)

Generic function fitter.

Fit data to a given function.

Parameters:

• funct (callable) – Function with the first argmument as data space, e.g., x, t, f, Nr. .. Any following arguments are the parameters to be fit. Except if a verbose flag if used.

• data (iterable (float)) – Data values

• err (iterable (float) [None]) – Data error values in %/100. Default is 1% if None are given.

• *dataSpace* (iterable) – Keyword argument of the data space of len(data). The name need to fit the first argument of funct.

Returns:

• model (array) – Fitted model parameter.

• response (array) – Model response.

Example

>>> import pygimli as pg
>>>
>>> func = lambda t, a, b: a*np.exp(b*t)
>>> t = np.linspace(1, 2, 20)
>>> data = func(t, 1.1, 2.2)
>>> model, response = pg.frameworks.fit(func, data, t=t)
>>> print(pg.core.round(model, 1e-5))
2 [1.1, 2.2]
>>> _ = pg.plt.plot(t, data, 'o', label='data')
>>> _ = pg.plt.plot(t, response, label='response')
>>> _ = pg.plt.legend()

pygimli.frameworks.harmfit(y, x=None, error=None, nc=42, resample=None, window=None, verbose=False, **kwargs)

GIMLi-based curve-fit by harmonic functions.

Parameters:

• y (1d-array) – values to be fitted

• x (1d-array(len(y))) – data abscissa data. default: [0 .. len(y))

• error (1d-array(len(y))) – error of y. default (absolute error = 0.01)

• nc (int) – Number of harmonic coefficients

• resample (1d-array) – resample y to x using fitting coeffients

• window (int) – just fit data inside window bounds

Returns:

• response (1d-array of len(resample) or len(x)) – smoothed values

• inv (pg.Inversion) – inversion instance, coefficients are in inv.model

pygimli.frameworks.harmfitNative(y, x=None, nc=None, xc=None, error=None, err=None)

Python-based curve-fit by harmonic functions.

Parameters:

• y (iterable) – values of a curve to be fitted

• x (iterable) – abscissa, if none [0..len(y))

• nc (int) – number of coefficients

• err (iterable) – absolute data error

• xc (iterable) – abscissa to predict y on (otherwise equal to x)

pygimli.frameworks.lineSearch(inv, dm, method='auto', **kwargs)

Carry out line search.

Optimize step length s such that m + s*dm is minimized.

Parameter

invpg.Inversion

Inversion instance

dmiterable

model update direction

methodstr [‘auto’]

Method to be used: ‘exact’ : function evaluation for every step ‘interp’ : linear interpolation of response ‘quad’ : fitting a parabola through 3 points ‘auto’: first try ‘inter’, then ‘quad’, else 0.1

tausarray [None]

array containing the tau values to test, alternatively:

tauminfloat [0.01]

minimum value

taumaxfloat [1]

maximum value

logScalebool [False]

use logarithmic scaling, otherwise linear

showbool [False]

show line search curve

pygimli.frameworks.resolutionMatrix(inv, returnRD=False)

Formal model (and data) resolution matrix (MCM) from inversion.

\[ \begin{align}\begin{aligned}\mathbf{R_M} = (\mathbf{J}^T\mathbf{D}^T\mathbf{D}\mathbf{J} + \alpha \mathbf{C}^T\mathbf{C})^{-1} \mathbf{J}^T\mathbf{D}^T\mathbf{D}\mathbf{J}\\\mathbf{R_D} = \mathbf{D}\mathbf{J} (\mathbf{J}^T\mathbf{D}^T\mathbf{D}\mathbf{J} + \alpha \mathbf{C}^T\mathbf{C})^{-1} \mathbf{J}^T\mathbf{D}^T\end{aligned}\end{align} \]

Parameters:

• inv (pg.Inversion) – pygimli inversion instance after inversion

• returnRD (bool [false]) – also return data resolution (information) matrix

Returns:

• RM (numpy.array) – model resolution matrix

• RD (numpy.array) – data resolution matrix

Examples using pygimli.frameworks.resolutionMatrix

Computing resolution properties

Computing resolution properties

Classes

class pygimli.frameworks.Block1DInversion(fop=None, **kwargs)

Bases: MarquardtInversion

Inversion of layered models (including layer thickness).

Variables:

nLayers (int)

__init__(fop=None, **kwargs)

fixLayers(fixLayers)

Fix layer thicknesses.

Parameters:

fixLayers (bool | [float]) – Fix all layers to the last value or set the fix layer thickness for all layers

run(dataVals, errorVals, nLayers=None, fixLayers=None, layerLimits=None, paraLimits=None, **kwargs)

Run inversion with given data and error vectors.

Parameters:

• nLayers (int [4]) – Number of layers.

• fixLayers (bool | [thicknesses]) – See: pygimli.modelling.Block1DInversion.fixLayers For fixLayers=None, preset or defaults are uses.

• layerLimits ([min, max]) – Limits the thickness off all layers. For layerLimits=None, preset or defaults are uses.

• paraLimits ([min, max] | [[min, max],...]) – Limits the range of the model parameter. If you have multiple parameters you can set them with a list of limits.

• **kwargs – Forwarded to the parent class. See: pygimli.modelling.MarquardtInversion

setForwardOperator(fop)

Set forward operator.

setLayerLimits(limits)

Set min and max layer thickness.

Parameters:

limits (False | [min, max])

setParaLimits(limits)

Set the limits for each parameter region.

class pygimli.frameworks.Block1DModelling(nPara=1, nLayers=4, **kwargs)

Bases: Modelling

General forward operator for 1D layered models.

Model space: [thickness_i, parameter_jk], with i = 0 - nLayers-1, j = (0 .. nLayers), k=(0 .. nPara)

__init__(nPara=1, nLayers=4, **kwargs)

Constructor.

Parameters:

• nLayers (int [4]) – Number of layers.

• nPara (int [1]) – Number of parameters per layer (e.g. nPara=2 for resistivity and phase)

drawData(ax, data, err=None, label=None, **kwargs)

Default data view.

Modelling creates the data and should know best how to draw them.

Probably ugly and you should overwrite it in your derived forward operator.

drawModel(ax, model, **kwargs)

Draw model into a given axis.

initModelSpace(nLayers)

Set number of layers for the 1D block model.

property nLayers

Number of layers.

property nPara

Number of parameters.

class pygimli.frameworks.HarmFunctor(A, coeff, xmin, xSpan)

Bases: object

Functor for harmonic functions plus offset and drift.

__init__(A, coeff, xmin, xSpan)

Initialize.

pygimli.frameworks.Inversion

alias of ClassicInversion

class pygimli.frameworks.JointModelling(fopList)

Bases: MeshModelling

Cumulative (joint) forward operator.

__init__(fopList)

Initialize with lists of forward operators.

createJacobian(model)

Fill the individual Jacobian matrices.

createStartModel(data)

Use inverse transformation to get m(p) for the starting model.

response(model)

Concatenate responses for all fops.

setData(data)

Distribute list of data to the forward operators.

setMesh(mesh, **kwargs)

Set the parameter mesh to all fops.

class pygimli.frameworks.JointPetroInversionManager(petros, mgrs)

Bases: MeshMethodManager

Joint inversion targeting at the same parameter through petrophysics.

This is just syntactic sugar for the combination of pygimli.frameworks.PetroModelling and pygimli.frameworks.JointModelling.

__init__(petros, mgrs)

Initialize with lists of managers and transformations.

checkData(data)

Collect data values.

checkError(err, data=None)

Collect error values.

invert(data, **kwargs)

Run inversion.

class pygimli.frameworks.LCInversion(fop=None, **kwargs)

Bases: ClassicInversion

Quasi-2D Laterally constrained inversion (LCI) framework.

__init__(fop=None, **kwargs)

prepare(dataVals, errorVals, nLayers=4, **kwargs)

Prepare inversion with given data and error vectors.

run(dataVals, errorVals, nLayers=4, **kwargs)

Run inversion with given data and error vectors.

class pygimli.frameworks.LCModelling(fop, **kwargs)

Bases: Modelling

2D Laterally constrained (LC) modelling.

2D Laterally constrained (LC) modelling based on BlockMatrices.

__init__(fop, **kwargs)

Parameters: fop class .

createDefaultStartModel(models)

Create default starting model.

createJacobian(par)

Create Jacobian matrix by creating individual Jacobians.

createParametrization(nSoundings, nLayers=4, nPar=1)

Create LCI mesh and suitable constraints informations.

Parameters:

• nLayers (int) – Numbers of depth layers

• nSoundings (int) – Numbers of 1D measurements to laterally constrain

• nPar (int) – Numbers of independent parameter types, e.g., nPar = 1 for VES (invert for resisitivies), nPar = 2 for VESC (invert for resisitivies and phases)

drawModel(ax, model, **kwargs)

Draw models as stitched 1D model section.

initJacobian(dataVals, nLayers, nPar=None)

Initialize Jacobian matrix.

Parameters:

dataVals (ndarray | RMatrix | list) – Data values of size (nSounding x Data per sounding). All data per sounding need to be equal in length. If they don’t fit into a matrix use list of sounding data.

initModelSpace(nLayers)

Initialize model space.

response(par)

Cut together forward responses of all soundings.

setDataBasis(**kwargs)

Set homogeneous data basis.

Set a common data basis to all forward operators. If you want individual you need to set them manually.

class pygimli.frameworks.LSQRInversion(*args, **kwargs)

Bases: ClassicInversion

LSQR solver based inversion

__init__(*args, **kwargs)

Init.

oneStep()

One inversion step.

setParameterConstraints(G, c, my=1.0)

Set parameter constraints G*p=c.

class pygimli.frameworks.LinearModelling(A)

Bases: Modelling

Modelling class for linearized problems with a given matrix.

__init__(A)

Initialize by storing the (reference to the) matrix.

createJacobian(model)

Do not compute a jacobian (linear).

property parameterCount

Define the number of parameters from the matrix size.

response(model)

Linearized forward modelling by matrix-vector product.

class pygimli.frameworks.MarquardtInversion(fop=None, **kwargs)

Bases: ClassicInversion

Marquardt scheme, i.e. local damping with decreasing strength.

__init__(fop=None, **kwargs)

run(dataVals, errorVals=None, **kwargs)

Run inversion with given data and error vectors.

Parameters:

• dataVals (iterable) – data vector

• errorVals (iterable) – error vector (relative errors), can also be computed from

• absoluteError (float | iterable) – absolute error in units of dataVals

• relativeError (float | iterable) – relative error related to dataVals

• **kwargs – Forwarded to the parent class. See: pygimli.modelling.Inversion

class pygimli.frameworks.MeshMethodManager(**kwargs)

Bases: MethodManager

Method manager for mesh-based modelling and inversion.

__init__(**kwargs)

Initialize by calling super methods.

Attribute

mesh: GIMLI::Mesh

Copy of the main mesh to be distributed to inversion and the fop. You can overwrite it with invert(mesh=mesh).

applyMesh(mesh, ignoreRegionManager=False, **kwargs)

Pass the mesh along to the forward operator.

coverage()

Coverage vector considering the logarithmic transformation.

createMesh(data=None, **kwargs)

Create default inversion mesh.

Inversion mesh for traveltime inversion does not need boundary region.

Parameters:

data (DataContainer) – Data container to read sensors from.

Keyword Arguments:

` (Forwarded to)

invert(data=None, mesh=None, startModel=None, **kwargs)

Run the full inversion.

Parameters:

• data (pg.DataContainer)

• mesh (GIMLI::Mesh [None])

• startModel (float | iterable [None]) – If set to None fop.createDefaultStartModel(dataValues) is called.

Keyword Arguments:

• zWeight (float [None]) – Set zWeight or use defaults from regionManager.

• correlationLengths ([float, float, float]) – Correlation lengths for geostatistical regularization

• dip (float) – rotation axis between first and last dimension (x and z)

• strike (float) – rotation axis between first and second dimension (x and y)

• limits ([float, float]) – lower and upper value bounds for logarithmic transformation

• Inversion.run (Al other are forwarded to)

Returns:

model – Model mapped for match the paraDomain Cell markers. The calculated model vector (unmapped) is in self.fw.model.

Return type:

array

property model

Inversion model.

property paraDomain

Parameter (inversion) domain mesh.

paraModel(model=None)

Give the model parameter regarding the parameter mesh.

setMesh(mesh, **kwargs)

Set a mesh and distribute it to the forward operator.

showFit(axs=None, **kwargs)

Show data and the inversion result model response.

standardizedCoverage(threshold=0.01)

Standardized coverage vector (0|1) using thresholding.

class pygimli.frameworks.MeshModelling(**kwargs)

Bases: Modelling

Modelling class with a mesh discretization.

__init__(**kwargs)

Initialize.

Variables:

• fop (pg.frameworks.Modelling)

• data (pg.DataContainer)

• modelTrans ([pg.trans.TransLog()])

Parameters:

**kwargs – fop : Modelling

createConstraints()

Create constraint matrix.

createFwdMesh_()

Create forward mesh.

createRefinedFwdMesh(mesh)

Refine the current mesh for higher accuracy.

This is called automatic when accessing self.mesh() so it ensures any effect of changing region properties (background, single).

drawModel(ax, model, **kwargs)

Draw the model as mesh-based distribution.

ensureContent()

Internal function to ensure there is a valid initialized mesh.

Initialization means the cell marker are recounted and/or there was a mesh refinement or boundary enlargement, all to fit the needs for the method-depending forward problem.

mesh()

Returns the currently used mesh.

property paraDomain

Return parameter (inverse) mesh.

paraModel(model)

Return parameter model, i.e. model mapped back with cell markers.

setCustomConstraints(C)

Set custom constraints matrix for lazy evaluation.

To remove them set it to ‘None’ again.

setDefaultBackground()

Set the lowest region to background if several exist.

setMesh(mesh, ignoreRegionManager=False)

Set mesh and specify whether region manager can be ignored.

setMeshPost(mesh)

Interface to be called when the mesh has been set successfully.

Might be overwritten by child classes.

class pygimli.frameworks.MethodManager(fop=None, fw=None, data=None, **kwargs)

Bases: object

General manager to maintenance a measurement method.

Method Manager are the interface to end-user interaction and can be seen as simple but complete application classes which manage all tasks of geophysical data processing.

The method manager holds one instance of a forward operator and an appropriate inversion framework to handle modelling and data inversion.

Method Manager also helps with data import and export, handle measurement data error estimation as well as model and data visualization.

Variables:

• verbose (bool) – Give verbose output.

• debug (bool) – Give debug output.

• fop (pygimli.frameworks.Modelling) – Forward Operator instance .. knows the physics. fop is initialized by pygimli.manager.MethodManager.initForwardOperator and calls a valid pygimli.manager.MethodManager.createForwardOperator method in any derived classes.

• inv (pygimli.frameworks.Inversion.) – Inversion framework instance .. knows the reconstruction approach. The attribute inv is initialized by default but can be changed overwriting pygimli.manager.MethodManager.initInversionFramework

__init__(fop=None, fw=None, data=None, **kwargs)

Initialize the class with given fop, inv and data.

applyData(data)

Pass the data to the forward operator.

checkData(data)

Overwrite for special checks to return data values.

checkError(err, dataVals=None)

Check and return relative error.

By default we assume ‘err’ as relative values. Overwrite in derived class if needed.

static createArgParser(dataSuffix='dat')

Create default argument parser.

TODO move this to some kind of app class

Create default argument parser for the following options:

-Q, –quiet -R, –robustData: options.robustData -B, –blockyModel: options.blockyModel -l, –lambda: options.lam -i, –maxIter: options.maxIter –depth: options.depth

createForwardOperator(**kwargs)

Mandatory interface for derived classes.

Here you need to specify which kind of forward operator FOP you want to use. This is called by any initForwardOperator() call.

Parameters:

**kwargs – Any arguments that are necessary for your FOP creation.

Returns:

Instance of any kind of pygimli.framework.Modelling.

Return type:

Modelling

createInversionFramework(**kwargs)

Create default Inversion framework.

Derived classes may overwrite this method.

Parameters:

**kwargs – Any arguments that are necessary for your creation.

Returns:

Instance of any kind of pygimli.framework.Inversion.

Return type:

Inversion

property data

property debug

Debug mode (extensive output).

estimateError(data, errLevel=0.01, absError=None)

Estimate data error.

Create an error of estimated measurement error. On default it returns an array of constant relative errors. More sophisticated error estimation should be done in specialized derived classes.

Parameters:

• data (iterable) – Data values for which the errors should be estimated.

• errLevel (float (0.01)) – Error level in percent/100 (i.e., 3% = 0.03).

• absError (float (None)) – Absolute error in the unit of the data.

Returns:

err – Returning array of size len(data)

Return type:

array

property fop

Forward operator.

property fw

Inversion framework.

property inv

Inversion instance.

invert(data=None, err=None, **kwargs)

Invert the data.

Invert the data by calling self.inv.run() with mandatory data and error values.

TODO

*need dataVals mandatory? what about already loaded data

Parameters:

• dataVals (iterable) – Data values to be inverted.

• errVals (iterable | float) – Error value for the given data. If errVals is float we assume this means to be a global relative error and force self.estimateError to be called.

load(fileName)

Load API, overwrite in derived classes.

property model

Inversion model.

postRun(*args, **kwargs)

Fcn to be called just after the inversion run.

preRun(*args, **kwargs)

Fcn to be called just before the inversion run starts.

reinitForwardOperator(**kwargs)

Reinitialize the forward operator.

Sometimes it can be useful to reinitialize the forward operator. Keyword arguments will be forwarded to ‘self.createForwardOperator’.

setData(data)

Set data and distribute it to the forward operator.

showData(data=None, ax=None, **kwargs)

Show the data.

Draw data values into a given axes or show the data values from the last run. Forwards on default to the self.fop.drawData function of the modelling operator. If there is no given function given, you have to override this method.

Parameters:

• ax (mpl axes) – Axes object to draw into. Create a new if its not given.

• data (iterable | pg.DataContainer) – Data values to be draw.

Return type:

ax, cbar

showFit(ax=None, **kwargs)

Show the last inversion data and response.

showModel(model, ax=None, **kwargs)

Show a model.

Draw model into a given axes or show inversion result from last run. Forwards on default to the self.fop.drawModel function of the modelling operator. If there is no function given, you have to override this method.

Parameters:

• ax (mpl axes) – Axes object to draw into. Create a new if its not given.

• model (iterable) – Model data to be draw.

Return type:

ax, cbar

showResult(model=None, ax=None, **kwargs)

Show the last inversion result.

Parameters:

• ax (mpl axes) – Axes object to draw into. Create a new if its not given.

• model (iterable [None]) – Model values to be draw. Default is self.model from the last run

Return type:

ax, cbar

showResultAndFit(**kwargs)

Call showResults and showFit.

Keyword Arguments:

• saveFig (str[None]) – If not None save figure.

• axs ([mpl.Axes]) – Give 3 axes and its plotted into them instead of creating 3 new.

simulate(model, **kwargs)

Run a simulation aka the forward task.

property verbose

Verbose output.

class pygimli.frameworks.MethodManager1d(fop=None, **kwargs)

Bases: MethodManager

Method Manager base class for managers on a 1d discretization.

__init__(fop=None, **kwargs)

Initialize with fop.

createInversionFramework(**kwargs)

Create inversion with block discretization.

invert(data=None, err=None, **kwargs)

Run inversion.

class pygimli.frameworks.Modelling(**kwargs)

Bases: ModellingBaseMT__

Abstract Forward Operator.

Abstract Forward Operator that is or can use a Modelling instance. Can be seen as some kind of proxy Forward Operator.

STy(y)

Right-hand side multiplication of Jacobian J.T*y.

By default, uses self.jacobian().transMult(x) Overwrite for efficient use with gradient-type inversion.

Sx(x)

Right-hand side multiplication of Jacobian J*x.

By default, uses self.jacobian().mult(x) Overwrite for efficient use with gradient-type inversion.

__init__(**kwargs)

Initialize.

Variables:

• fop (pg.frameworks.Modelling)

• data (pg.DataContainer)

• modelTrans ([pg.trans.TransLog()])

Parameters:

**kwargs – fop : Modelling

clearRegionProperties()

Clear all region parameter.

createDefaultStartModel(dataVals)

Create the default startmodel as the median of the data values.

createStartModel(dataVals=None)

Create the default startmodel as the median of the data values.

Overwriting might be a good idea. Its used by inversion to create a valid startmodel if there are no starting values from the regions.

property data

Return data.

drawData(ax, data, **kwargs)

Draw data into a given axis.

drawModel(ax, model, **kwargs)

Draw a model into a given axis.

ensureContent()

Whatever this is.

estimateError(data, **kwargs)

Create data error fallback when the data error is not known.

Should be implemented method-specific.

property fop

Forward operator.

initModelSpace(**kwargs)

TODO.

property modelTrans

Return model transformation.

property parameterCount

Return parameter count.

regionManager()

Region manager.

regionProperties(regionNr=None)

Return dictionary of all properties for region number regionNr.

setData(data)

Set data (actual version).

setDataContainer(data)

Set Data container.

setDataPost(data)

Called when the dataContainer has been set sucessfully.

setDataSpace(**kwargs)

Set data space, e.g., DataContainer, times, coordinates.

setInterRegionCoupling(region1, region2, weight=1.0)

Set the weighting for constraints across regions.

setRegionProperties(regionNr, **kwargs)

Set region properties. regionNr can be ‘*’ for all regions.

startModel=None, limits=None, trans=None, cType=None, zWeight=None, modelControl=None, background=None, fix=None, single=None, correlationLengths=None, dip=None, strike=None

Parameters:

• regionNr (int, [ints], '*') – Region number, list of numbers, or wildcard “*” for all.

• startModel (float) – starting model value

• limits ([float, float]) – lower and upper limit for value using a barrier transform

• trans (str) – transformation for model barrier: “log”, “cot”, “lin”

• cType (int) – constraint (regularization) type

• zWeight (float) – relative weight for vertical boundaries

• background (bool) – exclude region from inversion completely (prolongation)

• fix (float) – exclude region from inversion completely (fix to value)

• single (bool) – reduce region to one unknown

• correlationLengths ([floats]) – correlation lengths for geostatistical inversion (x’, y’, z’)

• dip (float [0]) – angle between x and x’ (first correlation length)

• strike (float [0]) – angle between y and y’ (second correlation length)

class pygimli.frameworks.MultiFrameModelling(modellingOperator, scalef=1.0, **ini)

Bases: MeshModelling

Full frame (multiple fop parallel) forward modelling.

__init__(modellingOperator, scalef=1.0, **ini)

Init class and jacobian matrix.

createConstraints(C=None)

Create constraint matrix (special type for this).

createDefaultStartModel()

Create standard starting model.

createJacobian(model)

Create Jacobian matrix.

createStartModel(dataVals)

Create a starting model from mean data values.

property parameterCount

Return number of parameters.

prepareJacobian()

Build up Jacobian block matrix (once the sizes are known).

response(model)

Forward response.

setData(data, modellingOperator=None, **ini)

Distribute the data containers amongst the fops.

setDefaultBackground()

Set the default background behaviour.

setMeshPost(mesh)

Set mesh to all forward operators.

class pygimli.frameworks.ParameterInversionManager(funct=None, fop=None, **kwargs)

Bases: MethodManager

Framework to invert unconstrained parameters.

__init__(funct=None, fop=None, **kwargs)

Inizialize instance.

createInversionFramework(**kwargs)

Create a Marquardt-type inversion framework instance.

invert(data=None, err=None, **kwargs)

Run inversion.

Parameters:

• limits ({str: [min, max]}) – Set limits for parameter by parameter name.

• startModel ({str: startModel}) – Set the start value for parameter by parameter name.

class pygimli.frameworks.ParameterModelling(funct=None, **kwargs)

Bases: Modelling

Model with symbolic parameter names instead of numbers.

__init__(funct=None, **kwargs)

Initialize, optionally with given function.

addParameter(name, id=None, **kwargs)

Add a parameter.

drawModel(ax, model)

Draw model.

property params

Return number of parameters.

response(params)

Compute and return model response.

setRegionProperties(k, **kwargs)

Set Region Properties by parameter name.

class pygimli.frameworks.PetroInversionManager(petro, mgr=None, **kwargs)

Bases: MeshMethodManager

Class for petrophysical inversion (s. Rücker et al. 2017).

__init__(petro, mgr=None, **kwargs)

Initialize instance with manager and petrophysical relation.

class pygimli.frameworks.PetroModelling(fop, petro, **kwargs)

Bases: MeshModelling

Combine petrophysical relation with the modelling class f(p).

Combine petrophysical relation \(p(m)\) with a modelling class \(f(p)\) to invert for the petrophysical model \(p\) instead of the geophysical model \(m\).

\(p\) be the petrophysical model, e.g., porosity, saturation, … \(m\) be the geophysical model, e.g., slowness, resistivity, …

__init__(fop, petro, **kwargs)

Save forward class and transformation, create Jacobian matrix.

createJacobian(model)

Fill the individual jacobian matrices.

J = dF(m) / dm = dF(m) / dp * dp / dm

createStartModel(data)

Use inverse transformation to get m(p) for the starting model.

property petro

Petrophysical model transformation.

response(model)

Use transformation to get p(m) and compute response f(p).

setDataPost(data)

Set data after init.

setMeshPost(mesh)

Set mesh after init.

class pygimli.frameworks.PriorModelling(mesh=None, pos=None, **kwargs)

Bases: MeshModelling

Forward operator for grabbing values out of a mesh (prior data).

__init__(mesh=None, pos=None, **kwargs)

Init with mesh and some positions that are converted into ids.

createJacobian(model)

Do nothing (linear).

createRefinedFwdMesh(mesh)

Create refined forward mesh: do nothing here to prevent this.

response(model)

Return values at the indexed cells.

setMesh(mesh)

Set mesh, save index vector and compute Jacobian.