stfinvbase.h

Go to the documentation of this file.

// include guard
#ifndef STFINV_STFINVBASE_H_VERSION

#define STFINV_STFINVBASE_H_VERSION \
  "STFINV_STFINVBASE_H   V1.2"

#include<stfinv/waveformheader.h>
#include<stfinv/parameterhandler.h>
#include<stfinv/error.h>
#include<aff/series.h>
#include<iostream>
#include<vector>

namespace stfinv {

  typedef aff::Series<Tvalue> Tseries;

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

  struct WaveformPair {
    CWaveformHeader sampling;
    Tseries::Tcoc synthetics;
    Tseries convolvedsynthetics;
  }; // class WaveformPair

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

  struct WaveformTriple {
    CTripleHeader header;
    Tseries::Tcoc data;
    Tseries::Tcoc synthetics;
    Tseries convolvedsynthetics;
    double offset() const;
  }; // class WaveformTriple

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

  struct Waveform {
    CWaveformHeader sampling;
    Tseries series;
  }; // class Waveform

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

  typedef std::vector<stfinv::WaveformPair> Tvectorofpairs;

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

  typedef std::vector<stfinv::WaveformTriple> Tvectoroftriples;

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

#define STFINV_baseillegal STFINV_abort("illegal call to abstract base class!")

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

  class STFBaseEngine {
    protected:
      STFBaseEngine(const stfinv::Tvectoroftriples& triples,
                    const stfinv::Waveform& stf,
                    const std::string& parameters);
      STFBaseEngine(const stfinv::Tvectoroftriples& triples,
                    const stfinv::Waveform& stf,
                    const stfinv::Tvectorofpairs& pairs,
                    const std::string& parameters);
    public:
      virtual ~STFBaseEngine() { }

      stfinv::Waveform run() 
      {
        this->exec();
        return(Mstf);
      }
      virtual void help(std::ostream& os=std::cout) const;
      virtual void usage(std::ostream& os=std::cout) const;
      virtual const char* name() const;
      static void classhelp(std::ostream& os=std::cout);
      static void classusage(std::ostream& os=std::cout);
        
      unsigned int nsamples() const
      { return (Mstf.sampling.n); }
      unsigned int nreceivers() const
      { return (Mtriples.size()); }
      unsigned int npairs() const
      { return (Mpairs.size()); }
      double dt() const 
      { return (Mstf.sampling.dt); }

      Tseries stf() const 
      { return (Mstf.series); }
      Tseries::Tcoc recording(const unsigned int& i) const ;
      Tseries::Tcoc synthetic(const unsigned int& i) const ;
      Tseries convolvedsynthetic(const unsigned int& i) const ;
      Tseries::Tcoc series(const unsigned int& i) const ;
      Tseries convolvedseries(const unsigned int& i) const ;
        
    protected:
      std::string parameter(const std::string& key,
                            const std::string& defvalue="false") const;
      bool parameterisset(const std::string& key) const;
      void checkreceiverindex(const unsigned int& i) const;
      void checkseriesindex(const unsigned int& i) const;
      virtual void exec() { STFINV_baseillegal; }
      double weight(const unsigned int& i) const 
      { return(Mweights(i)); }
      aff::Series<double> weights() const 
      { return(Mweights); }

    private:
      void initialize(const std::string& parameters);
      void parseparameters(std::string parameters);
      void checkconsistency() const;
      void setweights(const double& k);
      
    // member data
    // -----------

    protected:
      // protected members are accessed directly from derived classes
      stfinv::Tvectoroftriples Mtriples;
      stfinv::Waveform Mstf;
      stfinv::Tvectorofpairs Mpairs;
      int Mdebug;
      int Mverbose;
    private:
      mutable stfinv::tools::Tparamap Mparamap;
      aff::Series<double> Mweights;
  }; // class STFBaseEngine

} // namespace stfinv

#endif // STFINV_STFINVBASE_H_VERSION (includeguard)

/* ----- END OF stfinvbase.h ----- */