pyswapp package

Subpackages

• pyswapp.utils package
  • Submodules
  • pyswapp.utils.interactive module
    • DCPickingInteractive
      • DCPickingInteractive.interact()
      • DCPickingInteractive.picks
      • DCPickingInteractive.polygons
    • DraggablePoints
      • DraggablePoints.points
    • FKFilterInteractive
      • FKFilterInteractive.key
      • FKFilterInteractive.picks
      • FKFilterInteractive.terminate
      • FKFilterInteractive.update_plot()
    • TXInteractive
      • TXInteractive.key
      • TXInteractive.picks
      • TXInteractive.reset
      • TXInteractive.reset_last
      • TXInteractive.terminate
      • TXInteractive.update_plot()
  • pyswapp.utils.inversion module
    • compute_chi2()
    • lambda_search()
    • linear_LSQR()
    • phase_response()
    • tomo2D_phasediff()
  • pyswapp.utils.physics module
    • frequency()
    • lorentzian_err()
    • phase_velocity()
    • slowness()
    • wavelength()
    • wavenumber()
  • pyswapp.utils.plot_settings module
  • pyswapp.utils.plotting module
    • calculate_new_limit()
    • discrete_cmap()
    • draw1DColumn()
    • get_xy()
    • plot_colorBar()
    • plot_tomo2D()
    • plot_vphase()
  • pyswapp.utils.settings module
    • create_settings()
  • pyswapp.utils.sql module
    • SQL
      • SQL.array_to_blob()
      • SQL.blob_to_array()
      • SQL.check_data()
      • SQL.delete_data()
      • SQL.drop_table()
      • SQL.duplicate_data()
      • SQL.get_connection()
      • SQL.get_geometry()
      • SQL.get_proc_labels()
      • SQL.get_settings()
      • SQL.get_shotfile()
      • SQL.get_table()
      • SQL.get_tables()
      • SQL.get_trafo_labels()
      • SQL.get_wids()
      • SQL.group_pd()
      • SQL.read_FV()
      • SQL.read_curve()
      • SQL.read_curve_cc()
      • SQL.read_data()
      • SQL.read_f_from_pd()
      • SQL.read_filter()
      • SQL.read_geometry()
      • SQL.read_pd()
      • SQL.read_setting()
      • SQL.read_sql()
      • SQL.show_tables()
      • SQL.to_sql()
      • SQL.wids_exist()
      • SQL.write_FV()
      • SQL.write_curve()
      • SQL.write_data()
      • SQL.write_filter()
      • SQL.write_pd()
    • StdevFunc
      • StdevFunc.finalize()
      • StdevFunc.step()
  • pyswapp.utils.utils module
    • assert_exists()
    • combine_dict()
    • create_geometry()
    • create_logging()
    • create_projectdir()
    • filter_df2dict()
    • get_fileList()
    • get_num_from_str()
    • get_shotfiles_from_geometry()
    • interp()
    • natural_sort()
    • nextpow2()
    • print_inventory()
    • read_DC_csv()
    • read_filter()
    • rename_files()
    • safe_makedirs()
    • save2csv()
    • write_filter()
  • Module contents

Submodules

pyswapp.curve module

class pyswapp.curve.DispersionCurve(mode=0, wave='rayleigh')

Bases: object

class to manipulate and save dispersion curve data

dropInvalid(inplace)

drop invalid data points

estimate_error(**kwargs)

estimate error

filter(pmin=None, pmax=None, param='frequency', inplace=False)

remove points outside of [pmin,pmax]

get_data()

store data in a data frame

init_data(freq, vel, err=None)

initialize data

markInvalid(pmin=None, pmax=None, param='frequency', mask=None)

mark invalid data points

markInvalid_by_poly(vertices)

mark invalid rows based on points inside a polygon

plot(data=None, axes=None, outfile=None, fmt=None, show=True, show_orig=False, **kwargs)

plot dispersion curve

plotColumn(data=None, axes=None, outfile=None, fmt=None, show=True, **kwargs)

plot dispersion curve data as 1D column to construct pseudosection

read(fname)

import data from file

resample(pmin, pmax, pn, pspace='log', param='frequency', kind='cubic', inplace=False, **kwargs)

resample data

save(prjdir, pre, format, parkseis_params=None)

save dispersion curve data to file

set(param, value, orig=True)

set a parameter

smooth(kernel_size=5, inplace=False)

smooth data

pyswapp.curves module

class pyswapp.curves.CombineCurves(data)

Bases: object

combine dispersion curves and perform simple statistics

combination(combination_method='binning', axes=None, show=True, **kwargs)

run combination of dispersion curves

pyswapp.manager module

class pyswapp.manager.BaseManager(prjdir, path2raw=None, path2geom=None, settings=None, database='swa.db', overwrite=False, **kwargs)

Bases: object

apply_filter(ftype='FK', points_top=None, points_bot=None, procset=None, use_windows=True, **kwargs)

Apply manual filter from database.

Parameters:

• ftype (string, default 'FK', filter type)

• points_top (list, top filter)

• points_bot (list, bottom filter)

• procset (str, identifier to set on which dataset the processing should be applied to)

• use_windows (bool, default True, whether to apply the processing to windows)

• kwargs

apply_filter_2D(procset=None, apply_to='all', use_windows=True, ftype='FK', uniq_per_rep=True, uniq_per_wid=True, **kwargs)

Apply filter to current selection or all data sets

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

• ftype (string, default 'FK', filter type)

• uniq_per_rep (bool, default True, whether a unique filter exists for each rep)

• uniq_per_wid (bool, default True, whether a unique filter exists for each wid)

data_preview(figures)

data preview modus

delete(procset=None, table='amps', params=None)

extract(procset=None, use_windows=True, method='max', **kwargs)

apply dispersion curve extraction to a stream

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• use_windows (bool, default True, whether to apply the processing to windows)

• method (str, default 'max', extraction method)

• kwargs (arguments for the extraction)

get_figures(type='')

return plot for each data set

gui_interact(type='pick', domain='FV', procset=None, use_windows=True, **kwargs)

interactive figure switcher

Parameters:

• type (str, plot type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• use_windows (bool, default True, whether to apply the processing to windows)

gui_view(type='', procset=None, use_windows=True, **kwargs)

figure switcher

Parameters:

• type (str, plot type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• use_windows (bool, default True, whether to apply the processing to windows)

import_filter(fname)

Read filter from file in tabular format

Parameters:

fname (str, filename to import)

load_procset(procset=None, **kwargs)

load processed data from database

plot(type='seismogram', procset=None, use_windows=True, **kwargs)

plot portions of the stream data

Parameters:

• type (str, plot type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• use_windows (bool, default True, whether to apply the processing to windows)

plot_curve(procset=None, use_windows=True, method='phaseshift', **kwargs)

plot a dispersion curve

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• use_windows (bool, default True, whether to apply the processing to windows)

plot_pseudosection(procset=None, **kwargs)

plot the Rayleigh wave phase velocity pseudosection

Parameters:

procset (str, identifier to set on which dataset the processing should be applied to)

preprocess(type, procset=None, use_windows=True, **kwargs)

apply preprocessing steps to current selection or all data sets

Parameters:

• type (str, which processing method to call)

• procset (str, identifier to set on which dataset the processing should be applied to)

• use_windows (bool, default True, whether to apply the processing to windows)

• kwargs (arguments for the processing)

print_stats(which='stream')

print stream information

process_curve(type, procset=None, method=None, dc_mode=0, use_windows=True, **kwargs)

apply a process to a dispersion curve

Parameters:

• type (str, which processing method to call)

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• use_windows (bool, default True, whether to apply the processing to windows)

• kwargs (arguments for the processing)

process_curves(type, procset=None, method=None, dc_mode=0, use_windows=True, **kwargs)

read_filter(ftype='FK', procset=None, use_windows=True, uniq_per_rep=True, uniq_per_wid=True)

Read manual filter from database.

Parameters:

• ftype (string, default 'FK', filter type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• use_windows (bool, default True, whether to apply the processing to windows)

• uniq_per_rep (bool, default True, whether a unique filter exists for each rep)

• uniq_per_wid (bool, default True, whether a unique filter exists for each wid)

Return type:

points_top (list), points_bot (list)

save(procset=None, method=None, dc_mode=0, use_windows=True, **kwargs)

save a dispersion curve for a defined source location, repetition and window id

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• use_windows (bool, default True, whether to apply the processing to windows)

save_filter(fname='filter.csv', ftype='FK', procset=None)

Save filter to file in tabular format

Parameters:

• fname (str, filename to save data to disk)

• procset (str, identifier to set on which dataset the processing should be applied to)

• ftype (string, default 'FK', filter type)

save_stream(procset=None)

save stream in .mseed file format

save_streams(procset=None, apply_to='all')

save streams in .mseed file format

select_data(sin=1, rep=1, inplace=True, verbose=True)

Select one stream object based on source location and shot repetition indices

Parameters:

• sin (int, shot index number)

• rep (int, repeated shot index number)

• inplace (bool, default True, whether to modify the stream object rather than creating a new one)

• verbose (print current selection to console)

Return type:

stream object

set_loadset(procset=None)

set the loadset label, i.e. which dataset to load

set_new_procset(procset=None, verbose=True)

set the new active processing name

set_procset_label(procset=None, verbose=True)

set the new active processing name

transform(method='phaseshift', procset=None, use_windows=True, **kwargs)

apply wavefield transformation to current selection or all data sets

Parameters:

• method (str, default 'phaseshift', which transformation method to apply to the data)

• procset (str, identifier to set on which dataset the processing should be applied to)

• use_windows (bool, default True, whether to apply the processing to windows)

• kwargs (arguments for the processing)

class pyswapp.manager.MASW2DManager(prjdir, path2raw=None, path2geom=None, settings=None, database='swa.db', **kwargs)

Bases: BaseManager

apply_filter(procset=None, apply_to='all', use_windows=True, ftype='FK', uniq_per_rep=True, uniq_per_wid=True, **kwargs)

Apply filter to current selection or all data sets

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

• ftype (string, default 'FK', filter type)

• uniq_per_rep (bool, default True, whether a unique filter exists for each rep)

• uniq_per_wid (bool, default True, whether a unique filter exists for each wid)

combine(procset=None, method=None, filter=True, dc_mode=0, use_windows=True, **kwargs)

Combine dispersion curves with same receiver spread location

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curves)

• filter (, bool, manually filter curves if True)

• dc_mode (int, default 0, mode of propagation)

• use_windows (bool, default True, whether to apply the processing to windows)

extract(procset=None, method='max', apply_to='all', use_windows=True, **kwargs)

Extract dispersion curves

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, default 'max', method for dispersion curve extraction)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

extract_curves(procset=None, method='max', apply_to='all', use_windows=True, **kwargs)

Extract dispersion curves

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, default 'max', method for dispersion curve extraction)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

filter_CC()

Manually filter multiple dispersion curves

moving_window(procset=None, apply_to='all', **kwargs)

Apply windowing to current selection or all data sets

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• kwargs (window settings)

plot(type='seismogram', procset=None, apply_to='all', use_windows=True, **kwargs)

Plot the stream data

Parameters:

• type (str, plot type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

plot_CC(procset=None, method=None, dc_mode=0, pseudosection=True, **kwargs)

Plot the combined dispersion curves

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• pseudosection (bool, plot as pseudosection)

• kwargs (arguments for the processing)

plot_curves(procset=None, method=None, dc_mode=0, apply_to='all', use_windows=True, **kwargs)

Plot a dispersion curve

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

plot_streams(type='seismogram', procset=None, apply_to='all', use_windows=True, **kwargs)

Plot the stream data

Parameters:

• type (str, plot type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

preprocess(type='trim', procset=None, apply_to='all', use_windows=True, **kwargs)

Apply preprocessing steps to current selection or all data sets

Parameters:

• type (str, processing type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

preprocess_streams(type='trim', procset=None, apply_to='all', use_windows=True, **kwargs)

Apply preprocessing steps to current selection or all data sets

Parameters:

• type (str, processing type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

process_CC(type='smooth', procset=None, method=None, dc_mode=0, **kwargs)

Process the combined dispersion curves

Parameters:

• type (str, which processing method to call)

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• kwargs (arguments for the processing)

process_curves(type='smooth', procset=None, method=None, dc_mode=0, apply_to='all', use_windows=True, **kwargs)

Apply a process to a dispersion curve

Parameters:

• type (str, which processing method to call)

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

• kwargs (arguments for the processing)

save(procset=None, method=None, dc_mode=0, apply_to='all', use_windows=True, **kwargs)

Save the dispersion curves based on receiver spread midpoint

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

save_CC(procset=None, method=None, dc_mode=0, format='csv', **kwargs)

Save the dispersion curves based on receiver spread midpoint

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• format (str, default 'csv', in which format the dispersion curve should be saved (dinver and ParkSeis support))

save_curves(procset=None, method=None, dc_mode=0, apply_to='all', use_windows=True, **kwargs)

Save the dispersion curves based on receiver spread midpoint

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

transform(method='phaseshift', procset=None, apply_to='all', use_windows=True, **kwargs)

Apply wavefield transformation to current selection or all data sets

Parameters:

• type (str, transformation method)

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

transform_streams(method='phaseshift', procset=None, apply_to='all', use_windows=True, **kwargs)

Apply wavefield transformation to current selection or all data sets

Parameters:

• method (str, transformation method)

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

class pyswapp.manager.Tomo2DManager(prjdir, path2raw=None, path2geom=None, settings=None, database='swa.db', **kwargs)

Bases: BaseManager

apply_filter(procset=None, apply_to='all', use_windows=True, ftype='FK', uniq_per_rep=True, uniq_per_wid=True, **kwargs)

Apply filter to current selection or all data sets

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

• ftype (string, default 'FK', filter type)

• uniq_per_rep (bool, default True, whether a unique filter exists for each rep)

• uniq_per_wid (bool, default True, whether a unique filter exists for each wid)

compute_phasediff(procset=None)

Compute phase differences and store in database

Parameters:

procset (str, identifier to set on which dataset the processing should be applied to)

plot(type='seismogram', procset=None, apply_to='all', use_windows=True, **kwargs)

Plot the stream data

Parameters:

• type (str, plot type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

plot_curves(procset=None, method='tomo2D', dc_mode=0, **kwargs)

Plot dispersion curves

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

plot_streams(type='seismogram', procset=None, apply_to='all', use_windows=True, **kwargs)

Plot the stream data

Parameters:

• type (str, plot type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

prepare_streams(min_offset=-inf, max_offset=inf, min_rec=6, max_rec=None, procset=None)

retrieve subsets of the data based on forward and reverse offset shots

Parameters:

• min_offset (float, minimum offset (in m) to consider for trimming stream)

• max_offset (float, maximum offset (in m) to consider for trimming stream)

• min_rec (int, mininum number of receivers to keep for trimming down data)

• max_rec (int, maximum number of receivers to keep for trimming down data)

• procset (str, identifier to set on which dataset the processing should be applied to)

preprocess(type='trim', procset=None, apply_to='all', use_windows=True, **kwargs)

Apply preprocessing steps to current selection or all data sets

Parameters:

• type (str, processing type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

preprocess_streams(type='trim', procset=None, apply_to='all', use_windows=True, **kwargs)

Apply preprocessing steps to current selection or all data sets

Parameters:

• type (str, processing type)

• procset (str, identifier to set on which dataset the processing should be applied to)

• apply_to (str, default 'all', whether to apply function to all streams or just the current selection)

• use_windows (bool, default True, whether to apply the processing to windows)

process_curves(type='smooth', procset=None, method='tomo2D', dc_mode=0, **kwargs)

Apply a process to a dispersion curve

Parameters:

• type (str, which processing method to call)

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• kwargs (arguments for the processing)

run(min_offset=3, max_offset=1000000.0, lam=1, abs_err=None, rel_err=None, procset=None, opt_lam=False, scale=0.6, lam_max=200, **kwargs)

Run the tomographic like approach

Parameters:

• min_offset (float, minimum offset to consider for trimming stream)

• max_offset (float, maximum offset to consider for trimming stream)

• lam (int, regularization strength)

• rel_err (float or None, default None, error to consider in the error-weighted least-squares approach)

• procset (str, identifier to set on which dataset the processing should be applied to)

• opt_lam (bool, use constant lambda or find optimum lambda per iteration)

• scale (float, percentage value to decrease lambda)

• lam_max (int, maximum value of lambda)

save(procset=None, method='tomo2D', dc_mode=0, format='csv', **kwargs)

Save the dispersion curves based on receiver spread midpoint

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• format (str, default 'csv', in which format the dispersion curve should be saved (dinver and ParkSeis support))

save_curves(procset=None, method='tomo2D', dc_mode=0, format='csv', **kwargs)

Save the dispersion curves based on receiver spread midpoint

Parameters:

• procset (str, identifier to set on which dataset the processing should be applied to)

• method (str, method used to obtain dispersion curve)

• dc_mode (int, default 0, mode of propagation)

• format (str, default 'csv', in which format the dispersion curve should be saved (dinver and ParkSeis support))

pyswapp.qtapps module

class pyswapp.qtapps.CurveFilter(data)

Bases: QWidget

User interface to manually remove points from multiple curves

closeEvent(self, a0: QCloseEvent | None)

current_mask()

Get the most recent mask for the active curve.

init_ui()

interface design

onselect(verts)

Handle polygon selection and update mask.

remove_points()

Remove masked points

show_next_data()

show_popup()

show_prev_data()

undo_filter()

Undo last filtering operation for current curve.

update_display()

Refresh the plot with current curve and mask.

class pyswapp.qtapps.DataSwitcherBase(data, sql, plot='TX', use_windows=False, interaction_class=None, procset=None, procsets=None, btn_label='Click me', window_label='SHOTFILES', window_title='SWA Viewer', select_plot=True, **kwargs)

Bases: QWidget

Base user interface to manipulate seismic dataset

add_combobox(sets, set, label=None, size=90)

Add a combo box

clean()

closeEvent(self, a0: QCloseEvent | None)

create_figure(plot=None, procset=None, **kwargs)

Safely create the requested figure.

create_placeholder(canvas)

create canvas placeholder

index_changed

index_pair_changed

init_ui()

interface design

interact()

plot_changed

procset_changed

replace_widget(canvas, figure)

remove widget

select_data(sin=1, rep=1)

Select one stream object based on source location and shot repetition indices

set_group(group_index)

set_index(current_index)

set_plot(plot)

set_procset(procset)

show_next_figure()

show_previous_figure()

update_display()

update the display

class pyswapp.qtapps.DataSwitcherFilter(data, sql, plot='FK', use_windows=False, procset=None, procsets=None, select_plot=True, interaction_class=None, **kwargs)

Bases: DataSwitcherBase

Manual filter interface.

add_button(label, width=100)

apply_filter(stream, sin, rep, wid)

create_figure(plot=None, **kwargs)

Safely create the requested figure.

current_data()

interact_delete()

Delete data from database.

interact_filter()

Apply filter based on interaction points.

interact_save()

Save filtered data to database.

setup_interaction(figure)

show_popup()

Information

write_current_filtered_data(stream, flag, sin, rep, wid)

write_filtered_data()

class pyswapp.qtapps.DataSwitcherFilterFK(data, sql, plot='FK', use_windows=False, procset=None, procsets=None, select_plot=True, **kwargs)

Bases: DataSwitcherFilter

Manual FK filter interface.

init_ui()

Build the FK filter interface.

update_display()

Update all canvases, toolbars, labels, and interactor.

class pyswapp.qtapps.DataSwitcherFilterTX(data, sql, plot='TX', use_windows=False, procset=None, procsets=None, select_plot=True, **kwargs)

Bases: DataSwitcherFilter

Manual FK filter interface.

init_ui()

Build the FK filter interface.

update_display()

Update all canvases, toolbars, labels, and interactor.

class pyswapp.qtapps.DataSwitcherPick(data, sql, plot='FV', use_windows=False, procset=None, procsets=None, select_plot=True, **kwargs)

Bases: DataSwitcherBase

Manual dispersion curve picking interface

get_picks()

Load picks from SQL and return them as a dict.

init_ui()

Builds the UI. Mostly identical to original, but safer & cleaner.

interact()

Called when user performs picking interaction.

set_method(method)

Change FV/dc processing method and refresh display.

show_popup()

Help popup with keyboard shortcuts.

write_data_to_sql()

Writes edited picks to SQL.

class pyswapp.qtapps.DualDataSwitcher(data, sql, plot='geom', DataSwitcher=None, procset=None, procsets=None, window_title='SWA Viewer', select_plot=True, **kwargs)

Bases: QMainWindow

User interface to display raw data and select subset of data (e.g., based on windowing) side by side

clean()

closeEvent(self, a0: QCloseEvent | None)

class pyswapp.qtapps.FigureSwitcher(figures)

Bases: QMainWindow

User interface to view the seismic data

init_ui()

interface design

show_next_figure()

Switch to next figure

show_previous_figure()

Switch to previous figure

update_figure()

Update figure

pyswapp.stream module

python class for manipulating an Obspy stream

class pyswapp.stream.SeismicStream(fname, settings=None, channel_nr=1001, pre_trigger=0)

Bases: object

class to manipulate a seismic record for the analysis of surface waves

amps2st(amps, st=None)

store amplitudes (nchannels,nsamples) as obspy stream data

apply_fk_filter(points_list, key_list, **kwargs)

apply fk filter from picking boundaries

apply_geometry(source_coordinates, receiver_coordinates)

Apply the survey geometry to the seismic data

apply_linear_mute(points_list, key_list, **kwargs)

argfreq()

return the frequency ids of the selection

check_traces(st=None)

check whether a trace only contains zeros and remove it

compute_phasediffs()

compute phase differences between adjacent receivers for one shot file

dcpicking(pck_mode='auto', auto_method='max', **kwargs)

automatic or interactive dispersion curve picking

filter(by, **kwargs)

non-interactive FD based filtering of the trace data

linear_mute(points, key='t', **kwargs)

moving_window(**kwargs)

Move a window along the trace data to select a subset and store it in a dictionary

property offset

plot(type='', **kwargs)

Create static plots

preprocess_windows(windows, type='filter', **kwargs)

run a preprocessing step on all windows

print_stats(which='stream')

print stream information

read_data(fname, channel_nr=1001, pre_trigger=0, extract_geometry=False)

read a shotfile and extract relevant information

Parameters:

• fname (str, file name)

• channel_nr (int, optional)

• pre_trigger (float, optional)

• extract_geometry (bool, True if geometry should be extracted, False otherwise)

resample(sampling_rate, window='hann', no_filter=True, strict_length=False)

resample data in all traces using the method from obspy method

reset_FK()

Reset FK filter

reset_pst()

save_stream(fot, pre)

save stream in .mseed file format

set_shot_params()

set shot parameters

st2amps(st=None)

store amplitudes in ndarray (nchannels,nsamples)

transform(method='phaseshift', **kwargs)

Apply the wave field transformation

transform_windows(windows, trafo_type='phaseshift')

apply wavefield transformation to data stored in all windows

trim(by, **kwargs)

non interactive time or offset based trimming of the trace data

trim_by_offset(min_offset, max_offset, nrec=None)

cut traces outside of the offsets limits

update_FV(method, vel, kw, freq, FV)

update FV data

update_pst(amps, sht, recs, par)

update stream data

Module contents