esys.downunder.seismic Package — esys.escript 5.6 documentation

# esys.downunder.seismic Package

## Classes

- `HTIWave`
- `Ricker`
- `SimpleSEGYWriter`
- `SonicHTIWave`
- `SonicWave`
- `TTIWave`
- `VTIWave`
- `WaveBase`
- `Wavelet`

class `esys.downunder.seismic.` `HTIWave`(domain, v_p, v_s, wavelet, source_tag, source_vector=[1.0, 0.0, 0.0], eps=0.0, gamma=0.0, delta=0.0, rho=1.0, dt=None, u0=None, v0=None, absorption_zone=None, absorption_cut=0.01, lumping=True, disable_fast_assemblers=False)

  Bases: `esys.downunder.seismic.WaveBase`

  Solving the HTI wave equation (along the x_0 axis)

  Note: | In case of a two dimensional domain a horizontal domain is considered, i.e. the depth component is dropped.

  `__init__`(domain, v_p, v_s, wavelet, source_tag, source_vector=[1.0, 0.0, 0.0], eps=0.0, gamma=0.0, delta=0.0, rho=1.0, dt=None, u0=None, v0=None, absorption_zone=None, absorption_cut=0.01, lumping=True, disable_fast_assemblers=False)

    initialize the VTI wave solver

    Parameters: | domain (`Domain`) – domain of the problem v_p (`escript.Scalar`) – vertical p-velocity field v_s (`escript.Scalar`) – vertical s-velocity field wavelet (`Wavelet`) – wavelet to describe the time evolution of source term source_tag ('str' or 'int') – tag of the source location source_vector – source orientation vector eps – first Thompsen parameter delta – second Thompsen parameter gamma – third Thompsen parameter rho – density dt – time step size. If not present a suitable time step size is calculated. u0 – initial solution. If not present zero is used. v0 – initial solution change rate. If not present zero is used. absorption_zone – thickness of absorption zone absorption_cut – boundary value of absorption decay factor lumping – if True mass matrix lumping is being used. This is accelerates the computing but introduces some diffusion. disable_fast_assemblers – if True, forces use of slower and more general PDE assemblers

  `getTimeStepSize`()
  `setQ`(q)

    sets the PDE q value

    Parameters: | q – the value to set

  `update`(t)

    returns the solution for the next time marker t which needs to greater than the time marker from the previous call.

class `esys.downunder.seismic.` `Ricker`(f_dom=40, t_dom=None)

  Bases: `esys.downunder.seismic.Wavelet`

  The Ricker Wavelet w=f(t)

  `__init__`(f_dom=40, t_dom=None)

    Sets up a Ricker wavelet wih dominant frequence `f_dom` and center at time `t_dom`. If `t_dom` is not given an estimate for suitable `t_dom` is calculated so f(0)~0.

    Note: | maximum frequence is about 2 x the dominant frequence.

  `getAcceleration`(t)

    get the acceleration f’‘(t) at time `t`

  `getCenter`()

    Return value of wavelet center

  `getTimeScale`()

    Returns the time scale which is the inverse of the largest frequence with a significant spectral component.

  `getValue`(t)

    get value of wavelet at time `t`

  `getVelocity`(t)

    get the velocity f’(t) at time `t`

class `esys.downunder.seismic.` `SimpleSEGYWriter`(receiver_group=None, source=0.0, sampling_interval=0.004, text='some seimic data')

  Bases: `object`

  A simple writer for 2D and 3D seismic lines, in particular for synthetic data

  Typical usage:

      from esys.escript import unitsSI as U
      sw=SimpleSEGYWriter([0.,100*U.m,200*U,m,300.], source=200*U.m, sampling_interval=4*U.msec)
      while n < 10:
          sw.addRecord([i*2., i*0.67, i**2, -i*7])
      sw.write('example.segy')

  Note: | the writer uses `obspy`

  `__init__`(receiver_group=None, source=0.0, sampling_interval=0.004, text='some seimic data')

    initalize writer

    Parameters: | receiver_group – list of receiver coordinates (in meters). For the 2D case a list of floats is given, for the 3D case a list of coordinate tuples are given source – coordinates of the source (in meters). For the 2D case a single floats is given, for the 3D case a coordinate tuples sampling_interval – sample rate in seconds text – a text for the header file (e.g a description)

  `COORDINATE_SCALE` = 1000.0
  `addRecord`(record)

    Adds a record to the traces. A time difference of sample_interval between two records is assumed. The record mast be a list of as many values as given receivers or a float if a single receiver is used.

    Parameters: | record – list of tracks to be added to the record.

  `getSamplingInterval`()

    returns the sampling interval in seconds.

  `obspy_available`()

    for checking if the obspy module is available

  `write`(filename)

    writes to segy file

    Parameters: | filename – file name
    Note: | the function uses the `obspy` module.

class `esys.downunder.seismic.` `SonicHTIWave`(domain, v_p, wavelet, source_tag, source_vector=[1.0, 0.0], eps=0.0, delta=0.0, azimuth=0.0, dt=None, p0=None, v0=None, absorption_zone=300.0, absorption_cut=0.01, lumping=True)

  Bases: `esys.downunder.seismic.WaveBase`

  Solving the HTI wave equation (along the x_0 axis) with azimuth (rotation around verticle axis) under the assumption of zero shear wave velocities The unknowns are the transversal (along x_0) and vertial stress (Q, P)

  Note: | In case of a two dimensional domain the second spatial dimenion is depth.

  `__init__`(domain, v_p, wavelet, source_tag, source_vector=[1.0, 0.0], eps=0.0, delta=0.0, azimuth=0.0, dt=None, p0=None, v0=None, absorption_zone=300.0, absorption_cut=0.01, lumping=True)

    initialize the HTI wave solver

    Parameters: | domain (`Doamin`) – domain of the problem v_p (`escript.Scalar`) – vertical p-velocity field v_s (`escript.Scalar`) – vertical s-velocity field wavelet (`Wavelet`) – wavelet to describe the time evolution of source term source_tag ('str' or 'int') – tag of the source location source_vector – source orientation vector eps – first Thompsen parameter azimuth – azimuth (rotation around verticle axis) gamma – third Thompsen parameter rho – density dt – time step size. If not present a suitable time step size is calculated. p0 – initial solution (Q(t=0), P(t=0)). If not present zero is used. v0 – initial solution change rate. If not present zero is used. absorption_zone – thickness of absorption zone absorption_cut – boundary value of absorption decay factor lumping – if True mass matrix lumping is being used. This is accelerates the computing but introduces some diffusion.

  `getTimeStepSize`()
  `update`(t)

    returns the solution for the next time marker t which needs to greater than the time marker from the previous call.

class `esys.downunder.seismic.` `SonicWave`(domain, v_p, wavelet, source_tag, dt=None, p0=None, p0_t=None, absorption_zone=300.0, absorption_cut=0.01, lumping=True)

  Bases: `esys.downunder.seismic.WaveBase`

  Solving the sonic wave equation

  `p_tt = (v_p**2 * p_i)_i + f(t) * delta_s` where (p-) velocity v_p.

  f(t) is wavelet acting at a point source term at positon s

  `__init__`(domain, v_p, wavelet, source_tag, dt=None, p0=None, p0_t=None, absorption_zone=300.0, absorption_cut=0.01, lumping=True)

    initialize the sonic wave solver

    Parameters: | domain (`Domain`) – domain of the problem v_p (`escript.Scalar`) – p-velocity field wavelet (`Wavelet`) – wavelet to describe the time evolution of source term source_tag ('str' or 'int') – tag of the source location dt – time step size. If not present a suitable time step size is calculated. p0 – initial solution. If not present zero is used. p0_t – initial solution change rate. If not present zero is used. absorption_zone – thickness of absorption zone absorption_cut – boundary value of absorption decay factor lumping – if True mass matrix lumping is being used. This is accelerates the computing but introduces some diffusion.

  `getTimeStepSize`()
  `update`(t)

    returns the solution for the next time marker t which needs to greater than the time marker from the previous call.

class `esys.downunder.seismic.` `TTIWave`(domain, v_p, v_s, wavelet, source_tag, source_vector=[0.0, 1.0], eps=0.0, delta=0.0, theta=0.0, rho=1.0, dt=None, u0=None, v0=None, absorption_zone=300.0, absorption_cut=0.01, lumping=True)

  Bases: `esys.downunder.seismic.WaveBase`

  Solving the 2D TTI wave equation with

  `sigma_xx= c11*e_xx + c13*e_zz + c15*e_xz` `sigma_zz= c13*e_xx + c33*e_zz + c35*e_xz` `sigma_xz= c15*e_xx + c35*e_zz + c55*e_xz`

  the coefficients `c11`, `c13`, etc are calculated from the tompsen parameters `eps`, `delta` and the tilt `theta`

  Note: | currently only the 2D case is supported.

  `__init__`(domain, v_p, v_s, wavelet, source_tag, source_vector=[0.0, 1.0], eps=0.0, delta=0.0, theta=0.0, rho=1.0, dt=None, u0=None, v0=None, absorption_zone=300.0, absorption_cut=0.01, lumping=True)

    initialize the TTI wave solver

    Parameters: | domain (`Domain`) – domain of the problem v_p (`escript.Scalar`) – vertical p-velocity field v_s (`escript.Scalar`) – vertical s-velocity field wavelet (`Wavelet`) – wavelet to describe the time evolution of source term source_tag ('str' or 'int') – tag of the source location source_vector – source orientation vector eps – first Thompsen parameter delta – second Thompsen parameter theta – tilting (in Rad) rho – density dt – time step size. If not present a suitable time step size is calculated. u0 – initial solution. If not present zero is used. v0 – initial solution change rate. If not present zero is used. absorption_zone – thickness of absorption zone absorption_cut – boundary value of absorption decay factor lumping – if True mass matrix lumping is being used. This is accelerates the computing but introduces some diffusion.

  `getTimeStepSize`()
  `update`(t)

    returns the solution for the next time marker t which needs to greater than the time marker from the previous call.

class `esys.downunder.seismic.` `VTIWave`(domain, v_p, v_s, wavelet, source_tag, source_vector=[0.0, 0.0, 1.0], eps=0.0, gamma=0.0, delta=0.0, rho=1.0, dt=None, u0=None, v0=None, absorption_zone=None, absorption_cut=0.01, lumping=True, disable_fast_assemblers=False)

  Bases: `esys.downunder.seismic.WaveBase`

  Solving the VTI wave equation

  Note: | In case of a two dimensional domain the second spatial dimenion is depth.

  `__init__`(domain, v_p, v_s, wavelet, source_tag, source_vector=[0.0, 0.0, 1.0], eps=0.0, gamma=0.0, delta=0.0, rho=1.0, dt=None, u0=None, v0=None, absorption_zone=None, absorption_cut=0.01, lumping=True, disable_fast_assemblers=False)

    initialize the VTI wave solver

    Parameters: | domain (`Domain`) – domain of the problem v_p (`escript.Scalar`) – vertical p-velocity field v_s (`escript.Scalar`) – vertical s-velocity field wavelet (`Wavelet`) – wavelet to describe the time evolution of source term source_tag ('str' or 'int') – tag of the source location source_vector – source orientation vector eps – first Thompsen parameter delta – second Thompsen parameter gamma – third Thompsen parameter rho – density dt – time step size. If not present a suitable time step size is calculated. u0 – initial solution. If not present zero is used. v0 – initial solution change rate. If not present zero is used. absorption_zone – thickness of absorption zone absorption_cut – boundary value of absorption decay factor lumping – if True mass matrix lumping is being used. This is accelerates the computing but introduces some diffusion. disable_fast_assemblers (`boolean`) – if True, forces use of slower and more general PDE assemblers

  `getTimeStepSize`()
  `setQ`(q)

    sets the PDE q value

    Parameters: | q – the value to set

  `update`(t)

    returns the solution for the next time marker t which needs to greater than the time marker from the previous call.

class `esys.downunder.seismic.` `WaveBase`(dt, u0, v0, t0=0.0)

  Bases: `object`

  Base for wave propagation using the Verlet scheme.

  > `u_tt = A(t,u), u(t=t0)=u0, u_t(t=t0)=v0`

  with a given acceleration force as function of time.

  a_n=A(t_{n-1}) v_n=v_{n-1} + dt * a_n u_n=u_{n-1} + dt * v_n

  `__init__`(dt, u0, v0, t0=0.0)

    set up the wave base

    Parameters: | dt – time step size (need to be sufficiently small) u0 – initial value v0 – initial velocity t0 – initial time

  `getTimeStepSize`()
  `update`(t)

    returns the solution for the next time marker t which needs to greater than the time marker from the previous call.

class `esys.downunder.seismic.` `Wavelet`

  Bases: `object`

  place holder for source wavelet

  `__init__`()

    Initialize self. See help(type(self)) for accurate signature.

## Functions

`esys.downunder.seismic.` `createAbsorptionLayerFunction`(x, absorption_zone=300.0, absorption_cut=0.01, top_absorption=False)

  Creates a distribution which is one in the interior of the domain of `x` and is falling down to the value ‘absorption_cut’ over a margin of thickness ‘absorption_zone’ toward each boundary except the top of the domain.

  Parameters: | x (`escript.Data`) – location of points in the domain absorption_zone – thickness of the absorption zone absorption_cut – value of decay function on domain boundary
  Returns: | function on ‘x’ which is one in the iterior and decays to almost zero over a margin toward the boundary.

## Others

- OBSPY_AVAILABLE

## Packages