CoreSeismogram.h

#ifndef _MSPASS_CORESEISMOGRAM_H_
#define _MSPASS_CORESEISMOGRAM_H_
#include <memory>
#include <vector>
#include "mspass/utility/Metadata.h"
#include "mspass/utility/dmatrix.h"
#include "mspass/seismic/BasicTimeSeries.h"
#include "mspass/seismic/CoreTimeSeries.h"
#include "mspass/utility/SphericalCoordinate.h"
#include "mspass/seismic/SlownessVector.h"
//#include "mspass/seismic/Ensemble.h"
namespace mspass::seismic{
 
/* A Seismogram is viewed as a special collection of Time Series
type data that is essentially a special version of a vector time series.
It is "special" as the vector is 3D with real components.  One could produce a
similar inherited type for an n vector time series object.
 
The structure of a vector time series allows the data to be stored in a matrix.
Here we use a lightweight matrix object I call dmatrix.   This object is
contains core concepts that define a seismogram.   It can be extended as in
MsPASS to add functionality or aliased to Seismogram to simplify the naming as
done, for example, with std::basic_string made equivalent to std::string.
*/
 
 
class CoreSeismogram : public mspass::seismic::BasicTimeSeries , public mspass::utility::Metadata
{
public:
    mspass::utility::dmatrix u;
 
    CoreSeismogram();
    CoreSeismogram(const size_t nsamples);
    CoreSeismogram(const std::vector<mspass::seismic::CoreTimeSeries>& ts,
        const unsigned int component_to_clone=0);
        CoreSeismogram(const mspass::utility::Metadata& md,const bool load_data=true);
    CoreSeismogram(const CoreSeismogram&);
    /* These overload virtual methods in BasicTimeSeries. */
    void set_dt(const double sample_interval);
    void set_npts(const size_t npts);
    void sync_npts();
    void set_t0(const double t0in);
    CoreSeismogram& operator= (const CoreSeismogram&);
        CoreSeismogram& operator+=(const CoreSeismogram& d);
        const CoreSeismogram operator+(const CoreSeismogram& other) const;
        CoreSeismogram& operator*=(const double);
        CoreSeismogram& operator-=(const CoreSeismogram& d);
        const CoreSeismogram operator-(const CoreSeismogram& other) const;
        std::vector<double> operator[](const int sample)const;
        std::vector<double> operator[](const double time)const;
    virtual ~CoreSeismogram(){};
    void rotate_to_standard();
    // This overloaded pair do the same thing for a vector
    // specified as a unit vector nu or as spherical coordinate angles
    void rotate(mspass::utility::SphericalCoordinate& sc);
 
    void rotate(const double nu[3]);
  void rotate(const double phi);
    void transform(const double a[3][3]);
    void free_surface_transformation(const mspass::seismic::SlownessVector u, const double vp0, const double vs0);
  mspass::utility::dmatrix get_transformation_matrix() const
  {
      mspass::utility::dmatrix result(3,3);
      for(int i=0;i<3;++i)
          for(int j=0;j<3;++j) result(i,j)=tmatrix[i][j];
      return result;
  };
  bool set_transformation_matrix(const mspass::utility::dmatrix& A);
  bool set_transformation_matrix(const double a[3][3]);
  bool set_transformation_matrix(pybind11::object a);
 
    bool cardinal()const {return components_are_cardinal;};
    bool orthogonal()const {return components_are_orthogonal;};
    double endtime()const noexcept
  {
      return(mt0+mdt*static_cast<double>(u.columns()-1));
  };
 
protected:
        bool components_are_orthogonal;
        bool components_are_cardinal;  // true if x1=e, x2=n, x3=up
        double tmatrix[3][3];
private:
  /* This is used internally when necessary to test if a computed or input
           matrix is an identity matrix. */
  bool tmatrix_is_cardinal();
};
}  //end mspass::seismic namespace enscapsulation
#endif  // End guard