Simulation and Parameter Estimation in Geophysics

Last update: Dec 15, 2022

Overview

SimPEG

https://img.shields.io/discourse/users?server=http%3A%2F%2Fsimpeg.discourse.group%2F

Simulation and Parameter Estimation in Geophysics - A python package for simulation and gradient based parameter estimation in the context of geophysical applications.

The vision is to create a package for finite volume simulation with applications to geophysical imaging and subsurface flow. To enable the understanding of the many different components, this package has the following features:

modular with respect to the spacial discretization, optimization routine, and geophysical problem
built with the inverse problem in mind
provides a framework for geophysical and hydrogeologic problems
supports 1D, 2D and 3D problems
designed for large-scale inversions

You are welcome to join our forum and engage with people who use and develop SimPEG at: http://simpeg.discourse.group/.

Weekly meetings are open to all. They are generally held on Wednesdays at 10:30am PDT. Please see the calendar (GCAL, ICAL) for information on the next meeting.

Overview Video

Working towards all the Geophysics, but Backwards - SciPy 2016

Citing SimPEG

There is a paper about SimPEG!

Cockett, R., Kang, S., Heagy, L. J., Pidlisecky, A., & Oldenburg, D. W. (2015). SimPEG: An open source framework for simulation and gradient based parameter estimation in geophysical applications. Computers & Geosciences.

BibTex:

@article{cockett2015simpeg,
  title={SimPEG: An open source framework for simulation and gradient based parameter estimation in geophysical applications},
  author={Cockett, Rowan and Kang, Seogi and Heagy, Lindsey J and Pidlisecky, Adam and Oldenburg, Douglas W},
  journal={Computers \& Geosciences},
  year={2015},
  publisher={Elsevier}
}

Electromagnetics

If you are using the electromagnetics module of SimPEG, please cite:

Lindsey J. Heagy, Rowan Cockett, Seogi Kang, Gudni K. Rosenkjaer, Douglas W. Oldenburg, A framework for simulation and inversion in electromagnetics, Computers & Geosciences, Volume 107, 2017, Pages 1-19, ISSN 0098-3004, http://dx.doi.org/10.1016/j.cageo.2017.06.018.

BibTex:

@article{heagy2017,
    title= "A framework for simulation and inversion in electromagnetics",
    author= "Lindsey J. Heagy and Rowan Cockett and Seogi Kang and Gudni K. Rosenkjaer and Douglas W. Oldenburg",
    journal= "Computers & Geosciences",
    volume = "107",
    pages = "1 - 19",
    year = "2017",
    note = "",
    issn = "0098-3004",
    doi = "http://dx.doi.org/10.1016/j.cageo.2017.06.018"
}

Links

Website: http://simpeg.xyz

Slack (real time chat): http://slack.simpeg.xyz

Documentation: http://docs.simpeg.xyz

Code: https://github.com/simpeg/simpeg

Tests: https://travis-ci.org/simpeg/simpeg

Bugs & Issues: https://github.com/simpeg/simpeg/issues

Comments

Dcip/dev
[x] Survey Design for 2.5D Problem

[x] Implementing Mixed B.C for 2.5D and 3D Problem_CC

@thast contribution: Major updates to StaticUtils:

[x] IO functions for UBC-GIF codes DCIP2D and DCIP3D

[x] add Utils such electrode_separations or geometric_factor

[x] Utils are now compatible with all types of survey

@fourndo contribution:

[x] Add getJ forming sensitivity matrix explicitly

[x] Add sensitivity weighting directive

[x] Add functionality in Regularization to handle TreeMesh

[x] Update IRLS directive

[x] Change to Directive to convert reg, misfit to ComboObjective

[x] Update SaveEveryIteration Directives for Combo
opened by sgkang 32
Depth weighting function in "model_utils.py"

I added the depth weighting function in the "model_utils.py" file as another weighting option for users compared with sensitivity weighting. The constant parameters "v" and "z0" are adjustable to simulate the decay of potential filed data along the depth.

We can perform depth weighting function as following:

wr = depth_weighting(mesh, xyz_topo, indActive=ind_active, v=3, z0=5) reg.cell_weights = wr

I did a few tests shown below:

Gravity inversion:

Magnetic inversion:

opened by xiaolongw1223 27
install simpeg in windows error: failed building wheel for discretize

I was trying to install SimPEG on my new windows 10 machine using pip install simpeg, and got an error message that reads 'failed building wheel for discretize'.

Anyone has any idea about what might have gone wrong here?

BTW1, I was able to install python, numpy, scipy, scikit-learn, matplotlib without any trouble. BTW2, yesterday I ran into a similar error message when I was installing obspy that reads 'failed building wheel for obspy'.

Maybe something wrong with my wheel? But I did install wheel successfully by pip install wheel.

opened by jiajiasun 23
Use scooby for Versions

Use scooby internally for Versions. Now that scooby exists (thanks @banesullivan ) we should use it to simplify our lives. This removes lots of code from SimPEG, and will make maintenance easier down the road.

It is a bit a shame this comes only a few days after https://github.com/simpeg/simpeg/releases/tag/0.11.5 - but the development of scooby came a bit unexpected and fast.

However, there is absolutely NO change to the API / for the user. Everything remains the same.

In the end, the work we did with Versions in SimPEG (and in empymod/emg3d) all led to scooby, so it was well invested time ;-)

opened by prisae 22
Dcip/spectral ip
Simulation and inversion of time domain IP

Implementations:

Use stretched exponential (chargeability, time constant, frequency dependency) for parameterization

Tested 2D and 3D SIP problems

Deprecate Multiregularization and use combo objective function, so pulled ref/objectivefunctions branch - This is for inverting multiple parameters. Thanks @lheagy and @fourndo for combo objective functions, and @rowanc1 for wire implementation!

Implement storeJ option for both IP and SIP problems (2D and 3D), which boost up speed for relatively small problems.

Example:

True model

Recovered model

Data fit at the fist time channel:

enhancement ready for review
opened by sgkang 22
Joint Inversions in SimPEG
Hello, My name is Jae Deok Kim and I am a Master's student working on Joint Inversions with Dr. Jiajia Sun at the University of Houston.

As far as I know, the joint inversions in SimPEG are inverting for different physical properties (e.g. electrical conductivity and volume) using a single dataset (https://docs.simpeg.xyz/content/examples/11-seis/seis_tomo_joint_with_volume.html). We would like to add the functionalities for joint inversions that combine different physical properties (e.g. gravity and magnetics) from different datasets. This means that we would input multiple datasets of possibly different physical parameters (e.g. gravity and magnetics) and would output two different physical property models (e.g. density and susceptibility) that would be consistent in a predefined way (e.g. petrophysical relationships or structural similarity).

The joint inversion should be done within a single computational algorithm, with a single objective function and where all the models parameters are adjusted concurrently throughout the inversion.

Take for instance, the case of joint inversion of two models. We define our objective function as: $\large \Phi\left ( m_1,m_2 \right ) = \Phi_{d1} + \beta\Phi_{m1} + \Phi_{d2} + \beta\Phi_{m2} + \lambda\Phi_c$

The last term, $\large \Phi_c$ , is the coupling term that mathematically defines the relationship between different model parameters. The most prominent example would be the cross-gradient.

To minimize this objective function, we can still use the Gauss-Newton method by making some linear algebraic modifications.

Let me first restate the objective function in explicit form: $\large \Phi\left ( m_1,m_2 \right ) = \frac{1}{2}\left \|W_{d1}\left ( F[m_1] - d_1^{obs} \right ) \right \|_2^2 + \frac{1}{2}\beta_1\left \|W_{m1}\left ( m_1 - m_1^{ref} \right ) \right \|_2^2 + \frac{1}{2}\left \|W_{d2}\left ( F[m_2] - d_2^{obs} \right ) \right \|_2^2 + \frac{1}{2}\beta_2\left \|W_{m2}\left ( m_2 - m_2^{ref} \right ) \right \|_2^2 + \frac{1}{2}\lambda\phi_c$

We can combine this so that, we work with a single vector that represents the stacked models: $\small m=\begin{pmatrix} m_1 \\ m_2 \end{pmatrix}$ $\large \Phi\left ( m_1,m_2 \right ) = \frac{1}{2}\left \| \begin{bmatrix} W_{d1} & \\ & W_{d2} \end{bmatrix} \left [ \begin{pmatrix} F[m_1] \\ F[m_2] \end{pmatrix}\\ - \begin{pmatrix} d_1^{obs} \\ d_2^{obs} \end{pmatrix} \right ] \right \|_2^2 + \frac{1}{2}\left \| \begin{bmatrix} \sqrt{\beta_1} W_{m1} & \\ & \sqrt{\beta_2} W_{m2} \end{bmatrix} \left [ \begin{pmatrix} m_1 \\ m_2 \end{pmatrix}\\ - \begin{pmatrix} m_1^{ref} \\ m_2^{ref} \end{pmatrix} \right ] \right \|_2^2 + \frac{1}{2}\phi_c$

Our goal then becomes to find $\small m=\begin{pmatrix} m_1 \\ m_2 \end{pmatrix}$

At each Gauss-Newton step, we solve the system of linear equations given by: $\large H\Delta m = -g$

where, $\LARGE H = \begin{bmatrix} \frac{\partial^2\Phi}{\partial m_1^2} & \frac{\partial^2\Phi}{\partial m_1 m_2} \\ \frac{\partial^2\Phi}{\partial m_2 m_1} & \frac{\partial^2\Phi}{\partial m_2^2} \end{bmatrix}$

$\large \Delta m = \begin{bmatrix} \Delta m_1\\ \Delta m_2 \end{bmatrix}$

$\LARGE g = \begin{bmatrix} \frac{\partial \Phi}{\partial m_1}\\ \frac{\partial \Phi}{\partial m_2} \end{bmatrix}$

More explicitly, the Hessian can be stated as: $\large H = \begin{bmatrix} J_1^T & \\ & J_2^T \end{bmatrix} \begin{bmatrix} W_{d1}^T & \\ & W_{d2}^T \end{bmatrix} \begin{bmatrix} W_{d1} & \\ & W_{d2} \end{bmatrix} \begin{bmatrix} J_1 & \\ & J_2 \end{bmatrix} + \begin{bmatrix} \sqrt{\beta_1}W_{m1}^T & \\ & \sqrt{\beta_2}W_{m2}^T \end{bmatrix} \begin{bmatrix} \sqrt{\beta_1}W_{m1} & \\ & \sqrt{\beta_2}W_{m2} \end{bmatrix} + \frac{1}{2}\lambda\begin{bmatrix} \frac{\partial \phi^2_c}{\partial m_1^2} & \frac{\partial \phi^2_c}{\partial m_1 m_2} \\ \frac{\partial \phi^2_c}{\partial m_2 m_1} & \frac{\partial \phi^2_c}{\partial m_2^2} \end{bmatrix}$

And the gradient can be explicitly stated as: $\large g = \begin{bmatrix} J_1^T & \\ & J_2^T \end{bmatrix} \begin{bmatrix} W_{d1}^T & \\ & W_{d2}^T \end{bmatrix} \begin{bmatrix} W_{d1} & \\ & W_{d2} \end{bmatrix} \left [ \begin{pmatrix} F[m_1] \\ F[m_2] \end{pmatrix}\\ - \begin{pmatrix} d_1^{obs} \\ d_2^{obs} \end{pmatrix} \right ] + \begin{bmatrix} \sqrt{\beta_1}W_{m1}^T & \\ & \sqrt{\beta_2}W_{m2}^T \end{bmatrix} \begin{bmatrix} \sqrt{\beta_1}W_{m1} & \\ & \sqrt{\beta_2}W_{m2} \end{bmatrix}\left [ \begin{pmatrix} m_1 \\ m_2 \end{pmatrix}\\ - \begin{pmatrix} m_1^{ref} \\ m_2^{ref} \end{pmatrix} \right ] + \frac{1}{2}\lambda\begin{pmatrix} \frac{\partial \phi_c}{\partial m_1}\\ \frac{\partial \phi_c}{\partial m_2} \end{pmatrix}$

By constructing the Hessian and gradient as shown, we are able to take advantage of the optimization code that is already in SimPEG to implement our joint inversions.

These are the modifications that I've done:

Coupling: I've added a Coupling class that stores the methods related to the specific coupling strategy we use for joint inversions. For now, I've only coded the cross-gradient method. The relevant functions are deriv and deriv2 which compute the gradient and Hessian, respectively. For more detailed information on the cross-gradient, you may refer to this paper by Gallardo and Meju (2003) https://doi.org/10.1029/2003GL017370

Directives: I've added a JointInversionDirective class that inherits from InversionDirective, but we define some of the methods differently. Namely, for joint inversions we are now working with multiple data misfits, multiple regularizations, and a coupling term, so I've added methods that call and set the values for these objects. I've added a SaveOutputEveryIteration_JointInversion directive that will save the outputs of each iteration for joint inversions. I've added a UpdatePreconditioner_JointInversion directive that sets a Jacobi preconditioner for the joint inversion. Lastly, I've added a Adaptive_Beta_Reweighting directive that will adaptively change the trade-off parameters of the regularizations during the inversion. It makes sure that we stay within a certain range of our target data misfits.

InvProblem: I've created a new JointInvProblem class that inherits from BaseInvProblem. The relevant function is evalFunction, which computes the value of the objective function, as well as the gradient and Hessian (we store the Hessian as a scipy.sparse.linalg.LinearOperator object).

Optimization: I would like to add another stopping criteria, which I've named ratio_x, defined as $\large \frac{\left \| x_c-x_{last} \right \|}{\left \| x_{last} \right \|}$ . This captures information on how much we've updated the model, and if the update is negligibly small we decide we've converged. It's somewhat similar to the moving_x stopping criteria, but different in the sense that the ratio_x is like a percentage on the model update at each iteration, where as moving_x is relevant to the initial model. I've also added some IterationPrinters that are relevant for the joint inversion, such as printing multiple data misfits, multiple regularizations, the coupling term. Lastly, I've modified the ProjectedGNCG findsearchdirection method, where I think it's more intuitive to use a for loop for i in range(self.maxIterCG) and have a if...then...break statement inside the loop, instead of a while loop. For the convergence criteria of the Conjugate Gradient, I've found that using r.dot(r) / self.g.dot(self.g) < self.tolCG works better especially in cases where the residual does not easily fall below magnitudes of 1e-3.

Inversion: I've added a JointInversion class that inherits from BaseInversion that simply sets the IterationPrinters and StoppingCriteria for the joint inversion.

It's my first time contributing to an open-source project, so any guidance on how to proceed is appreciated (e.g. what tests I need to do?). I'm opening this issue to discuss the possibility of adding these functionalities for joint inversions in SimPEG. I've tested these modifications locally and the joint inversion runs successfully, so I'm ready to start a pull request any time, but first I'd like to hear back from the team.

Best regards, Jae
opened by kimjaed 19
Dcip/dev
Merging the latest dev (mostly properties):

Changes made before in Static package

Use list ofr Jvec rather than datapair (this makes memory leakage)

For DC, IP, and SIP

help wanted
opened by micmitch 18
Improvements: Potential Fields
A couple of improvements or fix for Potential Fields:

Fix reading functions for UBC file format (in case of line break)

add ModelMap property

Change survey.nD definition so it is independent of Problem

Use reg.deriv2 instead of reg.W for computing the preconditioner in Directives.updatePreconditioner

general PEP8 improvements (powered by AutoFormat)

naming convention: readUBCgravObs becomes readGravityObservations (for consistency between Grav and Mag names conventions.)

Combine all Mag problems (susc, amp, MVI) under Magnetics.MagneticIntegral

Change coordinate system from legacy x, y, z(down) to convention x, y, z (up)

Add test+example for MVI-S on TreeMesh

Add test+example for Amplitude inversion (CSM algo)

enhancement MAG GRAV optimization mapping ready for review
opened by thast 16
Install SimPEG on windows

Hello,

I'm trying to install SimPEG, but I'm getting an error. When I try through the prompt line, with the command pip install SimPEG, installs all the packages but when arrives in the discretize I get an error:

And when I try to run the setup.py file I have the same error:

I already installed the Microsoft Visual C++ 2008 from here https://www.microsoft.com/en-ca/download/details.aspx?id=29 But still getting the error... Someone knows how I can fix this?

Thanks a lot

opened by jc-barreto 15
Ref/objectivefunctions
Composable Objective Functions

First pass implementation to address #474

wrote a base objective function class that allows for composable objective functions, so you can now say

phi = alpha_s * Regularization.Smallness(mesh) + alpha_x * Regularization.Smoothness(mesh)

regularization and datamisfit now inherit from this. This results in several namespace changes

reg.eval(m) --> reg(m), dmisfit.eval(m) --> dmisfit(m)

reg.evalDeriv(m) --> reg.deriv(m), dmisfit.evalDerivl(m) --> dmisfit.deriv(m)

reg.eval2Deriv(m) --> reg.deriv(m), dmisfit.eval2Derivl(m) --> dmisfit.deriv(m)

all regularizations and datamisfit now each have their own individual W matrix. There are no longer differently named W's, eg

dmistfit.Wd = Utils.sdiag(1/wd) --> dmisfit.W = Utils.sdiag(1/wd)

Regularization

regularization refactor to be more modular.

For example, Regularization.Tikhonov is now a composite regularization that has an objective function list (reg.objfcts) consisting of Regularization.Smallness, Regularization.Smooth_x, Regularization.Smooth_y, Regularization.Smooth_z, Regularization.Smooth_xx, Regularization.Smooth_yy, Regularization.Smooth_zz.

implemented properties in regularization (requires dev right now) for

indActive

mref

cell_weights

mrefInSmooth

alpha_? (x, y, ...)

any time properites are updated on a CompositeRegularization, those changes are propagated to the objective functions that make it up.

Other impacts

update IRLS directive to hold the l2model (the directive should keep track of that model, it does not need to be stored on the regularization) cc @fourndo

updated Props to include a SimPEGArray and SimPEGFloat that allow Utils.Zero and Utils.Identity @rowanc1

update examples to set data weights on dmisfit.W instead of dmisfit.Wd as that will depreciate on these changes cc @fourndo

Prior to merging

[x] @rowanc1 : could you please have a look at this and we can chat through it

[x] @fourndo: once I have gone through this with Rowan and we make sure the implementation is what we are after, I would like to get your thoughts on the Sparse Regularization changes and do a thorough review to make sure I haven't broken anything!

[x] we should wait to merge until properties/dev is on master

Straight Ray Tomography

implement SEIS.StraightRay, Problem, Survey, Src and Rx

example: SEIS_StraightRayTomo.py

InvProb Compatibility with Composable Objective functions

allow both dmisfit to be either a base objective function or a base data misfit

extend invProb in cases where dmisfit is a combo objective function so that it can stash multiple fields from different problems

Example Joint Inversion

include an example "joint" inversion (consists of 2 data misfit terms and a regularization) based on the Heagy et. al., 2014 SEG abstract http://library.seg.org/doi/abs/10.1190/segam2014-1639.1: SEIS_VolumeRegularization.py

regularization refactor framework-bug
opened by lheagy 15
pip install simpeg in windows

I was installing simpeg using pip install through git repo

so, I did pip install git+git://github.com/simpeg/simpeg.git

and the below error is that I have got. I guess that is because of C ++ compiler, and possibly just because of the path. Any ideas?

C:\Users\administrator\AppData\Local\Programs\Common\Microsoft\Visual C++ for Python\9.0\VC\Bin\amd64\link.exe /DLL /nologo /INCREMENTAL:NO /LIBPATH:S:\EOSC350\anaconda\libs /LIBPATH:S:\EOSC350\anaconda\PCbuild\amd64 /LIBPATH:S:\EOSC350\anaconda\PC\VS9.0\amd64 /EXPORT:initSimPEG/Utils/interputils_cython build\temp.win-amd64-2.7\Release\SimPEG/Utils/interputils_cython.obj /OUT:S:\EOSC350\pythonprograms\simpeg\SimPEG\Utils\interputils_cython.pyd /IMPLIB:build\temp.win-amd64-2.7\Release\SimPEG/Utils\interputils_cython.lib /MANIFESTFILE:build\temp.win-amd64-2.7\Release\SimPEG/Utils\interputils_cython.pyd.manifest LINK : error LNK2001: unresolved external symbol initSimPEG/Utils/interputils_cython build\temp.win-amd64-2.7\Release\SimPEG/Utils\interputils_cython.lib : fatal error LNK1120: 1 unresolved externals error: command 'C:\Users\administrator\AppData\Local\Programs\Common\Microsoft\Visual C++ for Python\9.0\VC\Bin\amd64\link.exe' failed with exit status 1120

opened by sgkang 15
TEM Store factorizations in RAM

In this PR, we add the option to store factorizations in RAM. The ability to read/write factorizations can be handled as part of another project. Just like the FEM problem, this is controlled using the 'forward_only' kwarg

opened by dccowan 5
Enable use of inactive cells in equivalent source models

As described in https://simpeg.slack.com/archives/CFJUKBPDZ/p1670976419407039 equivalent source models currently do not allow use of inactive cells. The code requires the cell_z_top and cell_z_bottom to be the same size as mesh.nC. Simply changing this to the internally-set self.nC allows use of inactive and active cells with the existing ind_active parameter.

This change is backwards compatible since using the full active set of cells is always going to be the same as mesh.nC, and self.nC==mesh.nC in that case.

opened by nwilliams-kobold 4
Optimization and parallelization of 3D TDEM simulations
For reference: the forward problem

For a single electric source term, the forward problem can be defined as:

\begin{bmatrix} \mathbf{A_{dc}} & & & & & \\ \mathbf{B_1 G} & \mathbf{A_1} & & & & \\ & \mathbf{B_2} & \mathbf{A_2} & & & \\ & & & \ddots & & \\ & & & & \mathbf{B_n} & \mathbf{A_n} \end{bmatrix} \begin{bmatrix} \phi_0 \\ \mathbf{u_1} \\ \mathbf{u_2} \\ \vdots \\ \mathbf{u_n} \end{bmatrix} = \begin{bmatrix} \mathbf{q_{dc}} \\ \mathbf{q_1} \\ \mathbf{q_2} \\ \vdots \\ \mathbf{q_n} \end{bmatrix}

For the e-field formulation

$$ \begin{align} \mathbf{A_k} &= \mathbf{C^T M_\mu C} + \Delta t_k^{-1} \mathbf{N_e^T M_\sigma N_e} \ \mathbf{B_k} &= -\Delta t_k^{-1} \mathbf{N_e^T M_\sigma N_e} \ \mathbf{q_k} &= -\Delta t_k^{-1} \mathbf{N_e^T s} \Big [ f_k - f_{k-1} \Big ] \end{align} $$

Issue 1: Fields for many sources

At each time step, the right-hand side for all sources is computed, then the solve is done for all right-hand sides simultaneously. The efficiency of the this is dependent on the solver being used and how it handles many right-hand sides.

Q: Is there a limitation for storing the fields for an extremely large problem? (I.e. large mesh and/or large number of sources)

Q: Can a more light-weight fields object be used for most practical applications?

Issues 2: Projection from fields to receivers

The discretized fields for all sources have been computed on the mesh and stored. At this point, we loop over all sources and receivers to project from the fields object to the receivers. I think the projection is done as needed and the projection matrices are not stored explicitly.

Q: Is there a more efficient way to project from the fields to the receivers?

Issue 3: Storing factorizations of A:

For both the forward problem, and implicit computations of $\mathbf{Jv}$, we need to solve many linear systems of the form:

$$ \mathbf{A}\mathbf{x} = \mathbf{b} $$

for each time-step length.

Current SimPEG approach:

When the time-step length changes, the factorization of $\mathbf{A}$ for the previous step-length is discarded. If all we need is to solve the forward problem, this is fine. However if we need many implicit computations of $\mathbf{Jv}$, everything will need to be re-factored for each vector. This is not efficient.

Improvements:

Can we have the options to:

Discard factorizations when step length changes

forward simulation when RAM is severely limited

wouldn't be required if sensitivities were computed and stored explicitly (done using Jtv)

Store all factorizations for the current model to RAM

for inversion Jv must be solved implicitly

Store all factorizations for the current model to disk

for inversion Jv must be solved implicitly

Storing Factorizations of A^T

For implicit computations of $\mathbf{J^T v}$ (which is required to compute and store the sensitivities), we need to solve many linear systems of the form:

$$ \mathbf{A^T x} = \mathbf{b} $$

for each time-step length.

Current SimPEG approach:

When the time-step length changes, the factorization of $\mathbf{A^T}$ for the previous step-length is discarded. If we need many implicit computations of $\mathbf{J^T v}$, everything will need to be re-factored for each vector. This is not efficient. This issue occurs when:

$\mathbf{J^T v}$ is computed implicitly for many vectors to compute and store the sensitivities explicitly

$\mathbf{J^T v}$ is computed implicitly many times for the CG solve when sensitivities are not stored

Improvements:

Can we have the options to:

Store all factorizations for the current model to RAM

Store all factorizations for the current model to disk
opened by dccowan 8
Avoid using variables not binded in function definition

Fix flake8 B023 warnings. Avoid using variables inside function's body if they are not binded in the function definition. Tell flake8 to ignore some of those where needed.

opened by santisoler 1
Avoid using mutables as default parameters

Fix flake8 B006 warnings. Avoid using mutables as default values for function and methods parameters. Default function parameters are evaluated only once during function definition. If those default values are mutable variables it's possible that the function call might change it, leading to a "new default" value on subsequent function calls. Use tuples instead of lists and None for dictionaries (the default value could be defined inside the body through a quick is None check).

This article has good explanations of why using mutable default values is discouraged.

opened by santisoler 1

Releases(v0.14.0)

v0.14.0(May 27, 2020)
SimPEG 0.14.0 Release Notes

This release marks a major change in the structure of SimPEG, and it all started with this,

#562: What's the problem with Problem?

We hope to answer that question with this release!

This release will break backward compatibility as many modules and classes have been renamed. Check out the Examples and Tutorials (which have also been improved) to see how it's done.

We are also only supporting Python versions >=3.6 at this time. We have dropped all testing and development on Python versions previous to this (especially 2.7).

Highlights

No more Problem-s, only Simulation-s

Data is important

PEP 8 renaming

Dask parallelism

Resistivity Simulation improvements

Simulation

We will refer to this update as the simulation update, and there are a few large changes that we will attempt to describe here.

We (the developers) believed that there were some significant challenges with the overall structure of the SimPEG framework, which all revolved around constructing a forward simulation by pair-ing a Survey and a Problem. The Survey handled things like sources, receivers, and the Problem handled the physics engine of the forward simulation. These two items had to be created separately, then pair-ed afterwards for both the Problem to be able to use sources, and for the Survey to predict data. We found that this structure made it difficult to interface with other packages and was also generally difficult to explain. Also, field data was then attached to the Survey class.

These changes within this section are also the ones which will require the most changes to code (which are still hopefully small).

The Simulation class

Problem has been renamed to Simulation

We decided to refactor this code into something a little more understandable. The Simulation class is now the workhorse of the SimPEG forward simulations. It handles things like modeling fields and projecting those fields to the data locations defined by its survey. The Survey class is much lighter weight, now only handling the sources and receivers. Also a single survey can now be attached to many Simulation-s.

Previously we had something like,

survey = DC.Survey(srcList) prob = DC.Problem3D_CC(mesh, rhoMap=mapping) prob.pair(survey) # Compute the fields from `prob` fields = prob.fields(model) # And predict data using the `survey` dpred = survey.dpred(model, f=fields)

Now,

survey = resistivity.Survey([source_list]) sim = resistivity.Simulation3DCellCentered( mesh, survey=survey, rhoMap=mapping ) # Compute the fields from `sim` fields = sim.fields(model) # Predict data also using `sim` dpred = sim.dpred(model, f=fields)

See? The Simulation handles predicting data. This change will also make it easier to interface with external codes for inversion purposes, as all that is needed to be defined to use a Simulation for an InvProblem, is sim.dpred, sim.Jvec and sim.Jtvec.

Please see the documentation for the SimPEG.simulation.BaseSimulation class as well as the individual methods' Simulation-s, for a detailed description of arguments, but largely it accepts the same arguments as the Problem class, but now also requires a Survey to be set.

The Data class

Previously, field data would also live within the Survey class. Which was not only confusing, but placed the importance on the wrong component. When inverting geophysical data, we are concerned with the data. Thus we would like to enforce this importance by making data live in a dedicated Data class. This Data class can act like a smart dictionary to grab data associated with a specific source, receiver combination. More importantly, this Data class is where we store information related to observed data and its errors. This class started in the SimPEG.Survey module, but has now been moved into its own new module SimPEG.data. See the documentation for the SimPEG.data.Data for all of the details.

Previously, # Add data to the survey survey.dobs = dobs survey.std = 0.05 # a 5% relative error survey.eps = 1.0E-6 # a noise floor

Now,

# Create a data object data = data.Data(dobs=dobs, relative_error=0.05, noise_floor=1e-6)

You might also notice that we changed the name of the terms used to construct the standard deviation. See issue #846. Previously survey.std represented an error that was relative to the absolute value of the data. The name of this term is misleading, as it is not actually the classic statistical standard deviation.

Previously the uncertainty was constructed as:

uncertainty = survey.std * np.abs(survey.dobs) + survey.eps

We now have updated the names to be clearer and more in line with what we would naturally expect, which is accessed from data.standard_deviation. The value that is returned from this is now defined as:

data.standard_deviation = ( data.relative_error * np.abs(data.dobs) + data.noise_floor )

You can also directly set the value of data.standard_deviation if you prefer to work with that quantity.

data.standard_deviation = 0.01

This Data class is now also the object that is returned from:

data = sim.make_synthetic_data( m, relative_error=0.05, noise_floor=0.0, f=None, add_noise=True )

The DataMisfit class

Previously, because the Survey class handled predicting data at the receivers, and it also had knowledge of the observed data and its noise, we constructed the data misfit measure using only the survey. Now we have specifically broken this piece up into a forward Simulation object, and a Data object. This mimics the definition of the classic data misfit measure.

The Simulation class handles the forward operation, , and the Data class handles the noise, , and the observed data, . See the documentation for the SimPEG.data_misfit.L2DataMisfit for all of the details.

Previously,

# Survey knows how to predict data, knows the observed data, # and its standard deviation dmis = DataMisfit.l2_DataMisfit(survey)

Now,

# Create a data misfit # The data class now knows the observed data and its standard deviation. # The simulation knows how to create data from a model. dmis = data_misfit.L2DataMisfit(simulation=sim, data=data)

Dask

We have begun a concerted effort to incorporate dask as a means to allow SimPEG to scale to larger computers (and take advantage of parallelism). Checkout the dask docs at https://docs.dask.org/en/latest/.

This feature is experimental at the moment and can be toggled on like so,

import SimPEG.dask

which will then enable parallel operations for a few modules. It will specifically replace these functions with dask versions,

SimPEG.potential_fields.BasePFSimulation.linear_operator

SimPEG.potential_fields.magnetics.Simulation3DIntegral.getJtJdiag

SimPEG.potential_fields.gravity.Simulation3DIntegral.getJtJdiag

SimPEG.electromagnetics.static.resistivity.simulation.BaseDCSimulation.getJ

SimPEG.electromagnetics.static.resistivity.simulation.BaseDCSimulation.getJtJdiag

SimPEG.electromagnetics.static.induced_polarization.simulation.BaseDCSimulation.getJ

SimPEG.electromagnetics.static.induced_polarization.simulation.BaseDCSimulation.getJtJdiag

Changelog

As can be expected, there are many changes in this release, and we hope to identify most of them here (or at least point you in the right direction).

Renamed Modules

We have taken steps to rename the modules of SimPEG to a more PEP 8 friendly system. The previous locations do not exist.

EM → electromagnetics

EM.FDEM → electromagnetics.frequency_domain

EM.TDEM → electromagnetics.time_domain

EM.NSEM → electromagnetics.natural_source

EM.Static → electromagnetics.static

EM.Static.DC → electromagnetics.static.resistivity

EM.Static.DC.Utils → electromagnetics.static.resistivity.utils

EM.Static.IP → electromagnetics.static.induced_polarization

EM.Static.SIP → electromagnetics.static.spectral_induced_polarization

EM.Static.Utils → electromagnetics.static.utils

EM.Utils → electromagnetics.utils

VRM → electromagnetics.viscous_remanent_magnetization

FLOW → flow

SEIS → seismic

PF → potential_fields

PF.Gravity → potential_fields.gravity

PF.GravAnalytics → potential_fields.gravity.analytics

PF.Magnetics → potential_fields.magnetics

PF.MagAnalytics → potential_fields.magnetics.analytics

Utils → utils

DataMisfit → data_misfit

Directives → directives

Fields → fields

InvProblem → inverse_problem

Inversion → inversion

Maps → maps

Models → models

ObjectiveFunction → objective_function

Optimization → optimization

Props → props

Survey → survey

Problem → simulation

Also generally modules with the following names have changed:

METHOD.SurveyMETHOD → method_name.survey

METHOD.SrcMETHOD → method_name.sources

METHOD.RxMETHOD → method_name.receivers

METHOD.ProblemMETHOD_xD → method_name.simulation_xd

METHOD.FieldsMETHOD → method_name.fields

where METHOD was the old module name for the method and method_name is the new name.

Also many of the utilities modules within these are also being deprecated. Their old names are still around and should throw a deprecation warning when loaded pointing to the correct name.

For example,

Utils.codeutils → utils.code_utils

Utils.ModelBuilder → utils.model_builder

EM.Utils.EMUtils → electromagnetics.utils.waveform_utils (this one is a little less obvious)

Problem to Simulation

Many of the previous Problem classes are still within the modules, but will now throw a deprecation warning which points to the updated Simulation. The renaming scheme for the Simulation-s was decided in #857.

For example,

Problem3D_CC → Simulation3DCellCentered

Problem2D_CC → Simulation2DCellCentered

Problem3D_e → Simulation3DElectricField

Problem3D_b → Simulation3DMagneticFluxDensity

Problem3D_h → Simulation3DMagneticField

Problem3D_j → Simulation3DCurrentDensity

etc.

Our current plan is to remove these deprecated versions in the 0.15.0 SimPEG release.

Potential field reorganization

The potential_fields module has likely received the largest amount of reorganization to make it more in line with the structure of the other modules, and some things have moved around and been renamed. There are now two separate modules within potential_fields: gravity and magnetics. All of the classes in PF.BaseGrav have been moved to potential_fields.gravity, and the classes in PF.BaseMag have been moved to potential_fields.magnetics. The Map-s that were within them have been deprecated and can instead be found in SimPEG.maps.

The option of a coordinate_system for the magnetics simulation is no longer valid and will throw an AttributeError. Instead use the SimPEG.maps.SphericalSystem.

Improvements and Additions to resistivity

We have made a few improvements to the SimPEG.electromagnetics.static.resistivity that were motivated by our work under the Geoscientists Without Borders project.

One is that we now have a 1D layered Earth simulation class, SimPEG.electromagnetics.static.resistivity.simulation_1d.Simulation1DLayers, that can be used to invert resistivity sounding data for conductivity and/or thicknesses of a set number of layers.

The second, is a new miniaturize option for the 2D and 3D resistivity simulations. This option causes the class to internally replace Dipole sources and receivers with only unique Pole sources and receivers. This can result in a dramatic speedup and reduced memory requirements when the input survey contains many more Dipole-s than electrode locations. This is especially common in the wenner type survey acquisitions that use a unique source and receiver for each measured data point. This option is disabled by default, and can be enabled by passing the minaturize=True keyword to the resistivity Simulation upon initialization.

The third is automated TreeMesh construction within the resistivity.IO class for a 2D survey.

Deprecations

Some functions and properties have been renamed to more PEP 8 friendly names, for example:

Survey.makeSyntheticData → Simulation.make_synthetic_data

Survey.srcList → Survey.source_list

Source.rxList → Source.receiver_list

Source.loc → Source.location

Receiver.locs → Receiver.locations

etc...

As mentioned before, the old names of these items will still be around, but will throw DeprecationWarnings pointing the user to the new names.

We have done work to make this release as backwards compatible as possible, but can not guarantee that all code will work. At the minimum, module imports must be changed. The old style of pair-ing a survey will still work, in which case all of the older functions will still work. This is only intended for old code to continue working, and should not be relied upon for developing new code.

As noted all of the Problem-s are being deprecated and will be removed as of version 0.15.0 of SimPEG. The deprecated utility models will also be removed then.

Pull Requests

There were 25 pull requests contributing to this release.

#786: Simulation class refactor.

#792: Use scooby for Versions.

#802: Simulation jk.

#819: Simulation jk df.

#835: Add simulation PF tutorials to simulation PF branch

#843: Fix drapeTopoLoc.

#844: Static receiver midpoint 3D.

#845: Tile map.

#848: Fix Ward and Hohmann example.

#849: Update and fix tutorials.

#851: Simulation method names .

#853: CSEM TDEM 3D example.

#854: Simulation dc2.5 d speedup.

#861: Fix typo.

#863: light formatting to be closer to black, update filepaths to be os independent.

#864: Sim dask split.

#865: simulation fdem testing bug.

#866: waveform logic bug.

#868: This change was necessary for fields to be called correctly for dcip2...

#869: Simulation tutorials 2.

#872: Uncertainty rename in simulation.

#874: Release notes for simulation as part of the Documentation.

#876: Simulation tutorials cleanup.

#879: Run black on SimPEG.

#882: Replace html links to documentation with local links.

Closed Issues

#865: FDEM: derivative test seems to ignore imag-real-flag

#857: DOC: Broken link

#850: Can't set a waveform on initialized BaseTDEMSrc object

#847: Renaming of methods' Problems

#846: Standard deviation and it's place in the code base

#842: Static drape topo not on surface.

#787: Plotting integrated sensitivity for DC resistivity problem.

#765: DOC: Source code not linked, 404

#751: run black on SimPEG

#562: What's the problem with Problem?

#527: Remove MapPair, RxPair, Pair

#524: Remove rxType from BaseRx

#202: Using the DataClass

Contributors

Combining to produce over 500 commits (listed in no particular order):

@lheagy

@jcapriot

@fourndo /@domfournier

@sgkang

@dccowan

@JKutt

@prisae

@craigmillernz

Source code(tar.gz)
Source code(zip)
0.13.1(Jan 17, 2020)
SimPEG 0.13.1 release notes

from PR: #813, #824, #828, #829, #833 commits from: @dccowan, @fperez, @lheagy, @rowanc1, @thast

List of updates:

fix for the VRM examples, updated for matplotlib 3.1.1 (PR #813)

Add a .mailmap file to help organize author statistics. (PR #828)

unpin sphinx version in the dev requirements (PR #829)

fix bug in computing the extension of the topography data in surfac2ind_topo (PR #833)

tutorials for models and mapping (PR #824)

Source code(tar.gz)
Source code(zip)
0.13.0(Sep 13, 2019)
Updates to Simple regularization

from pr #807

commits by: @fourndo

Summary

Proposed modification to the model gradient measure for Simple and Sparse regularization. Normalized length scales are multiplying cell_weights before averaging to cell faces.

Reduces the dependency of the model on cell size changes

Still allows for IRLS weights to be mesh independent

Default alpha's remain at 1 (takes care of length scales internally)

Before

After

Additional Notes This pr also removed 2 VRM examples and the 1D MT example as they were failing. Issues #812, #814 document the issues, and pr's #813 and #815 have been started to resolve those issues.

Updates to Utils.plot2Ddata

from pr #808

commits from: @thast

summary

add shading options in utils.plot2Ddata

Illustrations:

On the docs example:

On a mag dataset:

Minor updates:

small fix in the calling of mkvc in the regularization mesh (from #810, commits from @thast)

update dependencies in the setup.py to remove indirect ones (from #188, commits from @lheagy)

Source code(tar.gz)
Source code(zip)
0.12.0(Jul 31, 2019)
from pr #715

commits from @sgkang, @fourndo

review from @lheagy

Spectral Induced Polarization Inversion

Invert multiple time channels of IP data to recover 3D distribution of polarization parameters: eta, tau, and c

Can handle various data types: volt (V) or apparent_chargeability (V/V)

Profile SIP modules to make sure it can handle large-scale time-domain IP data (storeJ=False)

DC and IP codes

Can handle various data types: volt (V) or apparent_resistivity (ohm-m), or apparent_chargeability (V/V)

Examples using DC, IP, SIP codes are available through:

https://github.com/simpeg-research/kang-2018-spectral-inducedpolarization/tree/master/notebooks
Source code(tar.gz)
Source code(zip)
0.11.6(Jul 30, 2019)
from pr #799

commits from @lheagy

review from @fourndo

Summary

break up Regularization.py into multiple files in a regularization module

Regularization Mesh in regularization_mesh.py

BaseRegularization and BaseComboRegularization in base.py

Tikhonov and Simple in tikhonov.py

Sparse in sparse.py

Source code(tar.gz)
Source code(zip)
0.11.5(Jun 25, 2019)
from pr #769

commits from @prisae

review from @lheagy

Replace func versions by class Versions

Turns out that there is a way to have html in a notebook and non-html in all the rest without even checking if you are in a notebook or not (thanks @banesullivan; https://github.com/simpeg/discretize/issues/142).

All that is needed is a Versions-class which has the right functions linked to __repr__ and _repr_html_:

class Versions: def __init__(self, add_pckg=None, ncol=4): self.add_pckg = add_pckg self.ncol = ncol def __repr__(self): return versions_text(self.add_pckg) def _repr_html_(self): return versions_html(self.add_pckg, self.ncol)

By removing the old functions, respectively integrating the relevant parts into the new class, the whole version printing utility gets a lot simpler (however, it is not backwards compatible).

Before, you had to do

from SimPEG import versions versions()

in Python, IPython etc, and in Jupyter

from SimPEG import versions versions('HTML')

Updating your code

Now, you simply do

from SimPEG import Versions Versions()

EVERYWHERE (note the uppercase V), and it will automatically print a html table in a notebook, and plain text everywhere else.
Source code(tar.gz)
Source code(zip)
0.11.4(Apr 22, 2019)

updates to keep pace with changes in simpeg/discretize#134
Source code(tar.gz)
Source code(zip)
0.11.3(Mar 27, 2019)
from pr #770

commits from @kalen-sj

review from: @fourndo, @lheagy

A complicated pattern that was copy/pasted several times in the code was able to be replaced with a simple np.where. An example:

actv = np.asarray([inds for inds, elem in enumerate(actv, 1) if elem], dtype=int) - 1 is now actv = np.where(actv)[0]

Also, a few spelling mistakes and corrections in the examples. A couple of cases where variables were defined twice before use are now just done once.
Source code(tar.gz)
Source code(zip)
0.11.2(Mar 26, 2019)
commits from: @thast, @fourndo

review from: @fourndo

This PR addresses issue #761 and follows PR #758 and PR #757 .

There was a naming discrepancy in the PF module and that causes me some trouble. In the Gravity module, there are two aliases for rhoMap: mapping and mapPair. In the Magnetics module, there is one alias for chiMap: modelMap.

This PR settle for modelMap as only alias, consistent with the definition of the LinearProblem class in Problem.py

Additional: Fix mapping name in LinearProblem (from mapping (depreciated) to modelMap)
Source code(tar.gz)
Source code(zip)
0.11.1(Mar 5, 2019)
from pr #757

commits from: @thast

review from: @fourndo

This formulation takes into account the regularization mapping into the preconditioner and remove the need to check for a specific wiresmap.
Source code(tar.gz)
Source code(zip)
0.11.0(Mar 5, 2019)
from pr: #758

commits from: @lheagy

review from: @thast

soft removal of python 2.7: we don't explicitly break compatibility as in #731, but it is no longer tested on Python 2.7

added a note in the docs saying we will not be working to ensure compatibility with python 2.7 anymore

Source code(tar.gz)
Source code(zip)
0.10.4(Jan 29, 2019)
DC Fields Derivatives

from pr #724

commits from: @lheagy

review from: @sgkang

DC Resistivity

add fields derivatives with respect to the electric field (in case you want to invert e-field data)

add e-field receivers to DC problem

see for example: https://github.com/simpeg-research/heagy-2018-injection-inversions

TDEM

add charge and charge density to j-fields

bug fix in calculation of db/dt in the j-fields object

add grounded source that solves the mmr problem in the H-J formulation for permeable targets

Directives

add option to save output to a directory, the default is the current working directory

numpy matlib imports

from pr #755

commits from: @lheagy

review from: @thast

import matlib explicitly as in numpy 1.16, it isn't imported in the numpy namespace be default

Source code(tar.gz)
Source code(zip)
0.10.3(Jan 19, 2019)
from pr: #670

commits from: @fourndo, @thast

review from: @thast , @lheagy

A couple of improvements or fix for Potential Fields:

Fix reading functions for UBC file format (in case of line break)

add ModelMap property

Change survey.nD definition so it is independent of Problem

Use reg.deriv2 instead of reg.W for computing the preconditioner in Directives.updatePreconditioner

general PEP8 improvements (powered by AutoFormat)

naming convention: readUBCgravObs becomes readGravityObservations (for consistency between Grav and Mag names conventions.)

Combine all Mag problems (susc, amp, MVI) under Magnetics.MagneticIntegral

Change coordinate system from legacy x, y, z(down) to convention x, y, z (up)

Add test+example for MVI-S on TreeMesh

Add test+example for Amplitude inversion (CSM algo)

Source code(tar.gz)
Source code(zip)
0.10.1(Jan 8, 2019)
from pr #749

commits from @lheagy

review from @thast

update plot2Ddata

update logic in plot2Ddata so that two vmin, vmax values cannot be provided to contourf (e.g. it was previously possible that an explicit vmin, vmax was provided by the user and that a vmin, vmax was chosen based on the colorbar)

ensure that if both clim and vmin, vmax provided to contourOpts that they are identical

Source code(tar.gz)
Source code(zip)
0.10.0(Dec 21, 2018)
fix std in DataMisfit and possible bug in PlotUtils

from pr #745

commits from @thast

review from @micmitch, @lheagy

Fix for Issue #746

fixed DataMisfit.std that now take into consideration survey.std. So you are not forced to set DataMisfit.W manually anymore

Fixed: Survey.MakeSyntheticData, if not given a std, was overwriting survey.std even if already set. Now it will use survey.std if not given a std argument.

Explanation: DataMisfit.std was set to 5% by default, but to change it to survey.std, it expected a None value, thus it never gets updated...

bonus: light improvement again of Plot2DData (reordering of if statement so specifying contourOpts['vmin','vmax'] without a clim works.

bonus: Somehow PR #725 did not make it to improve plot_misfit_curves so I put it back here. Mainly, more option to plot $\phi_m$ or $\phi_small$ and $\phi_smooth$ independently, plus more options to save the figure.

Code of conduct

from pr #744

commits from @lheagy

review from @rowanc1

Add a code of conduct based on the contributor covenant to SimPEG
Source code(tar.gz)
Source code(zip)
0.9.4(Dec 9, 2018)
fixed possible issue for levels definition in SimPEG.Utils.plot2DDdata

from pr: #738, closes #734

commits from: @thast

Description

fixed possible issue for levels definition in SimPEG.Utils.plot2DDdata

add mask functionality (already proposed as args but not implemented)

choice of linear or nearest interpolation

check if there is already a vmin, vmax in the contourOpts dict before adding them based on user-input clim

improved example forSimPEG.Utils.plot2DDdata

add an example for the IO.pseudosection function

Example output:

Installation docs

from prs: #736, #737

commits from: @sdevriese, @fourndo

Description

Replace links to numpy example page with link to SimPEG examples

update link for anaconda

Do not install tests in site-packages

from pr: #740

commits from: @cgohlke

Description

exclude tests from from SimPEG installation

Source code(tar.gz)
Source code(zip)
0.9.3(Nov 19, 2018)
commits from @thast

review from @lheagy

Address issue #734

PR notes: We have fixed the following bug:

the clim argument was not used in the SimPEG.Utils.plot2DData. We added the functionality to modify the colorscale based on the clim argument.

Improvements of the SimPEG.Utils.plot2DData function:

Levels of the matplotlib.pyplot.contourf function are defined by the function itself. This is done to give us complete control over the colorscale and colorbar.

Before plotting, we check if any data are NaN or infinite to ensure reasonable colorscale. We also ensure positivity is scale==log

colorbar limits choice through clim and ncontours: ncontours defines the number of contour inside the clim scale. If data lies outside that range on either side, an supplemental contour is added to regroup those data under a single color on either side (so two colors if on both side with of ncontour+2 contours).

Source code(tar.gz)
Source code(zip)
0.9.2(Aug 15, 2018)
originally from pr #706

commits from: @lheagy

review from: @sgkang, @rowanc1

Effective medium theory map

extend the effective medium theory mapping to work for preferentially aligned ellipsoids so that anisotropic conductivities are estimated

add a calculation of the Hashin-Shtrikman bounds

Anisotropic models

allow the shape of models to include 2D arrays so that anisotropic models can be input into simulations

New Example

add an example of the effective medium theory map from my thesis

Minor updates

allow receiver orientation inputs to be upper or lowercase z or Z in the FDEM code

Source code(tar.gz)
Source code(zip)
0.9.1(Aug 13, 2018)
from pr: #711

commits from: @dccowan, @lheagy

review from: @prisae, @lheagy

updates

Add square loop receiver for VRM problem

Create forward modeling and inversion example for VRM code

Fully utilise properties class to auto generate API

Edit VRM tests to include new OcTree refinement

Fix Codacy errors

Clean up and fix errors associated with autodoc creation. Includes fixing H5 error associated with Bookpurnong and adding any missing examples not found in toctrees.

Further fixes will be addressed in #714
Source code(tar.gz)
Source code(zip)
0.9.0(Jul 11, 2018)
originally from #699

commits from: @lheagy

review from: @sgkang

This pr depends on simpeg/discretize#36 (3D cyl mesh and cell grad stencils being properties) and supersedes #683.

Changes across EM

electric fields / fluxes and magnetic fields fluxes live on the same grid location (eg. in problem_e, e, j are on edges, b, h are on faces

TDEM improvements

fill out the fields objects (addresses issue #633)

added a raw vec grounded source for HJ forumlation

DC

a few typo fixes Dirichlet (some places it was Dirchlet)

a couple updates in the order of error checks to have the DC operate on the 3D cyl mesh

geoana dependence for sources

rely on geoana for vector potentials in the sources

add geoana to the dev requirements

General Cleanup

import derivative tests from discretize

only have dev requirements in the requirements_dev.txt rather than also including core dependencies which should be installed through the setup.py

Source code(tar.gz)
Source code(zip)
v0.8.6(Jul 10, 2018)
Use of sparse inversion for non-linear inverse problems (DC, TDEM, FDEM), where sensitivity matrix is changing in the inversion iterations.

This can be quite expensive when sparse inversion is used, because we need a number of iterations to make sparse inversion converged; requires a number of call for computing sensitivity matrix.

We are doing a simple cheat here. Sparse inversion starts when Smooth inversion finishes. So, we assume that our inversion is close to the solution, and hence sensitivity matrix does not change that much after while updating for sparse inversion.

By passing fix_Jmatrix=True to Update_IRLS, you can fix sensitivity matrix, that is we are using the same sensitivity matrix for all sparse inversion iterations.

review from: @fourndo and @lheagy

commits from: @sgkang

Source code(tar.gz)
Source code(zip)
0.8.5(Jun 29, 2018)
from pr #691

commits from @lheagy

review from @sgkang

Updates

work on simplifying the storage of the inner product matrix derivatives

implement storage of the mu matrix derivatives

Source code(tar.gz)
Source code(zip)
0.8.4(Jun 28, 2018)
originally from pr #698

commits from: @prisae

review from: @lheagy, @rowanc1

SimPEG.versions()

Print the versions of packages required by SimPEG

adapted from that implemented in empymod

Fixes #697

Source code(tar.gz)
Source code(zip)
0.8.3(Apr 30, 2018)
from pr #695

commits from: @lheagy

review from: @sgkang

Summary

move the if else so that we don't have to repeat the rx if / else statement in getABMN

Source code(tar.gz)
Source code(zip)
0.8.2(Apr 21, 2018)
from pr #693

commits from @sgkang

review from @lheagy

Summary

small bug fix in indentation level of the return statement in get_dpred in invProblem.py

Source code(tar.gz)
Source code(zip)
0.8.1(Apr 21, 2018)
Bug fix in the L2Objective function deriv2

From pr #692

commits from: @lheagy

review from: @rowanc1

Summary

fix deriv2 on the L2Objective function if v is None, add a test to ensure behaviour is the same if v is none and if v provided

closes issue #686

Source code(tar.gz)
Source code(zip)
0.8.0(Apr 16, 2018)
Simulation and inversion of time domain IP

from pr: #590

commits from: @sgkang, @fourndo, @micmitch

review from: @lheagu

Implementation:

Use stretched exponential (chargeability, time constant, frequency dependency) for parameterization

Tested 2D and 3D SIP problems

Deprecate Multiregularization and use combo objective function, so pulled ref/objectivefunctions branch - This is for inverting multiple parameters. Thanks @lheagy and @fourndo for combo objective functions, and @rowanc1 for wire implementation!

Implement storeJ option for both IP and SIP problems (2D and 3D), which boost up speed for relatively small problems.

Example:

True model

Recovered model

Data fit at the fist time channel:

Source code(tar.gz)
Source code(zip)
0.7.8(Apr 12, 2018)
from pr #690 (supersedes #689)

commits from @lheagy

review from @dccowan and @fourndo

Summary of changes

ensure indActive set prior to cell weights in the regularization init so the validator looks for cell weights that are the same size as the indactive.

# previously, most usage was the following reg = Regularization.Simple(mesh=mesh, indActive=indActive) reg.cell_weights = cell_weights # this should be equivalent but prior to the pr, this use-case failed reg = Regularization.Simple(mesh=mesh, indActive=indActive, cell_weights=cell_weights)

fixes the bug @dccowan was encountering in the example he generated in #684

Source code(tar.gz)
Source code(zip)
0.7.7(Apr 11, 2018)
from pr #687

commits from: @micmitch, @lheagy

review from: @lheagy

Summary

Fixed the way E fields were being computed in the fields object for the DC_CC problem. Added tests the check E and J for a electric dipole in a fullspace against the analytic solutions. Still lacking a test for charges.
Source code(tar.gz)
Source code(zip)
0.7.6(Apr 4, 2018)
from PR: #685

commits from @lheagy

review from @thast

Bug fix for the way that we set the _nC_residual in the Regularization; this is important for constructing a default W matrix used inside the norm. We also clean up the logic of how we set nC_residual and adds a test to ensure it doesn't break in the future.
Source code(tar.gz)
Source code(zip)

Simulation and Parameter Estimation in Geophysics

Related tags

Overview

SimPEG

Overview Video

Citing SimPEG

Electromagnetics

Links

Comments

Simulation and inversion of time domain IP

Implementations:

Example:

True model

Recovered model

Data fit at the fist time channel:

Composable Objective Functions

Regularization

Other impacts

Prior to merging

Straight Ray Tomography

InvProb Compatibility with Composable Objective functions

Example Joint Inversion

For reference: the forward problem

Issue 1: Fields for many sources

Issues 2: Projection from fields to receivers

Issue 3: Storing factorizations of A:

Storing Factorizations of A^T

Releases(v0.14.0)

v0.14.0(May 27, 2020)

SimPEG 0.14.0 Release Notes

Highlights

Simulation

The Simulation class

The Data class

The DataMisfit class

Dask

Changelog

Renamed Modules

Problem to Simulation

Potential field reorganization

Improvements and Additions to resistivity

Deprecations

Pull Requests

Closed Issues

Contributors

0.13.1(Jan 17, 2020)

0.13.0(Sep 13, 2019)

Updates to Simple regularization

Summary

Updates to Utils.plot2Ddata

summary

Minor updates:

0.12.0(Jul 31, 2019)

Spectral Induced Polarization Inversion

DC and IP codes

0.11.6(Jul 30, 2019)

Summary

0.11.5(Jun 25, 2019)

Replace func versions by class Versions

Updating your code

0.11.4(Apr 22, 2019)

0.11.3(Mar 27, 2019)

0.11.2(Mar 26, 2019)

0.11.1(Mar 5, 2019)

0.11.0(Mar 5, 2019)

0.10.4(Jan 29, 2019)

DC Fields Derivatives

DC Resistivity

TDEM

Directives

numpy matlib imports

0.10.3(Jan 19, 2019)

0.10.1(Jan 8, 2019)

update plot2Ddata

0.10.0(Dec 21, 2018)

fix std in DataMisfit and possible bug in PlotUtils

Code of conduct

0.9.4(Dec 9, 2018)

fixed possible issue for levels definition in SimPEG.Utils.plot2DDdata

Description

The `Simulation` class

The `Data` class

The `DataMisfit` class

`Problem` to `Simulation`

Improvements and Additions to `resistivity`

Replace `func versions` by `class Versions`

fixed possible issue for levels definition in `SimPEG.Utils.plot2DDdata`

`SimPEG.versions()`