CoreSeismogram.h

#ifndef _MSPASS_CORESEISMOGRAM_H_
#define _MSPASS_CORESEISMOGRAM_H_
#include "mspass/seismic/BasicTimeSeries.h"
#include "mspass/seismic/CoreTimeSeries.h"
#include "mspass/seismic/SlownessVector.h"
#include "mspass/utility/Metadata.h"
#include "mspass/utility/SphericalCoordinate.h"
#include "mspass/utility/dmatrix.h"
#include <memory>
#include <vector>
// #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();
};
} // namespace mspass::seismic
#endif // End guard