Version:

Changelog

Salvus version 0.12.4

Released: 2022-07-28
Minor release that brings in support for using strain and gradient measurements in full-waveform inversion. Furthermore, the ability to read (adjoint) sources in chunks was added to alleviate the memory requirements for simulations with many sources or time steps.
There are a few more small improvements and bug fixes listed below.
SalvusCompute
Support the partial loading of sources into memory. Can be important for simulations with lots of sources and / or a long duration.
SalvusFlow
New event block data structure to more efficiently deal with large-scale acquisition geometries and a corresponding way to deal with them in SalvusProject.
SalvusFlow
New omit_tasks_per_node setting for Slurm sites.
This will cause the ntasks-per-node to be omitted for both the #SBATCH command as well as the call to srun for the rare site where this is necessary.
SalvusProject
Generalized external data proxies to read data from arbitrary external data sources without copying them into a Project.
SalvusProject
Assorted file format utilities and converters.
SalvusProject
Fix a bug in the bandpass processing fragment, which did not recognize frequency inputs in scientific number format.
Here is an example of a data name:
Copy
"EXTERNAL_DATA:raw_data | bandpass(1.0e3, 2.0e3) | normalize"
SalvusProject
Enable the use of misfits and adjoint sources based on first spatial derivatives of the wavefield, i.e., strains and gradients.
It is now possible to also pass strain, gradient-of-displacement and gradient-of-phi as valid receiver fields in the misfit configuration and related event data and event misfit objects.
Remember that strain data are not rotated and output is in Cartesian coordinates.
SalvusProject
API CHANGE
Rename datasets (and derived channel names) in ASDF output for gradients of the displacement field to comply with the SEED convention.
This is a (small) breaking change that only affects the combination of ASDF files with outputting the gradient of the displacement field.
The names of datasets and channels need to be adjusted as follows:
2D (old): XXX, XXY, XYX, XYY
2D (new): XG0, XG1, XG2, XG3
3D (old): XXX, XXY, XXZ, XYX, XYY, XYZ, XZX, XZY, XZZ
3D (new): XG0, XG1, XG2, XG3, XG4, XG5, XG6, XG7, XG8
Apologies for the inconvenience caused.
SalvusProject
Fix a bug in p.viz.waveforms(), which caused to function to fail with a cryptic error message when data was passed as a string.

Salvus version 0.12.3

Released: 2022-07-03
This release introduces new modules or improved support for several physics in the simulation engine. This includes anisotropic acoustic media, native support for visco-acoustic simulations, and a new solver model for static problems to solve the Poisson equation. Some of the new features are currently only supported on CPU hardware.
Additionally, the release enables custom MPI commands, for instance to use machine files on remote machines and contains several small bug fixes.
SalvusCompute
Support waveform simulations and gradients w.r.t. medium properties in VTI acoustic media.
SalvusCompute
Support visco-acoustic modeling in the scalar wave equation. The implementation and API are very similar to visco-elastic modeling, and require the specification of linear solids and QKAPPA as a material parameter.
Previously, attenuation in a fluid could only be modeled as a degenerate case of elastic physics.
This feature is currently only supported on CPUs and SalvusCompute will throw an error when attempting to run a visco-acoustic simulation on a CUDA-enabled site.
SalvusFlow
API CHANGE
Extend functionality of handling segy files for adding external data to a project.
Instead of just passing the source mechanism, users can now define simple callback functions for sources and receivers to create Salvus objects from the information stored in segy files. This breaks the previous syntax of the implementation of SegyEvent, but it should be straightforward to upgrade.
SalvusFlow
Minor improvement in the SSH connection error handling. It should now report a better error message.
SalvusFlow
Extra keyword arguments can now be passed to paramiko.SSHClient.connect() to allow more fine tuning for some SSH connections.
Usage in the site config file:
[sites.my_site.ssh_settings]
    hostname = "some_host"
    username = "some_user"
    [sites.my_site.ssh_settings.extra_paramiko_connect_arguments.disabled_algorithms]
        pubkeys = ["rsa-sha2-512", "rsa2-sha2-256"]
Furthermore the init-site command now has a --verbose flag to facilitate debugging tricky connections:
salvus-cli init-site my_site --verbose
SalvusFlow
A new mpirun_template parameter for ssh and local site types that allows full customization of the actual call to mpirun in case it is necessary.
Usage in the site config file:
[sites.my_site.site_specific]
    mpirun_template = "/custom/mpirun -machinefile ~/mf -n {RANKS}"
This example will thus use a custom mpirun executable with a non-standard argument for all Salvus runs on that site. The {RANKS} argument will be filled in by Salvus with the number of ranks for each simulation.
SalvusProject
Changes to the event configuration in UnstructuredMeshSimulationConfiguration objects are now properly recognized when trying to overwrite an existing configuration of the same name.

Changes to Experimental Features in 0.12.3

SalvusCompute
Add a new physics module to solve the Poisson equation.
This is the first elliptic PDE that can be solved with Salvus. The Poisson equation is useful for simulatingthe gravitational potential of a planetary object as well as computing correct inner products and regularization terms in the Sobolev space H1H^1.
This feature is currently only supported on CPUs and is considered experimental.

Salvus version 0.12.2

Released: 2022-05-31
Minor update with a new model class based on xarray to invert for structured data in SalvusOpt. Furthermore, we extended the options for passing callback functions to SalvusProject.
SalvusOpt
Add new model class StructuredModel to SalvusOpt to invert models parameterized on a regular grid using xarray.Datasets.
SalvusProject
The function serialization can now also deal with functions passed in closures.

Salvus version 0.12.1

Released: 2022-05-16
This release provides several small improvements for making inversion workflows more resilient and more robust.
Furthermore, we added easier support for arbitrary boundary conditions through the WaveformSimulationConfiguration.
SalvusFlow
Add an normalization option for the misfit and adjoint source computation.
The adjoint source is aware of this operation and Salvus will make sure it is correct.
SalvusOpt
Add basic timing statistics for the tasks of an iteration. A summary is printed in the Stats tab of the iteration widget.
SalvusOpt
Reduce the memory overhead of dealing with many event-dependent gradients.
SalvusProject
Add support for specifying boundary conditions in the WaveformSimulationConfiguration. This is useful for Dirichlet-type boundaries or absorbing boundaries of a UnstructuredMeshSimulationConfiguration. Boundaries specified here will be applied in addition to ocean load and/or absorbing boundaries specified as AbsorbingBoundaryParameters in the SimulationConfiguration. A ValueError is raised for duplicated conditions on a side set.
SalvusProject
Add ability to recover from failed preconditioner tasks and provide error logs of failed smoothing jobs.
SalvusProject
Add ability to recover from failed misfit computations. If a misfit computation fails for one more events during compute_misfits, the simulation results are considered corrupted and will be automatically deleted. This means that those simulations will be resubmitted when calling compute_misfits again.
This helps, for instance, to recover from corrupted ASDF files in case they have not have been written or downloaded correctly.

Salvus version 0.12.0

Released: 2022-04-30
This is a new major release which comes with a big portion of internal changes.
Fortunately, there are only a few breaking changes on the user-facing API, which are mostly related to custom meshing functionality.
We've also used the opportunity to remove some deprecated functionality of the inversion component, and added several improvements related to resilience and performance.
SalvusFlow
Will now reinitialize the SSH site in case a socket has been closed.
SalvusFlow
Better sharing of existing SSH connections. Should reduce the number of necessary SSH connection reinitializations.
SalvusFlow
Added timings to the individual tasks of a TaskChain.
SalvusMesh
API CHANGE
Removed the StructuredGrid2D, StructuredGrid3D and Skeleton classes and replaced them with new MeshBlock and MeshBlockCollection classes.
This should have a minimal influence on most users - please contact us if you experience any issues.
SalvusOpt
Performance improvement of the adjoint mapping function when using cutouts around source or receiver locations.
SalvusProject
Remove job submission settings from the inversion routines iterate() and resume(). Specifying site_name, ranks_per_job and wall_time_in_seconds_per_job is no longer supported. Instead, the job_submission_settings either need to be passed to the constructor of the InverseProblemConfiguration or by using p.inversions.set_job_submission_configuration().
SalvusProject
Add option to query simulations for specific compression settings.
Example:
p.simulations.query(
    simulation_configuration="my_simulation",
    misfit_configuration="my_misfit",
    wavefield_compression=sn.WavefieldCompression(
        forward_wavefield_sampling_interval=15
    ),
    events=p.events.list(),
)
SalvusProject
Add the option to pass an element mask to Cartesian volume models. Useful, for instance, when you only want to interpolate parameters onto a specific subdomain of the mesh (i.e. only onto elastic elements).
SalvusProject
Fix a bug that could occur in very specific circumstances when overwriting an existing bathymetry model.

Salvus version 0.11.48

Released: 2022-03-30
This release contains a long-sought feature for reducing the memory footprint of checkpoints for adjoint simulations by sampling the forward wavefield on a coarser grid during the adjoint run. This includes breaking changes for some of the inversion routines, which may require updating the syntax of some notebooks. Details are listed below. If you are concerned about upgrading, please get in touch with us in the user forum.
The release also contains bug fixes concerning the use of custom bm files in SalvusProject and attaching receivers on SmoothieSEM meshes, as well as the option to provide a custom scaling for the mapping function of the inversion.
Also, don't forget to keep your python environment up-to-date! We recommend to always run
wget https://mondaic.com/environment.yml -O ~/environment.yml
conda env update -n salvus -f ~/environment.yml
before upgrading.
SalvusFlow
New TaskChain workflow primitive that can be used to run multiple Salvus jobs and/or Python scripts in a linear chain within a single local/ssh/HPC job.
This is a first implementation so expect some rough edges:
# Construct a forward simulation object.
w_forward = sn.simple_config.simulation.Waveform(
    ..., store_adjoint_checkpoints=True
)

# Construct an adjoint simulation object.
w_adjoint = sn.simple_config.simulation.Waveform(...)
...
# There is a new `PROMISE_FILE:` prefix to tell SalvusFlow that a file does
# not exist yet but it will exist when the simulation is run.
w_adjoint.adjoint.point_source_block = {
    "filename": "PROMISE_FILE:task_2_of_2/input/adjoint_source.h5",
    "groups": ["adjoint_sources"],
}

# Define a Python function that is run between forward and adjoint simulations
# to generate the adjoint sources.
def compute_adjoint_source(
    task_index: int, task_index_folder_map: typing.Dict[int, pathlib.Path]
):
    folder_forward = task_index_folder_map[task_index - 1]
    folder_adjoint = task_index_folder_map[task_index + 1]

    output_folder = folder_forward / "output"

    event = sn.EventData.from_output_folder(output_folder=output_folder)

    event_misfit = sn.EventMisfit(
        synthetic_event=event,
        misfit_function="L2_energy_no_observed_data",
        receiver_field="displacement",
    )

    input_folder_adjoint = folder_adjoint / "input"
    event_misfit.write(input_folder_adjoint / "adjoint_source.h5")


# Launch the task chain. It will serialize the Python function and launches
# everything either locally or in Slurm/other supported systems.
tc = sn.api.run_task_chain_async(
    site_name="local",
    tasks=[w_forward, compute_adjoint_source, w_adjoint],
    ranks=4,
)
# Wait until it finishes.
tc.wait()
SalvusFlow
More stable implementation of the rewritten receiver placement and it should now also work for highly distored meshes.
SalvusOpt
Add option for custom scaling in mapping function. The custom scaling parameters need to be defined on the same mesh as the simulation and provided as elemental fields for all parameters.
Example
mesh = p.simulations.get_mesh("sim")

# Modify scaling parameters for all fields
mesh.elemental_fields["VP"] = ...
mesh.elemental_fields["RHO"] = ...

m = Mapping(
  scaling=mesh,
  inversion_parameters=["M"],
  map_to_physical_parameters={"VP": "M", "RHO": "M"},
)
SalvusProject
API CHANGE
Add proper serialization of bm files in SalvusProject. Previously, custom bm files were not added to the project and relied on external paths which prevented copying projects to other machines.
Adding custom background models as string will now throw a deprecation warning. It is strongly recommended to add custom bm files using the class model.background.one_dimensional.FromBm.
SalvusProject
API CHANGE
Add option for wavefield compression during adjoint runs to reduce the memory overhead. In order to allocate the correct number of checkpoints, this setting needs to be available at the time of computing the forward wavefield. This setting can now be used in several locations listed below by adding
sn.WavefieldCompression(
      forward_wavefield_sampling_interval=N
  )
if checkpoints should be stored for a resampling interval of N during the adjoint run. forward_wavefield_sampling_interval=1 corresponds to no compression and is equivalent to what was done prior to this release.
This is a (small) breaking change that requires updating the syntax of inversion-related functionality!
new optional arguments:
The wavefield compression settings enter now as optional argument into some objects and functions. If not given, it will default to forward_wavefield_sampling_interval=1, which is consistent with Salvus <= 0.11.47.
Examples:
# Inversion actions:
p.action.inversion.compute_misfits(
  ...,
  derived_job_config=sn.WavefieldCompression(
      forward_wavefield_sampling_interval=5
  ),
  ...
)

p.action.inversion.compute_gradients(
  ...,
  wavefield_compression=sn.WavefieldCompression(
      forward_wavefield_sampling_interval=5
  ),
  ...
)

p.action.inversion.sum_gradients(
  ...,
  wavefield_compression=sn.WavefieldCompression(
      forward_wavefield_sampling_interval=5
  ),
  ...
)

# InverseProblemConfiguration
sn.InverseProblemConfiguration(
  ...
  wavefield_compression=sn.WavefieldCompression(
      forward_wavefield_sampling_interval=5
  ),
  ...
)
deprecated parameters:
The parameters store_adjoint_checkpoints in p.simulations.launch(...) and store_checkpoints in p.actions.inversion.compute_misfits(...) are deprecated. Instead, use
derived_job_config=WavefieldCompression(
      forward_wavefield_sampling_interval=N
  ),
derived_job_config=None is the new default, which corresponds to the deprecated store_adjoint_checkpoints=False or store_checkpoints=False, respectively.
breaking changes:
compute_misfits and compute_gradients in p.action.inversion are now keyword-only functions. Additionally, we made the wavefield compression settings mandatory arguments of a few lower-level functions, such as:
p.misfits.get_gradient_filenames()
p.simulations.get_adjoint_input_files()
p.action.validation.validate_model_gradients()
In case you are using one of these directly, you will notice an error like
TypeError: compute_gradients() needs keyword-only argument
wavefield_compression
which can be fixed by just adding the wavefield_compression object shown above.

Salvus version 0.11.47

Released: 2022-03-23
Minor update to patch a bug introduced with 0.11.46.
SalvusProject
Fix a bug introduced with 0.11.46, which broke backward compatibility of a project when deserializing an UnstructuredMeshSimulationConfiguration.

Salvus version 0.11.46

Released: 2022-03-18
This release comes with a fairly long list of small improvements and bug fixes listed below. Notable new features include (full) gradient sources for elastic simulations, GPU support for acoustic gradient sources, better memory management of inversions, several tweaks regarding window selection and weighting, and a more robust and faster algorithm to attach receivers.
Thanks again to all users who reported bugs and requested features!
SalvusCompute
Added vector gradient sources for elastic media.
SalvusCompute
Scalar gradient sources now also work on GPUs.
SalvusFlow
Initializing a site with SalvusFlow now runs a test job using the default number of ranks for that site instead of 2.
SalvusFlow
The site configuration for the GridEngine and PBS site types now allows simplistic expressions:
[[sites.site_name.site_specific.additional_qsub_arguments]]
      name = "pe"
      value = "mpi {NODES * TASKS_PER_NODE}"

  [[sites.site_name.site_specific.additional_qsub_arguments]]
      name = "l"
      value = "ngpus={int(ceil(RANKS / 12))}"
SalvusFlow
Add a new lat_lng_to_utm_crs() helper routine to directly get a pyproj UTM CRS object from a point given in latitude and longitude.
SalvusFlow
The relative source and receiver placement code is much faster now due to algorithmic changes and code optimizations. Additionally, a few previously uncaught edge cases now work as expected.
SalvusFlow
Added local version of all HPC sites that directly interact with the job queuing and file systems without using SSH.
SalvusFlow
New salvus-cli alias for the salvus-flow command line call. This will become the default at one point.
SalvusProject
Safely remove adjoint sources after the adjoint simulation. This happens automatically after retrieving the results from the adjoint simulation. Adjoint source files will be recomputed on-the-fly if required. This can also be done explicitly using
p.misfits.compute_adjoint_source()
SalvusProject
Fix a bug in the hash computation for adjoint simulations that could result in non-unique hashes in special cases.
SalvusProject
New default basemap for the seismology receiver weights and misfit maps. Furthermore they are now configurable.
SalvusProject
The error log output of the seismological window picking routine is now more descriptive.
SalvusProject
SalvusProject will no longer create an empty EventWindowAndWeightSet in case the window selection routine did not pick a single window for a chosen event.
An appropriate warning message and log file entry will be created in that case.
SalvusProject
New function to get all events with windows for a chosen data selection configuration:
p.actions.seismology.get_events_with_windows("DSC_NAME")
SalvusProject
Added some more receiver weight validation steps and Salvus now properly deals with a few more edge cases, for example when the total receiver weight sum of an event is zero.
SalvusProject
UTMDomain objects no longer require the ellipsoid to be passed.

Salvus version 0.11.45

Released: 2022-01-27
First release of 2022 with several small bug fixes listed below. As a new feature, SalvusProject supports multiple source time functions for different point sources, which facilitates simulating finite faults or encoded sources.
SalvusCompute
Bugfix for the Clayton-Enquist absorbing boundaries in 2-D anisotropic physics.
SalvusCompute
Fixes a performance bug for adjoint GPU runs in purely elastic media. In this case, an unnecessary serial step is now skipped when loading checkpoints.
SalvusFlow
Enable salvus-flow upgrade and salvus-flow upgrade-site for double precision versions using the salvus_f64 binary.
SalvusFlow
The init-site script will wait a bit longer for the stderr in case it is not yet available due to some synchronization delays on shared and parallel file systems.
SalvusMesh
The UnstructuredMesh.extrude_side_set_2D() method now also works as expected for higher order meshes. Additionally fixed an issue with inverted elements in certain scenarios.
SalvusOpt
Fix a bug in the gradient view of the iteration widget. Now the mapped gradient accumulated from all events is correctly displayed in the widget.
SalvusProject
Fix a bug that prevented loading an InverseProblemConfiguration after the project has been transferred to another python environment with a different site configuration.
SalvusProject
Enable different source time functions for event with multiple point sources.
Example:
Event(
  event_name="event",
  sources=[point_src1, point_src2],
  receivers=receivers,
)

...

EventConfiguration(
  waveform_simulation_configuration=...,
  wavelet=[
      simple_config.stf.Ricker(center_frequency=1.0),
      simple_config.stf.Ricker(center_frequency=2.0),
  ],
)

Salvus version 0.11.44

Released: 2021-12-06
Minor release with a few bug fixes listed below.
Shoutout to the user community for identifying these bugs and helping us to fix them.
SalvusCompute
Fix a bug for CPU sites where surface output with multiple side sets per element could cause an issue in the surface wavefield output ordering.
SalvusFlow
Fix a bug in (de)-serialization of receiver objects when accidentially passing int instead of float types.
SalvusFlow
Fixing a bug when plotting adjoint sources.
SalvusProject
Fix a bug in plotting shotgathers for single data series.
Example:
p.viz.shotgather(
    data="simulation",
    event="event",
    receiver_field="phi",
    component="A"
)

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