RawSparsifierTableBlock.cxx

Go to the documentation of this file.

// $Id: RawSparsifierTableBlock.cxx,v 1.13 2009/02/28 21:46:16 gmieg Exp $
// 
// RawSparsifierTableBlock 
// 
// RawSparsifierTableBlock holds the Sparsifier Table info
//
// Author:  R. Hatcher 2001.11.20
//
#include <cstring>

#include "RawData/RawSparsifierTableBlock.h"
#include "RawData/RawCrateStatus.h"

UInt_t RawSparsifierTableBlock::fgDebugFlags = 0;
enum EDebugSparsifierTableBlock {
  kdbg_ForceHexDump = 0x00000001
};

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

#include "MessageService/MsgService.h"
CVSID("$Id: RawSparsifierTableBlock.cxx,v 1.13 2009/02/28 21:46:16 gmieg Exp $");

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawSparsifierTableBlock,kMdBlockSparsifierTable,0);

ClassImp(RawSparsifierTableBlock)

enum ESparsifierTableBlkPos {
   indx_size     = 0,
   indx_checksum = 1,
   indx_blockid  = 2,
   indx_run      = 3,
   indx_subrun   = 4,
   indx_runtype  = indx_subrun,
   indx_loadsec  = 5,
   indx_loadnsec = 6,
   indx_crateid  = 7,
   indx_nvalues  = 8,
   zzzz_last     = 9
};

//_____________________________________________________________________________
RawSparsifierTableBlock::RawSparsifierTableBlock()
   : fRawCrateStatus(0)
{
   // Default constructor
}

//_____________________________________________________________________________
RawSparsifierTableBlock::RawSparsifierTableBlock(const Int_t *block)
   : RawDataBlock(block), fRawCrateStatus(0)
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   //  3   Run Number
   //  4   SubRun | RunType
   //  5   Load Time (sec)
   //  6   Load Time (ns)
   //  7   CrateId (+ special bits)
   //  8   # of pedestals to follow
   //  ... packed two entries per 32-bit word
   //      varc [0..2] vmm [0..5] adcsel [0..1] chip [0..2] channel [0..21]
}

//_____________________________________________________________________________
RawSparsifierTableBlock::~RawSparsifierTableBlock()
{
   // dtor
   if (fRawCrateStatus) delete fRawCrateStatus;
   fRawCrateStatus = 0;
}

//____________________________________________________________________________
RawSparsifierTableBlock& RawSparsifierTableBlock::operator=(const RawSparsifierTableBlock& rhs)
{
   // deep copy assignment 
  if (this != &rhs) {
    RawDataBlock::operator=(rhs);
    if (fRawCrateStatus) { delete fRawCrateStatus; fRawCrateStatus = 0; }
  }
  return *this;
}

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

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

   RawDataBlock::FormatToOStream(os,option);
   if (option[0] == 'X') return os;
   
   // additional block specific formatted output is done here

   os << " Loaded " << GetLoadTime().AsString("c") << endl;
   os << " Run " << GetRun() 
      << " SubRun " << GetSubRun() 
      << " RunType " << GetRunType() << endl; 
   os << " " << *GetCrateStatus();
   os << " " << GetNumberOfValues() << " pedestal values" << endl;

   if (strchr(option,'q') != 0) return os;

   Int_t  indx, value;
   RawChannelId rcid;

   switch (GetElecType()) {
   case (ElecType::kVA): {
      for (indx=0; indx<GetNumberOfValues(); indx++) {
         GetThresholdValue(indx,rcid,value);
//test alternative lookup method
//         Int_t value2 = GetThresholdValue(rcid);
         os << "   [" << setw(4) << indx << "] " 
            << rcid.AsString("e") << " := " << setw(5) << value 
//test alternative lookup method
//              << ((value != value2) ? " bad indexind " : " lookup ok")
            << endl;
      }
      break;
   }
   case (ElecType::kQIE):
      // not yet implemented ... fall through
   default:
      MSG("RawData",Msg::kWarning)
         << "Print not implemented for electronics type "
         << ElecType::AsString(GetElecType()) << endl;
   }

   return os;
}

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

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

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

//_____________________________________________________________________________
VldTimeStamp RawSparsifierTableBlock::GetLoadTime() const
{
   // get the start time
   if (fSize >= zzzz_last) 
      return VldTimeStamp(fRawBlock[indx_loadsec],fRawBlock[indx_loadnsec]);

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

//_____________________________________________________________________________
const RawCrateStatus* RawSparsifierTableBlock::GetCrateStatus() const
{
   // get the crate id --> status
   if (fRawCrateStatus) return fRawCrateStatus;

   if (fSize > indx_crateid) {
      const Int_t* crateid_ptr = fRawBlock+indx_crateid;
      fRawCrateStatus = new RawCrateStatus(GetBlockId(),crateid_ptr);
                                           
      return fRawCrateStatus;
   }
   return 0;
}

//_____________________________________________________________________________
Int_t RawSparsifierTableBlock::GetNumberOfValues() const
{
   // get the number of pedestals
   if (fSize > indx_nvalues) return fRawBlock[indx_nvalues];
   return -1;
}

//_____________________________________________________________________________
void RawSparsifierTableBlock::GetThresholdValue(Int_t indx, RawChannelId& rcid,
                                        Int_t& value) const
{
   if (indx >= GetNumberOfValues()) {
      rcid  = RawChannelId();
      value = -1;
      return;
   }

   RawBlockId rbid = GetBlockId();

   switch (GetElecType()) {
   case (ElecType::kVA): {
      // VA electronics
      // packed varc[0..2] XYZZY[0..12] chip[0..2] chann[0..21]
      Int_t tmp = indx;
      Int_t vachan = tmp%22;  tmp /= 22;
      Int_t vachip = tmp%3;   tmp /= 3;
      Int_t xyzzy  = tmp%12;  tmp /= 12;  
      Int_t adcsel = xyzzy&1;
      Int_t vmm    = xyzzy>>1;
      Int_t varc   = tmp%3;   tmp /= 3;

      rcid = RawChannelId(rbid.GetDetector(),
                          fRawCrateStatus->GetElecType(),
                          fRawCrateStatus->GetCrate(),
                          varc,vmm,adcsel,vachip,vachan);
      rcid.SetModeBits(fRawCrateStatus->GetCommonMode(),
                       fRawCrateStatus->GetSparsMode(),
                       fRawCrateStatus->GetPedMode());
      Int_t offset = indx/2;
      if (indx&1) {
         // odd indices == lower half of word
         value = fRawBlock[zzzz_last+offset] & 0xffff;
      }
      else {
         // even indices == upper half of word
         value = (fRawBlock[zzzz_last+offset] >> 16) & 0xffff;
      }
      break;
   }
   case (ElecType::kQIE):
      // not yet implemented ... fall through
   default:
      MSG("RawData",Msg::kWarning)
         << "GetThresholdValue not implemented for electronics type "
         << ElecType::AsString(GetElecType()) << endl;
   }
   }

//_____________________________________________________________________________
Int_t RawSparsifierTableBlock::GetThresholdValue(const RawChannelId& rcid) const
{
   Int_t indx = -1;

   RawBlockId rbid = GetBlockId();

   const Int_t kBadValue = -1;

   if (GetElecType() != rcid.GetElecType()) {
      MSG("RawData",Msg::kWarning)
         << "RawChannelId " << rcid 
         << " does not match ElecType of crate "
         << ElecType::AsString(fRawCrateStatus->GetElecType())
         << endl;
      return kBadValue;
   }

   if (fRawCrateStatus->GetCrate() != rcid.GetCrate()) {
      MSG("RawData",Msg::kWarning)
         << "RawChannelId " << rcid 
         << " does not match of crate # of table "
         << fRawCrateStatus->GetCrate()
         << endl;
      return kBadValue;
   }

   switch (GetElecType()) {
   case (ElecType::kVA): {
      // VA electronics
      // packed varc[0..2] XYZZY[0..12] chip[0..2] chann[0..21]
      Int_t vachan = rcid.GetVaChannel();
      Int_t vachip = rcid.GetVaChip();
      Int_t adcsel = rcid.GetVaAdcSel();
      Int_t vmm    = rcid.GetVmm();
      Int_t varc   = rcid.GetVarcId();
      Int_t xyzzy    = (vmm<<1) + adcsel;
      indx = (((varc)*12 + xyzzy)*3 + vachip)*22 + vachan;

      if (indx<0 || indx> GetNumberOfValues()) {
         MSG("RawData",Msg::kWarning)
            << "calulated index out of range "
            << indx << " (max " << GetNumberOfValues() << ")" << endl;
            return kBadValue;
      }
      
      Int_t offset = indx/2;
      if (indx&1) {
         // odd indices == lower half of word
         return fRawBlock[zzzz_last+offset] & 0xffff;
      }
      else {
         // even indices == upper half of word
         return (fRawBlock[zzzz_last+offset] >> 16) & 0xffff;
      }
    
      return kBadValue;
      break;
   }
   case (ElecType::kQIE):
      // not yet implemented ... fall through
   default:
      MSG("RawData",Msg::kWarning)
         << "GetThresholdValue not implemented for electronics type "
         << ElecType::AsString(GetElecType()) << endl;
      return kBadValue;
      break;
   }

   return kBadValue;

}

//_____________________________________________________________________________

---