Version:

This page here has been created for the latest stable release of Salvus. You have chosen to view the documentation for another Salvus version. Please be aware there might be some small differences you have to account for.

Changelog

Salvus version 0.11.43

Released: 2021-10-21
Minor update with a bug fix for serializing cythonized functions.
SalvusProject
The function serialization can now serialize cythonized functions imported from other modules.

Salvus version 0.11.42

Released: 2021-10-19
Minor update with some internal changes and support for frequency domain output in Salvus project.
SalvusProject
Add support for frequency-domain output to Salvus project.
Optional output of the Fourier transform for a discrete set of frequencies can now be passed as extra_output_configuration to the launch function.
Copy
p.simulations.launch(
    ranks_per_job=4,
    site_name="local",
    events=p.events.list(),
    simulation_configuration="simulation",
    extra_output_configuration={
        "frequency_domain": {
            "fields": ["displacement"],
            "frequencies": [1.0, 2.0, 3.0],
        }
    },
)

Salvus version 0.11.41

Released: 2021-10-08
This is a large release that adds many features useful for the inversion of seismic data, particularly for land and near-surface applications.
SalvusFlow
The observed and synthetic data can now optionally be downsampled before the misfit and adjoint source are computed. The adjoint source is later upsampled again and scaled correctly. Useful for expensive misfit functionals.
It can be used either at the event misfit level:
event_misfit = EventMisfit(
    ...,
    # Optionally downsample to the given number of npts.
    max_samples_for_misfit_computation=max_samples_for_misfit_computation
)
Or at the misfit configuration level within SalvusProject:
mc = MisfitConfiguration(
    ...,
    # Optionally downsample to the given number of npts.
    max_samples_for_misfit_computation=max_samples_for_misfit_computation
SalvusMesh
Fix a bug that caused the mesh widget to crash for fields with only negative values.
SalvusModules
Added comprehensive support for converting data from a point source to an equivalent line source which is necessary for example when using 3-D observed data in 2-D inversions.
We added a variety of different transform, each applicable in different use cases. Please have a look at the documentation for details.
from salvus.modules.near_surface.processing import convert_point_to_line_source

new_st = convert_point_to_line_source(
    st=st,
    source_coordinates=[22.0, 1.0],
    receiver_coordinates=[132.0, 0.0],
    transform_type="single_velocity_exact",
    velocity_m_s=550.0
)
SalvusModules
Added utility functions to compute, remove, and plot geophone responses.
import numpy as np
from salvus.modules.near_surface.processing import geophone_response

frequencies = np.logspace(0.1, 2, 2000)
response = geophone_response.compute_geophone_response(
    frequencies=frequencies,
    geophone_frequency=4.5,
    damping_ratio=0.4,
    calibration_factor=11.2,
)
geophone_response.plot_response(frequencies=frequencies, response=response)
SalvusOpt
Added an implementation of a graph space optimal transport misfit measure as introduced in this paper:
L. Métivier, R. Brossier, Q. Mérigot, and E. Oudet. 2019.
"A graph space optimal transport distance as a generalization of Lp  distances: application to a seismic imaging inverse problem"
Inverse Problems, Volume 35, Number 8, https://doi.org/10.1088/1361-6420/ab206f
You can use it by choosing "graph_space_optimal_tranport" everywhere Salvus accepts misfit functionals. The one tuning parameters is the "max_expected_time_shift" which, as the name implies, should be set to the maximum expected time shift in seconds for individual wiggles between observed and synthetic data.
For many problems this can get completely avoid the cycle skipping problem. This, admittedly manufactured, synthetic inversion example demonstrates the potential gains:
SalvusProject
The function serialization can now serialize numpy arrays and dictionaries as closure values.
SalvusProject
Added the ability to use processing fragments to more easily perform some simple and common processing techniques.
To for example bandpass and normalize some data use "EXTERNAL_DATA:raw_data | bandpass(1.0, 2.0) | normalize" as the data name.
Available processing fragments:
  • time_shift({SHIFT})
  • normalize
  • scale({FACTOR})
  • flip
  • bandpass({FREQ_MIN}, {FREQ_MAX}[, zerophase][, corners={CORNERS}])
SalvusProject
Added an automatic domain preview visualization for 3-D box domains.
SalvusProject
Added an improved shotgather visualization. Amongst other things, it can now plot interleaved data from multiple traces and sort the receivers with a lambda function:
p.viz.shotgather(
    data=[
        "PROCESSED_DATA:corrected_data_10_15_hz | normalize",
        "SYNTHETIC_DATA:starting_model_10_15_hz | normalize",
    ],
    event="shot_049",
    receiver_field="velocity",
    component="Y",
    sort_by=lambda r: r.location[0]
)
SalvusProject
Allow for the passing of an interpolation mode to the mesh_from_xarray function in the Salvus Toolbox. This allows one to override the default spline interpolation routine, which may be useful in the presence of strong velocity contrasts.

Salvus version 0.11.40

Released: 2021-09-25
This release contains improvements to the mesh-to-mesh interpolation implementation, as well as a few fixes and quality-of-life improvements to SalvusProject functionality and SalvusFlow database handling.
SalvusFlow
All input files are stored in Salvus' internal database. From now on these are compressed which can safe a lot of space for input files with large number of receivers. Existing databases will be automatically migrated to the new structure.
SalvusMesh
Improve the mesh-to-mesh interpolation algorithm by allowing element set to be further restricted in both the source and destination meshes. This is useful, for instance, when interpolating between meshes with oceans. Also improved the heuristic which decided which element to source parameters from if an element was outside of the mesh or outside of a certain layer set. This should improve the algorithm's stability in such cases.
SalvusProject
The domain map plots for spherical chunk and UTM domains now automatically zoom to fit upon loading.
SalvusProject
Less assumptions in the internal layout of AppEEARS DEM files so Salvus now works with older and newer AppEEARS files.

Salvus version 0.11.39

Released: 2021-09-09
This is a minor release that fixes a bug when applying anisotropic refinements to the crust in a global domain, and reduces the memory usage of some SalvusFlow routines.
SalvusFlow
Improve detection of duplicated mesh files when transferring data of JobArrays to remote sites.
SalvusFlow
Reduce memory usage of simple_config.Waveform objects by lazy evaluation of UnstructuredMesh objects.
SalvusMesh
Fix a bug where an undefined reference to a refinement skeleton may be deleted before it was defined.

Salvus version 0.11.38

Released: 2021-08-11
Minor update with some utilities to inspect the contents of a project and to free up space during an inversion by deleting disposable files.
SalvusProject
Add utility to compress the storage requirements of an inversion by deleting files which are no longer needed and/or can be recomputed.
Example:
p.inversions.delete_disposable_files(
  inverse_problem_configuration="my_inversion",
  data_to_remove=["auxiliary", "waveforms", "gradients"]
)
Note that data from the initial model and unfinished iterations will be kept. It is recommend to remove files in the order auxiliary, waveforms, gradients, because gradients are the most expensive to recompute.
SalvusProject
Add utility to delete simulation results (waveforms / gradients).
Example:
# Delete waveforms
p.simulations.delete_results(
  simulation_configuration="my_sim_config",
  events=["event"]
)

# Delete gradients
p.simulations.delete_results(
  simulation_configuration="my_sim_config",
  misfit_configuration="my_misfit_config",
  events=p.events.list()
)
SalvusProject
Add utility to list a project's contents. This function will be called automatically when a project is loaded.

Salvus version 0.11.37

Released: 2021-07-15
This is a small maintenance /bugfix release that primarily serves to activate 2-D fully anisotropic elastic simulations on CUDA-capable GPUs.
SalvusCompute
Activate 2-D fully anisotropic simulations on CUDA capable GPUs, and fixes some bugs in the associated gradient computations. No API changes are required from users -- simply feel free to now run 2-D anisotropic simulations and inversions on a GPU-enabled site!

Salvus version 0.11.36

Released: 2021-07-02
This release adds more flexibility for handling side-set extrusion and topography in 2-D, as well as a more robust implementation of processing function serialization. Additionally, the minimum supported CUDA Compute Capability has been lowered to 3.5, and as such Kepler-based NVIDIA GPUs can now be used.
SalvusCompute
Previously, the lowest CUDA compute capability supported by Salvus was 6.0, due to the unavailability of a double precision atomic add function in previous CCs. A workaround is now implemented, which should allow Salvus to run on GPUs of CC 3.5 and greater. Note that NVIDIA will soon deprecate architectures < 6.0, so at some point in the future new Salvus versions will again only support CC 6.0 and greater.
SalvusFlow
Add initial support for the GridEngine job queueing system.
There are a number of different versions of GridEngine out there and minor adjustments might be necessary for Salvus to run on them. Please let us know if you encounter some.
SalvusMesh
Add a utility to extrude meshes across side sets in 2D. The functionality is currently limited to Cartesian meshes and side sets aligned with a coordinate axis.
Example:
mesh = basic_mesh.CartesianHomogeneousAcoustic2D(
    vp=1500.0, rho=1000.0, x_max=1.0, y_max=0.5,
    max_frequency=1e3,
).create_mesh()

mesh = mesh.extrude_side_set_2D(
    side_set="x1",
    offsets=np.array([0.0, 2.0, 4.0]),
    direction="x",
)
SalvusMesh
More general definition of 2D dem objects for non-spherical models. Now, y0 can be set to -np.infty to deform all elements in y direction with negative y coordinates.
Example:
mesh = basic_mesh.CartesianHomogeneousAcoustic2D(
      vp=1500.0, rho=1000.0, x_max=1.0, y_max=2.0, max_frequency=10e3
  ).create_mesh()
  mesh.points[:, 1] -= 0.5
  mesh.add_dem_2D(
      x=np.array([0.0, 1.0]),
      dem=np.array([-0.25, 0.25]),
      y0=-np.infty,
      y1=np.infty,
      kx=1,
      ky=1,
  )
  mesh.apply_dem()
SalvusProject
SalvusProject sometimes has to serialize Python functions to disc (e.g. misfits, processing functions, ...).
This now works with more functions, like functions that call other custom functions, closure values within with statements and a few other things.
In general it should just be more reliable.

Salvus version 0.11.35

Released: 2021-06-23
Minor update including small bug fixes and adding support for constant material parameters per element.
SalvusProject
Small bug fix to visualize 2D box domains without receivers.

Salvus version 0.11.34

Released: 2021-05-28
This release comes with several small fixes and improvements listed below.
New features include built-in support for two new source time functions, box constraints for inverse problems.
SalvusCompute
Added new gradient output formats hdf5-full and hdf5-minimal. hdf5-full contains additional fields stored in the input mesh, e.g., the index of layers / regions. hdf5-minimal will only write the data fields of the gradient, but neither coordinates, connectivity nor an xdmf file.
The default format hdf5 remains unchanged.
SalvusFlow
Adds two useful built-in source-time functions: a Tone Burst, commonly used to model ultrasound transducers, and a wavelet with a flattened spectrum, sometimes used in geophysical applications.
SalvusFlow
Adds a .to_list() function to all receiver collections so that multiple collections can more easily be appended to each other.
SalvusFlow
Mitigate an error that sometimes happened upon closing the paramiko SSH and SFTP clients.
SalvusFlow
MPICH sometimes causes a problem on OSX. If this happens during site initialization the error message now points to the section on the Mondaic website that describes how to solve it.
SalvusFlow
The source and receiver placement could previously fail for strongly distorted high-order elements. For these rare cases it now falls back to a slower, more brute-force method that should always work.
SalvusFlow
Improved the temporal resampling of custom STF functions which is useful for plotting on the Python side.
SalvusMesh
A list of side sets can now be passed to the free_surface argument of AbsorbingBoundaryParameters. These side sets will in turn not be extended with absorbing layers (if they are requested), and no absorbing conditions will be placed on them. This is useful, for instance, to model a thing plate (free_surface=["z0", "z1"]).
SalvusMesh
The Jupyter notebook mesh visualization widget now has a "Toggle Mesh" button to quickly toggle the visibility of the mesh. This is to look at sources and receivers inside the mesh.
SalvusOpt
Add optional box constraints to the InverseProblemConfiguration and implement the related projection algorithm for the trust region method.
Here is a snippet that adds lower and upper bounds on VP to an inversion:
mesh = p.simulations.get_mesh("initial_model")
lb = mesh.copy()
lb.elemental_fields["VP"] *= 0.8
lb.elemental_fields["RHO"] *= 0.8

ub = mesh.copy()
ub.elemental_fields["VP"] *= 1.2
ub.elemental_fields["RHO"] *= 1.2

p.inversions.set_constraints(
    inverse_problem_configuration="my_third_inversion",
    constraints={
        "lower_bounds": lb,
        "upper_bounds": ub,
    },
)
SalvusProject
In some rare cases the order of the coordinates in xarray data sets was not passed on correctly to Salvus' internal interpolation routines. This now works as expected.
SalvusProject
Deleting a volume, topography, or bathymetry model will now delete any dependent, auto-generated meshes.
SalvusProject
Make SalvusProject compatible with the latest pyproj 3.1.0 package.

Salvus version 0.11.33

Released: 2021-05-11
This release makes sure Salvus keeps working with the latest versions of xarray and SQLAlchemy. A consequence of this is that the Python netCDF4 package is now a hard dependency.
Please make sure your conda environment/Python installation is up-to-date before upgrading to this Salvus version.
Additionally this release adds the option to invert for homogeneous material parameters in the full waveform inversion workflow.
SalvusFlow
Updates to make it work with the latest versions of xarray and SQLAlchemy. The netCDF4 package is now a hard dependency which should improve compatibility when reading and writing files with xarray.
SalvusFlow
The salvus-flow add-site wizard will now also ask if it should run Salvus using GPUs on a newly configured site.
SalvusFlow
Fix a bug in the SiteNameValidator that caused add-site to crash when no other site has been initialized yet.
SalvusOpt
Extend the mapping function to support inversion for homogeneous models.

Salvus version 0.11.32

Released: 2021-05-05
This release fixes a few minor bugs relevant for regular-grid model extraction, mesh-to-mesh interpolation, and database management.
SalvusFlow
Salvus now raises an actionable error message in case the internal SQLite database got corrupted or does not work for another reason.
SalvusMesh
Fix a type issue within unstructured_mesh_utils._match_layers that could crop up if a mesh was generated outside of SalvusProject.
SalvusMesh
Fixes a bug where, in certain exceptional cases, get_enclosing_elements would not return the proper reference coordinates.

Salvus version 0.11.31

Released: 2021-04-23
This release comes with a new experimental feature for general mesh-to-mesh interpolations, which is very useful to interpolate the same model between to different discretizations.
Additionally, we added a workaround for a bug in parallel HDF5 that sometime occured when reading or writing large datasets.
SalvusCompute
There still seems to be an issue with parallel HDF5 and writing large amounts of data per rank in HDF5 1.12.0. This patch implements a workaround for execution on a single rank.
SalvusMesh
Generic mesh-to-mesh interpolation is now implemented in 2- and 3-D! This is useful in several situations, such as
  • representing two models on the exact same mesh,
  • increasing the frequency band in an ongoing inversion, and
  • re-meshing a model due to a decrease in minimum velocity,
among others. The primary interpolation function is available in salvus.mesh.tools.transforms. Along with full-mesh interpolations, layer-to-layer discontinuity-preserving interpolations, and "flattened" interpolations handling topographic deformations, are supported. Additional helper functions for re-meshing applications have also been added to salvus.mesh.unstructured_mesh_utils. One of theses is a function to extract a conservative 1-D model from an unstructured mesh, which helps to ensure that a new mesh can be generated that respects both the 3-D minimum velocities and existing discontinuities. Another is a function to match up layers between two unstructured meshes in the case that their IDs are different. This is helpful in the case where the interpolation should respect pre-defined discontinuities in the model.
The method currently does not raise if the spatial domains covered by the target mesh is contained in the source mesh. Use this with care.
For additional information, please see our new tutorial on mesh-to-mesh interpolations.

Salvus version 0.11.30

Released: 2021-04-14
This release comes with two main features: (1) better support for spherical chunk domains formed by arbitrary polygons and (2) a new output format to compute the wavefield in frequency domain for a set of specified frequencies by applying the Fourier transform on the fly during the simulation.
Additionally, there are several important bug fixes related to SmoothieSEM meshes, reading large hdf5 datasets, and writing xdmf files in SalvusCompute.
SalvusCompute
Enable on-the-fly Fourier transforms to output the volumetruc wavefield in frequency domain for a list of discrete frequencies.
It can be configured in the simple_config.simulation.Waveform object using output.frequency_domain.
This feature is currently only enabled for simulations on CPUs.
SalvusCompute
Fix a bug in SalvusCompute that caused multiple ranks to write xdmf files.
SalvusCompute
It seems as though the large dataset mitigations introduced in HDF5 1.10.2 were only applied to dataset writes, and not reads. This introduces a temporary workaround to read models with large (> 2GB) amounts of data per rank.
SalvusMesh
Fixes an issue that caused broken meshes when smoothiesem was used with high number of elements in lateral direction.
SalvusProject
Various bug fixes and quality-of-life improvements when using a SphericalChunkDomain together with a spherical polygon to further constrain the spatial extent. Most importantly conversions between WGS84 and fully spherical coordinates are now consistent with the rest of Salvus. The in-notebook domain plot now also works and shows the original spherical chunk together with the domain polygon.

Salvus version 0.11.29

Released: 2021-04-06
Minor release which fixes a bug in certain GPU runs, and adds the capability to limit the number of simultaneously running jobs in a slurm job array.
SalvusCompute
Fix a bug that previously existed where, in the case of a multi-node GPU run with 1 rank per node, the GPU halo would not get initialized properly. This would then lead to a failure during site initialization (as expected).
SalvusFlow
Optionally limit the number of parallel jobs in a slurm job array.
This can be specified in the site configuration of a slurm site with
max_simultaneous_jobs_in_job_array = 4
which internally translates to, for example, the %4 in --array=0-15%4.

Salvus version 0.11.28

Released: 2021-03-19
Minor release including a few bug fixes listed below. Additionally, the spectral-element order and output sampling rate for receivers is now configurable through the WaveformSimulationConfiguration.
SalvusFlow
The last part of running a simulation usually is to delete the remote run and temp directories Salvus needs to simulate waves. In most cases this just works but especially on network file systems the file system might be busy and refuse to actually delete anything. Previously this resulted in an exception but because everything else worked fine this was undesired. It now, by default, only raises a warning.
You can restore the old behaviour by setting raise_on_deletion_failure=True when using the low-level SalvusFlow API calls:
sn.api.run(..., raise_on_deletion_failure=True)
sn.api.run_many(..., raise_on_deletion_failure=True)
As before it will retry deleting a remote directory up to 5 times before actually raising the warning or exception with a now slightly increased timeout between retries.
It will also no longer raise in these cases in SalvusProject which should make it more stable on some file systems.

Changes to Experimental Features in 0.11.28

SalvusProject
Add the sampling interval for point output to the WaveformSimulationConfiguration.
SalvusProject
Fix a bug where side-sets involving fluid layers on UTM domains where incorrectly attached.
SalvusProject
The polynomial degree of the spectral-element basis is now configurable in the WaveformSimulationConfiguration.
w = WaveformSimulationConfiguration(spectral_element_order=6)
If not specified, the default remains at 4 as in all previous releases.

Salvus version 0.11.27

Released: 2021-03-01
The main feature in this release is a new method for the visualization / analysis of 2- or 3-D models and gradients. The addition of the function extract_model_to_regular_grid to the salvus.mesh.unstructured_mesh_utils module allows users to regularly sample a given mesh given locations specified by an xarray dataset. Additional improvements include a more flexible API for surface topography in UTM domains, a memory use mitigation when running many shots with the same mesh, and the automatic up-casting of related types in certain schema (for example: "2 elements per wavelength" is now upcast to "2.0 elements per wavelength").
SalvusFlow
Automatically cast integers to floats in many cases where objects expect floating point values to be set.
SalvusFlow
Copying simulation objects now, by default, only references a potentially attached mesh.
Many workflow have a large number of copied simulation objects which can result in a high memory usage if the meshes are copied as well.
The meshes can still be optionally copied with:
w_copy = w.copy(copy_mesh=True)
SalvusMesh
A new function named extract_model_to_regular_grid has been added to the unstructured_mesh_utils module. This function performs an interpolation from a general, unstructured mesh (spherical or cartesian) to a set of points defined on a xarray dataset. This can be useful, for instance, to create slices through a model for efficient visualization and analysis. See the function's docstring for additional examples, information, and tips.

Changes to Experimental Features in 0.11.27

SalvusProject
A new parameter can optionally be passed to a cartesian SurfaceTopography object that restricts the mesh deformation above a given z-value. This is useful, for instance, when placing a layer (i.e. the atmosphere) above a free surface with topography. Related constructors (such as SurfaceTopography.from_gmrt_file() optionally take this parameter as well.

Salvus version 0.11.26

Released: 2021-02-23
This release focusses on quality of life improvements for solving the inverse problem. It includes a bunch of bug fixes as well as new features.
A new tab has been added to the inversion dashboard showing some details about model updates and the evolution of the trust-region algorithm. This grants insights into how an ongoing inversion is doing.
SalvusProject and SalvusFlow can now recover more gracefully from partially failed job arrays where only a few jobs did not finish.
Furthermore the window picking for seismological full waveform inversions is now a lot faster.
Note that plotly >= 4.12.0 is required to display the new widgets properly. To update the python environment, check the installation instructions or run
wget https://mondaic.com/environment.yml -O salvus-0.11.26.yml
conda env update -n salvus -f salvus-0.11.26.yml
.
SalvusFlow
If a few jobs in a Salvus job array failed for some reason, the output for the successfully completed jobs can now be retrieved in a much simpler way:
SalvusJobArray.copy_output(..., copy_partial_results=True)
copy_partial_results defaults to True.
The same parameter is exposed to the salvus.flow.api.run_many() command and also defaults to True there.

Changes to Experimental Features in 0.11.26

SalvusOpt
Expose more parameters to steer the adaptive adjustment of the trust-region radius.
SalvusProject
Bug fix for the gradient widget of the inversion dashboard, where previously some event-dependent gradients were not displayed correctly.
SalvusProject
Bug fix in the SimulationConfiguration to ensure the extra_output_configuration passed to launch overwrites additional output values defined in the WaveformSimulationConfiguration. The output options in the WaveformSimulationConfiguration will be deprecated in a future release.
SalvusProject
Add a new tab to the inversion dashboard to visualize the progress of model updates and trust-region radius.
SalvusProject
Add a toggle button to the misfit widget to switch between absolute and relative misfits - normalized per iteration or event, respectively.
SalvusProject
Much faster seismological window picking for some cases. Additionally it is now a bit more conservative and will not pick some sketchy windows it did not pick before. All in all the picked windows should be very similar to results from the previous version of this algorithm but a few less windows will be picked.
SalvusProject
The p.waveforms.has_data() method now also works for synthetic data.
SalvusProject
The partial copy of the Salvus job array results has been integrated into all parts of SalvusProject. If one or more jobs fail for a forward or an adjoint simulation, it will still raise an exception but copy all successfully completed jobs to the project folder. Any subsequent simulations launched will be aware of this and not submit the already run ones.
This makes it much easier to recover from sporadic cluster failures without having to directly modify the project directory.

Salvus version 0.11.25

Released: 2021-02-12
This release comes with several improvements to make inversions run more efficiently. New options to manage checkpoints and to reduce the I/O overhead of smoothing have been added. Furthermore, the mapping function now offers more general parameterizations.
Additionally, some visualization tools have been improved, and a tuning parameter to mesh ocean layers was added.
Finally, Salvus now by default supports GLL orders of 1-7. Additional orders remain available upon request.
SalvusCompute
SEM orders 1-7 are now supported by default for simulation. Adjoint simulations on GPUs are currently limited to order 4.
SalvusFlow
It is sometimes convenient to visualize source and receiver locations in Paraview. A new function, salvus.flow.utils.simulation_src_rec_to_vtk, has been added to facilitate this. As arguments it takes a simulation.Waveform object, along with a string specifying what type of entity one wants to generate a .vtk file for (i.e. source or receiver). Check the function's docstring for advice on how to open the resultant file in Paraview.
SalvusMesh
Adding a new parameter to better control the lateral element size in the ocean. This is particularly relevant for local domains with strong bathymetry, where Snel's law in 1D may break down.
SalvusOpt
Reduce the file access of the smoothing algorithms to construct the diffusion models and enable remote diffusion meshes.

Changes to Experimental Features in 0.11.25

SalvusOpt
Add support for flexible parameter mappings and inversion for relative or absolute perturbations:
sn.Mapping(
      scaling="relative_deviation_from_prior",
      inversion_parameters=["VSV", "VSH", "VP", "RHO"],
      map_to_physical_parameters={
          "VPV": "VP",
          "VPH": "VP",
      }
  )
The example above assumes a prior model parameterized as TTI medium. It inverts for four independent parameters that encode relative perturbations from the prior model. The deviations in VPV and VPH are tied to the same inversion variable VP..
SalvusProject
Add memory_per_rank_in_MB as optional parameter to SiteConfig. This allows to adjust the memory settings for different machines during an inversion.
SalvusProject
Improve memory management of checkpoints in SalvusProject.
This gives more flexibility to tune the strategy regarding checkpoints. By default, checkpoints will be stored for every forward run, and automatically removed after (a) gradients for the simulation configuration have been computed and/or (b) the model got rejected by the trust region algorithm.
This behavior can be modified using optional boolean flags store_checkpoints and cleanup_checkpoints in the job_submission settings.
job_submission={
  "forward": ...,
  "preconditioner": ...,
  "store_checkpoints": False,
  "cleanup_checkpoints": False,
}
If the former is False checkpoints will only be stored when gradients are requested. If the latter is False checkpoints will never be deleted automatically.
SalvusProject
The _plot method of an EventData object now takes an additional optional parameter: _exclude_cbar. If set to true, a colorbar won't be added to the axis if a shotgather plot is requested. This makes it easier to produce shotgathers for multi-component data (i.e. for strain output).

Salvus version 0.11.24

Released: 2021-01-12
This release comes with a couple of generalizations and bug fixes related to preconditioners of the inverse problem as well as utilities to deal with cylindrical meshes.

Changes to Experimental Features in 0.11.24

SalvusCompute
Fix a bug in the auto time-step detection of the diffusion and the anisotropic acoustic wave equation that could previously result in a significant under-estimation of a stable time-step size.
SalvusFlow
New receiver collections to facilitate the creation of 3D apertures on Cartesian domains.
SalvusMesh
Add utilities to create cylindrical meshes including side sets and topography.
SalvusOpt
Enable space-dependent smoothing with arbitrary (an)-isotropic smoothing lengths as preconditioner of an InverseProblemConfiguration.
SalvusProject
Fix a bug in plotting gradients in the inversion dashboard or using p.viz.nb.gradients.

Salvus version 0.11.23

Released: 2020-12-03
This release adds several quality-of-life improvements for ongoing inversions, as well as a more sophisticated scheme to handle sites where two factor authentication is required. Support for volumetric models in 2-D seismological domains was added, along with a relevant tutorial ("Teleseismic 2D"). Volumetric seismological mantle and crustal models will also now automatically recognize the presence of oceans, and restrict the interpolation of material parameters to the elastic regions. If more control over this process is desired, one can still use the GenericModel constructor.
SalvusFlow
The port number of remote sites in the ~/.ssh/config file is now respected.
SalvusFlow
Salvus can now perform interactive SSH logins. This is necessary for example for interactive two factor authentication schemes.
Enable it like this in the site configuration:
[sites.site_name.ssh_settings]
            hostname = "host"
            username = "user"
            interactive_login = true

Changes to Experimental Features in 0.11.23

SalvusMesh
Adds functionality to refine, increase tensor order or build meshes in chunks to avoid memory bottlenecks. In particular, this adds two new functions:
Firstly, in salvus.mesh.tools.transforms uniformly_refine_chunkwise() wraps uniformly_refine() working with a subset of elements at a time, writing each of the readily processed chunks to a temporary file and finally merging everything together. This can both be used to refine each element by subdivision into an arbitrary number of elements in each dimension and/or to increase the order of the shape mapping.
Secondly, salvus.mesh.chunked_interface.create_mesh_chunkwise() can be used instead of create_mesh() of SphericalChunk3D, Cartesian3D and Cartesian2D using the same approach as described above to directly create large meshes that would otherwise reach the memory limitations of the machine.
SalvusProject
Enable stopping criteria to limit the maximum number of iterations in an inverse problem. This is mainly useful for automated monolithic inversion workflows.
p.inversions.set_stopping_criteria(
  inverse_problem_configuration="...",
  criteria={
    "max_iterations_global": 10,
    "max_iterations": 5,
  }
)
The criteria can be overwritten anytime to continue with the inversion. global settings apply to the entire inversion tree, the other settings apply to individual branches.
SalvusProject
Remove some path dependencies which previously prevented renaming the project.
SalvusProject
Various improvements to make 2-D seismological domains more useful.
SalvusProject
The interpolation of volumetric models onto seismological meshes was previously only available for 3-D domains. Support is now extended to 2-D domains, with "longitude" and "radius" OR "depth" being required coordinate axes in the parent xarray Dataset. A new tutorial (teleseismic_2d) has been added, fleshing out this feature.
SalvusProject
Add the ability to ignore elements flagged with a certain value during volume model interpolation for seismological models. This is useful, for instance, if one wants to limit interpolation to a specific region (say, the elastic subsurface, and not any water layers). See the description in the seismology GenericModel constructor for more details. Crustal and Mantle models will now ignore fluid elements by default, to ensure that elastic models are not interpolated into oceans. Is this behavior is undesirable, one has more control with the GenericModel interface.

Salvus version 0.11.22

Released: 2020-11-10
This release contains several small improvements to streamline the workflow orchestration behind the scenes.
SalvusFlow
API CHANGE
Salvus uses a job database to keep track of asynchronously launched jobs. Over time this database can become quite big to the point of negatively effecting the total performance.
With this change Salvus will now perform periodic maintenance of the database to optimize it and keep its size in check.
Additionally finished jobs are no longer moved into the "archived" group in the database but removed from the database upon job deletion. We don't expect this to have an effect on any user.

Changes to Experimental Features in 0.11.22

SalvusOpt
Provide a workaround for externally computed and incorrect adjoint sources. It is strongly recommend to verify the implementation of custom misfits and adjoint sources with a finite-difference test. Using the optional parameter force_trust_region_scaling badly scaled adjont sources can be mitigated by enforcing to scale the proposed model update to the trust region radius.
SalvusProject
When re-launching simulations for which data already exist (e.g. to compute checkpoints), previously computed outputs are kept in the project file structure and only overwritten once the new jobs have finished. Additionally, a utility to manually clean the simulation store has been added.

Salvus version 0.11.21

Released: 2020-11-05
This release contains several quality of life improvements and fixes for some minor issues.
SalvusFlow
The site configuration for local and SSH sites now has an extra python_binary key to choose which Python is used to execute the minimal wrapper script used to launch and control SalvusCompute. This is only important for sites which do not have a Python on their default paths.
Usage:
[sites.laptop]
    ...
    [sites.laptop.site_specific]
    python_executable = "/usr/local/bin/python"
SalvusFlow
Salvus now supports usernames in SSH proxy jump connections with settings like ProxyJump [email protected] in ~/.ssh/config files.
SalvusFlow
A full disk previously raised an error that the internal SalvusFlow database was corrupt. It now gives a more descriptive error message.
SalvusFlow
salvus-flow init-site SITE_NAME now always prints the disk usage of the Salvus controlled run and temp directories. As init-site is called each time Salvus is upgraded this serves as a period reminder to monitor the size of these directories.

Changes to Experimental Features in 0.11.21

SalvusProject
The internal workflow for handling checkpoints and adjoint simulations has been improved to avoid duplicated simulations for missing checkpoints on remote sites. This changes the hash values of adjoint simulations, which do not depend on synthetic receiver files anymore.
SalvusProject
The waveform plotting widget can now also plot windows without a reference time.

Salvus version 0.11.20

Released: 2020-10-25
This release brings in local refinements for cylindrical meshes, a speed-up for surface data output, and several usability improvements in SalvusProject. See below for a detailed list of features and bugs that have been patched.
SalvusCompute
Fixed the applications of pressure-free boundaries for GPU simulations in certain situations where refinements were present along fluid/solid coupling interfaces.
SalvusCompute
Significant speedup to the detection of which facets to select for surface output.
SalvusMesh
API CHANGE
Add cylindrical interpolation to local refinement schemes and adopt same interface as change_tensor_order() has for interpolation_type. This changes the api for spherical interpolation from
m.refine_locally(mask, spherical=True, r0_spherical=1.0, r1_spherical=2.0)
to
m.refine_locally(
    mask,
	interpolation_mode="spherical",
	interpolation_kwargs={"r0_spherical": 1.0, "r1_spherical": 2.0}
)
The new cylindrical scheme can be used accordingly
m.refine_locally(
    mask,
	interpolation_mode="cylindrical",
	interpolation_kwargs={"r0_cylindrical": 1.0, "r1_cylindrical": 2.0}
)
Below an example of how this can be used for improved representation of cylindrical structures (left new, right old).

Changes to Experimental Features in 0.11.20

SalvusOpt
Improve the inversion tree widget to visualize per-branch progress.
SalvusProject
The p.simulations.launch() method can now take extra output configurations. These can be any setting that does not modify the receiver output which currently are surface and volume data settings as well as the memory per rank buffer settings.
p.simulations.launch(
    simulation_configuration="basic",
    events=p.events.list(),
    site_name="my_computer",
    ranks_per_job=12,
    extra_output_configuration={
        "volume_data": {
            "sampling_interval_in_time_steps": 50,
            "fields": ["displacement"],
        },
        "surface_data": {
            "sampling_interval_in_time_steps": 20,
            "fields": ["acceleration", "velocity"],
            "side_sets": [