salvus.project.configuration.data_selection_configuration

class DataSelectionConfiguration(
    salvus.flow.utils.serialization_helpers.SerializationMixin
):
    def __init__(
        self,
        name: str,
        receiver_field: str,
        data_selection_function: str | typing.Callable | None = None,
        extra_kwargs_data_selection: dict | None = None,
    ): ...

Configure which pieces of the data to use and how much they influence the final misfits and adjoint sources and thus the result of any inversion.

At the base level this means to select pieces of waveforms that are “good enough” to do whatever needs to be done - usually to enable a physically meaningful comparison between observed and synthetic data.

Here this is done via so-called temporal weights which are just an array of weights, one for each sample in a waveform. This can be used to for example mute arrivals after the primary arrival. It can also be used to only select certain windows in the data by setting the temporal weights to zero in time ranges one wants to mask out. Each component on each receiver can have multiple temporal weight sets or windows - misfits and adjoint sources will be computed and summed for each individually. Salvus takes care that everything is consistent in the end.

Furthermore this class enables settings weights at up to three different levels. They will all default to 1.0 but can be set individually.

• Receiver weights to for example reduce the importance of clustered receivers or increase the influence of far-offset receivers.
• Component weights for each receiver to prioritize for example vertical component recordings.
• Window weights. Individual weights for each windows/temporal weight array enables an even finer grained control of what information enters an inversion. Use cases are for example to give higher weights to certain phases or use the signal to noise ratio to steer individual weights.

Together all of this enables use cases ranging from single phase selection, FWI window picking, exponential damping of energy after the first arrival, arbitrarily complex geometrical receiver weighting schemes and many more.

Please note that weighting individual events or misfit configurations is not handled here - in the case of SalvusProject it is handled by the inverse problem configuration.

There are largely two options to steer this:

• Provide a data selection function. It will be called on-the-fly everytime data is requested.
• Create an EventWindowAndWeightSet for each event. These can store interval windows and weights which on-the-fly will be mapped and applied to the data.

If both exist for an event, the EventWindowAndWeightSet will be given preference.

def from_json(d: builtins.dict) -> Any: ...

def create_new_event_window_and_weight_set(
    self,
    event: Event,
    window_taper_width_in_seconds: float,
    taper_type: str = "hanning",
) -> EventWindowAndWeightSet: ...

def delete_event_window_and_weight_set(self, event: Event | str) -> None: ...

def get_event_window_and_weight_set(
    self, event: Event
) -> EventWindowAndWeightSet: ...

def get_interval_window_statistics_table(
    self, events: list[Event] | EventCollection
) -> pd.DataFrame: ...

def get_temporal_weights_function_for_event(
    self, event: Event
) -> typing.Callable: ...

def has_event_window_and_weight_set(self, event: Event | str) -> bool: ...

def list_event_window_and_weight_sets(self) -> list[str]: ...

def to_json(
    self,
    external_file_hash: str | None = None,
    timer: Timer | None = None,
    log_to_logger: bool = False,
    comm: int | None = None,
) -> dict: ...