ScalarDecon.h

#ifndef __SIMPLE_DECON_H__
#define __SIMPLE_DECON_H__
 
#include "mspass/algorithms/deconvolution/BasicDeconOperator.h"
#include "mspass/algorithms/deconvolution/ShapingWavelet.h"
#include "mspass/seismic/CoreTimeSeries.h"
#include "mspass/seismic/TimeSeries.h"
#include "mspass/utility/Metadata.h"
#include <string>
#include <vector>
 
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/vector.hpp>
 
namespace mspass::algorithms::deconvolution {
class ScalarDecon : public BasicDeconOperator {
public:
  ScalarDecon() : shapingwavelet() {};
  ScalarDecon(const mspass::utility::Metadata &md);
  ScalarDecon(const std::vector<double> &d, const std::vector<double> &w);
  ScalarDecon(const ScalarDecon &parent);
  int load(const std::vector<double> &wavelet, const std::vector<double> &data);
  int loaddata(const std::vector<double> &data);
  int loadwavelet(const std::vector<double> &wavelet);
  virtual void process() = 0;
  virtual ~ScalarDecon() {};
  ScalarDecon &operator=(const ScalarDecon &parent);
  std::vector<double> getresult() { return result; };
  void changeparameter(const mspass::utility::Metadata &md);
  void change_shaping_wavelet(const ShapingWavelet &nsw);
  ShapingWavelet get_shaping_wavelet() const { return this->shapingwavelet; };
  virtual mspass::seismic::TimeSeries output_shaping_wavelet() {
    return mspass::seismic::TimeSeries(
        this->shapingwavelet.impulse_response());
  };
  mspass::seismic::TimeSeries ideal_output() {
    return this->output_shaping_wavelet();
  };
  virtual mspass::seismic::TimeSeries actual_output() = 0;
  mspass::seismic::TimeSeries resolution_kernel() {
    return this->actual_output();
  };
 
  virtual mspass::seismic::CoreTimeSeries inverse_wavelet() = 0;
  virtual mspass::seismic::CoreTimeSeries inverse_wavelet(double t0parent) = 0;
  virtual mspass::utility::Metadata QCMetrics() = 0;
 
protected:
  mspass::utility::Metadata BasicQCMetrics(const std::string &operator_name,
                                           const bool processed);
  std::vector<double> data;
  std::vector<double> wavelet;
  std::vector<double> result;
  ShapingWavelet shapingwavelet;
 
private:
  friend boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar & data;
    ar & wavelet;
    ar & result;
    ar & shapingwavelet;
  }
};
} // namespace mspass::algorithms::deconvolution
#endif