`gf`¶

Pyrocko-GF: storage and calculation of synthetic seismograms

The pyrocko.gf subpackage splits functionality into several submodules:

The pyrocko.gf.store module deals with the storage, retrieval and summation of Green’s functions.
The pyrocko.gf.meta module provides data structures for the meta information associated with the Green’s function stores and implements various the Green’s function lookup indexing schemes.
The pyrocko.gf.builder module defines a common base for Green’s function store builders.
The pyrocko.gf.seismosizer module provides high level synthetic seismogram synthesis.

All classes defined in the pyrocko.gf.* submodules are imported into the pyrocko.gf namespace, so user scripts may simply use from pyrocko import gf or from pyrocko.gf import * for convenience.

`gf.store`¶

exception NotMultipleOfSamplingInterval[source]¶: Bases: Exception

class GFTrace(data=None, itmin=None, deltat=1.0, is_zero=False, begin_value=None, end_value=None, tmin=None)[source]¶

Bases: object

Green’s Function trace class for handling traces from the GF store.

t¶

Time vector of the GF trace.

Returns:	Time vector
Return type:	`numpy.ndarray`

exception CannotCreate[source]¶: Bases: pyrocko.gf.error.StoreError

exception CannotOpen[source]¶: Bases: pyrocko.gf.error.StoreError

exception DuplicateInsert[source]¶: Bases: pyrocko.gf.error.StoreError

exception NotAllowedToInterpolate[source]¶: Bases: pyrocko.gf.error.StoreError

exception NoSuchExtra(s)[source]¶: Bases: pyrocko.gf.error.StoreError

exception NoSuchPhase(s)[source]¶: Bases: pyrocko.gf.error.StoreError

class Store(store_dir, mode='r', use_memmap=True)[source]¶

Bases: pyrocko.gf.store.BaseStore

Green’s function disk storage and summation machine.

The Store can be used to efficiently store, retrieve, and sum Green’s function traces. A Store contains many 1D time traces sampled at even multiples of a global sampling rate, where each time trace has an individual start and end time. The traces are treated as having repeating end points, so the functions they represent can be non-constant only between begin and end time. It provides capabilities to retrieve decimated traces and to extract parts of the traces. The main purpose of this class is to provide a fast, easy to use, and flexible machanism to compute weighted delay-and-sum stacks with many Green’s function traces involved.

Individual Green’s functions are accessed through a single integer index at low level. On top of that, various indexing schemes can be implemented by providing a mapping from physical coordinates to the low level index i. E.g. for a problem with cylindrical symmetry, one might define a mapping from the coordinates (receiver_depth, source_depth, distance) to the low level index. Index translation is done in the pyrocko.gf.meta.Config subclass object associated with the Store. It is accessible through the store’s config attribute, and contains all meta information about the store, including physical extent, geometry, sampling rate, and information about the type of the stored Green’s functions. Information about the underlying earth model can also be found there.

A GF store can also contain tabulated phase arrivals. In basic cases, these can be created with the make_ttt() and evaluated with the t() methods.

config¶: The pyrocko.gf.meta.Config derived object associated with the store which contains all meta information about the store and provides the high-level to low-level index mapping.

store_dir¶: Path to the store’s data directory.

mode¶: The mode in which the store is opened: 'r': read-only, 'w': writeable.

classmethod create(store_dir, config, force=False, extra=None)[source]¶

Create new GF store.

Creates a new GF store at path store_dir. The layout of the GF is defined with the parameters given in config, which should be an object of a subclass of Config. This function will refuse to overwrite an existing GF store, unless force is set to True. If more information, e.g. parameters used for the modelling code, earth models or other, should be saved along with the GF store, these may be provided though a dict given to extra. The keys of this dict must be names and the values must be guts type objects.

Parameters:	store_dir (str) – GF store path config (`Config`) – GF store Config force (bool) – Force overwrite, defaults to `False` extra (dict or None) – Extra information

get_extra(key)[source]¶: Get extra information stored under given key.

upgrade()[source]¶: Upgrade store config and files to latest Pyrocko version.

put(args, trace)[source]¶

Insert trace into GF store.

Store a single GF trace at (high-level) index args.

Parameters:	args (tuple) – `Config` index tuple, e.g. `(source_depth, distance, component)` as in `ConfigTypeA`.
Returns:	GF trace at `args`
Return type:	`GFTrace`

get(args, itmin=None, nsamples=None, decimate=1, interpolation='nearest_neighbor', implementation='c')[source]¶

Retrieve GF trace from store.

Retrieve a single GF trace from the store at (high-level) index args. By default, the full trace is retrieved. Given itmin and nsamples, only the selected portion of the trace is extracted. If decimate is an integer in the range [2,8], the trace is decimated on the fly or, if available, the trace is read from a decimated version of the GF store.

Parameters:	args (tuple) – `Config` index tuple, e.g. `(source_depth, distance, component)` as in `ConfigTypeA`. itmin (int or None) – Start time index (start time is `itmin * dt`), defaults to None nsamples (int or None) – Number of samples, defaults to None decimate (int) – Decimatation factor, defaults to 1 interpolation (str) – Interpolation method `['nearest_neighbor', 'multilinear', 'off']`, defaults to `'nearest_neighbor'` implementation (str) – Implementation to use `['c', 'reference']`, defaults to `'c'`.
Returns:	GF trace at `args`
Return type:	`GFTrace`

sum(args, delays, weights, itmin=None, nsamples=None, decimate=1, interpolation='nearest_neighbor', implementation='c', optimization='enable')[source]¶

Sum delayed and weighted GF traces.

Calculate sum of delayed and weighted GF traces. args is a tuple of arrays forming the (high-level) indices of the GF traces to be selected. Delays and weights for the summation are given in the arrays delays and weights. itmin and nsamples can be given to restrict to computation to a given time interval. If decimate is an integer in the range [2,8], decimated traces are used in the summation.

Parameters:	args (tuple(numpy.ndarray)) – `Config` index tuple, e.g. `(source_depth, distance, component)` as in `ConfigTypeA`. delays (`numpy.ndarray`) – Delay times weights (`numpy.ndarray`) – Trace weights itmin (int or None) – Start time index (start time is `itmin * dt`), defaults to None nsamples (int or None) – Number of samples, defaults to None decimate (int) – Decimatation factor, defaults to 1 interpolation (str) – Interpolation method `['nearest_neighbor', 'multilinear', 'off']`, defaults to `'nearest_neighbor'` implementation (str) – Implementation to use, `['c', 'alternative', 'reference']`, where `'alternative'` and `'reference'` use a Python implementation, defaults to ‘c’ optimization (str) – Optimization mode `['enable', 'disable']`, defaults to `'enable'`
Returns:	Stacked GF trace.
Return type:	`GFTrace`

make_decimated(decimate, config=None, force=False, show_progress=False)[source]¶

Create decimated version of GF store.

Create a downsampled version of the GF store. Downsampling is done for the integer factor decimate which should be in the range [2,8]. If config is None, all traces of the GF store are decimated and held available (i.e. the index mapping of the original store is used), otherwise, a different spacial stepping can be specified by giving a modified GF store configuration in config (see create()). Decimated GF sub-stores are created under the decimated subdirectory within the GF store directory. Holding available decimated versions of the GF store can save computation time, IO bandwidth, or decrease memory footprint at the cost of increased disk space usage, when computation are done for lower frequency signals.

Parameters:	decimate (int) – Decimate factor config (`Config` or None) – GF store config object, defaults to None force (bool) – Force overwrite, defaults to `False` show_progress (bool) – Show progress, defaults to `False`

get_stored_phase(phase_id)[source]¶

Get stored phase from GF store

Returns:	Phase information
Return type:	`pyrocko.spit.SPTree`

t(timing, *args)[source]¶

Compute interpolated phase arrivals.

Examples:

If test_store is of ConfigTypeA:

test_store.t('p', (1000, 10000))
test_store.t('last{P|Pdiff}', (1000, 10000)) # The latter arrival
                                             # of P or diffracted
                                             # P phase

If test_store is of ConfigTypeB:

test_store.t('S', (1000, 1000, 10000))
test_store.t('first{P|p|Pdiff|sP}', (1000, 1000, 10000)) # The
            `                                # first arrival of
                                             # the given phases is
                                             # selected

Parameters:	timing (str or `Timing`) – Timing string as described above args (tuple*) – `Config` index tuple, e.g. `(source_depth, distance, component)` as in `ConfigTypeA`.
Returns:	Phase arrival according to `timing`
Return type:	float or None

make_timing_params(begin, end, snap_vred=True, force=False)[source]¶

Compute tight parameterized time ranges to include given timings.

Calculates appropriate time ranges to cover given begin and end timings over all GF points in the store. A dict with the following keys is returned:

'tmin': time [s], minimum of begin timing over all GF points
'tmax': time [s], maximum of end timing over all GF points
'vred', 'tmin_vred': slope [m/s] and offset [s] of reduction velocity [m/s] appropriate to catch begin timing over all GF points
'tlenmax_vred': maximum time length needed to cover all end timings, when using linear slope given with (vred, tmin_vred) as start

make_ttt(force=False)[source]¶

Compute travel time tables.

Travel time tables are computed using the 1D earth model defined in earthmodel_1d for each defined phase in tabulated_phases. The accuracy of the tablulated times is adjusted to the sampling rate of the store.

`gf.builder`¶

`gf.seismosizer`¶

exception SeismosizerError[source]¶: Bases: Exception

exception BadRequest[source]¶: Bases: pyrocko.gf.seismosizer.SeismosizerError

exception NoSuchStore(store_id=None, dirs=None)[source]¶: Bases: pyrocko.gf.seismosizer.BadRequest

class Range(*args, **kwargs)[source]¶

Bases: pyrocko.guts.SObject

Convenient range specification.

Equivalent ways to sepecify the range [ 0., 1000., … 10000. ]:

Range('0 .. 10k : 1k')
Range(start=0., stop=10e3, step=1e3)
Range(0, 10e3, 1e3)
Range('0 .. 10k @ 11')
Range(start=0., stop=10*km, n=11)

Range(0, 10e3, n=11)
Range(values=[x*1e3 for x in range(11)])

Depending on the use context, it can be possible to omit any part of the specification. E.g. in the context of extracting a subset of an already existing range, the existing range’s specification values would be filled in where missing.

The values are distributed with equal spacing, unless the spacing argument is modified. The values can be created offset or relative to an external base value with the relative argument if the use context supports this.

The range specification can be expressed with a short string representation:

'start .. stop @ num | spacing, relative'
'start .. stop : step | spacing, relative'

most parts of the expression can be omitted if not needed. Whitespace is allowed for readability but can also be omitted.

♦ start¶: float, optional

♦ stop¶: float, optional

♦ step¶: float, optional

♦ n¶: int, optional

♦ values¶: numpy.ndarray (pyrocko.guts_array.Array), optional

♦ spacing¶: builtins.str (pyrocko.guts.StringChoice), optional, default: 'lin'

♦ relative¶: builtins.str (pyrocko.guts.StringChoice), optional, default: ''

class STF(effective_duration=None, **kwargs)[source]¶

Bases: pyrocko.guts.Object, pyrocko.gf.seismosizer.Cloneable

Base class for source time functions.

class BoxcarSTF(effective_duration=None, **kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.STF

Boxcar type source time function.

♦ duration¶

float, default: 0.0

duration of the boxcar

♦ anchor¶

float, default: 0.0

anchor point with respect to source.time: (-1.0: left -> source duration [0, T] ~ hypocenter time, 0.0: center -> source duration [-T/2, T/2] ~ centroid time, +1.0: right -> source duration [-T, 0] ~ rupture end time)

class TriangularSTF(effective_duration=None, **kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.STF

Triangular type source time function.

♦ duration¶

float, default: 0.0

baseline of the triangle

♦ peak_ratio¶

float, default: 0.5

fraction of time compared to duration, when the maximum amplitude is reached

♦ anchor¶

float, default: 0.0

class HalfSinusoidSTF(effective_duration=None, **kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.STF

Half sinusoid type source time function.

♦ duration¶

float, default: 0.0

duration of the half-sinusoid (baseline)

♦ anchor¶

float, default: 0.0

♦ exponent¶

int, default: 1

set to 2 to use square of the half-period sinusoidal function.

class ResonatorSTF(effective_duration=None, **kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.STF

Simple resonator like source time function.

$f(t) = 0 for t < 0 f(t) = e^{-t/tau} * sin(2 * pi * f * t)$

♦ duration¶

float, default: 0.0

decay time

♦ frequency¶

float, default: 1.0

resonance frequency

class STFMode(dummy) → str[source]¶

Bases: pyrocko.guts.StringChoice

Any str out of ['pre', 'post'].

class Source(**kwargs)[source]¶

Bases: pyrocko.model.location.Location, pyrocko.gf.seismosizer.Cloneable

Base class for all source models.

♦ name¶: str, optional, default: ''

♦ time¶

builtins.float (pyrocko.guts.Timestamp), default: 0.0

source origin time.

♦ stf¶

STF, optional

source time function.

♦ stf_mode¶

builtins.str (STFMode), default: 'post'

whether to apply source time function in pre or post-processing.

update(**kwargs)[source]¶

Change some of the source models parameters.

Example:

>>> from pyrocko import gf
>>> s = gf.DCSource()
>>> s.update(strike=66., dip=33.)
>>> print(s)
--- !pf.DCSource
depth: 0.0
time: 1970-01-01 00:00:00
magnitude: 6.0
strike: 66.0
dip: 33.0
rake: 0.0

grid(**variables)[source]¶

Create grid of source model variations.

Returns:	`SourceGrid` instance.

Example:

>>> from pyrocko import gf
>>> base = DCSource()
>>> R = gf.Range
>>> for s in base.grid(R('

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

When two source models differ only in amplitude and origin time, the discretization and the GF stacking can be done only once for a unit amplitude and a zero origin time and the amplitude and origin times of the seismograms can be applied during post-processing of the synthetic seismogram.

For any derived parameterized source model, this method is called to decide if discretization and stacking of the source should be shared. When two source models return an equal vector of values discretization is shared.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

Discretization of the base seismogram is usually done for a unit amplitude, because a common factor can be efficiently multiplied to final seismograms. This eliminates to do repeat the stacking when creating seismograms for a series of source models only differing in amplitude.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

effective_stf_pre()[source]¶

Return the STF applied before stacking of the Green’s functions.

This STF is used during discretization of the parameterized source models, i.e. to produce a temporal distribution of point sources.

Handling of the STF before stacking of the GFs is less efficient but allows to use different source time functions for different parts of the source.

effective_stf_post()[source]¶

Return the STF applied after stacking of the Green’s fuctions.

This STF is used in the post-processing of the synthetic seismograms.

Handling of the STF after stacking of the GFs is usually more efficient but is only possible when a common STF is used for all subsources.

class SourceWithMagnitude(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.Source

Base class for sources containing a moment magnitude.

♦ magnitude¶

float, default: 6.0

Moment magnitude Mw as in [Hanks and Kanamori, 1979]

exception DerivedMagnitudeError[source]¶: Bases: pyrocko.guts.ValidationError

class SourceWithDerivedMagnitude(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.Source

Undocumented.

check_conflicts()[source]¶

Check for parameter conflicts.

To be overloaded in subclasses. Raises DerivedMagnitudeError on conflicts.

class ExplosionSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.SourceWithDerivedMagnitude

An isotropic explosion point source.

♦ magnitude¶

float, optional

moment magnitude Mw as in [Hanks and Kanamori, 1979]

♦ volume_change¶

float, optional

volume change of the explosion/implosion or the contracting/extending magmatic source. [m^3]

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedExplosionSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

check_conflicts()[source]¶

Check for parameter conflicts.

To be overloaded in subclasses. Raises DerivedMagnitudeError on conflicts.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

class RectangularExplosionSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.ExplosionSource

Rectangular or line explosion source.

♦ strike¶

float, default: 0.0

strike direction in [deg], measured clockwise from north

♦ dip¶

float, default: 90.0

dip angle in [deg], measured downward from horizontal

♦ length¶

float, default: 0.0

length of rectangular source area [m]

♦ width¶

float, default: 0.0

width of rectangular source area [m]

♦ anchor¶

builtins.str (pyrocko.guts.StringChoice), optional, default: 'center'

Anchor point for positioning the plane, can be: top, center orbottom and also top_left, top_right,bottom_left,bottom_right, center_left and center right

♦ nucleation_x¶

float, optional

horizontal position of rupture nucleation in normalized fault plane coordinates (-1 = left edge, +1 = right edge)

♦ nucleation_y¶

float, optional

down-dip position of rupture nucleation in normalized fault plane coordinates (-1 = upper edge, +1 = lower edge)

♦ velocity¶

float, default: 3500.0

speed of explosion front [m/s]

♦ aggressive_oversampling¶

bool, default: False

Aggressive oversampling for basesource discretization. When using ‘multilinear’ interpolation oversampling has practically no effect.

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedExplosionSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

class DCSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.SourceWithMagnitude

A double-couple point source.

♦ strike¶

float, default: 0.0

strike direction in [deg], measured clockwise from north

♦ dip¶

float, default: 90.0

dip angle in [deg], measured downward from horizontal

♦ rake¶

float, default: 0.0

rake angle in [deg], measured counter-clockwise from right-horizontal in on-plane view

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedMTSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

class CLVDSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.SourceWithMagnitude

A pure CLVD point source.

♦ azimuth¶

float, default: 0.0

azimuth direction of largest dipole, clockwise from north [deg]

♦ dip¶

float, default: 90.0

dip direction of largest dipole, downward from horizontal [deg]

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedMTSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

class VLVDSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.SourceWithDerivedMagnitude

Volumetric linear vector dipole source.

This source is a parameterization for a restricted moment tensor point source, useful to represent dyke or sill like inflation or deflation sources. The restriction is such that the moment tensor is rotational symmetric. It can be represented by a superposition of a linear vector dipole (here we use a CLVD for convenience) and an isotropic component. The restricted moment tensor has 4 degrees of freedom: 2 independent eigenvalues and 2 rotation angles orienting the the symmetry axis.

In this parameterization, the isotropic component is controlled by volume_change. To define the moment tensor, it must be converted to the scalar moment of the the MT’s isotropic component. For the conversion, the shear modulus at the source’s position must be known. This value is extracted from the earth model defined in the GF store in use.

The CLVD part by controlled by its scalar moment $M_0$ : clvd_moment. The sign of clvd_moment is used to switch between a positiv or negativ CLVD (the sign of the largest eigenvalue).

♦ azimuth¶

float, default: 0.0

azimuth direction of symmetry axis, clockwise from north [deg].

♦ dip¶

float, default: 90.0

dip direction of symmetry axis, downward from horizontal [deg].

♦ volume_change¶

float, default: 0.0

volume change of the inflation/deflation [m^3].

♦ clvd_moment¶

float, default: 0.0

scalar moment $M_0$ of the CLVD component [Nm]. The sign controls the sign of the CLVD (the sign of its largest eigenvalue).

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedMTSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

class MTSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.Source

A moment tensor point source.

♦ mnn¶

float, default: 1.0

north-north component of moment tensor in [Nm]

♦ mee¶

float, default: 1.0

east-east component of moment tensor in [Nm]

♦ mdd¶

float, default: 1.0

down-down component of moment tensor in [Nm]

♦ mne¶

float, default: 0.0

north-east component of moment tensor in [Nm]

♦ mnd¶

float, default: 0.0

north-down component of moment tensor in [Nm]

♦ med¶

float, default: 0.0

east-down component of moment tensor in [Nm]

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedMTSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

class RectangularSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.SourceWithDerivedMagnitude

Classical Haskell source model modified for bilateral rupture.

♦ magnitude¶

float, optional

moment magnitude Mw as in [Hanks and Kanamori, 1979]

♦ strike¶

float, default: 0.0

strike direction in [deg], measured clockwise from north

♦ dip¶

float, default: 90.0

dip angle in [deg], measured downward from horizontal

♦ rake¶

float, default: 0.0

rake angle in [deg], measured counter-clockwise from right-horizontal in on-plane view

♦ length¶

float, default: 0.0

length of rectangular source area [m]

♦ width¶

float, default: 0.0

width of rectangular source area [m]

♦ anchor¶

builtins.str (pyrocko.guts.StringChoice), optional, default: 'center'

Anchor point for positioning the plane, can be: top, center bottom, top_left, top_right,bottom_left,bottom_right, center_left, center right.

♦ nucleation_x¶

float, optional

horizontal position of rupture nucleation in normalized fault plane coordinates (-1. = left edge, +1. = right edge)

♦ nucleation_y¶

float, optional

down-dip position of rupture nucleation in normalized fault plane coordinates (-1. = upper edge, +1. = lower edge)

♦ velocity¶

float, default: 3500.0

speed of rupture front [m/s]

♦ slip¶

float, optional

Slip on the rectangular source area [m]

♦ decimation_factor¶

int, optional, default: 1

Sub-source decimation factor, a larger decimation will make the result inaccurate but shorten the necessary computation time (use for testing puposes only).

♦ aggressive_oversampling¶

bool, default: False

Aggressive oversampling for basesource discretization. When using ‘multilinear’ interpolation oversampling has practically no effect.

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedMTSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

check_conflicts()[source]¶

Check for parameter conflicts.

To be overloaded in subclasses. Raises DerivedMagnitudeError on conflicts.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

class PseudoDynamicRupture(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.SourceWithDerivedMagnitude

Merged Eikonal and Okada Source for quasi-dynamic rupture modeling.

Details are described in Pseudo Dynamic Rupture - A stress-based self-similar finite source model.

♦ strike¶

float, default: 0.0

strike direction in [deg], measured clockwise from north

♦ dip¶

float, default: 0.0

dip angle in [deg], measured downward from horizontal

♦ length¶

float, default: 10000.0

length of rectangular source area [m]

♦ width¶

float, default: 5000.0

width of rectangular source area [m]

♦ anchor¶

builtins.str (pyrocko.guts.StringChoice), optional, default: 'center'

Anchor point for positioning the plane, can be: top, center, bottom, top_left, top_right,bottom_left, bottom_right, center_left, center right

♦ nucleation_x¶

numpy.ndarray (pyrocko.guts_array.Array), default: array([0.])

horizontal position of rupture nucleation in normalized fault plane coordinates (-1. = left edge, +1. = right edge)

♦ nucleation_y¶

numpy.ndarray (pyrocko.guts_array.Array), default: array([0.])

down-dip position of rupture nucleation in normalized fault plane coordinates (-1. = upper edge, +1. = lower edge)

♦ nucleation_time¶

numpy.ndarray (pyrocko.guts_array.Array), optional

Time in [s] after origin, when nucleation points defined by nucleation_x and nucleation_y rupture.

♦ gamma¶

float, default: 0.8

scaling factor between S wave velocity and rupture velocity: $v_r = \gamma * v_s$

♦ nx¶

int, default: 2

number of discrete source patches in x direction (along strike)

♦ ny¶

int, default: 2

number of discrete source patches in y direction (down dip)

♦ magnitude¶

float, optional

moment magnitude Mw as in [Hanks and Kanamori, 1979]. Setting the moment magnitude the tractions/stress field will be normalized to accomodate the desired moment magnitude. Mutually exclusive with the slip parameter.

♦ slip¶

float, optional

maximum slip of the rectangular source [m]. Setting the moment magnitude the tractions/stress field will be normalized to accomodate the desired maximum slip. Mutually exclusive with the magnitude parameter.

♦ rake¶

float, optional

rake angle in [deg], measured counter-clockwise from right-horizontal in on-plane view. Rake is translated into homogenous tractions in strike and up-dip direction. rake is mutually exclusive with tractions parameter.

♦ patches¶

list of pyrocko.modelling.okada.OkadaSource objects, optional

List of all boundary elements/sub faults/fault patches

♦ tractions¶

pyrocko.gf.tractions.TractionField, optional

Traction field the rupture plane is exposed to. See the:py:mod:pyrocko.gf.tractions module for more details. If tractions=None and rake is given DirectedTractions will be used.

♦ coef_mat¶

numpy.ndarray (pyrocko.guts_array.Array), optional

Coefficient matrix linking traction and dislocation field

♦ eikonal_decimation¶

int, optional, default: 1

Sub-source eikonal factor, a smaller eikonal factor will increase the accuracy of rupture front calculation but increases also the computation time.

♦ decimation_factor¶

int, optional, default: 1

Sub-source decimation factor, a larger decimation will make the result inaccurate but shorten the necessary computation time (use for testing puposes only).

♦ nthreads¶

int, optional, default: 1

Number of threads for Okada forward modelling, matrix inversion and calculation of point subsources. Note: for small/medium matrices 1 thread is most efficient!

♦ pure_shear¶

bool, optional, default: False

Calculate only shear tractions and omit tensile tractions.

♦ smooth_rupture¶

bool, default: True

Smooth the tractions by weighting partially ruptured fault patches.

♦ aggressive_oversampling¶

bool, default: False

Aggressive oversampling for basesource discretization. When using ‘multilinear’ interpolation oversampling has practically no effect.

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedMTSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

check_conflicts()[source]¶

Check for parameter conflicts.

To be overloaded in subclasses. Raises DerivedMagnitudeError on conflicts.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

discretize_time(store, interpolation='nearest_neighbor', vr=None, times=None, *args, **kwargs)[source]¶

Get rupture start time for discrete points on source plane

Parameters:	store (`pyrocko.gf.store.Store`) – Greens function database (needs to cover whole region of of the source) target (optional, `pyrocko.gf.targets.Target`) – Target information vr (optional, `numpy.ndarray`) – Array, containing rupture user defined rupture velocity values times (optional, `numpy.ndarray`) – Array, containing zeros, where rupture is starting and otherwise -1, where time will be calculated. If not given, rupture starts at nucleation_x, nucleation_y. Times are given for discrete points with equal horizontal and vertical spacing
Returns:	Coordinates (latlondepth), Coordinates (xy), rupture velocity rupture propagation time of discrete points
Return type:	`numpy.ndarray`, `(points.shape[0], 1)`, `numpy.ndarray`, `(points.shape[0], 1)`, `numpy.ndarray`, `(n_points_dip, n_points_strike)`, `numpy.ndarray`, `(n_points_dip, n_points_strike)`

discretize_patches(store=None, interpolation='nearest_neighbor', grid_shape=(), *args, **kwargs)[source]¶

Get rupture start time and OkadaSource elements for discrete centre points on source plane and stores them in the patches-attribute

Arguments and keyword arguments needed for self.discretize_time.

Parameters:	store (`pyrocko.gf.store.Store`) – Greens function database (needs to cover whole region of of the source) interpolation (optional, str) – Kind of interpolation used. Choice between ‘multilinear’ and ‘nearest_neighbor’ grid_shape (optional, tuple of int) – Desired sub fault patch grid size (nlength, nwidth). Either factor or grid_shape should be set.

discretize_basesource(store, target=None)[source]¶

Prepare source for synthetic waveform calculation

Parameters:	store (`pyrocko.gf.store.Store`) – Greens function database (needs to cover whole region of of the source)
Returns:	Source discretized by a set of moment tensors and times
Return type:	`pyrocko.gf.meta.DiscretizedMTSource`

calc_coef_mat()[source]¶: Calculate linear coefficient relating tractions and dislocations on the fault patches

get_patch_attribute(attr)[source]¶

Get array of patch attributes

Parameters:	attr (str) – Attribute of fault patches which shall be listed for all patches in an array (possible attributes: check :py:class`pyrocko.modelling.okada.OkadaSource`)
Returns:	Array of attribute values per fault patch
Return type:	:py:class`numpy.ndarray`

get_okada_slip(time=None, scale_slip=True, interpolation='nearest_neighbor', **kwargs)[source]¶

Get slip per subfault patch for given time after rupture start

Parameters:	time (float > 0.) – time after origin [s], for which slip is computed
Returns:	inverted displacements (u_strike, u_dip , u_tensile) for each source patch. order: [ patch1 u_Strike, patch1 u_Dip, patch1 u_Tensile, patch2 u_Strike, …]
Return type:	`numpy.ndarray`, `(n_sources * 3, 1)`

get_delta_slip(store=None, deltat=None, delta=True, interpolation='nearest_neighbor', **kwargs)[source]¶

Get slip change inverted from OkadaSources depending on store deltat

The time intervall, within which the slip changes are computed is determined by the sampling rate of the Greens function database. Arguments and keyword arguments needed for self.get_okada_slip.

Parameters:	store (optional, `pyrocko.gf.store.Store`) – Greens function database (needs to cover whole region of of the source). Its delta t [s] is used as time increment for slip difference calculation. Either dt or store should be given. deltat (optional, float) – time increment for slip difference calculation [s]. Either deltat or store should be given.
Returns:	displacement changes(du_strike, du_dip , du_tensile) for each source patch and time. order: [ patch1 du_Strike t1, patch1 du_Dip t1, patch1 du_Tensile t1, patch2 du_Strike t1, …], [ patch1 du_Strike t2, patch1 du_Dip t2, patch1 du_Tensile t2, patch2 du_Strike t2, …]; corner times, for which delta slip is computed
Return type:	`numpy.ndarray`, `(n_sources, n_times, 3)` `numpy.ndarray`, `(n_times, 1)`

get_moment_rate_patches(*args, **kwargs)[source]¶

Get scalar seismic moment rate for each boundary element individually

Arguments and keyword arguments needed for self.get_okada_slip.

Returns:	seismic moment rate for each source patch and time. order: [ patch1 moment_rate t1, patch2 moment_rate t1, …], [ patch1 moment_rate t2, patch2 moment_rate t2, …]; corner times, for which moment rate is computed based on slip rate
Return type:	`numpy.ndarray`, `(n_sources, n_times)` `numpy.ndarray`, `(n_times, 1)`

get_moment_rate(store, deltat=None)[source]¶

Get seismic source moment rate for the total source (STF)

Parameters:	store (optional, `pyrocko.gf.store.Store`) – Greens function database (needs to cover whole region of of the source). Its delta t [s] is used as time increment for slip difference calculation. Either dt or store should be given. deltat (optional, float) – time increment for slip difference calculation [s]. Either deltat or store should be given.
Returns:	seismic moment rate for each time. order: [ moment_rate t1, moment_rate t2, …]; corner times, for which moment rate is computed based on slip rate
Return type:	`numpy.ndarray`, `(n_times, 1)` `numpy.ndarray`, `(n_times, 1)`

class DoubleDCSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.SourceWithMagnitude

Two double-couple point sources separated in space and time. Moment share between the sub-sources is controlled by the parameter mix. The position of the subsources is dependent on the moment distribution between the two sources. Depth, east and north shift are given for the centroid between the two double-couples. The subsources will positioned according to their moment shares around this centroid position. This is done according to their delta parameters, which are therefore in relation to that centroid. Note that depth of the subsources therefore can be depth+/-delta_depth. For shallow earthquakes therefore the depth has to be chosen deeper to avoid sampling above surface.

♦ strike1¶

float, default: 0.0

strike direction in [deg], measured clockwise from north

♦ dip1¶

float, default: 90.0

dip angle in [deg], measured downward from horizontal

♦ azimuth¶

float, default: 0.0

azimuth to second double-couple [deg], measured at first, clockwise from north

♦ rake1¶

float, default: 0.0

rake angle in [deg], measured counter-clockwise from right-horizontal in on-plane view

♦ strike2¶

float, default: 0.0

strike direction in [deg], measured clockwise from north

♦ dip2¶

float, default: 90.0

dip angle in [deg], measured downward from horizontal

♦ rake2¶

float, default: 0.0

rake angle in [deg], measured counter-clockwise from right-horizontal in on-plane view

♦ delta_time¶

float, default: 0.0

separation of double-couples in time (t2-t1) [s]

♦ delta_depth¶

float, default: 0.0

difference in depth (z2-z1) [m]

♦ distance¶

float, default: 0.0

distance between the two double-couples [m]

♦ mix¶

float, default: 0.5

how to distribute the moment to the two doublecouples mix=0 -> m1=1 and m2=0; mix=1 -> m1=0, m2=1

♦ stf1¶

STF, optional

Source time function of subsource 1 (if given, overrides STF from attribute Source.stf)

♦ stf2¶

STF, optional

Source time function of subsource 2 (if given, overrides STF from attribute Source.stf)

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedMTSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

effective_stf_post()[source]¶

Return the STF applied after stacking of the Green’s fuctions.

This STF is used in the post-processing of the synthetic seismograms.

Handling of the STF after stacking of the GFs is usually more efficient but is only possible when a common STF is used for all subsources.

class RingfaultSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.SourceWithMagnitude

A ring fault with vertical doublecouples.

♦ diameter¶

float, default: 1.0

diameter of the ring in [m]

♦ sign¶

float, default: 1.0

inside of the ring moves up (+1) or down (-1)

♦ strike¶

float, default: 0.0

strike direction of the ring plane, clockwise from north, in [deg]

♦ dip¶

float, default: 0.0

dip angle of the ring plane from horizontal in [deg]

♦ npointsources¶

int, default: 360

number of point sources to use

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedMTSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

class CombiSource(subsources=[], **kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.Source

Composite source model.

♦ subsources¶: list of Source objects, default: []

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedMTSource

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

class SFSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.Source

A single force point source.

♦ fn¶

float, default: 0.0

northward component of single force [N]

♦ fe¶

float, default: 0.0

eastward component of single force [N]

♦ fd¶

float, default: 0.0

downward component of single force [N]

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedSFSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

class PorePressurePointSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.Source

Excess pore pressure point source.

For poro-elastic initial value problem where an excess pore pressure is brought into a small source volume.

♦ pp¶

float, default: 1.0

initial excess pore pressure in [Pa]

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedPorePressureSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

class PorePressureLineSource(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.Source

Excess pore pressure line source.

The line source is centered at (north_shift, east_shift, depth).

♦ pp¶

float, default: 1.0

initial excess pore pressure in [Pa]

♦ length¶

float, default: 0.0

length of the line source [m]

♦ azimuth¶

float, default: 0.0

azimuth direction, clockwise from north [deg]

♦ dip¶

float, default: 90.0

dip direction, downward from horizontal [deg]

discretized_source_class¶: alias of pyrocko.gf.meta.DiscretizedPorePressureSource

base_key()[source]¶

Get key to decide about source discretization / GF stack sharing.

get_factor()[source]¶

Get the scaling factor to be applied during post-processing.

This method should return the scaling factor to apply in the post-processing (often this is simply the scalar moment of the source).

class Request(*args, **kwargs)[source]¶

Bases: pyrocko.guts.Object

Synthetic seismogram computation request.

Request(**kwargs)
Request(sources, targets, **kwargs)

♦ sources¶

list of Source objects, default: []

list of sources for which to produce synthetics.

♦ targets¶

list of pyrocko.gf.targets.Target objects, default: []

list of targets for which to produce synthetics.

class ProcessingStats(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

♦ t_perc_get_store_and_receiver¶: float, default: 0.0

♦ t_perc_discretize_source¶: float, default: 0.0

♦ t_perc_make_base_seismogram¶: float, default: 0.0

♦ t_perc_make_same_span¶: float, default: 0.0

♦ t_perc_post_process¶: float, default: 0.0

♦ t_perc_optimize¶: float, default: 0.0

♦ t_perc_stack¶: float, default: 0.0

♦ t_perc_static_get_store¶: float, default: 0.0

♦ t_perc_static_discretize_basesource¶: float, default: 0.0

♦ t_perc_static_sum_statics¶: float, default: 0.0

♦ t_perc_static_post_process¶: float, default: 0.0

♦ t_wallclock¶: float, default: 0.0

♦ t_cpu¶: float, default: 0.0

♦ n_read_blocks¶: int, default: 0

♦ n_results¶: int, default: 0

♦ n_subrequests¶: int, default: 0

♦ n_stores¶: int, default: 0

♦ n_records_stacked¶: int, default: 0

class Response(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Resonse object to a synthetic seismogram computation request.

♦ request¶: Request

♦ results_list¶: list of list of pyrocko.gf.meta.SeismosizerResult objects objects, default: []

♦ stats¶: ProcessingStats

pyrocko_traces()[source]¶: Return a list of requested Trace instances.

kite_scenes()[source]¶: Return a list of requested scenes instances.

static_results()[source]¶: Return a list of requested StaticResult instances.

iter_results(get='pyrocko_traces')[source]¶

Generator function to iterate over results of request.

Yields associated Source, Target, Trace instances in each iteration.

snuffle(**kwargs)[source]¶: Open snuffler with requested traces.

class Engine(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Base class for synthetic seismogram calculators.

get_store_ids()[source]¶: Get list of available GF store IDs

class LocalEngine(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.Engine

Offline synthetic seismogram calculator.

Parameters:

Parameters:	use_env – if `True`, fill `store_superdirs` and `store_dirs` with paths set in environment variables GF_STORE_SUPERDIRS and GF_STORE_DIRS. use_config – if `True`, fill `store_superdirs` and `store_dirs` with paths set in the user’s config file. The config file can be found at `~/.pyrocko/config.pf` gf_store_dirs: ['/home/pyrocko/gf_stores/ak135/'] gf_store_superdirs: ['/home/pyrocko/gf_stores/']

use_env – if True, fill store_superdirs and store_dirs with paths set in environment variables GF_STORE_SUPERDIRS and GF_STORE_DIRS.
use_config –
if True, fill store_superdirs and store_dirs with paths set in the user’s config file.

The config file can be found at ~/.pyrocko/config.pf
```
gf_store_dirs: ['/home/pyrocko/gf_stores/ak135/']
gf_store_superdirs: ['/home/pyrocko/gf_stores/']
```

♦ store_superdirs¶

list of str objects, default: []

directories which are searched for Green’s function stores

♦ store_dirs¶

list of str objects, default: []

additional individual Green’s function store directories

♦ default_store_id¶

str, optional

default store ID to be used when a request does not provide one

get_store_dir(store_id)[source]¶: Lookup directory given a GF store ID.

get_store_ids()[source]¶: Get list of available store IDs.

get_store(store_id=None)[source]¶

Get a store from the engine.

Parameters:	store_id – identifier of the store (optional)
Returns:	`Store` object

If no store_id is provided the store associated with the default_store_id is returned. Raises NoDefaultStoreSet if default_store_id is undefined.

close_cashed_stores()[source]¶: Close and remove ids from cashed stores.

process(*args, **kwargs)[source]¶

Process a request.

process(**kwargs)
process(request, **kwargs)
process(sources, targets, **kwargs)

The request can be given a a Request object, or such an object is created using Request(**kwargs) for convenience.

Returns:	`Response` object

class RemoteEngine(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.Engine

Client for remote synthetic seismogram calculator.

♦ site¶: str, optional, default: 'localhost'

♦ url¶: str, optional, default: '%(site)s/gfws/%(service)s/%(majorversion)i/%(method)s'

class SourceGroup(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

class SourceList(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.SourceGroup

Undocumented.

♦ sources¶: list of Source objects, default: []

class SourceGrid(**kwargs)[source]¶

Bases: pyrocko.gf.seismosizer.SourceGroup

Undocumented.

♦ base¶: Source

♦ variables¶: dict of Range objects, default: {}

♦ order¶: list of str objects, default: []

`gf.targets`¶

exception BadTarget[source]¶: Bases: Exception

class Filter(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

class OptimizationMethod(dummy) → str[source]¶

Bases: pyrocko.guts.StringChoice

Any str out of ['enable', 'disable'].

component_orientation(source, target, component)[source]¶

Get component and azimuth for standard components R, T, Z, N, and E.

Parameters:	source – `pyrocko.gf.Location` object target – `pyrocko.gf.Location` object component – string `'R'`, `'T'`, `'Z'`, `'N'` or `'E'`

class Target(**kwargs)[source]¶

Bases: pyrocko.gf.meta.Receiver

A seismogram computation request for a single component, including its post-processing parmeters.

♦ quantity¶

builtins.str (pyrocko.gf.meta.QuantityType), optional

Measurement quantity type. If not given, it is guessed from the channel code. For some common cases, derivatives of the stored quantities are supported by using finite difference approximations (e.g. displacement to velocity or acceleration). 4th order central FD schemes are used.

♦ codes¶

tuple of 4 str objects, default: ('', 'STA', '', 'Z')

network, station, location and channel codes to be set on the response trace.

♦ elevation¶

float, default: 0.0

station surface elevation in [m]

♦ store_id¶

builtins.str (pyrocko.gf.meta.StringID), optional

ID of Green’s function store to use for the computation. If not given, the processor may use a system default.

♦ sample_rate¶

float, optional

sample rate to produce. If not given the GF store’s default sample rate is used. GF store specific restrictions may apply.

♦ interpolation¶

builtins.str (pyrocko.gf.meta.InterpolationMethod), default: 'nearest_neighbor'

Interpolation method between Green’s functions. Supported are nearest_neighbor and multilinear

♦ optimization¶

builtins.str (OptimizationMethod), optional, default: 'enable'

disable/enable optimizations in weight-delay-and-sum operation

♦ tmin¶

builtins.float (pyrocko.guts.Timestamp), optional

time of first sample to request in [s]. If not given, it is determined from the Green’s functions.

♦ tmax¶

builtins.float (pyrocko.guts.Timestamp), optional

time of last sample to request in [s]. If not given, it is determined from the Green’s functions.

♦ azimuth¶

float, optional

azimuth of sensor component in [deg], clockwise from north. If not given, it is guessed from the channel code.

♦ dip¶

float, optional

dip of sensor component in [deg], measured downward from horizontal. If not given, it is guessed from the channel code.

♦ filter¶

Filter, optional

frequency response filter.

class StaticTarget(*args, **kwargs)[source]¶

Bases: pyrocko.gf.meta.MultiLocation

A computation request for a spatial multi-location target of static/geodetic quantities.

♦ quantity¶

builtins.str (pyrocko.gf.meta.QuantityType), optional, default: 'displacement'

Measurement quantity type, for now only displacement issupported.

♦ interpolation¶

builtins.str (pyrocko.gf.meta.InterpolationMethod), default: 'nearest_neighbor'

Interpolation method between Green’s functions. Supported are nearest_neighbor and multilinear

♦ tsnapshot¶

builtins.float (pyrocko.guts.Timestamp), optional

time of the desired snapshot in [s], If not given, the first sample is taken. If the desired sample exceeds the length of the Green’s function store, the last sample is taken.

♦ store_id¶

builtins.str (pyrocko.gf.meta.StringID), optional

ID of Green’s function store to use for the computation. If not given, the processor may use a system default.

ntargets¶: Number of targets held by instance.

get_targets()[source]¶

Discretizes the multilocation target into a list of Target:

Returns:	`Target`
Return type:	list

class SatelliteTarget(*args, **kwargs)[source]¶

Bases: pyrocko.gf.targets.StaticTarget

A computation request for a spatial multi-location target of static/geodetic quantities measured from a satellite instrument. The line of sight angles are provided and projecting post-processing is applied.

♦ theta¶

numpy.ndarray (pyrocko.guts_array.Array)

Horizontal angle towards satellite’s line of sight in radians.

Important

$0$ is east and $\frac{\pi}{2}$ is north.

♦ phi¶

numpy.ndarray (pyrocko.guts_array.Array)

Theta is look vector elevation angle towards satellite from horizon in radians. Matrix of theta towards satellite’s line of sight.

Important

$-\frac{\pi}{2}$ is down and $\frac{\pi}{2}$ is up.

class KiteSceneTarget(scene, **kwargs)[source]¶

Bases: pyrocko.gf.targets.SatelliteTarget

Undocumented.

♦ shape¶

tuple of 2 int objects, default: (None, None)

Shape of the displacement vectors.

class GNSSCampaignTarget(*args, **kwargs)[source]¶

Bases: pyrocko.gf.targets.StaticTarget

Undocumented.

`gf.tractions`¶

class AbstractTractionField(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Abstract traction field

Fields of this type a re multiplied in the TractionComposition

class TractionField(**kwargs)[source]¶

Bases: pyrocko.gf.tractions.AbstractTractionField

Traction field

Fields of this type are added in the TractionComposition

class TractionComposition(**kwargs)[source]¶

Bases: pyrocko.gf.tractions.TractionField

Composition of traction fields

TractionField and AbstractTractionField can be combined to realize a combination of different fields.

♦ components¶

list of AbstractTractionField objects, default: []

Ordered list of tractions

class UniformTractions(**kwargs)[source]¶

Bases: pyrocko.gf.tractions.TractionField

Uniform traction field

The traction field is uniform in strike, dip and normal direction. This realisation is not only simple but also unrealistic.

♦ traction¶

float, default: 1.0

Uniform traction in strike, dip and normal direction [Pa]

class HomogeneousTractions(**kwargs)[source]¶

Bases: pyrocko.gf.tractions.TractionField

Homogeneous traction field

The traction vectors in strike, dip and normal direction are acting homogeneously on the rupture plane.

♦ strike¶

float, default: 1.0

Tractions in strike direction [Pa]

♦ dip¶

float, default: 1.0

Traction in dip direction (up) [Pa]

♦ normal¶

float, default: 1.0

Traction in normal direction [Pa]

class DirectedTractions(**kwargs)[source]¶

Bases: pyrocko.gf.tractions.TractionField

Directed traction field

The traction vectors are following a uniform rake.

♦ rake¶

float, default: 0.0

rake angle in [deg], measured counter-clockwise from right-horizontal in on-plane view. Rake is translated into homogenous tractions in strike and up-dip direction.

♦ traction¶

float, default: 1.0

Traction in rake direction [Pa]

class SelfSimilarTractions(**kwargs)[source]¶

Bases: pyrocko.gf.tractions.TractionField

Traction model following Power & Tullis (1991).

The traction vectors are calculated as a sum of 2D-cosines with a constant amplitude / wavelength ratio. The wavenumber kx and ky are constant for each cosine function. The rank defines the maximum wavenumber used for summation. So, e.g. a rank of 3 will lead to a summation of cosines with kx = ky in (1, 2, 3). Each cosine has an associated phases, which defines both the phase shift and also the shift from the rupture plane centre. Finally the summed cosines are translated into shear tractions based on the rake and normalized with traction_max.

♦ rank¶

int, default: 1

maximum summed cosine wavenumber/spatial frequency.

♦ rake¶

float, default: 0.0

rake angle in [deg], measured counter-clockwise from right-horizontal in on-plane view. Rake is translated into homogenous tractions in strike and up-dip direction.

♦ traction_max¶

float, default: 1.0

maximum traction vector length [Pa]

♦ phases¶

numpy.ndarray (pyrocko.guts_array.Array), optional

phase shift of the cosines in [rad].

class FractalTractions(*args, **kwargs)[source]¶

Bases: pyrocko.gf.tractions.TractionField

Fractal traction field

♦ rseed¶

int, optional

Seed for RandomState.If None, an random seed will be initialized.

♦ rake¶

float, default: 0.0

rake angle in [deg], measured counter-clockwise from right-horizontal in on-plane view. Rake is translated into homogenous tractions in strike and up-dip direction.

♦ traction_max¶

float, default: 1.0

maximum traction vector length [Pa]

class RectangularTaper(**kwargs)[source]¶

Bases: pyrocko.gf.tractions.AbstractTractionField

Undocumented.

♦ width¶

float, default: 0.2

Width of the taper as a fraction of the plane.

♦ type¶

builtins.str (pyrocko.guts.StringChoice), default: 'tukey'

Type of the taper, default “tukey”

class DepthTaper(**kwargs)[source]¶

Bases: pyrocko.gf.tractions.AbstractTractionField

Undocumented.

♦ depth_start¶

float

Depth where the taper begins [km]

♦ depth_stop¶

float

Depth where taper stops, and drops to 0. [km]

♦ type¶

builtins.str (pyrocko.guts.StringChoice), default: 'linear'

Type of the taper, default “linear”

plot_tractions(tractions, nx=15, ny=12, depth=10000.0, component='strike')[source]¶

Plot choosen traction model for quick inspection

Parameters:

Parameters:	tractions (`pyrocko.gf.tractions.TractionField`) – traction field or traction composition to be displayed nx (optional, int) – number of patches along strike ny (optional, int) – number of patches down dip depth (optional, float) – depth of the rupture plane center in [m] component (optional, str) – choice, which component of the traction is displayed. Choose between: - “tx”: along strike tractions - “ty”: up dip tractions - “tz”: normal tractions - “absolut”: length of the traction vector

tractions (pyrocko.gf.tractions.TractionField) – traction field or traction composition to be displayed
nx (optional, int) – number of patches along strike
ny (optional, int) – number of patches down dip
depth (optional, float) – depth of the rupture plane center in [m]
component (optional, str) – choice, which component of the traction is displayed. Choose between: - “tx”: along strike tractions - “ty”: up dip tractions - “tz”: normal tractions - “absolut”: length of the traction vector

`gf.meta`¶

class InterpolationMethod(dummy) → str[source]¶

Bases: pyrocko.guts.StringChoice

Any str out of ['nearest_neighbor', 'multilinear'].

class SeismosizerTrace(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

♦ codes¶

tuple of 4 str objects, default: ('', 'STA', '', 'Z')

network, station, location and channel codes

♦ data¶

numpy.ndarray (pyrocko.guts_array.Array)

numpy array with data samples

♦ deltat¶

float, default: 1.0

sampling interval [s]

♦ tmin¶

builtins.float (pyrocko.guts.Timestamp), default: 0.0

time of first sample as a system timestamp [s]

class SeismosizerResult(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

♦ n_records_stacked¶: int, optional, default: 1

♦ t_stack¶: float, optional, default: 0.0

class Result(**kwargs)[source]¶

Bases: pyrocko.gf.meta.SeismosizerResult

Undocumented.

♦ trace¶: SeismosizerTrace, optional

♦ n_shared_stacking¶: int, optional, default: 1

♦ t_optimize¶: float, optional, default: 0.0

class StaticResult(**kwargs)[source]¶

Bases: pyrocko.gf.meta.SeismosizerResult

Undocumented.

♦ result¶: dict of numpy.ndarray (pyrocko.guts_array.Array) objects, default: {}

class ComponentScheme(dummy) → str[source]¶

Bases: pyrocko.guts.StringChoice

Different Green’s Function component schemes are available:

Name	Description
`elastic10`	Elastodynamic for `ConfigTypeA` and `ConfigTypeB` stores, MT sources only
`elastic8`	Elastodynamic for far-field only `ConfigTypeA` and `ConfigTypeB` stores, MT sources only
`elastic2`	Elastodynamic for `ConfigTypeA` and `ConfigTypeB` stores, purely isotropic sources only
`elastic5`	Elastodynamic for `ConfigTypeA` and `ConfigTypeB` stores, SF sources only
`elastic18`	Elastodynamic for `ConfigTypeC` stores, MT sources only
`poroelastic10`	Poroelastic for `ConfigTypeA` and `ConfigTypeB` stores

class Earthmodel1D(dummy) → LayeredModel[source]¶

Bases: pyrocko.guts.Object

Undocumented.

class StringID(dummy) → str[source]¶

Bases: pyrocko.guts.StringPattern

Any str matching pattern '^[A-Za-z][A-Za-z0-9._]{0,64}$'.

class ScopeType(dummy) → str[source]¶

Bases: pyrocko.guts.StringChoice

Any str out of ['global', 'regional', 'local'].

class NearfieldTermsType(dummy) → str[source]¶

Bases: pyrocko.guts.StringChoice

Any str out of ['complete', 'incomplete', 'missing'].

class QuantityType(dummy) → str[source]¶

Bases: pyrocko.guts.StringChoice

Any str out of ['displacement', 'rotation', 'velocity', 'acceleration', 'pressure', 'tilt', 'pore_pressure', 'darcy_velocity', 'vertical_tilt'].

class Reference(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

♦ id¶: builtins.str (StringID)

♦ type¶: str

♦ title¶: str

♦ journal¶: str, optional

♦ volume¶: str, optional

♦ number¶: str, optional

♦ pages¶: str, optional

♦ year¶: str

♦ issn¶: str, optional

♦ doi¶: str, optional

♦ url¶: str, optional

♦ eprint¶: str, optional

♦ authors¶: list of str objects, default: []

♦ publisher¶: str, optional

♦ keywords¶: str, optional

♦ note¶: str, optional

♦ abstract¶: str, optional

class PhaseSelect(dummy) → str[source]¶

Bases: pyrocko.guts.StringChoice

Any str out of ['', 'first', 'last'].

exception InvalidTimingSpecification[source]¶: Bases: pyrocko.guts.ValidationError

class Timing(s=None, **kwargs)[source]¶

Bases: pyrocko.guts.SObject

Definition of a time instant relative to one or more named phase arrivals

Instances of this class can be used e.g. in cutting and tapering operations. They can hold an absolute time or an offset to a named phase arrival or group of such arrivals.

Timings can be instantiated from a simple string defintion i.e. with Timing(str) where str is something like 'SELECT{PHASE_DEFS}[+-]OFFSET[S|%]' where 'SELECT' is 'first', 'last' or empty, 'PHASE_DEFS' is a '|'-separated list of phase definitions, and 'OFFSET' is the time offset in seconds. If a '%' is appended, it is interpreted as percent. If the an 'S' is appended to 'OFFSET', it is interpreted as a surface slowness in [s/km].

Phase definitions can be specified in either of the following ways:

'stored:PHASE_ID' - retrieves value from stored travel time table
'cake:CAKE_PHASE_DEF' - evaluates first arrival of phase with cake (see pyrocko.cake.PhaseDef)
'vel_surface:VELOCITY' - arrival according to surface distance / velocity [km/s]
'vel:VELOCITY' - arrival according to 3D-distance / velocity [km/s]

Examples:

'100' : absolute time; 100 s
'{stored:P}-100' : 100 s before arrival of P phase according to stored travel time table named 'P' * '{stored:P}-10%' : 10% before arrival of P phase according to stored travel time table named 'P'
'{stored:A|stored:B}' : time instant of phase arrival A, or B if A is undefined for a given geometry
'first{stored:A|stored:B}' : as above, but the earlier arrival of A and B is chosen, if both phases are defined for a given geometry
'last{stored:A|stored:B}' : as above but the later arrival is chosen
'first{stored:A|stored:B|stored:C}-100' : 100 s before first out of arrivals A, B, and C

♦ phase_defs¶: list of str objects, default: []

♦ offset¶: float, default: 0.0

♦ offset_is_slowness¶: bool, default: False

♦ offset_is_percent¶: bool, default: False

♦ select¶

builtins.str (PhaseSelect), default: ''

Can be either '', 'first', or 'last'.

class TPDef(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Maps an arrival phase identifier to an arrival phase definition.

♦ id¶

builtins.str (StringID)

name used to identify the phase

♦ definition¶

str

definition of the phase in either cake syntax as defined in pyrocko.cake.PhaseDef, or, if prepended with an !, as a classic phase name, or, if it is a simple number, as a constant horizontal velocity.

exception OutOfBounds(values=None, reason=None)[source]¶: Bases: Exception

class Receiver(**kwargs)[source]¶

Bases: pyrocko.model.location.Location

Undocumented.

♦ codes¶

tuple of 3 str objects, optional

network, station, and location codes

exception UnavailableScheme[source]¶: Bases: Exception

class DiscretizedExplosionSource(**kwargs)[source]¶

Bases: pyrocko.gf.meta.DiscretizedSource

Undocumented.

♦ m0s¶: numpy.ndarray (pyrocko.guts_array.Array)

classmethod combine(sources, **kwargs)[source]¶

Combine several discretized source models.

Concatenenates all point sources in the given discretized sources. Care must be taken when using this function that the external amplitude factors and reference times of the parameterized (undiscretized) sources match or are accounted for.

class DiscretizedSFSource(**kwargs)[source]¶

Bases: pyrocko.gf.meta.DiscretizedSource

Undocumented.

♦ forces¶: numpy.ndarray (pyrocko.guts_array.Array)

classmethod combine(sources, **kwargs)[source]¶

Combine several discretized source models.

class DiscretizedMTSource(**kwargs)[source]¶

Bases: pyrocko.gf.meta.DiscretizedSource

Undocumented.

♦ m6s¶

numpy.ndarray (pyrocko.guts_array.Array)

rows with (m_nn, m_ee, m_dd, m_ne, m_nd, m_ed)

classmethod combine(sources, **kwargs)[source]¶

Combine several discretized source models.

class DiscretizedPorePressureSource(**kwargs)[source]¶

Bases: pyrocko.gf.meta.DiscretizedSource

Undocumented.

♦ pp¶: numpy.ndarray (pyrocko.guts_array.Array)

classmethod combine(sources, **kwargs)[source]¶

Combine several discretized source models.

class Region(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

♦ name¶: str, optional

class RectangularRegion(**kwargs)[source]¶

Bases: pyrocko.gf.meta.Region

Undocumented.

♦ lat_min¶: float

♦ lat_max¶: float

♦ lon_min¶: float

♦ lon_max¶: float

class CircularRegion(**kwargs)[source]¶

Bases: pyrocko.gf.meta.Region

Undocumented.

♦ lat¶: float

♦ lon¶: float

♦ radius¶: float

class Config(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Green’s function store meta information.

Currently implemented Store configuration types are:

ConfigTypeA - cylindrical or spherical symmetry, 1D earth model, single receiver depth
- Problem is invariant to horizontal translations and rotations around vertical axis.
- All receivers must be at the same depth (e.g. at the surface)
- High level index variables: (source_depth, receiver_distance, component)
ConfigTypeB - cylindrical or spherical symmetry, 1D earth model, variable receiver depth
- Symmetries like in Type A but has additional index for receiver depth
- High level index variables: (source_depth, receiver_distance, receiver_depth, component)
ConfigTypeC - no symmetrical constraints but fixed receiver positions
- Cartesian source volume around a reference point
- High level index variables: (ireceiver, source_depth, source_east_shift, source_north_shift, component)

♦ id¶

builtins.str (StringID)

Name of the store. May consist of upper and lower-case letters, digits, dots and underscores. The name must start with a letter.

♦ derived_from_id¶

builtins.str (StringID), optional

Name of the original store, if this store has been derived from another one (e.g. extracted subset).

♦ version¶

str, optional, default: '1.0'

User-defined version string. Use <major>.<minor> format.

♦ modelling_code_id¶

builtins.str (StringID), optional

Identifier of the backend used to compute the store.

♦ author¶

str, optional

Comma-separated list of author names.

♦ author_email¶

str, optional

Author’s contact email address.

♦ created_time¶

builtins.float (pyrocko.guts.Timestamp), optional

Time of creation of the store.

♦ regions¶

list of Region objects, default: []

Geographical regions for which the store is representative.

♦ scope_type¶

builtins.str (ScopeType), optional

Distance range scope of the store (choices: 'global', 'regional', 'local').

♦ waveform_type¶

builtins.str (WaveType), optional

Wave type stored (choices: 'full waveform', 'bodywave', 'P wave', 'S wave', 'surface wave').

♦ nearfield_terms¶

builtins.str (NearfieldTermsType), optional

Information about the inclusion of near-field terms in the modelling (choices: 'complete', 'incomplete', 'missing').

♦ description¶

str, optional

Free form textual description of the GF store.

♦ references¶

list of Reference objects, default: []

Reference list to cite the modelling code, earth model or related work.

♦ earthmodel_1d¶

pyrocko.cake.LayeredModel (Earthmodel1D), optional

Layered earth model in ND (named discontinuity) format.

♦ earthmodel_receiver_1d¶

pyrocko.cake.LayeredModel (Earthmodel1D), optional

Receiver-side layered earth model in ND format.

♦ can_interpolate_source¶

bool, optional

Hint to indicate if the spatial sampling of the store is dense enough for multi-linear interpolation at the source.

♦ can_interpolate_receiver¶

bool, optional

Hint to indicate if the spatial sampling of the store is dense enough for multi-linear interpolation at the receiver.

♦ frequency_min¶

float, optional

Hint to indicate the lower bound of valid frequencies [Hz].

♦ frequency_max¶

float, optional

Hint to indicate the upper bound of valid frequencies [Hz].

♦ sample_rate¶

float, optional

Sample rate of the GF store [Hz].

♦ factor¶

float, optional, default: 1.0

Gain value, factored out of the stored GF samples. (may not work properly, keep at 1.0).

♦ component_scheme¶

builtins.str (ComponentScheme), default: 'elastic10'

GF component scheme (choices: 'elastic2', 'elastic8', 'elastic10', 'elastic18', 'elastic5', 'poroelastic10').

♦ stored_quantity¶

builtins.str (QuantityType), optional

Physical quantity of stored values (choices: 'displacement', 'rotation', 'velocity', 'acceleration', 'pressure', 'tilt', 'pore_pressure', 'darcy_velocity', 'vertical_tilt'). If not given, a default is used based on the GF component scheme. The default for the "elastic*" family of component schemes is "displacement".

♦ tabulated_phases¶

list of TPDef objects, default: []

Mapping of phase names to phase definitions, for which travel time tables are available in the GF store.

♦ ncomponents¶

int, optional

Number of GF components. Use component_scheme instead.

♦ uuid¶

str, optional

Heuristic hash value which can be used to uniquely identify the GF store for practical purposes.

♦ reference¶

str, optional

Store reference name composed of the store’s id and the first six letters of its uuid.

get_shear_moduli(lat, lon, points, interpolation=None)[source]¶

Get shear moduli at given points from contained velocity model.

Parameters:	lat – surface origin for coordinate system of `points` points – NumPy array of shape `(N, 3)`, where each row is a point `(north, east, depth)`, relative to origin at `(lat, lon)` interpolation – interpolation method. Choose from `('nearest_neighbor', 'multilinear')`
Returns:	NumPy array of length N with extracted shear moduli at each point

The default implementation retrieves and interpolates the shear moduli from the contained 1D velocity profile.

get_vs(lat, lon, points, interpolation=None)[source]¶

Get Vs at given points from contained velocity model.

Parameters:	lat – surface origin for coordinate system of `points` points – NumPy array of shape `(N, 3)`, where each row is a point `(north, east, depth)`, relative to origin at `(lat, lon)` interpolation – interpolation method. Choose from `('nearest_neighbor', 'multilinear')`
Returns:	NumPy array of length N with extracted shear moduli at each point

The default implementation retrieves and interpolates Vs from the contained 1D velocity profile.

get_vp(lat, lon, points, interpolation=None)[source]¶

Get Vp at given points from contained velocity model.

Parameters:	lat – surface origin for coordinate system of `points` points – NumPy array of shape `(N, 3)`, where each row is a point `(north, east, depth)`, relative to origin at `(lat, lon)` interpolation – interpolation method. Choose from `('nearest_neighbor', 'multilinear')`
Returns:	NumPy array of length N with extracted shear moduli at each point

The default implementation retrieves and interpolates Vp from the contained 1D velocity profile.

get_rho(lat, lon, points, interpolation=None)[source]¶

Get rho at given points from contained velocity model.

Parameters:	lat – surface origin for coordinate system of `points` points – NumPy array of shape `(N, 3)`, where each row is a point `(north, east, depth)`, relative to origin at `(lat, lon)` interpolation – interpolation method. Choose from `('nearest_neighbor', 'multilinear')`
Returns:	NumPy array of length N with extracted shear moduli at each point

The default implementation retrieves and interpolates rho from the contained 1D velocity profile.

get_tabulated_phase(phase_id)[source]¶: Get tabulated phase definition.

class ConfigTypeA(**kwargs)[source]¶

Bases: pyrocko.gf.meta.Config

Cylindrical symmetry, 1D earth model, single receiver depth

Problem is invariant to horizontal translations and rotations around vertical axis.
All receivers must be at the same depth (e.g. at the surface) High level index variables: (source_depth, distance, component)
The distance is the surface distance between source and receiver points.

♦ receiver_depth¶

float, default: 0.0

Fixed receiver depth [m].

♦ source_depth_min¶

float

Minimum source depth [m].

♦ source_depth_max¶

float

Maximum source depth [m].

♦ source_depth_delta¶

float

Grid spacing of source depths [m]

♦ distance_min¶

float

Minimum source-receiver surface distance [m].

♦ distance_max¶

float

Maximum source-receiver surface distance [m].

♦ distance_delta¶

float

Grid spacing of source-receiver surface distance [m].

class ConfigTypeB(**kwargs)[source]¶

Bases: pyrocko.gf.meta.Config

Cylindrical symmetry, 1D earth model, variable receiver depth

Symmetries like in ConfigTypeA but has additional index for receiver depth
High level index variables: (source_depth, receiver_distance, receiver_depth, component)

♦ receiver_depth_min¶

float

Minimum receiver depth [m].

♦ receiver_depth_max¶

float

Maximum receiver depth [m].

♦ receiver_depth_delta¶

float

Grid spacing of receiver depths [m]

♦ source_depth_min¶

float

Minimum source depth [m].

♦ source_depth_max¶

float

Maximum source depth [m].

♦ source_depth_delta¶

float

Grid spacing of source depths [m]

♦ distance_min¶

float

Minimum source-receiver surface distance [m].

♦ distance_max¶

float

Maximum source-receiver surface distance [m].

♦ distance_delta¶

float

Grid spacing of source-receiver surface distances [m].

class ConfigTypeC(**kwargs)[source]¶

Bases: pyrocko.gf.meta.Config

No symmetrical constraints but fixed receiver positions.

Cartesian 3D source volume around a reference point
High level index variables: (ireceiver, source_depth, source_east_shift, source_north_shift, component)

♦ receivers¶

list of Receiver objects, default: []

List of fixed receivers.

♦ source_origin¶

pyrocko.model.location.Location

Origin of the source volume grid.

♦ source_depth_min¶

float

Minimum source depth [m].

♦ source_depth_max¶

float

Maximum source depth [m].

♦ source_depth_delta¶

float

Source depth grid spacing [m].

♦ source_east_shift_min¶

float

Minimum easting of source grid [m].

♦ source_east_shift_max¶

float

Maximum easting of source grid [m].

♦ source_east_shift_delta¶

float

Source volume grid spacing in east direction [m].

♦ source_north_shift_min¶

float

Minimum northing of source grid [m].

♦ source_north_shift_max¶

float

Maximum northing of source grid [m].

♦ source_north_shift_delta¶

float

Source volume grid spacing in north direction [m].

class Weighting(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

♦ factor¶: float, default: 1.0

class Taper(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

♦ tmin¶: Timing

♦ tmax¶: Timing

♦ tfade¶: float, default: 0.0

♦ shape¶: builtins.str (pyrocko.guts.StringChoice), optional, default: 'cos'

class SimplePattern(pattern)[source]¶

Bases: pyrocko.guts.SObject

Undocumented.

class WaveformType(dummy) → str[source]¶

Bases: pyrocko.guts.StringChoice

Any str out of ['dis', 'vel', 'acc', 'amp_spec_dis', 'amp_spec_vel', 'amp_spec_acc', 'envelope_dis', 'envelope_vel', 'envelope_acc'].

class WaveformType(dummy) → str[source]

Bases: pyrocko.guts.StringChoice

Any str out of ['dis', 'vel', 'acc', 'amp_spec_dis', 'amp_spec_vel', 'amp_spec_acc', 'envelope_dis', 'envelope_vel', 'envelope_acc'].

class ChannelSelection(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

♦ pattern¶: SimplePattern, optional

♦ min_sample_rate¶: float, optional

♦ max_sample_rate¶: float, optional

class StationSelection(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

♦ includes¶: SimplePattern

♦ excludes¶: SimplePattern

♦ distance_min¶: float, optional

♦ distance_max¶: float, optional

♦ azimuth_min¶: float, optional

♦ azimuth_max¶: float, optional

class WaveformSelection(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Undocumented.

♦ channel_selection¶: ChannelSelection, optional

♦ station_selection¶: StationSelection, optional

♦ taper¶: Taper

♦ waveform_type¶: builtins.str (WaveformType), default: 'dis'

♦ weighting¶: Weighting, optional

♦ sample_rate¶: float, optional

♦ gf_store_id¶: builtins.str (StringID), optional

exception GridSpecError(s)[source]¶: Bases: Exception

class Location(**kwargs)[source]¶

Bases: pyrocko.guts.Object

Geographical location.

The location is given by a reference point at the earth’s surface (lat, lon, elevation) and a cartesian offset from this point (north_shift, east_shift, depth). The offset corrected lat/lon coordinates of the location can be accessed though the effective_latlon, effective_lat, and effective_lon properties.

♦ lat¶

float, optional, default: 0.0

latitude of reference point [deg]

♦ lon¶

float, optional, default: 0.0

longitude of reference point [deg]

♦ north_shift¶

float, optional, default: 0.0

northward cartesian offset from reference point [m]

♦ east_shift¶

float, optional, default: 0.0

eastward cartesian offset from reference point [m]

♦ elevation¶

float, optional, default: 0.0

surface elevation, above sea level [m]

♦ depth¶

float, default: 0.0

depth, below surface [m]

effective_latlon¶: Property holding the offset-corrected lat/lon pair of the location.

effective_lat¶: Property holding the offset-corrected latitude of the location.

effective_lon¶: Property holding the offset-corrected longitude of the location.

same_origin(other)[source]¶: Check whether other location object has the same reference location.

distance_to(other)[source]¶: Compute surface distance [m] to other location object.

distance_3d_to(other)[source]¶

Compute 3D distance [m] to other location object.

All coordinates are transformed to cartesian coordinates if necessary then distance is:

$\Delta = \sqrt{\Delta {\bf x}^2 + \Delta {\bf y}^2 + \Delta {\bf z}^2}$

azibazi_to(other)[source]¶: Compute azimuth and backazimuth to and from other location object.

Navigation

gf¶

gf.store¶

gf.builder¶

gf.seismosizer¶

gf.targets¶

gf.tractions¶

gf.meta¶

Navigation

`gf`¶

`gf.store`¶

`gf.builder`¶

`gf.seismosizer`¶

`gf.targets`¶

`gf.tractions`¶

`gf.meta`¶