\[\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 Simulation

class SimPEG.electromagnetics.time_domain.simulation.BaseTDEMSimulation(*args, **kwargs)[source]

Bases: SimPEG.simulation.BaseTimeSimulation, SimPEG.electromagnetics.base.BaseEMSimulation

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.

Required Properties:

  • counter (Counter): A SimPEG.utils.Counter object, an instance of Counter

  • mesh (BaseMesh): a discretize mesh instance, an instance of BaseMesh

  • sensitivity_path (String): path to store the sensitivty, a unicode string, Default: ./sensitivity/

  • None

  • solver_opts (Dictionary): solver options as a kwarg dict, a dictionary

  • survey (Survey): a survey object, an instance of Survey

  • t0 (Float): Origin of the time discretization, a float, Default: 0.0

  • time_steps (TimeStepArray):

    Sets/gets the time steps for the time domain simulation. You can set as an array of dt’s or as a list of tuples/floats. Tuples must be length two with […, (dt, repeat), …] For example, the following setters are the same:

    sim.time_steps = [(1e-6, 3), 1e-5, (1e-4, 2)]
sim.time_steps = np.r_[1e-6,1e-6,1e-6,1e-5,1e-4,1e-4]

    , an array or list of tuples specifying the mesh tensor of <class ‘float’> with shape (*)

Optional Properties:

  • model (Model): Inversion model., a numpy array of <class ‘float’>, <class ‘int’> with shape (*, *) or (*)

  • mu (PhysicalProperty): Magnetic Permeability (H/m), a physical property, Default: 1.25663706212e-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.

clean_on_model_update = ['_Adcinv']

clear DC matrix factors on any model updates

dt_threshold = 1e-08
property survey

survey (Survey): a survey object, an instance of Survey

fields(m)[source]

Solve the forward problem for the fields.

Parameters

m (numpy.ndarray) – inversion model (nP,)

Return type

SimPEG.electromagnetics.time_domain.fields.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, f=None)[source]
property Adcinv
class SimPEG.electromagnetics.time_domain.simulation.Simulation3DMagneticFluxDensity(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.simulation.BaseTDEMSimulation

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

Required Properties:

  • counter (Counter): A SimPEG.utils.Counter object, an instance of Counter

  • mesh (BaseMesh): a discretize mesh instance, an instance of BaseMesh

  • sensitivity_path (String): path to store the sensitivty, a unicode string, Default: ./sensitivity/

  • None

  • solver_opts (Dictionary): solver options as a kwarg dict, a dictionary

  • survey (Survey): a survey object, an instance of Survey

  • t0 (Float): Origin of the time discretization, a float, Default: 0.0

  • time_steps (TimeStepArray):

    Sets/gets the time steps for the time domain simulation. You can set as an array of dt’s or as a list of tuples/floats. Tuples must be length two with […, (dt, repeat), …] For example, the following setters are the same:

    sim.time_steps = [(1e-6, 3), 1e-5, (1e-4, 2)]
sim.time_steps = np.r_[1e-6,1e-6,1e-6,1e-5,1e-4,1e-4]

    , an array or list of tuples specifying the mesh tensor of <class ‘float’> with shape (*)

Optional Properties:

  • model (Model): Inversion model., a numpy array of <class ‘float’>, <class ‘int’> with shape (*, *) or (*)

  • mu (PhysicalProperty): Magnetic Permeability (H/m), a physical property, Default: 1.25663706212e-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[source]

alias of SimPEG.electromagnetics.time_domain.fields.Fields3DMagneticFluxDensity

Fields_Derivs[source]

alias of SimPEG.electromagnetics.time_domain.fields.FieldsDerivativesEB

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.electromagnetics.time_domain.simulation.Simulation3DElectricField(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.simulation.BaseTDEMSimulation

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}\]

Required Properties:

  • counter (Counter): A SimPEG.utils.Counter object, an instance of Counter

  • mesh (BaseMesh): a discretize mesh instance, an instance of BaseMesh

  • sensitivity_path (String): path to store the sensitivty, a unicode string, Default: ./sensitivity/

  • None

  • solver_opts (Dictionary): solver options as a kwarg dict, a dictionary

  • survey (Survey): a survey object, an instance of Survey

  • t0 (Float): Origin of the time discretization, a float, Default: 0.0

  • time_steps (TimeStepArray):

    Sets/gets the time steps for the time domain simulation. You can set as an array of dt’s or as a list of tuples/floats. Tuples must be length two with […, (dt, repeat), …] For example, the following setters are the same:

    sim.time_steps = [(1e-6, 3), 1e-5, (1e-4, 2)]
sim.time_steps = np.r_[1e-6,1e-6,1e-6,1e-5,1e-4,1e-4]

    , an array or list of tuples specifying the mesh tensor of <class ‘float’> with shape (*)

Optional Properties:

  • model (Model): Inversion model., a numpy array of <class ‘float’>, <class ‘int’> with shape (*, *) or (*)

  • mu (PhysicalProperty): Magnetic Permeability (H/m), a physical property, Default: 1.25663706212e-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[source]

alias of SimPEG.electromagnetics.time_domain.fields.Fields3DElectricField

Fields_Derivs[source]

alias of SimPEG.electromagnetics.time_domain.fields.FieldsDerivativesEB

Jtvec(m, v, f=None)[source]

Jvec computes the adjoint of the sensitivity times a vector

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]
getAdc()[source]
getAdcDeriv(u, v, adjoint=False)[source]
class SimPEG.electromagnetics.time_domain.simulation.Simulation3DMagneticField(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.simulation.BaseTDEMSimulation

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}\]

Required Properties:

  • counter (Counter): A SimPEG.utils.Counter object, an instance of Counter

  • mesh (BaseMesh): a discretize mesh instance, an instance of BaseMesh

  • sensitivity_path (String): path to store the sensitivty, a unicode string, Default: ./sensitivity/

  • None

  • solver_opts (Dictionary): solver options as a kwarg dict, a dictionary

  • survey (Survey): a survey object, an instance of Survey

  • t0 (Float): Origin of the time discretization, a float, Default: 0.0

  • time_steps (TimeStepArray):

    Sets/gets the time steps for the time domain simulation. You can set as an array of dt’s or as a list of tuples/floats. Tuples must be length two with […, (dt, repeat), …] For example, the following setters are the same:

    sim.time_steps = [(1e-6, 3), 1e-5, (1e-4, 2)]
sim.time_steps = np.r_[1e-6,1e-6,1e-6,1e-5,1e-4,1e-4]

    , an array or list of tuples specifying the mesh tensor of <class ‘float’> with shape (*)

Optional Properties:

  • model (Model): Inversion model., a numpy array of <class ‘float’>, <class ‘int’> with shape (*, *) or (*)

  • mu (PhysicalProperty): Magnetic Permeability (H/m), a physical property, Default: 1.25663706212e-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[source]

alias of SimPEG.electromagnetics.time_domain.fields.Fields3DMagneticField

Fields_Derivs[source]

alias of SimPEG.electromagnetics.time_domain.fields.FieldsDerivativesHJ

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]
getAdc()[source]
getAdcDeriv(u, v, adjoint=False)[source]
class SimPEG.electromagnetics.time_domain.simulation.Simulation3DCurrentDensity(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.simulation.BaseTDEMSimulation

Solve the H-J formulation for current density

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

Required Properties:

  • counter (Counter): A SimPEG.utils.Counter object, an instance of Counter

  • mesh (BaseMesh): a discretize mesh instance, an instance of BaseMesh

  • sensitivity_path (String): path to store the sensitivty, a unicode string, Default: ./sensitivity/

  • None

  • solver_opts (Dictionary): solver options as a kwarg dict, a dictionary

  • survey (Survey): a survey object, an instance of Survey

  • t0 (Float): Origin of the time discretization, a float, Default: 0.0

  • time_steps (TimeStepArray):

    Sets/gets the time steps for the time domain simulation. You can set as an array of dt’s or as a list of tuples/floats. Tuples must be length two with […, (dt, repeat), …] For example, the following setters are the same:

    sim.time_steps = [(1e-6, 3), 1e-5, (1e-4, 2)]
sim.time_steps = np.r_[1e-6,1e-6,1e-6,1e-5,1e-4,1e-4]

    , an array or list of tuples specifying the mesh tensor of <class ‘float’> with shape (*)

Optional Properties:

  • model (Model): Inversion model., a numpy array of <class ‘float’>, <class ‘int’> with shape (*, *) or (*)

  • mu (PhysicalProperty): Magnetic Permeability (H/m), a physical property, Default: 1.25663706212e-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[source]

alias of SimPEG.electromagnetics.time_domain.fields.Fields3DCurrentDensity

Fields_Derivs[source]

alias of SimPEG.electromagnetics.time_domain.fields.FieldsDerivativesHJ

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]
getAdc()[source]
getAdcDeriv(u, v, adjoint=False)[source]
class SimPEG.electromagnetics.time_domain.simulation.Problem3D_e(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.simulation.Simulation3DElectricField

This class has been deprecated, see Simulation3DElectricField for documentation

class SimPEG.electromagnetics.time_domain.simulation.Problem3D_b(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.simulation.Simulation3DMagneticFluxDensity

This class has been deprecated, see Simulation3DMagneticFluxDensity for documentation

class SimPEG.electromagnetics.time_domain.simulation.Problem3D_h(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.simulation.Simulation3DMagneticField

This class has been deprecated, see Simulation3DMagneticField for documentation

class SimPEG.electromagnetics.time_domain.simulation.Problem3D_j(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.simulation.Simulation3DCurrentDensity

This class has been deprecated, see Simulation3DCurrentDensity for documentation

Fields

class SimPEG.electromagnetics.time_domain.fields.FieldsTDEM(*args, **kwargs)[source]

Bases: SimPEG.fields.TimeFields

Fancy Field Storage for a TDEM simulation. 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[source_list,'e']
b = f[source_list,'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)

Required Properties:

  • aliasFields (Dictionary):

    a dictionary of the aliased fields with [alias, location, function], e.g. {“b”:[“e”,”F”,lambda(F,e,ind)]} , a dictionary

  • simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

knownFields = {}
dtype

alias of builtins.float

property aliasFields

aliasFields (Dictionary): a dictionary of the aliased fields with [alias, location, function], e.g. {“b”:[“e”,”F”,lambda(F,e,ind)]} , a dictionary

property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

startup()[source]
property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.FieldsDerivativesEB(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.FieldsTDEM

A fields object for satshing derivs in the EB formulation

Required Properties:

  • aliasFields (Dictionary):

    a dictionary of the aliased fields with [alias, location, function], e.g. {“b”:[“e”,”F”,lambda(F,e,ind)]} , a dictionary

  • simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

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

aliasFields (Dictionary): a dictionary of the aliased fields with [alias, location, function], e.g. {“b”:[“e”,”F”,lambda(F,e,ind)]} , a dictionary

property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

startup()[source]
property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.FieldsDerivativesHJ(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.FieldsTDEM

A fields object for satshing derivs in the HJ formulation

Required Properties:

  • aliasFields (Dictionary):

    a dictionary of the aliased fields with [alias, location, function], e.g. {“b”:[“e”,”F”,lambda(F,e,ind)]} , a dictionary

  • simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

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

aliasFields (Dictionary): a dictionary of the aliased fields with [alias, location, function], e.g. {“b”:[“e”,”F”,lambda(F,e,ind)]} , a dictionary

property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

startup()[source]
property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.Fields3DMagneticFluxDensity(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.FieldsTDEM

Field Storage for a TDEM simulation.

Required Properties:

  • simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

knownFields = {'bSolution': 'F'}
aliasFields = {'b': ['bSolution', 'F', '_b'], 'dbdt': ['bSolution', 'F', '_dbdt'], 'dhdt': ['bSolution', 'F', '_dhdt'], 'e': ['bSolution', 'E', '_e'], 'h': ['bSolution', 'F', '_h'], 'j': ['bSolution', 'E', '_j']}
startup()[source]
property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.Fields3DElectricField(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.FieldsTDEM

Fancy Field Storage for a TDEM simulation.

Required Properties:

  • simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

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

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.Fields3DMagneticField(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.FieldsTDEM

Fancy Field Storage for a TDEM simulation.

Required Properties:

  • simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

knownFields = {'hSolution': 'E'}
aliasFields = {'b': ['hSolution', 'E', '_b'], 'charge': ['hSolution', 'CC', '_charge'], 'dbdt': ['hSolution', 'E', '_dbdt'], 'dhdt': ['hSolution', 'E', '_dhdt'], 'e': ['hSolution', 'F', '_e'], 'h': ['hSolution', 'E', '_h'], 'j': ['hSolution', 'F', '_j']}
startup()[source]
property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.Fields3DCurrentDensity(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.FieldsTDEM

Fancy Field Storage for a TDEM simulation.

Required Properties:

  • simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

knownFields = {'jSolution': 'F'}
aliasFields = {'charge': ['jSolution', 'CC', '_charge'], 'charge_density': ['jSolution', 'CC', '_charge_density'], 'dbdt': ['jSolution', 'E', '_dbdt'], 'dhdt': ['jSolution', 'E', '_dhdt'], 'e': ['jSolution', 'F', '_e'], 'j': ['jSolution', 'F', '_j']}
startup()[source]
property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.Fields_Derivs_eb(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.FieldsDerivativesEB

This class has been deprecated, see FieldsDerivativesEB for documentation

property aliasFields

aliasFields (Dictionary): a dictionary of the aliased fields with [alias, location, function], e.g. {“b”:[“e”,”F”,lambda(F,e,ind)]} , a dictionary

property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

knownFields = {'bDeriv': 'F', 'dbdtDeriv': 'F', 'dhdtDeriv': 'F', 'eDeriv': 'E', 'hDeriv': 'F', 'jDeriv': 'E'}
property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

startup()[source]
property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.Fields_Derivs_hj(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.FieldsDerivativesHJ

This class has been deprecated, see FieldsDerivativesHJ for documentation

property aliasFields

aliasFields (Dictionary): a dictionary of the aliased fields with [alias, location, function], e.g. {“b”:[“e”,”F”,lambda(F,e,ind)]} , a dictionary

property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

knownFields = {'bDeriv': 'E', 'dbdtDeriv': 'E', 'dhdtDeriv': 'E', 'eDeriv': 'F', 'hDeriv': 'E', 'jDeriv': 'F'}
property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

startup()[source]
property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.Fields3D_b(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.Fields3DMagneticFluxDensity

This class has been deprecated, see Fields3DMagneticFluxDensity for documentation

aliasFields = {'b': ['bSolution', 'F', '_b'], 'dbdt': ['bSolution', 'F', '_dbdt'], 'dhdt': ['bSolution', 'F', '_dhdt'], 'e': ['bSolution', 'E', '_e'], 'h': ['bSolution', 'F', '_h'], 'j': ['bSolution', 'E', '_j']}
property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

knownFields = {'bSolution': 'F'}
property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

startup()[source]
property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.Fields3D_e(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.Fields3DElectricField

This class has been deprecated, see Fields3DElectricField for documentation

aliasFields = {'b': ['eSolution', 'F', '_b'], 'dbdt': ['eSolution', 'F', '_dbdt'], 'dhdt': ['eSolution', 'F', '_dhdt'], 'e': ['eSolution', 'E', '_e'], 'j': ['eSolution', 'E', '_j']}
property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

knownFields = {'eSolution': 'E'}
property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

startup()[source]
property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.Fields3D_h(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.Fields3DMagneticField

This class has been deprecated, see Fields3DMagneticField for documentation

aliasFields = {'b': ['hSolution', 'E', '_b'], 'charge': ['hSolution', 'CC', '_charge'], 'dbdt': ['hSolution', 'E', '_dbdt'], 'dhdt': ['hSolution', 'E', '_dhdt'], 'e': ['hSolution', 'F', '_e'], 'h': ['hSolution', 'E', '_h'], 'j': ['hSolution', 'F', '_j']}
property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

knownFields = {'hSolution': 'E'}
property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

startup()[source]
property survey
validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.fields.Fields3D_j(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.fields.Fields3DCurrentDensity

This class has been deprecated, see Fields3DCurrentDensity for documentation

aliasFields = {'charge': ['jSolution', 'CC', '_charge'], 'charge_density': ['jSolution', 'CC', '_charge_density'], 'dbdt': ['jSolution', 'E', '_dbdt'], 'dhdt': ['jSolution', 'E', '_dhdt'], 'e': ['jSolution', 'F', '_e'], 'j': ['jSolution', 'F', '_j']}
property approxSize

The approximate cost to storing all of the known fields.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dtype

alias of builtins.float

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

knownFields = {'jSolution': 'F'}
property mesh
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property simulation

simulation (BaseTimeSimulation): a SimPEG time simulation, an instance of BaseTimeSimulation

startup()[source]
property survey
validate()[source]

Call all registered class validator methods

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

Sources

class SimPEG.electromagnetics.time_domain.sources.BaseWaveform(*args, **kwargs)[source]

Bases: properties.base.base.HasProperties

Required Properties:

  • eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

  • hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

  • offTime (Float): off-time of the source, a float, Default: 0.0

property hasInitialFields

hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

property offTime

offTime (Float): off-time of the source, a float, Default: 0.0

property eps

eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

eval(time)[source]
evalDeriv(time)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.sources.StepOffWaveform(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.BaseWaveform

Required Properties:

  • eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

  • hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

  • offTime (Float): off-time of the source, a float, Default: 0.0

eval(time)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

property eps

eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

evalDeriv(time)[source]
property hasInitialFields

hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

property offTime

offTime (Float): off-time of the source, a float, Default: 0.0

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.sources.RampOffWaveform(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.BaseWaveform

Required Properties:

  • eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

  • hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

  • offTime (Float): off-time of the source, a float, Default: 0.0

eval(time)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

property eps

eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

evalDeriv(time)[source]
property hasInitialFields

hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

property offTime

offTime (Float): off-time of the source, a float, Default: 0.0

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.sources.RawWaveform(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.BaseWaveform

Required Properties:

  • eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

  • hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

  • offTime (Float): off-time of the source, a float, Default: 0.0

eval(time)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

property eps

eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

evalDeriv(time)[source]
property hasInitialFields

hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

property offTime

offTime (Float): off-time of the source, a float, Default: 0.0

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.sources.VTEMWaveform(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.BaseWaveform

Required Properties:

  • a (Float): parameter controlling how quickly the waveform ramps on, a float, Default: 3.0

  • eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

  • hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

  • offTime (Float): off-time of the source, a float, Default: 0.0042

  • peakTime (Float): Time at which the VTEM waveform is at its peak, a float, Default: 0.00273

property offTime

offTime (Float): off-time of the source, a float, Default: 0.0042

property peakTime

peakTime (Float): Time at which the VTEM waveform is at its peak, a float, Default: 0.00273

property a

a (Float): parameter controlling how quickly the waveform ramps on, a float, Default: 3.0

eval(time)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

property eps

eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

evalDeriv(time)[source]
property hasInitialFields

hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.sources.TrapezoidWaveform(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.BaseWaveform

A waveform that has a linear ramp-on and a linear ramp-off.

Required Properties:

  • eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

  • hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

  • offTime (Float): off-time of the source, a float, Default: 0.0

  • ramp_off (Array): times over which we ramp off the waveform

    [time starting to ramp off, time off] , a list or numpy array of <class ‘float’> with shape (2)

  • ramp_on (Array): times over which the transmitter ramps on

    [time starting to ramp on, time fully on] , a list or numpy array of <class ‘float’> with shape (2)

property ramp_on

ramp_on (Array): times over which the transmitter ramps on [time starting to ramp on, time fully on] , a list or numpy array of <class ‘float’> with shape (2)

property ramp_off

ramp_off (Array): times over which we ramp off the waveform [time starting to ramp off, time off] , a list or numpy array of <class ‘float’> with shape (2)

property hasInitialFields

hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

eval(time)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

property eps

eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

evalDeriv(time)[source]
property offTime

offTime (Float): off-time of the source, a float, Default: 0.0

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.sources.TriangularWaveform(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.TrapezoidWaveform

TriangularWaveform is a special case of TrapezoidWaveform where there’s no pleateau

Required Properties:

  • eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

  • hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

  • offTime (Float): off-time of the source, a float

  • peakTime (Float): Time at which the Triangular waveform is at its peak, a float

  • ramp_off (Array): times over which we ramp off the waveform

    [time starting to ramp off, time off] , a list or numpy array of <class ‘float’> with shape (2)

  • ramp_on (Array): times over which the transmitter ramps on

    [time starting to ramp on, time fully on] , a list or numpy array of <class ‘float’> with shape (2)

property offTime

offTime (Float): off-time of the source, a float

property peakTime

peakTime (Float): Time at which the Triangular waveform is at its peak, a float

property hasInitialFields

hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

property ramp_on

ramp_on (Array): times over which the transmitter ramps on [time starting to ramp on, time fully on] , a list or numpy array of <class ‘float’> with shape (2)

property ramp_off

ramp_off (Array): times over which we ramp off the waveform [time starting to ramp off, time off] , a list or numpy array of <class ‘float’> with shape (2)

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

property eps

eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

equal(other)[source]

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(time)[source]
evalDeriv(time)[source]
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.sources.QuarterSineRampOnWaveform(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.BaseWaveform

A waveform that has a quarter-sine ramp-on and a linear ramp-off

Required Properties:

  • eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

  • hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

  • offTime (Float): off-time of the source, a float, Default: 0.0

  • ramp_off (Array): times over which we ramp off the waveform, a list or numpy array of <class ‘float’> with shape (2)

  • ramp_on (Array): times over which the transmitter ramps on, a list or numpy array of <class ‘float’> with shape (2)

property ramp_on

ramp_on (Array): times over which the transmitter ramps on, a list or numpy array of <class ‘float’> with shape (2)

property ramp_off

ramp_off (Array): times over which we ramp off the waveform, a list or numpy array of <class ‘float’> with shape (2)

property hasInitialFields

hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

eval(time)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

property eps

eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

evalDeriv(time)[source]
property offTime

offTime (Float): off-time of the source, a float, Default: 0.0

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.sources.HalfSineWaveform(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.BaseWaveform

A waveform that has a quarter-sine ramp-on and a quarter-cosine ramp-off. When the end of ramp-on and start of ramp off are on the same spot, it looks like a half sine wave.

Required Properties:

  • eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

  • hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

  • offTime (Float): off-time of the source, a float, Default: 0.0

  • ramp_off (Array): times over which we ramp off the waveform, a list or numpy array of <class ‘float’> with shape (2)

  • ramp_on (Array): times over which the transmitter ramps on, a list or numpy array of <class ‘float’> with shape (2)

property ramp_on

ramp_on (Array): times over which the transmitter ramps on, a list or numpy array of <class ‘float’> with shape (2)

property ramp_off

ramp_off (Array): times over which we ramp off the waveform, a list or numpy array of <class ‘float’> with shape (2)

property hasInitialFields

hasInitialFields (Boolean): Does the waveform have initial fields?, a boolean, Default: False

eval(time)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

property eps

eps (Float): window of time within which the waveform is considered on, a float, Default: 1e-09

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

evalDeriv(time)[source]
property offTime

offTime (Float): off-time of the source, a float, Default: 0.0

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.sources.BaseTDEMSrc(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.base.BaseEMSrc

Required Properties:

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

  • receiver_list (a list of BaseRx): receiver list, a list (each item is an instance of BaseRx)

  • srcType (StringChoice): is the source a galvanic of inductive source, either “inductive” or “galvanic”

  • waveform (BaseWaveform): A source waveform, an instance of BaseWaveform, Default: <SimPEG.electromagnetics.time_domain.sources.StepOffWaveform object at 0x7ffaed087828>

Optional Properties:

  • location (SourceLocationArray): Location of the source [x, y, z] in 3D, a 1D array denoting the source location of <class ‘float’>, <class ‘int’> with shape (*)

property waveform

waveform (BaseWaveform): A source waveform, an instance of BaseWaveform, Default: <SimPEG.electromagnetics.time_domain.sources.StepOffWaveform object at 0x7ffaed087828>

property srcType

srcType (StringChoice): is the source a galvanic of inductive source, either “inductive” or “galvanic”

bInitial(prob)[source]
bInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
eInitial(prob)[source]
eInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
hInitial(prob)[source]
hInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
jInitial(prob)[source]
jInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
eval(prob, time)[source]

  • \(s_m\) : magnetic source term

  • \(s_e\) : electric source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

tuple

Returns

tuple with magnetic source term and electric source term

evalDeriv(prob, time, v=None, adjoint=False)[source]

Derivatives of the source terms with respect to the inversion model - s_mDeriv : derivative of the magnetic source term - s_eDeriv : derivative of the electric source term

Parameters
Return type

tuple

Returns

tuple with magnetic source term and electric source term derivatives times a vector

s_m(prob, time)[source]

Magnetic source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

numpy.ndarray

Returns

magnetic source term on mesh

s_e(prob, time)[source]

Electric source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

numpy.ndarray

Returns

electric source term on mesh

s_mDeriv(prob, time, v=None, adjoint=False)[source]

Derivative of magnetic source term with respect to the inversion model

Parameters
Return type

numpy.ndarray

Returns

product of magnetic source term derivative with a vector

s_eDeriv(prob, time, v=None, adjoint=False)[source]

Derivative of electric source term with respect to the inversion model

Parameters
Return type

numpy.ndarray

Returns

product of electric source term derivative with a vector

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

getReceiverIndex(receiver)[source]
property integrate

integrate (Boolean): integrate the source term?, a boolean, Default: False

property loc

loc has been deprecated. See location for documentation

property location

location (SourceLocationArray): Location of the source [x, y, z] in 3D, a 1D array denoting the source location of <class ‘float’>, <class ‘int’> with shape (*)

property nD

Number of data

property receiver_list

receiver_list (a list of BaseRx): receiver list, a list (each item is an instance of BaseRx)

property rxList

rxList has been deprecated. See receiver_list for documentation

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

validate()[source]

Call all registered class validator methods

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

property vnD

Vector number of data

class SimPEG.electromagnetics.time_domain.sources.MagDipole(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.BaseTDEMSrc

Required Properties:

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

  • location (LocationVector): location of the source, A location array (1-dimensional numpy array) of <class ‘float’>, <class ‘int’> with shape (3), Default: [0. 0. 0.]

  • 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.25663706212e-06

  • orientation (Vector3): orientation of the source, a 3D Vector of <class ‘float’> with shape (3), Default: Z

  • receiver_list (a list of BaseRx): receiver list, a list (each item is an instance of BaseRx)

  • srcType (StringChoice): is the source a galvanic of inductive source, either “inductive” or “galvanic”

  • waveform (BaseWaveform): A source waveform, an instance of BaseWaveform, Default: <SimPEG.electromagnetics.time_domain.sources.StepOffWaveform object at 0x7ffaed087828>

property moment

moment (Float): dipole moment of the transmitter, a float in range [0.0, inf], Default: 1.0

property mu

mu (Float): permeability of the background, a float in range [0.0, inf], Default: 1.25663706212e-06

property orientation

orientation (Vector3): orientation of the source, a 3D Vector of <class ‘float’> with shape (3), Default: Z

property location

location (LocationVector): location of the source, A location array (1-dimensional numpy array) of <class ‘float’>, <class ‘int’> with shape (3), Default: [0. 0. 0.]

property loc

loc has been deprecated. See location for documentation

bInitial(prob)[source]
hInitial(prob)[source]
s_m(prob, time)[source]

Magnetic source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

numpy.ndarray

Returns

magnetic source term on mesh

s_e(prob, time)[source]

Electric source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

numpy.ndarray

Returns

electric source term on mesh

bInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

eInitial(prob)[source]
eInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
equal(other)[source]

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

  • \(s_m\) : magnetic source term

  • \(s_e\) : electric source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

tuple

Returns

tuple with magnetic source term and electric source term

evalDeriv(prob, time, v=None, adjoint=False)[source]

Derivatives of the source terms with respect to the inversion model - s_mDeriv : derivative of the magnetic source term - s_eDeriv : derivative of the electric source term

Parameters
Return type

tuple

Returns

tuple with magnetic source term and electric source term derivatives times a vector

getReceiverIndex(receiver)[source]
hInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
property integrate

integrate (Boolean): integrate the source term?, a boolean, Default: False

jInitial(prob)[source]
jInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
property nD

Number of data

property receiver_list

receiver_list (a list of BaseRx): receiver list, a list (each item is an instance of BaseRx)

property rxList

rxList has been deprecated. See receiver_list for documentation

s_eDeriv(prob, time, v=None, adjoint=False)[source]

Derivative of electric source term with respect to the inversion model

Parameters
Return type

numpy.ndarray

Returns

product of electric source term derivative with a vector

s_mDeriv(prob, time, v=None, adjoint=False)[source]

Derivative of magnetic source term with respect to the inversion model

Parameters
Return type

numpy.ndarray

Returns

product of magnetic source term derivative with a vector

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property srcType

srcType (StringChoice): is the source a galvanic of inductive source, either “inductive” or “galvanic”

validate()[source]

Call all registered class validator methods

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

property vnD

Vector number of data

property waveform

waveform (BaseWaveform): A source waveform, an instance of BaseWaveform, Default: <SimPEG.electromagnetics.time_domain.sources.StepOffWaveform object at 0x7ffaed087828>

class SimPEG.electromagnetics.time_domain.sources.CircularLoop(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.MagDipole

Required Properties:

  • N (Float): number of turns in the loop, a float, Default: 1.0

  • current (Float): current in the loop, a float, Default: 1.0

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

  • location (LocationVector): location of the source, A location array (1-dimensional numpy array) of <class ‘float’>, <class ‘int’> with shape (3), Default: [0. 0. 0.]

  • mu (Float): permeability of the background, a float in range [0.0, inf], Default: 1.25663706212e-06

  • orientation (Vector3): orientation of the source, a 3D Vector of <class ‘float’> with shape (3), Default: Z

  • radius (Float): radius of the loop source, a float in range [0.0, inf], Default: 1.0

  • receiver_list (a list of BaseRx): receiver list, a list (each item is an instance of BaseRx)

  • srcType (StringChoice): is the source a galvanic of inductive source, either “inductive” or “galvanic”

  • waveform (BaseWaveform): A source waveform, an instance of BaseWaveform, Default: <SimPEG.electromagnetics.time_domain.sources.StepOffWaveform object at 0x7ffaed087828>

property radius

radius (Float): radius of the loop source, a float in range [0.0, inf], Default: 1.0

property current

current (Float): current in the loop, a float, Default: 1.0

property N

N (Float): number of turns in the loop, a float, Default: 1.0

property moment

moment (Float): dipole moment of the transmitter, a float in range [0.0, inf], Default: 1.0

bInitial(prob)[source]
bInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

eInitial(prob)[source]
eInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
equal(other)[source]

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

  • \(s_m\) : magnetic source term

  • \(s_e\) : electric source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

tuple

Returns

tuple with magnetic source term and electric source term

evalDeriv(prob, time, v=None, adjoint=False)[source]

Derivatives of the source terms with respect to the inversion model - s_mDeriv : derivative of the magnetic source term - s_eDeriv : derivative of the electric source term

Parameters
Return type

tuple

Returns

tuple with magnetic source term and electric source term derivatives times a vector

getReceiverIndex(receiver)[source]
hInitial(prob)[source]
hInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
property integrate

integrate (Boolean): integrate the source term?, a boolean, Default: False

jInitial(prob)[source]
jInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
property loc

loc has been deprecated. See location for documentation

property location

location (LocationVector): location of the source, A location array (1-dimensional numpy array) of <class ‘float’>, <class ‘int’> with shape (3), Default: [0. 0. 0.]

property mu

mu (Float): permeability of the background, a float in range [0.0, inf], Default: 1.25663706212e-06

property nD

Number of data

property orientation

orientation (Vector3): orientation of the source, a 3D Vector of <class ‘float’> with shape (3), Default: Z

property receiver_list

receiver_list (a list of BaseRx): receiver list, a list (each item is an instance of BaseRx)

property rxList

rxList has been deprecated. See receiver_list for documentation

s_e(prob, time)[source]

Electric source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

numpy.ndarray

Returns

electric source term on mesh

s_eDeriv(prob, time, v=None, adjoint=False)[source]

Derivative of electric source term with respect to the inversion model

Parameters
Return type

numpy.ndarray

Returns

product of electric source term derivative with a vector

s_m(prob, time)[source]

Magnetic source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

numpy.ndarray

Returns

magnetic source term on mesh

s_mDeriv(prob, time, v=None, adjoint=False)[source]

Derivative of magnetic source term with respect to the inversion model

Parameters
Return type

numpy.ndarray

Returns

product of magnetic source term derivative with a vector

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property srcType

srcType (StringChoice): is the source a galvanic of inductive source, either “inductive” or “galvanic”

validate()[source]

Call all registered class validator methods

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

property vnD

Vector number of data

property waveform

waveform (BaseWaveform): A source waveform, an instance of BaseWaveform, Default: <SimPEG.electromagnetics.time_domain.sources.StepOffWaveform object at 0x7ffaed087828>

class SimPEG.electromagnetics.time_domain.sources.LineCurrent(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.BaseTDEMSrc

RawVec electric source. It is defined by the user provided vector s_e

param list rxList

receiver list

param bool integrate

Integrate the source term (multiply by Me) [False]

Required Properties:

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

  • location (Array): location of the source, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*, 3)

  • receiver_list (a list of BaseRx): receiver list, a list (each item is an instance of BaseRx)

  • srcType (StringChoice): is the source a galvanic of inductive source, either “inductive” or “galvanic”

  • waveform (BaseWaveform): A source waveform, an instance of BaseWaveform, Default: <SimPEG.electromagnetics.time_domain.sources.StepOffWaveform object at 0x7ffaed087828>

property location

location (Array): location of the source, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*, 3)

property loc

loc has been deprecated. See location for documentation

property integrate

integrate (Boolean): integrate the source term?, a boolean, Default: False

Mejs(prob)[source]
getRHSdc(prob)[source]
bInitial(prob)[source]
eInitial(prob)[source]
jInitial(prob)[source]
hInitial(prob)[source]
eInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
s_m(prob, time)[source]

Magnetic source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

numpy.ndarray

Returns

magnetic source term on mesh

s_e(prob, time)[source]

Electric source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

numpy.ndarray

Returns

electric source term on mesh

bInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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

  • \(s_m\) : magnetic source term

  • \(s_e\) : electric source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

tuple

Returns

tuple with magnetic source term and electric source term

evalDeriv(prob, time, v=None, adjoint=False)[source]

Derivatives of the source terms with respect to the inversion model - s_mDeriv : derivative of the magnetic source term - s_eDeriv : derivative of the electric source term

Parameters
Return type

tuple

Returns

tuple with magnetic source term and electric source term derivatives times a vector

getReceiverIndex(receiver)[source]
hInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
jInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
property nD

Number of data

property receiver_list

receiver_list (a list of BaseRx): receiver list, a list (each item is an instance of BaseRx)

property rxList

rxList has been deprecated. See receiver_list for documentation

s_eDeriv(prob, time, v=None, adjoint=False)[source]

Derivative of electric source term with respect to the inversion model

Parameters
Return type

numpy.ndarray

Returns

product of electric source term derivative with a vector

s_mDeriv(prob, time, v=None, adjoint=False)[source]

Derivative of magnetic source term with respect to the inversion model

Parameters
Return type

numpy.ndarray

Returns

product of magnetic source term derivative with a vector

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property srcType

srcType (StringChoice): is the source a galvanic of inductive source, either “inductive” or “galvanic”

validate()[source]

Call all registered class validator methods

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

property vnD

Vector number of data

property waveform

waveform (BaseWaveform): A source waveform, an instance of BaseWaveform, Default: <SimPEG.electromagnetics.time_domain.sources.StepOffWaveform object at 0x7ffaed087828>

class SimPEG.electromagnetics.time_domain.sources.RawVec_Grounded(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.sources.BaseTDEMSrc

Required Properties:

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

  • receiver_list (a list of BaseRx): receiver list, a list (each item is an instance of BaseRx)

  • srcType (StringChoice): is the source a galvanic of inductive source, either “inductive” or “galvanic”

  • waveform (BaseWaveform): A source waveform, an instance of BaseWaveform, Default: <SimPEG.electromagnetics.time_domain.sources.StepOffWaveform object at 0x7ffaed087828>

Optional Properties:

  • location (SourceLocationArray): Location of the source [x, y, z] in 3D, a 1D array denoting the source location of <class ‘float’>, <class ‘int’> with shape (*)

property integrate

integrate (Boolean): integrate the source term?, a boolean, Default: False

getRHSdc(prob)[source]
phiInitial(prob)[source]
jInitial(prob)[source]
jInitialDeriv(prob, v, adjoint=False)[source]
hInitial(prob)[source]
hInitialDeriv(prob, v, adjoint=False, f=None)[source]
bInitial(prob)[source]
bInitialDeriv(prob, v, adjoint=False, f=None)[source]
classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

eInitial(prob)[source]
eInitialDeriv(prob, v=None, adjoint=False, f=None)[source]
equal(other)[source]

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

  • \(s_m\) : magnetic source term

  • \(s_e\) : electric source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

tuple

Returns

tuple with magnetic source term and electric source term

evalDeriv(prob, time, v=None, adjoint=False)[source]

Derivatives of the source terms with respect to the inversion model - s_mDeriv : derivative of the magnetic source term - s_eDeriv : derivative of the electric source term

Parameters
Return type

tuple

Returns

tuple with magnetic source term and electric source term derivatives times a vector

getReceiverIndex(receiver)[source]
property loc

loc has been deprecated. See location for documentation

property location

location (SourceLocationArray): Location of the source [x, y, z] in 3D, a 1D array denoting the source location of <class ‘float’>, <class ‘int’> with shape (*)

property nD

Number of data

property receiver_list

receiver_list (a list of BaseRx): receiver list, a list (each item is an instance of BaseRx)

property rxList

rxList has been deprecated. See receiver_list for documentation

s_e(prob, time)[source]

Electric source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

numpy.ndarray

Returns

electric source term on mesh

s_eDeriv(prob, time, v=None, adjoint=False)[source]

Derivative of electric source term with respect to the inversion model

Parameters
Return type

numpy.ndarray

Returns

product of electric source term derivative with a vector

s_m(prob, time)[source]

Magnetic source term

Parameters

simulation (BaseFDEMSimulation) – FDEM Simulation

Return type

numpy.ndarray

Returns

magnetic source term on mesh

s_mDeriv(prob, time, v=None, adjoint=False)[source]

Derivative of magnetic source term with respect to the inversion model

Parameters
Return type

numpy.ndarray

Returns

product of magnetic source term derivative with a vector

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property srcType

srcType (StringChoice): is the source a galvanic of inductive source, either “inductive” or “galvanic”

validate()[source]

Call all registered class validator methods

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

property vnD

Vector number of data

property waveform

waveform (BaseWaveform): A source waveform, an instance of BaseWaveform, Default: <SimPEG.electromagnetics.time_domain.sources.StepOffWaveform object at 0x7ffaed087828>

Receivers

class SimPEG.electromagnetics.time_domain.receivers.BaseRx(*args, **kwargs)[source]

Bases: SimPEG.survey.BaseTimeRx

Time domain receiver base class

param numpy.ndarray locations

receiver locations (ie. np.r_[x,y,z])

param numpy.ndarray times

times

param string orientation

receiver orientation ‘x’, ‘y’ or ‘z’

Required Properties:

  • locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

  • orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

  • storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

  • times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

property projComp

projComp has been deprecated. See orientation for documentation

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

eval(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.PointElectricField(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.BaseRx

Electric field TDEM receiver

param numpy.ndarray locations

receiver locations (ie. np.r_[x,y,z])

param numpy.ndarray times

times

param string orientation

receiver orientation ‘x’, ‘y’ or ‘z’

Required Properties:

  • locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

  • orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

  • storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

  • times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.PointMagneticFluxDensity(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.BaseRx

Magnetic flux TDEM receiver

param numpy.ndarray locations

receiver locations (ie. np.r_[x,y,z])

param numpy.ndarray times

times

param string orientation

receiver orientation ‘x’, ‘y’ or ‘z’

Required Properties:

  • locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

  • orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

  • storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

  • times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.PointMagneticFluxTimeDerivative(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.BaseRx

dbdt TDEM receiver

param numpy.ndarray locations

receiver locations (ie. np.r_[x,y,z])

param numpy.ndarray times

times

param string orientation

receiver orientation ‘x’, ‘y’ or ‘z’

Required Properties:

  • locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

  • orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

  • storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

  • times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

eval(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

Determine if two HasProperties instances are equivalent

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

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.PointMagneticField(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.BaseRx

Magnetic field TDEM receiver

param numpy.ndarray locations

receiver locations (ie. np.r_[x,y,z])

param numpy.ndarray times

times

param string orientation

receiver orientation ‘x’, ‘y’ or ‘z’

Required Properties:

  • locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

  • orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

  • storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

  • times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.PointCurrentDensity(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.BaseRx

Current density TDEM receiver

param numpy.ndarray locations

receiver locations (ie. np.r_[x,y,z])

param numpy.ndarray times

times

param string orientation

receiver orientation ‘x’, ‘y’ or ‘z’

Required Properties:

  • locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

  • orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

  • storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

  • times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.PointMagneticFieldTimeDerivative(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.BaseRx

Required Properties:

  • locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

  • orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

  • storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

  • times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.Point_e(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.PointElectricField

This class has been deprecated, see PointElectricField for documentation

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.Point_b(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.PointMagneticFluxDensity

This class has been deprecated, see PointMagneticFluxDensity for documentation

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.Point_h(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.PointMagneticField

This class has been deprecated, see PointMagneticField for documentation

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.Point_j(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.PointCurrentDensity

This class has been deprecated, see PointCurrentDensity for documentation

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.Point_dbdt(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.PointMagneticFluxTimeDerivative

This class has been deprecated, see PointMagneticFluxTimeDerivative for documentation

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

class SimPEG.electromagnetics.time_domain.receivers.Point_dhdt(*args, **kwargs)[source]

Bases: SimPEG.electromagnetics.time_domain.receivers.PointMagneticFieldTimeDerivative

This class has been deprecated, see PointMagneticFieldTimeDerivative for documentation

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

equal(other)[source]

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(src, mesh, time_mesh, f)[source]

Project fields to receivers to get data.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

evalDeriv(src, mesh, time_mesh, f, v, adjoint=False)[source]

Derivative of projected fields with respect to the inversion model times a vector.

Parameters
Return type

numpy.ndarray

Returns

fields projected to recievers

getP(mesh, time_mesh, f)[source]

Returns the projection matrices as a list for all components collected by the receivers.

Note

Projection matrices are stored as a dictionary (mesh, time_mesh) if storeProjections is True

getSpatialP(mesh, f)[source]

Returns the spatial projection matrix.

Note

This is not stored in memory, but is created on demand.

getTimeP(time_mesh, f)[source]

Returns the time projection matrix.

Note

This is not stored in memory, but is created on demand.

property locations

locations (RxLocationArray): Locations of the receivers (nRx x nDim), an array of receiver locations of <class ‘float’>, <class ‘int’> with shape (*, *)

property locs

locs has been deprecated. See locations for documentation

property nD

Number of data in the receiver.

property orientation

orientation (StringChoice): orientation of the receiver. Must currently be ‘x’, ‘y’, ‘z’, any of “x”, “y”, “z”

property projComp

projComp has been deprecated. See orientation for documentation

projGLoc(f)[source]

Grid Location projection (e.g. Ex Fy …)

projTLoc(f)[source]

Time Location projection (e.g. CC N)

serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property storeProjections

storeProjections (Boolean): Store calls to getP (organized by mesh), a boolean, Default: True

property times

times (Array): times where the recievers measure data, a list or numpy array of <class ‘float’>, <class ‘int’> with shape (*)

validate()[source]

Call all registered class validator methods

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

Survey

class SimPEG.electromagnetics.time_domain.survey.Survey(*args, **kwargs)[source]

Bases: SimPEG.survey.BaseSurvey

Time domain electromagnetic survey

Required Properties:

  • counter (Counter): A SimPEG counter object, an instance of Counter

  • source_list (a list of BaseTDEMSrc): A list of sources for the survey, a list (each item is an instance of BaseTDEMSrc)

property source_list

source_list (a list of BaseTDEMSrc): A list of sources for the survey, a list (each item is an instance of BaseTDEMSrc)

property counter

counter (Counter): A SimPEG counter object, an instance of Counter

classmethod deserialize(value, trusted=False, strict=False, assert_valid=False, **kwargs)[source]

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.

  • strict - Requires '__class__', if present on the input dictionary, to match the deserialized instance’s class. Also disallows unused properties in the input dictionary. Default is False.

  • assert_valid - Require deserialized instance to be valid. Default is False.

  • Any other keyword arguments will be passed through to the Property deserializers.

dpred(m=None, f=None)[source]
equal(other)[source]

Determine if two HasProperties instances are equivalent

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

getSourceIndex(sources)[source]
makeSyntheticData(m, std=None, f=None, force=False, **kwargs)[source]
property nD

Number of data

property nSrc

Number of Sources

pair(simulation)[source]
serialize(include_class=True, save_dynamic=False, **kwargs)[source]

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__'

  • save_dynamic - If True, dynamic properties are written to the serialized dict (default: False).

  • Any other keyword arguments will be passed through to the Property serializers.

property srcList

srcList has been deprecated. See source_list for documentation

validate()[source]

Call all registered class validator methods

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

property vnD

Vector number of data