RawVaTimingMonitorBlock.cxx

Go to the documentation of this file.

// $Id: RawVaTimingMonitorBlock.cxx,v 1.5 2005/08/26 19:04:53 rhatcher Exp $
// 
// RawVaTimingMonitorBlock 
// 
// RawVaTimingMonitorBlock holds Va System Time Monitoring digits
//
// Author:  R. Hatcher 2004.05.13
//

#include "RawData/RawVaTimingMonitorBlock.h"

enum EDebugDigitDataBlock {
   dbg_DumpHeaderOnUnpack = 0x0001,
   dbg_DumpCrateOnUnpack  = 0x0002,
   dbg_DumpDigitOnUnpack  = 0x0004
};
UInt_t RawVaTimingMonitorBlock::fgDebugFlags = 0;

#include "RawData/RawCrateStatus.h"
#include "RawData/RawVaMCDigit.h"
#include "RawData/RawQieMCDigit.h"

#include "MessageService/MsgStream.h"
#include "MessageService/MsgFormat.h"

#include "MessageService/MsgService.h"
CVSID("$Id: RawVaTimingMonitorBlock.cxx,v 1.5 2005/08/26 19:04:53 rhatcher Exp $");

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawVaTimingMonitorBlock,kMdBlockVaTimingMonitor,0);

ClassImp(RawVaTimingMonitorBlock)

enum EVaTimingMonitorBlkPos {
   indx_size     =  0,
   indx_checksum =  1,
   indx_blockid  =  2,
   indx_run      =  3,
   indx_subrun   =  4,
   indx_runtype  =  indx_subrun,
   indx_loadsec  =  5,
   indx_loadnsec =  6,
   indx_crateid  =  7,
   indx_tf       =  8,
   indx_ndigits  =  -1,
   zzzz_last     =  9
};

//_____________________________________________________________________________
RawVaTimingMonitorBlock::RawVaTimingMonitorBlock()
  : fRawCrateStatus(0), fRawDigits(0)
{
   // Default constructor
}

//_____________________________________________________________________________
RawVaTimingMonitorBlock::RawVaTimingMonitorBlock(const Int_t *block)
  : RawDataBlock(block), fRawCrateStatus(0), fRawDigits(0)
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   //  3   Run Number
   //  4   SubRun | RunType
   //  5   Time (sec)
   //  6   Time (ns)
   //  7   CrateId (+ special bits)
   //  8   TimeFrame #
   //  8   # of digits to follow
   //  ... packed two 32-bit words per digit

}

//_____________________________________________________________________________
RawVaTimingMonitorBlock::~RawVaTimingMonitorBlock()
{
   // dtor
   if ( fRawDigits ) {
     fRawDigits->Delete();
     delete fRawDigits;
     fRawDigits = 0;
   }
   if ( fRawCrateStatus ) {
     delete fRawCrateStatus;
     fRawCrateStatus = 0;
   }

}

//____________________________________________________________________________
RawVaTimingMonitorBlock& RawVaTimingMonitorBlock::operator=(const RawVaTimingMonitorBlock& rhs)
{
   // deep copy assignment 
  if (this != &rhs) {
    RawDataBlock::operator=(rhs);
    if (fRawCrateStatus) { delete fRawCrateStatus; fRawCrateStatus = 0; }
    if (fRawDigits) { 
      fRawDigits->Delete(); 
      delete fRawDigits; 
      fRawDigits = 0;
    }
  }
  return *this;
}

//_____________________________________________________________________________
std::ostream& RawVaTimingMonitorBlock::FormatToOStream(std::ostream& os, 
                                                    Option_t *option) const
{
   RawDataBlock::FormatToOStream(os,option);
   if (option[0] == 'X') return os;
   
   // additional block specific formatted output is done here

   os << " TimeStamp " << GetTimeStamp().AsString("c") << endl;
   os << " Run " << GetRun() 
      << " SubRun " << GetSubRun() 
      << " RunType " << GetRunType() 
      << " TimeFrame " << GetTimeFrameNum()
      << " with " << GetNumberOfDigits() << " digits "
      << endl; 
   os << " " << *GetCrateStatus() << endl;

   if (strchr(option,'q') != 0) return os;

   TIter iter = GetDatumIter();
   TObject *tobj;
   RawDigit *udigit;
   while ( ( tobj = iter.Next() ) ) {
     udigit = dynamic_cast<RawDigit *>(tobj);
     if (udigit) os << " " << (*udigit) << endl;
   }
   os << endl;
   return os;
}

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

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

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

//_____________________________________________________________________________
VldTimeStamp RawVaTimingMonitorBlock::GetTimeStamp() const
{
   // get the start time
   if (fSize >= zzzz_last) 
      return VldTimeStamp(fRawBlock[indx_loadsec],fRawBlock[indx_loadnsec]);

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

//_____________________________________________________________________________
VldContext RawVaTimingMonitorBlock::GetVldContext() const
{
   // get a VldContext

   RawBlockId rbid = GetBlockId();
   return VldContext(rbid.GetDetector(),rbid.GetSimFlag(),GetTimeStamp());
}

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

//_____________________________________________________________________________
const RawDigitCrateStatus* RawVaTimingMonitorBlock::GetCrateStatus() const
{
   // get the crate id --> status
   if ( ! fRawDigits ) FillRawDigits();
   return fRawCrateStatus;

}

//_____________________________________________________________________________
Int_t RawVaTimingMonitorBlock::GetNumberOfDigits() const
{
   // get the number of digits
   if ( ! fRawDigits ) FillRawDigits();
   return fRawDigits->GetEntriesFast();  // known not to have gaps
}

//_____________________________________________________________________________
const RawDigit* RawVaTimingMonitorBlock::At(Int_t idx) const
{
   // create/fill the TObjArray of RawDigits (if it doesn't exist)
   // return pointer to the i-th element

   if ( ! fRawDigits ) FillRawDigits();
   return (RawDigit*) fRawDigits->At(idx);
}

//_____________________________________________________________________________
TIter RawVaTimingMonitorBlock::GetDatumIter(Bool_t dir) const
{
   // create/fill the TObjArray of RawDigits (if it doesn't exist)
   // return an iterator to look over them

   if ( ! fRawDigits ) FillRawDigits();
   return TIter(fRawDigits,dir);
}

//_____________________________________________________________________________
Int_t RawVaTimingMonitorBlock::IndexOf(RawDigit *rawdigit) const
{
   // create/fill the TObjArray of RawDigits (if it doesn't exist)
   // return the index for this object (if contained in the list)

   if ( ! fRawDigits ) FillRawDigits();
   return fRawDigits->IndexOf(rawdigit);
}

//_____________________________________________________________________________
void RawVaTimingMonitorBlock::FillRawDigits() const
{
   // create the TObjArray of RawDigit (if it doesn't exist)
   
   if ( fRawDigits ) return;   // already filled
   if ( fSize <= 0 || fRawBlock == 0) {
      MSG("RawData",Msg::kWarning)
         << "RawVaTimingMonitorBlock::FillRawDigits empty block? "
         << fSize << " " << fRawBlock << endl;
      return;
   }

   fRawDigits          = new TObjArray();
   RawDigit  *rawdigit = 0;
   const Int_t    *p   = fRawBlock;
   const Int_t    *end = fRawBlock + fSize; // 1 beyond end

   RawBlockId rbid = GetBlockId();
   p += indx_crateid; // skip #words, blockid and checksum, etc

   if (fgDebugFlags&dbg_DumpHeaderOnUnpack) {
      MSG("RawData",Msg::kInfo) 
         << "RawVaTimingMonitorBlock::FillRawDigits "
         << " fSize " << fSize 
         << " id " << rbid.AsString()
         << endl;
   }

   // unpack crate info
   // all version have TF word between crateId and # of entries
   fRawCrateStatus = new RawDigitCrateStatus(rbid,p,GetTimeStamp(),true);
   Int_t npairs = fRawCrateStatus->GetEntries(); 

   if (fgDebugFlags&dbg_DumpCrateOnUnpack) fRawCrateStatus->Print();

   while (p<end) {

      for (Int_t ipair = 0; ipair < npairs; ipair++) {
         // assume that the readout type is consistent for whole crate
         // and that the status block knows what it is
         ElecType::Elec_t etype = fRawCrateStatus->GetElecType();

         // pointer is advanced by RawDigit ctor
         // knowing how many words it needed to eat
         switch (rbid.GetSimFlag()) {
         case SimFlag::kData:
         case SimFlag::kDaqFakeData:
            switch (etype) {
            case ElecType::kVA:
               rawdigit = new RawVaDigit(p,fRawCrateStatus);
               break;
            case ElecType::kQIE:
               rawdigit = new RawQieDigit(p,fRawCrateStatus);
               break;
            default:
               rawdigit = new RawDigit(p,fRawCrateStatus);
               break;
            }
            break;
         case SimFlag::kMC:
         case SimFlag::kReroot:
            switch (etype) {
            case ElecType::kVA:
               rawdigit = new RawVaMCDigit(p,fRawCrateStatus);
               break;
            case ElecType::kQIE:
               rawdigit = new RawQieMCDigit(p,fRawCrateStatus);
               break;
            case ElecType::kReroot:
              {
                if (rbid.GetDetector() == Detector::kNear) {
                  static int nmsg = 10;
                  if (nmsg) {
                    MSG("RawData",Msg::kWarning)
                      << "RawVaTimingMonitorBlock::FillRawDigits SimFlag "
                      << SimFlag::AsString(rbid.GetSimFlag())
                      << " ElecType " << ElecType::AsString(etype)
                      << " in Detector " 
                      << Detector::AsString(rbid.GetDetector())
                      << endl
                      << " treat as kQIE for RawQieMCDigit creation"
                      << endl;
                    if (nmsg) {
                      if (--nmsg == 0)
                        MSG("RawData",Msg::kWarning)
                          << " ... last warning of this type" << endl;
                    }
                  }
                  rawdigit = new RawQieMCDigit(p,fRawCrateStatus);
                  break;
                }
                else 
                  MSG("RawData",Msg::kError) 
                    << "RawVaTimingMonitorBlock::FillRawDigits SimFlag "
                    << SimFlag::AsString(rbid.GetSimFlag())
                    << " ElecType " << ElecType::AsString(etype)
                    << endl << "  attempt to move past problem " << endl;
                p += 3;
                break;
              }
            default:
               MSG("RawData",Msg::kError) 
                  << "RawVaTimingMonitorBlock::FillRawDigits SimFlag "
                  << SimFlag::AsString(rbid.GetSimFlag())
                  << " ElecType " << ElecType::AsString(etype)
                  << endl << "  attempt to move past problem " << endl;
               p += 3;
               break;
            }
            break;
         case SimFlag::kUnknown:
               MSG("RawData",Msg::kError) 
                  << "RawVaTimingMonitorBlock::FillRawDigits SimFlag "
                  << SimFlag::AsString(rbid.GetSimFlag())
                  << endl << "  attempt to move past problem " << endl;
               p += 2;
               break;
         }

         fRawDigits->Add(rawdigit);

         if (fgDebugFlags&dbg_DumpDigitOnUnpack) {
           rawdigit->Print(); cout << endl;
         }
         if (p>end) {
            MSG("RawData",Msg::kWarning)
               << "RawVaTimingMonitorBlock::FillRawDigits crate info seems trashed"
               << endl << " SimFlag " << SimFlag::AsString(rbid.GetSimFlag())
               << " ElecType " << ElecType::AsString(etype)
               << endl;
            break;
         }
      }
   }

}

//_____________________________________________________________________________

---