pygimli.physics.ert

Direct current electromagnetics

This package contains tools, modelling operators, and managers for:

  • lightweight Electrical Resistivity Tomography (ERT)
  • Vertical Electric Sounding (VES)

Overview

Functions

createERTData(elecs[, schemeName]) Simple data creator for compatibility (advanced version in BERT).

Classes

ERTManager(**kwargs) Minimalistic ERT Manager for compatibility (advanced version in BERT)
ERTModelling([mesh, data, verbose]) Minimal Forward Operator for 2.5D Electrical resistivity Tomography.
VESCModelling(**kwargs)
Attributes:
VESManager(**kwargs) Vertical electrical sounding (VES) manager class.
VESModelling([ab2, mn2]) Vertical Electrical Sounding (VES) forward operator.

Functions

createERTData

pygimli.physics.ert.createERTData(elecs, schemeName='none', **kwargs)[source]

Simple data creator for compatibility (advanced version in BERT).

Classes

ERTManager

class pygimli.physics.ert.ERTManager(**kwargs)[source]

Minimalistic ERT Manager for compatibility (advanced version in BERT)

Methods

apparentData() Convert data into apparent data.
checkData() Check data validity.
createApparentData(data) Create apparent data (what the hack is this?)
createArgParser([dataSuffix]) Create argument parser for the manager.
createData(sensors, scheme) Create an empty data set.
createFOP([verbose]) Create forward operator working on refined mesh.
createFOP_([verbose]) Create forward operator working on refined mesh.
createInv(fop[, verbose, dosave]) Create inversion instance.
createInv_(fop[, verbose, dosave]) Create inversion instance, data- and model transformations.
createMesh(**kwargs) Create a mesh aka the parametrization.
dataToken() Token name for the data in a DataContainer.
dataVals(data) Return pure data values from a given DataContainer.
estimateError(data[, absoluteError, …]) Estimate error composed of an absolute and a relative part.
invert([data, vals, err, mesh]) Run the full inversion.
model() Return the actual model.
relErrorVals(data) Return pure data values from a given DataContainer.
saveResult([folder, size]) Save results in the specified folder.
setData(data) Set data container from outside.
setDataToken(token) Set the token name to identity the data in a DataContainer.
setMesh(mesh[, refine]) Set the internal mesh for this Manager.
setVerbose(verbose) Make the class verbose (put output to the console)
show(data[, values, axes, cMin, cMax, colorBar]) Forward the visualization.
showData([data, vals, ax]) Show mesh in given axes or in a new figure.
showMesh([ax]) Show mesh in given axes or in a new figure.
showResult([ax, cMin, cMax, logScale]) Show resulting vector.
simulate(mesh, res, scheme[, verbose]) Forward calculation vor given mesh, data and resistivity.
__init__(**kwargs)[source]

Constructor.

apparentData()

Convert data into apparent data.

checkData()

Check data validity.

createApparentData(data)[source]

Create apparent data (what the hack is this?)

static createArgParser(dataSuffix='dat')

Create argument parser for the manager.

createData(sensors, scheme)

Create an empty data set.

static createFOP(verbose=False)[source]

Create forward operator working on refined mesh.

createFOP_(verbose=False)

Create forward operator working on refined mesh.

createInv(fop, verbose=True, dosave=False)[source]

Create inversion instance.

createInv_(fop, verbose=True, dosave=False)

Create inversion instance, data- and model transformations.

createMesh(**kwargs)

Create a mesh aka the parametrization.

dataToken()

Token name for the data in a DataContainer.

dataVals(data)[source]

Return pure data values from a given DataContainer.

static estimateError(data, absoluteError=0.001, relativeError=0.001)

Estimate error composed of an absolute and a relative part.

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

Run the full inversion.

The data and error needed to be set before. The meshes will be created if necessary.

DOCUMENTME!!!

Parameters:
lam : float [20]

regularization parameter

zWeight : float [0.7]

relative vertical weight

maxIter : int [20]

maximum iteration number

robustdata : bool [False]

robust data reweighting using an L1 scheme (IRLS reweighting)

blockymodel : bool [False]

blocky model constraint using L1 reweighting roughness vector

startModelIsReference : bool [False]

startmodel is the reference model for the inversion

forwarded to createMesh
depth
quality
paraDX
maxCellArea
model()

Return the actual model.

relErrorVals(data)[source]

Return pure data values from a given DataContainer.

saveResult(folder=None, size=(16, 10), **kwargs)

Save results in the specified folder.

setData(data)

Set data container from outside.

setDataToken(token)

Set the token name to identity the data in a DataContainer.

setMesh(mesh, refine=True)

Set the internal mesh for this Manager.

Inject the mesh in the internal fop und inv.

Initialize RegionManager. For more than two regions the first is assumed to be background.

Optional the forward mesh can be refined for higher numerical accuracy.

Parameters:
DOCUMENTME!!!
setVerbose(verbose)

Make the class verbose (put output to the console)

show(data, values=None, axes=None, cMin=None, cMax=None, colorBar=1, **kwargs)

Forward the visualization.

showData(data=None, vals=None, ax=None)[source]

Show mesh in given axes or in a new figure.

showMesh(ax=None)

Show mesh in given axes or in a new figure.

showResult(ax=None, cMin=None, cMax=None, logScale=False, **kwargs)

Show resulting vector.

static simulate(mesh, res, scheme, verbose=False, **kwargs)[source]

Forward calculation vor given mesh, data and resistivity.

ERTModelling

class pygimli.physics.ert.ERTModelling(mesh=None, data=None, verbose=False)[source]

Minimal Forward Operator for 2.5D Electrical resistivity Tomography.

Methods

__call__((object)arg1, (object)model) C++ signature :
calcGeometricFactors(data) Calculate geometry factors for a given dataset.
clearConstraints((object)arg1) C++ signature :
clearJacobian((object)arg1) C++ signature :
constraints((object)arg1) C++ signature :
constraintsRef((object)arg1) C++ signature :
createConstraints((object)arg1) C++ signature :
createDefaultStartModel((object)arg1) C++ signature :
createJacobian(model) Create Jacobian matrix.
createMappedModel((object)arg1, …) Read only extrapolation of model values given per cell marker to values given per cell.
createRHS(mesh, elecs) Create right-hand side.
createRefinedForwardMesh((object)arg1 [, …) C++ signature :
createStartModel((object)arg1) C++ signature :
createStartVector((object)arg1) DEPRECATED use createStartModel
data((object)arg1) Return the associated data container.
deleteMesh((object)arg1) Delete the actual mesh.
getIntegrationWeights(rMin, rMax) Retrieve Gauss-Legende/Laguerre integration weights.
initConstraints((object)arg1) C++ signature :
initJacobian((object)arg1) C++ signature :
initRegionManager((object)arg1) C++ signature :
jacobian((object)arg1) Return the pointer to the Jacobian matrix associated with this forward operator.
jacobianRef((object)arg1) C++ signature :
mapModel((object)arg1, (object)model [, …) C++ signature :
mesh((object)arg1) C++ signature :
mixedBC(boundary, userData) Apply mixed boundary conditions.
multiThreadJacobian((object)arg1) Return number of threads used for Jacobian generation.
pointSource(cell, f, userData) Define function for the current source term.
region((object)arg1, (object)marker) Syntactic sugar for this->regionManager().region(marker).
regionManager((object)arg1) C++ signature :
regionManagerRef((object)arg1) C++ signature :
response(model) Solve forward task.
response_mt((object)arg1, (object)model [, …) C++ signature :
setConstraints((object)arg1, (object)C) C++ signature :
setData(data) Set a DataContainer.
setJacobian((object)arg1, (object)J) C++ signature :
setMesh(mesh[, ignoreRegionManager]) Set Mesh.
setMultiThreadJacobian((object)arg1, …) Set number of threads used for brute force Jacobian generation.
setRegionManager((object)arg1, (object)reg) C++ signature :
setStartModel((object)arg1, (object)startModel) C++ signature :
setThreadCount((object)arg1, (object)nThreads) Set the maximum number of allowed threads for MT calculation.
setVerbose((object)arg1, (object)verbose) Set verbose state.
solution((object)arg1) C++ signature :
startModel((object)arg1) C++ signature :
threadCount((object)arg1) Return the maximum number of allowed threads for MT calculation
uAnalytical(p, sourcePos, k) Calculates the analytical solution for the 2.5D geoelectrical problem.
verbose((object)arg1) Get verbose state.
createJacobian_mt  
responses  
__init__(mesh=None, data=None, verbose=False)[source]

Constructor, optionally with data container and mesh.

calcGeometricFactors(data)[source]

Calculate geometry factors for a given dataset.

clearConstraints((object)arg1) → object :
C++ signature :
void* clearConstraints(GIMLI::ModellingBase {lvalue})

clearConstraints( (object)arg1) -> object :

C++ signature :
void* clearConstraints(ModellingBase_wrapper {lvalue})
clearJacobian((object)arg1) → object :
C++ signature :
void* clearJacobian(GIMLI::ModellingBase {lvalue})

clearJacobian( (object)arg1) -> object :

C++ signature :
void* clearJacobian(ModellingBase_wrapper {lvalue})
constraints((object)arg1) → object :
C++ signature :
GIMLI::MatrixBase* constraints(GIMLI::ModellingBase {lvalue})

constraints( (object)arg1) -> object :

C++ signature :
GIMLI::MatrixBase* constraints(ModellingBase_wrapper {lvalue})

constraints( (object)arg1) -> object :

C++ signature :
GIMLI::MatrixBase* constraints(GIMLI::ModellingBase {lvalue})

constraints( (object)arg1) -> object :

C++ signature :
GIMLI::MatrixBase* constraints(ModellingBase_wrapper {lvalue})
constraintsRef((object)arg1) → object :
C++ signature :
GIMLI::SparseMapMatrix<double, unsigned long> {lvalue} constraintsRef(GIMLI::ModellingBase {lvalue})

constraintsRef( (object)arg1) -> object :

C++ signature :
GIMLI::SparseMapMatrix<double, unsigned long> {lvalue} constraintsRef(GIMLI::ModellingBase {lvalue})
createConstraints((object)arg1) → object :
C++ signature :
void* createConstraints(GIMLI::ModellingBase {lvalue})

createConstraints( (object)arg1) -> object :

C++ signature :
void* createConstraints(ModellingBase_wrapper {lvalue})
createDefaultStartModel((object)arg1) → object :
C++ signature :
GIMLI::Vector<double> createDefaultStartModel(GIMLI::ModellingBase {lvalue})

createDefaultStartModel( (object)arg1) -> object :

C++ signature :
GIMLI::Vector<double> createDefaultStartModel(ModellingBase_wrapper {lvalue})
createJacobian(model)[source]

Create Jacobian matrix.

createJacobian_mt(model, resp)
createMappedModel((object)arg1, (object)model[, (object)background=-1]) → object :

Read only extrapolation of model values given per cell marker to values given per cell. Exterior values will be set to background or prolongated for background = -1.

C++ signature :
GIMLI::Vector<double> createMappedModel(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double> [,double=-1])
createRHS(mesh, elecs)[source]

Create right-hand side.

createRefinedForwardMesh((object)arg1[, (object)refine=True[, (object)pRefine=False]]) → object :
C++ signature :
void* createRefinedForwardMesh(GIMLI::ModellingBase {lvalue} [,bool=True [,bool=False]])
createStartModel((object)arg1) → object :
C++ signature :
GIMLI::Vector<double> createStartModel(GIMLI::ModellingBase {lvalue})
createStartVector((object)arg1) → object :

DEPRECATED use createStartModel

C++ signature :
GIMLI::Vector<double> createStartVector(GIMLI::ModellingBase {lvalue})
data((object)arg1) → object :

Return the associated data container.

C++ signature :
GIMLI::DataContainer {lvalue} data(GIMLI::ModellingBase {lvalue})
deleteMesh((object)arg1) → object :

Delete the actual mesh.

C++ signature :
void* deleteMesh(GIMLI::ModellingBase {lvalue})
getIntegrationWeights(rMin, rMax)[source]

Retrieve Gauss-Legende/Laguerre integration weights.

initConstraints((object)arg1) → object :
C++ signature :
void* initConstraints(GIMLI::ModellingBase {lvalue})

initConstraints( (object)arg1) -> object :

C++ signature :
void* initConstraints(ModellingBase_wrapper {lvalue})
initJacobian((object)arg1) → object :
C++ signature :
void* initJacobian(GIMLI::ModellingBase {lvalue})

initJacobian( (object)arg1) -> object :

C++ signature :
void* initJacobian(ModellingBase_wrapper {lvalue})
initRegionManager((object)arg1) → object :
C++ signature :
void* initRegionManager(GIMLI::ModellingBase {lvalue})
jacobian((object)arg1) → object :

Return the pointer to the Jacobian matrix associated with this forward operator.

C++ signature :
GIMLI::MatrixBase* jacobian(GIMLI::ModellingBase {lvalue})
jacobian( (object)arg1) -> object :

Return the pointer to the Jacobian matrix associated with this forward operator.

C++ signature :
GIMLI::MatrixBase* jacobian(GIMLI::ModellingBase {lvalue})
jacobianRef((object)arg1) → object :
C++ signature :
GIMLI::Matrix<double> {lvalue} jacobianRef(GIMLI::ModellingBase {lvalue})

jacobianRef( (object)arg1) -> object :

C++ signature :
GIMLI::Matrix<double> {lvalue} jacobianRef(GIMLI::ModellingBase {lvalue})
mapModel((object)arg1, (object)model[, (object)background=0]) → object :
C++ signature :
void* mapModel(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double> [,double=0])
mesh((object)arg1) → object :
C++ signature :
GIMLI::Mesh* mesh(GIMLI::ModellingBase {lvalue})
mixedBC(boundary, userData)[source]

Apply mixed boundary conditions.

multiThreadJacobian((object)arg1) → object :

Return number of threads used for Jacobian generation.

C++ signature :
unsigned long multiThreadJacobian(GIMLI::ModellingBase {lvalue})
pointSource(cell, f, userData)[source]

Define function for the current source term.

\(\delta(x-pos), \int f(x) \delta(x-pos)=f(pos)=N(pos)\)
Right-hand-side entries will be shape functions(pos)
region((object)arg1, (object)marker) → object :

Syntactic sugar for this->regionManager().region(marker).

C++ signature :
GIMLI::Region* region(GIMLI::ModellingBase {lvalue},int)
regionManager((object)arg1) → object :
C++ signature :
GIMLI::RegionManager regionManager(GIMLI::ModellingBase {lvalue})

regionManager( (object)arg1) -> object :

C++ signature :
GIMLI::RegionManager {lvalue} regionManager(GIMLI::ModellingBase {lvalue})
regionManagerRef((object)arg1) → object :
C++ signature :
GIMLI::RegionManager {lvalue} regionManagerRef(GIMLI::ModellingBase {lvalue})
response(model)[source]

Solve forward task.

Create apparent resistivity values for a given resistivity distribution for self.mesh.

response_mt((object)arg1, (object)model[, (object)i=0]) → object :
C++ signature :
GIMLI::Vector<double> response_mt(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double> [,unsigned long=0])

response_mt( (object)arg1, (object)model [, (object)i=0]) -> object :

C++ signature :
GIMLI::Vector<double> response_mt(ModellingBase_wrapper {lvalue},GIMLI::Vector<double> [,unsigned long=0])
responses(models, respos)
setConstraints((object)arg1, (object)C) → object :
C++ signature :
void* setConstraints(GIMLI::ModellingBase {lvalue},GIMLI::MatrixBase*)

setConstraints( (object)arg1, (object)C) -> object :

C++ signature :
void* setConstraints(ModellingBase_wrapper {lvalue},GIMLI::MatrixBase*)
setData(data)[source]

Set a DataContainer.

setJacobian((object)arg1, (object)J) → object :
C++ signature :
void* setJacobian(GIMLI::ModellingBase {lvalue},GIMLI::MatrixBase*)

setJacobian( (object)arg1, (object)J) -> object :

C++ signature :
void* setJacobian(ModellingBase_wrapper {lvalue},GIMLI::MatrixBase*)
setMesh(mesh, ignoreRegionManager=False)[source]

Set Mesh.

setMultiThreadJacobian((object)arg1, (object)nThreads) → object :

Set number of threads used for brute force Jacobian generation. 1 is default. If nThreads is greater than 1 you need to implement response_mt with a read only response function. Maybe its worth set the single setThreadCount to 1 than, that you dont find yourself in a threading overkill.

C++ signature :
void* setMultiThreadJacobian(GIMLI::ModellingBase {lvalue},unsigned long)
setRegionManager((object)arg1, (object)reg) → object :
C++ signature :
void* setRegionManager(GIMLI::ModellingBase {lvalue},GIMLI::RegionManager*)
setStartModel((object)arg1, (object)startModel) → object :
C++ signature :
void* setStartModel(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double>)

setStartModel( (object)arg1, (object)startModel) -> object :

C++ signature :
void* setStartModel(ModellingBase_wrapper {lvalue},GIMLI::Vector<double>)
setThreadCount((object)arg1, (object)nThreads) → object :

Set the maximum number of allowed threads for MT calculation. Have to be greater than 0. Will also set ENV(OPENBLAS_NUM_THREADS) .. if used.

C++ signature :
void* setThreadCount(GIMLI::ModellingBase {lvalue},unsigned long)
setVerbose((object)arg1, (object)verbose) → object :

Set verbose state.

C++ signature :
void* setVerbose(GIMLI::ModellingBase {lvalue},bool)
solution((object)arg1) → object :
C++ signature :
GIMLI::Matrix<double> solution(GIMLI::ModellingBase {lvalue})
startModel((object)arg1) → object :
C++ signature :
GIMLI::Vector<double> startModel(GIMLI::ModellingBase {lvalue})

startModel( (object)arg1) -> object :

C++ signature :
GIMLI::Vector<double> startModel(ModellingBase_wrapper {lvalue})
threadCount((object)arg1) → object :

Return the maximum number of allowed threads for MT calculation

C++ signature :
unsigned long threadCount(GIMLI::ModellingBase {lvalue})
uAnalytical(p, sourcePos, k)[source]

Calculates the analytical solution for the 2.5D geoelectrical problem.

Solves the 2.5D geoelectrical problem for one wave number k. It calculates the normalized (for injection current 1 A and sigma=1 S/m) potential at position p for a current injection at position sourcePos. Injection at the subsurface is recognized via mirror sources along the surface at depth=0.

Parameters:
p : pg.Pos

Position for the sought potential

sourcePos : pg.Pos

Current injection position.

k : float

Wave number

Returns:
u : float

Solution u(p)

verbose((object)arg1) → object :

Get verbose state.

C++ signature :
bool verbose(GIMLI::ModellingBase {lvalue})

verbose( (object)arg1) -> object :

C++ signature :
bool verbose(GIMLI::ModellingBase {lvalue})

VESCModelling

class pygimli.physics.ert.VESCModelling(**kwargs)[source]
Attributes:
transModel

Methods

__call__((object)arg1, (object)model) C++ signature :
clearConstraints((object)arg1) C++ signature :
clearJacobian((object)arg1) C++ signature :
constraints((object)arg1) C++ signature :
constraintsRef((object)arg1) C++ signature :
createConstraints((object)arg1) C++ signature :
createDefaultStartModel((object)arg1) C++ signature :
createJacobian((object)arg1, (object)model) C++ signature :
createMappedModel((object)arg1, …) Read only extrapolation of model values given per cell marker to values given per cell.
createRefinedForwardMesh((object)arg1 [, …) C++ signature :
createStartModel(rhoa, nLayer) Create Starting model.
createStartVector((object)arg1) DEPRECATED use createStartModel
data((object)arg1) Return the associated data container.
deleteMesh((object)arg1) Delete the actual mesh.
estimateError(data, **kwargs) Create
initConstraints((object)arg1) C++ signature :
initJacobian((object)arg1) C++ signature :
initRegionManager((object)arg1) C++ signature :
jacobian((object)arg1) Return the pointer to the Jacobian matrix associated with this forward operator.
jacobianRef((object)arg1) C++ signature :
mapModel((object)arg1, (object)model [, …) C++ signature :
mesh((object)arg1) C++ signature :
multiThreadJacobian((object)arg1) Return number of threads used for Jacobian generation.
region((object)arg1, (object)marker) Syntactic sugar for this->regionManager().region(marker).
regionManager((object)arg1) C++ signature :
regionManagerRef((object)arg1) C++ signature :
response((object)arg1, (object)model) C++ signature :
response_mt((object)arg1, (object)model [, …) C++ signature :
setConstraints((object)arg1, (object)C) C++ signature :
setData((object)arg1, (object)data) Change the associated data container
setDataBasis(**kwargs) Set data basis, i.e., arrays for all am, an, bm, bn distances.
setJacobian((object)arg1, (object)J) C++ signature :
setMesh((object)arg1, (object)mesh [, …) Set new mesh to the forward operator, optionally hold region parameter for the new mesh (i.e.
setMultiThreadJacobian((object)arg1, …) Set number of threads used for brute force Jacobian generation.
setRegionManager((object)arg1, (object)reg) C++ signature :
setStartModel((object)arg1, (object)startModel) C++ signature :
setThreadCount((object)arg1, (object)nThreads) Set the maximum number of allowed threads for MT calculation.
setVerbose((object)arg1, (object)verbose) Set verbose state.
solution((object)arg1) C++ signature :
startModel((object)arg1) C++ signature :
threadCount((object)arg1) Return the maximum number of allowed threads for MT calculation
verbose((object)arg1) Get verbose state.
createJacobian_mt  
drawData  
drawModel  
responses  
setForwardOperator  
setLayers  
setRegionProperties  
__init__((object)arg1[, (object)verbose=False]) → object :[source]
C++ signature :
void* __init__(_object* [,bool=False])

__init__( (object)arg1, (object)dataContainer [, (object)verbose=False]) -> object :

C++ signature :
void* __init__(_object*,GIMLI::DataContainer {lvalue} [,bool=False])

__init__( (object)arg1, (object)mesh [, (object)verbose=False]) -> object :

C++ signature :
void* __init__(_object*,GIMLI::Mesh [,bool=False])

__init__( (object)arg1, (object)mesh, (object)dataContainer [, (object)verbose=False]) -> object :

C++ signature :
void* __init__(_object*,GIMLI::Mesh,GIMLI::DataContainer {lvalue} [,bool=False])
clearConstraints((object)arg1) → object :
C++ signature :
void* clearConstraints(GIMLI::ModellingBase {lvalue})

clearConstraints( (object)arg1) -> object :

C++ signature :
void* clearConstraints(ModellingBase_wrapper {lvalue})
clearJacobian((object)arg1) → object :
C++ signature :
void* clearJacobian(GIMLI::ModellingBase {lvalue})

clearJacobian( (object)arg1) -> object :

C++ signature :
void* clearJacobian(ModellingBase_wrapper {lvalue})
constraints((object)arg1) → object :
C++ signature :
GIMLI::MatrixBase* constraints(GIMLI::ModellingBase {lvalue})

constraints( (object)arg1) -> object :

C++ signature :
GIMLI::MatrixBase* constraints(ModellingBase_wrapper {lvalue})

constraints( (object)arg1) -> object :

C++ signature :
GIMLI::MatrixBase* constraints(GIMLI::ModellingBase {lvalue})

constraints( (object)arg1) -> object :

C++ signature :
GIMLI::MatrixBase* constraints(ModellingBase_wrapper {lvalue})
constraintsRef((object)arg1) → object :
C++ signature :
GIMLI::SparseMapMatrix<double, unsigned long> {lvalue} constraintsRef(GIMLI::ModellingBase {lvalue})

constraintsRef( (object)arg1) -> object :

C++ signature :
GIMLI::SparseMapMatrix<double, unsigned long> {lvalue} constraintsRef(GIMLI::ModellingBase {lvalue})
createConstraints((object)arg1) → object :
C++ signature :
void* createConstraints(GIMLI::ModellingBase {lvalue})

createConstraints( (object)arg1) -> object :

C++ signature :
void* createConstraints(ModellingBase_wrapper {lvalue})
createDefaultStartModel((object)arg1) → object :
C++ signature :
GIMLI::Vector<double> createDefaultStartModel(GIMLI::ModellingBase {lvalue})

createDefaultStartModel( (object)arg1) -> object :

C++ signature :
GIMLI::Vector<double> createDefaultStartModel(ModellingBase_wrapper {lvalue})
createJacobian((object)arg1, (object)model) → object :
C++ signature :
void* createJacobian(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double>)

createJacobian( (object)arg1, (object)model) -> object :

C++ signature :
void* createJacobian(ModellingBase_wrapper {lvalue},GIMLI::Vector<double>)

createJacobian( (object)arg1, (object)model, (object)resp) -> object :

C++ signature :
void* createJacobian(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double>,GIMLI::Vector<double>)

createJacobian( (object)arg1, (object)model, (object)resp) -> object :

C++ signature :
void* createJacobian(ModellingBase_wrapper {lvalue},GIMLI::Vector<double>,GIMLI::Vector<double>)
createJacobian_mt(model, resp)
createMappedModel((object)arg1, (object)model[, (object)background=-1]) → object :

Read only extrapolation of model values given per cell marker to values given per cell. Exterior values will be set to background or prolongated for background = -1.

C++ signature :
GIMLI::Vector<double> createMappedModel(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double> [,double=-1])
createRefinedForwardMesh((object)arg1[, (object)refine=True[, (object)pRefine=False]]) → object :
C++ signature :
void* createRefinedForwardMesh(GIMLI::ModellingBase {lvalue} [,bool=True [,bool=False]])
createStartModel(rhoa, nLayer)[source]

Create Starting model.

Create Starting model based on current data values and additional args.

createStartVector((object)arg1) → object :

DEPRECATED use createStartModel

C++ signature :
GIMLI::Vector<double> createStartVector(GIMLI::ModellingBase {lvalue})
data((object)arg1) → object :

Return the associated data container.

C++ signature :
GIMLI::DataContainer {lvalue} data(GIMLI::ModellingBase {lvalue})
deleteMesh((object)arg1) → object :

Delete the actual mesh.

C++ signature :
void* deleteMesh(GIMLI::ModellingBase {lvalue})
drawData(ax, data, err=None, label=None)[source]
drawModel(ax, model)[source]
estimateError(data, **kwargs)

Create

initConstraints((object)arg1) → object :
C++ signature :
void* initConstraints(GIMLI::ModellingBase {lvalue})

initConstraints( (object)arg1) -> object :

C++ signature :
void* initConstraints(ModellingBase_wrapper {lvalue})
initJacobian((object)arg1) → object :
C++ signature :
void* initJacobian(GIMLI::ModellingBase {lvalue})

initJacobian( (object)arg1) -> object :

C++ signature :
void* initJacobian(ModellingBase_wrapper {lvalue})
initRegionManager((object)arg1) → object :
C++ signature :
void* initRegionManager(GIMLI::ModellingBase {lvalue})
jacobian((object)arg1) → object :

Return the pointer to the Jacobian matrix associated with this forward operator.

C++ signature :
GIMLI::MatrixBase* jacobian(GIMLI::ModellingBase {lvalue})
jacobian( (object)arg1) -> object :

Return the pointer to the Jacobian matrix associated with this forward operator.

C++ signature :
GIMLI::MatrixBase* jacobian(GIMLI::ModellingBase {lvalue})
jacobianRef((object)arg1) → object :
C++ signature :
GIMLI::Matrix<double> {lvalue} jacobianRef(GIMLI::ModellingBase {lvalue})

jacobianRef( (object)arg1) -> object :

C++ signature :
GIMLI::Matrix<double> {lvalue} jacobianRef(GIMLI::ModellingBase {lvalue})
mapModel((object)arg1, (object)model[, (object)background=0]) → object :
C++ signature :
void* mapModel(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double> [,double=0])
mesh((object)arg1) → object :
C++ signature :
GIMLI::Mesh* mesh(GIMLI::ModellingBase {lvalue})
multiThreadJacobian((object)arg1) → object :

Return number of threads used for Jacobian generation.

C++ signature :
unsigned long multiThreadJacobian(GIMLI::ModellingBase {lvalue})
region((object)arg1, (object)marker) → object :

Syntactic sugar for this->regionManager().region(marker).

C++ signature :
GIMLI::Region* region(GIMLI::ModellingBase {lvalue},int)
regionManager((object)arg1) → object :
C++ signature :
GIMLI::RegionManager regionManager(GIMLI::ModellingBase {lvalue})

regionManager( (object)arg1) -> object :

C++ signature :
GIMLI::RegionManager {lvalue} regionManager(GIMLI::ModellingBase {lvalue})
regionManagerRef((object)arg1) → object :
C++ signature :
GIMLI::RegionManager {lvalue} regionManagerRef(GIMLI::ModellingBase {lvalue})
response((object)arg1, (object)model) → object :
C++ signature :
GIMLI::Vector<double> response(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double>)

response( (object)arg1, (object)model) -> object :

C++ signature :
GIMLI::Vector<double> response(ModellingBase_wrapper {lvalue},GIMLI::Vector<double>)
response_mt((object)arg1, (object)model[, (object)i=0]) → object :[source]
C++ signature :
GIMLI::Vector<double> response_mt(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double> [,unsigned long=0])

response_mt( (object)arg1, (object)model [, (object)i=0]) -> object :

C++ signature :
GIMLI::Vector<double> response_mt(ModellingBase_wrapper {lvalue},GIMLI::Vector<double> [,unsigned long=0])
responses(models, respos)
setConstraints((object)arg1, (object)C) → object :
C++ signature :
void* setConstraints(GIMLI::ModellingBase {lvalue},GIMLI::MatrixBase*)

setConstraints( (object)arg1, (object)C) -> object :

C++ signature :
void* setConstraints(ModellingBase_wrapper {lvalue},GIMLI::MatrixBase*)
setData((object)arg1, (object)data) → object :

Change the associated data container

C++ signature :
void* setData(GIMLI::ModellingBase {lvalue},GIMLI::DataContainer {lvalue})
setDataBasis(**kwargs)

Set data basis, i.e., arrays for all am, an, bm, bn distances.

setForwardOperator(fop)
setJacobian((object)arg1, (object)J) → object :
C++ signature :
void* setJacobian(GIMLI::ModellingBase {lvalue},GIMLI::MatrixBase*)

setJacobian( (object)arg1, (object)J) -> object :

C++ signature :
void* setJacobian(ModellingBase_wrapper {lvalue},GIMLI::MatrixBase*)
setLayers(nLayers)
setMesh((object)arg1, (object)mesh [, (object)ignoreRegionManager=False]) -> object : Set new mesh to the forward operator, optionally hold region parameter for the new mesh (i.e. for roll a long)

Set new mesh to the forward operator, optionally hold region parameter for the new mesh (i.e. for roll a long)

C++ signature :
void* setMesh(GIMLI::ModellingBase {lvalue},GIMLI::Mesh [,bool=False])
setMultiThreadJacobian((object)arg1, (object)nThreads) → object :

Set number of threads used for brute force Jacobian generation. 1 is default. If nThreads is greater than 1 you need to implement response_mt with a read only response function. Maybe its worth set the single setThreadCount to 1 than, that you dont find yourself in a threading overkill.

C++ signature :
void* setMultiThreadJacobian(GIMLI::ModellingBase {lvalue},unsigned long)
setRegionManager((object)arg1, (object)reg) → object :
C++ signature :
void* setRegionManager(GIMLI::ModellingBase {lvalue},GIMLI::RegionManager*)
setRegionProperties(region, startModel=None, limits=None, trans=None)
setStartModel((object)arg1, (object)startModel) → object :
C++ signature :
void* setStartModel(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double>)

setStartModel( (object)arg1, (object)startModel) -> object :

C++ signature :
void* setStartModel(ModellingBase_wrapper {lvalue},GIMLI::Vector<double>)
setThreadCount((object)arg1, (object)nThreads) → object :

Set the maximum number of allowed threads for MT calculation. Have to be greater than 0. Will also set ENV(OPENBLAS_NUM_THREADS) .. if used.

C++ signature :
void* setThreadCount(GIMLI::ModellingBase {lvalue},unsigned long)
setVerbose((object)arg1, (object)verbose) → object :

Set verbose state.

C++ signature :
void* setVerbose(GIMLI::ModellingBase {lvalue},bool)
solution((object)arg1) → object :
C++ signature :
GIMLI::Matrix<double> solution(GIMLI::ModellingBase {lvalue})
startModel((object)arg1) → object :
C++ signature :
GIMLI::Vector<double> startModel(GIMLI::ModellingBase {lvalue})

startModel( (object)arg1) -> object :

C++ signature :
GIMLI::Vector<double> startModel(ModellingBase_wrapper {lvalue})
threadCount((object)arg1) → object :

Return the maximum number of allowed threads for MT calculation

C++ signature :
unsigned long threadCount(GIMLI::ModellingBase {lvalue})
transModel
verbose((object)arg1) → object :

Get verbose state.

C++ signature :
bool verbose(GIMLI::ModellingBase {lvalue})

verbose( (object)arg1) -> object :

C++ signature :
bool verbose(GIMLI::ModellingBase {lvalue})

VESManager

class pygimli.physics.ert.VESManager(**kwargs)[source]

Vertical electrical sounding (VES) manager class.

Examples

>>> # no need to import matplotlib. pygimli's show does
>>> import numpy as np
>>> import pygimli as pg
>>> from pygimli.physics import VESManager
>>> ab2 = np.logspace(np.log10(1.5), np.log10(100), 32)
>>> mn2 = 1.0
>>> # 3 layer with 100, 500 and 20 Ohmm
>>> # and layer thickness of 4, 6, 10 m
>>> # over a Halfspace of 800 Ohmm
>>> synthModel = pg.cat([4., 6., 10.], [100., 5., 20., 800.])
>>> VES = VESManager()
>>> ra, err = VES.simulate(synthModel, ab2=ab2, mn2=mn2, noiseLevel=0.01)
>>> ax = VES.showData(ra, err)
>>> # _= VES.invert(ra, err, nLayer=4, showProgress=0, verbose=0)
>>> # ax = VES.showModel(synthModel)
>>> # ax = VES.showResult(ax=ax)
>>> pg.wait()

()

../../_images/pygimli-physics-ert-1.png
Attributes:
complex
debug
verbose

Methods

createArgParser([dataSuffix]) Create default argument parser.
createForwardOperator(**kwargs) Create Forward Operator.
estimateError(data[, errLevel]) Estimate data error.
exportData(fileName[, data, error]) Export data into simple ascii matrix.
initForwardOperator(**kwargs) Initialize or re-initialize the forward operator.
initInversionFramework(**kwargs) Initialize or re-initialize the inversion framework.
invert([data, err, ab2, mn2]) Invert measured data.
loadData(fileName, **kwargs) Mandatory interface for derived classes.
setVerbose(verbose) Make the class verbose (put output to the console)
showData(data[, error, ax]) Shows the data.
showFit([ax]) Show the last inversion date and response.
showModel(model[, ax]) Shows a model.
showResult([ax]) Show the last inversion result.
showResultAndFit() Calls showResults and showFit.
simulate(model[, ab2, mn2]) Simulate measurement data.
createInversionFramework  
__init__(**kwargs)[source]

Constructor

Parameters:
complex : bool

Accept complex resistivities.

Attributes:
complex : bool

Accept complex resistivities.

complex
static createArgParser(dataSuffix='dat')

Create default argument parser.

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)[source]

Create Forward Operator.

Create Forward Operator based on complex attribute.

createInversionFramework(**kwargs)
debug
estimateError(data, errLevel=0.01)

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.

Returns:
err : array

Returning array of size len(data)

exportData(fileName, data=None, error=None)[source]

Export data into simple ascii matrix.

Usefull?

initForwardOperator(**kwargs)

Initialize or re-initialize the forward operator.

Called once in the constructor to force the manager to create the necessary forward operator member. Can be recalled if you need to changed the mangers own forward operator object. If you want a own instance of a valid FOP call createForwardOperator.

initInversionFramework(**kwargs)

Initialize or re-initialize the inversion framework.

Called once in the constructor to force the manager to create the necessary Framework instance.

invert(data=None, err=None, ab2=None, mn2=None, **kwargs)[source]

Invert measured data.

loadData(fileName, **kwargs)[source]

Mandatory interface for derived classes.

setVerbose(verbose)

Make the class verbose (put output to the console)

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

Shows 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

Data values to be draw.

error : iterable

Data error values to be draw.

showFit(ax=None)

Show the last inversion date and response.

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

Shows a model.

Draw model date into a given axes or show the inversion result from the last run. Forwards on default to the self.fop.drawModel 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.

model : iterable

Model data to be draw.

showResult(ax=None, **kwargs)

Show the last inversion result.

showResultAndFit()

Calls showResults and showFit.

simulate(model, ab2=None, mn2=None, **kwargs)[source]

Simulate measurement data.

verbose

VESModelling

class pygimli.physics.ert.VESModelling(ab2=None, mn2=None, **kwargs)[source]

Vertical Electrical Sounding (VES) forward operator.

Attributes:
am :

Part of data basis. Distances between A and M electrodes. A is first power, M is first potential electrode.

bm :

Part of data basis. Distances between B and M electrodes. B is second power, M is first potential electrode.

an :

Part of data basis. Distances between A and N electrodes. A is first power, N is second potential electrode.

bn :

Part of data basis. Distances between B and N electrodes. B is second power, N is second potential electrode.

ab2 :

Half distance between A and B. Only used for output and auto generated.

Methods

__call__((object)arg1, (object)model) C++ signature :
clearConstraints((object)arg1) C++ signature :
clearJacobian((object)arg1) C++ signature :
constraints((object)arg1) C++ signature :
constraintsRef((object)arg1) C++ signature :
createConstraints((object)arg1) C++ signature :
createDefaultStartModel((object)arg1) C++ signature :
createJacobian((object)arg1, (object)model) C++ signature :
createMappedModel((object)arg1, …) Read only extrapolation of model values given per cell marker to values given per cell.
createRefinedForwardMesh((object)arg1 [, …) C++ signature :
createStartModel(rhoa, nLayer) Create Starting model.
createStartVector((object)arg1) DEPRECATED use createStartModel
data((object)arg1) Return the associated data container.
deleteMesh((object)arg1) Delete the actual mesh.
estimateError(data, **kwargs) Create
initConstraints((object)arg1) C++ signature :
initJacobian((object)arg1) C++ signature :
initRegionManager((object)arg1) C++ signature :
jacobian((object)arg1) Return the pointer to the Jacobian matrix associated with this forward operator.
jacobianRef((object)arg1) C++ signature :
mapModel((object)arg1, (object)model [, …) C++ signature :
mesh((object)arg1) C++ signature :
multiThreadJacobian((object)arg1) Return number of threads used for Jacobian generation.
region((object)arg1, (object)marker) Syntactic sugar for this->regionManager().region(marker).
regionManager((object)arg1) C++ signature :
regionManagerRef((object)arg1) C++ signature :
response((object)arg1, (object)model) C++ signature :
response_mt((object)arg1, (object)model [, …) C++ signature :
setConstraints((object)arg1, (object)C) C++ signature :
setData((object)arg1, (object)data) Change the associated data container
setDataBasis(**kwargs) Set data basis, i.e., arrays for all am, an, bm, bn distances.
setJacobian((object)arg1, (object)J) C++ signature :
setMesh((object)arg1, (object)mesh [, …) Set new mesh to the forward operator, optionally hold region parameter for the new mesh (i.e.
setMultiThreadJacobian((object)arg1, …) Set number of threads used for brute force Jacobian generation.
setRegionManager((object)arg1, (object)reg) C++ signature :
setStartModel((object)arg1, (object)startModel) C++ signature :
setThreadCount((object)arg1, (object)nThreads) Set the maximum number of allowed threads for MT calculation.
setVerbose((object)arg1, (object)verbose) Set verbose state.
solution((object)arg1) C++ signature :
startModel((object)arg1) C++ signature :
threadCount((object)arg1) Return the maximum number of allowed threads for MT calculation
verbose((object)arg1) Get verbose state.
createJacobian_mt  
drawData  
drawModel  
responses  
setForwardOperator  
setLayers  
setRegionProperties  
__init__((object)arg1[, (object)verbose=False]) → object :[source]
C++ signature :
void* __init__(_object* [,bool=False])

__init__( (object)arg1, (object)dataContainer [, (object)verbose=False]) -> object :

C++ signature :
void* __init__(_object*,GIMLI::DataContainer {lvalue} [,bool=False])

__init__( (object)arg1, (object)mesh [, (object)verbose=False]) -> object :

C++ signature :
void* __init__(_object*,GIMLI::Mesh [,bool=False])

__init__( (object)arg1, (object)mesh, (object)dataContainer [, (object)verbose=False]) -> object :

C++ signature :
void* __init__(_object*,GIMLI::Mesh,GIMLI::DataContainer {lvalue} [,bool=False])
clearConstraints((object)arg1) → object :
C++ signature :
void* clearConstraints(GIMLI::ModellingBase {lvalue})

clearConstraints( (object)arg1) -> object :

C++ signature :
void* clearConstraints(ModellingBase_wrapper {lvalue})
clearJacobian((object)arg1) → object :
C++ signature :
void* clearJacobian(GIMLI::ModellingBase {lvalue})

clearJacobian( (object)arg1) -> object :

C++ signature :
void* clearJacobian(ModellingBase_wrapper {lvalue})
constraints((object)arg1) → object :
C++ signature :
GIMLI::MatrixBase* constraints(GIMLI::ModellingBase {lvalue})

constraints( (object)arg1) -> object :

C++ signature :
GIMLI::MatrixBase* constraints(ModellingBase_wrapper {lvalue})

constraints( (object)arg1) -> object :

C++ signature :
GIMLI::MatrixBase* constraints(GIMLI::ModellingBase {lvalue})

constraints( (object)arg1) -> object :

C++ signature :
GIMLI::MatrixBase* constraints(ModellingBase_wrapper {lvalue})
constraintsRef((object)arg1) → object :
C++ signature :
GIMLI::SparseMapMatrix<double, unsigned long> {lvalue} constraintsRef(GIMLI::ModellingBase {lvalue})

constraintsRef( (object)arg1) -> object :

C++ signature :
GIMLI::SparseMapMatrix<double, unsigned long> {lvalue} constraintsRef(GIMLI::ModellingBase {lvalue})
createConstraints((object)arg1) → object :
C++ signature :
void* createConstraints(GIMLI::ModellingBase {lvalue})

createConstraints( (object)arg1) -> object :

C++ signature :
void* createConstraints(ModellingBase_wrapper {lvalue})
createDefaultStartModel((object)arg1) → object :
C++ signature :
GIMLI::Vector<double> createDefaultStartModel(GIMLI::ModellingBase {lvalue})

createDefaultStartModel( (object)arg1) -> object :

C++ signature :
GIMLI::Vector<double> createDefaultStartModel(ModellingBase_wrapper {lvalue})
createJacobian((object)arg1, (object)model) → object :
C++ signature :
void* createJacobian(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double>)

createJacobian( (object)arg1, (object)model) -> object :

C++ signature :
void* createJacobian(ModellingBase_wrapper {lvalue},GIMLI::Vector<double>)

createJacobian( (object)arg1, (object)model, (object)resp) -> object :

C++ signature :
void* createJacobian(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double>,GIMLI::Vector<double>)

createJacobian( (object)arg1, (object)model, (object)resp) -> object :

C++ signature :
void* createJacobian(ModellingBase_wrapper {lvalue},GIMLI::Vector<double>,GIMLI::Vector<double>)
createJacobian_mt(model, resp)
createMappedModel((object)arg1, (object)model[, (object)background=-1]) → object :

Read only extrapolation of model values given per cell marker to values given per cell. Exterior values will be set to background or prolongated for background = -1.

C++ signature :
GIMLI::Vector<double> createMappedModel(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double> [,double=-1])
createRefinedForwardMesh((object)arg1[, (object)refine=True[, (object)pRefine=False]]) → object :
C++ signature :
void* createRefinedForwardMesh(GIMLI::ModellingBase {lvalue} [,bool=True [,bool=False]])
createStartModel(rhoa, nLayer)[source]

Create Starting model.

Create Starting model based on current data values and additional args.

createStartVector((object)arg1) → object :

DEPRECATED use createStartModel

C++ signature :
GIMLI::Vector<double> createStartVector(GIMLI::ModellingBase {lvalue})
data((object)arg1) → object :

Return the associated data container.

C++ signature :
GIMLI::DataContainer {lvalue} data(GIMLI::ModellingBase {lvalue})
deleteMesh((object)arg1) → object :

Delete the actual mesh.

C++ signature :
void* deleteMesh(GIMLI::ModellingBase {lvalue})
drawData(ax, data, err=None, label=None, **kwargs)[source]
drawModel(ax, model)[source]
estimateError(data, **kwargs)

Create

initConstraints((object)arg1) → object :
C++ signature :
void* initConstraints(GIMLI::ModellingBase {lvalue})

initConstraints( (object)arg1) -> object :

C++ signature :
void* initConstraints(ModellingBase_wrapper {lvalue})
initJacobian((object)arg1) → object :
C++ signature :
void* initJacobian(GIMLI::ModellingBase {lvalue})

initJacobian( (object)arg1) -> object :

C++ signature :
void* initJacobian(ModellingBase_wrapper {lvalue})
initRegionManager((object)arg1) → object :
C++ signature :
void* initRegionManager(GIMLI::ModellingBase {lvalue})
jacobian((object)arg1) → object :

Return the pointer to the Jacobian matrix associated with this forward operator.

C++ signature :
GIMLI::MatrixBase* jacobian(GIMLI::ModellingBase {lvalue})
jacobian( (object)arg1) -> object :

Return the pointer to the Jacobian matrix associated with this forward operator.

C++ signature :
GIMLI::MatrixBase* jacobian(GIMLI::ModellingBase {lvalue})
jacobianRef((object)arg1) → object :
C++ signature :
GIMLI::Matrix<double> {lvalue} jacobianRef(GIMLI::ModellingBase {lvalue})

jacobianRef( (object)arg1) -> object :

C++ signature :
GIMLI::Matrix<double> {lvalue} jacobianRef(GIMLI::ModellingBase {lvalue})
mapModel((object)arg1, (object)model[, (object)background=0]) → object :
C++ signature :
void* mapModel(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double> [,double=0])
mesh((object)arg1) → object :
C++ signature :
GIMLI::Mesh* mesh(GIMLI::ModellingBase {lvalue})
multiThreadJacobian((object)arg1) → object :

Return number of threads used for Jacobian generation.

C++ signature :
unsigned long multiThreadJacobian(GIMLI::ModellingBase {lvalue})
region((object)arg1, (object)marker) → object :

Syntactic sugar for this->regionManager().region(marker).

C++ signature :
GIMLI::Region* region(GIMLI::ModellingBase {lvalue},int)
regionManager((object)arg1) → object :
C++ signature :
GIMLI::RegionManager regionManager(GIMLI::ModellingBase {lvalue})

regionManager( (object)arg1) -> object :

C++ signature :
GIMLI::RegionManager {lvalue} regionManager(GIMLI::ModellingBase {lvalue})
regionManagerRef((object)arg1) → object :
C++ signature :
GIMLI::RegionManager {lvalue} regionManagerRef(GIMLI::ModellingBase {lvalue})
response((object)arg1, (object)model) → object :[source]
C++ signature :
GIMLI::Vector<double> response(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double>)

response( (object)arg1, (object)model) -> object :

C++ signature :
GIMLI::Vector<double> response(ModellingBase_wrapper {lvalue},GIMLI::Vector<double>)
response_mt((object)arg1, (object)model[, (object)i=0]) → object :[source]
C++ signature :
GIMLI::Vector<double> response_mt(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double> [,unsigned long=0])

response_mt( (object)arg1, (object)model [, (object)i=0]) -> object :

C++ signature :
GIMLI::Vector<double> response_mt(ModellingBase_wrapper {lvalue},GIMLI::Vector<double> [,unsigned long=0])
responses(models, respos)
setConstraints((object)arg1, (object)C) → object :
C++ signature :
void* setConstraints(GIMLI::ModellingBase {lvalue},GIMLI::MatrixBase*)

setConstraints( (object)arg1, (object)C) -> object :

C++ signature :
void* setConstraints(ModellingBase_wrapper {lvalue},GIMLI::MatrixBase*)
setData((object)arg1, (object)data) → object :

Change the associated data container

C++ signature :
void* setData(GIMLI::ModellingBase {lvalue},GIMLI::DataContainer {lvalue})
setDataBasis(**kwargs)[source]

Set data basis, i.e., arrays for all am, an, bm, bn distances.

setForwardOperator(fop)
setJacobian((object)arg1, (object)J) → object :
C++ signature :
void* setJacobian(GIMLI::ModellingBase {lvalue},GIMLI::MatrixBase*)

setJacobian( (object)arg1, (object)J) -> object :

C++ signature :
void* setJacobian(ModellingBase_wrapper {lvalue},GIMLI::MatrixBase*)
setLayers(nLayers)
setMesh((object)arg1, (object)mesh [, (object)ignoreRegionManager=False]) -> object : Set new mesh to the forward operator, optionally hold region parameter for the new mesh (i.e. for roll a long)

Set new mesh to the forward operator, optionally hold region parameter for the new mesh (i.e. for roll a long)

C++ signature :
void* setMesh(GIMLI::ModellingBase {lvalue},GIMLI::Mesh [,bool=False])
setMultiThreadJacobian((object)arg1, (object)nThreads) → object :

Set number of threads used for brute force Jacobian generation. 1 is default. If nThreads is greater than 1 you need to implement response_mt with a read only response function. Maybe its worth set the single setThreadCount to 1 than, that you dont find yourself in a threading overkill.

C++ signature :
void* setMultiThreadJacobian(GIMLI::ModellingBase {lvalue},unsigned long)
setRegionManager((object)arg1, (object)reg) → object :
C++ signature :
void* setRegionManager(GIMLI::ModellingBase {lvalue},GIMLI::RegionManager*)
setRegionProperties(region, startModel=None, limits=None, trans=None)
setStartModel((object)arg1, (object)startModel) → object :
C++ signature :
void* setStartModel(GIMLI::ModellingBase {lvalue},GIMLI::Vector<double>)

setStartModel( (object)arg1, (object)startModel) -> object :

C++ signature :
void* setStartModel(ModellingBase_wrapper {lvalue},GIMLI::Vector<double>)
setThreadCount((object)arg1, (object)nThreads) → object :

Set the maximum number of allowed threads for MT calculation. Have to be greater than 0. Will also set ENV(OPENBLAS_NUM_THREADS) .. if used.

C++ signature :
void* setThreadCount(GIMLI::ModellingBase {lvalue},unsigned long)
setVerbose((object)arg1, (object)verbose) → object :

Set verbose state.

C++ signature :
void* setVerbose(GIMLI::ModellingBase {lvalue},bool)
solution((object)arg1) → object :
C++ signature :
GIMLI::Matrix<double> solution(GIMLI::ModellingBase {lvalue})
startModel((object)arg1) → object :
C++ signature :
GIMLI::Vector<double> startModel(GIMLI::ModellingBase {lvalue})

startModel( (object)arg1) -> object :

C++ signature :
GIMLI::Vector<double> startModel(ModellingBase_wrapper {lvalue})
threadCount((object)arg1) → object :

Return the maximum number of allowed threads for MT calculation

C++ signature :
unsigned long threadCount(GIMLI::ModellingBase {lvalue})
transModel
verbose((object)arg1) → object :

Get verbose state.

C++ signature :
bool verbose(GIMLI::ModellingBase {lvalue})

verbose( (object)arg1) -> object :

C++ signature :
bool verbose(GIMLI::ModellingBase {lvalue})


2019 - GIMLi Development Team
Created using Bootstrap, Sphinx and pyGIMLi 1.0.11+23.g5fafebb7 on May 23, 2019.