RawSnarlHeaderBlock.cxx

Go to the documentation of this file.

// $Id: RawSnarlHeaderBlock.cxx,v 1.17 2005/04/13 17:05:00 rhatcher Exp $
// 
// RawSnarlHeaderBlock 
// 
// RawSnarlHeaderBlock holds the Snarl Header info
//
// Author:  R. Hatcher 2001.05.01
//

#include "RawData/RawSnarlHeaderBlock.h"

UInt_t RawSnarlHeaderBlock::fgDebugFlags = 0;
enum DDebugRawSnarlHeaderBlock {
  kdbg_ForceHexDump = 0x00000001
};

#include "MessageService/MsgService.h"
//CVSID("$Id: RawSnarlHeaderBlock.cxx,v 1.17 2005/04/13 17:05:00 rhatcher Exp $");

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawSnarlHeaderBlock,kMdBlockSnarlHeader,0);

ClassImp(RawSnarlHeaderBlock)

enum ESnarlHeaderBlkPos {
   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_tf        =  7,
   indx_snarl     =  8,
   indx_trigsrc   =  9,
   indx_errcode   = 10,
   indx_nrdigit   = 11,
   indx_spilltype = 12,
   zzzz_last      = 13
};

//_____________________________________________________________________________
RawSnarlHeaderBlock::RawSnarlHeaderBlock()
{
   // Default constructor
}

//_____________________________________________________________________________
RawSnarlHeaderBlock::RawSnarlHeaderBlock(const Int_t *block)
   : RawDataBlock(block)
{
   //  stored block format is:
   //      version 0             version 1, 2
   //---   ---------------       ----------------      
   //  0   # words in block       # words in block     
   //  1   checksum               checksum             
   //  2   Block Id               Block Id             
   //---                                             
   //  3   run #                  run #                
   //  4   {subrun #| run type}   {subrun #| run type} 
   //  5   trigger time (sec)     trigger time (sec)   
   //  6   trigger time (nsec)    trigger time (nsec)  
   //  7   snarl #                timeframe #
   //  8   trigger source         snarl #              
   //  9   error code             trigger source       
   // 10                          error code 
   // 11                          # of raw digits in crate block ( >= v2 only )
   // 12                          remote spill type ( >= v3 only )
}
//_____________________________________________________________________________
RawSnarlHeaderBlock::RawSnarlHeaderBlock(const VldContext& vldc,
                       Int_t run, Short_t subrun, Short_t runtype,
                       Int_t timeframe, Int_t snarl, Int_t trigsrc, 
                       Int_t err, Int_t nrawdigits, Int_t spilltype)
   : RawDataBlock()
{
   // Component ctor

   fSize = zzzz_last;
   fRawBlock = new Int_t [fSize];

   fRawBlock[0] = fSize;
// fRawBlock[1] = checksum... see below

   RawBlockRegistry& rbr = RawBlockRegistry::Instance();
   RawBlockProxy*    rbp = rbr.LookUp("RawSnarlHeaderBlock");

   Bool_t isDCS   = rbp->IsDCS();
   Int_t  majorId = rbp->GetMajorId();
   Int_t  minorId = 3;  // latest and greatest minor version #
   RawBlockId rbid(majorId,minorId,isDCS,
                   vldc.GetDetector(),vldc.GetSimFlag());
   fRawBlock[2] = rbid.GetEncoded();

   fRawBlock[indx_run]       = run;
   fRawBlock[indx_subrun]    = (subrun&0xffff)<<16 | (runtype&0xffff);
   fRawBlock[indx_sec]       = vldc.GetTimeStamp().GetSec();
   fRawBlock[indx_nsec]      = vldc.GetTimeStamp().GetNanoSec();
   fRawBlock[indx_tf]        = timeframe;

   fRawBlock[indx_snarl]     = snarl;
   fRawBlock[indx_trigsrc]   = trigsrc;
   fRawBlock[indx_errcode]   = err;
   fRawBlock[indx_nrdigit]   = nrawdigits;
   fRawBlock[indx_spilltype] = spilltype;

   // fill checksum
   rdxsum_fill((long*)fRawBlock,0); 
}

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

//_____________________________________________________________________________
VldTimeStamp RawSnarlHeaderBlock::GetTriggerTime() const
{
   // get the trigger time
   if (fSize > indx_nsec) 
      return VldTimeStamp(fRawBlock[indx_sec],fRawBlock[indx_nsec]);

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

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

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

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

//_____________________________________________________________________________
Int_t RawSnarlHeaderBlock::GetTimeFrameNum() const
{
   // get the timeframe number
   if (GetMinorId() <= 0) return -1;  // didn't exist in this version
   if (fSize > indx_tf) return fRawBlock[indx_tf];
   return -1;
}

//_____________________________________________________________________________
Int_t RawSnarlHeaderBlock::GetSnarl() const
{
   // get the snarl number

   int indx_snarl_v = indx_snarl;
   if (GetMinorId() <= 0) indx_snarl_v--;
   if (fSize > indx_snarl_v) return fRawBlock[indx_snarl_v];
   return -1;
}

//_____________________________________________________________________________
Int_t RawSnarlHeaderBlock::GetTriggerSource() const
{
   // get the trigger source

   int indx_trigsrc_v = indx_trigsrc;
   if (GetMinorId() <= 0) indx_trigsrc_v--;
   if (fSize > indx_trigsrc_v) return fRawBlock[indx_trigsrc_v];
   return -1;
}

//_____________________________________________________________________________
Int_t RawSnarlHeaderBlock::GetErrorCode() const
{
   // get the trigger source

   int indx_errcode_v = indx_errcode;
   if (GetMinorId() <= 0) indx_errcode_v--;
   if (fSize > indx_errcode_v) return fRawBlock[indx_errcode_v];
   return -1;
}

//_____________________________________________________________________________
Int_t RawSnarlHeaderBlock::GetNumRawDigits() const
{
   // get the # of raw digits in crate readout block RawDigitDataBlock

   if (fSize > indx_nrdigit) return fRawBlock[indx_nrdigit];
   return -1;
}

//_____________________________________________________________________________
Int_t RawSnarlHeaderBlock::GetRemoteSpillType() const
{
   // get the remote spill type (only valid for appropriate triggers)

   if (fSize > indx_spilltype) return fRawBlock[indx_spilltype];
   return -1;
}

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

//_____________________________________________________________________________
std::ostream& RawSnarlHeaderBlock::FormatToOStream(std::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
   int minorid = GetMinorId();

   os << " TriggerTime " << GetTriggerTime().AsString("c") << endl;
   os << " Run " << GetRun() 
      << " SubRun " << GetSubRun() 
      << " RunType " << GetRunType();
   if (minorid > 0) {
      os << " TimeFrame " << GetTimeFrameNo();
   }
   os << endl; 
   os << " Snarl " << GetSnarl()
      << " TrigSource " << GetTriggerSource()
      << " ErrorCode " << GetErrorCode();
   if (minorid > 1) {
     os << " # RawDigits " << GetNumRawDigits();
   }
   if (minorid > 2) {
     os << " RemoteSpillType " << GetRemoteSpillType();
   }
   os << endl;

   return os;
}


//_____________________________________________________________________________

---