LArRodDecoder Class Reference

This class provides conversion between ROD data and LArRawChannels. More...

#include <LArRodDecoder.h>

Inheritance diagram for LArRodDecoder:

Collaboration diagram for LArRodDecoder:

Public Member Functions
	LArRodDecoder (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor Standard AlgTool constructor.
virtual	~LArRodDecoder ()
	Destructor.
virtual StatusCode initialize	ATLAS_NOT_THREAD_SAFE () override
void	setsecfeb (HWIdentifier feb)
uint32_t	fillCollectionHLT (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, const uint32_t *p, uint32_t n, LArCellCollection &coll, LArRodBlockStructure *&providedRodBlockStructure, uint16_t &rodMinorVersion, uint32_t &robBlockType) const
void	fillCollection (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, const uint32_t *p, uint32_t n, LArRawChannelContainer &coll, const CaloGain::CaloGain gain) const
void	fillCollection (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, const uint32_t *p, uint32_t n, LArDigitContainer &coll, const CaloGain::CaloGain gain) const
void	fillCollection (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, const uint32_t *p, uint32_t n, LArAccumulatedCalibDigitContainer &coll, const CaloGain::CaloGain gain, const LArCalibLineMapping &calibLineMapping) const
void	fillCollection (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, const uint32_t *p, uint32_t n, LArAccumulatedDigitContainer &coll, const CaloGain::CaloGain gain) const
void	fillCollection (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, const uint32_t *p, uint32_t n, LArCalibDigitContainer &coll, const CaloGain::CaloGain gain, const LArCalibLineMapping &calibLineMapping, const LArOnOffIdMapping &onOffIdMapping) const
void	fillCollection (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, const uint32_t *p, uint32_t n, LArFebHeaderContainer &coll, const CaloGain::CaloGain) const
template<class T>
bool	check_valid (const T *frag, MsgStream &log) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
LArRodBlockStructure *	prepareBlockStructure1 (const uint16_t rodMinorVersion, const uint32_t robBlockType) const
LArRodBlockStructure *	prepareBlockStructure (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, const uint32_t *p, uint32_t n, const CaloGain::CaloGain RequestedGain) const
std::unique_ptr< LArRodBlockStructure >	makeBlockStructure (unsigned int rodBlockType, unsigned int rodMinorVersion) const
void	setCellEnergy (LArCell *element, int energy, int time, int quality, CaloGain::CaloGain gain) const
void	writeFebInfo (LArCellCollection &m_coll, LArFebEnergy &febene) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< xAOD::EventInfo >	m_evt {this, "EvtInfo", "EventInfo", "EventInfo name"}
float	m_LArCellEthreshold
bool	m_readtdc
bool	m_febExchange
unsigned int	m_febId1
unsigned int	m_febId2
unsigned int	m_febIdHLT = 0U
int	m_firstSample
std::vector< int >	m_vFTPreselection
std::vector< int >	m_vBEPreselection
std::vector< int >	m_vPosNegPreselection
std::vector< unsigned int >	m_vFinalPreselection
uint32_t	m_StatusMask
uint32_t	m_StatusNMask = 0U
const LArOnlineID *	m_onlineHelper
std::vector< std::string >	m_LArCellCorrNames
std::vector< unsigned int >	m_IgnoreCheckFEBs
std::vector< const CaloCellCorrection * >	m_LArCellCorrTools
double	m_delayScale
SG::SlotSpecificObj< std::vector< std::unique_ptr< LArRodBlockStructure > > > m_blstructs	ATLAS_THREAD_SAFE
bool	m_MultiDSPMode
bool	m_CheckSum
unsigned short	m_requiredPhysicsNSamples
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

This class provides conversion between ROD data and LArRawChannels.

Author

H. Ma

Version

0-0-1 , Oct 7, 2002

Modified, Dec 4, 2002 Create either LArRawChannel or LArCell.

Modified, Jan 02, 2003 Moved Encoding part to LArROD_Encoder.

Modified, Jul 23, 2003 by R. Lafaye Added LArDigit support Build on the same structure as LArROD_Encoder No longer an AlgTool

Modified, Aug 5 2003 by W. Lampl Have now functionality to decode:

• LArDigitContainer
• LArRawChannelCollection (as IdentfiableContainer)
• LArCellCollection (as Identifiable Container) Is now again a AlgTool since I need jobOpts for the LArCell creation.

Modified, Aug 7 2003 by W. Lampl Made a template-function for LArRawChannelCollection and LArRawCellCollection

Modified, Aug 17 2003 by W. Lampl Introduce ability to decode different ROD format versions by using a map of LArRodBlockStructures

Modified, Sept 9 2003 by W. Lampl Change implementation of multiple-version feature. A ROD block type/version is now written as second word of the fragment. Replace std::map by c-style array to increase performance

Modified, Sept 28 2003 by W. Lampl Adapt for new constructor of LArRawChannels. (Needs also gain as parameter)

Modified, November 10 2005 by D.O. Damazio Inclusion of new RodBlock format (Bertrand Laforge). Inclusion of methods for fast decoding of data.

Modified,January 04 2006 by I. Wingerter Inclusion of Accumulated Calib Digit

Modified, May 03 2006 by I. Aracena Inclusion of fillCollectionHLTFeb

Modified, Dec 03 2006 by G. Rosenbaum Loop over all possible pusled calib lines and make isPulsed int which stores which lines 1-4 have been pulsed. (needed for HEC)

Modified Aug 16 2009 by W. Lampl Remove internal accumlation of LArAccumulatedCalibDigit. They are now put in the event store for each substep and contain only data of this substep.

Definition at line 127 of file LArRodDecoder.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

LArRodDecoder()

LArRodDecoder::LArRodDecoder	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Constructor Standard AlgTool constructor.

Definition at line 26 of file LArRodDecoder.cxx.

  : AthAlgTool(type,name,parent),
    m_LArCellEthreshold(-100.),
    m_readtdc(false),
    m_onlineHelper(0)
 {
  declareInterface< LArRodDecoder  >( this );
  declareProperty("IgnoreCheckFEBs",m_IgnoreCheckFEBs);
  declareProperty("CellCorrections",m_LArCellCorrNames ); 
  declareProperty("LArCellEthreshold",m_LArCellEthreshold ); 
  declareProperty("ReadTDC",m_readtdc);
  declareProperty("DelayScale",m_delayScale=(25./240.)*CLHEP::ns);
  declareProperty("FebExchange", m_febExchange=0); //FIXME: Very ugly hack! See explanation in .h file
  declareProperty("FebId1", m_febId1=0);
  declareProperty("FebId2", m_febId2=0);
  declareProperty("FirstSample", m_firstSample=0); //FIXME: Very ugly hack! See explanation in .h file
 
  declareProperty("BEPreselection",m_vBEPreselection,"For channel-selection: Barrel=0, Endcap=1");
  declareProperty("PosNegPreselection",m_vPosNegPreselection,"For channel-selection: C-Side:0, A-Side: 1");
  declareProperty("FTNumPreselection",m_vFTPreselection,"For channel-selection: Feedthrough numbers (e.g. 0 - 31 for barrel)");
  declareProperty("MultiDSPMode", m_MultiDSPMode=false);
  declareProperty("CheckSum", m_CheckSum=false);
  declareProperty("StatusMask", m_StatusMask=0x00000212);
  declareProperty("RequiredPhysicsNSamples", m_requiredPhysicsNSamples = 0);
}

~LArRodDecoder()

LArRodDecoder::~LArRodDecoder ( )

virtual

Destructor.

Definition at line 53 of file LArRodDecoder.cxx.

{
}

Member Function Documentation

ATLAS_NOT_THREAD_SAFE()

virtual StatusCode initialize LArRodDecoder::ATLAS_NOT_THREAD_SAFE ( )

overridevirtual

check_valid()

template<class T>

bool LArRodDecoder::check_valid ( const T * frag, MsgStream & log ) const

inline

Definition at line 244 of file LArRodDecoder.h.

{ 
  bool ret=false;
  try {
    ret=frag->check();
  } 
  catch (eformat::Issue& ex) {
    msg(MSG::WARNING) << "Exception while checking eformat fragment validity: " << ex.what() << endmsg; 
    ret=false;
  }
  return ret;
 
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

fillCollection() [1/6]

void LArRodDecoder::fillCollection	(	const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &	robFrag,
		const uint32_t *	p,
		uint32_t	n,
		LArAccumulatedCalibDigitContainer &	coll,
		const CaloGain::CaloGain	gain,
		const LArCalibLineMapping &	calibLineMapping ) const

Definition at line 494 of file LArRodDecoder.cxx.

{ // Accumulated Digit pointer
  LArAccumulatedCalibDigit * dg=0 ;
  CaloGain::CaloGain calogain;
  uint32_t gain, ntrigger;
  int dac, delay, NStep=-1, StepIndex=-1;
  bool ispulsed;
  uint16_t ispulsed_int;
  int bitShift; 
  uint32_t FirstGoodFEB=1;
  int fcNb;
  std::vector< uint64_t > samplesSum;   
  std::vector< uint64_t > samples2Sum;   
 
  LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
  if (!BlStruct) return;
  do
    {
      // IWS 24.01.2006 protection against NULL events (null pointer to rawdata block) 
      if (!BlStruct->hasCalibBlock())
    {  
      ATH_MSG_DEBUG("No Calib Data for this FEB - NULL event");
      continue; 
    }
      if(FirstGoodFEB) 
    {
      FirstGoodFEB=0;
    }
      HWIdentifier fId(Identifier32(BlStruct->getFEBID()));
      unsigned int fId32 = fId.get_identifier32().get_compact();
      // RL 20.09.2006 protection against 0 FebId
      if (!fId32){
    ATH_MSG_DEBUG("Bad FebID=0x" << std::hex << BlStruct->getFEBID() << " found for this FEB, skipping it!" << std::dec);
    continue; 
      }
      // RL 04.17.2008 skip check for some FEBs
      int do_check=1;
      std::vector<unsigned int>::const_iterator it_feb     = m_IgnoreCheckFEBs.begin(); 
      std::vector<unsigned int>::const_iterator it_feb_end = m_IgnoreCheckFEBs.end();
      for(; it_feb!=it_feb_end;++it_feb)
    if(fId==*it_feb) {
      do_check=0;
      break;
    }
      if(do_check) {
    //WL 31.10.2007 //check RodStatus-word to catch corrupt events
    if (BlStruct->getStatus() & m_StatusNMask) {
      ATH_MSG_WARNING("RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB  "<< std::hex << fId32 << std::dec <<".  Ignored.");
      continue;
    }
      }
      // RL 05.11.2007 checksum
      if(m_CheckSum) {
    uint32_t onsum  = BlStruct->onlineCheckSum();
    uint32_t offsum = BlStruct->offlineCheckSum();
    if(onsum!=offsum) {
      ATH_MSG_WARNING("Checksum error:");
      ATH_MSG_WARNING(" online checksum  = " << MSG::hex << onsum);
      ATH_MSG_WARNING(" offline checksum = " << MSG::hex << offsum);
      continue;
    }
      }
      if(m_febExchange) {
        if     (fId32 == m_febId1) {
          fId = HWIdentifier(Identifier32(m_febId2));
          fId32 = fId.get_identifier32().get_compact();
        }
        else if(fId32 == m_febId2) {
          fId = HWIdentifier(Identifier32(m_febId1));
          fId32 = fId.get_identifier32().get_compact();
        }
      }
 
      if (m_vFinalPreselection.size()) {
    unsigned int ftId=m_onlineHelper->feedthrough_Id(fId).get_identifier32().get_compact();
    if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
      ATH_MSG_DEBUG("Feedthrough with id " << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
      continue;
    }
      }
      int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
      uint32_t idum=0;
      while (BlStruct->getNextAccumulatedCalibDigit(fcNb,samplesSum,samples2Sum,idum,gain))
    {
      ispulsed_int=0;
      bitShift=0;
      if (fcNb>=NthisFebChannel)continue;
      if (samplesSum.size()==0) continue; // Ignore missing cells
      HWIdentifier cId = m_onlineHelper->channel_Id(fId,fcNb);
      calogain=(CaloGain::CaloGain)gain;
      ntrigger=BlStruct->getNTrigger();
      dac=BlStruct->getDAC();
      delay=BlStruct->getDelay();
      NStep=BlStruct->getNStep();
      if(!NStep) NStep=1; // To be able to decode v6 code
      StepIndex=BlStruct->getStepIndex();
      // 08.08.2005 IWS get calib line
      const std::vector<HWIdentifier>& calibChannelIDs = calibLineMapping.calibSlotLine(cId);
      if (calibChannelIDs.size()==0) { 
            samplesSum.clear();
            samples2Sum.clear();
        continue;// connected channel 
      }
      //GR: Loop over all the calib chans instead of just looking at the first one and set four bit isPulsed int
      for(std::vector<HWIdentifier>::const_iterator csl_it=calibChannelIDs.begin(); csl_it!=calibChannelIDs.end();++csl_it){
        uint32_t calibLine = m_onlineHelper->channel(*csl_it);
        ispulsed=BlStruct->getPulsed(calibLine);
        ispulsed_int=( ispulsed_int | ((uint16_t)ispulsed<<bitShift) );  
        bitShift++;
      }
 
      dg=new LArAccumulatedCalibDigit(cId, calogain, samplesSum, samples2Sum, ntrigger, dac, delay, 
                      (uint16_t)ispulsed_int, NStep, StepIndex);
 
      coll.push_back(dg); 
    } // End while
    }//End do loop of FEBs
  while (BlStruct->nextFEB()); //Get NextFeb
}

fillCollection() [2/6]

void LArRodDecoder::fillCollection	(	const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &	robFrag,
		const uint32_t *	p,
		uint32_t	n,
		LArAccumulatedDigitContainer &	coll,
		const CaloGain::CaloGain	gain ) const

Definition at line 619 of file LArRodDecoder.cxx.

{ // Accumulated Digit pointer
  LArAccumulatedDigit * dg=0 ;
  CaloGain::CaloGain calogain;
  uint32_t gain, ntrigger;
  int fcNb;
  std::vector<uint64_t> sampleSum;   
  std::vector< uint64_t > sampleSquare;   
 
  LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
  if (!BlStruct) return;
  do
    {
      // IWS 24.01.2006 protection against NULL events (null pointer to rawdata block) 
      if (!BlStruct->hasAccumBlock()) {
    ATH_MSG_DEBUG("No Accum Data for this FEB - NULL event");
    continue; 
      }
      HWIdentifier fId(Identifier32(BlStruct->getFEBID()));
      unsigned int fId32 = fId.get_identifier32().get_compact();
      // RL 20.09.2006 protection against 0 FebId
      if (!fId32) {
    ATH_MSG_DEBUG("Bad FebID=0x" << std::hex << BlStruct->getFEBID() << " found for this FEB, skipping it!" << std::dec);
    continue; 
      }
      // RL 04.17.2008 skip check for some FEBs
      int do_check=1;
      std::vector<unsigned int>::const_iterator it_feb     = m_IgnoreCheckFEBs.begin(); 
      std::vector<unsigned int>::const_iterator it_feb_end = m_IgnoreCheckFEBs.end();
      for(; it_feb!=it_feb_end;++it_feb)
    if(fId==*it_feb) {
      do_check=0;
      break;
    }
      if(do_check) {
    //WL 31.10.2007 //check RodStatus-word to catch corrupt events
    if (BlStruct->getStatus() & m_StatusNMask) {
      ATH_MSG_WARNING("RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB  "<< std::hex << fId32 << std::dec <<".  Ignored.");
      continue;
    }
      }
      // RL 05.11.2007 checksum
      if(m_CheckSum) {
    uint32_t onsum  = BlStruct->onlineCheckSum();
    uint32_t offsum = BlStruct->offlineCheckSum();
    if(onsum!=offsum) {
      ATH_MSG_WARNING("Checksum error:");
      ATH_MSG_WARNING(" online checksum  = " << MSG::hex << onsum);
      ATH_MSG_WARNING(" offline checksum = " << MSG::hex << offsum);
      continue;
    }
      }
      if(m_febExchange) {
        if     (fId32 == m_febId1) {
          fId = HWIdentifier(Identifier32(m_febId2));
          fId32 = fId.get_identifier32().get_compact();
        }
        else if(fId32 == m_febId2) {
          fId = HWIdentifier(Identifier32(m_febId1));
          fId32 = fId.get_identifier32().get_compact();
        }
      }
 
      if (m_vFinalPreselection.size()) {
    unsigned int ftId=m_onlineHelper->feedthrough_Id(fId).get_identifier32().get_compact();
    if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
      ATH_MSG_DEBUG("Feedthrough with id " << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
      continue;
    }
      }
      int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
      ntrigger=BlStruct->getNTrigger();
      while (BlStruct->getNextAccumulatedDigit(fcNb,sampleSum,sampleSquare,gain)) {
      if (fcNb>=NthisFebChannel)continue;
      if (sampleSquare.size()==0) continue; // Ignore missing cells
      HWIdentifier cId = m_onlineHelper->channel_Id(fId,fcNb);
      calogain=(CaloGain::CaloGain)gain;
      dg=new LArAccumulatedDigit(cId,calogain,sampleSum,sampleSquare,ntrigger);
      coll.push_back(dg); 
    } // End while
    }//End do loop of FEBs
  while (BlStruct->nextFEB()); //Get NextFeb
}

fillCollection() [3/6]

void LArRodDecoder::fillCollection	(	const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &	robFrag,
		const uint32_t *	p,
		uint32_t	n,
		LArCalibDigitContainer &	coll,
		const CaloGain::CaloGain	gain,
		const LArCalibLineMapping &	calibLineMapping,
		const LArOnOffIdMapping &	onOffIdMapping ) const

Definition at line 305 of file LArRodDecoder.cxx.

{ // CalibDigit pointer
  LArCalibDigit * dg=0 ;
  uint32_t gain;
  CaloGain::CaloGain calogain;
  int fcNb;
  uint16_t dac, delay;
  bool ispulsed;
  std::vector<short> samples;
 
  ATH_MSG_VERBOSE("FillCollection for LArCalibDigitContainer is called.");
  LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
  if (!BlStruct) return;
  if (BlStruct->canSetCalibration()) {
    dac=BlStruct->getDAC();
    delay=BlStruct->getDelay();
    do
      {
    // IWS 24.01.2006 protection against NULL events (null pointer to rawdata block) 
    if (!BlStruct->hasRawDataBlock()) {
      ATH_MSG_DEBUG("No Raw Data for this FEB - NULL event for FEBID " << std::hex << BlStruct->getFEBID());
      continue; 
    }
    HWIdentifier fId(Identifier32(BlStruct->getFEBID()));
        unsigned int fId32 = fId.get_identifier32().get_compact();
    // RL 20.09.2006 protection against 0 FebId
        if (!fId32){
      ATH_MSG_DEBUG("Bad FebID=0x"<< std::hex << BlStruct->getFEBID() << " found for this FEB, skipping it!");
      continue; 
    }
    // RL 04.17.2008 skip check for some FEBs
    int do_check=1;
    std::vector<unsigned int>::const_iterator it_feb     = m_IgnoreCheckFEBs.begin(); 
    std::vector<unsigned int>::const_iterator it_feb_end = m_IgnoreCheckFEBs.end();
    for(; it_feb!=it_feb_end;++it_feb)
      if(fId==*it_feb) {
        do_check=0;
        break;
      }
    if(do_check) {
      //WL 31.10.2007 //check RodStatus-word to catch corrupt events
      if (BlStruct->getStatus() & m_StatusNMask) {
        msg(MSG::WARNING) << "RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB  "<< std::hex << fId32 << std::dec <<".  Ignored." << endmsg;
        continue;
      }
    }
       // RL 05.11.2007 checksum
    if(m_CheckSum) {
      uint32_t onsum  = BlStruct->onlineCheckSum();
      uint32_t offsum = BlStruct->offlineCheckSum();
      if(onsum!=offsum) {
        msg(MSG::WARNING) << "Checksum error:" << endmsg;
        msg(MSG::WARNING) << " online checksum  = " << MSG::hex << onsum  << endmsg;
        msg(MSG::WARNING) << " offline checksum = " << MSG::hex << offsum << endmsg;
        continue;
      }
    }
        if(m_febExchange) {
          if     (fId32 == m_febId1) {
            fId = HWIdentifier(Identifier32(m_febId2));
            fId32 = fId.get_identifier32().get_compact();
          }
          else if(fId32 == m_febId2) {
            fId = HWIdentifier(Identifier32(m_febId1));
            fId32 = fId.get_identifier32().get_compact();
          }
        }
 
    if (m_vFinalPreselection.size()) {
          unsigned int ftId=m_onlineHelper->feedthrough_Id(fId).get_identifier32().get_compact();
      if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
        ATH_MSG_DEBUG("Feedthrough with id 0x" << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
        continue;
      }
    }
    const int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
    while (BlStruct->getNextRawData(fcNb,samples,gain))
      {if (fcNb>=NthisFebChannel)
        continue;
      if (samples.size()==0) continue; // Ignore missing cells
      HWIdentifier cId = m_onlineHelper->channel_Id(fId,fcNb);
      ispulsed=BlStruct->getPulsed(fcNb);
      
      calogain=(CaloGain::CaloGain)gain;
      dg = new LArCalibDigit(cId, calogain, samples, dac, delay, ispulsed);
      samples.clear();
      coll.push_back(dg);
      }
      }
    while (BlStruct->nextFEB()); //Get NextFeb
  }
  else {//Not a calibration data block, try to get from database
    ATH_MSG_VERBOSE("Not LArCalibDigit data block found. Building it using DB values");
    //1st step, get Calib board config object
    const LArCalibParams* calibParams = nullptr;
    StatusCode sc=detStore()->retrieve(calibParams);
    if (sc.isFailure())
      {msg(MSG::ERROR) << "Cannot load LArCalibParams from DetStore!" << endmsg;
      return;
      }
    //2st step, get Event number
    SG::ReadHandle<xAOD::EventInfo> evt(m_evt);
    if (!evt.isValid()) {
      ATH_MSG_ERROR("Cannot get EventInfo");
      return; //Return empty container. 
    }
    const unsigned eventNb=evt->eventNumber();
    const std::vector<HWIdentifier>* calibChannelIDs;
    do { //Loop over all FEBs in this ROD
      
      // IWS 24.01.2006 protection against NULL events (null pointer to rawdata block) 
      if (!BlStruct->hasRawDataBlock()) {
    ATH_MSG_DEBUG("No Raw Data for this FEB - NULL event for FEBID 0x" << std::hex << BlStruct->getFEBID() << std::dec);
    continue; 
      }
      HWIdentifier fId(Identifier32(BlStruct->getFEBID()));
      unsigned int fId32 = fId.get_identifier32().get_compact();
      // RL 20.09.2006 protection against 0 FebId
      if (!fId32) {
    ATH_MSG_DEBUG("Bad FebID=0x" << std::hex << BlStruct->getFEBID() << " found for this FEB, skipping it!" << std::dec);
        continue; 
      }
      if(m_febExchange) {
        if     (fId32 == m_febId1) {
          fId = HWIdentifier(Identifier32(m_febId2));
          fId32 = fId.get_identifier32().get_compact();
        }
        else if(fId32 == m_febId2) {
          fId = HWIdentifier(Identifier32(m_febId1));
          fId32 = fId.get_identifier32().get_compact();
        }
      }
      fcNb=0;
      HWIdentifier cId;
      do { //Search for the first connected channel of this FEB (probably the first one...)
    fcNb++; 
    cId = m_onlineHelper->channel_Id(fId,fcNb);
    calibChannelIDs=&calibLineMapping.calibSlotLine(cId);
      }
      while ( (!onOffIdMapping.isOnlineConnected(cId) || calibChannelIDs->size()==0) && fcNb<128); // This is the right  conditions to exit the loop!
      
      if ( calibChannelIDs->size()==0 ) {
    msg(MSG::ERROR) << "Cannot get calibration Channel ID for FEB " << std::hex << fId32 << std::dec << endmsg;
    return;
      }
 
      uint16_t dac;
      uint16_t delay;
 
      std::vector<HWIdentifier>::const_iterator csl_it=calibChannelIDs->begin();
      //Derive DAC and Delay value from this channel
      dac=calibParams->DAC(eventNb,*csl_it);
      delay=calibParams->Delay(eventNb,*csl_it);
 
      //Now start looping over channels in FEB
      const int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
 
      fcNb=0;
      while (BlStruct->getNextRawData(fcNb,samples,gain))
    {
      if (fcNb>=NthisFebChannel) continue;
      if (samples.size()==0) continue; // Ignore missing cells
      cId = m_onlineHelper->channel_Id(fId,fcNb);
      calibChannelIDs=&calibLineMapping.calibSlotLine(cId);
      //For the time being, I assume we are in H8 and have only one calib channel per FEB channel
 
      if (calibChannelIDs->size()!=0) {
        csl_it=calibChannelIDs->begin();
        ispulsed=calibParams->isPulsed(eventNb,*csl_it);
        
      } else ispulsed=0;
      calogain=(CaloGain::CaloGain)gain;
      dg = new LArCalibDigit(cId, calogain, samples, dac, delay, ispulsed);
      samples.clear();
      
      coll.push_back(dg);
    }
    }
    while (BlStruct->nextFEB()); //Get NextFeb
  }
  coll.setDelayScale(m_delayScale);
}

fillCollection() [4/6]

void LArRodDecoder::fillCollection	(	const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &	robFrag,
		const uint32_t *	p,
		uint32_t	n,
		LArDigitContainer &	coll,
		const CaloGain::CaloGain	gain ) const

Definition at line 125 of file LArRodDecoder.cxx.

{ // Digit pointer
  LArDigit * dg=0 ;
  CaloGain::CaloGain calogain;
  uint32_t gain;
  int fcNb;
  std::vector<short> samples;
  LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
  if (!BlStruct) return;
 
  do {
    HWIdentifier fId( Identifier32(BlStruct->getFEBID()) );
    unsigned int fId32 = fId.get_identifier32().get_compact();
    if (!m_onlineHelper->isValidId(fId)) {
      ATH_MSG_WARNING("Invalid FEB identifer 0x" << std::hex << fId32 << std::dec << ". Skipping");
      continue;
    }
    if(m_febExchange) {
      if     (fId32 == m_febId1) {
        fId = HWIdentifier(Identifier32(m_febId2));
        fId32 = fId.get_identifier32().get_compact();
      }
      else if(fId32 == m_febId2) {
        fId = HWIdentifier(Identifier32(m_febId1));
        fId32 = fId.get_identifier32().get_compact();
      }
    }
      
    // IWS 24.01.2006 protection against NULL events (null pointer to rawdata block)
    if (!BlStruct->hasRawDataBlock())
    {
      ATH_MSG_DEBUG("No Raw Data for this FEB - NULL event for FEBID 0x"<< std::hex << BlStruct->getFEBID() << std::dec);
      continue;
    }
 
    // RL 04.17.2008 skip check for some FEBs
    int do_check=1;
    std::vector<unsigned int>::const_iterator it_feb     = m_IgnoreCheckFEBs.begin();
    std::vector<unsigned int>::const_iterator it_feb_end = m_IgnoreCheckFEBs.end();
    for(; it_feb!=it_feb_end;++it_feb)
      if(fId==*it_feb) {
        do_check=0;
        break;
      }
    if(do_check) {
      //WL 31.10.2007 //check RodStatus-word to catch corrupt events
      if (BlStruct->getStatus() & m_StatusNMask) {
        ATH_MSG_WARNING("RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB  "<< std::hex << fId32 << std::dec <<".  Ignored.");
        continue;
      }
    }
    // RL 05.11.2007 checksum
    if(m_CheckSum) {
      const uint32_t onsum  = BlStruct->onlineCheckSum();
      const uint32_t offsum = BlStruct->offlineCheckSum();
      if(onsum!=offsum) {
        ATH_MSG_WARNING("Checksum error for FEB: " << MSG::hex << fId32);
        ATH_MSG_WARNING(" online checksum  = " << MSG::hex << onsum);
        ATH_MSG_WARNING(" offline checksum = " << MSG::hex << offsum << MSG::dec);
        continue;
      }
    }
 
    if (m_vFinalPreselection.size()) {
      const unsigned int ftId=m_onlineHelper->feedthrough_Id(fId).get_identifier32().get_compact();
      if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
        ATH_MSG_DEBUG("Feedthrough with id 0x" << MSG::hex << ftId << MSG::dec <<" not in preselection. Ignored.");
        continue;
      }
    }
    const int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
    while (BlStruct->getNextRawData(fcNb,samples,gain))
    {
      if (fcNb>=NthisFebChannel)
        continue;
      if (samples.size()==0) continue; // Ignore missing cells
      HWIdentifier cId = m_onlineHelper->channel_Id(fId,fcNb);
      calogain=(CaloGain::CaloGain)gain;
      dg = new LArDigit(cId, calogain, std::move(samples));
      samples.clear();
      coll.push_back(dg);
    }
  }
  while (BlStruct->nextFEB()); //Get NextFeb
}

fillCollection() [5/6]

void LArRodDecoder::fillCollection	(	const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &	robFrag,
		const uint32_t *	p,
		uint32_t	n,
		LArFebHeaderContainer &	coll,
		const CaloGain::CaloGain	RequestedGain ) const

Definition at line 704 of file LArRodDecoder.cxx.

{
  LArFebHeader* larFebHeader;
  HWIdentifier FEBID;
 
  LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
  if (!BlStruct) return;
 
  do{
    //Read first FEB. The header of this feb is combined with the ROD-Header
 
    FEBID=HWIdentifier(Identifier32(BlStruct->getFEBID()));
    unsigned int FEBID32 = FEBID.get_identifier32().get_compact();
    if (!m_onlineHelper->isValidId(FEBID)) {
      ATH_MSG_WARNING("Invalid FEB identifer " << std:: hex << FEBID32 << std::dec << ". Skipping");
      continue;
    }
 
    if(m_febExchange) {
      if     (FEBID32 == m_febId1) {
          FEBID   = HWIdentifier(Identifier32(m_febId2));
          FEBID32 = FEBID.get_identifier32().get_compact();
      }
      else if(FEBID32 == m_febId2) {
          FEBID = HWIdentifier(Identifier32(m_febId1));
          FEBID32 = FEBID.get_identifier32().get_compact();
      }
    }
 
    if (m_vFinalPreselection.size()) {
      const unsigned int ftId=m_onlineHelper->feedthrough_Id(FEBID).get_identifier32().get_compact();
      if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
    ATH_MSG_DEBUG("Feedthrough with id 0x" << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
    continue;
      }
    }
 
 
 
    larFebHeader=new LArFebHeader(FEBID);
    //setROD header data
    
    larFebHeader->SetFormatVersion(robFrag.rod_version());
    larFebHeader->SetSourceId(robFrag.rod_source_id());
    larFebHeader->SetRunNumber(robFrag.rod_run_no());
    larFebHeader->SetELVL1Id(robFrag.rod_lvl1_id());
    larFebHeader->SetBCId(robFrag.rod_bc_id());
    larFebHeader->SetLVL1TigType(robFrag.rod_lvl1_trigger_type());
    larFebHeader->SetDetEventType(robFrag.rod_detev_type());
  
    //set DSP data
    const unsigned nsample=BlStruct->getNumberOfSamples();
    const uint32_t status= BlStruct->getStatus();
    larFebHeader->SetDspCodeVersion(BlStruct->getDspCodeVersion()); 
    larFebHeader->SetDspEventCounter(BlStruct->getDspEventCounter()); 
    larFebHeader->SetRodResults1Size(BlStruct->getResults1Size()); 
    larFebHeader->SetRodResults2Size(BlStruct->getResults2Size()); 
    larFebHeader->SetRodRawDataSize(BlStruct->getRawDataSize()); 
    larFebHeader->SetNbSweetCells1(BlStruct->getNbSweetCells1()); 
    larFebHeader->SetNbSweetCells2(BlStruct->getNbSweetCells2()); 
    larFebHeader->SetNbSamples(nsample); 
    larFebHeader->SetOnlineChecksum(BlStruct->onlineCheckSum());
    larFebHeader->SetOfflineChecksum(BlStruct->offlineCheckSum());
 
    if(!BlStruct->hasControlWords()) {
      larFebHeader->SetFebELVL1Id(robFrag.rod_lvl1_id());
      larFebHeader->SetFebBCId(robFrag.rod_bc_id());
    } else {
      const uint16_t evtid = BlStruct->getCtrl1(0) & 0x1f;
      const uint16_t bcid  = BlStruct->getCtrl2(0) & 0x1fff;
 
      larFebHeader->SetFebELVL1Id(evtid);
      larFebHeader->SetFebBCId(bcid);
      for(int iadc=0;iadc<16;iadc++) {
    larFebHeader->SetFebCtrl1(BlStruct->getCtrl1(iadc));
    larFebHeader->SetFebCtrl2(BlStruct->getCtrl2(iadc));
    larFebHeader->SetFebCtrl3(BlStruct->getCtrl3(iadc));
      }
      for(unsigned int i = 0; i<nsample; i++ ) {
    larFebHeader->SetFebSCA(BlStruct->getRadd(0,i) & 0xff);
      }
    }
    larFebHeader->SetRodStatus(status);
    coll.push_back(larFebHeader);
  
  } while (BlStruct->nextFEB()); //Get NextFeb
}

fillCollection() [6/6]

void LArRodDecoder::fillCollection	(	const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &	robFrag,
		const uint32_t *	p,
		uint32_t	n,
		LArRawChannelContainer &	coll,
		const CaloGain::CaloGain	gain ) const

Definition at line 215 of file LArRodDecoder.cxx.

{ 
  int32_t energy;
  int32_t time;
  int32_t quality;
  uint32_t gain;
  int fcNb;
  HWIdentifier cId;
  LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
  if (!BlStruct) return;
 
  do {
    HWIdentifier fId( Identifier32(BlStruct->getFEBID()) );
    unsigned int fId32 = fId.get_identifier32().get_compact();
    if (!m_onlineHelper->isValidId(fId)) {
      ATH_MSG_WARNING("Invalid FEB identifer " << std::hex << fId32 << std::dec << ". Skipping");
      continue;
    }
 
    if(m_febExchange) {
      if     (fId32 == m_febId1) {
        fId = HWIdentifier(Identifier32(m_febId2));
        fId32 = fId.get_identifier32().get_compact();
      }
      else if(fId32 == m_febId2) {
        fId = HWIdentifier(Identifier32(m_febId1));
        fId32 = fId.get_identifier32().get_compact();
      }
    }
    if (!BlStruct->hasPhysicsBlock()) {
      ATH_MSG_DEBUG("No Physics Data for this FEB - NULL event for FEBID 0x" << std::hex << BlStruct->getFEBID() << std::dec);
      continue;
    }
 
    // RL 04.17.2008 skip check for some FEBs
    int do_check=1;
    std::vector<unsigned int>::const_iterator it_feb     = m_IgnoreCheckFEBs.begin();
    std::vector<unsigned int>::const_iterator it_feb_end = m_IgnoreCheckFEBs.end();
    for(; it_feb!=it_feb_end;++it_feb)
      if(fId==*it_feb) {
        do_check=0;
        break;
      }
    if(do_check) {
      //WL 31.10.2007 //check RodStatus-word to catch corrupt events
      if (BlStruct->getStatus() & m_StatusNMask) {
        ATH_MSG_WARNING("RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB  "<< std::hex << fId32 << std::dec <<".  Ignored.");
        continue;
      }
    }
      
    // RL 05.11.2007 checksum
    if(m_CheckSum) {
      const uint32_t onsum  = BlStruct->onlineCheckSum();
      const uint32_t offsum = BlStruct->offlineCheckSum();
      if(onsum!=offsum) {
        ATH_MSG_WARNING("Checksum error:");
        ATH_MSG_WARNING(" online checksum  = " << MSG::hex << onsum);
        ATH_MSG_WARNING(" offline checksum = " << MSG::hex << offsum);
        continue;
      }
    }
 
    if (m_vFTPreselection.size()) {
      int ftId=m_onlineHelper->feedthrough_Id(fId).get_identifier32().get_compact();
      if (!std::binary_search(m_vFTPreselection.begin(), m_vFTPreselection.end(),ftId)) {
        ATH_MSG_DEBUG("Feedthrough with id " << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
        continue;
      }
    }
    const int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
    while (BlStruct->getNextEnergy(fcNb,energy,time,quality,gain)) {
      if (fcNb>=NthisFebChannel)
        continue;
      cId = m_onlineHelper->channel_Id(fId,fcNb);
      uint16_t iquality = 0;
      uint16_t iprovenance = 0x1000;
      if (quality>0) {
        iprovenance |= 0x2000;
        iquality = (quality & 0xFFFF);
      }
      LArRawChannel chan(cId, energy, time, iquality, iprovenance, (CaloGain::CaloGain)gain);
      coll.push_back(chan);
    }
  }
  while (BlStruct->nextFEB()); //Get NextFeb
}

fillCollectionHLT()

uint32_t LArRodDecoder::fillCollectionHLT ( const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment & robFrag, const uint32_t * p, uint32_t n, LArCellCollection & coll, LArRodBlockStructure *& providedRodBlockStructure, uint16_t & rodMinorVersion = rMV, uint32_t & robBlockType = rBT ) const

inline

Definition at line 262 of file LArRodDecoder.h.

{
  LArCell *collElem=0; //Pointer to a new element to be added to the collection
  uint32_t error = 0;
 
#ifndef NDEBUG
  ATH_MSG_VERBOSE("Prepare LArRodBlockStructure. Got a fragment of size " << n);
#endif
  const uint32_t blocksize=p[0]; //First word contains block size
  if (blocksize>n) {
    msg(MSG::ERROR) << "Got truncated ROD Fragment!" << endmsg;
    // First Bit is truncated (see also below)
    error|= 0x1;
    return error;
  }
 
  //Get version and blocktype form header
  eformat::helper::Version ver(robFrag.rod_version());
  const uint16_t rMV_present=ver.minor_version();
  const uint32_t rBT_present=robFrag.rod_detev_type()&0xff;
 
  LArRodBlockStructure* BlStruct(nullptr);
  if ( !providedRodBlockStructure || (rodMinorVersion!=rMV_present) || (robBlockType!=rBT_present) ){
  BlStruct = prepareBlockStructure1 (rMV_present, rBT_present);
  if (!BlStruct) {
    // Second Bit is block empty or unknown
    error|= 0x2;
    return error;
  }
  providedRodBlockStructure = BlStruct;
  rodMinorVersion = rMV_present;
  robBlockType = rBT_present;
  } else BlStruct = providedRodBlockStructure;
 
  BlStruct->setFragment(p,n);
  for(LArCellCollection::iterator ii=coll.begin();ii!=coll.end();++ii)
       (*ii)->setEnergyFast(0.0);
 
  int32_t energy(0);
  int32_t time;
  int32_t quality;
  uint32_t gain;
  CaloGain::CaloGain calogain;
  int fcNb;
  int nfeb;
  calogain=CaloGain::LARNGAIN;
  if(!BlStruct->setGain(calogain)){
    ATH_MSG_DEBUG("Setting the Gain Problem");
  }
 
  int feb_number=0;
  do //Loop over FEB's
    {
      HWIdentifier fId(BlStruct->getFEBID());
      if (!(fId.get_identifier32().get_compact())) {
#ifndef NDEBUG
    ATH_MSG_DEBUG("Bad FebID=0x"<< std::hex << BlStruct->getFEBID() << std::dec << " found for this FEB, skipping it!");
#endif
     // Third Bit is FEB ID issue (disabled - use 0x20 instead)
     //error|= 0x4;
       continue;
    }
  // RL 05.11.2007 checksum
  if(m_CheckSum) {
    uint32_t onsum  = BlStruct->onlineCheckSum();
    uint32_t offsum = BlStruct->offlineCheckSum();
    if(onsum!=offsum) {
      msg(MSG::WARNING) << "Checksum error:" << endmsg;
      msg(MSG::WARNING) << " online checksum  = 0x" << MSG::hex << onsum  << endmsg;
      msg(MSG::WARNING) << " offline checksum = 0x" << MSG::hex << offsum << MSG::dec << endmsg;
     // Fourth Bit CheckSum issue (maybe disabled!)
     error|= 0x8;
      continue;
    }
  }
  feb_number++;
 
  if ( BlStruct->hasPhysicsBlock() ) {
      if ( fId == m_febIdHLT ) nfeb = 128; // This is the second feb
        else nfeb = 0;
      int NthisFebChannel=128 ; // m_onlineHelper->channelInSlotMax(fId);
     uint16_t iquality;
     uint16_t iprovenance;
     while (BlStruct->getNextEnergy(fcNb,energy,time,quality,gain)) {
        if (fcNb>=NthisFebChannel) continue;
        collElem = coll[fcNb+nfeb];
        iprovenance=0x1000; // data comes from DSP computation
        iquality=0;
        if ( quality>=0 ) { iprovenance|= 0x2000; iquality=(quality& 0xffff);}
    // time converted to ns
    collElem->set(energy, time*1e-3, iquality, iprovenance, (CaloGain::CaloGain)gain);
       }
       continue;
    } 
  }
  while (BlStruct->nextFEB()); //Get NextFeb
  // Error meaning data corruption. Maybe in any FEB
  if ( BlStruct->report_error() ) error |= 0x1;
  // error of uncompatible number of cells is bit 5
  unsigned int collection_size = coll.size();
  if ( feb_number== 0 && collection_size>0 ) error |= 0x20;
  if ( feb_number== 1 && collection_size !=128 ) error |= 0x20;
  if ( feb_number== 2 && collection_size !=256 ) error |= 0x20;
  return error;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & LArRodDecoder::interfaceID ( )

static

Definition at line 57 of file LArRodDecoder.cxx.

{ return IID_ILArRodDecoder;  }

makeBlockStructure()

std::unique_ptr< LArRodBlockStructure > LArRodDecoder::makeBlockStructure ( unsigned int rodBlockType, unsigned int rodMinorVersion ) const

private

Definition at line 870 of file LArRodDecoder.cxx.

{
  switch (rodBlockType) {
  case 2:
    break;
 
  case 3:
    // RodBlockType 3 = Test mode
    //return std::make_unique<LArRodBlockTransparentV0<LArRodBlockHeaderTransparentV0> >(this->msgSvc().get());
    break;
 
  case 4:
    // RodBlockType 4 = Physics mode
    switch (rodMinorVersion) {
    case 10: // Physics mode v5 16.06.2008 for LHC 
    case 11: // Physics mode v5 16.06.2008 for LHC
      {
        auto bl = std::make_unique<LArRodBlockPhysicsV5>(this->msgSvc().get());
        if (m_requiredPhysicsNSamples > 0) {
          bl->setRequiredNSamples(m_requiredPhysicsNSamples);
        }
        return bl;
      }
    case 12: // Physics mode v5 09.03.2011 for LHC
      {
        auto bl = std::make_unique<LArRodBlockPhysicsV6>(this->msgSvc().get());
        if (m_requiredPhysicsNSamples > 0) {
          bl->setRequiredNSamples(m_requiredPhysicsNSamples);
        }
        return bl;
      }
    default:
      break;
    }
    break;
 
  case 5:
    // RodBlockType 5 = Physics simulation mode
    // Physics mode v3 11.04.2005 for simulation
    //return std::make_unique<LArRodBlockPhysicsV3>(this->msgSvc().get());
    break;
 
  case 6:
    // RodBlockType 6 = Physics test mode
    break;
 
  case 7:
    // RodBlockType 7 = Calibration mode
    break;
 
  case 10:
    // RodBlockType 10 = Accumulated mode (used for pre-processed pedestal runs)
    // Accumulated mode v3 10.06.2008
    //return std::make_unique<LArRodBlockAccumulatedV3>(this->msgSvc().get());
    break;
 
  default:
    break;
  }
 
  return std::unique_ptr<LArRodBlockStructure>();
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

prepareBlockStructure()

LArRodBlockStructure * LArRodDecoder::prepareBlockStructure ( const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment & robFrag, const uint32_t * p, uint32_t n, const CaloGain::CaloGain RequestedGain ) const

private

Definition at line 829 of file LArRodDecoder.cxx.

{ 
#ifndef NDEBUG
  ATH_MSG_DEBUG("Prepare LArRodBlockStructure. Got a fragement of size " << n);
#endif
 
  //Get version and blocktype form header
  eformat::helper::Version ver(robFrag.rod_version());
  const uint16_t rodMinorVersion=ver.minor_version();
  const uint32_t rodBlockType=robFrag.rod_detev_type()&0xff;
  LArRodBlockStructure* BlStruct = prepareBlockStructure1 (rodMinorVersion, rodBlockType);
  if (!BlStruct) {
    return nullptr;
  }
 
  if (!BlStruct->setFragment(p,n)) {
    constexpr int maxMess = 100;
    static std::atomic<int> nMess = 1;
    int thismess = nMess++;
    if (thismess <= maxMess) {
      ATH_MSG_ERROR("Could not set fragment (wrong number of samples in data ?) - container will not be filled");
      if (thismess == maxMess)
        ATH_MSG_ERROR("This message will not be repeated");
    }
    return NULL;
  }
#ifndef NDEBUG
  ATH_MSG_VERBOSE("Set Fragment at address "<<  &(p[0]) << " " << p[5]);
#endif
 
  BlStruct->setGain(RequestedGain); //Will be ignored if BlockStructure does not support fixed gains.    
  //FIXME: Very ugly hack! See explanation in LArRodDecoder.h 
  if (m_firstSample) {
    BlStruct->setFirstSample(m_firstSample);
  }
  return BlStruct;
}

prepareBlockStructure1()

LArRodBlockStructure * LArRodDecoder::prepareBlockStructure1 ( const uint16_t rodMinorVersion, const uint32_t robBlockType ) const

private

Definition at line 795 of file LArRodDecoder.cxx.

{ 
  const unsigned MAXMINOR = 12;
  const unsigned MAXTYPE = 10;
 
  if (rodMinorVersion > MAXMINOR || robBlockType > MAXTYPE) {
    ATH_MSG_ERROR("Bad Rod block type " <<  robBlockType
                  << " / " << rodMinorVersion);
    return nullptr;
  }
  std::vector<std::unique_ptr<LArRodBlockStructure> >& blstructs =
    *m_blstructs.get();
  unsigned int index = robBlockType * (MAXMINOR+1) + rodMinorVersion;
  if (blstructs.empty()) {
    blstructs.resize ((MAXMINOR+1)*(MAXTYPE+1));
  }
  if (!blstructs[index]) {
    blstructs[index] = makeBlockStructure (robBlockType, rodMinorVersion);
  }
  if (!blstructs[index]) {
    ATH_MSG_ERROR("Bad Rod block type " <<  robBlockType
                  << " / " << rodMinorVersion);
    return nullptr;
  }
 
#ifndef NDEBUG
  ATH_MSG_DEBUG("Found version " << rodMinorVersion << " of Rod block type " << robBlockType);
#endif
 
  return blstructs[index].get();
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setCellEnergy()

void LArRodDecoder::setCellEnergy ( LArCell * element, int energy, int time, int quality, CaloGain::CaloGain gain ) const

inlineprivate

Definition at line 371 of file LArRodDecoder.h.

{
  // Set energy, time, quality and hardware gain
  element->set((float)energy, (float)time, (double)quality, gain);
}

setsecfeb()

void LArRodDecoder::setsecfeb ( HWIdentifier feb )

inline

Definition at line 145 of file LArRodDecoder.h.

{m_febIdHLT = feb.get_identifier32().get_compact();};

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

writeFebInfo()

void LArRodDecoder::writeFebInfo ( LArCellCollection & m_coll, LArFebEnergy & febene ) const

inlineprivate

Definition at line 379 of file LArRodDecoder.h.

 {
   coll.addfebenergy(febene);
 }

Member Data Documentation

ATLAS_THREAD_SAFE

SG::SlotSpecificObj<std::vector<std::unique_ptr<LArRodBlockStructure> > > m_blstructs LArRodDecoder::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 236 of file LArRodDecoder.h.

m_CheckSum

bool LArRodDecoder::m_CheckSum

private

Definition at line 239 of file LArRodDecoder.h.

m_delayScale

double LArRodDecoder::m_delayScale

private

Definition at line 234 of file LArRodDecoder.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_evt

SG::ReadHandleKey<xAOD::EventInfo> LArRodDecoder::m_evt {this, "EvtInfo", "EventInfo", "EventInfo name"}

private

Definition at line 210 of file LArRodDecoder.h.

{this, "EvtInfo", "EventInfo", "EventInfo name"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_febExchange

bool LArRodDecoder::m_febExchange

private

Definition at line 213 of file LArRodDecoder.h.

m_febId1

unsigned int LArRodDecoder::m_febId1

private

Definition at line 214 of file LArRodDecoder.h.

m_febId2

unsigned int LArRodDecoder::m_febId2

private

Definition at line 214 of file LArRodDecoder.h.

m_febIdHLT

unsigned int LArRodDecoder::m_febIdHLT = 0U

private

Definition at line 214 of file LArRodDecoder.h.

m_firstSample

int LArRodDecoder::m_firstSample

private

Definition at line 216 of file LArRodDecoder.h.

m_IgnoreCheckFEBs

std::vector<unsigned int> LArRodDecoder::m_IgnoreCheckFEBs

private

Definition at line 231 of file LArRodDecoder.h.

m_LArCellCorrNames

std::vector<std::string> LArRodDecoder::m_LArCellCorrNames

private

Definition at line 230 of file LArRodDecoder.h.

m_LArCellCorrTools

std::vector<const CaloCellCorrection*> LArRodDecoder::m_LArCellCorrTools

private

Definition at line 232 of file LArRodDecoder.h.

m_LArCellEthreshold

float LArRodDecoder::m_LArCellEthreshold

private

Definition at line 211 of file LArRodDecoder.h.

m_MultiDSPMode

bool LArRodDecoder::m_MultiDSPMode

private

Definition at line 238 of file LArRodDecoder.h.

m_onlineHelper

const LArOnlineID* LArRodDecoder::m_onlineHelper

private

Definition at line 229 of file LArRodDecoder.h.

m_readtdc

bool LArRodDecoder::m_readtdc

private

Definition at line 212 of file LArRodDecoder.h.

m_requiredPhysicsNSamples

unsigned short LArRodDecoder::m_requiredPhysicsNSamples

private

Definition at line 240 of file LArRodDecoder.h.

m_StatusMask

uint32_t LArRodDecoder::m_StatusMask

private

Definition at line 228 of file LArRodDecoder.h.

m_StatusNMask

uint32_t LArRodDecoder::m_StatusNMask = 0U

private

Definition at line 228 of file LArRodDecoder.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vBEPreselection

std::vector<int> LArRodDecoder::m_vBEPreselection

private

Definition at line 225 of file LArRodDecoder.h.

m_vFinalPreselection

std::vector<unsigned int> LArRodDecoder::m_vFinalPreselection

private

Definition at line 227 of file LArRodDecoder.h.

m_vFTPreselection

std::vector<int> LArRodDecoder::m_vFTPreselection

private

Definition at line 224 of file LArRodDecoder.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

m_vPosNegPreselection

std::vector<int> LArRodDecoder::m_vPosNegPreselection

private

Definition at line 226 of file LArRodDecoder.h.

---

The documentation for this class was generated from the following files:

• LArRodDecoder.h
• LArRodDecoder.cxx