Simulation and Parameter Estimation in Geophysics

Overview

SimPEG Logo

SimPEG

Latest PyPI version Latest conda-forge version MIT license Azure pipeline Coverage status https://img.shields.io/discourse/users?server=http%3A%2F%2Fsimpeg.discourse.group%2F https://img.shields.io/badge/Slack-simpeg-4A154B.svg?logo=slack https://img.shields.io/badge/Youtube%20channel-GeoSci.xyz-FF0000.svg?logo=youtube

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

All of the Geophysics But Backwards

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

    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

    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:

    Screen Shot 2021-05-16 at 8 34 20 PM

    Magnetic inversion:

    Screen Shot 2021-05-16 at 8 35 35 PM
    opened by xiaolongw1223 27
  • install simpeg in windows error: failed building wheel for discretize

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

    Dcip/spectral ip

    Simulation and inversion of time domain IP

    Implementations:

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

    2. Tested 2D and 3D SIP problems

    3. 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!

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

    Example:

    True model

    image

    Recovered model

    image

    Data fit at the fist time channel:

    image

    enhancement ready for review 
    opened by sgkang 22
  • Joint Inversions in SimPEG

    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:

    The last term, , 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:

    We can combine this so that, we work with a single vector that represents the stacked models:

    Our goal then becomes to find

    At each Gauss-Newton step, we solve the system of linear equations given by:

    where,

    More explicitly, the Hessian can be stated as:

    And the gradient can be explicitly stated as:

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

    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

    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

    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:

    image

    image

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

    image

    image

    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

    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

    image

    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

    image

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

    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

    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

    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

    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

    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

    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.

    image

    The Simulation class handles the forward operation, image, and the Data class handles the noise, image, and the observed data, image. 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.

    • EMelectromagnetics
    • EM.FDEMelectromagnetics.frequency_domain
    • EM.TDEMelectromagnetics.time_domain
    • EM.NSEMelectromagnetics.natural_source
    • EM.Staticelectromagnetics.static
    • EM.Static.DCelectromagnetics.static.resistivity
    • EM.Static.DC.Utilselectromagnetics.static.resistivity.utils
    • EM.Static.IPelectromagnetics.static.induced_polarization
    • EM.Static.SIPelectromagnetics.static.spectral_induced_polarization
    • EM.Static.Utilselectromagnetics.static.utils
    • EM.Utilselectromagnetics.utils
    • VRMelectromagnetics.viscous_remanent_magnetization
    • FLOWflow
    • SEISseismic
    • PFpotential_fields
    • PF.Gravitypotential_fields.gravity
    • PF.GravAnalyticspotential_fields.gravity.analytics
    • PF.Magneticspotential_fields.magnetics
    • PF.MagAnalyticspotential_fields.magnetics.analytics
    • Utilsutils
    • DataMisfitdata_misfit
    • Directivesdirectives
    • Fieldsfields
    • InvProbleminverse_problem
    • Inversioninversion
    • Mapsmaps
    • Modelsmodels
    • ObjectiveFunctionobjective_function
    • Optimizationoptimization
    • Propsprops
    • Surveysurvey
    • Problemsimulation

    Also generally modules with the following names have changed:

    • METHOD.SurveyMETHODmethod_name.survey
    • METHOD.SrcMETHODmethod_name.sources
    • METHOD.RxMETHODmethod_name.receivers
    • METHOD.ProblemMETHOD_xDmethod_name.simulation_xd
    • METHOD.FieldsMETHODmethod_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.codeutilsutils.code_utils
    • Utils.ModelBuilderutils.model_builder
    • EM.Utils.EMUtilselectromagnetics.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_CCSimulation3DCellCentered
    • Problem2D_CCSimulation2DCellCentered
    • Problem3D_eSimulation3DElectricField
    • Problem3D_bSimulation3DMagneticFluxDensity
    • Problem3D_hSimulation3DMagneticField
    • Problem3D_jSimulation3DCurrentDensity
    • 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.makeSyntheticDataSimulation.make_synthetic_data
    • Survey.srcListSurvey.source_list
    • Source.rxListSource.receiver_list
    • Source.locSource.location
    • Receiver.locsReceiver.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) image
    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 image

    After LengthScalesApplied

    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: image

    • On a mag dataset: image

    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)

    image

    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)

  • 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

    image

    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: image

    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 image

    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

    selection_001

    selection_002

    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:

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

    2. Tested 2D and 3D SIP problems

    3. 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!

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

    Example:

    True model

    image

    Recovered model

    image

    Data fit at the fist time channel:

    image

    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)
Owner
SimPEG
A community and tools for open geophysics.
SimPEG
Read and write rasters in parallel using Rasterio and Dask

dask-rasterio dask-rasterio provides some methods for reading and writing rasters in parallel using Rasterio and Dask arrays. Usage Read a multiband r

Dymaxion Labs 85 Aug 30, 2022
Location field and widget for Django. It supports Google Maps, OpenStreetMap and Mapbox

django-location-field Let users pick locations using a map widget and store its latitude and longitude. Stable version: django-location-field==2.1.0 D

Caio Ariede 481 Dec 29, 2022
Deal with Bing Maps Tiles and Pixels / WGS 84 coordinates conversions, and generate grid Shapefiles

PyBingTiles This is a small toolkit in order to deal with Bing Tiles, used i.e. by Facebook for their Data for Good datasets. Install Clone this repos

Shoichi 1 Dec 8, 2021
A short term landscape evolution using a path sampling method to solve water and sediment flow continuity equations and model mass flows over complex topographies.

r.sim.terrain A short-term landscape evolution model that simulates topographic change for both steady state and dynamic flow regimes across a range o

Brendan Harmon 7 Oct 21, 2022
Using Global fishing watch's data to build a machine learning model that can identify illegal fishing and poaching activities through satellite and geo-location data.

Using Global fishing watch's data to build a machine learning model that can identify illegal fishing and poaching activities through satellite and geo-location data.

Ayush Mishra 3 May 6, 2022
This repository contains the scripts to derivate the ENU and ECEF coordinates from the longitude, latitude, and altitude values encoded in the NAD83 coordinates.

This repository contains the scripts to derivate the ENU and ECEF coordinates from the longitude, latitude, and altitude values encoded in the NAD83 coordinates.

Luigi Cruz 1 Feb 7, 2022
A Django application that provides country choices for use with forms, flag icons static files, and a country field for models.

Django Countries A Django application that provides country choices for use with forms, flag icons static files, and a country field for models. Insta

Chris Beaven 1.2k Jan 3, 2023
Python bindings and utilities for GeoJSON

geojson This Python library contains: Functions for encoding and decoding GeoJSON formatted data Classes for all GeoJSON Objects An implementation of

Jazzband 765 Jan 6, 2023
Manipulation and analysis of geometric objects

Shapely Manipulation and analysis of geometric objects in the Cartesian plane. Shapely is a BSD-licensed Python package for manipulation and analysis

null 3.1k Jan 3, 2023
Python interface to PROJ (cartographic projections and coordinate transformations library)

pyproj Python interface to PROJ (cartographic projections and coordinate transformations library). Documentation Stable: http://pyproj4.github.io/pypr

null 832 Dec 31, 2022
Rasterio reads and writes geospatial raster datasets

Rasterio Rasterio reads and writes geospatial raster data. Geographic information systems use GeoTIFF and other formats to organize and store gridded,

Mapbox 1.9k Jan 7, 2023
Fiona reads and writes geographic data files

Fiona Fiona reads and writes geographic data files and thereby helps Python programmers integrate geographic information systems with other computer s

null 987 Jan 4, 2023
Python bindings and utilities for GeoJSON

geojson This Python library contains: Functions for encoding and decoding GeoJSON formatted data Classes for all GeoJSON Objects An implementation of

Jazzband 763 Dec 26, 2022
Documentation and samples for ArcGIS API for Python

ArcGIS API for Python ArcGIS API for Python is a Python library for working with maps and geospatial data, powered by web GIS. It provides simple and

Esri 1.4k Dec 30, 2022
Search and download Copernicus Sentinel satellite images

sentinelsat Sentinelsat makes searching, downloading and retrieving the metadata of Sentinel satellite images from the Copernicus Open Access Hub easy

null 837 Dec 28, 2022
python toolbox for visualizing geographical data and making maps

geoplotlib is a python toolbox for visualizing geographical data and making maps data = read_csv('data/bus.csv') geoplotlib.dot(data) geoplotlib.show(

Andrea Cuttone 976 Dec 11, 2022
geemap - A Python package for interactive mapping with Google Earth Engine, ipyleaflet, and ipywidgets.

A Python package for interactive mapping with Google Earth Engine, ipyleaflet, and folium

Qiusheng Wu 2.4k Dec 30, 2022
Python interface to PROJ (cartographic projections and coordinate transformations library)

pyproj Python interface to PROJ (cartographic projections and coordinate transformations library). Documentation Stable: http://pyproj4.github.io/pypr

null 832 Dec 31, 2022
A utility to search, download and process Landsat 8 satellite imagery

Landsat-util Landsat-util is a command line utility that makes it easy to search, download, and process Landsat imagery. Docs For full documentation v

Development Seed 681 Dec 7, 2022