trace.hpp

/* trace.hpp */
/* $Id: trace.hpp 22204 2013-07-11 13:40:55Z urij $ */
#ifndef __trace_hpp
#define __trace_hpp

#include <cstddef>
#include <string>
#include <vector>
#include <map>

union TrHdrAttrVal;

class Trace
{
public:
  
  /*
   * Basic types. 
   */
  typedef float AmplT;                                   
  typedef float TimeT;                                   
  typedef float OffsetT;                                 
  typedef std::vector<AmplT> AmplsStorageT;              
  typedef AmplsStorageT::iterator iterator;              
  typedef AmplsStorageT::const_iterator const_iterator;  
  class Header
  {
  public: 
    
    enum AttrId
      {
    TA_NTR = 0,  
    TA_NMGL,     
    TA_NSP,      
    TA_NSL,      
    TA_NSS,      
    TA_NRP,      
    TA_NRL,      
    TA_NRS,      
    TA_NDP,      
    TA_XSP,      
    TA_YSP,      
    TA_ZSP,      
    TA_XOP,      
    TA_YOP,      
    TA_ZOP,      
    TA_L,        
    TA_HCAB,     
    TA_COMP,     
    TA_TFB,      
    TA_PSC_STRIDE,   
    TA_PSC_DIR,      
    TA_PSC_QMINNEG,  
    TA_PSC_QMAXPOS,  
    TA_RESERVE_0,  
    TA_RESERVE_1,  
    TA_RESERVE_2,  
    TA_RESERVE_3,  
    TA_RESERVE_4,  
      };
    
    static std::string toString(const AttrId &attr);
    
    Header();
    
    Header(TimeT i_t0, TimeT i_timestep, OffsetT i_offset);
    
    bool compatiable(const Header &hdr) const;
    
    bool operator==(const Header &hdr) const;
    
    
    template <typename T>
    void setAttr(AttrId id, const T& value);
    
    template <typename T>
    const T& getAttrValue(AttrId id, bool *result = 0x0) const;
    
    bool hasAttr(AttrId id) const;

    void clearAttrs();
    
    
    bool hasNAN(); 
    
    bool hasInf();
    
    bool hasNANInf();
    
    
    TimeT t0;
    
    TimeT timestep;
    
    OffsetT offset;
    
    std::map<AttrId, TrHdrAttrVal> m_attrs;
    
  private:
    
    static TrHdrAttrVal m_tmp_attribute;
  };
  
  /*
   * Operators.
   */
  
  const AmplT& operator[](size_t n) const {return at(n);}
  
  AmplT& operator[](size_t n) {return at(n);}
  
  Trace& operator=(const Trace &tr);

  bool operator==(const Trace &tr) const;
  
  Trace operator+(const Trace &tr) const;
  
  Trace operator-(const Trace &tr) const;
  
  Trace&   operator+=(const Trace& that);
  Trace&   operator-=(const Trace& that);
  Trace&   operator*=(AmplT value);
  Trace&   operator/=(AmplT value);
  
  /*
   * Constructors. 
   */
  
  Trace();
  
  explicit Trace(const Header &hdr);
  
  Trace(const Header &hdr, size_t size, AmplT ampl);
  
  template <typename Iterator>
  Trace(const Header &hdr, Iterator first, Iterator last)
  {m_hdr = hdr; m_ampls = AmplsStorageT(first, last);}
  
  Trace(const Trace &tr);
  
  Trace* clone() const;
    
  virtual ~Trace();

  /*
   * Accesors. 
   */
  
  const Header& header() const {return m_hdr;}
  
  const_iterator begin() const;
  const_iterator end() const;
  
  const AmplT& at(size_t n) const;
  
  size_t size() const;
  
  TimeT duration() const;
      
  /*
   *  Modificators. 
   */
  
  Header& header() {return m_hdr;}
  
  iterator begin();
  iterator end();
  
  AmplT& at(size_t n);
  
  void clear();
  
  void resize(size_t n, AmplT ampl = 0.);
  
  void erase(iterator first, iterator last);
  
  void shift(TimeT s);
  
  void shift_old(TimeT s);
  
  static void applyKin(Trace &trace,                          
               const std::vector<AmplT> &tsrc,        
               const std::vector<AmplT> &tres,        
               const double &max_shift_ratio = 10e+6  );
  
  static void expand(Trace &trace, size_t n1, size_t n2, Trace::AmplT ampl = 0.);
  
  static void reduce(Trace &trace, size_t n1, size_t n2);
    
  void fill(const AmplT &ampl);
  
  /*
   *  Working with windows. 
   */
  
  const Trace& set_window(TimeT start, TimeT duration) const;
  
  TimeT get_window_start() const;

  TimeT get_window_duration() const;

  void remove_window() const;

  bool is_windowed() const;
  
  
  /*
   *  Check data correctness. 
   */
  
  bool hasNAN(); 
  
  bool hasInf();
  
  bool hasNANInf();
  
protected:

  Header m_hdr;
  
  AmplsStorageT m_ampls; 

  struct Window
  {
    size_t left;   
    size_t right;  
  };

  mutable std::vector<Window> m_win_stack;
};

#ifdef GE_BUILD
#include <trace_inline.hpp>
#else
#include <s2proc/trace_inline.hpp>
#endif

#endif /* trace.hpp */