RawCrateMonitorBlock.cxx

Go to the documentation of this file.

// $Id: RawCrateMonitorBlock.cxx,v 1.7 2005/08/26 19:04:53 rhatcher Exp $
// 
// RawCrateMonitorBlock 
// 
// RawCrateMonitorBlock holds a block of raw digitizations
//  and knows how to unpack it into individual RawDigits
//
// Author:  R. Hatcher 2000.04.19
//

#include "RawData/RawCrateMonitorBlock.h"

enum EDebugCrateMonitorBlock {
   kdbg_ForceHexDump  = 0x0001
};
UInt_t RawCrateMonitorBlock::fgDebugFlags = 0;

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

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawCrateMonitorBlock,kMdBlockCrateMonitor,0);

ClassImp(RawCrateMonitorBlock::RawVfbMonitor)

ClassImp(RawCrateMonitorBlock)

enum ECrateMonitorBlkPos {
   indx_size       =  0,
   indx_checksum   =  1,
   indx_blockid    =  2,
   indx_run        =  3,
   indx_subrun     =  4,
   indx_runtype    = indx_subrun,
   indx_sec        =  5,
   indx_nsec       =  6,
   indx_crateid    =  7,
   indx_tf         =  8,
   indx_roptempcpu =  9,
   indx_roptempmem = 10,
   indx_roptemppmc = 11,
   indx_nfeeblks   = 12,
   zzzz_last       = 13
};

static RawCrateMonitorBlock::RawVfbMonitor    dummyVfbMonitor;
static RawCrateMonitorBlock::RawMasterMonitor dummyMasterMonitor;

//_____________________________________________________________________________
RawCrateMonitorBlock::RawCrateMonitorBlock()
  : RawDataBlock(), fCrateId()
{
   // Default constructor
}

//_____________________________________________________________________________
RawCrateMonitorBlock::RawCrateMonitorBlock(const Int_t *block)
  : RawDataBlock(block), fCrateId()
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   //  3   run #
   //  4   subRunAndType
   //  5   timestamp sec
   //  6   timestamp nsec
   //  7   crateIdentifier
   //  8   timeFrameNumber
   //  9   ropTempCpuInDegC
   // 10   ropTempMemInDegC
   // 11   ropTempPmcInDegC
   // 12   numFeeMonitorBlocks
   //  ...  some number of sub structures

}

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

//____________________________________________________________________________
RawCrateMonitorBlock& RawCrateMonitorBlock::operator=(const RawCrateMonitorBlock& rhs)
{
   // deep copy assignment 
   if (this != &rhs) {
     RawDataBlock::operator=(rhs);
     fCrateId = rhs.fCrateId;
   }
   return *this;
}

//_____________________________________________________________________________
VldTimeStamp RawCrateMonitorBlock::GetTimeStamp() const
{
   // get the timestamp
   if (fSize > indx_nsec) 
      return VldTimeStamp(fRawBlock[indx_sec],fRawBlock[indx_nsec]);

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

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

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

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

//_____________________________________________________________________________
Int_t RawCrateMonitorBlock::GetCrateIdInfo() const
{
   // get the crate id info (packed)
   if (fSize > indx_crateid) return fRawBlock[indx_crateid];
   return -1;
}

//_____________________________________________________________________________
Int_t RawCrateMonitorBlock::GetTimeFrameNum() const
{
   // get the time frame
   if (fSize > indx_tf) return fRawBlock[indx_tf];
   return -1;
}

//_____________________________________________________________________________
float RawCrateMonitorBlock::GetRopTempCpuC() const
{
   // get the ROP CPU temperature in deg C
   if (fSize > indx_roptempcpu) return fRawBlock[indx_roptempcpu];
   return -1;
}

//_____________________________________________________________________________
float RawCrateMonitorBlock::GetRopTempMemC() const
{
   // get the ROP memory temperature in deg C
   if (fSize > indx_roptempmem) return fRawBlock[indx_roptempmem];
   return -1;
}

//_____________________________________________________________________________
float RawCrateMonitorBlock::GetRopTempPmcC() const
{
   // get the ROP "pmc" temperature in deg C
   if (fSize > indx_roptemppmc) return fRawBlock[indx_roptemppmc];
   return -1;
}

//_____________________________________________________________________________
Int_t RawCrateMonitorBlock::GetNumFeeMonitors() const
{
   // get the # of FEE Monitor sub-blocks
   if (fSize > indx_nfeeblks) return fRawBlock[indx_nfeeblks];
   return -1;
}

//_____________________________________________________________________________
Int_t RawCrateMonitorBlock::GetNumVfbMonitors() const
{
   // get the # of Vfb Monitor sub-blocks
   UnpackFeeMonitors();
   return fVfbMonitors.size();
}

//_____________________________________________________________________________
const RawCrateMonitorBlock::RawVfbMonitor& 
RawCrateMonitorBlock::GetVfbMonitor(UInt_t indx) const
{
   // get the i--th Vfb Monitor sub-blocks
   size_t nvfbs = GetNumVfbMonitors();
   if (indx >= nvfbs) {
     MSG("Raw",Msg::kWarning)
       << "GetVfbMonitors() can't get index " << indx
       << " as there are only " << nvfbs << endl;
     return dummyVfbMonitor;
   }
   return fVfbMonitors[indx];
}

//_____________________________________________________________________________
const RawCrateMonitorBlock::RawVfbMonitor& 
RawCrateMonitorBlock::GetVfbMonitor(RawChannelId rcidLookFor) const
{
   // get the Vfb Monitor for a given raw channel (ignore chip,chan fields)

   if (rcidLookFor.GetElecType() != ElecType::kVA) {
     MSG("Raw",Msg::kWarning)
       << "GetVfbMonitor was supplied raw channel of wrong ElecType: "
       << rcidLookFor << endl;
     return dummyVfbMonitor;
   }

   size_t nvfbs = GetNumVfbMonitors();
   for (size_t indx = 0; indx < nvfbs; ++indx) {
     const RawVfbMonitor& vfbmon = fVfbMonitors[indx];
     // compare w/ pseudo (incomplete) RawChannelId 
     if (rcidLookFor.IsSameVfb(vfbmon.pseudo_rcid)) return vfbmon;
   }

   // fell through without finding anything appropriate
   MSG("Raw",Msg::kWarning)
       << "GetVfbMonitors() can't get find a match for " 
       << rcidLookFor << endl;
   return dummyVfbMonitor;
}

//_____________________________________________________________________________
Int_t RawCrateMonitorBlock::GetNumMasterMonitors() const
{
   // get the # of Master Monitor sub-blocks
   UnpackFeeMonitors();
   return fMasterMonitors.size();
}

//_____________________________________________________________________________
const RawCrateMonitorBlock::RawMasterMonitor&
RawCrateMonitorBlock::GetMasterMonitor(UInt_t indx) const
{
   // get the i--th Master Monitor sub-blocks
   size_t nmasters = GetNumMasterMonitors();
   if (indx >= nmasters) {
     MSG("Raw",Msg::kWarning)
       << "GetMasterMonitors() can't get index " << indx
       << " as there are only " << nmasters << endl;
     return dummyMasterMonitor;
   }
   return fMasterMonitors[indx];
}

//_____________________________________________________________________________
const RawCrateMonitorBlock::RawMasterMonitor&
RawCrateMonitorBlock::GetMasterMonitor(RawChannelId rcidLookFor) const
{
   // get the Master Monitor for a given raw channel (ignore chip,chan fields)

   if (rcidLookFor.GetElecType() != ElecType::kQIE) {
     MSG("Raw",Msg::kWarning)
       << "GetMasterMonitor was supplied raw channel of wrong ElecType: "
       << rcidLookFor << endl;
     return dummyMasterMonitor;
   }

   if (rcidLookFor.GetDetector() != GetBlockId().GetDetector() ||
       rcidLookFor.GetCrate()    != GetCrate()                    ) {
     MSG("Raw",Msg::kWarning)
       << "GetMasterMonitor was supplied wrong crate: "
       << rcidLookFor << endl;
     return dummyMasterMonitor;
   }

   UShort_t geoAddr = rcidLookFor.GetGeographicAddress();

   size_t nmasters = GetNumMasterMonitors();
   for (size_t indx = 0; indx < nmasters; ++indx) {
     const RawMasterMonitor& mastermon = fMasterMonitors[indx];
     // compare w/ pseudo (incomplete) RawChannelId 
     if ( mastermon.masterSlot == geoAddr ) return mastermon;
   }

   // fell through without finding anything appropriate
   MSG("Raw",Msg::kWarning)
       << "GetMasterMonitors() can't get find a match for " 
       << rcidLookFor << endl;
   return dummyMasterMonitor;
}

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

//_____________________________________________________________________________
std::ostream& RawCrateMonitorBlock::FormatToOStream(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 << " TimeStamp " << GetTimeStamp().AsString("c")
      << " TimeFrame " << GetTimeFrameNum() << endl;
   os << " Run " << GetRun()
      << " SubRun " << GetSubRun()
      << " RunType " << GetRunType();
   int crateid = GetCrateIdInfo();

   MsgFormat f8p3("f8.3");
   MsgFormat f9p3("f9.3");

   os << " Crate " << (crateid&0x3f)
      << " (0x" << hex << crateid << dec << ") had: " << endl
      << " ROP Temperatures (degC): "
      << f8p3(GetRopTempCpuC()) << " (CPU), "
      << f8p3(GetRopTempMemC()) << " (mem), "
      << f8p3(GetRopTempPmcC()) << " (pmc) " << endl;

   ElecType::Elec_t etype = GetElecType();
   os << " ElecType: " << ElecType::AsString(etype);
   switch(etype) {
   case ElecType::kVA:
     {
       UInt_t nvfb = GetNumVfbMonitors();
       os << ", unpacked into " << nvfb << " VfbMonitors " << endl;
       os << "       varc vfb :    grnd     asd   +rail  -rail0  -rail1  -rail2 (V)  temp (C)" << endl;
       //     xx[ii]x           -12345 -12345 -12345 -12345 -12345 -12345 1234567
       for (UInt_t indxVfb = 0; indxVfb < nvfb; ++indxVfb) {
         // print out the info for this VFB
         const RawVfbMonitor& vfbmon = GetVfbMonitor(indxVfb);
         os << "  " << "[" << setw(2) << indxVfb << "] "
            << setw(4) << vfbmon.varcId << setw(4) << vfbmon.vfbId
            << " :" 
            << f8p3(vfbmon.groundPlaneV)
            << f8p3(vfbmon.asdSupplyV)
            << f8p3(vfbmon.positiveVaRailV)
            << f8p3(vfbmon.negativeVaRail0V)
            << f8p3(vfbmon.negativeVaRail1V)
            << f8p3(vfbmon.negativeVaRail2V)
            << "   "
            << f9p3(vfbmon.vfbTempC)
           // << " [" << vfbmon.pseudo_rcid.AsString("ec") << "]"
            << endl;
       }
       break;
     };
   case ElecType::kQIE:
     {
       UInt_t nmaster = GetNumMasterMonitors();
       os << ", unpacked into " << nmaster << " MasterMonitors " << endl;
       for (UInt_t indxMaster = 0; indxMaster < nmaster; ++indxMaster) {
         // print out the info for this master
         const RawMasterMonitor& mastermon = GetMasterMonitor(indxMaster);
         os << "  " << "[" << setw(2) << indxMaster << "] "
            << " masterId " << setw(4) << mastermon.masterId << " "
            << " Slot " << setw(2) << mastermon.masterSlot << " "
            << " Ctrl " <<setw(2) << mastermon.masterCtrl 
            << " dynodeThreshold ";
         for (int ithr=0; ithr<4; ++ithr)
           os << mastermon.dynodeThreshold[ithr] << " ";
         os << endl;
         // print out the minders read out by this master
         UInt_t nminder = mastermon.fMinderMonitors.size();
         for (UInt_t indxMinder = 0; indxMinder < nminder; ++indxMinder) {
           const RawMinderMonitor& mindermon = 
             mastermon.fMinderMonitors[indxMinder];
           os << "     (" << indxMinder << ") "
              << " serial# " << setw(4) 
              << mindermon.GetMinderSerialNum() << " "
              << " slot# " << setw(2) 
              << mindermon.GetMinderSlot() << " "
              << " (0x" << hex << mindermon.minderId << dec << ") "
              << " sparsThr " << mindermon.sparsThreshold
              << endl;
         }
       }
       break;
     }
   default:
     os << " can't be unpacked (yet)." << endl;
   }
   os << endl;
   return os;
}

//_____________________________________________________________________________
void RawCrateMonitorBlock::FillCrateId() const
{
   // unpack crate info
   if (!fCrateId.IsNull()) return;
   fCrateId = RawChannelId(GetBlockId().GetDetector(),GetCrateIdInfo(),0x1fff);
}

//_____________________________________________________________________________
void RawCrateMonitorBlock::UnpackFeeMonitors() const
{
  // unpack individual monitor sub-blocks
  if (!fVfbMonitors.empty() || !fMasterMonitors.empty()) return;

  switch (GetElecType()) {
  case ElecType::kVA:  UnpackVfbMonitors(); break;
  case ElecType::kQIE: UnpackQieMonitors(); break;
  default:
    MSG("Raw",Msg::kWarning)
      << "Unpacking of data for "
      << ElecType::AsString(GetElecType())
      << " crates not yet supported" << endl;
  }

}

//_____________________________________________________________________________
void RawCrateMonitorBlock::UnpackVfbMonitors() const
{
  // unpack individual VFB monitor sub-blocks

  Int_t *varc_start, *vfb_start;
  Int_t *toofar = fRawBlock + fSize;
  Int_t  nvarc = GetNumFeeMonitors();
  Int_t  ivarc = 0;

  const  size_t sizeVarcSubBlk = 2;
  const  size_t sizeVfbSubBlk  = 8;

  varc_start = fRawBlock + indx_nfeeblks + 1;

  Detector::Detector_t det   = GetBlockId().GetDetector();
  ElecType::Elec_t     etype = GetElecType(); 
  UShort_t             crate = GetCrate();

  while (varc_start < toofar) {
    unsigned long   varcId, numVfbs;
    varcId  = varc_start[0];
    numVfbs = varc_start[1];
    vfb_start = varc_start + sizeVarcSubBlk;
    for (unsigned long currVfb = 0; currVfb < numVfbs; ++currVfb) {
      RawVfbMonitor vfbmon;

      vfbmon.varcId           = varcId;
      vfbmon.vfbId            = vfb_start[0];
      const float mVtoV = 0.001;
      const float mCtoC = 0.001;
      vfbmon.groundPlaneV     = vfb_start[1] * mVtoV;
      vfbmon.asdSupplyV       = vfb_start[2] * mVtoV;
      vfbmon.positiveVaRailV  = vfb_start[3] * mVtoV;
      vfbmon.negativeVaRail0V = vfb_start[4] * mVtoV;
      vfbmon.negativeVaRail1V = vfb_start[5] * mVtoV;
      vfbmon.negativeVaRail2V = vfb_start[6] * mVtoV;
      vfbmon.vfbTempC         = vfb_start[7] * mCtoC;
      UInt_t vmm    = vfbmon.vfbId >> 1;
      UInt_t adcsel = vfbmon.vfbId  & 1;
      const UInt_t vachip = 0;
      const UInt_t vachan = 0;
      vfbmon.pseudo_rcid = 
        RawChannelId(det,etype,crate,varcId,vmm,adcsel,vachip,vachan);
                                        
      fVfbMonitors.push_back(vfbmon);
      vfb_start += sizeVfbSubBlk;
    }
    ++ivarc;
    varc_start = vfb_start;
  }

  if (ivarc != nvarc || varc_start != toofar)
    MSG("Raw",Msg::kWarning)
      << "Unpacking reached end in an inconsistent manner"
      << " ptr @ " << varc_start << " should be " << toofar
      << " saw " << ivarc << " of " << nvarc 
      << " fee (Varc) sub-blocks " << endl;
}

//_____________________________________________________________________________
void RawCrateMonitorBlock::UnpackQieMonitors() const
{
  // unpack individual Master/Minder monitor sub-blocks

  Int_t *master_start, *minder_start;
  Int_t *toofar = fRawBlock + fSize;
  Int_t  nmasters = GetNumFeeMonitors();
  Int_t  imaster = 0;

  const  size_t sizeMasterSubBlk = 8;
  const  size_t sizeMinderSubBlk = 2;
  
  master_start = fRawBlock + indx_nfeeblks + 1;
    
  //Detector::Detector_t det   = GetBlockId().GetDetector();
  //ElecType::Elec_t         etype = GetElecType(); 
  //UShort_t                 crate = GetCrate();

  while (master_start < toofar) {
    RawMasterMonitor mastermon;
    mastermon.masterId           = master_start[0];
    mastermon.masterSlot         = master_start[1];
    mastermon.masterCtrl         = master_start[2];
    mastermon.dynodeThreshold[0] = master_start[3];
    mastermon.dynodeThreshold[1] = master_start[4];
    mastermon.dynodeThreshold[2] = master_start[5];
    mastermon.dynodeThreshold[3] = master_start[6];
    unsigned long numMinders     = master_start[7];
    minder_start = master_start + sizeMasterSubBlk;
    for (unsigned long currMinder = 0; currMinder < numMinders; ++currMinder) {
      RawMinderMonitor mindermon;
      mindermon.minderId         = minder_start[0];
      mindermon.sparsThreshold   = minder_start[1];  
      mastermon.fMinderMonitors.push_back(mindermon);
      minder_start += sizeMinderSubBlk;
    }
    ++imaster;
    fMasterMonitors.push_back(mastermon);
    master_start = minder_start;
  }

  if (imaster != nmasters || master_start != toofar)
    MSG("Raw",Msg::kWarning)
      << "Unpacking reached end in an inconsistent manner"
      << " ptr @ " << master_start << " should be " << toofar
      << " saw " << imaster << " of " << nmasters 
      << " fee (Master) sub-blocks " << endl;
}

//_____________________________________________________________________________

---