read()

Tiseries datrw::imseedstream::read ( const bool &  skipdata = false )

private

read file

read next trace from file.

All reading is controlled within this function...

File reading always is one record ahead. The record being read in advance is stored in member field imseedstream::Mrecord. This type of operation is necessary, since data data contiguity can only be checked after the next record has been read. If this record is not contiguous, it must be stored for the next read request, where it will provide the first samples of the next trace.

Reading is done as follows:

1. Data records are read from input as long as the next record read is contiguous to the previous one. They are intermediately stored in a vector.
2. After having read all contiguous records, the total number of samples in the trace is established and data samples can be collected in a series container.

Definition at line 194 of file imseedstream.cc.

References datrw::mseed::key::data, datrw::mseed::Record::data, DATRW_assert, DATRW_debug, datrw::hpmo::dt(), Mchecks, datrw::idatstream::Mdebug, Mdumpascii, MestimateNframes, datrw::idatstream::Mis, Mrecord, Mttolerance, datrw::hpmo::nsamples, datrw::mseed::Record::read(), datrw::idatstream::setlast(), datrw::idatstream::setwid2(), datrw::mseed::Record::valid, datrw::mseed::Record::wid2, and datrw::mseed::Record::xm1.

Referenced by dseries(), fseries(), iseries(), and skipseries().

  {
    DATRW_debug(Mdebug, "imseedstream::read", "entered reading function");

    // define vector of records, where input data are collected
    typedef std::vector<Tiseries> Tvecofrecorddata;
    Tvecofrecorddata vecofrecorddata;

    // abort is last record recently read from file is not valid
    // this indicates that the last reading operation arrived at the end of
    // file
    DATRW_assert(Mrecord.valid,
                   "invalid record; passed end of file?");

    /* The record present in this->Mrecord form the beginning of the next
     * trace. Its WID2 header defines the trace to be read. Only records
     * matching this header may be added to the current trace. The this as a
     * base.
     */
    sff::WID2 wid2line=Mrecord.wid2;
    libtime::TRelativeTime dt=libtime::double2time(wid2line.dt);

    /* Define a WID2 comparison instance to check whether WID headers of
     * subsequent record match the header of the total trace being assembled.
     */
    sff::WID2compare wid2areequal(sff::Fdate    
                                  | sff::Fstation
                                  | sff::Fchannel 
                                  | sff::Fauxid   
                                  | sff::Fdt      
                                  | sff::Fcalib   
                                  | sff::Fcalper  
                                  | sff::Finstype 
                                  | sff::Fhang     
                                  | sff::Fvang);  
    // set date tolerance
    wid2areequal.setdatetolerance(this->Mttolerance*1.e-6/wid2line.dt);
     
    /* collect data
     * ------------
     * Read record sequentially from file and check whether the recently read
     * record is part of the trace. Count the number of samples while doing
     * this.
     */
    DATRW_debug(Mdebug, "imseedstream::read", "collect data");

    sff::WID2 nextwid2=wid2line;

    int nsamples=0;
    bool contiguous=true;

    while(Mrecord.valid && Mis.good() && contiguous)
    {
      DATRW_debug(Mdebug, "imseedstream::read", 
                 "save data from record (" 
                 << Mrecord.data.size() << " samples)");
      
      Tiseries data=Mrecord.data;
      if (!skipdata) { vecofrecorddata.push_back(data.copyout()); }
      
      DATRW_debug(Mdebug, "imseedstream::read", "last data index " <<
                 data.last());
      
      /*
       * Remember value of last sample in previous record to be compared to
       * retrospect value derived from the succeeding record. A mismatch will
       * indicate non-contiguous data.
       */
      int xm1=data(data.last());
      nsamples += Mrecord.wid2.nsamples;
      nextwid2.date=wid2line.date+dt*nsamples;
      
      DATRW_debug(Mdebug, "imseedstream::read", "read next");
      
      Mrecord.read(Mis, Mdumpascii, MestimateNframes, Mchecks);

      DATRW_debug(Mdebug, "imseedstream::read", "compare next");
      DATRW_debug(Mdebug, "imseedstream::read", "expected wid2: " <<
                 nextwid2.line());
      DATRW_debug(Mdebug, "imseedstream::read", "    this wid2: " <<
                 Mrecord.wid2.line());
      
      if (Mrecord.valid)
      {
        if (! (wid2areequal(Mrecord.wid2, nextwid2) && (xm1 == Mrecord.xm1)))
        { 
          contiguous=false; 
          DATRW_debug(Mdebug, "imseedstream::read", "non-contiguous data");
        }
        else
        {
          DATRW_debug(Mdebug, "imseedstream::read", "data is still contiguous");
        }
      }
      else
      {
        // reading has met the end of file
        contiguous=false;
        this->setlast();
      }
    }
    wid2line.nsamples=nsamples;

    // extract data samples
    DATRW_debug(Mdebug, "imseedstream::read", "extract data");
    Tiseries series;
    if (!skipdata)
    {
      DATRW_debug(Mdebug, "imseedstream::read", "do not skip");
      Tvecofrecorddata::const_iterator I(vecofrecorddata.begin());
      DATRW_debug(Mdebug, "imseedstream::read", "create buffer");
      series=Tiseries(0,nsamples-1);
      nsamples=0;
      DATRW_debug(Mdebug, "imseedstream::read", "cycle vector");
      while (I != vecofrecorddata.end())
      {
        DATRW_debug(Mdebug, "imseedstream::read", "create dest");
        Tiseries dest=aff::subarray(series)(nsamples,nsamples+I->size()-1);
        DATRW_debug(Mdebug, "imseedstream::read", "copy to dest");
        dest.copyin(*I);
        DATRW_debug(Mdebug, "imseedstream::read", "step nsamples");
        nsamples += I->size();
        ++I;
      }
    }

    // set headers
    this->setwid2(wid2line);
    return (series);
  } // Tiseries imseedstream::read(const bool& skipdata)

Here is the call graph for this function:

Here is the caller graph for this function: