Changelog

def forward_norm(data_synthetic, data_observed, sampling_rate_in_hertz):
        ...

    def jacobian_norm(
        adjoint_source, data_synthetic, data_observed, sampling_rate_in_hertz
    ):
        ...

    norm = sn.TraceNormalization(forward=forward_norm, jacobian=jacobian_norm)
    p += sn.MisfitConfiguration(
        ...,
        normalization=norm,
    )

sn.WaveformSimulationConfiguration(
    receiver_sampling_rate_in_time_steps=11, ...
)

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

task_chain_config = TaskChainSiteConfig(
        site_name="test_site",
        number_of_parallel_workers=5,
        ranks_per_salvus_simulation=2,
        max_threads_per_worker=2,
        shared_file_system=True,
    )

    p.simulations.run(
        events=p.events.list(),
        simulation_configuration="my_simulation",
        site_config=task_chain_config,
    )

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