gsexx.h

Go to the documentation of this file.

// include guard
#ifndef TF_GSEXX_H_VERSION

#define TF_GSEXX_H_VERSION \
  "TF_GSEXX_H   V1.5"
#define TF_GSEXX_H_CVSID \
  "$Id$"

// #include <libtime++.h>
#include<string>
#include<iostream>

namespace GSE2 {

/*----------------------------------------------------------------------*/
/*
 * exception base class
 * --------------------
 */

class Terror {
  public: 
    Terror(const std::string& message): Mmessage(message) { 
      if (!silent) { std::cerr << Mmessage << std::endl; }
    }
    const std::string& message() const { return(Mmessage); }
    static bool silent;
  private:
    std::string Mmessage;
}; // Terror

/*======================================================================*/

namespace waveform {

typedef int intT;

enum Esubformat 
{
  SF_INT,        
  SF_CM6,        
  SF_CM8,        
  SF_AUT,        
  SF_AU6,        
  SF_AU8         
};

/*======================================================================*/
/*
 * all stuff for WID2 lines
 * ------------------------
 */

struct TWID2 {
  public:
    static const char* const GSEID;
    TWID2() { this->defaults(); }
    std::string subformat() const;
    std::string line() const;
    void read(std::istream& is);
    void defaults();
    void setsubformat(const std::string& key);
    double seconds() const;
    void seconds(const double& s);
  public:
    int                    Fyear;        
    int                    Fmonth;       
    int                    Fday;         
    int                    Fhour;        
    int                    Fminute;      
    // double                 Fseconds;     //!< seconds of time
    std::string            Fstation;     
    std::string            Fchannel;     
    std::string            Fauxid;       
    Esubformat             Fsubformat;   
    int                    Fsamps;       
    double                 Fsamprate;    
    double                 Fcalib;       
    double                 Fcalper;      
    std::string            Finstype;     
    double                 Fhang;        
    double                 Fvang;        
    int                    Fmilsec;
}; // struct TWID2

/*======================================================================*/
/*
 * all stuff for the GSE2.1 STA2 line
 * ----------------------------------
 */

class TSTA2 {
  public:
    static const char* const GSEID;
}; // class TSTA2

/*======================================================================*/
/*
 * all stuff for checksums
 * -----------------------
 */

class TCHK2 {
    friend std::istream& operator>>(std::istream&, TCHK2& chk2);
  public:
    TCHK2(): Msum(0) { }
    void add(const intT& value);
    intT value() const { return(Msum > 0 ? Msum : -Msum); }
    std::string write() const;
    void read(std::istream& is);
    static const char* const GSEID;
  private:
    void set(const intT& value) { Msum=value; }
    intT Msum;   
}; // class TCHK2

/*======================================================================*/
/*
 * modules to apply and remove differnces must be declared here
 * ------------------------------------------------------------
 * the full stuff must be provided here, since we want to use the classes
 * as member types in the TDAT2 compression classes.
 */

namespace differences {

class Tapply_diff { 
  public:
    Tapply_diff(): Mxold(0) { }
    int operator()(const intT& x) 
    { 
      intT xold=Mxold;
      Mxold=x;
      return(x-xold); 
    }
    intT previous_value() const { return(Mxold); }
  private:
    intT Mxold;
}; // Tapply_diff


class Tremove_diff { 
  public:
    Tremove_diff(): Mxold(0) { }
    intT operator()(const intT& x) 
    { return(Mxold=Mxold+x); }
    intT previous_value() const { return(Mxold); }
  private:
    intT Mxold;
}; // Tremove_diff

template<int n, class OP>
class Tdiff_operator {
  public:
    intT operator()(const intT& val) { return(Mop(Mdiff(val))); }
    void report_status(std::ostream& os) const
    {
      Mdiff.report_status(os);
      os << "operator of order " << n 
        << " holds value: " << Mop.previous_value() << std:: endl;
    }
  private:
    OP Mop;
    Tdiff_operator<n-1, OP> Mdiff;
}; // Tdiff_operator<n, OP>

template<class OP>
class Tdiff_operator<0, OP> {
  public:
    intT operator()(const intT& val) { return(val); }
    void report_status(std::ostream& os) const
    {
      os << "operator of order 0 just returns values" << std::endl;
    }
}; // Tdiff_operator<0, OP>

} // namespace differences

typedef differences::Tdiff_operator<1, differences::Tapply_diff> 
  apply1stdiffT;
typedef differences::Tdiff_operator<2, differences::Tapply_diff> 
  apply2nddiffT;
typedef differences::Tdiff_operator<1, differences::Tremove_diff> 
  remove1stdiffT;
typedef differences::Tdiff_operator<2, differences::Tremove_diff> 
  remove2nddiffT;

/*======================================================================*/
/*
 * All stuff for DAT2 reading and writing
 * --------------------------------------
 */

class TDAT2sum {
  public:
    const TCHK2& checksum() const { return(Mchecksum); }
    intT nread() const { return(Mnsamp); }
    intT msamp() const { return(Mmsamp); }
    bool hot() const { return((Mnsamp<Mmsamp)); }
    static const char* const GSEID;
  protected:
    TDAT2sum(const intT& msamp): Mnsamp(0), Mmsamp(msamp) { }
    void add(const intT& value);
  private:
    TCHK2 Mchecksum;
    intT Mnsamp;
    intT Mmsamp;
}; // TDAT2sum

// inline add function
inline void TDAT2sum::add(const intT& value)
{
  Mchecksum.add(value);
  ++Mnsamp;
}

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

class TDAT2read: public TDAT2sum
{
  public:
    virtual ~TDAT2read() { }
    intT operator()(std::istream& is);
  protected:
    TDAT2read(const intT& msamp):
      TDAT2sum(msamp) { }
  private:
    virtual intT convert(std::istream& is) = 0;
  protected:
}; // TDAT2read

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

class TDAT2write: public TDAT2sum
{
  public:
    virtual ~TDAT2write() { }
    std::string operator()(const intT& value);
  protected:
    TDAT2write(const intT& msamp, const intT& linelength):
      TDAT2sum(msamp), Mlinelength(linelength), Mcpos(0) { }
  private:
    virtual std::string convert(const intT& value) = 0;
  protected:
    intT Mlinelength;
    intT Mcpos;
}; // TDAT2write

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

class TDAT2readCM6: public TDAT2read
{
  public:
    virtual ~TDAT2readCM6() { }
    TDAT2readCM6(const intT& msamp):
      TDAT2read(msamp) { }
  private:
    intT convert(std::istream& is);
  private:
    remove2nddiffT Mremovediff;
}; // TDAT2readCM6

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

class TDAT2writeCM6:public TDAT2write
{
  public:
    virtual ~TDAT2writeCM6() { }
    TDAT2writeCM6(const intT& msamp, const intT& linelength=80):
      TDAT2write(msamp, linelength) { }
  private:
    std::string convert(const intT& value);
  private:
    apply2nddiffT Mapplydiff;
}; // TDAT2writeCM6

/*======================================================================*/

} // namespace waveform

/*======================================================================*/
/*
 * GSE2 helper functions
 * ---------------------
 */

template<class C>
bool GSEIDmatch(const std::string& line)
{ return(line.substr(0,4)==std::string(C::GSEID)); }

} // namespace GSE2

#endif // TF_GSEXX_H_VERSION (includeguard)

/* ----- END OF gsexx.h ----- */