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 388 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 40 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 67 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 254 of file LArRodDecoder.h.

{ 
 
 
/* FIXME,  exception?
  EventFormat::Error error;
  if (!frag->is_valid (&error)) {
    report_error (error, log);
    return false;
  }
  return true;
*/
 
  bool ret=false;
  try {
    ret=frag->check();
  } 
  //catch ( .... ) {
  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 517 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;   
 
  //  for(int i=0;i<16;i++)
  //  std::cout << " -     " << std::hex << p[i] << std::endl;
 
  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) {
      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 " << 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
 
  return;
}

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 647 of file LArRodDecoder.cxx.

{ // Accumulated Digit pointer
  LArAccumulatedDigit * dg=0 ;
  CaloGain::CaloGain calogain;
  uint32_t gain, ntrigger;
  //int NStep=-1, StepIndex=-1;
  int fcNb;
  std::vector<uint64_t> sampleSum;   
  std::vector< uint64_t > sampleSquare;   
 
  //  for(int i=0;i<16;i++)
  //  std::cout << " -     " << std::hex << p[i] << std::endl;
 
  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) {
      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 " << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
      continue;
    }
      }
      int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
      ntrigger=BlStruct->getNTrigger();
      //NStep=BlStruct->getNStep();
      //if(!NStep) NStep=1; // To be able to decode v6 code
      //StepIndex=BlStruct->getStepIndex();
      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
 
  return;
}

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 320 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();
    //    int iFeb=0, iCan=0; //For debug purpose
    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);
      //std::cout << "Processing FEB #" << iFeb++ << std::endl;
      
      //int iCan=0;
 
      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);
      //if (calibChannelIDs->size()==0) 
      //continue; //Disconnected channel
      //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);
      //iCan++;
    }
    }
    while (BlStruct->nextFEB()); //Get NextFeb
  }
  coll.setDelayScale(m_delayScale);
  return;
}

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 137 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)) {
    msg(MSG::WARNING) << "Invalid FEB identifer 0x" << std::hex << fId32 << std::dec << ". Skipping" << endmsg;
    continue;
      }
      // std::cout << "digit FEBID=" << std::hex<<  " " <<fId32 << std::dec<<std::endl;
      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) {
      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) {
    const uint32_t onsum  = BlStruct->onlineCheckSum();
    const uint32_t offsum = BlStruct->offlineCheckSum();
    if(onsum!=offsum) {
      msg(MSG::WARNING) << "Checksum error for FEB: " << MSG::hex << fId32 << endmsg;
      msg(MSG::WARNING) << " online checksum  = " << MSG::hex << onsum  << endmsg;
      msg(MSG::WARNING) << " offline checksum = " << MSG::hex << offsum << MSG::dec << endmsg;
      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
   return;
}

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 741 of file LArRodDecoder.cxx.

{
  LArFebHeader* larFebHeader;
  //uint32_t NWtot=0;
  HWIdentifier FEBID;
 
  //  for(int i=0;i<16;i++)
  //  std::cout << " -     " << std::hex << p[i] << std::endl;
 
  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
    //NWtot=BlStruct->getNumberOfWords();
    //if(NWtot<=4) continue;
 
    FEBID=HWIdentifier(Identifier32(BlStruct->getFEBID()));
    unsigned int FEBID32 = FEBID.get_identifier32().get_compact();
    if (!m_onlineHelper->isValidId(FEBID)) {
      msg(MSG::WARNING) << "Invalid FEB identifer " << std:: hex << FEBID32 << std::dec << ". Skipping" << endmsg;
      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 228 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)) {
    msg(MSG::WARNING) << "Invalid FEB identifer " << std::hex << fId32 << std::dec << ". Skipping" << endmsg;
    continue;
      }
      // std::cout << "rawChan FEBID=" << std::hex <<fId32 << std::dec<<std::endl;
 
      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) {
      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) {
    const uint32_t onsum  = BlStruct->onlineCheckSum();
    const 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_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
   return;
}

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 290 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
/*  if (n<2) //Avoid segmentation fault
    {(*m_log) << MSG::WARNING << "Got empty Rod Fragment!" << endmsg;
     return;
    }
*/
  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);
        //setCellEnergy(collElem,energy, time, quality, (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 71 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 914 of file LArRodDecoder.cxx.

{
  switch (rodBlockType) {
  case 2:
    // RodBlockType 2 = Transparent mode only
    switch (rodMinorVersion) {
    case 0: // Transparent mode v0 05.01.2004
    case 1: // Transparent mode v0
    case 2: // Transparent mode v0
    case 3: // Transparent mode v0
    case 4: // Transparent mode v0
      return std::make_unique<LArRodBlockTransparentV0<LArRodBlockHeaderTransparentV0> >();
    case 5: // Calibration (Transparent mode) v1 17.01.2006
      return std::make_unique<LArRodBlockCalibrationV1>();
    case 6: // Calibration (Transparent mode) v3 31.05.2006
    case 7: // Calibration (Transparent mode) v3
    case 8: // Calibration (Transparent mode) v3
    case 9: // Calibration (Transparent mode) v3
    case 10:// Calibration (Transparent mode) v3
    case 11:// Calibration (Transparent mode) v3
    case 12:// Calibration (Transparent mode) v3
      return std::make_unique<LArRodBlockCalibrationV3>();
    default:
      break;
    }
    break;
 
  case 3:
    // RodBlockType 3 = Test mode
    return std::make_unique<LArRodBlockTransparentV0<LArRodBlockHeaderTransparentV0> >();
 
  case 4:
    // RodBlockType 4 = Physics mode
    switch (rodMinorVersion) {
    case 0: // Physics mode v0 05.01.2004 first draft
      return std::make_unique<LArRodBlockPhysicsV0>();
    case 1: // Physics mode v1 19.08.2004 only small differences
      return std::make_unique<LArRodBlockPhysicsV1>();
    case 2: // Physics mode v2 05.10.2004 adapted to real DSP data
    case 3: // Physics mode v2
    case 4: // Physics mode v2
    case 5: // Physics mode v2
    case 6: // Physics mode v2
    case 7: // Physics mode v2
    case 8: // Physics mode v2
      return std::make_unique<LArRodBlockPhysicsV2>();
    case 9: // Physics mode v4 10.07.2007 for commissioning
      return std::make_unique<LArRodBlockPhysicsV4>();
    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>();
        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>();
        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>();
 
  case 6:
    // RodBlockType 6 = Physics test mode
    switch (rodMinorVersion) {
    case 0: // Physics mode v0 05.01.2004 first draft
      return std::make_unique<LArRodBlockPhysicsV0>();
    case 1: // Physics mode v2 05.10.2004 adapted to real DSP data
    case 2: // Physics mode v2
      return std::make_unique<LArRodBlockPhysicsV2>();
    default:
      break;
    }
    break;
 
  case 7:
    // RodBlockType 7 = Calibration mode
    switch (rodMinorVersion) {
    case 0: // Calibration mode v0  05.01.2004
      return std::make_unique<LArRodBlockCalibrationV0<LArRodBlockHeaderCalibrationV0> >();
    case 1: // Calibration mode v1  17.01.2006
    case 2: // Calibration mode v1 
    case 3: // Calibration mode v1 
    case 4: // Calibration mode v1 
      return std::make_unique<LArRodBlockCalibrationV1>();
    case 5: // Calibration mode v2  26.04.2006
      return std::make_unique<LArRodBlockCalibrationV2>();
    case 6: // Calibration mode v3  31.05.2006
    case 7: // Calibration mode v3
    case 8: // Calibration mode v3
    case 9: // Calibration mode v3
    case 10:// Calibration mode v3
    case 11:// Calibration mode v3
    case 12:// Calibration mode v3
      return std::make_unique<LArRodBlockCalibrationV3>();
    default:
      break;
    }
    break;
 
  case 10:
    // RodBlockType 10 = Accumulated mode (used for pre-processed pedestal runs)
    // Accumulated mode v3 10.06.2008
    return std::make_unique<LArRodBlockAccumulatedV3>();
 
  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 872 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;
  }
 
  //BlStruct->dumpFragment(v); // For testing purpose
  if (!BlStruct->setFragment(p,n)) {
    constexpr int maxMess = 100;
    static std::atomic<int> nMess = 1;
    int thismess = nMess++;
    if (thismess <= maxMess) {
      msg(MSG::ERROR) << "Could not set fragment (wrong number of samples in data ?) - container will not be filled" << endmsg;
      if (thismess == maxMess)
        msg(MSG::ERROR) << "This message will not be repeated" << endmsg;
    }
    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 838 of file LArRodDecoder.cxx.

{ 
  const unsigned MAXMINOR = 12;
  const unsigned MAXTYPE = 10;
 
  if (rodMinorVersion > MAXMINOR || robBlockType > MAXTYPE) {
    msg(MSG::ERROR) << "Bad Rod block type " <<  robBlockType
                    << " / " << rodMinorVersion << endmsg;
    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]) {
    msg(MSG::ERROR) << "Bad Rod block type " <<  robBlockType
                    << " / " << rodMinorVersion << endmsg;
    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 380 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 364 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 405 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 148 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 >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    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 413 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 246 of file LArRodDecoder.h.

m_CheckSum

bool LArRodDecoder::m_CheckSum

private

Definition at line 249 of file LArRodDecoder.h.

m_delayScale

double LArRodDecoder::m_delayScale

private

Definition at line 244 of file LArRodDecoder.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evt

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

private

Definition at line 220 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 390 of file AthCommonDataStore.h.

m_febExchange

bool LArRodDecoder::m_febExchange

private

Definition at line 223 of file LArRodDecoder.h.

m_febId1

unsigned int LArRodDecoder::m_febId1

private

Definition at line 224 of file LArRodDecoder.h.

m_febId2

unsigned int LArRodDecoder::m_febId2

private

Definition at line 224 of file LArRodDecoder.h.

m_febIdHLT

unsigned int LArRodDecoder::m_febIdHLT = 0U

private

Definition at line 224 of file LArRodDecoder.h.

m_firstSample

int LArRodDecoder::m_firstSample

private

Definition at line 226 of file LArRodDecoder.h.

m_IgnoreCheckFEBs

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

private

Definition at line 241 of file LArRodDecoder.h.

m_LArCellCorrNames

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

private

Definition at line 240 of file LArRodDecoder.h.

m_LArCellCorrTools

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

private

Definition at line 242 of file LArRodDecoder.h.

m_LArCellEthreshold

float LArRodDecoder::m_LArCellEthreshold

private

Definition at line 221 of file LArRodDecoder.h.

m_MultiDSPMode

bool LArRodDecoder::m_MultiDSPMode

private

Definition at line 248 of file LArRodDecoder.h.

m_onlineHelper

const LArOnlineID* LArRodDecoder::m_onlineHelper

private

Definition at line 239 of file LArRodDecoder.h.

m_readtdc

bool LArRodDecoder::m_readtdc

private

Definition at line 222 of file LArRodDecoder.h.

m_requiredPhysicsNSamples

unsigned short LArRodDecoder::m_requiredPhysicsNSamples

private

Definition at line 250 of file LArRodDecoder.h.

m_StatusMask

uint32_t LArRodDecoder::m_StatusMask

private

Definition at line 238 of file LArRodDecoder.h.

m_StatusNMask

uint32_t LArRodDecoder::m_StatusNMask = 0U

private

Definition at line 238 of file LArRodDecoder.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vBEPreselection

std::vector<int> LArRodDecoder::m_vBEPreselection

private

Definition at line 235 of file LArRodDecoder.h.

m_vFinalPreselection

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

private

Definition at line 237 of file LArRodDecoder.h.

m_vFTPreselection

std::vector<int> LArRodDecoder::m_vFTPreselection

private

Definition at line 234 of file LArRodDecoder.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_vPosNegPreselection

std::vector<int> LArRodDecoder::m_vPosNegPreselection

private

Definition at line 236 of file LArRodDecoder.h.

---

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

• LArRodDecoder.h
• LArRodDecoder.cxx