firfilters.h

Go to the documentation of this file.

// include guard
#ifndef TF_FIRFILTERS_H_VERSION

#define TF_FIRFILTERS_H_VERSION \
  "TF_FIRFILTERS_H   V1.0   "

#include<iostream>
#include<string>
#include<aff/series.h>
#include<aff/iterator.h>
#include<tsxx/error.h>

namespace ts {

  namespace fir {

    struct FIR {
      const char* name;
      const char* description;
      const int points;
      const int delay;
      const bool symmetric;
      const int decimation_factor;
      const double gain;
      const double* c;
    }; // struct FIR

    extern const FIR SeisCompMP;
    extern const FIR SeisCompLP;
    extern const FIR SeisCompVLP;

    extern const FIR* FIRfilters[];

    /*----------------------------------------------------------------------*/

    std::ostream& operator<<(std::ostream& os, const FIR& fir);

    /*----------------------------------------------------------------------*/

    void help(std::ostream& os);

    /*----------------------------------------------------------------------*/

    template<class T>
      class FIRfilter {
        public:
          typedef T Tvalue;
          typedef aff::Series<Tvalue> Tseries;
          typedef aff::Iterator<Tseries> Titerator;
          FIRfilter(const FIR* fir): Mfir(fir), Ms(fir->points), Mi(Ms) 
          { this->clear(); }
          FIRfilter(const std::string name): Mfir(0), Ms(1), Mi(Ms)
          { 
            int i=0;
            while (FIRfilters[i]!=0)
            { 
              if (name == FIRfilters[i]->name) { Mfir=FIRfilters[i]; } 
              ++i;
            }
            TSXX_assert(Mfir != 0, "FIRfilter: unknown FIR filter name"); 
            Ms=Tseries(Mfir->points);
            Mi=Titerator(Ms);
            this->clear(); 
          }
          void push(const Tvalue& v)
          {
            *Mi = v;
            ++Mi;
          }
          Tvalue pop() const
          {
            Titerator Ml=Mi;
            double sum=0;
            if (Mfir->symmetric)
            {
              for (int i=0; i<Mfir->points / 2; ++i)
              { sum += *Ml * Mfir->c[i] * Mfir->gain; --Ml; }
              for (int i= Mfir->points/2 -1; i>=0; --i)
              { sum += *Ml * Mfir->c[i] * Mfir->gain; --Ml; }
            }
            else
            {
              for (int i=0; i<Mfir->points; ++i)
              { sum += *Ml * Mfir->c[i] * Mfir->gain; --Ml; }
            }
            return(Tvalue(sum));
          }
          void clear()
          {
            Mi.tofirst();
            while (Mi.valid()) { *Mi = 0; ++Mi; }
            Mi.tofirst();
          }
          const FIR& fir() const { return(*Mfir); }
        private:
          const FIR* Mfir;
          Tseries Ms;
          Titerator Mi;
      }; // class FIRfilter

  } // namespace fir

} // namespace ts

#endif // TF_FIRFILTERS_H_VERSION (includeguard)

/* ----- END OF firfilters.h ----- */