readtraceheader()

TraceHeader datrw::tfascii::readtraceheader	(	std::istream &	is,
		const bool &	verbose = false
	)

read the complete traceheader

Parameters

is	the input stream
verbose	for verbose output or not

Returns

the TraceHeader of the data

Definition at line 165 of file readtfascii.cc.

References DATRW_assert, datrw::tfascii::helper::extract(), datrw::tfascii::helper::extractvalue(), datrw::tfascii::TraceHeader::hasinfo, datrw::tfascii::TraceHeader::hastracefree, datrw::tfascii::TraceHeader::haswid2, datrw::tfascii::TraceHeader::info, datrw::tfascii::TraceHeader::tracefree, and datrw::tfascii::TraceHeader::wid2.

Referenced by datrw::itfasciistream::set_traceheader().

    {
      std::string line;
      TraceHeader traceheader;
      traceheader.hastracefree = false;
      traceheader.hasinfo = false;
      traceheader.haswid2 = false;
      
      while (is.good())
      {
        getline(is, line);
        // get WID2 lines if available
        if (line == "contents of SFF WID2 line:")
        {
          traceheader.haswid2 = true;
          if (verbose)
          {
            std::cout << "SFF WID2 line detected." << std::endl;
          }
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extract(line);
          std::istringstream iss(line);
          char c;
          int doy, day, month, year, hour, minute, secs, micsecs;
          iss >> doy;
          iss >> day >> c >> month >> c >> year;
          iss >> hour >> c >> minute >> c >> secs >> c >> micsecs;
          traceheader.wid2.date = libtime::TAbsoluteTime(year, 
                                                        month,
                                                        day,
                                                        hour,
                                                        minute,
                                                        secs,
                                                        0,
                                                        micsecs);
          DATRW_assert(doy == traceheader.wid2.date.doy(),
            "ERROR: inconsistent date values");
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line);
          traceheader.wid2.station = line; 
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line);
          traceheader.wid2.channel = line; 
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line);
          traceheader.wid2.auxid = line; 
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line);
          traceheader.wid2.instype = line; 
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line);
          traceheader.wid2.nsamples = std::atoi(line.c_str()); 
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line, true);
          traceheader.wid2.dt = std::atof(line.c_str()); 
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line);
          traceheader.wid2.calib = std::atof(line.c_str()); 
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line);
          traceheader.wid2.calper = std::atof(line.c_str()); 
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line, true);
          traceheader.wid2.hang = std::atof(line.c_str()); 
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line, true);
          traceheader.wid2.vang = std::atof(line.c_str()); 
        }
        // get INFO lines if available
        if (line == "contents of SFF INFO line:")
        {
          traceheader.hasinfo = true;
          if (verbose)
          {
            std::cout << "SFF INFO line detected." << std::endl;
          }
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line);
          if (line == "cartesian")
          {
            traceheader.info.cs = sff::CS_cartesian;
          } 
          else
          {
            traceheader.info.cs = sff::CS_spherical;
          }
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line, true);
          traceheader.info.cx = std::atof(line.c_str());
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line, true);
          traceheader.info.cy = std::atof(line.c_str());
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line, true);
          traceheader.info.cz = std::atof(line.c_str());
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line);
          traceheader.info.nstacks = std::atoi(line.c_str());
        }
        // get traceFREE block if available
        if (line == "contents of SFF FREE block:")
        {
          traceheader.hastracefree = true;
          if (verbose)
          {
            std::cout << "trace FREE block detected." << std::endl;
          }
          while (getline(is, line))
          {
            // break if stream reaches a empty line
            if (line.empty()) { break; }
            traceheader.tracefree.append(line); 
          }
        }
        // break if stream reaches data
        if (line == "data:") { break; }
      }

      return traceheader;
    } // function readtraceheader

Here is the call graph for this function:

Here is the caller graph for this function: