tscollection.h

Go to the documentation of this file.

// include guard
#ifndef TS_TSCOLLECTION_H_VERSION

#define TS_TSCOLLECTION_H_VERSION \
  "TS_TSCOLLECTION_H   V1.0"

#include<vector>
#include<tsxx/error.h>
#include<tsxx/wid2timeseries.h>

namespace ts {

  template<typename T>
    class TimeSeriesCollection: 
      public std::vector<TimeSeries<aff::Series<T>, ::sff::WID2> >
  {
    public:
      typedef T Tvalue;
      typedef aff::Series<Tvalue> Tseries;
      typedef ::sff::WID2 Theader;
      typedef ts::TimeSeries<Tseries, Theader> Ttimeseries;
      typedef ts::TimeSeries<typename Tseries::Tcoc, Theader> Tconsttimeseries;
      typedef std::vector<Ttimeseries> Tbase;
      
      bool are_consistent(const ::sff::WID2compare comparer) const;
      bool overlap() const;
      void synchronize_nsamples();
      void trim_to_date();
      void trim_to_nsamples();

  }; // class TimeSeriesCollection

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

  template<typename T>
    bool TimeSeriesCollection<T>::are_consistent(const ::sff::WID2compare comparer) const
    {
      bool retval=true;
      if (this->size() > 1)
      {
        typename Tbase::const_iterator i_series=this->begin();
        Theader refheader=i_series->header;
        ++i_series;
        while ((i_series != this->end()) && retval)
        {
          retval=comparer(refheader, i_series->header);
          ++i_series;
        }
      }
      return(retval);
    } // bool TimeSeriesCollection<T>::are_consistent(const ::sff::WID2compare comparer) const

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

  template<typename T>
    bool TimeSeriesCollection<T>::overlap() const
    {
      bool retval=true;
      if (this->size() > 1)
      {
        typename Tbase::const_iterator i_series=this->begin();
        Theader header=i_series->header;
        libtime::TAbsoluteTime begin=header.date;
        libtime::TAbsoluteTime end=::sff::wid2lastsample(header);
        ++i_series;
        while ((i_series != this->end()) && retval)
        {
          header=i_series->header;
          libtime::TAbsoluteTime thisbegin=header.date;
          libtime::TAbsoluteTime thisend=::sff::wid2lastsample(header);
          begin = thisbegin > begin ? thisbegin : begin;
          end = thisend < end ? thisend : end;
          ++i_series;
        }
        retval=(end >= begin);
      }
      return(retval);
    } // bool TimeSeriesCollection<T>::overlap() const

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

  template<typename T>
    void TimeSeriesCollection<T>::synchronize_nsamples() 
    {
      typename Tbase::iterator i_series=this->begin();
      while (i_series != this->end())
      {
        const unsigned int& header_nsamples=i_series->header.nsamples;
        unsigned int series_nsamples=i_series->size();
        unsigned int nsamples=
          series_nsamples < header_nsamples 
          ? series_nsamples : header_nsamples;
        i_series->header.nsamples=nsamples;
        i_series->setlastindex(i_series->f()+nsamples-1);
        ++i_series;
      }
    } // void TimeSeriesCollection<T>::synchronize_nsamples() 

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

  template<typename T>
    void TimeSeriesCollection<T>::trim_to_date() 
    {
      if (this->size() > 1)
      {
        // find lastest start date
        typename Tbase::iterator i_series=this->begin();
        Theader header=i_series->header;
        libtime::TAbsoluteTime begin=header.date;
        ++i_series;
        while (i_series != this->end())
        {
          header=i_series->header;
          libtime::TAbsoluteTime thisbegin=header.date;
          begin = thisbegin > begin ? thisbegin : begin;
          ++i_series;
        }

        // adjust series and header
        i_series=this->begin();
        while (i_series != this->end())
        {
          header=i_series->header;
          long int index_offset=wid2isample(header, begin);
          TSXX_assert(index_offset >= 0,
                      "inconsistent header data");
          TSXX_assert(index_offset < header.nsamples,
                      "time series does not overlap with others");
          i_series->header.date=wid2isample(header, index_offset);
          i_series->header.nsamples -= index_offset;
          i_series->setfirstindex(i_series->f()+index_offset);
          ++i_series;
        }
      }
    } // void TimeSeriesCollection<T>::trim_to_date() 

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

  template<typename T>
    void TimeSeriesCollection<T>::trim_to_nsamples() 
    {
      this->synchronize_nsamples();
      if (this->size() > 1)
      {
        // find smallest number of samples in collection
        typename Tbase::iterator i_series=this->begin();
        Theader header=i_series->header;
        unsigned int nsamples=header.nsamples;
        ++i_series;
        while (i_series != this->end())
        {
          header=i_series->header;
          unsigned int thisnsamples=header.nsamples;
          nsamples = thisnsamples < nsamples ? thisnsamples : nsamples;
          ++i_series;
        }

        // adjust number of samples
        i_series=this->begin();
        while (i_series != this->end())
        {
          i_series->header.nsamples = nsamples;
          i_series->setlastindex(i_series->f()+nsamples-1);
          ++i_series;
        }
      }
    } // void TimeSeriesCollection<T>::trim_to_nsamples() 

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

} // namespace ts

#endif // TS_TSCOLLECTION_H_VERSION (includeguard)

/* ----- END OF tscollection.h ----- */