ShapingWavelet.h

#ifndef __SHAPING_WAVELET_H__
#define __SHAPING_WAVELET_H__
#include "mspass/algorithms/deconvolution/ComplexArray.h"
#include "mspass/seismic/CoreTimeSeries.h"
#include "mspass/utility/Metadata.h"
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/vector.hpp>
namespace mspass::algorithms::deconvolution {
class ShapingWavelet {
public:
  ShapingWavelet() {
    dt = -1;
    df = -1;
  };
  ShapingWavelet(const mspass::utility::Metadata &md, int npts = 0);
  /* \brief Use a wavelet defined by a TimeSeries object.
   *
   This constructor uses the data stored in a TimeSeries object to define
   the shaping wavelet.   Note to assure output is properly time aligned
   this signal is forced to be symmetric around relative time 0.   That is
   necessary because of the way this, like every fft we are aware of, handles
   phase.   Hence, the user should assure zero time is an appropriate
   zero reference (e.g. a zero phase filter should the dominant peak at 0
   time.)   If the input data size is smaller than the buffer size
   specified the buffer is zero padded.
 
   \param w - TimeSeries specifying wavelet.   Note dt will be extracted
     and stored in this object.
   \param nfft - buffer size = fft length for frequency domain representation
     of the wavelet.  If ns of d is less than nfft or the time range defined
     by d is does not exceed -(nfft/2)*dt to (nfft2)*dt the result will
     be sero padded before computing the fft. if nfft is 0 the d.ns will
     set the fft length.
     */
  ShapingWavelet(mspass::seismic::CoreTimeSeries d, int nfft = 0);
  ShapingWavelet(const double fpeak, const double dtin, const int n);
  ShapingWavelet(const int npolelo, const double f3dblo, const int npolehi,
                 const double f3dbhi, const double dtin, const int n);
  ShapingWavelet(const ShapingWavelet &parent);
  ShapingWavelet &operator=(const ShapingWavelet &parent);
  ComplexArray *wavelet() { return &w; };
  mspass::seismic::CoreTimeSeries impulse_response();
  double freq_bin_size() { return df; };
  double sample_interval() { return dt; };
  std::string type() { return wavelet_name; };
  int size() const { return w.size(); };
 
private:
  int nfft;
  ComplexArray w;
  double dt, df;
  std::string wavelet_name;
  friend boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar & nfft;
    ar & dt;
    ar & df;
    ar & wavelet_name;
    ar & w;
  }
};
} // namespace mspass::algorithms::deconvolution
#endif