• Antelope Release 5.5 Linux 2.6.32-220.el6.x86_64 2015-04-21

 

NAME

slowness - C++ objects for slowness vectors

SYNOPSIS

include "slowness.h"
using namespace SEISPP;
class SlownessVector
{
public:
        double ux,uy;   // base vector stored as components in s/km units
        SlownessVector();
        SlownessVector(const SlownessVector&);
        double mag();
        double azimuth();
        double baz();
};
class RectangularSlownessGrid
{
public:
        string name;
        double uxlow, uylow;
        double dux, duy;
        int nux, nuy;
        RectangularSlownessGrid();  // generic default is defined
        RectangularSlownessGrid(string nm, double uxl, double uxh,
                double du1,double du2,int n1, int n2);
        RectangularSlownessGrid(Pf *pf,string tag);
        RectangularSlownessGrid(const  RectangularSlownessGrid&);
        double ux(int i) {return(uxlow+i*dux);};
        double uy(int i) {return(uylow+i*duy);};
        SlownessVector slow(int i, int j);
};

SUPPORT


Contributed code: NO BRTT support.
THIS PIECE OF SOFTWARE WAS CONTRIBUTED BY THE ANTELOPE USER COMMUNITY. BRTT DISCLAIMS ALL OWNERSHIP, LIABILITY, AND SUPPORT FOR THIS PIECE OF SOFTWARE.

FOR HELP WITH THIS PIECE OF SOFTWARE, PLEASE CONTACT THE CONTRIBUTING AUTHOR.

DESCRIPTION

Slowness vectors are a common concept in array processing. The SlownessVector object encapsulates this concept. The slowness vector is defined by a local geographical coordinate system with +x pointing east and +y pointing north. The azimuth function returns a geographical azimuth (0 is north for an azimuth) for the slowness vector defined by the components ux and uy in the local cartesian system. Similarly baz returns the back azimuth.

In array processing slowness grids are commonly used to find a best beam. The RectangularSlownessGrid object defines one particular class of such a grid. Slowness space in the Cartesian system (ux and uy) is gridded in a rectangular area with (uxlow, uylow) defining the lower left corner of the grid. The slowness grid is then uniformly spaced in units of dux (for x) and duy (for y). nux and nuy define the total number of grid points in each of the x and y directions. Slowness vectors for the grid can be obtained by calling the component functions (ux and uy) the slow function which returns a SlownessVector object.

CONSTRUCTORS

The default constructor for a SlownessVector initializes ux and uy to zero.

The RectangularSlownessGrid object has a fully parameterized constructor which loads all the data in the object directly. I trust it's usage is obvious.

A less obvious usage is the parameter file based constructor for a RectangularSlownessGrid object. In that usage pf is a pointer to an Antelope pf and tag is a string used to define the block of the parameter file to load the data from. The example below is the best way to document this.

PARAMETER FILE

To use the parameter file constructor for a RectangularSlownessGrid object follow this template.

Slowness_Grid_Example &Arr{  #Here the tag is Slowness_Grid_Example
Slowness_Grid_Name test  # name of the grid object
# This creates a 21 x 21 grid from -0.1 to 0.1 in increments of .01
uxlow -0.1
uylow -0.1
nux 21
nuy 21
dux 0.01
duy 0.01
}

EXCEPTIONS

None of these objects currently will throw an exception.

LIBRARY

-lseispp

SEE ALSO

http://geology.indiana.edu/pavlis/software/seispp/html/index.html

BUGS AND CAVEATS

The default constructor sets the slowness vector components to zero. The azimuth and baz functions will silently return 0 in this situation.

AUTHOR

Gary L. Pavlis
Department of Geological Sciences
Indiana University
pavlis@indiana.edu

Antelope User Group Contributed Software
Printer icon