RawQieErrorStatsBlock.cxx

Go to the documentation of this file.

// $Id: RawQieErrorStatsBlock.cxx,v 1.3 2005/01/14 00:20:18 rhatcher Exp $
// 
// RawQieErrorStatsBlock 
// 
// RawQieErrorStatsBlock holds the Qie Error statistics info
//
// Author:  R. Hatcher 2005.01.11
//

#include "RawData/RawQieErrorStatsBlock.h"

enum EDebugQieErrorStatsBlock {
   kdbg_ForceHexDump  = 0x0001
};
UInt_t RawQieErrorStatsBlock::fgDebugFlags = 0;

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

#include "MessageService/MsgService.h"
CVSID("$Id: RawQieErrorStatsBlock.cxx,v 1.3 2005/01/14 00:20:18 rhatcher Exp $");

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawQieErrorStatsBlock,kMdBlockQieErrorStats,0);

ClassImp(RawQieErrorStatsBlock)

enum EErrorStatsBlkPos {
   indx_size      =  0,
   indx_checksum  =  1,
   indx_blockid   =  2,
   indx_run       =  3,
   indx_subrun    =  4,
   indx_runtype   = indx_subrun,
   indx_startsec  =  5,
   indx_startnsec =  6,
   indx_endsec    =  7,
   indx_endnsec   =  8,
   indx_nerrtypes =  9,
   zzzz_last      = 11
};

//_____________________________________________________________________________

static Int_t knownListOrder[] = { RawQieDigit::kParityError,
                                  RawQieDigit::kCapIdError,
                                  RawQieDigit::kMisCountError };
static Int_t nknownLists = sizeof(knownListOrder)/sizeof(Int_t);
static Int_t unknownListCode = 0x7FFFFFFF;

//_____________________________________________________________________________
RawQieErrorStatsBlock::RawQieErrorStatsBlock() 
  : RawDataBlock(), fUnpacked(false)
{
   // Default constructor
}

//_____________________________________________________________________________
RawQieErrorStatsBlock::RawQieErrorStatsBlock(const Int_t *block)
  : RawDataBlock(block), fUnpacked(false)
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   //  3   run #
   //  4   {subrun#| run type}
   //  5   start time (sec)
   //  6   start time (nsec)
   //  7   end time (sec)
   //  8   end time (nsec)
   //  9   # of error types
   // 10   NPE = # of errors of type: parity
   // 11   channel w/ parity error upper 16=chadd, lower 16=crate#
   // 12   # errors on this channel
   // ..   {channel / count}  pairs
   // 12+2*NPE:  NCE = # of error of type: cap id
   // ..
   // 12+2*NPE+1+2*NCE:  NWE = # of errors of type: word count
   // ..
}

//_____________________________________________________________________________
RawQieErrorStatsBlock::RawQieErrorStatsBlock(const VldContext& vldc_start, 
                                             const VldTimeStamp& time_end, 
                                             Int_t run,
                                             Short_t subrun, Short_t runtype,
                                             Int_t nerrtypes)
  : RawDataBlock(), fUnpacked(false)
{
   // Component ctor

   fSize = zzzz_last + nerrtypes;
   if (fRawBlock) delete [] fRawBlock;
   fRawBlock = new Int_t [fSize];

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

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

   Bool_t isDCS   = rbp->IsDCS();
   Int_t  majorId = rbp->GetMajorId();
   Int_t  minorId = 0;
   RawBlockId rbid(majorId,minorId,isDCS,
                   vldc_start.GetDetector(),vldc_start.GetSimFlag());
   fRawBlock[2] = rbid.GetEncoded();

   fRawBlock[indx_run]        = run;
   fRawBlock[indx_subrun]     = (subrun&0xffff)<<16 | (runtype&0xffff);
   fRawBlock[indx_startsec]   = vldc_start.GetTimeStamp().GetSec();
   fRawBlock[indx_startnsec]  = vldc_start.GetTimeStamp().GetNanoSec();
   fRawBlock[indx_endsec]     = time_end.GetSec();
   fRawBlock[indx_endnsec]    = time_end.GetNanoSec();
   fRawBlock[indx_nerrtypes]  = nerrtypes;

   for (Int_t i=0; i<nerrtypes; i++) {
      Int_t ioff = zzzz_last + i;
      fRawBlock[ioff+0] = 0;   // error counts for each type
   }

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

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

//_____________________________________________________________________________
RawQieErrorStatsBlock& 
RawQieErrorStatsBlock::operator=( const RawQieErrorStatsBlock& rhs)
{
   // deep copy assignment
   if (this != &rhs) {
     RawDataBlock::operator=(rhs);
     // clear the unpacked info to allow it to be re-filled
     ClearAllMaps();
   }
   return *this;
}

//_____________________________________________________________________________
VldTimeStamp RawQieErrorStatsBlock::GetStartTime() const
{
   // get the start time
   if (fSize >= zzzz_last) 
      return VldTimeStamp(fRawBlock[indx_startsec],fRawBlock[indx_startnsec]);

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

//_____________________________________________________________________________
VldTimeStamp RawQieErrorStatsBlock::GetEndTime() const
{
   // get the end time
   if (fSize >= zzzz_last) 
      return VldTimeStamp(fRawBlock[indx_endsec],fRawBlock[indx_endnsec]);

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

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

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

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

//_____________________________________________________________________________
Int_t RawQieErrorStatsBlock::GetNumberOfErrTypes() const
{
   // get the number of error types reported by block
   if (fSize >= zzzz_last) return fRawBlock[indx_nerrtypes];
   return -1;
}

//_____________________________________________________________________________
Int_t RawQieErrorStatsBlock::GetTotalErrChannels() const
{
   // get the total number of channels with error
   if (fSize >= zzzz_last) {
     Int_t pairs =  fSize - (zzzz_last-1) - GetNumberOfErrTypes();
     return pairs >> 1;
   }
   return -1;
}

//_____________________________________________________________________________
Int_t RawQieErrorStatsBlock::GetNumOfErrChannels(RawQieDigit::EQieErrorCode errcode) const
{
   // get the number of channels with errors of a particular type
   return GetErrorList(errcode).size();
}

//_____________________________________________________________________________
const std::map<RawChannelId,UInt_t>& 
RawQieErrorStatsBlock::GetErrorList(RawQieDigit::EQieErrorCode errcode) const
{
   // get the unpacked list
   FillAllMaps();  // unpack the data
   return GetNonConstListRef(errcode);  // const-ness when returned!
}

//_____________________________________________________________________________
std::map<RawChannelId,UInt_t>& 
RawQieErrorStatsBlock::GetNonConstListRef(Int_t errcode) const
{

   switch ( errcode ) {
   case RawQieDigit::kParityError:   return fParityErrorList;
   case RawQieDigit::kCapIdError:    return fCapIdErrorList;
   case RawQieDigit::kMisCountError: return fMisCountErrorList;
   default:                          return fUnknownErrorList;
   }
}

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

//_____________________________________________________________________________
void RawQieErrorStatsBlock::FillAllMaps() const
{
   // unpack the data

   if ( fUnpacked ) return; // already unpacked
   fUnpacked = true;

   Detector::Detector_t det = GetBlockId().GetDetector();
   Int_t indx_cur = zzzz_last - 1; // just before first sublist

   for (int isublist = 0; isublist < GetNumberOfErrTypes(); ++isublist ) {
     Int_t listKey = unknownListCode;
     if ( isublist < nknownLists ) {
       listKey = knownListOrder[isublist];
     }
     else {
       MSG("RawData",Msg::kWarning)
         << "RawQieErrorStatsBlock has " << GetNumberOfErrTypes()
         << " sub-lists, but unpacker was expecting no more than "
         << knownListOrder << endl;
     }
     if ( fSize < indx_cur ) {
       MSG("RawData",Msg::kWarning)
         << "RawQieErrorStatsBlock  fSize=" << fSize
         << " but expected sub-list to start at index=" << indx_cur
         << endl;
       return;
     }
     Int_t nInList = fRawBlock[indx_cur++];
     std::map<RawChannelId,UInt_t>& curList = GetNonConstListRef(listKey);
     for (int inlist = 0; inlist < nInList; ++inlist) {
       if ( fSize < indx_cur ) {
         MSG("RawData",Msg::kWarning)
           << "RawQieErrorStatsBlock  fSize=" << fSize
           << " but saw end before processing inlist=" << inlist
           << " of sub-list=" << isublist
           << endl;
         return;
           
       }
       Int_t funky = fRawBlock[indx_cur++];
       Int_t count = fRawBlock[indx_cur++];
       // Geoff says these have no extraneous bits (error bits)
       UInt_t crate = funky & 0xFF;
       UInt_t chadd = funky >> 16;
       // only for QIE!
       RawChannelId rcid(det,ElecType::kQIE,crate,chadd);
       curList[rcid] = count;
     }

   }

   if ( indx_cur != fSize ) {
     MSG("RawData",Msg::kWarning)
       << "RawQieErrorStatsBlock  fSize=" << fSize
       << " but finished at index=" << indx_cur
       << endl;
   }

}

//_____________________________________________________________________________
void RawQieErrorStatsBlock::ClearAllMaps() const
{
   // clear the unpacked data

   fUnpacked = false;
   fParityErrorList.clear();
   fCapIdErrorList.clear();
   fMisCountErrorList.clear();
   fUnknownErrorList.clear();

}

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

   if (fgDebugFlags & kdbg_ForceHexDump) option = "x";

   RawDataBlock::FormatToOStream(os,option);
   if (option[0] == 'X') return os;

   os << " Start " << GetStartTime().AsString("c") << endl;
   os << " End   " << GetEndTime().AsString("c") << endl;
   os << " Run " << GetRun() 
      << " SubRun " << GetSubRun() 
      << " RunType " << GetRunType() << endl; 
   os << "   " << GetNumberOfErrTypes() << " error types, "
      << GetTotalErrChannels() << " total channels: " << endl;

   for (int iList = 0; iList<=nknownLists; iList++) {
     Int_t keyList = unknownListCode;
     if (iList<nknownLists) keyList = knownListOrder[iList];

     RawQieDigit::EQieErrorCode errcode = (RawQieDigit::EQieErrorCode)keyList;

     const std::map<RawChannelId,UInt_t>& listChannels = GetErrorList(errcode);
     size_t nentries = listChannels.size();

     // if the unknown error code list is empty don't print it
     if ( keyList == unknownListCode && nentries == 0 ) break;

     os << "   List of errors of type: "
        << RawQieDigit::AsString(errcode)
        << " (" << nentries << " entries)"
        << endl;

     std::map<RawChannelId,UInt_t>::const_iterator mapItr = 
       listChannels.begin(); 
     while ( mapItr != listChannels.end() ) {
       RawChannelId rcid = mapItr->first;
       UInt_t count      = mapItr->second;
       os << "     " << rcid.AsString("ec")
          << "     " << setw(8) << count
          << endl;
       mapItr++;  // move on
     }
   }
   return os;
}

//_____________________________________________________________________________

---