\[\renewcommand{\div}{\nabla\cdot\,} \newcommand{\grad}{\vec \nabla} \newcommand{\curl}{{\vec \nabla}\times\,} \newcommand {\J}{{\vec J}} \renewcommand{\H}{{\vec H}} \newcommand {\E}{{\vec E}} \newcommand{\dcurl}{{\mathbf C}} \newcommand{\dgrad}{{\mathbf G}} \newcommand{\Acf}{{\mathbf A_c^f}} \newcommand{\Ace}{{\mathbf A_c^e}} \renewcommand{\S}{{\mathbf \Sigma}} \newcommand{\St}{{\mathbf \Sigma_\tau}} \newcommand{\T}{{\mathbf T}} \newcommand{\Tt}{{\mathbf T_\tau}} \newcommand{\diag}[1]{\,{\sf diag}\left( #1 \right)} \newcommand{\M}{{\mathbf M}} \newcommand{\MfMui}{{\M^f_{\mu^{-1}}}} \newcommand{\MeSig}{{\M^e_\sigma}} \newcommand{\MeSigInf}{{\M^e_{\sigma_\infty}}} \newcommand{\MeSigO}{{\M^e_{\sigma_0}}} \newcommand{\Me}{{\M^e}} \newcommand{\Mes}[1]{{\M^e_{#1}}} \newcommand{\Mee}{{\M^e_e}} \newcommand{\Mej}{{\M^e_j}} \newcommand{\BigO}[1]{\mathcal{O}\bigl(#1\bigr)} \newcommand{\bE}{\mathbf{E}} \newcommand{\bH}{\mathbf{H}} \newcommand{\B}{\vec{B}} \newcommand{\D}{\vec{D}} \renewcommand{\H}{\vec{H}} \newcommand{\s}{\vec{s}} \newcommand{\bfJ}{\bf{J}} \newcommand{\vecm}{\vec m} \renewcommand{\Re}{\mathsf{Re}} \renewcommand{\Im}{\mathsf{Im}} \renewcommand {\j} { {\vec j} } \newcommand {\h} { {\vec h} } \renewcommand {\b} { {\vec b} } \newcommand {\e} { {\vec e} } \newcommand {\c} { {\vec c} } \renewcommand {\d} { {\vec d} } \renewcommand {\u} { {\vec u} } \newcommand{\I}{\vec{I}}\]

Time Domain Electromagnetics

The quasi-static time domain Maxwell’s equations are given by

\[\begin{split}\curl \vec{e} + \frac{\partial \vec{b}}{\partial t} = \vec{s}_m \\ \curl \vec{h} - \vec{j} = \vec{s}_e\end{split}\]

where:

  • \(\vec{e}\) is the electric field
  • \(\vec{b}\) is the magnetic flux
  • \(\vec{h}\) is the magnetic field
  • \(\vec{j}\) is the current density
  • \(\vec{s}_m\) is the magnetic source term
  • \(\vec{s}_e\) is the electric source term

Note

These docs are under construction. More to come soon!

TDEM Problem

class SimPEG.EM.TDEM.ProblemTDEM.BaseTDEMProblem(mesh, **kwargs)[source]

Bases: SimPEG.Problem.BaseTimeProblem, SimPEG.EM.Base.BaseEMProblem

We start with the first order form of Maxwell’s equations, eliminate and solve the second order form. For the time discretization, we use backward Euler.

Optional Properties:

  • model (Model): Inversion model., a numpy array of <type ‘float’>, <type ‘int’> with shape (*)
  • mu (PhysicalProperty): Magnetic Permeability (H/m), a physical property, Default: 1.25663706144e-06
  • mui (PhysicalProperty): Inverse Magnetic Permeability (m/H), a physical property
  • rho (PhysicalProperty): Electrical resistivity (Ohm m), a physical property
  • rhoMap (Mapping): Mapping of Electrical resistivity (Ohm m) to the inversion model., a SimPEG Map
  • sigma (PhysicalProperty): Electrical conductivity (S/m), a physical property
  • sigmaMap (Mapping): Mapping of Electrical conductivity (S/m) to the inversion model., a SimPEG Map

Other Properties:

  • rhoDeriv (Derivative): Derivative of Electrical resistivity (Ohm m) wrt the model.
  • sigmaDeriv (Derivative): Derivative of Electrical conductivity (S/m) wrt the model.
surveyPair

A SimPEG.EM.TDEM.SurveyTDEM Class

alias of Survey

fieldsPair

A SimPEG.EM.TDEM.FieldsTDEM Class

alias of FieldsTDEM

fields(m)[source]

Solve the forward problem for the fields.

Parameters:m (numpy.array) – inversion model (nP,)
Return type:SimPEG.EM.TDEM.FieldsTDEM
Return F:fields object
Jvec(m, v, f=None)[source]

Jvec computes the sensitivity times a vector

\[\mathbf{J} \mathbf{v} = \frac{d\mathbf{P}}{d\mathbf{F}} \left( \frac{d\mathbf{F}}{d\mathbf{u}} \frac{d\mathbf{u}}{d\mathbf{m}} + \frac{\partial\mathbf{F}}{\partial\mathbf{m}} \right) \mathbf{v}\]

where

\[\mathbf{A} \frac{d\mathbf{u}}{d\mathbf{m}} + \frac{\partial \mathbf{A}(\mathbf{u}, \mathbf{m})} {\partial\mathbf{m}} = \frac{d \mathbf{RHS}}{d \mathbf{m}}\]
Jtvec(m, v, f=None)[source]

Jvec computes the adjoint of the sensitivity times a vector

\[\mathbf{J}^\top \mathbf{v} = \left( \frac{d\mathbf{u}}{d\mathbf{m}} ^ \top \frac{d\mathbf{F}}{d\mathbf{u}} ^ \top + \frac{\partial\mathbf{F}}{\partial\mathbf{m}} ^ \top \right) \frac{d\mathbf{P}}{d\mathbf{F}} ^ \top \mathbf{v}\]

where

\[\frac{d\mathbf{u}}{d\mathbf{m}} ^\top \mathbf{A}^\top + \frac{d\mathbf{A}(\mathbf{u})}{d\mathbf{m}} ^ \top = \frac{d \mathbf{RHS}}{d \mathbf{m}} ^ \top\]
getSourceTerm(tInd)[source]

Assemble the source term. This ensures that the RHS is a vector / array of the correct size

getInitialFields()[source]

Ask the sources for initial fields

getInitialFieldsDeriv(src, v, adjoint=False)[source]
class SimPEG.EM.TDEM.ProblemTDEM.Problem3D_b(mesh, **kwargs)[source]

Bases: SimPEG.EM.TDEM.ProblemTDEM.BaseTDEMProblem

Starting from the quasi-static E-B formulation of Maxwell’s equations (semi-discretized)

\[\begin{split}\mathbf{C} \mathbf{e} + \frac{\partial \mathbf{b}}{\partial t} = \mathbf{s_m} \\ \mathbf{C}^{\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b} - \mathbf{M_{\sigma}^e} \mathbf{e} = \mathbf{s_e}\end{split}\]

where \(\mathbf{s_e}\) is an integrated quantity, we eliminate \(\mathbf{e}\) using

\[\mathbf{e} = \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b} - \mathbf{M_{\sigma}^e}^{-1} \mathbf{s_e}\]

to obtain a second order semi-discretized system in \(\mathbf{b}\)

\[\mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b} + \frac{\partial \mathbf{b}}{\partial t} = \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{s_e} + \mathbf{s_m}\]

and moving everything except the time derivative to the rhs gives

\[\frac{\partial \mathbf{b}}{\partial t} = -\mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b} + \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{s_e} + \mathbf{s_m}\]

For the time discretization, we use backward euler. To solve for the \(n+1\) th time step, we have

\[\frac{\mathbf{b}^{n+1} - \mathbf{b}^{n}}{\mathbf{dt}} = -\mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b}^{n+1} + \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{s_e}^{n+1} + \mathbf{s_m}^{n+1}\]

re-arranging to put \(\mathbf{b}^{n+1}\) on the left hand side gives

\[(\mathbf{I} + \mathbf{dt} \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\top} \mathbf{M_{\mu^{-1}}^f}) \mathbf{b}^{n+1} = \mathbf{b}^{n} + \mathbf{dt}(\mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{s_e}^{n+1} + \mathbf{s_m}^{n+1})\]

Optional Properties:

  • model (Model): Inversion model., a numpy array of <type ‘float’>, <type ‘int’> with shape (*)
  • mu (PhysicalProperty): Magnetic Permeability (H/m), a physical property, Default: 1.25663706144e-06
  • mui (PhysicalProperty): Inverse Magnetic Permeability (m/H), a physical property
  • rho (PhysicalProperty): Electrical resistivity (Ohm m), a physical property
  • rhoMap (Mapping): Mapping of Electrical resistivity (Ohm m) to the inversion model., a SimPEG Map
  • sigma (PhysicalProperty): Electrical conductivity (S/m), a physical property
  • sigmaMap (Mapping): Mapping of Electrical conductivity (S/m) to the inversion model., a SimPEG Map

Other Properties:

  • rhoDeriv (Derivative): Derivative of Electrical resistivity (Ohm m) wrt the model.
  • sigmaDeriv (Derivative): Derivative of Electrical conductivity (S/m) wrt the model.
fieldsPair

A SimPEG.EM.TDEM.Fields3D_b object

alias of Fields3D_b

surveyPair

alias of Survey

getAdiag(tInd)[source]

System matrix at a given time index

\[(\mathbf{I} + \mathbf{dt} \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\top} \mathbf{M_{\mu^{-1}}^f})\]
getAdiagDeriv(tInd, u, v, adjoint=False)[source]

Derivative of ADiag

getAsubdiag(tInd)[source]

Matrix below the diagonal

getAsubdiagDeriv(tInd, u, v, adjoint=False)[source]
getRHS(tInd)[source]

Assemble the RHS

getRHSDeriv(tInd, src, v, adjoint=False)[source]

Derivative of the RHS

class SimPEG.EM.TDEM.ProblemTDEM.Problem3D_e(mesh, **kwargs)[source]

Bases: SimPEG.EM.TDEM.ProblemTDEM.BaseTDEMProblem

Solve the EB-formulation of Maxwell’s equations for the electric field, e.

Starting with

\[\nabla \times \mathbf{e} + \frac{\partial \mathbf{b}}{\partial t} = \mathbf{s_m} \ \nabla \times \mu^{-1} \mathbf{b} - \sigma \mathbf{e} = \mathbf{s_e}\]

we eliminate \(\frac{\partial b}{\partial t}\) using

\[\frac{\partial \mathbf{b}}{\partial t} = - \nabla \times \mathbf{e} + \mathbf{s_m}\]

taking the time-derivative of Ampere’s law, we see

\[\frac{\partial}{\partial t}\left( \nabla \times \mu^{-1} \mathbf{b} - \sigma \mathbf{e} \right) = \frac{\partial \mathbf{s_e}}{\partial t} \ \nabla \times \mu^{-1} \frac{\partial \mathbf{b}}{\partial t} - \sigma \frac{\partial\mathbf{e}}{\partial t} = \frac{\partial \mathbf{s_e}}{\partial t}\]

which gives us

\[\nabla \times \mu^{-1} \nabla \times \mathbf{e} + \sigma \frac{\partial\mathbf{e}}{\partial t} = \nabla \times \mu^{-1} \mathbf{s_m} + \frac{\partial \mathbf{s_e}}{\partial t}\]

Optional Properties:

  • model (Model): Inversion model., a numpy array of <type ‘float’>, <type ‘int’> with shape (*)
  • mu (PhysicalProperty): Magnetic Permeability (H/m), a physical property, Default: 1.25663706144e-06
  • mui (PhysicalProperty): Inverse Magnetic Permeability (m/H), a physical property
  • rho (PhysicalProperty): Electrical resistivity (Ohm m), a physical property
  • rhoMap (Mapping): Mapping of Electrical resistivity (Ohm m) to the inversion model., a SimPEG Map
  • sigma (PhysicalProperty): Electrical conductivity (S/m), a physical property
  • sigmaMap (Mapping): Mapping of Electrical conductivity (S/m) to the inversion model., a SimPEG Map

Other Properties:

  • rhoDeriv (Derivative): Derivative of Electrical resistivity (Ohm m) wrt the model.
  • sigmaDeriv (Derivative): Derivative of Electrical conductivity (S/m) wrt the model.
fieldsPair

A Fields3D_e

alias of Fields3D_e

surveyPair

alias of Survey

getAdiag(tInd)[source]

Diagonal of the system matrix at a given time index

getAdiagDeriv(tInd, u, v, adjoint=False)[source]

Deriv of ADiag with respect to electrical conductivity

getAsubdiag(tInd)[source]

Matrix below the diagonal

getAsubdiagDeriv(tInd, u, v, adjoint=False)[source]

Derivative of the matrix below the diagonal with respect to electrical conductivity

getRHS(tInd)[source]

right hand side

getRHSDeriv(tInd, src, v, adjoint=False)[source]
class SimPEG.EM.TDEM.ProblemTDEM.Problem3D_h(mesh, **kwargs)[source]

Bases: SimPEG.EM.TDEM.ProblemTDEM.BaseTDEMProblem

Solve the H-J formulation of Maxwell’s equations for the magnetic field h.

We start with Maxwell’s equations in terms of the magnetic field and current density

\[\nabla \times \rho \mathbf{j} + \mu \frac{\partial h}{\partial t} = \mathbf{s_m} \ \nabla \times \mathbf{h} - \mathbf{j} = \mathbf{s_e}\]

and eliminate \(\mathbf{j}\) using

\[\mathbf{j} = \nabla \times \mathbf{h} - \mathbf{s_e}\]

giving

\[\nabla \times \rho \nabla \times \mathbf{h} + \mu \frac{\partial h}{\partial t} = \nabla \times \rho \mathbf{s_e} + \mathbf{s_m}\]

Optional Properties:

  • model (Model): Inversion model., a numpy array of <type ‘float’>, <type ‘int’> with shape (*)
  • mu (PhysicalProperty): Magnetic Permeability (H/m), a physical property, Default: 1.25663706144e-06
  • mui (PhysicalProperty): Inverse Magnetic Permeability (m/H), a physical property
  • rho (PhysicalProperty): Electrical resistivity (Ohm m), a physical property
  • rhoMap (Mapping): Mapping of Electrical resistivity (Ohm m) to the inversion model., a SimPEG Map
  • sigma (PhysicalProperty): Electrical conductivity (S/m), a physical property
  • sigmaMap (Mapping): Mapping of Electrical conductivity (S/m) to the inversion model., a SimPEG Map

Other Properties:

  • rhoDeriv (Derivative): Derivative of Electrical resistivity (Ohm m) wrt the model.
  • sigmaDeriv (Derivative): Derivative of Electrical conductivity (S/m) wrt the model.
fieldsPair

Fields object pair

alias of Fields3D_h

surveyPair

alias of Survey

getAdiag(tInd)[source]

System matrix at a given time index

getAdiagDeriv(tInd, u, v, adjoint=False)[source]
getAsubdiag(tInd)[source]
getAsubdiagDeriv(tInd, u, v, adjoint=False)[source]
getRHS(tInd)[source]
getRHSDeriv(tInd, src, v, adjoint=False)[source]
class SimPEG.EM.TDEM.ProblemTDEM.Problem3D_j(mesh, **kwargs)[source]

Bases: SimPEG.EM.TDEM.ProblemTDEM.BaseTDEMProblem

Solve the H-J formulation for current density

In this case, we eliminate \(\partial \mathbf{h} / \partial t\) and solve for \(\mathbf{j}\)

Optional Properties:

  • model (Model): Inversion model., a numpy array of <type ‘float’>, <type ‘int’> with shape (*)
  • mu (PhysicalProperty): Magnetic Permeability (H/m), a physical property, Default: 1.25663706144e-06
  • mui (PhysicalProperty): Inverse Magnetic Permeability (m/H), a physical property
  • rho (PhysicalProperty): Electrical resistivity (Ohm m), a physical property
  • rhoMap (Mapping): Mapping of Electrical resistivity (Ohm m) to the inversion model., a SimPEG Map
  • sigma (PhysicalProperty): Electrical conductivity (S/m), a physical property
  • sigmaMap (Mapping): Mapping of Electrical conductivity (S/m) to the inversion model., a SimPEG Map

Other Properties:

  • rhoDeriv (Derivative): Derivative of Electrical resistivity (Ohm m) wrt the model.
  • sigmaDeriv (Derivative): Derivative of Electrical conductivity (S/m) wrt the model.
fieldsPair

Fields object pair

alias of Fields3D_j

surveyPair

survey

alias of Survey

getAdiag(tInd)[source]

System matrix at a given time index

getAdiagDeriv(tInd, u, v, adjoint=False)[source]
getAsubdiag(tInd)[source]
getAsubdiagDeriv(tInd, u, v, adjoint=False)[source]
getRHS(tInd)[source]
getRHSDeriv(tInd, src, v, adjoint=False)[source]

Fields

class SimPEG.EM.TDEM.FieldsTDEM.FieldsTDEM(mesh, survey, **kwargs)[source]

Bases: SimPEG.Fields.TimeFields

Fancy Field Storage for a TDEM survey. Only one field type is stored for each problem, the rest are computed. The fields obejct acts like an array and is indexed by

f = problem.fields(m)
e = f[srcList,'e']
b = f[srcList,'b']

If accessing all sources for a given field, use the :

f = problem.fields(m)
e = f[:,'e']
b = f[:,'b']

The array returned will be size (nE or nF, nSrcs \(\times\) nFrequencies)

knownFields = {}
dtype

alias of float

aliasFields = None
approxSize

The approximate cost to storing all of the known fields.

startup()
class SimPEG.EM.TDEM.FieldsTDEM.Fields_Derivs(mesh, survey, **kwargs)[source]

Bases: SimPEG.EM.TDEM.FieldsTDEM.FieldsTDEM

A fields object for satshing derivs

knownFields = {'jDeriv': 'F', 'dhdtDeriv': 'E', 'eDeriv': 'E', 'hDeriv': 'E', 'dbdtDeriv': 'F', 'bDeriv': 'F'}
aliasFields = None
approxSize

The approximate cost to storing all of the known fields.

dtype

alias of float

startup()
class SimPEG.EM.TDEM.FieldsTDEM.Fields3D_b(mesh, survey, **kwargs)[source]

Bases: SimPEG.EM.TDEM.FieldsTDEM.FieldsTDEM

Field Storage for a TDEM survey.

knownFields = {'bSolution': 'F'}
aliasFields = {'dbdt': ['bSolution', 'F', '_dbdt'], 'b': ['bSolution', 'F', '_b'], 'e': ['bSolution', 'E', '_e']}
startup()[source]
approxSize

The approximate cost to storing all of the known fields.

dtype

alias of float

class SimPEG.EM.TDEM.FieldsTDEM.Fields3D_e(mesh, survey, **kwargs)[source]

Bases: SimPEG.EM.TDEM.FieldsTDEM.FieldsTDEM

Fancy Field Storage for a TDEM survey.

knownFields = {'eSolution': 'E'}
aliasFields = {'dbdt': ['eSolution', 'F', '_dbdt'], 'b': ['eSolution', 'F', '_b'], 'e': ['eSolution', 'E', '_e']}
startup()[source]
approxSize

The approximate cost to storing all of the known fields.

dtype

alias of float

class SimPEG.EM.TDEM.FieldsTDEM.Fields3D_h(mesh, survey, **kwargs)[source]

Bases: SimPEG.EM.TDEM.FieldsTDEM.FieldsTDEM

Fancy Field Storage for a TDEM survey.

knownFields = {'hSolution': 'E'}
aliasFields = {'dhdt': ['hSolution', 'E', '_dhdt'], 'h': ['hSolution', 'E', '_h'], 'j': ['hSolution', 'F', '_j']}
startup()[source]
approxSize

The approximate cost to storing all of the known fields.

dtype

alias of float

class SimPEG.EM.TDEM.FieldsTDEM.Fields3D_j(mesh, survey, **kwargs)[source]

Bases: SimPEG.EM.TDEM.FieldsTDEM.FieldsTDEM

Fancy Field Storage for a TDEM survey.

knownFields = {'jSolution': 'F'}
aliasFields = {'dhdt': ['jSolution', 'E', '_dhdt'], 'j': ['jSolution', 'F', '_j']}
startup()[source]
approxSize

The approximate cost to storing all of the known fields.

dtype

alias of float

Sources

class SimPEG.EM.TDEM.SrcTDEM.BaseWaveform(**kwargs)[source]

Bases: object

hasInitialFields = <properties.basic.Bool object>
offTime = <properties.basic.Float object>
eval(time)[source]
evalDeriv(time)[source]
class SimPEG.EM.TDEM.SrcTDEM.StepOffWaveform(offTime=0.0)[source]

Bases: SimPEG.EM.TDEM.SrcTDEM.BaseWaveform

eval(time)[source]
evalDeriv(time)
hasInitialFields = <properties.basic.Bool object>
offTime = <properties.basic.Float object>
class SimPEG.EM.TDEM.SrcTDEM.RawWaveform(offTime=0.0, waveFct=None, **kwargs)[source]

Bases: SimPEG.EM.TDEM.SrcTDEM.BaseWaveform

eval(time)[source]
evalDeriv(time)
hasInitialFields = <properties.basic.Bool object>
offTime = <properties.basic.Float object>
class SimPEG.EM.TDEM.SrcTDEM.TriangularWaveform(offTime=0.0)[source]

Bases: SimPEG.EM.TDEM.SrcTDEM.BaseWaveform

eval(time)[source]
evalDeriv(time)
hasInitialFields = <properties.basic.Bool object>
offTime = <properties.basic.Float object>
class SimPEG.EM.TDEM.SrcTDEM.BaseTDEMSrc(rxList, waveform=<SimPEG.EM.TDEM.SrcTDEM.StepOffWaveform object>, **kwargs)[source]

Bases: SimPEG.EM.Base.BaseEMSrc

Required Properties:

  • integrate (Bool): integrate the source term?, a boolean, Default: False
waveformPair

type of waveform to pair with

alias of BaseWaveform

waveform

source waveform

bInitial(prob)[source]
bInitialDeriv(prob, v=None, adjoint=False)[source]
eInitial(prob)[source]
eInitialDeriv(prob, v=None, adjoint=False)[source]
hInitial(prob)[source]
hInitialDeriv(prob, v=None, adjoint=False)[source]
jInitial(prob)[source]
jInitialDeriv(prob, v=None, adjoint=False)[source]
eval(prob, time)[source]
evalDeriv(prob, time, v=None, adjoint=False)[source]
s_m(prob, time)[source]
s_e(prob, time)[source]
s_mDeriv(prob, time, v=None, adjoint=False)[source]
s_eDeriv(prob, time, v=None, adjoint=False)[source]
deserialize(value, trusted=False, verbose=True, **kwargs)

Creates HasProperties instance from serialized dictionary

This uses the Property deserializers to deserialize all JSON-compatible dictionary values into their corresponding Property values on a new instance of a HasProperties class. Extra keys in the dictionary that do not correspond to Properties will be ignored.

Parameters:

  • value - Dictionary to deserialize new instance from.
  • trusted - If True (and if the input dictionary has '__class__' keyword and this class is in the registry), the new HasProperties class will come from the dictionary. If False (the default), only the HasProperties class this method is called on will be constructed.
  • verbose - Raise warnings if '__class__' is not found in the registry or of there are unused Property values in the input dictionary. Default is True.
  • Any other keyword arguments will be passed through to the Property deserializers.
equal(*args, **kwargs)

Determine if two HasProperties instances are equivalent

Equivalence is determined by checking if all Property values on two instances are equal, using Property.equal.

integrate

integrate the source term?

loc = None
nD

Number of data

rxList = None
rxPair

alias of BaseRx

serialize(*args, **kwargs)

Serializes a HasProperties instance to dictionary

This uses the Property serializers to serialize all Property values to a JSON-compatible dictionary. Properties that are undefined are not included. If the HasProperties instance contains a reference to itself, a properties.SelfReferenceError will be raised.

Parameters:

  • include_class - If True (the default), the name of the class will also be saved to the serialized dictionary under key '__class__'
  • Any other keyword arguments will be passed through to the Property serializers.
validate(*args, **kwargs)

Call all registered class validator methods

These are all methods decorated with @properties.validator. Validator methods are expected to raise an error if they fail.

vnD

Vector number of data

class SimPEG.EM.TDEM.SrcTDEM.MagDipole(rxList, **kwargs)[source]

Bases: SimPEG.EM.TDEM.SrcTDEM.BaseTDEMSrc

Required Properties:

  • integrate (Bool): integrate the source term?, a boolean, Default: False
  • moment (Float): dipole moment of the transmitter, a float in range [0.0, inf], Default: 1.0
  • mu (Float): permeability of the background, a float in range [0.0, inf], Default: 1.25663706144e-06
  • orientation (Vector3): orientation of the source, a 3D Vector of <type ‘float’> with shape (3), Default: Z
moment

dipole moment of the transmitter

mu

permeability of the background

orientation

orientation of the source

bInitial(prob)[source]
hInitial(prob)[source]
eInitial(prob)[source]
eInitialDeriv(prob, v=None, adjoint=False)[source]
s_m(prob, time)[source]
s_e(prob, time)[source]
bInitialDeriv(prob, v=None, adjoint=False)
deserialize(value, trusted=False, verbose=True, **kwargs)

Creates HasProperties instance from serialized dictionary

This uses the Property deserializers to deserialize all JSON-compatible dictionary values into their corresponding Property values on a new instance of a HasProperties class. Extra keys in the dictionary that do not correspond to Properties will be ignored.

Parameters:

  • value - Dictionary to deserialize new instance from.
  • trusted - If True (and if the input dictionary has '__class__' keyword and this class is in the registry), the new HasProperties class will come from the dictionary. If False (the default), only the HasProperties class this method is called on will be constructed.
  • verbose - Raise warnings if '__class__' is not found in the registry or of there are unused Property values in the input dictionary. Default is True.
  • Any other keyword arguments will be passed through to the Property deserializers.
equal(*args, **kwargs)

Determine if two HasProperties instances are equivalent

Equivalence is determined by checking if all Property values on two instances are equal, using Property.equal.

eval(prob, time)
evalDeriv(prob, time, v=None, adjoint=False)
hInitialDeriv(prob, v=None, adjoint=False)
integrate

integrate the source term?

jInitial(prob)
jInitialDeriv(prob, v=None, adjoint=False)
loc = None
nD

Number of data

rxList = None
rxPair

alias of BaseRx

s_eDeriv(prob, time, v=None, adjoint=False)
s_mDeriv(prob, time, v=None, adjoint=False)
serialize(*args, **kwargs)

Serializes a HasProperties instance to dictionary

This uses the Property serializers to serialize all Property values to a JSON-compatible dictionary. Properties that are undefined are not included. If the HasProperties instance contains a reference to itself, a properties.SelfReferenceError will be raised.

Parameters:

  • include_class - If True (the default), the name of the class will also be saved to the serialized dictionary under key '__class__'
  • Any other keyword arguments will be passed through to the Property serializers.
validate(*args, **kwargs)

Call all registered class validator methods

These are all methods decorated with @properties.validator. Validator methods are expected to raise an error if they fail.

vnD

Vector number of data

waveform

A waveform instance is not None

waveformPair

alias of BaseWaveform

class SimPEG.EM.TDEM.SrcTDEM.CircularLoop(rxList, **kwargs)[source]

Bases: SimPEG.EM.TDEM.SrcTDEM.MagDipole

Required Properties:

  • integrate (Bool): integrate the source term?, a boolean, Default: False
  • moment (Float): dipole moment of the transmitter, a float in range [0.0, inf], Default: 1.0
  • mu (Float): permeability of the background, a float in range [0.0, inf], Default: 1.25663706144e-06
  • orientation (Vector3): orientation of the source, a 3D Vector of <type ‘float’> with shape (3), Default: Z
  • radius (Float): radius of the loop source, a float in range [0.0, inf], Default: 1.0
bInitial(prob)
bInitialDeriv(prob, v=None, adjoint=False)
deserialize(value, trusted=False, verbose=True, **kwargs)

Creates HasProperties instance from serialized dictionary

This uses the Property deserializers to deserialize all JSON-compatible dictionary values into their corresponding Property values on a new instance of a HasProperties class. Extra keys in the dictionary that do not correspond to Properties will be ignored.

Parameters:

  • value - Dictionary to deserialize new instance from.
  • trusted - If True (and if the input dictionary has '__class__' keyword and this class is in the registry), the new HasProperties class will come from the dictionary. If False (the default), only the HasProperties class this method is called on will be constructed.
  • verbose - Raise warnings if '__class__' is not found in the registry or of there are unused Property values in the input dictionary. Default is True.
  • Any other keyword arguments will be passed through to the Property deserializers.
eInitial(prob)
eInitialDeriv(prob, v=None, adjoint=False)
equal(*args, **kwargs)

Determine if two HasProperties instances are equivalent

Equivalence is determined by checking if all Property values on two instances are equal, using Property.equal.

eval(prob, time)
evalDeriv(prob, time, v=None, adjoint=False)
hInitial(prob)
hInitialDeriv(prob, v=None, adjoint=False)
integrate

integrate the source term?

jInitial(prob)
jInitialDeriv(prob, v=None, adjoint=False)
loc = None
moment

dipole moment of the transmitter

mu

permeability of the background

nD

Number of data

orientation

orientation of the source

rxList = None
rxPair

alias of BaseRx

s_e(prob, time)
s_eDeriv(prob, time, v=None, adjoint=False)
s_m(prob, time)
s_mDeriv(prob, time, v=None, adjoint=False)
serialize(*args, **kwargs)

Serializes a HasProperties instance to dictionary

This uses the Property serializers to serialize all Property values to a JSON-compatible dictionary. Properties that are undefined are not included. If the HasProperties instance contains a reference to itself, a properties.SelfReferenceError will be raised.

Parameters:

  • include_class - If True (the default), the name of the class will also be saved to the serialized dictionary under key '__class__'
  • Any other keyword arguments will be passed through to the Property serializers.
validate(*args, **kwargs)

Call all registered class validator methods

These are all methods decorated with @properties.validator. Validator methods are expected to raise an error if they fail.

vnD

Vector number of data

waveform

A waveform instance is not None

waveformPair

alias of BaseWaveform

radius

radius of the loop source

Survey

class SimPEG.EM.TDEM.SurveyTDEM.Survey(srcList, **kwargs)[source]

Bases: SimPEG.Survey.BaseSurvey

Time domain electromagnetic survey

srcPair

alias of BaseTDEMSrc

rxPair = <module 'SimPEG.EM.TDEM.RxTDEM' from '/home/travis/build/simpeg/simpeg/SimPEG/EM/TDEM/RxTDEM.py'>
srcList

Source List

eval(u)[source]
evalDeriv(u, v=None, adjoint=False)[source]
counter = None
dobs = None
dpred(m, f=None)

Create the projected data from a model. The fields, f, (if provided) will be used for the predicted data instead of recalculating the fields (which may be expensive!).

\[d_\text{pred} = P(f(m))\]

Where P is a projection of the fields onto the data space.

Note

To use survey.dpred(), SimPEG requires that a problem be bound to the survey. If a problem has not been bound, an Exception will be raised. To bind a problem to the Data object:

survey.pair(myProblem)
dtrue = None
eps = None
getSourceIndex(sources)
isSynthetic

Check if the data is synthetic.

ispaired
makeSyntheticData(m, std=0.05, f=None, force=False)

Make synthetic data given a model, and a standard deviation.

Parameters:
  • m (numpy.array) – geophysical model
  • std (numpy.array) – standard deviation
  • u (numpy.array) – fields for the given model (if pre-calculated)
  • force (bool) – force overwriting of dobs
mesh

Mesh of the paired problem.

mtrue = None
nD

Number of data

nSrc

Number of Sources

pair(p)

Bind a problem to this survey instance using pointers

prob

The geophysical problem that explains this survey, use:

survey.pair(prob)
residual(m, f=None)
Parameters:
Return type:

numpy.array

Returns:

data residual

The data residual:

\[\mu_\text{data} = \mathbf{d}_\text{pred} - \mathbf{d}_\text{obs}\]
std = None
unpair()

Unbind a problem from this survey instance

vnD

Vector number of data