mspass::algorithms::LinearTaper Class Reference

Used to construct an operator to apply a linear taper to either end. More...

#include <Taper.h>

Inheritance diagram for mspass::algorithms::LinearTaper:

Collaboration diagram for mspass::algorithms::LinearTaper:

Public Member Functions
	LinearTaper (const double t0head, const double t1head, const double t1tail, const double t0tail)
	primary constructor.
int	apply (mspass::seismic::TimeSeries &d)
int	apply (mspass::seismic::Seismogram &d)
double	get_t0head () const
double	get_t1head () const
double	get_t0tail () const
double	get_t1tail () const
Public Member Functions inherited from mspass::algorithms::BasicTaper
	BasicTaper ()
virtual	~BasicTaper ()
void	enable_head ()
void	disable_head ()
void	enable_tail ()
void	disable_tail ()
bool	head_is_enabled ()
bool	tail_is_enable ()

Friends
class	boost::serialization::access

Additional Inherited Members
Protected Attributes inherited from mspass::algorithms::BasicTaper
bool	head
bool	tail
bool	all

Detailed Description

Used to construct an operator to apply a linear taper to either end.

Linear tapers are defined here as a time spanning a ramp running from 0 to 1. Data will be zeroed on each end of a 0 mark and a linear weight applied between 0 points and 1 points. Postive ramp slope on left and negative slope ramp on right.

Constructor & Destructor Documentation

LinearTaper() [1/2]

mspass::algorithms::LinearTaper::LinearTaper

(

)

                         {
  head = false;
  tail = false;
  all = false;
}

LinearTaper() [2/2]

mspass::algorithms::LinearTaper::LinearTaper	(	const double	t0head,
		const double	t1head,
		const double	t1tail,
		const double	t0tail
	)

primary constructor.

Defines linear taper for front and/or back end of a time range. Zero times before t0head and after t0tail. Linear ramp between t0head and t1head and in opposite sense from t1tail to t0tail. Setting 0 value = 1 value should be used as a signal to disable.

                                           {
  t0head = t0h;
  t1head = t1h;
  t0tail = t0t;
  t1tail = t1t;
  if (t1head > t0head)
    head = true;
  else
    head = false;
  if (t1tail < t0tail)
    tail = true;
  else
    tail = false;
  if (head && tail)
    all = true;
  else
    all = false;
  if (!(head || tail)) {
    stringstream ss;
    ss << "LinearTaper constructor:  illegal input.  No valid taper parameters"
       << endl
       << "Input defines front end ramp defined as 0 at " << t0h
       << " rising to 1 at " << t1h << endl
       << "Tail end ramp defined with 1 at " << t1t << " dropping to 0 at "
       << t0t << endl;
    throw MsPASSError(ss.str(), ErrorSeverity::Invalid);
  }
}

References mspass::algorithms::BasicTaper::all, mspass::algorithms::BasicTaper::head, and mspass::algorithms::BasicTaper::tail.

Member Function Documentation

apply() [1/2]

int mspass::algorithms::LinearTaper::apply ( mspass::seismic::Seismogram &  d )

virtual

Apply the linear taper to a three-component Seismogram.

Implements mspass::algorithms::BasicTaper.

                                    {
  int k;
  double rampslope;
  if (head) {
    if (d.endtime() < t0head) {
      stringstream ss;
      ss << "LinearTaper::apply:  inconsistent head taper parameters" << endl
         << "Data endtime=" << d.endtime()
         << " which is earlier than start of head taper=" << t0head << endl
         << "Data vector was not altered" << endl;
      d.elog.log_error("LinearTaper", ss.str(), ErrorSeverity::Complaint);
      return -1;
    }
    int is;
    double t, wt;
    for (t = d.t0(); t < t0head; t += d.dt()) {
      is = d.sample_number(t);
      if (is >= 0 && is < d.npts()) {
        for (k = 0; k < 3; ++k)
          d.u(k, is) = 0.0;
      }
    }
    rampslope = 1.0 / (t1head - t0head);
    for (t = t0head; t < t1head; t += d.dt()) {
      is = d.sample_number(t);
      if (is >= 0) {
        wt = rampslope * (t - t0head);
        for (k = 0; k < 3; ++k)
          d.u(k, is) *= wt;
      }
    }
  }
  if (tail) {
    if (d.t0() > t0tail) {
      stringstream ss;
      ss << "LinearTaper::apply:  inconsistent tail taper parameters" << endl
         << "Data start time=" << d.t0()
         << " is after the end of the tail taper = " << t0tail << endl
         << "Data vector was not altered" << endl;
      MsPASSError merr(ss.str(), ErrorSeverity::Complaint);
      d.elog.log_error("LinearTaper", ss.str(), ErrorSeverity::Complaint);
      return -1;
    }
    int is;
    double t, wt;
    for (t = d.endtime(); t >= t0tail; t -= d.dt()) {
      is = d.sample_number(t);
      if (is >= 0 && is < d.npts()) {
        for (k = 0; k < 3; ++k)
          d.u(k, is) = 0.0;
      }
    }
    rampslope = 1.0 / (t0tail - t1tail);
    for (t = t0tail; t >= t1tail; t -= d.dt()) {
      is = d.sample_number(t);
      if (is >= 0) {
        wt = rampslope * (t - t1tail);
        for (k = 0; k < 3; ++k)
          d.u(k, is) *= wt;
      }
    }
  }
  return 0;
}

References mspass::seismic::BasicTimeSeries::dt(), mspass::utility::ProcessingHistory::elog, mspass::seismic::CoreSeismogram::endtime(), mspass::algorithms::BasicTaper::head, mspass::utility::ErrorLogger::log_error(), mspass::seismic::BasicTimeSeries::npts(), mspass::seismic::BasicTimeSeries::sample_number(), mspass::seismic::BasicTimeSeries::t0(), mspass::algorithms::BasicTaper::tail, and mspass::seismic::CoreSeismogram::u.

apply() [2/2]

int mspass::algorithms::LinearTaper::apply ( mspass::seismic::TimeSeries &  d )

virtual

Apply the linear taper to a scalar TimeSeries.

Implements mspass::algorithms::BasicTaper.

                                    {
  double rampslope;
  if (head) {
    if (d.endtime() < t0head) {
      stringstream ss;
      ss << "LinearTaper::apply:  inconsistent head taper parameters" << endl
         << "Data endtime=" << d.endtime()
         << " which is earlier than start of head taper=" << t0head << endl
         << "Data vector was not altered" << endl;
      d.elog.log_error("LinearTaper", ss.str(), ErrorSeverity::Complaint);
      return -1;
    }
    int is;
    double t, wt;
    for (t = d.t0(); t < t0head; t += d.dt()) {
      is = d.sample_number(t);
      if (is >= 0 && is < d.npts())
        d.s[is] = 0.0;
    }
    rampslope = 1.0 / (t1head - t0head);
    for (t = t0head; t < t1head; t += d.dt()) {
      is = d.sample_number(t);
      if (is >= 0) {
        wt = rampslope * (t - t0head);
        d.s[is] *= wt;
      }
    }
  }
  if (tail) {
    if (d.t0() > t0tail) {
      stringstream ss;
      ss << "LinearTaper::apply:  inconsistent tail taper parameters" << endl
         << "Data start time=" << d.t0()
         << " is after the end of the tail taper = " << t0tail << endl
         << "Data vector was not altered" << endl;
      d.elog.log_error("LinearTaper", ss.str(), ErrorSeverity::Complaint);
      return -1;
    }
    int is;
    double t, wt;
    for (t = d.endtime(); t >= t0tail; t -= d.dt()) {
      is = d.sample_number(t);
      if (is >= 0 && is < d.npts())
        d.s[is] = 0.0;
    }
    rampslope = 1.0 / (t0tail - t1tail);
    for (t = t0tail; t >= t1tail; t -= d.dt()) {
      is = d.sample_number(t);
      if (is >= 0) {
        wt = rampslope * (t0tail - t);
        d.s[is] *= wt;
      }
    }
  }
  return 0;
}

References mspass::seismic::BasicTimeSeries::dt(), mspass::utility::ProcessingHistory::elog, mspass::seismic::BasicTimeSeries::endtime(), mspass::algorithms::BasicTaper::head, mspass::utility::ErrorLogger::log_error(), mspass::seismic::BasicTimeSeries::npts(), mspass::seismic::CoreTimeSeries::s, mspass::seismic::BasicTimeSeries::sample_number(), mspass::seismic::BasicTimeSeries::t0(), and mspass::algorithms::BasicTaper::tail.

get_t0head()

double mspass::algorithms::LinearTaper::get_t0head ( ) const

inlinevirtual

Return the start time of the head ramp.

Implements mspass::algorithms::BasicTaper.

{ return t0head; };

get_t0tail()

double mspass::algorithms::LinearTaper::get_t0tail ( ) const

inline

Return the zero-weight end time of the tail ramp.

{ return t0tail; };

get_t1head()

double mspass::algorithms::LinearTaper::get_t1head ( ) const

inlinevirtual

Return the end time of the head ramp.

Implements mspass::algorithms::BasicTaper.

{ return t1head; };

get_t1tail()

double mspass::algorithms::LinearTaper::get_t1tail ( ) const

inline

Return the one-weight start time of the tail ramp.

{ return t1tail; };

---

The documentation for this class was generated from the following files:

• /home/runner/work/mspass/mspass/cxx/include/mspass/algorithms/Taper.h
• /home/runner/work/mspass/mspass/cxx/src/lib/algorithms/Taper.cc