mspass::algorithms::TopMute Class Reference

Mute operator for "top" of signals defined first smaple forward. More...

#include <Taper.h>

Public Member Functions
	TopMute ()
	TopMute (const double t0, const double t1, const std::string type)
	Primary constructor driven by a named keyword.
	TopMute (const TopMute &parent)
	~TopMute ()
TopMute &	operator= (const TopMute &parent)
int	apply (mspass::seismic::TimeSeries &d)
int	apply (mspass::seismic::Seismogram &d)
double	get_t0 () const
double	get_t1 () const
std::string	taper_type () const

Detailed Description

Mute operator for "top" of signals defined first smaple forward.

A top mute is very commonly used in a many forms of seismic processing. It is, for example, a very low level operation in traditional seismic reflection processing. A top mute zeros the front (forward in time from first sample) of the signal and ramps up to a multiplier of 1 (does nothing) at some later time. It can also be thought of as a taper with only the low side altered. The implementation, in fact, uses the family of mspass taper operators internally the the high time range (tail) turned off.

The main constructor uses a string keyword to select the type of tapering applied to define the mute. Because of the relationship to mspass tapers there is also a constructor using the base class for Taper objects. It allows custom implementations of taper beyond those associated with keywords in the definition passed to the main constructor.

Constructor & Destructor Documentation

TopMute() [1/3]

mspass::algorithms::TopMute::TopMute

(

)

Default constructor. Exists but the result is invalid

{ taper = NULL; }

TopMute() [2/3]

mspass::algorithms::TopMute::TopMute	(	const double	t0,
		const double	t1,
		const std::string	type
	)

Primary constructor driven by a named keyword.

This is the normal constructor most users will want to us. It is defined by a time range for the mute to ramp from 0 to 1 and a string matching one of the supported types. Note the mspass VectorTaper cannot be used for this constructor because it requires more than 2 arguments to be defined.

Parameters

t0	is the end of the zeroed time range. Date from the first sample to this value will be zeroed.
t1	end ramp. Data with t>t1 will be unaltered.
type	defines the type of taper desired. Current options are 'linear' and 'cosine'. They enable the LinearTaper and CosineTaper opeators respectively.

Exceptions

This	function will throw a MsPASSError if t1<=t0.

                                                                       {
  const string base_error("TopMute parameterized constructor:  ");
  if (t1 <= t0) {
    stringstream ss;
    ss << base_error << "Zero time (t0) must be less than end of mute time (t1)"
       << endl
       << "Constructor was passed t0=" << t0 << " and t1=" << t1 << endl;
    throw MsPASSError(ss.str(), ErrorSeverity::Invalid);
  }
  try {
    if (type == "linear") {
      taper =
          std::make_shared<LinearTaper>(t0, t1, t0 + 999999.0, t1 + 999999.0);
      taper->disable_tail();
    } else if (type == "cosine") {
      taper =
          std::make_shared<CosineTaper>(t0, t1, t0 + 999999.0, t1 + 999999.0);
      taper->disable_tail();
    } else {
      stringstream ss;
      ss << base_error << "Unrecognized type argument=" << type << endl
         << "Current options are:  linear OR cosine" << endl;
      throw MsPASSError(ss.str(), ErrorSeverity::Invalid);
    }
  } catch (...) {
    throw;
  };
}

TopMute() [3/3]

mspass::algorithms::TopMute::TopMute

(

const TopMute &

parent

)

Standard copy constructor.

: taper(parent.taper) {}

~TopMute()

mspass::algorithms::TopMute::~TopMute

(

)

Destructor. The destructor of this class is not null.

{}

Member Function Documentation

apply() [1/2]

int mspass::algorithms::TopMute::apply

(

mspass::seismic::Seismogram &

d

)

Apply the operator to a Seismogram object.

                                             {
  try {
    int iret;
    iret = this->taper->apply(d);
    return iret;
  } catch (...) {
    throw;
  };
}

apply() [2/2]

int mspass::algorithms::TopMute::apply

(

mspass::seismic::TimeSeries &

d

)

Apply the operator to a TimeSeries object.

                                             {
  try {
    int iret;
    iret = this->taper->apply(d);
    return iret;
  } catch (...) {
    throw;
  };
}

get_t0()

double mspass::algorithms::TopMute::get_t0 ( ) const

inline

Return the start of mute taper - points with time < this number are zeroed

{ return taper->get_t0head(); };

get_t1()

double mspass::algorithms::TopMute::get_t1 ( ) const

inline

Return the end time of the mute taper - points after this point are unaltered by the mute.

{ return taper->get_t1head(); };

operator=()

TopMute & mspass::algorithms::TopMute::operator=

(

const TopMute &

parent

)

Standard assignment operator.

                                                 {
  if (&parent != this) {
    this->taper = parent.taper;
  }
  return *this;
}

taper_type()

string mspass::algorithms::TopMute::taper_type

(

)

const

Return a string with a name describing the form of the taper - currently returns either linear or cosine

                                 {
  BasicTaper *rawptr;
  rawptr = this->taper.get();
  if (dynamic_cast<const LinearTaper *>(rawptr))
    return string("linear");
  else if (dynamic_cast<const CosineTaper *>(rawptr))
    return string("cosine");
  else
    /* note there is a VectorTaper child of BasicTaper but it is not supported
    by TopMute - only allows linear and cosine - so if that happened somehow
    we throw this exception in that case too. */
    throw MsPASSError("TopMute::taper_type:  Internal taper dynamic cast does "
                      "not resolve;  this should not happen and is a bug",
                      ErrorSeverity::Fatal);
}

---

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