Changelog

p.simulations.launch(
    simulation_configuration="my_simulation",
    events=p.events.list(),
    ranks_per_job=2,
    site_name="local",
    extra_output_configuration={
        "frequency_domain": {
            "frequencies": [10.0],
            "fields": ["phi"],
            "start_time_in_seconds": 1.0,
            "end_time_in_seconds": 1.1,
        }
    }
)

p.simulations.cancel(
  simulation_configuration="my_simulation",
  events=p.events.list()
)

"EXTERNAL_DATA:raw_data | bandpass(1.0e3, 2.0e3) | normalize"

p.simulations.query(
    simulation_configuration="my_simulation",
    misfit_configuration="my_misfit",
    wavefield_compression=sn.WavefieldCompression(
        forward_wavefield_sampling_interval=15
    ),
    events=p.events.list(),
)

sn.WavefieldCompression(
      forward_wavefield_sampling_interval=N
  )

# 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
  ),
  ...
)

derived_job_config=WavefieldCompression(
      forward_wavefield_sampling_interval=N
  ),

p.misfits.get_gradient_filenames()
p.simulations.get_adjoint_input_files()
p.action.validation.validate_model_gradients()

TypeError: compute_gradients() needs keyword-only argument
wavefield_compression

p.misfits.compute_adjoint_source()

p.actions.seismology.get_events_with_windows("DSC_NAME")

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),
  ],
)

p.viz.shotgather(
    data="simulation",
    event="event",
    receiver_field="phi",
    component="A"
)

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

• time_shift({SHIFT})
• normalize
• scale({FACTOR})
• flip
• bandpass({FREQ_MIN}, {FREQ_MAX}[, zerophase][, corners={CORNERS}])

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

p.inversions.delete_disposable_files(
  inverse_problem_configuration="my_inversion",
  data_to_remove=["auxiliary", "waveforms", "gradients"]
)

# 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()
)

w = WaveformSimulationConfiguration(spectral_element_order=6)

job_submission={
  "forward": ...,
  "preconditioner": ...,
  "store_checkpoints": False,
  "cleanup_checkpoints": False,
}

p.inversions.set_stopping_criteria(
  inverse_problem_configuration="...",
  criteria={
    "max_iterations_global": 10,
    "max_iterations": 5,
  }
)

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": ["x0", "x1"],
        },
        "memory_per_rank_in_MB": 2000.0,
    },
)

p.add_to_project(
    sn.DataSelectionConfiguration(
        name="mute_with_direct_phase",
        receiver_field="phi",
        data_selection_function=mute_with_direct_phase,
    )
)

p.actions.seismology.pick_windows(
    data_selection_configuration="custom_windows",
    ...
    window_taper_width_in_seconds=10.0,
)

# Get the data selection configuration.
dsc = p.entities.get(
    entity_type="data_selection_configuration", entity_name="custom_windows"
)
# If interval windows have been picked before an event, its
# `EventWindowAndWeightSet` can be retrieved.
ewws = dsc.get_event_window_and_weight_set(event=p.events.get("event_0000"))

In  [1]: ewws.receivers
Out [1]:
{'XX.A0000.': {'receiver_weight': 1.5462720296177797,
  'components': {'Z': {'component_weight': 1.0,
    'windows': [{'window_start': 229.67554,
      'window_end': 1389.219377,
      'window_weight': 1.0}]},
...

In [2]: ewws.receivers["XX.A0000."]["receiver_weight"] = 0.7

In [3]: ewws.write(overwrite=True)

def data_selection_function(st, receiver, sources):

    # Receiver and component weights.
    weights = {
        # This is optional but allows to specify additional weights
        # important for the misfit and adjoint source computations.
        "receiver_and_component_weights": {
            # Pass the receiver weight here.
            "receiver_weight": 0.75,
            # It is also possible to give weights to individual
            # receivers.
            "component_weights": {"X": 1.0, "Y": 0.8", "Z": 0.5},
        }
    }

    for tr in st:
        component = tr.stats.channel[-1]
        temporal_weights = compute_window(...)

        # Individual window weights.
        weights[component] = [
            {"values": temporal_weights, "misfit_weight": 0.8},
            ...
        ]

    return weights

# Add to the project.
p.add_to_project(
    sn.DataSelectionConfiguration(
        name="custom_data_selection",
        receiver_field="phi",
        data_selection_function=data_selection_function,
    ),
    overwrite=True,
)

# Custom receiver weighting function.
def my_favorite_station(event, receivers, receiver_name):
    weights = {}
    for name in receivers:
        if name == receiver_name:
            weight = 2.0
        else:
            weight = 1.0
        weights[name] = weight
    return weights


p.actions.seismology.add_receiver_weights_to_windows(
    # Add the weights to existing windows in this data selection
    # configuration.
    data_selection_configuration="custom_windows",
    events=p.events.list(),
    # The weights for each item in the chain will be multiplied together.
    weighting_chain=[
        {
            "weighting_scheme": "ruan_et_al_2019",
            "function_kwargs": {"ref_distance_condition_fraction": 1.0 / 3.0},
        },
        {
            "weighting_scheme": "mute_near_source_receivers",
            "function_kwargs": {
                # All receivers closer than this to the sources
                # will have zero weight.
                "minimum_receiver_distance_in_m": 200e3,
                # All receivers further away than this will not be muted.
                "maximum_receiver_mute_distance_in_m": 1000e3,
                # How to go from weight 0 to weight 1 for receivers in the
                # transition region. Currently only "hanning" is supported.
                "taper_type": "hanning",
            },
        },
        # Custom weighting function.
        {
            "weighting_scheme": my_favorite_station,
            "function_kwargs": {"receiver_name": "XX.A0044."},
        },
    ],
    # Normalize the sum of all receiver weights to the receiver count.
    normalize=True,
)

p.viz.seismology.receiver_weights_map(
    data_selection_configuration="custom_windows"
)

p.viz.misfit_histogram(
    simulation_configuration_a="initial_model_70_120_seconds",
    simulation_configuration_b=p.inversions.get_simulation_name(
            inverse_problem_configuration="inversion", iteration_id=25
    ),
    misfit_configuration="phase_misfit_70_120_seconds",
    events=p.events.list(),
    merge_all_components=False
)

df = p.entities.get(
    entity_type="data_selection_configuration", entity_name="selection_a"
).get_interval_window_statistics_table(events=p.events.get_all())

p.viz.interval_window_statistics("selection_a")

In [1]: p.misfits.get_misfit_comparison_table(
            reference_data="initial_model",
            other_data=[
                p.inversions.get_simulation_name(
                    inverse_problem_configuration="inv", iteration_id=4
                )
            ],
            misfit_configuration="L2-misfit-to-target-model",
            event="event_0000",
        )

Out [1]:
           initial_model (ref)  inv_it_3__trial   Reduction inv_it_3__trial
XX.A0000.      1.266640e-03     0.000224           0.001043
XX.A0001.      1.438440e-03     0.000361           0.001078
XX.A0002.      1.450685e-03     0.000369           0.001081
XX.A0003.      1.607995e-03     0.000430           0.001178
XX.A0004.      9.473526e-04     0.000238           0.000709
...                     ...          ...                ...
XX.A0095.      1.182061e-05     0.000065          -0.000053
XX.A0096.      1.360653e-06     0.000529          -0.000527
XX.A0097.      9.762485e-07     0.000102          -0.000101
XX.A0098.      4.663780e-06     0.000306          -0.000301
XX.A0099.      1.784453e-06     0.000165          -0.000163

[100 rows x 3 columns]

p.viz.nb.misfit_comparison(
    reference_data="initial_model",
    other_data=[
        p.inversions.get_simulation_name(
            inverse_problem_configuration="inv", iteration_id=4
        )
    ],
    misfit_configuration="L2-misfit-to-target-model",
    event=p.events.list()[0],
)

p.viz.seismology.misfit_map(
    reference_data="initial_model",
    compare_data=p.inversions.get_simulation_name(
            inverse_problem_configuration="inv", iteration_id=5
        ),
    misfit_configuration="L2-misfit-to-target-model",
    event=p.events.list()[0],
)

sn.domain.dim3.SphericalChunkDomain(
    lat_center=52.0,
    lat_extent=16.0,
    lon_center=170.0,
    lon_extent=66.0,
    radius_in_meter=6371000.0,
).plot()

p.actions.inversion.smooth_model(
    model=gradient,
    smoothing_configuration=sn.ConstantSmoothing(
        smoothing_lengths_in_meters={"VP": 0.01, "RHO": 0.01,},
    ),
    ranks_per_job=4,
    site_name="local",
)