RawTpSinglesSummaryBlock.cxx

Go to the documentation of this file.

// $Id: RawTpSinglesSummaryBlock.cxx,v 1.24 2009/02/28 21:46:16 gmieg Exp $
// 
// RawTpSinglesSummaryBlock 
// 
// RawTpSinglesSummaryBlock holds the trigger processor 
// singles rate summary
//
// Author:  R. Hatcher 2001.05.11
//
#include <cstring>

#include "RawData/RawTpSinglesSummaryBlock.h"
#include "RawData/RawCrateStatus.h"  // used for shift info

enum EDebugTpSinglesSummaryBlock {
   kdbg_ForceHexDump  = 0x0001
};
UInt_t RawTpSinglesSummaryBlock::fgDebugFlags = 0;

#include <iomanip>

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

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawTpSinglesSummaryBlock,kMdBlockTpSummarySingles,0);

ClassImp(RawTpSinglesSummaryBlock)

enum ESnarlHeaderBlkPos {
   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_src       =  9,
   indx_ncrates   = 10,
   zzzz_last      = 11
};

//_____________________________________________________________________________
RawTpSinglesSummaryBlock::RawTpSinglesSummaryBlock() : RawDataBlock()
{
   // Default constructor
}

//_____________________________________________________________________________
RawTpSinglesSummaryBlock::RawTpSinglesSummaryBlock(const Int_t *block)
   : RawDataBlock(block)
{
   //  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   source
   // 10   number of crates
   // 11   hits/sec from crate 0
   // 12   hits/sec from crate 1
   //      ...

}
//_____________________________________________________________________________
RawTpSinglesSummaryBlock::RawTpSinglesSummaryBlock(
   Detector::Detector_t detector, SimFlag::SimFlag_t simflg,
   Int_t run, Short_t subrun, Short_t runtype,
   VldTimeStamp start, VldTimeStamp end,
   Int_t src, Int_t ncrates, Int_t* hitsPerSec)
   : RawDataBlock()
{
   // Component ctor

   fSize = zzzz_last + ncrates;
   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("RawTpSinglesSummaryBlock");

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

   fRawBlock[indx_run]    = run;
   fRawBlock[indx_subrun] = (subrun&0xffff)<<16 | (runtype&0xffff);

   fRawBlock[indx_startsec]  = start.GetSec();
   fRawBlock[indx_startnsec] = start.GetNanoSec();

   fRawBlock[indx_endsec]  = end.GetSec();
   fRawBlock[indx_endnsec] = end.GetNanoSec();

   fRawBlock[indx_src] = src;

   fRawBlock[indx_ncrates] = ncrates;

   for (Int_t i=0; i<ncrates; i++) 
      fRawBlock[zzzz_last+i] = hitsPerSec[i];
   
   // fill checksum
   rdxsum_fill((long*)fRawBlock,0); 

}

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

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

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

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

//_____________________________________________________________________________
VldTimeStamp RawTpSinglesSummaryBlock::GetStartTimeStamp() const
{
   // get the starting time stamp
   if (fSize >= zzzz_last) 
      return VldTimeStamp(fRawBlock[indx_startsec],fRawBlock[indx_startnsec]);

   return VldTimeStamp();
}

//_____________________________________________________________________________
VldTimeStamp RawTpSinglesSummaryBlock::GetEndTimeStamp() const
{
   // get the ending time stamp
   if (fSize >= zzzz_last) 
      return VldTimeStamp(fRawBlock[indx_endsec],fRawBlock[indx_endnsec]);
   return VldTimeStamp();
}

//_____________________________________________________________________________
Int_t RawTpSinglesSummaryBlock::GetSource() const
{
   // get the "source"
   if (fSize >= zzzz_last) return fRawBlock[indx_src];
   return 0;
}

//_____________________________________________________________________________
Int_t RawTpSinglesSummaryBlock::GetNumberOfCrates() const
{
   // get the number of crates with hits/sec info
   if (fSize >= zzzz_last) return fRawBlock[indx_ncrates];
   return 0;
}

//_____________________________________________________________________________
const Int_t* RawTpSinglesSummaryBlock::GetHitsPerSecArray() const
{
   // get access to the array of hits/sec
   if (fSize >= zzzz_last) return fRawBlock+zzzz_last;
   return 0;
}

//_____________________________________________________________________________
Int_t RawTpSinglesSummaryBlock::GetHitsPerSecByCrate(Int_t crate) const
{
   // get the hits/sec by crate #
   if (fSize > zzzz_last+crate) 
      return fRawBlock[zzzz_last+crate];
   return -1;
}

//_____________________________________________________________________________
std::ostream& RawTpSinglesSummaryBlock::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

  Int_t src = GetSource();

  os << " Run " << GetRun()
     << " SubRun " << GetSubRun() 
     << " RunType " << GetRunType()
     << " : " 
     << " Source " << src << " (";
  switch (src) {
  case 0:  os << "Crate only";                  break;
  case 1:  os << "Crate and VARC";              break;
  case 2:  os << "Crate and VFB/ADCSEL";        break;
  case 3:  os << "Crate and VACHIP";            break;
  case 4:  os << "Crate and Plane";             break;
  case 5:  os << "Crate and MASTER";            break;
  case 6:  os << "Crate and MINDER";            break;
  case 7:  os << "Crate and MENU";              break;
  default: os << "Crate and ??";                break;
  }
  os << ")" << endl;
  os << " Start " << GetStartTimeStamp() << endl;
  os << " End   " << GetEndTimeStamp() << endl;
  for (Int_t i=0; i<GetNumberOfCrates(); i++) 
     os << "   crate " << setw(3) << i << ": "
          << setiosflags(ios::right)
          << setw(8) << GetHitsPerSecByCrate(i) 
          << setiosflags(ios::left)
          << " hits/sec" << endl;

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

  typedef std::map<RawChannelId,UInt_t> RCIdToRateMap;
  const RCIdToRateMap&  chnrates = GetChannelRates();  // force unpacking

  if ( src >= 1 && src <= 3 ) {
    // 1=VARC 2=VFB 3=VA chip

    os << "  " << chnrates.size() << " individual rates " << endl;
    // n.b. 2304 = 16crates * 4varcs * 12 vfbs * 3chips

    RCIdToRateMap::const_iterator rateItr = chnrates.begin();
    RCIdToRateMap::const_iterator rateEnd = chnrates.end();
    RawChannelId rcid_last(0xffffffff);    // garbage id
    rcid_last.SetElecType(ElecType::kVA);  // make it VA
    //cout << "fake rcid " << rcid_last.AsString("ec") << endl;

    while ( rateItr != rateEnd ) {
      RawChannelId  rcid = rateItr->first;
      Int_t        arate = rateItr->second;
    
      if ( rcid.GetCrate() != rcid_last.GetCrate() ) 
        os << endl << "  Crate: " << setw(2) << rcid.GetCrate() << " ";

      if ( src == 1 ) {
        UShort_t varcid = rcid.GetVarcId();
        if ( varcid == 0) os << " VarcId: ";
        os << "  [" << varcid << "] " 
             << setw(6) << arate << " ";  // series of [varc] rates
      }
      else {
        // (possibly) random varcs
        // src=2: series of vfb rates
        // src=3: series of vfb/chip rates
        if ( src == 2 ) {
          if ( rcid.GetVarcId() != rcid_last.GetVarcId() ) 
            os << endl << "    Varc: " << rcid.GetVarcId() << " ";
          os << "[" << setw(2) << rcid.GetVfb() << "] "
               << setw(5) << arate << " ";  // series of [vfb] rates
        }
        else {
          if ( rcid.GetVarcId() != rcid_last.GetVarcId() || 
               rcid.GetVfb()    != rcid_last.GetVfb() ) 
            os << endl << "    Varc: " << rcid.GetVarcId() 
                 << " Vfb: " << setw(2) << rcid.GetVfb() << "   ";
          os << "[" << rcid.GetVaChip() << "] "
               << setw(5) << arate << " ";  // series of [vachip] rates
        }
      }
      
      rateItr++;
      rcid_last = rcid;
    } // loop over channel map
  } // src = 1,2,3
  else if ( src == 4 ) {
    // 4=plane
    const std::vector<UInt_t> plnrates = GetPlaneRates(); // get reference
    os << "  " << plnrates.size() << " plane rates " << endl << "  ";
    const size_t nplnline = 5; 
    size_t iplnline=0;
    for (size_t ipln=0; ipln<plnrates.size(); ++ipln) {
      os << "  [" << setw(4) << ipln 
         << "] " << setw(6) << plnrates[ipln];        
      if (++iplnline==nplnline) { os << endl << "  "; iplnline=0; }
    }
    if (iplnline!=0) os << endl;
  } // src = 4
  else if ( src >= 5 && src <= 7 ) {
    // 5=MASTER, 6=MINDER, 7=MENU
      
    os << "  " << chnrates.size() << " individual rates " << endl;
    // n.b. 2304 = 16crates * 4varcs * 12 vfbs * 3chips

    RCIdToRateMap::const_iterator rateItr = chnrates.begin();
    RCIdToRateMap::const_iterator rateEnd = chnrates.end();
    RawChannelId rcid_last(0xffffffff);    // garbage id
    rcid_last.SetElecType(ElecType::kQIE);  // make it QIE
    //cout << "fake rcid " << rcid_last.AsString("ec") << endl;

    while ( rateItr != rateEnd ) {
      RawChannelId  rcid = rateItr->first;
      Int_t        arate = rateItr->second;
    
      if ( rcid.GetCrate() != rcid_last.GetCrate() ) 
        os << endl << "  Crate: " << setw(2) << rcid.GetCrate() << " ";

      if ( src == 5 ) {
        UShort_t master = rcid.GetGeographicAddress();
        if ( master != rcid_last.GetGeographicAddress() ) 
          os << endl << "      " << " Master: ";
        os << "  [" << setw(2) << master << "] " 
             << setw(6) << arate << " ";  // series of [master] rates
      }
      else {
        // (possibly) random masters
        // src=6: series of minder rates
        // src=7: series of minder/menu rates
        const size_t nminderline = 6;
        static size_t iminderline = 0;
        if ( src == 6 ) {
          if ( rcid.GetGeographicAddress() != 
               rcid_last.GetGeographicAddress() ) {
            iminderline = 0;
            os << endl << "    Master: " << setw(2) 
               << rcid.GetGeographicAddress() 
               << endl << "      ";
          }
          os << "[" << setw(2) << rcid.GetMasterChannel() << "] "
               << setw(5) << arate << " ";  // series of [minder] rates
        }
        else {
          if ( rcid.GetGeographicAddress() != rcid_last.GetGeographicAddress() || 
               rcid.GetMasterChannel()     != rcid_last.GetMasterChannel() ) {
            iminderline = 0;
            os << endl << "    Master: " << rcid.GetGeographicAddress() 
               << " Minder: " << setw(2) << rcid.GetMasterChannel() 
               << endl << "      ";
          }
          os << "[" << setw(2) << rcid.GetMinderChannel() << "] "
               << setw(5) << arate << " ";  // series of [menu] rates
        }
        if (++iminderline==nminderline) {
          os << endl << "      ";
          iminderline=0;
        }
      }
      
      rateItr++;
      rcid_last = rcid;
    } 
    os << endl;

  }  // extended data (src>0)

  return os;
}

//_____________________________________________________________________________
void RawTpSinglesSummaryBlock::UnpackRates() const
{
  // Unpack the extra sub-crate rate information into 
  // pairs of <RawChannelId,UInt_t> ( or <UInt_t,UInt_t> for src=4->Plane)
  //
  // Meaningful parts of RawChannelId:
  // Source    CrateInfo  VarcId  Vfb  VaChip VaChannel
  //   1       yes        yes     --   --     --
  //   2       yes        yes     yes  --     --
  //   3       yes        yes     yes  yes    --
  // Source    CrateInfo  PlaneNum
  //   4       yes        yes
  // Source    CrateInfo  Master  Minder Menu
  //   5       yes        yes     --     -- 
  //   6       yes        yes     yes    -- 
  //   7       yes        yes     yes    yes

  Int_t src = GetSource();
  if      ( src == 0 ) return;  // nothing to unpack
  else if ( src == 4 ) {
    if ( !fPlaneRates.empty()   ) return;  // already unpacked
  }
  else {
    if ( !fChannelRates.empty() ) return;  // already unpacked
  }

  RawBlockId rbid = GetBlockId();
  Int_t minor = rbid.GetMinor();
  if ( minor < 2 ) {
      MSG("Raw",Msg::kWarning)
        << " minor version " << minor << endl 
        << " should have no sub-crate info,"
      << " but Source = " << src << " so try unpacking anyway." << endl;
  }

  switch (src) {
  case 1:
  case 2:
  case 3:
    UnpackVaRates();
    break;
  case 4:
    UnpackPlaneRates();
    break;
  case 5:
  case 6:
  case 7:
    UnpackQieRates();
    break;
  default:
    {
      MSG("Raw",Msg::kWarning)
        << rbid << " with source = " << src << " is unknown format." << endl;
      return;
    }
  }  

}

//_____________________________________________________________________________
void RawTpSinglesSummaryBlock::UnpackVaRates() const
{
  // Trailing information should hold rates for various levels
  // VA electronics (1=VARC only, 2=VFB, 3=VA Chip)

  Int_t src = GetSource();
  RawBlockId rbid = GetBlockId();
  Detector::Detector_t det = rbid.GetDetector();

  const Int_t  *p   = fRawBlock;
  const Int_t  *end = fRawBlock + fSize;  // 1 beyond end
  
  p += zzzz_last + GetNumberOfCrates(); //

  const UInt_t unknown = (UInt_t)(-1);

  while ( p < end ) {
    Int_t crateid = *p++;
    Int_t nvarcs  = *p++;

    if ( src == 1 ) {
      for (Int_t varcid = 0; varcid < nvarcs; varcid++) {
        Int_t varcRate = *p++;
        AddVaRate(det,crateid,varcid,unknown,unknown,varcRate);
      }  // loop over varcs in crate
    }
    else {
      // src = 2, 3
      for (Int_t ivarc = 0; ivarc < nvarcs; ivarc++) {
        Int_t xyzzy = *p++;
        UInt_t nchip  = ( xyzzy       ) & 0xff;
        UInt_t nvfb   = ( xyzzy >>  8 ) & 0xff;
        UInt_t varcid = ( xyzzy >> 16 ) & 0xff;
        for (UInt_t ivfb = 0; ivfb < nvfb; ++ivfb) {
          if ( src == 2 ) {
            Int_t vfbRate = *p++;
            AddVaRate(det,crateid,varcid,ivfb,unknown,vfbRate);
          }
          else if (src == 3 ) {
            if (nchip != 3) {
              MAXMSG("Raw",Msg::kWarning,10)
                << rbid << " unpack at chip level but Nchip = "
                << nchip << " != 3 " << endl;
            }
            for (UInt_t ichip = 0; ichip < nchip; ++ichip) {
              Int_t chipRate = *p++;
              AddVaRate(det,crateid,varcid,ivfb,ichip,chipRate);
            }  // loop over chips
          }  // src 2 vs 3 
        }  // loop over vfb's
      } // loop over varcs

    } // end of src=2,3 unpacking

  } // p < end ... still data to be unpacked

}

//_____________________________________________________________________________
void RawTpSinglesSummaryBlock::UnpackPlaneRates() const
{
  // Trailing information should hold rates for planes

  //Int_t src = GetSource();
  RawBlockId rbid = GetBlockId();
  //Detector::Detector_t det = rbid.GetDetector();

  const Int_t  *p   = fRawBlock;
  const Int_t  *end = fRawBlock + fSize;  // 1 beyond end
  
  p += zzzz_last + GetNumberOfCrates(); //

  UInt_t nplanes  = *p++;
  fPlaneRates.resize(nplanes);

  UInt_t ipln = 0;
  while ( p < end && ipln < nplanes ) {
    Int_t planeRate = *p++;
    fPlaneRates[ipln++] = planeRate;
  } // p < end ... still data to be unpacked

  if ( p < end ) {
    MAXMSG("Raw",Msg::kWarning,10)
      << rbid << " plane unpack failed to use all data: " 
      << p << "<" << end << endl;
  }
  else if ( ipln < nplanes ) {
    MAXMSG("Raw",Msg::kWarning,10)
      << rbid << " plane unpack failed to find all data: " 
      << ipln << "<" << nplanes << endl;
  }

}

//_____________________________________________________________________________
void RawTpSinglesSummaryBlock::UnpackQieRates() const
{
  // Trailing information should hold rates for various levels
  // QIE electronics (5=Master only, 6=Minder, 7=Menu)

  Int_t src = GetSource();
  RawBlockId rbid = GetBlockId();
  Detector::Detector_t det = rbid.GetDetector();

  const Int_t  *p   = fRawBlock;
  const Int_t  *end = fRawBlock + fSize;  // 1 beyond end
  
  p += zzzz_last + GetNumberOfCrates(); //

  const UInt_t unknown = (UInt_t)(-1);

  while ( p < end ) {
    Int_t crateid  = *p++;
    Int_t nmasters = *p++;

    // funkiness!
    Int_t imaster  = nmasters >> 16;
    if (imaster==0) imaster = 9;
    nmasters &= 0xffff;

    if ( src == 5 ) {
      for (Int_t jmaster = 0; jmaster < nmasters; jmaster++) {
        Int_t masterRate = *p++;
        AddQieRate(det,crateid,imaster,unknown,unknown,masterRate);
        imaster++;
      }  // loop over masters in crate
    }
    else {
      // src = 6, 7
      for (Int_t jmaster = 0; jmaster < nmasters; jmaster++) {
        Int_t xyzzy = *p++;
        UInt_t nmenu    = ( xyzzy       ) & 0xff;
        UInt_t nminder  = ( xyzzy >>  8 ) & 0xff;
        UInt_t masterid = ( xyzzy >> 16 ) & 0xff;
        for (UInt_t iminder = 0; iminder < nminder; ++iminder) {
          if ( src == 6 ) {
            Int_t minderRate = *p++;
            AddQieRate(det,crateid,masterid,iminder,unknown,minderRate);
          }
          else if (src == 7 ) {
            for (UInt_t imenu = 0; imenu < nmenu; ++imenu) {
              Int_t menuRate = *p++;
              AddQieRate(det,crateid,masterid,iminder,imenu,menuRate);
            }  // loop over menus
          }  // src 6 vs 7 
        }  // loop over vfb's
      } // loop over masters

    } // end of src=6,7 unpacking

  } // p < end ... still data to be unpacked

}

//_____________________________________________________________________________
bool RawTpSinglesSummaryBlock::AddVaRate(Detector::Detector_t det, 
                                         Int_t crateid, UInt_t varcid, 
                                         UInt_t vfb, UInt_t vachip, 
                                         UInt_t rate) const
{
  // add an VA entry to the rates map

  const UInt_t unknown = (UInt_t)(-1);

  UInt_t adcsel = vfb & 0x01;
  UInt_t vmm    = vfb >> 1; 
  
  UInt_t crateinfo = (ElecType::kVA<<rcsShiftElec) | (crateid&rcsMaskCrate); 

  Int_t chadd = RawChannelId::CalcChAdd(varcid,vmm,adcsel,vachip,unknown);
  RawChannelId rcid(det,crateinfo,chadd);

  return AddChannelRate(rcid,rate);
}

//_____________________________________________________________________________
bool RawTpSinglesSummaryBlock::AddQieRate(Detector::Detector_t det, 
                                          Int_t crateid, UInt_t master, 
                                          UInt_t minder, UInt_t menu, 
                                          UInt_t rate) const
{
  // add an QIE entry to the rates map

  UInt_t crateinfo = (ElecType::kQIE<<rcsShiftElec) | (crateid&rcsMaskCrate); 

  Int_t chadd = RawChannelId::CalcChAdd(master,minder,menu);
  RawChannelId rcid(det,crateinfo,chadd);

  return AddChannelRate(rcid,rate);
}

//_____________________________________________________________________________
bool RawTpSinglesSummaryBlock::AddChannelRate(RawChannelId rcid, 
                                              UInt_t rate) const
{
  // add an entry to the rates map

  typedef std::map<RawChannelId,UInt_t> RCIdToRateMap;
  RCIdToRateMap::const_iterator itr;

  if ( (itr = fChannelRates.find(rcid)) == fChannelRates.end() ) {
    fChannelRates[rcid] = rate;
    return true;
  }
  else {
    MSG("Raw",Msg::kWarning)
      << " duplicate rate for " << rcid.AsString("e")
      << " prior value: " << itr->second
      << ", later value: " << rate
      << endl;
    return false;
  }

}

//_____________________________________________________________________________

---