Taper.h

#ifndef _TAPER_H_
#define _TAPER_H_
// #include <math.h>
#include <memory>
#include <vector>
 
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/vector.hpp>
 
#include "mspass/seismic/Seismogram.h"
#include "mspass/seismic/TimeSeries.h"
 
namespace mspass::algorithms {
 
class BasicTaper {
public:
  BasicTaper() {
    head = false;
    tail = false;
    all = false;
  };
  virtual ~BasicTaper() {};
  virtual int apply(mspass::seismic::TimeSeries &d) = 0;
  virtual int apply(mspass::seismic::Seismogram &d) = 0;
  void enable_head() { head = true; };
  void disable_head() {
    head = false;
    all = false;
  };
  void enable_tail() { tail = true; };
  void disable_tail() {
    tail = false;
    all = false;
  };
  bool head_is_enabled() {
    if (head || all) {
      return true;
    }
    return false;
  };
  bool tail_is_enable() {
    if (tail || all) {
      return true;
    }
    return false;
  };
  /* These virtual methods are a bit of a design flaw as they don't
  apply well to the vector taper, but we implement them there to just
  throw an exception */
  virtual double get_t0head() const = 0;
  virtual double get_t1head() const = 0;
 
protected:
  /* A taper can be head, tail, or all.  For efficiency it is required
  implementations set these three booleans.   head or tail may be true.
  all means a single function is needed to defne the taper.  */
  bool head; 
  bool tail; 
  bool all; 
private:
  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar & head;
    ar & tail;
    ar & all;
  };
};
class LinearTaper : public BasicTaper {
public:
  LinearTaper();
  LinearTaper(const double t0head, const double t1head, const double t1tail,
              const double t0tail);
  int apply(mspass::seismic::TimeSeries &d);
  int apply(mspass::seismic::Seismogram &d);
  double get_t0head() const { return t0head; };
  double get_t1head() const { return t1head; };
  double get_t0tail() const { return t0tail; };
  double get_t1tail() const { return t1tail; };
 
private:
  double t0head, t1head, t1tail, t0tail;
  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar &boost::serialization::base_object<BasicTaper>(*this);
    ar & t0head;
    ar & t1head;
    ar & t1tail;
    ar & t0tail;
  };
};
class CosineTaper : public BasicTaper {
public:
  CosineTaper();
  CosineTaper(const double t0head, const double t1head, const double t1tail,
              const double t0tail);
  /* these need to post to history using new feature*/
  int apply(mspass::seismic::TimeSeries &d);
  int apply(mspass::seismic::Seismogram &d);
  double get_t0head() const { return t0head; };
  double get_t1head() const { return t1head; };
  double get_t0tail() const { return t0tail; };
  double get_t1tail() const { return t1tail; };
 
private:
  double t0head, t1head, t1tail, t0tail;
  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar &boost::serialization::base_object<BasicTaper>(*this);
    ar & t0head;
    ar & t1head;
    ar & t1tail;
    ar & t0tail;
  };
};
class VectorTaper : public BasicTaper {
public:
  VectorTaper();
  VectorTaper(const std::vector<double> taperdata);
  int apply(mspass::seismic::TimeSeries &d);
  int apply(mspass::seismic::Seismogram &d);
  void disable() { all = false; };
  void enable() {
    if (taper.size() > 0)
      all = true;
  };
  std::vector<double> get_taper() { return taper; };
  double get_t0head() const {
    std::cerr << "get_t0head not implemented for VectorTaper";
    return 0.0;
  };
  double get_t1head() const {
    std::cerr << "get_t1head not implemented for VectorTaper";
    return 0.0;
  };
 
private:
  std::vector<double> taper;
  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar &boost::serialization::base_object<BasicTaper>(*this);
    ar & taper;
  };
};
class TopMute {
public:
  TopMute();
  TopMute(const double t0, const double t1, const std::string type);
  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 { return taper->get_t0head(); };
  double get_t1() const { return taper->get_t1head(); };
  std::string taper_type() const;
 
private:
  /* We use a shared_ptr to the base class.  That allows inheritance to
  handle the actual form - a classic oop use of a base class. the shared_ptr
  allows us to get around an abstract base problem.   May be other solutions
  but this should be ok.  There may be a problem in parallel environment,
  however, as not sure how this would be handled by spark or dask.   this is
  in that pickable realm.*/
  std::shared_ptr<BasicTaper> taper;
  /* I tried this but couldn't make it work.   It compiles but dies at
  runtime with mysterious errors for me.   Internet conversations suggest
  shared_ptr data with polymorphic types like this is problematic.
  For mspass the python bindings with pickle are more what is needed anyway
  so serialization of TopMute is purely done in the pybind11 wrappers.
  Turns out to be easy because the TopMute taper is actually define donly
  by two paramters (t0head and t1head).
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version)
  {
    ar & taper;
  };
  */
};
} // namespace mspass::algorithms
#endif // End guard