seifeclass.h

Go to the documentation of this file.

// include guard
#ifndef TF_SEIFECLASS_H_VERSION

#define TF_SEIFECLASS_H_VERSION \
  "TF_SEIFECLASS_H   V1.1"

#include<string>
#include<tsxx/filterbase.h>

namespace ts {

  namespace seife {

    class LPB: public ts::filter::BasicFilter {
      public:
        LPB(double t0, int o):
          Mt0(t0), Mo(o) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0;
        int Mo;
    }; // class LPB

    class HPB: public ts::filter::BasicFilter {
      public:
        HPB(double t0, int o):
          Mt0(t0), Mo(o) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0;
        int Mo;
    }; // class HPB

    class LP2: public ts::filter::BasicFilter {
      public:
        LP2(double t0, double h):
          Mt0(t0), Mh(h) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0, Mh;
    }; // class LP2

    class HP2: public ts::filter::BasicFilter {
      public:
        HP2(double t0, double h):
          Mt0(t0), Mh(h) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0, Mh;
    }; // class HP2

    class BP2: public ts::filter::BasicFilter {
      public:
        BP2(double t0, double h):
          Mt0(t0), Mh(h) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0, Mh;
    }; // class BP2

    class LP1: public ts::filter::BasicFilter {
      public:
         LP1(double t0):
           Mt0(t0) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0;
    }; // class LP1

    class HP1: public ts::filter::BasicFilter {
      public:
        HP1(double t0):
          Mt0(t0) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0;
    }; // class HP1

    class INT: public ts::filter::BasicFilter {
      public:
        INT(double t0):
          Mt0(t0) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0;
    }; // class INT

    class HE1: public ts::filter::BasicFilter {
      public:
        HE1(double t0s, double t0):
          Mt0s(t0s), Mt0(t0) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0s, Mt0;
    }; // class HE1

    class LE1: public ts::filter::BasicFilter {
      public:
        LE1(double t0s, double t0):
          Mt0s(t0s), Mt0(t0) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0s, Mt0;
    }; // class LE1

    class HE2: public ts::filter::BasicFilter {
      public:
        HE2(double t0s, double hs, double t0, double h):
          Mt0s(t0s), Mhs(hs), Mt0(t0), Mh(h) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0s, Mhs;
        double Mt0, Mh;
    }; // class HE2

    class LE2: public ts::filter::BasicFilter {
      public:
        LE2(double t0s, double hs, double t0, double h):
          Mt0s(t0s), Mhs(hs), Mt0(t0), Mh(h) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0s, Mhs;
        double Mt0, Mh;
    }; // class LE2

    class TID: public ts::filter::BasicFilter {
      public:
        TID(int ni):
          Mni(ni) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        int Mni;
    }; // class TID

    class DIF: public ts::filter::BasicFilter {
      public:
        DIF(double t0):
          Mt0(t0) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mt0;
    }; // class DIF

    class FIRST: public ts::filter::BasicFilter {
      public:
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
    }; // class FIRST

    ts::filter::Tfilterhandle make_seife_filter(std::string s,
                                                const bool& debug=false);

    void print_help(std::ostream& os);

  } // namespace seife

} // namespace ts

#endif // TF_SEIFECLASS_H_VERSION (includeguard)

/* ----- END OF seifeclass.h ----- */