RawDeadChipBlock.cxx

Go to the documentation of this file.

// $Id: RawDeadChipBlock.cxx,v 1.11 2005/08/26 19:04:53 rhatcher Exp $
// 
// RawDeadChipBlock 
// 
// RawDeadChipBlock holds list of dead chips as gleaned from BRP info
//
// Author:  R. Hatcher 2001.11.07
//

#include "RawData/RawDeadChipBlock.h"

UInt_t RawDeadChipBlock::fgDebugFlags = 0;
UInt_t RawDeadChipBlock::fgStdVaChannel = 0;

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

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawDeadChipBlock,kMdBlockVaDeadChips,0);

ClassImp(RawDeadChipBlock)

enum EDeadChipBlkPos {
   indx_size      = 0,
   indx_checksum  = 1,
   indx_blockid   = 2,
   zzzz_last      = 3
};

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

//_____________________________________________________________________________
RawDeadChipBlock::RawDeadChipBlock(const Int_t *block)
   : RawDataBlock(block), fUnpacked(false)
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   //  3      # dead chips in crate 0
   //  4      chad for 0th dead chip (chan=0)
   //  5      chad ...
   //  3+N0   # dead chips in crate 1
   //  3+N0+1 chad for 0th dead chip (chan=0)
   //   ...
}

//_____________________________________________________________________________
RawDeadChipBlock::RawDeadChipBlock(const VldContext& vldc,
                                   const RawChannelIdSet& inset)
   : RawDataBlock(), fUnpacked(false)
{
   // create a RawDeadChipBlock from a list of RawChannelId's

   // find crate # of last element (assume sorted by set)
   Int_t ncrates = 0;
   Int_t *crate_count = 0;
   if (inset.size()>0) {
      RawChannelId rcid_last = *inset.rbegin();
      ncrates = rcid_last.GetCrate() + 1;  // crate numbering starts at 0
      // build list of how many entries for each crate
      crate_count = new Int_t [ncrates];
      for (int i=0; i<ncrates; i++) crate_count[i] = 0;
      RawChannelIdSetConstIter iter = inset.begin();
      while (iter != inset.end()) {
         RawChannelId rcid = *iter;
         crate_count[rcid.GetCrate()] += 1;
         iter++;
      }
   }
   // 3 words of header + count for each crate (no skips) + # of chips
   fSize = 3 + ncrates + inset.size();
   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("RawDeadChipBlock");
 
   Bool_t isDCS   = rbp->IsDCS();
   Int_t  majorId = rbp->GetMajorId();
   Int_t  minorId = 0;
   RawBlockId rbid(majorId,minorId,isDCS,
                   vldc.GetDetector(),vldc.GetSimFlag());
   fRawBlock[2] = rbid.GetEncoded();

   Int_t *p = fRawBlock + 3;
   Int_t this_crate = -1;
   RawChannelIdSetConstIter iter = inset.begin();
   while (iter != inset.end()) {
      RawChannelId rcid = *iter;
      while (this_crate != rcid.GetCrate()) {
         this_crate++;
         *p = crate_count[this_crate];
         p++;
      }
      *p = rcid.GetChAdd();
      p++;
      iter++;
   }


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

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

//____________________________________________________________________________
RawDeadChipBlock& RawDeadChipBlock::operator=(const RawDeadChipBlock& rhs)
{
   // deep copy assignment 
   if (this != &rhs) {
     RawDataBlock::operator=(rhs);
     // clear the unpacked info to allow it to be re-filled
     fUnpacked = false;
     fDeadChannels.clear();
   }
   return *this;
}

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

   // additional block specific formatted output is done here

   FillDeadChannels();
   RawChannelIdSetConstIter iter = fDeadChannels.begin();
   while (iter != fDeadChannels.end()) {
      RawChannelId rcid = *iter;
      os << " " << rcid.AsString("e") << " was dead " << endl;
      iter++;
   }
   return os;
}

//_____________________________________________________________________________
void RawDeadChipBlock::FillDeadChannels() const
{
   // unpack the data into a STL set of RawChannelId's

   if (fUnpacked) return;

   Detector::Detector_t det = GetBlockId().GetDetector();
   // assume this block is only sensible for VA electronics
   ElecType::Elec_t elec = ElecType::kVA;

   Int_t  crate = -1;
   Int_t* ptr = fRawBlock+zzzz_last;
   while (ptr < fRawBlock+fSize) {
      // start of new crate
      crate++;
      int ndead = *ptr; ptr++;
      for (int i=0; i<ndead; i++) {
         Int_t chad = *ptr; ptr++;
         RawChannelId rcid0(det,elec,crate,chad);
         rcid0.ClearModeBits();   // standardize mode bits
         // only one entry for every va *chip* so vachannel is irrelevant
         // but standardize it so that lookup can proceed
         rcid0.SetVaChannel(fgStdVaChannel);
         fDeadChannels.insert(rcid0);
      }
   }
}

//_____________________________________________________________________________
Bool_t RawDeadChipBlock::ChipWasDead(const RawChannelId& rcid) const
{ 
   // look up whether chip was registered as dead
   FillDeadChannels();

   // table was built with {pedestal,spars,common} mode bits off
   RawChannelId rcid0 = rcid;
   rcid0.ClearModeBits();   // standardize mode bits
   // only one entry for every va *chip* so vachannel is irrelevant
   // but standardize it so that lookup can proceed
   rcid0.SetVaChannel(fgStdVaChannel);

   return fDeadChannels.end() != fDeadChannels.find(rcid0); 
}
//_____________________________________________________________________________

---