RawLITimingSummaryBlock.cxx

Go to the documentation of this file.

// $Id: RawLITimingSummaryBlock.cxx,v 1.14 2004/09/02 21:21:23 rhatcher Exp $
// 
// RawLITimingSummaryBlock 
// 
// RawLITimingSummaryBlock holds a block of raw light injection summaries
//  and knows how to unpack it into individual RawLITimingSummary's
//
// Author:  R. Hatcher 2001.05.10
//

#include "RawData/RawLITimingSummaryBlock.h"

enum EDebugLITimingSummaryBlock {
   dbg_DumpHeaderOnUnpack = 0x0001,
   dbg_DumpCrateOnUnpack  = 0x0002,
   dbg_DumpTimingSumOnUnpack = 0x0004
};

UInt_t RawLITimingSummaryBlock::fgDebugFlags = 0;
//  dbg_DumpCrateOnUnpack | dbg_DumpTimingSumOnUnpack;

#include "RawData/RawLIHeader.h"
#include "RawData/RawLITimingSummary.h"

#include "MessageService/MsgStream.h"
#include "MessageService/MsgService.h"
CVSID("$Id: RawLITimingSummaryBlock.cxx,v 1.14 2004/09/02 21:21:23 rhatcher Exp $");

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawLITimingSummaryBlock,kMdBlockLiSummaryTiming,0);

ClassImp(RawLITimingSummaryBlock)

//_____________________________________________________________________________
RawLITimingSummaryBlock::RawLITimingSummaryBlock() :
  RawDataBlock(), fRawLIHeader(0), fRawCrateStatuses(0), fRawTimingSums(0)
{
   // Default constructor
}

//_____________________________________________________________________________
RawLITimingSummaryBlock::RawLITimingSummaryBlock(const Int_t *block)
  : RawDataBlock(block), 
    fRawLIHeader(0), fRawCrateStatuses(0), fRawTimingSums(0)
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   //  3   CalibType   | CalibPoint#
   //  4   PulserBox # | LED #
   //  5   PulseHeight | PulseWidth
   //  6   # pulses    | flashing frequency
   //  7   T0 (1st ROP) sec
   //  8   T0 (1st ROP) nsec
   //  9   spare field 0 (v0,v1) : # pulses used in this summary (v2)
   // 10   spare field 1 (v0,v1) : spare field 0  (v2)
   //-----
   // 11   Crate # i (+extra)
   // 12   # of crate entries (N_i)
   //-----
   // 13   ChAdd 1_i  | # of entries
   // 14   Mean
   // 15   RMS
   // 16   ChAdd 2_i  | # of entries
   // 17   Mean
   // 18   RMS
   //  ...
   //      ChAdd N_i  | # of entries
   //      Mean
   //      RMS
   //-----
   //  x   Crate # j (+extra)
   //      # of crate entries (N_j)
   //-----
   //      ChAdd 1_j  | # of entries
   //      Mean
   //      RMS
   //      ChAdd 2_j  | # of entries
   //      Mean
   //      RMS
   //  ...
   //      ChAdd N_j  | # of entries
   //      Mean*4     | RMS*4

}

//_____________________________________________________________________________
RawLITimingSummaryBlock::~RawLITimingSummaryBlock()
{

   if (fRawLIHeader) {
      delete fRawLIHeader;
      fRawLIHeader = 0;
   }

   if (fRawTimingSums) {
      fRawTimingSums->Delete();
      delete fRawTimingSums;
      fRawTimingSums = 0;
   }
   if (fRawCrateStatuses) {
      fRawCrateStatuses->Delete();
      delete fRawCrateStatuses;
      fRawCrateStatuses = 0;
   }
   return;
}

//_____________________________________________________________________________
RawLITimingSummaryBlock& RawLITimingSummaryBlock::operator=(const RawLITimingSummaryBlock& rhs)
{

   // deep copy assignment
   if (this != &rhs) {
     RawDataBlock::operator=(rhs);

     if (fRawLIHeader) {
       delete fRawLIHeader;
       fRawLIHeader = 0;
     }
     
     if (fRawTimingSums) {
       fRawTimingSums->Delete();
       delete fRawTimingSums;
       fRawTimingSums = 0;
     }
     if (fRawCrateStatuses) {
       fRawCrateStatuses->Delete();
       delete fRawCrateStatuses;
       fRawCrateStatuses = 0;
     }
   }
   return *this;
}

//_____________________________________________________________________________
Int_t RawLITimingSummaryBlock::GetNumberOfSummaries(void) const
{
   // create/fill the TObjArray of RawTimingSummarys (if it doesn't exist)
   // return the number of entries

   if ( ! fRawTimingSums ) FillRawTimingSums();
   return fRawTimingSums->GetEntriesFast(); // known not to have gaps
}

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

   if ( ! fRawTimingSums ) FillRawTimingSums();
   return (RawLITimingSummary*) fRawTimingSums->At(idx);
}

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

   if ( ! fRawTimingSums ) FillRawTimingSums();
   return TIter(fRawTimingSums,dir);
}

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

   if ( ! fRawTimingSums ) FillRawTimingSums();
   return fRawTimingSums->IndexOf(rawTimingSum);
}

//_____________________________________________________________________________
void RawLITimingSummaryBlock::FillRawTimingSums() const
{
   // create the TObjArray of RawTimingSum (if it doesn't exist)

   if ( fRawTimingSums ) return;   // already filled
   if ( fSize <= 0 || fRawBlock == 0) {
      MSG("RawData",Msg::kWarning)
         << "RawLITimingSummaryBlock::FillRawTimingSums empty block? "
         << fSize << " " << fRawBlock << endl;
      // build a dummy header at least
      fRawLIHeader = new RawLIHeader;
      return;
   }

   fRawCrateStatuses = new TObjArray();
   fRawTimingSums    = new TObjArray();
   RawCrateStatus     *cratestatus = 0;
   RawLITimingSummary *rawTimingSum   = 0;
   const Int_t    *p   = fRawBlock;
   const Int_t    *end = fRawBlock + fSize; // 1 beyond end

   RawBlockId rbid = GetBlockId();
   Int_t minor = rbid.GetMinor();

   p += 3; // skip #words, blockid and checksum

   // eat up the common header info
   fRawLIHeader = new RawLIHeader(rbid,p);

   if (fgDebugFlags&dbg_DumpHeaderOnUnpack) fRawLIHeader->Print();

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

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

      for (Int_t ipair = 0; ipair < npairs; ipair++) {
         rawTimingSum = new RawLITimingSummary(p,cratestatus,minor);
         fRawTimingSums->Add(rawTimingSum);

         if (fgDebugFlags&dbg_DumpTimingSumOnUnpack) rawTimingSum->Print();
         if (p>end) {
            MSG("RawData",Msg::kWarning)
               << "RawLITimingSummaryBlock::FillRawTimingSums crate info seems trashed"
               << endl << " SimFlag " << SimFlag::AsString(rbid.GetSimFlag())
               << endl;
            break;
         }
      }
   }

}

//_____________________________________________________________________________
std::ostream& RawLITimingSummaryBlock::FormatToOStream(std::ostream& os, 
                                                       Option_t *option) const
{
   RawDataBlock::FormatToOStream(os,option);
   if (option[0] == 'X') return os;

   TIter iter = GetDatumIter();

   const RawLIHeader* header = GetHeader();
   os << (*header);

   os << " " << "Channel         " 
      << "entries"
      << " " << "      Mean" << "          "
      << " " << "       RMS" << "          "
      << endl;

   TObject *tobj;
   RawLITimingSummary *usum;
   while ( ( tobj = iter.Next() ) ) {
      usum = dynamic_cast<RawLITimingSummary *>(tobj);
      if (usum)  os << (*usum);
   }
   os << endl;

   return os;
}




//_____________________________________________________________________________

---