pygimli.physics.petro

This package contains submodules for various petrophysical models

Overview

Functions

permeabilityEngelhardtPitter(poro[, q, s, …]) Empirical model for porosity to hydraulic permeability.
resistivityArchie(rFluid, porosity[, a, m, …]) Resistivity of rock for the petrophysical model from Archies law.
slownessWyllie(phi[, sat, vm, vw, va, mesh, …]) Return slowness \(s\) after Wyllie time-average equation.
transFwdArchiePhi([rFluid, m]) Archies law transformation function for resistivity(porosity).
transFwdArchieS([rFluid, phi, m, n]) Inverse Archie transformation function resistivity(saturation).
transFwdWylliePhi([sat, vm, vw, va]) Wyllie transformation function porosity(slowness).
transFwdWyllieS(phi[, vm, vw, va]) Wyllie transformation function slowness(saturation).
transInvArchiePhi([rFluid, m]) Inverse Archie transformation function porosity(resistivity).
transInvArchieS([rFluid, phi, m, n]) Inverse Archie transformation function saturation(resistivity).
transInvWylliePhi([sat, vm, vw, va]) Inverse Wyllie transformation function porosity(slowness).
transInvWyllieS(phi[, vm, vw, va]) Inverse Wyllie transformation function slowness(saturation).

Classes

JointPetroInversion(managers, trans[, …]) TODO.
PetroInversion(manager, trans, **kwargs) TODO.
PetroJointModelling([f, p, mesh, verbose]) Cumulative (joint) forward operator for petrophysical inversions.
PetroModelling(fop, trans[, mesh, verbose]) Combine petrophysical relation m(p) with modelling class f(p).

Functions

permeabilityEngelhardtPitter

pygimli.physics.petro.permeabilityEngelhardtPitter(poro, q=3.5, s=0.005, mesh=None, meshI=None)[source]

Empirical model for porosity to hydraulic permeability.

Postulated for sand and sandstones. [vEP55]

\[\begin{split}k & = 2\cdot 10^7 \frac{\phi^2}{(1-\phi)^2}* \frac{1}{S^2} \\ S & = q\cdot s \\ s & = \sum_{i=1}(\frac{P_i}{r_i})\end{split}\]
  • \(\phi\) - poro 0.0 –1.0
  • \(q\) - (3 for spheres, > 3 shape differ from sphere)
    3.5 sand
  • \(s\) - in cm^-1 (s = 1/r for particles with homogeneous radii r)
  • \(P_i\) - Particle ration with radii \(r_i\) on 1cm^3 Sample
  • \(S\) - in cm^-1 specific surface in cm^2/cm^3
Returns:
k :

in Darcy

resistivityArchie

pygimli.physics.petro.resistivityArchie(rFluid, porosity, a=1.0, m=2.0, sat=1.0, n=2.0, mesh=None, meshI=None, fill=None, show=False)[source]

Resistivity of rock for the petrophysical model from Archies law.

Calculates resistivity of rock for the petrophysical model from Archie’s law. [Arc42]

\[\rho = a\rho_{\text{fl}}\phi^{-m} S^{-n}\]
  • \(\rho\) - the electrical resistivity of the fluid saturated rock in \(\Omega\text{m}\)
  • \(\rho_{\text{fl}}\) - rFluid: electrical resistivity of the fluid in \(\Omega\text{m}\)
  • \(\phi\) - porosity 0.0 –1.0
  • \(S\) - fluid saturation 0.0 –1.0 [sat]
  • \(a\) - Tortuosity factor. (common 1)
  • \(m\) - Cementation exponent of the rock (usually in the range 1.3 – 2.5 for sandstones)
  • \(n\) - is the saturation exponent (usually close to 2)

If mesh is not None the resulting values are calculated for each cell of the mesh. All parameter can be scalar, array of length mesh.cellCount() or callable(pg.cell). If rFluid is non-steady n-step distribution than rFluid can be a matrix of size(n, mesh.cellCount()) If meshI is not None the result is interpolated to meshI.cellCenters() and prolonged (if fill ==1).

Notes

We experience some unstable nonlinear behavior. Until this is clarified all results are rounded to the precision 1e-6.

Examples

>>> #

WRITEME

slownessWyllie

pygimli.physics.petro.slownessWyllie(phi, sat=1, vm=4000, vw=1484, va=343, mesh=None, meshI=None, fill=None)[source]

Return slowness \(s\) after Wyllie time-average equation.

\[s = (1-\phi) \cdot\frac{1}{v_m} + \phi \cdot S \cdot\frac{1}{v_w} + \phi \cdot(1 - S) \cdot\frac{1}{v_a}\]
  • \(\phi\) - porosity 0.0 –1.0
  • \(S\) - fluid saturation 0.0 –1.0 [sat]
  • \(v_m\) - velocity of matrix [4000 m/s]
  • \(v_w\) - velocity of water [1484 m/s]
  • \(v_a\) - velocity of air [343 m/s]

If mesh is not None the resulting values are calculated for each cell of the mesh. All parameter can be scalar, array of length mesh.cellCount() or callable(pg.cell). If meshI is not None the result is interpolated to meshI.cellCenters() and prolonged (if fill ==1).

Examples

WRITEME

transFwdArchiePhi

pygimli.physics.petro.transFwdArchiePhi(rFluid=20, m=2)[source]

Archies law transformation function for resistivity(porosity).

\[\begin{split}\rho & = a\rho_{\text{fl}}\phi^{-m}\S_w^{-n} \\ \rho & = \rho_{\text{fl}}\phi^(-m) = \left(\phi/\rho_{\text{fl}}^{-1/n}\right)^{-n}\end{split}\]

See also pygimli.physics.petro.resistivityArchie

Returns:
trans : GIMLI::RTransPower

Transformation function

Examples

>>> from pygimli.physics.petro import *
>>> phi = 0.3
>>> tFAPhi = transFwdArchiePhi(rFluid=20)
>>> r1 = tFAPhi.trans(phi)
>>> r2 = resistivityArchie(rFluid=20.0, porosity=phi,
...                        a=1.0, m=2.0, sat=1.0, n=2.0)
>>> print(r1-r2 < 1e-12)
True
>>> phi = [0.3]
>>> tFAPhi = transFwdArchiePhi(rFluid=20)
>>> r1 = tFAPhi.trans(phi)
>>> r2 = resistivityArchie(rFluid=20.0, porosity=phi,
...                        a=1.0, m=2.0, sat=1.0, n=2.0)
>>> print((r1-r2 < 1e-12)[0])
True

transFwdArchieS

pygimli.physics.petro.transFwdArchieS(rFluid=20, phi=0.4, m=2, n=2)[source]

Inverse Archie transformation function resistivity(saturation).

transFwdWylliePhi

pygimli.physics.petro.transFwdWylliePhi(sat=1, vm=4000, vw=1600, va=330)[source]

Wyllie transformation function porosity(slowness).

transFwdWyllieS

pygimli.physics.petro.transFwdWyllieS(phi, vm=4000, vw=1600, va=330)[source]

Wyllie transformation function slowness(saturation).

transInvArchiePhi

pygimli.physics.petro.transInvArchiePhi(rFluid=20, m=2)[source]

Inverse Archie transformation function porosity(resistivity).

# rFluid/rho = phi^m ==> phi = (rFluid/rho)^(1/m) = (rho/rFluid)^(-1/m) See — pygimli.physics.petro.transFwdArchiePhi

transInvArchieS

pygimli.physics.petro.transInvArchieS(rFluid=20, phi=0.4, m=2, n=2)[source]

Inverse Archie transformation function saturation(resistivity).

transInvWylliePhi

pygimli.physics.petro.transInvWylliePhi(sat=1, vm=4000, vw=1600, va=330)[source]

Inverse Wyllie transformation function porosity(slowness).

transInvWyllieS

pygimli.physics.petro.transInvWyllieS(phi, vm=4000, vw=1600, va=330)[source]

Inverse Wyllie transformation function slowness(saturation).

Classes

JointPetroInversion

class pygimli.physics.petro.JointPetroInversion(managers, trans, verbose=False, debug=False, **kwargs)[source]

TODO.

Methods

apparentData() Convert data into apparent data.
checkData() Check data validity.
createArgParser([dataSuffix]) Create default argument parser.
createData(sensors, scheme) Create an empty data set.
createFOP([verbose]) Create forward operator.
createFOP_([verbose]) Create forward operator working on refined mesh.
createInv(fop[, verbose, doSave]) TODO.
createInv_(fop[, verbose, dosave]) Create inversion instance, data- and model transformations.
dataToken() Token name for the data in a DataContainer.
estimateError(data[, absoluteError, …]) Estimate error composed of an absolute and a relative part.
invert([data, mesh, lam, limits]) TODO.
model() Return the actual model.
saveResult([folder, size]) Save results in the specified folder.
setData(data) TODO.
setDataToken(token) Set the token name to identity the data in a DataContainer.
setMesh(mesh) TODO.
setVerbose(verbose) Make the class verbose (put output to the console)
show(data[, values, axes, cMin, cMax, colorBar]) Forward the visualization.
showData([axes, response, name]) Show data.
showModel(**showkwargs) TODO.
showResult([ax, cMin, cMax, logScale]) Show resulting vector.
simulate(**kwargs) Run a simulation aka the forward task.
__init__(managers, trans, verbose=False, debug=False, **kwargs)[source]

TODO.

apparentData()

Convert data into apparent data.

checkData()

Check data validity.

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

createData(sensors, scheme)

Create an empty data set.

static createFOP(verbose=False)[source]

Create forward operator.

createFOP_(verbose=False)

Create forward operator working on refined mesh.

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

TODO.

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

Create inversion instance, data- and model transformations.

dataToken()

Token name for the data in a DataContainer.

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

Estimate error composed of an absolute and a relative part.

invert(data=None, mesh=None, lam=20, limits=None, **kwargs)[source]

TODO.

model()[source]

Return the actual model.

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

Save results in the specified folder.

setData(data)[source]

TODO.

setDataToken(token)

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

setMesh(mesh)[source]

TODO.

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(axes=None, response=None, name='data')

Show data.

showModel(**showkwargs)[source]

TODO.

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

Show resulting vector.

simulate(**kwargs)

Run a simulation aka the forward task.

PetroInversion

class pygimli.physics.petro.PetroInversion(manager, trans, **kwargs)[source]

TODO.

Methods

apparentData() Convert data into apparent data.
checkData() Check data validity.
createArgParser([dataSuffix]) Create default argument parser.
createData(sensors, scheme) Create an empty data set.
createFOP([verbose]) Create forward operator.
createFOP_([verbose]) Create forward operator working on refined mesh.
createInv(fop[, verbose, doSave]) TODO.
createInv_(fop[, verbose, dosave]) Create inversion instance, data- and model transformations.
dataToken() Token name for the data in a DataContainer.
estimateError(data[, absoluteError, …]) Estimate error composed of an absolute and a relative part.
invert(data, **kwargs) TODO.
model() Return the actual model.
saveResult([folder, size]) Save results in the specified folder.
setData(data) TODO.
setDataToken(token) Set the token name to identity the data in a DataContainer.
setMesh(mesh) TODO.
setVerbose(verbose) Make the class verbose (put output to the console)
show(data[, values, axes, cMin, cMax, colorBar]) Forward the visualization.
showData([axes, response, name]) Show data.
showModel(**showkwargs) TODO.
showResult([ax, cMin, cMax, logScale]) Show resulting vector.
simulate(**kwargs) Run a simulation aka the forward task.
__init__(manager, trans, **kwargs)[source]

TODO.

apparentData()

Convert data into apparent data.

checkData()

Check data validity.

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

createData(sensors, scheme)

Create an empty data set.

static createFOP(verbose=False)

Create forward operator.

createFOP_(verbose=False)

Create forward operator working on refined mesh.

createInv(fop, verbose=True, doSave=False)

TODO.

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

Create inversion instance, data- and model transformations.

dataToken()

Token name for the data in a DataContainer.

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

Estimate error composed of an absolute and a relative part.

invert(data, **kwargs)[source]

TODO.

model()

Return the actual model.

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

Save results in the specified folder.

setData(data)

TODO.

setDataToken(token)

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

setMesh(mesh)

TODO.

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(axes=None, response=None, name='data')

Show data.

showModel(**showkwargs)

TODO.

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

Show resulting vector.

simulate(**kwargs)

Run a simulation aka the forward task.

PetroJointModelling

class pygimli.physics.petro.PetroJointModelling(f=None, p=None, mesh=None, verbose=True)[source]

Cumulative (joint) forward operator for petrophysical inversions.

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(model) Creating individual Jacobian matrices.
createMappedModel((object)arg1, …) Read only extrapolation of model values given per cell marker to values given per cell.
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.
initConstraints((object)arg1) C++ signature :
initJacobian() TODO.
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(model) Create concatenated response for fop stack with model.
response_mt((object)arg1, (object)model [, …) C++ signature :
setConstraints((object)arg1, (object)C) C++ signature :
setData(data) TODO.
setFopsAndTrans(fops, trans) TODO.
setJacobian((object)arg1, (object)J) C++ signature :
setMesh(mesh) TODO.
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  
responses  
__init__(f=None, p=None, mesh=None, verbose=True)[source]

Constructor.

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]

Creating individual Jacobian matrices.

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((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})
initConstraints((object)arg1) → object :
C++ signature :
void* initConstraints(GIMLI::ModellingBase {lvalue})

initConstraints( (object)arg1) -> object :

C++ signature :
void* initConstraints(ModellingBase_wrapper {lvalue})
initJacobian()[source]

TODO.

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

Create concatenated response for fop stack with model.

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]

TODO.

setFopsAndTrans(fops, trans)[source]

TODO.

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

TODO.

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})
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})

PetroModelling

class pygimli.physics.petro.PetroModelling(fop, trans, mesh=None, verbose=False)[source]

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

Combine petrophysical relation m(p) with modelling class f(p) to invert for m (or any inversion transformation) instead of p.

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(model) Fill the individual jacobian matrices.
createMappedModel((object)arg1, …) Read only extrapolation of model values given per cell marker to values given per cell.
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.
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(model) Use inverse transformation to get p(m) and compute response.
response_mt((object)arg1, (object)model [, …) C++ signature :
setConstraints((object)arg1, (object)C) C++ signature :
setData(data) TODO.
setJacobian((object)arg1, (object)J) C++ signature :
setMesh(mesh) TODO.
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  
responses  
__init__(fop, trans, mesh=None, verbose=False)[source]

Save forward class and transformation, create Jacobian matrix.

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]

Fill the individual jacobian matrices.

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

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

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]

TODO.

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

TODO.

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})
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.