structgapanalysis.h

Go to the documentation of this file.

// include guard
#ifndef TF_STRUCTGAPANALYSIS_H_VERSION

#define TF_STRUCTGAPANALYSIS_H_VERSION \
  "TF_STRUCTGAPANALYSIS_H   V1.1"

#include <tfxx/stringfunc.h>
#include <libtime++.h>
#include <list>
#include <vector>
#include <iostream>

struct Contiguous {
  libtime::TAbsoluteTime first, last;
  libtime::TRelativeTime dt;
  std::string station, channel, auxid;
}; // struct Contiguous

typedef std::list<Contiguous> TContiguouslist;

struct Gapid {
  Gapid() { }
  Gapid(const Contiguous& c):
    ID(tfxx::string::trimws(c.channel)
       +":"+tfxx::string::trimws(c.station)
       +":"+tfxx::string::trimws(c.auxid)), 
    dt(c.dt), Mstation(c.station), Mchannel(c.channel), Mauxid(c.auxid)
  { }
  bool operator==(const Gapid& other) const
  { return((this->ID == other.ID) && (this->dt == other.dt)); }
  bool operator!=(const Gapid& other) const
  { return(!this->operator==(other)); }
  std::string ID;
  libtime::TRelativeTime dt;
  std::string station() const { return Mstation; }
  std::string channel() const { return Mchannel; }
  std::string auxid() const { return Mauxid; }
  private:
  std::string Mstation, Mchannel, Mauxid;
}; // struct Gapid

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

struct Gap {
  // true, if no sample is missing (just a break in contiguous data)
  bool isbreak() const { return (last<=(first+ID.dt)); }
  // time span from first missing sample to last missing sample + one sample
  // interval (represents gaps size in terms of missing sample intervals)
  libtime::TRelativeTime tmissing() const 
  { 
    libtime::TRelativeTime retval(0);
    if (!this->isbreak()) { retval=last-first+ID.dt; }
    return(retval); 
  }
  // number of missing samples, taking irregular sampling into account
  unsigned int nmissing() const 
  { 
    unsigned int retval=0;
    if (!this->isbreak()) { retval=(this->tmissing()+(ID.dt/2))/ID.dt; }
    return retval;
  }
  // data
  libtime::TAbsoluteTime first, last;
  Gapid ID;
}; // struct Gap

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

struct Gapsummary {
  Gapsummary(const libtime::TAbsoluteTime& earliest,
             const libtime::TAbsoluteTime& latest,
             const libtime::TRelativeTime& indt)
    : ngaps(0), nbreaks(0), nmissing(0), nexpected(1+((latest-earliest)/indt)),
    tspan(latest-earliest), tmissing(0), dt(indt)
  { }
  unsigned int ngaps;
  unsigned int nbreaks;
  unsigned int nmissing;
  unsigned int nexpected;
  libtime::TRelativeTime tspan;
  libtime::TRelativeTime tmissing;
  libtime::TRelativeTime dt;
}; // struct Gapsummary

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

struct Gapsofstream {
  typedef std::vector<Gap> Tvecofgap;
  Gapsofstream(const Gapid& id,
               const libtime::TAbsoluteTime& earliest,
               const libtime::TAbsoluteTime& latest)
    : ID(id), Mearliest(earliest), Mlatest(latest)
  {
    this->gap.clear(); 
  }
  Gapsummary summarize() const;
  Gapid ID;
  Tvecofgap gap;
  private: 
    libtime::TAbsoluteTime Mearliest;
    libtime::TAbsoluteTime Mlatest;
}; // struct Gapsofstream 

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

typedef std::vector<Gapsofstream> Tvecofgaps;

/*----------------------------------------------------------------------*/
// output operators
  
std::ostream& operator<<(std::ostream& os, const Gapid& id);

std::ostream& operator<<(std::ostream& os, const Contiguous& chunk);

std::ostream& operator<<(std::ostream& os, const Gap& gap);

#endif // TF_STRUCTGAPANALYSIS_H_VERSION (includeguard)

/* ----- END OF structgapanalysis.h ----- */