RawDigitDataBlock.cxx

Go to the documentation of this file.

// $Id: RawDigitDataBlock.cxx,v 1.35 2007/06/04 21:02:44 rhatcher Exp $
// 
// RawDigitDataBlock 
// 
// RawDigitDataBlock holds a block of raw digitizations
//  and knows how to unpack it into individual RawDigits
//
// Author:  R. Hatcher 2000.04.19
//

#include "RawData/RawDigitDataBlock.h"

enum EDebugDigitDataBlock {
   dbg_DumpHeaderOnUnpack = 0x0001,
   dbg_DumpCrateOnUnpack  = 0x0002,
   dbg_DumpDigitOnUnpack  = 0x0004,
   dbg_DumpOnlyHeader     = 0x0008,
   dbg_DumpOnlyFirstLast  = 0x0010
};

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

#include "RawData/RawQieMCDigit.h"
#include "RawData/RawVaMCDigit.h"
#include "RawData/RawQieDigiDigit.h"
#include "RawData/RawVaDigiDigit.h"

#include <set>
#include <vector>
#include <map>
using namespace std;
#include <cstring>

#include "MessageService/MsgStream.h"
#include "MessageService/MsgService.h"
CVSID("$Id: RawDigitDataBlock.cxx,v 1.35 2007/06/04 21:02:44 rhatcher Exp $");

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawDigitDataBlock,kMdBlockCrateReadout,0);

ClassImp(RawDigitDataBlock)

//_____________________________________________________________________________
RawDigitDataBlock::RawDigitDataBlock() :
   fRawCrateStatuses(0), fRawDigits(0), 
   fCrates(-1), fNPedMode(0), fNSparsMode(0), fNCommonMode(0),
   fSeenErrorsQIE(0), fSeenErrorsVA(0)
{
   // Default constructor
}

//_____________________________________________________________________________
RawDigitDataBlock::RawDigitDataBlock(const Int_t *block)
   : RawDataBlock(block), 
     fRawCrateStatuses(0), fRawDigits(0),
     fCrates(-1), fNPedMode(0), fNSparsMode(0), fNCommonMode(0),
     fSeenErrorsQIE(0), fSeenErrorsVA(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>
   //      readout 2_i word 1
   //      readout 2_i word 2
   //      ...
   //      readout N_i word 1
   //      readout N_i word 2
   //-----
   //  x   Crate # j (+extra)
   //      # of crate entries (N_j)
   //      Crate T0_j sec
   //      Crate T0_j nsec
   //-----
   //      readout 1_j word 1
   //      readout 1_j word 2
   //  ...

}

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

//____________________________________________________________________________
RawDigitDataBlock& RawDigitDataBlock::operator=(const RawDigitDataBlock& rhs)
{
   // deep copy assignment 
   if (this != &rhs) {
     RawDataBlock::operator=(rhs);
     if (fRawDigits) { 
       fRawDigits->Delete();
       delete fRawDigits;
       fRawDigits = 0;
     }
     if (fRawCrateStatuses) {
       fRawCrateStatuses->Delete();
       delete fRawCrateStatuses;
       fRawCrateStatuses = 0;
     }
     fCrates        = -1;
     fNPedMode      =  0;
     fNSparsMode    =  0;
     fNCommonMode   =  0;
     fSeenErrorsQIE =  0;
     fSeenErrorsVA  =  0;
   }
   return *this;
}

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

//_____________________________________________________________________________
Short_t RawDigitDataBlock::GetNumberOfCrates() const
{
   // return number of crates involved
   if ( fCrates < 0 ) FillCrateModes();
   return fCrates;
}

//_____________________________________________________________________________
Short_t RawDigitDataBlock::GetNPedModeCrates() const
{
   // return number of crates involved
   if ( fCrates < 0 ) FillCrateModes();
   return fNPedMode;
}

//_____________________________________________________________________________
Short_t RawDigitDataBlock::GetNSparsModeCrates() const
{
   // return number of crates involved
   if ( fCrates < 0 ) FillCrateModes();
   return fNSparsMode;
}

//_____________________________________________________________________________
Short_t RawDigitDataBlock::GetNCommonModeCrates() const
{
   // return number of crates involved
   if ( fCrates < 0 ) FillCrateModes();
   return fNCommonMode;
}

//_____________________________________________________________________________
Int_t RawDigitDataBlock::GetNumOfErrorDigits() const
{
   // create/fill the TObjArray of RawDigit (if it doesn't exist)
   // return number of entries with a error bit set
   
   if ( ! fRawDigits ) FillRawDigits();

   Int_t nerrDigits = 0;
   TIter rditer = GetDatumIter();
   while ( RawDigit *rd = dynamic_cast<RawDigit*>(rditer()) ) {
     if (rd->GetErrorCode()) nerrDigits++;
   }
   return nerrDigits;
}

//_____________________________________________________________________________
Char_t RawDigitDataBlock::GetSeenErrorMaskQIE() const
{
   // create/fill the TObjArray of RawDigit (if it doesn't exist)
   // return mask of all errors encountered
   
   if ( ! fRawDigits ) FillRawDigits();
   return fSeenErrorsQIE;
}

//_____________________________________________________________________________
Char_t RawDigitDataBlock::GetSeenErrorMaskVA() const
{
   // create/fill the TObjArray of RawDigit (if it doesn't exist)
   // return mask of all errors encountered
   
   if ( ! fRawDigits ) FillRawDigits();
   return fSeenErrorsVA;
}

//_____________________________________________________________________________
Int_t RawDigitDataBlock::IsOverlapTfBoundary() const
{
   // determine if digits exist in adjacent TimeFrames
   // 0 = no overlap
   // 1 = different crates have different TF's
   // 2 = at least one crate saw digits in both TF's
  //  3 = 1 + 2

   if ( ! fRawDigits ) FillRawDigits();

   MSG("RawData",Msg::kDebug)
     << " NCrates " << GetNumberOfCrates() << endl;

   Int_t overlapCode = 0;

   map<VldTimeStamp,UInt_t> timestampCnt;
   map<Int_t,UInt_t>       crateCnt;

   TIter citr(fRawCrateStatuses);
   while ( RawDigitCrateStatus* cstat = 
           dynamic_cast<RawDigitCrateStatus*>(citr()) ) {
     VldTimeStamp crateT0  = cstat->GetCrateT0();
     Int_t        crateNum = cstat->GetCrate();
     timestampCnt[crateT0]++;
     crateCnt[crateNum]++;
     MSG("RawData",Msg::kDebug)
       << "   crateNum " << crateNum << " to " << crateT0 << endl;
   }

   // condition 1 is if we saw different T0's
   if ( timestampCnt.size() > 1 ) overlapCode += 1;

   // condition 2 is seeing the same crate twice
   map<Int_t,UInt_t>::const_iterator crateCntItr = crateCnt.begin();
   while ( crateCntItr != crateCnt.end() ) {
     if ( (*crateCntItr).second != 1 ) overlapCode += 2;
     crateCntItr++;
   }

   MSG("RawData",Msg::kDebug)
     << "  return code " << overlapCode << endl;
   return overlapCode;
}

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

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

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

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

//_____________________________________________________________________________
VldContext RawDigitDataBlock::GetVldContext() const
{
   // create/fill the TObjArray of RawDigit (if it doesn't exist)
   // return the VldContext (with earliest timestamp of any crate)

   if ( ! fRawDigits ) FillRawDigits();
   
   VldTimeStamp vts(2038,1,18,0,0,0); // far future

   TIter citr(fRawCrateStatuses);
   while ( RawDigitCrateStatus* cstat = 
           dynamic_cast<RawDigitCrateStatus*>(citr()) ) {
     VldTimeStamp t0 = cstat->GetCrateT0();
     if (t0<vts) vts = t0;
   }
   
   RawBlockId rbid = GetBlockId();
   return VldContext(rbid.GetDetector(),rbid.GetSimFlag(),vts);

}

//_____________________________________________________________________________
void RawDigitDataBlock::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)
         << "RawDigitDataBlock::FillRawDigits empty block? "
         << fSize << " " << fRawBlock << endl;
      return;
   }

   fRawCrateStatuses = new TObjArray();
   fRawDigits        = new TObjArray();
   RawDigitCrateStatus *cratestatus = 0;
   RawDigit       *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) 
         << "RawDigitDataBlock::FillRawDigits "
         << " 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 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,cratestatus);
               break;
            case ElecType::kQIE:
               rawdigit = new RawQieDigit(p,cratestatus);
               break;
            default:
               rawdigit = new RawDigit(p,cratestatus);
               break;
            }
            break;
         case SimFlag::kMC:
           switch (etype) {
           case ElecType::kVA:
             rawdigit = new RawVaDigiDigit(p,cratestatus);
             break;
           case ElecType::kQIE:
             rawdigit = new RawQieDigiDigit(p,cratestatus);
             break;
           default:
             MSG("RawData",Msg::kError) 
               << "RawDigitDataBlock::FillRawDigits SimFlag "
               << SimFlag::AsString(rbid.GetSimFlag())
               << " ElecType " << ElecType::AsString(etype)
               << endl << "  attempt to move past problem " << endl;
             p += 3;
             break;          
           };
           break;
         case SimFlag::kReroot:
            switch (etype) {
            case ElecType::kVA:
               rawdigit = new RawVaMCDigit(p,cratestatus);
               break;
            case ElecType::kQIE:
               rawdigit = new RawQieMCDigit(p,cratestatus);
               break;
            case ElecType::kReroot:
              {
                if (rbid.GetDetector() == Detector::kNear) {
                  static int nmsg = 10;
                  if (nmsg) {
                    MSG("RawData",Msg::kWarning)
                      << "RawDigitDataBlock::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,cratestatus);
                  break;
                }
                else 
                  MSG("RawData",Msg::kError) 
                    << "RawDigitDataBlock::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) 
                  << "RawDigitDataBlock::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) 
                  << "RawDigitDataBlock::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();
         if (p>end) {
            MSG("RawData",Msg::kWarning)
               << "RawDigitDataBlock::FillRawDigits crate info seems trashed"
               << endl << " SimFlag " << SimFlag::AsString(rbid.GetSimFlag())
               << " ElecType " << ElecType::AsString(etype)
               << endl;
            break;
         }
      }
   }

   // post process digits
   // accumulate mask off all error bits seen in the block and
   // for cases of QIE CapIdError, ParityError and MisCountError
   // we also might tag other digits that share a Minder
   PostFillRawDigits();
}

//_____________________________________________________________________________
void RawDigitDataBlock::PostFillRawDigits() const
{
  // Post-process RawDigits after unpacking
  // In particular we are looking for QIE digits in the same
  //   Minder as those with CapIdErrors, ParityErrors or MisCountErrors
  // We also fill fSeenErrors (mask of all error bits seen in this block)

  UInt_t ncaperr=0, ncapmenuerr=0, ncapsharederr=0;
  UInt_t ntranserr=0, ntranssharederr=0;

  // Collect all problematic RawChannelId addresses.
  // Make a list of all QIE RawDigits without known 
  //   CapIdError, ParityError or MisCountError for 2nd pass
  set<RawChannelId>    rcidCapIdErrors;
  set<RawChannelId>    rcidTransferErrors;
  vector<RawQieDigit*> otherQieDigitsCapId;
  vector<RawQieDigit*> otherQieDigitsTrans;
  otherQieDigitsCapId.reserve(fRawDigits->GetLast()+1); // reserve enough space
  otherQieDigitsTrans.reserve(fRawDigits->GetLast()+1); // reserve enough space

  TIter rditr(fRawDigits);
  while ( RawDigit* rd = dynamic_cast<RawDigit*>(rditr()) ) { 
    RawChannelId rcid = rd->GetChannel();
    Char_t       err  = rd->GetErrorCode();

    ElecType::Elec_t etype = rcid.GetElecType();
    // masks of all error coded encountered in block
    if      ( etype == ElecType::kVA  ) fSeenErrorsVA  |= err;
    else if ( etype == ElecType::kQIE ) fSeenErrorsQIE |= err;

    // the rest of the processing is only relevant for QIE digits
    if ( etype != ElecType::kQIE ) continue;
    RawQieDigit* rdqie = dynamic_cast<RawQieDigit*>(rd);
    if ( !rdqie ) continue;

    if ( err & RawQieDigit::kCapIdError ) {
      // problem channel for CapId
      ncaperr++;
      MSG("Raw",Msg::kVerbose)
        << "raw CapIdError on rcid " << rcid.AsString("c") << endl;
      rcid.ClearModeBits();
      rcidCapIdErrors.insert(rcid);
    }
    else otherQieDigitsCapId.push_back(rdqie);

    if ( err & (RawQieDigit::kParityError|RawQieDigit::kMisCountError) ) {
      // problem channel for data transfer
      ntranserr++;
      MSG("Raw",Msg::kVerbose)
        << "raw " << RawQieDigit::AsString((RawQieDigit::EQieErrorCode)err)
        << " (" << (int)err << ") on rcid " << rcid.AsString("c") << endl;
      rcid.ClearModeBits();
      rcidTransferErrors.insert(rcid);
    }
    else otherQieDigitsTrans.push_back(rdqie);

  } // loop over all digits

  // Find and set error condition on all digits in problematic minders
  set<RawChannelId>::const_iterator rcidItr;

  // CapId errors
  rcidItr = rcidCapIdErrors.begin();
  while ( rcidItr != rcidCapIdErrors.end() ) {
    RawChannelId rcidBadMenu = *rcidItr++;
    for (size_t iqied=0; iqied < otherQieDigitsCapId.size(); ++iqied) {
      RawQieDigit* rdqie = otherQieDigitsCapId[iqied];
      RawChannelId rcid  = rdqie->GetChannel();
      rcid.ClearModeBits();
      if      ( rcid == rcidBadMenu ) {
        rdqie->SetCapIdSameMenuError(); 
        ncapmenuerr++; 
        fSeenErrorsQIE |= RawQieDigit::kCapIdSameMenuError;
      }
      else if ( rcid.IsSameMinder(rcidBadMenu) ) {
        rdqie->SetCapIdSharedMinderError();
        ncapsharederr++;
        fSeenErrorsQIE |= RawQieDigit::kCapIdSharedMinderError;
      }
    } // loop over qie digits without errors
  }  // loop over bad capid minder addresses

  // transfer errors
  rcidItr = rcidTransferErrors.begin();
  while ( rcidItr != rcidTransferErrors.end() ) {
    RawChannelId rcidBadMenu = *rcidItr++;
    for (size_t iqied=0; iqied < otherQieDigitsTrans.size(); ++iqied) {
      RawQieDigit* rdqie = otherQieDigitsTrans[iqied];
      RawChannelId rcid  = rdqie->GetChannel();
      if ( rcid.IsSameMinder(rcidBadMenu) ) {
        rdqie->SetTransferSharedMinderError();
        ntranssharederr++;
        fSeenErrorsQIE |= RawQieDigit::kTransferSharedMinderError;
      }
    } // loop over qie digits without errors
  }  // loop over bad transfer minder addresses

  if ( ncaperr > 0 ) {
    MAXMSG("Raw",Msg::kInfo,10)
      << "CapId Error on " << ncaperr <<" digits, "
      << ncapmenuerr << "," << ncapsharederr 
      << " other digits shared same menus,minders."
      << endl;
  }
  if ( ntranserr > 0 ) {
    MAXMSG("Raw",Msg::kInfo,10)
      << "Transfer Error on " << ntranserr <<" digits, "
      << ntranssharederr
      << " other digits shared same minders."
      << endl;
  }
}

//_____________________________________________________________________________
void RawDigitDataBlock::FillCrateModes() const
{
   // count the number of crates used and record what state they were in
   // (ped,spars,common)
   
   if ( ! fRawDigits ) FillRawDigits();

   fCrates = fNPedMode = fNSparsMode = fNCommonMode = 0;

   TIter citr(fRawCrateStatuses);

   TObject *tobj;
   RawDigitCrateStatus *cstat;

   while ( ( tobj = citr.Next() ) ) {
      cstat = dynamic_cast<RawDigitCrateStatus*>(tobj);
      if (cstat) {
         ++fCrates;
         if (cstat->GetPedMode())    ++fNPedMode;
         if (cstat->GetSparsMode())  ++fNSparsMode;
         if (cstat->GetCommonMode()) ++fNCommonMode;
      }
   }

}

//_____________________________________________________________________________
std::ostream& RawDigitDataBlock::FormatToOStream(ostream& os,
                                                 Option_t *option) const
{

   RawDataBlock::FormatToOStream(os,option);
   if (strchr(option,'X')!=0) return os;

   // additional block specific formatted output is done here

   os << " NumDigits=" << GetNumberOfDigits()
      << " (w/Errors=" << GetNumOfErrorDigits() << ")"
      << " NumCrates=" << GetNumberOfCrates()
      << " (PedSub=" << GetNPedModeCrates()
      << ",Spars=" << GetNSparsModeCrates()
      << ",CommonMode=" << GetNCommonModeCrates()
      << ")"
      << endl;
   
   os << " SeenErrorMask " 
      << "QIE 0x" << hex << setfill('0') << setw(2) 
      << (int)GetSeenErrorMaskQIE() << setfill(' ') << dec << " "
      << "VA 0x" << hex << setfill('0') << setw(2) 
      << (int)GetSeenErrorMaskVA() << setfill(' ') << dec << ","
      << " OverlapTfBoundary: "
      << ((IsOverlapTfBoundary())?"Yes":"No")
      << endl;

   if (strchr(option,'-')!=0) return os;
   if (fgDebugFlags&dbg_DumpOnlyHeader) return os;

   const RawDigitCrateStatus *lastcrate = 0;

   RawDigit *rd, *rdprev = 0;
   TIter rditer = GetDatumIter();
   Int_t tmin=0x7fffffff, tmax=-1;
   while ( ( rd = dynamic_cast<RawDigit*>(rditer()) ) ) {
     if (rd->GetCrateStatus() != lastcrate) {
       if ((fgDebugFlags&dbg_DumpOnlyFirstLast) && rdprev )
           os << "  " << (*rdprev) << endl;
       lastcrate = rd->GetCrateStatus();
       os << " " << (*lastcrate) << endl;
       if (fgDebugFlags&dbg_DumpOnlyFirstLast)
           os << "  " << (*rd) << endl << "  ..." << endl;
     }
     if (!fgDebugFlags&dbg_DumpOnlyFirstLast)
         os << "  " << (*rd) << endl;
     rdprev = rd;
     Int_t tdc = rd->GetTDC();
     if (tdc<tmin) tmin = tdc;
     if (tdc>tmax) tmax = tdc;
   }
   if (fgDebugFlags&dbg_DumpOnlyFirstLast) {
       os << "  " << (*rdprev) << endl;
       os << "  TDC range all crates [" << tmin << ":" << tmax << "]" << endl;
   }
   os << endl;
   return os;
}


//_____________________________________________________________________________

---