settimes()

void datrw::su::SUheader::settimes

(

)

set time values correctly

set time values

Definition at line 426 of file suheader.cc.

References datrw::su::TraceHeaderStruct::d1, DATRW_assert, DATRW_debug, datrw::su::TraceHeaderStruct::delrt, datrw::su::TraceHeaderStruct::dt, datrw::su::options::TemporalSampling::forceseismic, datrw::su::options::TemporalSampling::forceultrasonic, Mdebug, Mhassrce, Mhaswid2, Mheader, Mheadercontrol, Msrcedate, Mwid2date, Mwid2dt, and datrw::su::options::SUHeaderControl::temporalsampling.

Referenced by set().

    {
      // report inpu data for debugging
      DATRW_debug(Mdebug,
                  "ERROR SUheader::settimes: ",
                  "set times: Mhaswid2 " << Mhaswid2
                  << " Mhassrce " << Mhassrce);
      DATRW_debug(Mdebug && Mhaswid2,
                  "ERROR SUheader::settimes: ",
                  "WID2 time: " << Mwid2date.timestring()
                  << " WID2 dt: " << Mwid2dt);
      DATRW_debug(Mdebug && Mhassrce,
                  "ERROR SUheader::settimes: ",
                  "SRCE time: " << Msrcedate.timestring());
      // check whether evaluation of this function makes sense at all
      DATRW_assert(Mhaswid2 || Mhassrce,
                   "ERROR SUheader::settimes: "
                   "function called at wrong instance");

      // ultrasonic flag is required for setting delrt
      bool ultrasonic=false;
      // set sampling interval if WID2 data is present
      // ---------------------------------------------
      if (Mhaswid2)
      {
        DATRW_assert(this->Mwid2dt>0,
                     "received non-positive sampling interval");
        // evaluate dt and check for ultrasonic data
        double dtfactor=1.e6;
        double scaleddt=nearbyint(dtfactor*this->Mwid2dt);
        if (Mheadercontrol.temporalsampling.forceseismic
            || Mheadercontrol.temporalsampling.forceultrasonic)
        {
          if (Mheadercontrol.temporalsampling.forceultrasonic)
          {
            ultrasonic=true;
            dtfactor=1.e9;
            scaleddt=nearbyint(dtfactor*this->Mwid2dt);
            DATRW_debug(Mdebug,
                        "SUheader::settimes",
                        "ultrasonic scaling is forced");
          }
          else
          {
            DATRW_debug(Mdebug,
                        "SUheader::settimes",
                        "seismic scaling is forced");
          }
        }
        else
        {
          if ((!ultrasonic) && scaleddt <1.)
          {
            ultrasonic=true;
            dtfactor=1.e9;
            scaleddt=nearbyint(dtfactor*this->Mwid2dt);
            DATRW_debug(Mdebug,
                        "SUheader::settimes",
                        "ultrasonic scaling because of dt "
                        << scaleddt << "ns value");
          }
          else
          {
            DATRW_debug(Mdebug,
                        "SUheader::settimes",
                        "seismic scaling because of dt "
                        << scaleddt << "us value");
          }
        }
        if (scaleddt > USHRT_MAX)
        {
          std::cerr << "received sampling interval: " << scaleddt;
          if (ultrasonic)
          {
            std::cerr << " ns";
          }
          else
          {
            std::cerr << " us";
          }
          std::cerr << std::endl;
        }
        DATRW_assert(scaleddt <= USHRT_MAX,
                     "ERROR (SUheader::set): "
                     "sampling interval cannot be represented by "
                     "a field of type unsigend short");
        Mheader.dt=static_cast<unsigned short>(scaleddt);
        Mheader.d1=0.;
        if (ultrasonic) 
        { Mheader.d1=static_cast<double>(Mheader.dt)/dtfactor; }
      }

      // set source time and trigger delay
      // ---------------------------------
      if (Mhaswid2 && Mhassrce)
      {
        libtime::TRelativeTime del=Mwid2date-Msrcedate;
        this->set(Msrcedate);
        double delfactor=1.e3;
        if (ultrasonic) { delfactor=1.e6; }
        double delvalue=std::floor(delfactor*libtime::time2double(del));
        if (Mwid2date<Msrcedate) { delvalue *= -1.; }
        DATRW_assert(((delvalue >= SHRT_MIN) && (delvalue <= SHRT_MAX)),
                     "ERROR (SUheader::set): "
                     "trigger delay cannot be represented by "
                     "a field of type short.");
        this->Mheader.delrt=static_cast<short>(delvalue);
      }
      else if (Mhaswid2)
      {
        this->set(Mwid2date);
        this->Mheader.delrt=0;
      }
      else if (Mhassrce)
      {
        this->set(Msrcedate);
        this->Mheader.delrt=0;
      }
    } // void SUheader::settimes();

Here is the caller graph for this function: