RawVtmTimeInfoBlock.cxx

Go to the documentation of this file.

// $Id: RawVtmTimeInfoBlock.cxx,v 1.5 2005/06/07 21:47:32 rhatcher Exp $
// 
// RawVtmTimeInfoBlock 
// 
// RawVtmTimeInfoBlock holds a latched time counter in NearDet VTM
//
// Author:  R. Hatcher 2003.02.18
//

#include "RawData/RawVtmTimeInfoBlock.h"

enum EDebugVtmTimeInfoBlock {
   kdbg_ForceHexDump  = 0x0001
};
UInt_t RawVtmTimeInfoBlock::fgDebugFlags = 0;

#include <vector>

#include "MessageService/MsgStream.h"
#include "MessageService/MsgService.h"
#include "MessageService/MsgFormat.h"
CVSID("$Id: RawVtmTimeInfoBlock.cxx,v 1.5 2005/06/07 21:47:32 rhatcher Exp $");

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawVtmTimeInfoBlock,kMdBlockVtmTimeInfo,0);

ClassImp(RawVtmTimeInfoBlock)

enum EVtmTimeInfoBlkPos {
   indx_size          =  0,
   indx_checksum      =  1,
   indx_blockid       =  2,
   indx_run           =  3,
   indx_subrun        =  4,
   indx_runtype       = indx_subrun,
   indx_sec           =  5,
   indx_nsec          =  6,
   indx_crateid       =  7,
   indx_tf            =  8,
   indx_lastrfclock   =  9,
   indx_spilltimerf   = 10,
   indx_spilltimegps  = 11,
   indx_clockstatus   = 12,
   indx_endlasttf     = 13,
   zzzz_last          = 14
};

//_____________________________________________________________________________
RawVtmTimeInfoBlock::RawVtmTimeInfoBlock()
  : RawDataBlock(), fCrateId()
{
   // Default constructor
}

//_____________________________________________________________________________
RawVtmTimeInfoBlock::RawVtmTimeInfoBlock(const Int_t *block)
  : RawDataBlock(block), fCrateId()
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   //  3   run #
   //  4   subRunAndType
   //  5   timestamp sec
   //  6   timestamp nsec
   //  7   crateIdentifier
   //  8   timeFrameNumber
   //  9   lastRFClock
   // 10   spillTimeRF
   // 11   spillTimeGPS
   // 12   clockStatus   (version 2 and above)
   // 13   endLastTF     (version 3 and above)

}

//_____________________________________________________________________________
RawVtmTimeInfoBlock::~RawVtmTimeInfoBlock()
{
  // dtor
}

//____________________________________________________________________________
RawVtmTimeInfoBlock& RawVtmTimeInfoBlock::operator=(const RawVtmTimeInfoBlock& rhs)
{
   // deep copy assignment 
   if (this != &rhs) {
     RawDataBlock::operator=(rhs);
     fCrateId = rhs.fCrateId;
   }
   return *this;
}

//_____________________________________________________________________________
VldTimeStamp RawVtmTimeInfoBlock::GetTimeStamp() const
{
   // get the timestamp
   if (fSize > indx_nsec) 
      return VldTimeStamp(fRawBlock[indx_sec],fRawBlock[indx_nsec]);

   return VldTimeStamp((time_t)0,(Int_t)0);
}

//_____________________________________________________________________________
Int_t RawVtmTimeInfoBlock::GetRun() const
{
   // get the run number
   if (fSize > indx_run) return fRawBlock[indx_run];
   return -1;
}

//_____________________________________________________________________________
Short_t RawVtmTimeInfoBlock::GetSubRun() const
{
   // get the subrun number
   if (fSize > indx_subrun) return (fRawBlock[indx_subrun]>>16)&0xffff;
   return -1;
}

//_____________________________________________________________________________
Short_t RawVtmTimeInfoBlock::GetRunType() const
{
   // get the run type
   if (fSize > indx_runtype) return fRawBlock[indx_runtype]&0xffff;
   return -1;
}

//_____________________________________________________________________________
Int_t RawVtmTimeInfoBlock::GetCrateIdInfo() const
{
   // get the crate id info (packed)
   if (fSize > indx_crateid) return fRawBlock[indx_crateid];
   return -1;
}

//_____________________________________________________________________________
Int_t RawVtmTimeInfoBlock::GetTimeFrameNum() const
{
   // get the time frame
   if (fSize > indx_tf) return fRawBlock[indx_tf];
   return -1;
}

//_____________________________________________________________________________
Int_t RawVtmTimeInfoBlock::GetLastRFClock() const
{
   // get the RF clock counter at end of time frame
   if (fSize > indx_lastrfclock) return fRawBlock[indx_lastrfclock];
   return -1;
}

//_____________________________________________________________________________
Int_t RawVtmTimeInfoBlock::GetSpillTimeRF() const
{
   // get the latched timestamp counter at spill gate
   if (fSize > indx_spilltimerf) return fRawBlock[indx_spilltimerf];
   return -1;
}

//_____________________________________________________________________________
Int_t RawVtmTimeInfoBlock::GetSpillTimeGPS() const
{
   // get the latched GPS 10Mhz dounter at spill gate
   if (fSize > indx_spilltimegps) return fRawBlock[indx_spilltimegps];
   return -1;
}

//_____________________________________________________________________________
Int_t RawVtmTimeInfoBlock::GetClockStatus() const
{
   // get the latched bits from each mtm and vtm
   const Int_t badValue = -1;
   if (GetMinorId() <= 1 || fSize <= indx_clockstatus) {
     MSG("RawData",Msg::kWarning)
       << "GetClockStatus() not available fSize " << fSize
       << " MinorId " << GetMinorId() << endl;
     return badValue;
   }
   return fRawBlock[indx_clockstatus];
}

//_____________________________________________________________________________
Bool_t RawVtmTimeInfoBlock::VtmInError() const
{
  // return whether the was in an error state
  Int_t status = GetClockStatus();
  // the modules are bits 0-14, vtm is bit 15
  return ((1<<15) & status);
}

//_____________________________________________________________________________
Bool_t RawVtmTimeInfoBlock::ModuleInError(UShort_t indx) const
{
  // return whether a module was in an error state
  Int_t status = GetClockStatus();
  // the modules are only bit 0-14
  if (indx > 14) return true;
  return ((1<<indx) & status);
}

//_____________________________________________________________________________
std::vector<UShort_t> RawVtmTimeInfoBlock::ErrorModules() const
{
  // return list of module that were in the error state
  std::vector<UShort_t> mdlsInError;

  for (unsigned short mdl = 0; mdl < 15; ++mdl) {
    if ( ModuleInError(mdl) ) mdlsInError.push_back(mdl);
  }

  return mdlsInError;
}

//_____________________________________________________________________________
Int_t RawVtmTimeInfoBlock::GetLastRFClockFromPrevTF() const
{
   // get the RF clock at the counter reset on the previous time frame
   if (fSize > indx_endlasttf) return fRawBlock[indx_endlasttf];
   return -1;
}

//_____________________________________________________________________________
VldContext RawVtmTimeInfoBlock::GetVldContext() const
{
   // build validity context
  RawBlockId rbid = GetBlockId();
  return VldContext(rbid.GetDetector(),rbid.GetSimFlag(),GetTimeStamp());
}

//_____________________________________________________________________________
std::ostream& RawVtmTimeInfoBlock::FormatToOStream(ostream& os,
                                                   Option_t *option) const
{
   if (fgDebugFlags & kdbg_ForceHexDump) option = "x";

   RawDataBlock::FormatToOStream(os,option);
   if (option[0] == 'X') return os;

   // additional block specific formatted output is done here

   os << " TimeStamp " << GetTimeStamp().AsString("c")
      << " TimeFrame " << GetTimeFrameNum() << endl;
   os << " Run " << GetRun()
      << " SubRun " << GetSubRun()
      << " RunType " << GetRunType();
   int crateid = GetCrateIdInfo();

   os << " Crate " << (crateid&0x3f)
      << " (0x" << hex << crateid << dec << ") had: " << endl
      << " LastTimeStamp " << setw(8) << GetLastTimeStamp()
      << " SpillTimeRF "   << setw(8) << GetSpillTimeRF()
      << " SpillTimeGPS "  << setw(8) << GetSpillTimeGPS()
      << endl;

   int minor = GetMinorId();

   if (minor > 1) {
     os << " ClockStatus 0x" 
        << std::hex << std::setfill('0') 
        << setw(8) << GetClockStatus()
        << std::setfill(' ') << std::dec;

     if ( ! VtmInError() ) os << " Vtm Okay,";
     else                  os << " Vtm Error,";

     std::vector<UShort_t> mdlsInError = ErrorModules();
     unsigned int nerr = mdlsInError.size();
     if ( nerr == 0 ) os << " No Module Errors";
     else {
       if ( nerr == 1 ) os << " Error in Module " << mdlsInError[0];
       else {
         os << " Errors in Modules:";
         for (unsigned short i = 0; i < nerr; ++i)
           os << " " << mdlsInError[i];
       }
     }
     os << "." << endl;
   }
   if (minor > 2) {
     os << " LastRFClockFromPrevTF " 
        << setw(10) << GetLastRFClockFromPrevTF()
        << endl;
   }

   return os;
}

//_____________________________________________________________________________
void RawVtmTimeInfoBlock::FillCrateId() const
{
   // unpack crate info
   if (!fCrateId.IsNull()) return;
   fCrateId = RawChannelId(GetBlockId().GetDetector(),GetCrateIdInfo(),0x1fff);
}

//_____________________________________________________________________________

---