RawTOFBlock.cxx

Go to the documentation of this file.

// $Id: RawTOFBlock.cxx,v 1.9 2004/09/02 21:47:34 rhatcher Exp $
// 
// RawTOFBlock 
// 
// RawTOFBlock holds a block of raw digitizations
//  and knows how to unpack it into individual RawDigits
//
// Author:  R. Hatcher 2000.04.19
//

#include "RawData/RawTOFBlock.h"

enum EDebugDigitDataBlock {
   dbg_DumpHeaderOnUnpack = 0x0001,
   dbg_DumpCrateOnUnpack  = 0x0002,
   dbg_DumpDigitOnUnpack  = 0x0004
};

UInt_t RawTOFBlock::fgDebugFlags = 0;
//  dbg_DumpCrateOnUnpack | dbg_DumpDigitOnUnpack;

#include "RawData/RawTOFDigit.h"

#include "MessageService/MsgStream.h"
#include "MessageService/MsgService.h"
CVSID("$Id: RawTOFBlock.cxx,v 1.9 2004/09/02 21:47:34 rhatcher Exp $");

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawTOFBlock,kMdBlockTofReadout,0);

ClassImp(RawTOFBlock)

//_____________________________________________________________________________
RawTOFBlock::RawTOFBlock() :
   fRawCrateStatuses(0), fRawTOFDigits(0)
{
   // Default constructor
}

//_____________________________________________________________________________
RawTOFBlock::RawTOFBlock(const Int_t *block)
   : RawDataBlock(block), 
     fRawCrateStatuses(0), fRawTOFDigits(0)
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   //  3   Crate # i (+extra)
   //  4   # of crate entries (N_i)
   //  5   Crate T0_i sec
   //  6   Crate T0_i nsec
   //-----
   //  7   readout 1_i word 1
   //  8   readout 1_i word 2
   //      < truth PlexStripEndId if Reroot data>
   //      tdc header (inc count)
   //      tdc data word 0
   //      ...
   //      tdc trailer
   //      readout 2_i word 1
   //      readout 2_i word 2
   //      ...

}

//_____________________________________________________________________________
RawTOFBlock::~RawTOFBlock()
{
   if (fRawTOFDigits) {
      fRawTOFDigits->Delete();
      delete fRawTOFDigits;
      fRawTOFDigits = 0;
   }
   if (fRawCrateStatuses) {
      fRawCrateStatuses->Delete();
      delete fRawCrateStatuses;
      fRawCrateStatuses = 0;
   }
   return;
}

//_____________________________________________________________________________
RawTOFBlock& RawTOFBlock::operator=(const RawTOFBlock& rhs)
{
   // deep copy assignment
   if (this != &rhs) {
     RawDataBlock::operator=(rhs);
     if (fRawTOFDigits) {
       fRawTOFDigits->Delete();
       delete fRawTOFDigits;
       fRawTOFDigits = 0;
     }
     if (fRawCrateStatuses) {
       fRawCrateStatuses->Delete();
       delete fRawCrateStatuses;
       fRawCrateStatuses = 0;
     }
   }
   return *this;
}

//_____________________________________________________________________________
Int_t RawTOFBlock::GetNumberOfDigits() const
{
   // create/fill the TObjArray of RawTOFDigit (if it doesn't exist)
   // return number of entries
   
   if ( ! fRawTOFDigits ) FillRawTOFDigits();
   return fRawTOFDigits->GetEntriesFast(); // known not to have gaps
}

//_____________________________________________________________________________
const RawTOFDigit* RawTOFBlock::At(Int_t idx) const
{
   // create/fill the TObjArray of RawTOFDigit (if it doesn't exist)
   // return pointer to the i-th element
   
   if ( ! fRawTOFDigits ) FillRawTOFDigits();
   return (RawTOFDigit*) fRawTOFDigits->At(idx);
}

//_____________________________________________________________________________
TIter RawTOFBlock::GetDatumIter(Bool_t dir) const
{
   // create/fill the TObjArray of RawTOFDigit (if it doesn't exist)
   // return an iterator to look over them
   
   if ( ! fRawTOFDigits ) FillRawTOFDigits();
   return TIter(fRawTOFDigits,dir);
}

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

   if ( ! fRawTOFDigits ) FillRawTOFDigits();
   return fRawTOFDigits->IndexOf(rawdigit);
}

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

   fRawCrateStatuses = new TObjArray();
   fRawTOFDigits     = new TObjArray();
   RawDigitCrateStatus *cratestatus = 0;
   RawTOFDigit         *rawdigit    = 0;
   const Int_t    *p   = fRawBlock;
   const Int_t    *end = fRawBlock + fSize; // 1 beyond end

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

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

   while (p<end) {
      // start a new crate (pointer advanced by RawCrateStatus ctor
      cratestatus = new RawDigitCrateStatus(rbid,p);
      fRawCrateStatuses->Add(cratestatus);
      Int_t npairs = cratestatus->GetEntries(); 

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

      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 = cratestatus->GetElecType();

         // pointer is advanced by RawTOFDigit ctor
         // knowing how many words it needed to eat
         switch (rbid.GetSimFlag()) {
         case SimFlag::kData:
         case SimFlag::kDaqFakeData:
            rawdigit = new RawTOFDigit(p,cratestatus);
            break;
         case SimFlag::kMC:
         case SimFlag::kReroot:
            rawdigit = new RawTOFDigit(p,cratestatus);
            break;
         default:
            MSG("RawData",Msg::kWarning)
               << "RawTOFBlock::FillRawTOFDigits simflag was: \""
               << SimFlag::AsString(rbid.GetSimFlag()) << "\" ("
               << (int)rbid.GetSimFlag() << ")" << endl;
            break;
         }

         fRawTOFDigits->Add(rawdigit);

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

}

//_____________________________________________________________________________
std::ostream& RawTOFBlock::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

   const RawDigitCrateStatus *lastcrate = 0;

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

//_____________________________________________________________________________

---