ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
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:

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

40 : AthAlgTool(type,name,parent),
41 m_LArCellEthreshold(-100.),
42 m_readtdc(false),
43 m_onlineHelper(0)
44 {
45 declareInterface< LArRodDecoder >( this );
46 declareProperty("IgnoreCheckFEBs",m_IgnoreCheckFEBs);
47 declareProperty("CellCorrections",m_LArCellCorrNames );
48 declareProperty("LArCellEthreshold",m_LArCellEthreshold );
49 declareProperty("ReadTDC",m_readtdc);
50 declareProperty("DelayScale",m_delayScale=(25./240.)*CLHEP::ns);
51 declareProperty("FebExchange", m_febExchange=0); //FIXME: Very ugly hack! See explanation in .h file
52 declareProperty("FebId1", m_febId1=0);
53 declareProperty("FebId2", m_febId2=0);
54 declareProperty("FirstSample", m_firstSample=0); //FIXME: Very ugly hack! See explanation in .h file
55
56 declareProperty("BEPreselection",m_vBEPreselection,"For channel-selection: Barrel=0, Endcap=1");
57 declareProperty("PosNegPreselection",m_vPosNegPreselection,"For channel-selection: C-Side:0, A-Side: 1");
58 declareProperty("FTNumPreselection",m_vFTPreselection,"For channel-selection: Feedthrough numbers (e.g. 0 - 31 for barrel)");
59 declareProperty("MultiDSPMode", m_MultiDSPMode=false);
60 declareProperty("CheckSum", m_CheckSum=false);
61 declareProperty("StatusMask", m_StatusMask=0x00000212);
62 declareProperty("RequiredPhysicsNSamples", m_requiredPhysicsNSamples = 0);
63}
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
LArRodDecoder::m_LArCellCorrNames
std::vector< std::string > m_LArCellCorrNames
Definition LArRodDecoder.h:230
LArRodDecoder::m_vFTPreselection
std::vector< int > m_vFTPreselection
Definition LArRodDecoder.h:224
LArRodDecoder::m_onlineHelper
const LArOnlineID * m_onlineHelper
Definition LArRodDecoder.h:229
LArRodDecoder::m_IgnoreCheckFEBs
std::vector< unsigned int > m_IgnoreCheckFEBs
Definition LArRodDecoder.h:231
LArRodDecoder::m_febId1
unsigned int m_febId1
Definition LArRodDecoder.h:214
LArRodDecoder::m_LArCellEthreshold
float m_LArCellEthreshold
Definition LArRodDecoder.h:211
LArRodDecoder::m_requiredPhysicsNSamples
unsigned short m_requiredPhysicsNSamples
Definition LArRodDecoder.h:240
LArRodDecoder::m_vBEPreselection
std::vector< int > m_vBEPreselection
Definition LArRodDecoder.h:225
LArRodDecoder::m_febId2
unsigned int m_febId2
Definition LArRodDecoder.h:214
LArRodDecoder::m_StatusMask
uint32_t m_StatusMask
Definition LArRodDecoder.h:228
LArRodDecoder::m_vPosNegPreselection
std::vector< int > m_vPosNegPreselection
Definition LArRodDecoder.h:226

◆ ~LArRodDecoder()

LArRodDecoder::~LArRodDecoder ( )
virtual

Destructor.

Definition at line 66 of file LArRodDecoder.cxx.

67{
68}

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.

245{
246 bool ret=false;
247 try {
248 ret=frag->check();
249 }
250 catch (eformat::Issue& ex) {
251 msg(MSG::WARNING) << "Exception while checking eformat fragment validity: " << ex.what() << endmsg;
252 ret=false;
253 }
254 return ret;
255
256}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24

◆ 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.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ 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.

95{ 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.

85{ 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 507 of file LArRodDecoder.cxx.

513{ // Accumulated Digit pointer
514 LArAccumulatedCalibDigit * dg=0 ;
515 CaloGain::CaloGain calogain;
516 uint32_t gain, ntrigger;
517 int dac, delay, NStep=-1, StepIndex=-1;
518 bool ispulsed;
519 uint16_t ispulsed_int;
520 int bitShift;
521 uint32_t FirstGoodFEB=1;
522 int fcNb;
523 std::vector< uint64_t > samplesSum;
524 std::vector< uint64_t > samples2Sum;
525
526 LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
527 if (!BlStruct) return;
528 do
529 {
530 // IWS 24.01.2006 protection against NULL events (null pointer to rawdata block)
531 if (!BlStruct->hasCalibBlock())
532 {
533 ATH_MSG_DEBUG("No Calib Data for this FEB - NULL event");
534 continue;
535 }
536 if(FirstGoodFEB)
537 {
538 FirstGoodFEB=0;
539 }
540 HWIdentifier fId(Identifier32(BlStruct->getFEBID()));
541 unsigned int fId32 = fId.get_identifier32().get_compact();
542 // RL 20.09.2006 protection against 0 FebId
543 if (!fId32){
544 ATH_MSG_DEBUG("Bad FebID=0x" << std::hex << BlStruct->getFEBID() << " found for this FEB, skipping it!" << std::dec);
545 continue;
546 }
547 // RL 04.17.2008 skip check for some FEBs
548 int do_check=1;
549 std::vector<unsigned int>::const_iterator it_feb = m_IgnoreCheckFEBs.begin();
550 std::vector<unsigned int>::const_iterator it_feb_end = m_IgnoreCheckFEBs.end();
551 for(; it_feb!=it_feb_end;++it_feb)
552 if(fId==*it_feb) {
553 do_check=0;
554 break;
555 }
556 if(do_check) {
557 //WL 31.10.2007 //check RodStatus-word to catch corrupt events
558 if (BlStruct->getStatus() & m_StatusNMask) {
559 ATH_MSG_WARNING("RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB "<< std::hex << fId32 << std::dec <<". Ignored.");
560 continue;
561 }
562 }
563 // RL 05.11.2007 checksum
564 if(m_CheckSum) {
565 uint32_t onsum = BlStruct->onlineCheckSum();
566 uint32_t offsum = BlStruct->offlineCheckSum();
567 if(onsum!=offsum) {
568 ATH_MSG_WARNING("Checksum error:");
569 ATH_MSG_WARNING(" online checksum = " << MSG::hex << onsum);
570 ATH_MSG_WARNING(" offline checksum = " << MSG::hex << offsum);
571 continue;
572 }
573 }
574 if(m_febExchange) {
575 if (fId32 == m_febId1) {
576 fId = HWIdentifier(Identifier32(m_febId2));
577 fId32 = fId.get_identifier32().get_compact();
578 }
579 else if(fId32 == m_febId2) {
580 fId = HWIdentifier(Identifier32(m_febId1));
581 fId32 = fId.get_identifier32().get_compact();
582 }
583 }
584
585 if (m_vFinalPreselection.size()) {
586 unsigned int ftId=m_onlineHelper->feedthrough_Id(fId).get_identifier32().get_compact();
587 if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
588 ATH_MSG_DEBUG("Feedthrough with id " << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
589 continue;
590 }
591 }
592 int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
593 uint32_t idum=0;
594 while (BlStruct->getNextAccumulatedCalibDigit(fcNb,samplesSum,samples2Sum,idum,gain))
595 {
596 ispulsed_int=0;
597 bitShift=0;
598 if (fcNb>=NthisFebChannel)continue;
599 if (samplesSum.size()==0) continue; // Ignore missing cells
600 HWIdentifier cId = m_onlineHelper->channel_Id(fId,fcNb);
601 calogain=(CaloGain::CaloGain)gain;
602 ntrigger=BlStruct->getNTrigger();
603 dac=BlStruct->getDAC();
604 delay=BlStruct->getDelay();
605 NStep=BlStruct->getNStep();
606 if(!NStep) NStep=1; // To be able to decode v6 code
607 StepIndex=BlStruct->getStepIndex();
608 // 08.08.2005 IWS get calib line
609 const std::vector<HWIdentifier>& calibChannelIDs = calibLineMapping.calibSlotLine(cId);
610 if (calibChannelIDs.size()==0) {
611 samplesSum.clear();
612 samples2Sum.clear();
613 continue;// connected channel
614 }
615 //GR: Loop over all the calib chans instead of just looking at the first one and set four bit isPulsed int
616 for(std::vector<HWIdentifier>::const_iterator csl_it=calibChannelIDs.begin(); csl_it!=calibChannelIDs.end();++csl_it){
617 uint32_t calibLine = m_onlineHelper->channel(*csl_it);
618 ispulsed=BlStruct->getPulsed(calibLine);
619 ispulsed_int=( ispulsed_int | ((uint16_t)ispulsed<<bitShift) );
620 bitShift++;
621 }
622
623 dg=new LArAccumulatedCalibDigit(cId, calogain, samplesSum, samples2Sum, ntrigger, dac, delay,
624 (uint16_t)ispulsed_int, NStep, StepIndex);
625
626 coll.push_back(dg);
627 } // End while
628 }//End do loop of FEBs
629 while (BlStruct->nextFEB()); //Get NextFeb
630}
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
delay
double delay(std::size_t d)
Definition JetTrigTimerTest.cxx:11
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
LArCalibLineMapping::calibSlotLine
const std::vector< HWIdentifier > & calibSlotLine(const HWIdentifier id) const
Definition LArCalibLineMapping.cxx:15
LArRodBlockStructure::getNStep
virtual uint16_t getNStep() const
Definition LArRodBlockStructure.h:475
LArRodBlockStructure::hasCalibBlock
virtual uint32_t hasCalibBlock() const
Definition LArRodBlockStructure.h:120
LArRodBlockStructure::getDelay
virtual uint16_t getDelay() const
Definition LArRodBlockStructure.h:461
LArRodBlockStructure::getPulsed
virtual bool getPulsed(unsigned channelNumber) const
Definition LArRodBlockStructure.h:451
LArRodBlockStructure::getDAC
virtual uint16_t getDAC() const
Definition LArRodBlockStructure.h:456
LArRodBlockStructure::getNextAccumulatedCalibDigit
virtual int getNextAccumulatedCalibDigit(int &channelNumber, std::vector< uint64_t > &SamplesSum, std::vector< uint64_t > &Samples2Sum, uint32_t &nStepTriggers, uint32_t &gain)
Definition LArRodBlockStructure.cxx:86
LArRodBlockStructure::getStepIndex
virtual uint16_t getStepIndex() const
Definition LArRodBlockStructure.h:471
LArRodBlockStructure::getNTrigger
virtual uint16_t getNTrigger() const
Definition LArRodBlockStructure.h:466
LArRodBlockStructure::offlineCheckSum
virtual uint32_t offlineCheckSum() const
Definition LArRodBlockStructure.cxx:147
LArRodBlockStructure::getStatus
virtual uint32_t getStatus() const
Definition LArRodBlockStructure.cxx:227
LArRodBlockStructure::onlineCheckSum
virtual uint32_t onlineCheckSum() const
Definition LArRodBlockStructure.cxx:139
LArRodDecoder::m_vFinalPreselection
std::vector< unsigned int > m_vFinalPreselection
Definition LArRodDecoder.h:227
LArRodDecoder::m_StatusNMask
uint32_t m_StatusNMask
Definition LArRodDecoder.h:228
LArRodDecoder::prepareBlockStructure
LArRodBlockStructure * prepareBlockStructure(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, const uint32_t *p, uint32_t n, const CaloGain::CaloGain RequestedGain) const
Definition LArRodDecoder.cxx:842
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition CaloCondBlobAlgs_fillNoiseFromASCII.py:109
integrator_ascii2db.dac
dac
Definition integrator_ascii2db.py:126
xAOD::uint16_t
setWord1 uint16_t
Definition eFexEMRoI_v1.cxx:93
xAOD::uint32_t
setEventNumber uint32_t
Definition EventInfo_v1.cxx:127

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

634{ // Accumulated Digit pointer
635 LArAccumulatedDigit * dg=0 ;
636 CaloGain::CaloGain calogain;
637 uint32_t gain, ntrigger;
638 int fcNb;
639 std::vector<uint64_t> sampleSum;
640 std::vector< uint64_t > sampleSquare;
641
642 LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
643 if (!BlStruct) return;
644 do
645 {
646 // IWS 24.01.2006 protection against NULL events (null pointer to rawdata block)
647 if (!BlStruct->hasAccumBlock()) {
648 ATH_MSG_DEBUG("No Accum Data for this FEB - NULL event");
649 continue;
650 }
651 HWIdentifier fId(Identifier32(BlStruct->getFEBID()));
652 unsigned int fId32 = fId.get_identifier32().get_compact();
653 // RL 20.09.2006 protection against 0 FebId
654 if (!fId32) {
655 ATH_MSG_DEBUG("Bad FebID=0x" << std::hex << BlStruct->getFEBID() << " found for this FEB, skipping it!" << std::dec);
656 continue;
657 }
658 // RL 04.17.2008 skip check for some FEBs
659 int do_check=1;
660 std::vector<unsigned int>::const_iterator it_feb = m_IgnoreCheckFEBs.begin();
661 std::vector<unsigned int>::const_iterator it_feb_end = m_IgnoreCheckFEBs.end();
662 for(; it_feb!=it_feb_end;++it_feb)
663 if(fId==*it_feb) {
664 do_check=0;
665 break;
666 }
667 if(do_check) {
668 //WL 31.10.2007 //check RodStatus-word to catch corrupt events
669 if (BlStruct->getStatus() & m_StatusNMask) {
670 ATH_MSG_WARNING("RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB "<< std::hex << fId32 << std::dec <<". Ignored.");
671 continue;
672 }
673 }
674 // RL 05.11.2007 checksum
675 if(m_CheckSum) {
676 uint32_t onsum = BlStruct->onlineCheckSum();
677 uint32_t offsum = BlStruct->offlineCheckSum();
678 if(onsum!=offsum) {
679 ATH_MSG_WARNING("Checksum error:");
680 ATH_MSG_WARNING(" online checksum = " << MSG::hex << onsum);
681 ATH_MSG_WARNING(" offline checksum = " << MSG::hex << offsum);
682 continue;
683 }
684 }
685 if(m_febExchange) {
686 if (fId32 == m_febId1) {
687 fId = HWIdentifier(Identifier32(m_febId2));
688 fId32 = fId.get_identifier32().get_compact();
689 }
690 else if(fId32 == m_febId2) {
691 fId = HWIdentifier(Identifier32(m_febId1));
692 fId32 = fId.get_identifier32().get_compact();
693 }
694 }
695
696 if (m_vFinalPreselection.size()) {
697 unsigned int ftId=m_onlineHelper->feedthrough_Id(fId).get_identifier32().get_compact();
698 if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
699 ATH_MSG_DEBUG("Feedthrough with id " << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
700 continue;
701 }
702 }
703 int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
704 ntrigger=BlStruct->getNTrigger();
705 while (BlStruct->getNextAccumulatedDigit(fcNb,sampleSum,sampleSquare,gain)) {
706 if (fcNb>=NthisFebChannel)continue;
707 if (sampleSquare.size()==0) continue; // Ignore missing cells
708 HWIdentifier cId = m_onlineHelper->channel_Id(fId,fcNb);
709 calogain=(CaloGain::CaloGain)gain;
710 dg=new LArAccumulatedDigit(cId,calogain,sampleSum,sampleSquare,ntrigger);
711 coll.push_back(dg);
712 } // End while
713 }//End do loop of FEBs
714 while (BlStruct->nextFEB()); //Get NextFeb
715}
LArRodBlockStructure::hasAccumBlock
virtual uint32_t hasAccumBlock() const
Definition LArRodBlockStructure.h:121
LArRodBlockStructure::getNextAccumulatedDigit
virtual int getNextAccumulatedDigit(int &channelNumber, std::vector< uint64_t > &SamplesSum, std::vector< uint64_t > &corr2Sum, uint32_t &gain)
Definition LArRodBlockStructure.cxx:92

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

325{ // CalibDigit pointer
326 LArCalibDigit * dg=0 ;
327 uint32_t gain;
328 CaloGain::CaloGain calogain;
329 int fcNb;
330 uint16_t dac, delay;
331 bool ispulsed;
332 std::vector<short> samples;
333
334 ATH_MSG_VERBOSE("FillCollection for LArCalibDigitContainer is called.");
335 LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
336 if (!BlStruct) return;
337 if (BlStruct->canSetCalibration()) {
338 dac=BlStruct->getDAC();
339 delay=BlStruct->getDelay();
340 do
341 {
342 // IWS 24.01.2006 protection against NULL events (null pointer to rawdata block)
343 if (!BlStruct->hasRawDataBlock()) {
344 ATH_MSG_DEBUG("No Raw Data for this FEB - NULL event for FEBID " << std::hex << BlStruct->getFEBID());
345 continue;
346 }
347 HWIdentifier fId(Identifier32(BlStruct->getFEBID()));
348 unsigned int fId32 = fId.get_identifier32().get_compact();
349 // RL 20.09.2006 protection against 0 FebId
350 if (!fId32){
351 ATH_MSG_DEBUG("Bad FebID=0x"<< std::hex << BlStruct->getFEBID() << " found for this FEB, skipping it!");
352 continue;
353 }
354 // RL 04.17.2008 skip check for some FEBs
355 int do_check=1;
356 std::vector<unsigned int>::const_iterator it_feb = m_IgnoreCheckFEBs.begin();
357 std::vector<unsigned int>::const_iterator it_feb_end = m_IgnoreCheckFEBs.end();
358 for(; it_feb!=it_feb_end;++it_feb)
359 if(fId==*it_feb) {
360 do_check=0;
361 break;
362 }
363 if(do_check) {
364 //WL 31.10.2007 //check RodStatus-word to catch corrupt events
365 if (BlStruct->getStatus() & m_StatusNMask) {
366 msg(MSG::WARNING) << "RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB "<< std::hex << fId32 << std::dec <<". Ignored." << endmsg;
367 continue;
368 }
369 }
370 // RL 05.11.2007 checksum
371 if(m_CheckSum) {
372 uint32_t onsum = BlStruct->onlineCheckSum();
373 uint32_t offsum = BlStruct->offlineCheckSum();
374 if(onsum!=offsum) {
375 msg(MSG::WARNING) << "Checksum error:" << endmsg;
376 msg(MSG::WARNING) << " online checksum = " << MSG::hex << onsum << endmsg;
377 msg(MSG::WARNING) << " offline checksum = " << MSG::hex << offsum << endmsg;
378 continue;
379 }
380 }
381 if(m_febExchange) {
382 if (fId32 == m_febId1) {
383 fId = HWIdentifier(Identifier32(m_febId2));
384 fId32 = fId.get_identifier32().get_compact();
385 }
386 else if(fId32 == m_febId2) {
387 fId = HWIdentifier(Identifier32(m_febId1));
388 fId32 = fId.get_identifier32().get_compact();
389 }
390 }
391
392 if (m_vFinalPreselection.size()) {
393 unsigned int ftId=m_onlineHelper->feedthrough_Id(fId).get_identifier32().get_compact();
394 if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
395 ATH_MSG_DEBUG("Feedthrough with id 0x" << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
396 continue;
397 }
398 }
399 const int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
400 while (BlStruct->getNextRawData(fcNb,samples,gain))
401 {if (fcNb>=NthisFebChannel)
402 continue;
403 if (samples.size()==0) continue; // Ignore missing cells
404 HWIdentifier cId = m_onlineHelper->channel_Id(fId,fcNb);
405 ispulsed=BlStruct->getPulsed(fcNb);
406
407 calogain=(CaloGain::CaloGain)gain;
408 dg = new LArCalibDigit(cId, calogain, samples, dac, delay, ispulsed);
409 samples.clear();
410 coll.push_back(dg);
411 }
412 }
413 while (BlStruct->nextFEB()); //Get NextFeb
414 }
415 else {//Not a calibration data block, try to get from database
416 ATH_MSG_VERBOSE("Not LArCalibDigit data block found. Building it using DB values");
417 //1st step, get Calib board config object
418 const LArCalibParams* calibParams = nullptr;
419 StatusCode sc=detStore()->retrieve(calibParams);
420 if (sc.isFailure())
421 {msg(MSG::ERROR) << "Cannot load LArCalibParams from DetStore!" << endmsg;
422 return;
423 }
424 //2st step, get Event number
425 SG::ReadHandle<xAOD::EventInfo> evt(m_evt);
426 if (!evt.isValid()) {
427 ATH_MSG_ERROR("Cannot get EventInfo");
428 return; //Return empty container.
429 }
430 const unsigned eventNb=evt->eventNumber();
431 const std::vector<HWIdentifier>* calibChannelIDs;
432 do { //Loop over all FEBs in this ROD
433
434 // IWS 24.01.2006 protection against NULL events (null pointer to rawdata block)
435 if (!BlStruct->hasRawDataBlock()) {
436 ATH_MSG_DEBUG("No Raw Data for this FEB - NULL event for FEBID 0x" << std::hex << BlStruct->getFEBID() << std::dec);
437 continue;
438 }
439 HWIdentifier fId(Identifier32(BlStruct->getFEBID()));
440 unsigned int fId32 = fId.get_identifier32().get_compact();
441 // RL 20.09.2006 protection against 0 FebId
442 if (!fId32) {
443 ATH_MSG_DEBUG("Bad FebID=0x" << std::hex << BlStruct->getFEBID() << " found for this FEB, skipping it!" << std::dec);
444 continue;
445 }
446 if(m_febExchange) {
447 if (fId32 == m_febId1) {
448 fId = HWIdentifier(Identifier32(m_febId2));
449 fId32 = fId.get_identifier32().get_compact();
450 }
451 else if(fId32 == m_febId2) {
452 fId = HWIdentifier(Identifier32(m_febId1));
453 fId32 = fId.get_identifier32().get_compact();
454 }
455 }
456 fcNb=0;
457 HWIdentifier cId;
458 do { //Search for the first connected channel of this FEB (probably the first one...)
459 fcNb++;
460 cId = m_onlineHelper->channel_Id(fId,fcNb);
461 calibChannelIDs=&calibLineMapping.calibSlotLine(cId);
462 }
463 while ( (!onOffIdMapping.isOnlineConnected(cId) || calibChannelIDs->size()==0) && fcNb<128); // This is the right conditions to exit the loop!
464
465 if ( calibChannelIDs->size()==0 ) {
466 msg(MSG::ERROR) << "Cannot get calibration Channel ID for FEB " << std::hex << fId32 << std::dec << endmsg;
467 return;
468 }
469
470 uint16_t dac;
471 uint16_t delay;
472
473 std::vector<HWIdentifier>::const_iterator csl_it=calibChannelIDs->begin();
474 //Derive DAC and Delay value from this channel
475 dac=calibParams->DAC(eventNb,*csl_it);
476 delay=calibParams->Delay(eventNb,*csl_it);
477
478 //Now start looping over channels in FEB
479 const int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
480
481 fcNb=0;
482 while (BlStruct->getNextRawData(fcNb,samples,gain))
483 {
484 if (fcNb>=NthisFebChannel) continue;
485 if (samples.size()==0) continue; // Ignore missing cells
486 cId = m_onlineHelper->channel_Id(fId,fcNb);
487 calibChannelIDs=&calibLineMapping.calibSlotLine(cId);
488 //For the time being, I assume we are in H8 and have only one calib channel per FEB channel
489
490 if (calibChannelIDs->size()!=0) {
491 csl_it=calibChannelIDs->begin();
492 ispulsed=calibParams->isPulsed(eventNb,*csl_it);
493
494 } else ispulsed=0;
495 calogain=(CaloGain::CaloGain)gain;
496 dg = new LArCalibDigit(cId, calogain, samples, dac, delay, ispulsed);
497 samples.clear();
498
499 coll.push_back(dg);
500 }
501 }
502 while (BlStruct->nextFEB()); //Get NextFeb
503 }
504 coll.setDelayScale(m_delayScale);
505}
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
LArCalibDigitContainer::setDelayScale
void setDelayScale(const double scale)
set delay scale
Definition LArCalibDigitContainer.h:30
LArCalibParams::Delay
unsigned Delay(const unsigned event, const HWIdentifier calibLineID) const
Definition LArCalibParams.cxx:112
LArCalibParams::isPulsed
bool isPulsed(const unsigned event, const HWIdentifier calibLineID) const
Definition LArCalibParams.cxx:151
LArCalibParams::DAC
unsigned DAC(const unsigned event, const HWIdentifier calibLineID) const
Definition LArCalibParams.cxx:131
LArOnOffIdMapping::isOnlineConnected
bool isOnlineConnected(const HWIdentifier &sid) const
Test whether a HWIdentifier is connected of not (inline) .
Definition LArOnOffIdMapping.h:121
LArRodBlockStructure::hasRawDataBlock
virtual uint32_t hasRawDataBlock() const
Definition LArRodBlockStructure.h:123
LArRodBlockStructure::canSetCalibration
virtual bool canSetCalibration()
Definition LArRodBlockStructure.h:98
LArRodBlockStructure::getNextRawData
virtual int getNextRawData(int &channelNumber, std::vector< short > &samples, uint32_t &gain)
Definition LArRodBlockStructure.cxx:80
LArRodDecoder::m_evt
SG::ReadHandleKey< xAOD::EventInfo > m_evt
Definition LArRodDecoder.h:210
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22

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

140{ // Digit pointer
141 LArDigit * dg=0 ;
142 CaloGain::CaloGain calogain;
143 uint32_t gain;
144 int fcNb;
145 std::vector<short> samples;
146 LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
147 if (!BlStruct) return;
148
149 do {
150 HWIdentifier fId( Identifier32(BlStruct->getFEBID()) );
151 unsigned int fId32 = fId.get_identifier32().get_compact();
152 if (!m_onlineHelper->isValidId(fId)) {
153 ATH_MSG_WARNING("Invalid FEB identifer 0x" << std::hex << fId32 << std::dec << ". Skipping");
154 continue;
155 }
156 if(m_febExchange) {
157 if (fId32 == m_febId1) {
158 fId = HWIdentifier(Identifier32(m_febId2));
159 fId32 = fId.get_identifier32().get_compact();
160 }
161 else if(fId32 == m_febId2) {
162 fId = HWIdentifier(Identifier32(m_febId1));
163 fId32 = fId.get_identifier32().get_compact();
164 }
165 }
166
167 // IWS 24.01.2006 protection against NULL events (null pointer to rawdata block)
168 if (!BlStruct->hasRawDataBlock())
169 {
170 ATH_MSG_DEBUG("No Raw Data for this FEB - NULL event for FEBID 0x"<< std::hex << BlStruct->getFEBID() << std::dec);
171 continue;
172 }
173
174 // RL 04.17.2008 skip check for some FEBs
175 int do_check=1;
176 std::vector<unsigned int>::const_iterator it_feb = m_IgnoreCheckFEBs.begin();
177 std::vector<unsigned int>::const_iterator it_feb_end = m_IgnoreCheckFEBs.end();
178 for(; it_feb!=it_feb_end;++it_feb)
179 if(fId==*it_feb) {
180 do_check=0;
181 break;
182 }
183 if(do_check) {
184 //WL 31.10.2007 //check RodStatus-word to catch corrupt events
185 if (BlStruct->getStatus() & m_StatusNMask) {
186 ATH_MSG_WARNING("RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB "<< std::hex << fId32 << std::dec <<". Ignored.");
187 continue;
188 }
189 }
190 // RL 05.11.2007 checksum
191 if(m_CheckSum) {
192 const uint32_t onsum = BlStruct->onlineCheckSum();
193 const uint32_t offsum = BlStruct->offlineCheckSum();
194 if(onsum!=offsum) {
195 ATH_MSG_WARNING("Checksum error for FEB: " << MSG::hex << fId32);
196 ATH_MSG_WARNING(" online checksum = " << MSG::hex << onsum);
197 ATH_MSG_WARNING(" offline checksum = " << MSG::hex << offsum << MSG::dec);
198 continue;
199 }
200 }
201
202 if (m_vFinalPreselection.size()) {
203 const unsigned int ftId=m_onlineHelper->feedthrough_Id(fId).get_identifier32().get_compact();
204 if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
205 ATH_MSG_DEBUG("Feedthrough with id 0x" << MSG::hex << ftId << MSG::dec <<" not in preselection. Ignored.");
206 continue;
207 }
208 }
209 const int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
210 while (BlStruct->getNextRawData(fcNb,samples,gain))
211 {
212 if (fcNb>=NthisFebChannel)
213 continue;
214 if (samples.size()==0) continue; // Ignore missing cells
215 HWIdentifier cId = m_onlineHelper->channel_Id(fId,fcNb);
216 calogain=(CaloGain::CaloGain)gain;
217 dg = new LArDigit(cId, calogain, std::move(samples));
218 samples.clear();
219 coll.push_back(dg);
220 }
221 }
222 while (BlStruct->nextFEB()); //Get NextFeb
223}

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

719{
720 LArFebHeader* larFebHeader;
721 HWIdentifier FEBID;
722
723 LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
724 if (!BlStruct) return;
725
726 do{
727 //Read first FEB. The header of this feb is combined with the ROD-Header
728
729 FEBID=HWIdentifier(Identifier32(BlStruct->getFEBID()));
730 unsigned int FEBID32 = FEBID.get_identifier32().get_compact();
731 if (!m_onlineHelper->isValidId(FEBID)) {
732 ATH_MSG_WARNING("Invalid FEB identifer " << std:: hex << FEBID32 << std::dec << ". Skipping");
733 continue;
734 }
735
736 if(m_febExchange) {
737 if (FEBID32 == m_febId1) {
738 FEBID = HWIdentifier(Identifier32(m_febId2));
739 FEBID32 = FEBID.get_identifier32().get_compact();
740 }
741 else if(FEBID32 == m_febId2) {
742 FEBID = HWIdentifier(Identifier32(m_febId1));
743 FEBID32 = FEBID.get_identifier32().get_compact();
744 }
745 }
746
747 if (m_vFinalPreselection.size()) {
748 const unsigned int ftId=m_onlineHelper->feedthrough_Id(FEBID).get_identifier32().get_compact();
749 if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
750 ATH_MSG_DEBUG("Feedthrough with id 0x" << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
751 continue;
752 }
753 }
754
755
756
757 larFebHeader=new LArFebHeader(FEBID);
758 //setROD header data
759
760 larFebHeader->SetFormatVersion(robFrag.rod_version());
761 larFebHeader->SetSourceId(robFrag.rod_source_id());
762 larFebHeader->SetRunNumber(robFrag.rod_run_no());
763 larFebHeader->SetELVL1Id(robFrag.rod_lvl1_id());
764 larFebHeader->SetBCId(robFrag.rod_bc_id());
765 larFebHeader->SetLVL1TigType(robFrag.rod_lvl1_trigger_type());
766 larFebHeader->SetDetEventType(robFrag.rod_detev_type());
767
768 //set DSP data
769 const unsigned nsample=BlStruct->getNumberOfSamples();
770 const uint32_t status= BlStruct->getStatus();
771 larFebHeader->SetDspCodeVersion(BlStruct->getDspCodeVersion());
772 larFebHeader->SetDspEventCounter(BlStruct->getDspEventCounter());
773 larFebHeader->SetRodResults1Size(BlStruct->getResults1Size());
774 larFebHeader->SetRodResults2Size(BlStruct->getResults2Size());
775 larFebHeader->SetRodRawDataSize(BlStruct->getRawDataSize());
776 larFebHeader->SetNbSweetCells1(BlStruct->getNbSweetCells1());
777 larFebHeader->SetNbSweetCells2(BlStruct->getNbSweetCells2());
778 larFebHeader->SetNbSamples(nsample);
779 larFebHeader->SetOnlineChecksum(BlStruct->onlineCheckSum());
780 larFebHeader->SetOfflineChecksum(BlStruct->offlineCheckSum());
781
782 if(!BlStruct->hasControlWords()) {
783 larFebHeader->SetFebELVL1Id(robFrag.rod_lvl1_id());
784 larFebHeader->SetFebBCId(robFrag.rod_bc_id());
785 } else {
786 const uint16_t evtid = BlStruct->getCtrl1(0) & 0x1f;
787 const uint16_t bcid = BlStruct->getCtrl2(0) & 0x1fff;
788
789 larFebHeader->SetFebELVL1Id(evtid);
790 larFebHeader->SetFebBCId(bcid);
791 for(int iadc=0;iadc<16;iadc++) {
792 larFebHeader->SetFebCtrl1(BlStruct->getCtrl1(iadc));
793 larFebHeader->SetFebCtrl2(BlStruct->getCtrl2(iadc));
794 larFebHeader->SetFebCtrl3(BlStruct->getCtrl3(iadc));
795 }
796 for(unsigned int i = 0; i<nsample; i++ ) {
797 larFebHeader->SetFebSCA(BlStruct->getRadd(0,i) & 0xff);
798 }
799 }
800 larFebHeader->SetRodStatus(status);
801 coll.push_back(larFebHeader);
802
803 } while (BlStruct->nextFEB()); //Get NextFeb
804}
Identifier32::get_compact
value_type get_compact() const
Get the compact id.
Definition Identifier32.h:47
Identifier::get_identifier32
Identifier32 get_identifier32() const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
LArFebHeader::SetRodResults1Size
void SetRodResults1Size(const uint16_t size)
set the ROD block sizes
Definition LArFebHeader.h:142
LArFebHeader::SetOnlineChecksum
void SetOnlineChecksum(const uint32_t checksum)
Definition LArFebHeader.h:156
LArFebHeader::SetNbSweetCells2
void SetNbSweetCells2(const uint16_t n)
Definition LArFebHeader.h:152
LArFebHeader::SetRodStatus
void SetRodStatus(const uint32_t status)
set the ROD Status
Definition LArFebHeader.h:198
LArFebHeader::SetFebBCId
void SetFebBCId(const uint16_t bcid)
set the FEB Bunch Crossing ID
Definition LArFebHeader.h:182
LArFebHeader::SetFebCtrl2
void SetFebCtrl2(const uint16_t ctrl2)
set the FEB Control Word #2
Definition LArFebHeader.h:190
LArFebHeader::SetFormatVersion
void SetFormatVersion(const uint32_t formatVersion)
set the format version
Definition LArFebHeader.h:122
LArFebHeader::SetOfflineChecksum
void SetOfflineChecksum(const uint32_t checksum)
Definition LArFebHeader.h:158
LArFebHeader::SetFebSCA
void SetFebSCA(const uint16_t sca)
set the SCA's
Definition LArFebHeader.h:202
LArFebHeader::SetDetEventType
void SetDetEventType(const uint32_t detEvType)
set the Detector event type ID
Definition LArFebHeader.h:166
LArFebHeader::SetDspEventCounter
void SetDspEventCounter(const uint32_t eventCounter)
set the Event number counted by the DSP code
Definition LArFebHeader.h:174
LArFebHeader::SetLVL1TigType
void SetLVL1TigType(const uint32_t lvl1ttype)
set the Level1 trigger type ID
Definition LArFebHeader.h:162
LArFebHeader::SetRodRawDataSize
void SetRodRawDataSize(const uint16_t size)
Definition LArFebHeader.h:146
LArFebHeader::SetFebCtrl3
void SetFebCtrl3(const uint16_t ctrl3)
set the FEB Control Word #3
Definition LArFebHeader.h:194
LArFebHeader::SetFebCtrl1
void SetFebCtrl1(const uint16_t ctrl1)
set the FEB Control Word #1
Definition LArFebHeader.h:186
LArFebHeader::SetBCId
void SetBCId(const uint16_t bcid)
set the Bunch Crossing ID
Definition LArFebHeader.h:138
LArFebHeader::SetFebELVL1Id
void SetFebELVL1Id(const uint16_t elvl1Id)
set the FEB Event ID
Definition LArFebHeader.h:178
LArFebHeader::SetRunNumber
void SetRunNumber(const uint32_t runNumber)
set the run number
Definition LArFebHeader.h:130
LArFebHeader::SetSourceId
void SetSourceId(const uint32_t sourceID)
set the source Id
Definition LArFebHeader.h:126
LArFebHeader::SetRodResults2Size
void SetRodResults2Size(const uint16_t size)
Definition LArFebHeader.h:144
LArFebHeader::SetDspCodeVersion
void SetDspCodeVersion(const uint32_t codeVersion)
set the version of the DSP code
Definition LArFebHeader.h:170
LArFebHeader::SetNbSweetCells1
void SetNbSweetCells1(const uint16_t n)
set the number of samples and cells above thresholds
Definition LArFebHeader.h:150
LArFebHeader::SetNbSamples
void SetNbSamples(const uint16_t n)
Definition LArFebHeader.h:154
LArFebHeader::SetELVL1Id
void SetELVL1Id(const uint16_t elvl1Id)
set the EventID
Definition LArFebHeader.h:134
LArRodBlockStructure::getCtrl1
virtual uint16_t getCtrl1(uint32_t adc) const
Definition LArRodBlockStructure.cxx:224
LArRodBlockStructure::getCtrl3
virtual uint16_t getCtrl3(uint32_t adc) const
Definition LArRodBlockStructure.cxx:226
LArRodBlockStructure::getResults1Size
virtual uint16_t getResults1Size() const
Definition LArRodBlockStructure.cxx:228
LArRodBlockStructure::getRawDataSize
virtual uint16_t getRawDataSize() const
Definition LArRodBlockStructure.cxx:230
LArRodBlockStructure::getDspCodeVersion
virtual uint32_t getDspCodeVersion() const
Definition LArRodBlockStructure.cxx:234
LArRodBlockStructure::getCtrl2
virtual uint16_t getCtrl2(uint32_t adc) const
Definition LArRodBlockStructure.cxx:225
LArRodBlockStructure::getRadd
virtual uint32_t getRadd(uint32_t adc, uint32_t sample) const
Definition LArRodBlockStructure.cxx:223
LArRodBlockStructure::getNbSweetCells2
virtual uint16_t getNbSweetCells2() const
Definition LArRodBlockStructure.cxx:232
LArRodBlockStructure::getNumberOfSamples
virtual uint32_t getNumberOfSamples() const
Definition LArRodBlockStructure.cxx:221
LArRodBlockStructure::hasControlWords
virtual uint32_t hasControlWords() const
Definition LArRodBlockStructure.h:124
LArRodBlockStructure::getResults2Size
virtual uint16_t getResults2Size() const
Definition LArRodBlockStructure.cxx:229
LArRodBlockStructure::getNbSweetCells1
virtual uint16_t getNbSweetCells1() const
Definition LArRodBlockStructure.cxx:231
LArRodBlockStructure::getDspEventCounter
virtual int32_t getDspEventCounter() const
Definition LArRodBlockStructure.cxx:240
merge.status
status
Definition merge.py:16
xAOD::bcid
setEventNumber setTimeStamp bcid
Definition EventInfo_v1.cxx:133

◆ 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.

230{
231 int32_t energy;
232 int32_t time;
233 int32_t quality;
234 uint32_t gain;
235 int fcNb;
236 HWIdentifier cId;
237 LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
238 if (!BlStruct) return;
239
240 do {
241 HWIdentifier fId( Identifier32(BlStruct->getFEBID()) );
242 unsigned int fId32 = fId.get_identifier32().get_compact();
243 if (!m_onlineHelper->isValidId(fId)) {
244 ATH_MSG_WARNING("Invalid FEB identifer " << std::hex << fId32 << std::dec << ". Skipping");
245 continue;
246 }
247
248 if(m_febExchange) {
249 if (fId32 == m_febId1) {
250 fId = HWIdentifier(Identifier32(m_febId2));
251 fId32 = fId.get_identifier32().get_compact();
252 }
253 else if(fId32 == m_febId2) {
254 fId = HWIdentifier(Identifier32(m_febId1));
255 fId32 = fId.get_identifier32().get_compact();
256 }
257 }
258 if (!BlStruct->hasPhysicsBlock()) {
259 ATH_MSG_DEBUG("No Physics Data for this FEB - NULL event for FEBID 0x" << std::hex << BlStruct->getFEBID() << std::dec);
260 continue;
261 }
262
263 // RL 04.17.2008 skip check for some FEBs
264 int do_check=1;
265 std::vector<unsigned int>::const_iterator it_feb = m_IgnoreCheckFEBs.begin();
266 std::vector<unsigned int>::const_iterator it_feb_end = m_IgnoreCheckFEBs.end();
267 for(; it_feb!=it_feb_end;++it_feb)
268 if(fId==*it_feb) {
269 do_check=0;
270 break;
271 }
272 if(do_check) {
273 //WL 31.10.2007 //check RodStatus-word to catch corrupt events
274 if (BlStruct->getStatus() & m_StatusNMask) {
275 ATH_MSG_WARNING("RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB "<< std::hex << fId32 << std::dec <<". Ignored.");
276 continue;
277 }
278 }
279
280 // RL 05.11.2007 checksum
281 if(m_CheckSum) {
282 const uint32_t onsum = BlStruct->onlineCheckSum();
283 const uint32_t offsum = BlStruct->offlineCheckSum();
284 if(onsum!=offsum) {
285 ATH_MSG_WARNING("Checksum error:");
286 ATH_MSG_WARNING(" online checksum = " << MSG::hex << onsum);
287 ATH_MSG_WARNING(" offline checksum = " << MSG::hex << offsum);
288 continue;
289 }
290 }
291
292 if (m_vFTPreselection.size()) {
293 int ftId=m_onlineHelper->feedthrough_Id(fId).get_identifier32().get_compact();
294 if (!std::binary_search(m_vFTPreselection.begin(), m_vFTPreselection.end(),ftId)) {
295 ATH_MSG_DEBUG("Feedthrough with id " << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
296 continue;
297 }
298 }
299 const int NthisFebChannel=m_onlineHelper->channelInSlotMax(fId);
300 while (BlStruct->getNextEnergy(fcNb,energy,time,quality,gain)) {
301 if (fcNb>=NthisFebChannel)
302 continue;
303 cId = m_onlineHelper->channel_Id(fId,fcNb);
304 uint16_t iquality = 0;
305 uint16_t iprovenance = 0x1000;
306 if (quality>0) {
307 iprovenance |= 0x2000;
308 iquality = (quality & 0xFFFF);
309 }
310 LArRawChannel chan(cId, energy, time, iquality, iprovenance, (CaloGain::CaloGain)gain);
311 coll.push_back(chan);
312 }
313 }
314 while (BlStruct->nextFEB()); //Get NextFeb
315}
LArRodBlockStructure::hasPhysicsBlock
virtual uint32_t hasPhysicsBlock() const
Definition LArRodBlockStructure.h:122
LArRodBlockStructure::getNextEnergy
virtual int getNextEnergy(int &channelNumber, int32_t &energy, int32_t &time, int32_t &quality, uint32_t &gain)
Definition LArRodBlockStructure.h:445
CaloSwCorrections.time
time(flags, cells_name, *args, **kw)
Definition CaloSwCorrections.py:242
Epos4_Base_Fragment_PbPb.energy
energy
Definition Epos4_Base_Fragment_PbPb.py:11

◆ 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.

266{
267 LArCell *collElem=0; //Pointer to a new element to be added to the collection
268 uint32_t error = 0;
269
270#ifndef NDEBUG
271 ATH_MSG_VERBOSE("Prepare LArRodBlockStructure. Got a fragment of size " << n);
272#endif
273 const uint32_t blocksize=p[0]; //First word contains block size
274 if (blocksize>n) {
275 msg(MSG::ERROR) << "Got truncated ROD Fragment!" << endmsg;
276 // First Bit is truncated (see also below)
277 error|= 0x1;
278 return error;
279 }
280
281 //Get version and blocktype form header
282 eformat::helper::Version ver(robFrag.rod_version());
283 const uint16_t rMV_present=ver.minor_version();
284 const uint32_t rBT_present=robFrag.rod_detev_type()&0xff;
285
286 LArRodBlockStructure* BlStruct(nullptr);
287 if ( !providedRodBlockStructure || (rodMinorVersion!=rMV_present) || (robBlockType!=rBT_present) ){
288 BlStruct = prepareBlockStructure1 (rMV_present, rBT_present);
289 if (!BlStruct) {
290 // Second Bit is block empty or unknown
291 error|= 0x2;
292 return error;
293 }
294 providedRodBlockStructure = BlStruct;
295 rodMinorVersion = rMV_present;
296 robBlockType = rBT_present;
297 } else BlStruct = providedRodBlockStructure;
298
299 BlStruct->setFragment(p,n);
300 for(LArCellCollection::iterator ii=coll.begin();ii!=coll.end();++ii)
301 (*ii)->setEnergyFast(0.0);
302
303 int32_t energy(0);
304 int32_t time;
305 int32_t quality;
306 uint32_t gain;
307 CaloGain::CaloGain calogain;
308 int fcNb;
309 int nfeb;
310 calogain=CaloGain::LARNGAIN;
311 if(!BlStruct->setGain(calogain)){
312 ATH_MSG_DEBUG("Setting the Gain Problem");
313 }
314
315 int feb_number=0;
316 do //Loop over FEB's
317 {
318 HWIdentifier fId(BlStruct->getFEBID());
319 if (!(fId.get_identifier32().get_compact())) {
320#ifndef NDEBUG
321 ATH_MSG_DEBUG("Bad FebID=0x"<< std::hex << BlStruct->getFEBID() << std::dec << " found for this FEB, skipping it!");
322#endif
323 // Third Bit is FEB ID issue (disabled - use 0x20 instead)
324 //error|= 0x4;
325 continue;
326 }
327 // RL 05.11.2007 checksum
328 if(m_CheckSum) {
329 uint32_t onsum = BlStruct->onlineCheckSum();
330 uint32_t offsum = BlStruct->offlineCheckSum();
331 if(onsum!=offsum) {
332 msg(MSG::WARNING) << "Checksum error:" << endmsg;
333 msg(MSG::WARNING) << " online checksum = 0x" << MSG::hex << onsum << endmsg;
334 msg(MSG::WARNING) << " offline checksum = 0x" << MSG::hex << offsum << MSG::dec << endmsg;
335 // Fourth Bit CheckSum issue (maybe disabled!)
336 error|= 0x8;
337 continue;
338 }
339 }
340 feb_number++;
341
342 if ( BlStruct->hasPhysicsBlock() ) {
343 if ( fId == m_febIdHLT ) nfeb = 128; // This is the second feb
344 else nfeb = 0;
345 int NthisFebChannel=128 ; // m_onlineHelper->channelInSlotMax(fId);
346 uint16_t iquality;
347 uint16_t iprovenance;
348 while (BlStruct->getNextEnergy(fcNb,energy,time,quality,gain)) {
349 if (fcNb>=NthisFebChannel) continue;
350 collElem = coll[fcNb+nfeb];
351 iprovenance=0x1000; // data comes from DSP computation
352 iquality=0;
353 if ( quality>=0 ) { iprovenance|= 0x2000; iquality=(quality& 0xffff);}
354 // time converted to ns
355 collElem->set(energy, time*1e-3, iquality, iprovenance, (CaloGain::CaloGain)gain);
356 }
357 continue;
358 }
359 }
360 while (BlStruct->nextFEB()); //Get NextFeb
361 // Error meaning data corruption. Maybe in any FEB
362 if ( BlStruct->report_error() ) error |= 0x1;
363 // error of uncompatible number of cells is bit 5
364 unsigned int collection_size = coll.size();
365 if ( feb_number== 0 && collection_size>0 ) error |= 0x20;
366 if ( feb_number== 1 && collection_size !=128 ) error |= 0x20;
367 if ( feb_number== 2 && collection_size !=256 ) error |= 0x20;
368 return error;
369}
CaloCell::set
void set(const CaloDetDescrElement *caloDDE, const Identifier &ID)
Fast method to change the identity of a cell.
Definition CaloCell.h:511
DataVector< LArCell >::iterator
DataModel_detail::iterator< DataVector > iterator
Definition DataVector.h:842
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
LArRodBlockStructure::setFragment
bool setFragment(const uint32_t *p, uint32_t n)
Definition LArRodBlockStructure.h:248
LArRodDecoder::m_febIdHLT
unsigned int m_febIdHLT
Definition LArRodDecoder.h:214
LArRodDecoder::prepareBlockStructure1
LArRodBlockStructure * prepareBlockStructure1(const uint16_t rodMinorVersion, const uint32_t robBlockType) const
Definition LArRodDecoder.cxx:808
CaloGain::LARNGAIN
@ LARNGAIN
Definition CaloGain.h:19
Pythia8_A14_NNPDF23LO_Var1Down_Common.ver
ver
Definition Pythia8_A14_NNPDF23LO_Var1Down_Common.py:26
get_generator_info.error
error
Definition get_generator_info.py:40

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

71{ return IID_ILArRodDecoder; }
IID_ILArRodDecoder
static const InterfaceID IID_ILArRodDecoder("LArRodDecoder", 1, 0)

◆ makeBlockStructure()

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

Definition at line 883 of file LArRodDecoder.cxx.

885{
886 switch (rodBlockType) {
887 case 2:
888 // RodBlockType 2 = Transparent mode only
889 switch (rodMinorVersion) {
890 case 0: // Transparent mode v0 05.01.2004
891 case 1: // Transparent mode v0
892 case 2: // Transparent mode v0
893 case 3: // Transparent mode v0
894 case 4: // Transparent mode v0
895 return std::make_unique<LArRodBlockTransparentV0<LArRodBlockHeaderTransparentV0> >(this->msgSvc().get());
896 case 5: // Calibration (Transparent mode) v1 17.01.2006
897 return std::make_unique<LArRodBlockCalibrationV1>(this->msgSvc().get());
898 case 6: // Calibration (Transparent mode) v3 31.05.2006
899 case 7: // Calibration (Transparent mode) v3
900 case 8: // Calibration (Transparent mode) v3
901 case 9: // Calibration (Transparent mode) v3
902 case 10:// Calibration (Transparent mode) v3
903 case 11:// Calibration (Transparent mode) v3
904 case 12:// Calibration (Transparent mode) v3
905 return std::make_unique<LArRodBlockCalibrationV3>(this->msgSvc().get());
906 default:
907 break;
908 }
909 break;
910
911 case 3:
912 // RodBlockType 3 = Test mode
913 return std::make_unique<LArRodBlockTransparentV0<LArRodBlockHeaderTransparentV0> >(this->msgSvc().get());
914
915 case 4:
916 // RodBlockType 4 = Physics mode
917 switch (rodMinorVersion) {
918 case 0: // Physics mode v0 05.01.2004 first draft
919 return std::make_unique<LArRodBlockPhysicsV0>(this->msgSvc().get());
920 case 1: // Physics mode v1 19.08.2004 only small differences
921 return std::make_unique<LArRodBlockPhysicsV1>(this->msgSvc().get());
922 case 2: // Physics mode v2 05.10.2004 adapted to real DSP data
923 case 3: // Physics mode v2
924 case 4: // Physics mode v2
925 case 5: // Physics mode v2
926 case 6: // Physics mode v2
927 case 7: // Physics mode v2
928 case 8: // Physics mode v2
929 return std::make_unique<LArRodBlockPhysicsV2>(this->msgSvc().get());
930 case 9: // Physics mode v4 10.07.2007 for commissioning
931 return std::make_unique<LArRodBlockPhysicsV4>(this->msgSvc().get());
932 case 10: // Physics mode v5 16.06.2008 for LHC
933 case 11: // Physics mode v5 16.06.2008 for LHC
934 {
935 auto bl = std::make_unique<LArRodBlockPhysicsV5>(this->msgSvc().get());
936 if (m_requiredPhysicsNSamples > 0) {
937 bl->setRequiredNSamples(m_requiredPhysicsNSamples);
938 }
939 return bl;
940 }
941 case 12: // Physics mode v5 09.03.2011 for LHC
942 {
943 auto bl = std::make_unique<LArRodBlockPhysicsV6>(this->msgSvc().get());
944 if (m_requiredPhysicsNSamples > 0) {
945 bl->setRequiredNSamples(m_requiredPhysicsNSamples);
946 }
947 return bl;
948 }
949 default:
950 break;
951 }
952 break;
953
954 case 5:
955 // RodBlockType 5 = Physics simulation mode
956 // Physics mode v3 11.04.2005 for simulation
957 return std::make_unique<LArRodBlockPhysicsV3>(this->msgSvc().get());
958
959 case 6:
960 // RodBlockType 6 = Physics test mode
961 switch (rodMinorVersion) {
962 case 0: // Physics mode v0 05.01.2004 first draft
963 return std::make_unique<LArRodBlockPhysicsV0>(this->msgSvc().get());
964 case 1: // Physics mode v2 05.10.2004 adapted to real DSP data
965 case 2: // Physics mode v2
966 return std::make_unique<LArRodBlockPhysicsV2>(this->msgSvc().get());
967 default:
968 break;
969 }
970 break;
971
972 case 7:
973 // RodBlockType 7 = Calibration mode
974 switch (rodMinorVersion) {
975 case 0: // Calibration mode v0 05.01.2004
976 return std::make_unique<LArRodBlockCalibrationV0<LArRodBlockHeaderCalibrationV0> >(this->msgSvc().get());
977 case 1: // Calibration mode v1 17.01.2006
978 case 2: // Calibration mode v1
979 case 3: // Calibration mode v1
980 case 4: // Calibration mode v1
981 return std::make_unique<LArRodBlockCalibrationV1>(this->msgSvc().get());
982 case 5: // Calibration mode v2 26.04.2006
983 return std::make_unique<LArRodBlockCalibrationV2>(this->msgSvc().get());
984 case 6: // Calibration mode v3 31.05.2006
985 case 7: // Calibration mode v3
986 case 8: // Calibration mode v3
987 case 9: // Calibration mode v3
988 case 10:// Calibration mode v3
989 case 11:// Calibration mode v3
990 case 12:// Calibration mode v3
991 return std::make_unique<LArRodBlockCalibrationV3>(this->msgSvc().get());
992 default:
993 break;
994 }
995 break;
996
997 case 10:
998 // RodBlockType 10 = Accumulated mode (used for pre-processed pedestal runs)
999 // Accumulated mode v3 10.06.2008
1000 return std::make_unique<LArRodBlockAccumulatedV3>(this->msgSvc().get());
1001
1002 default:
1003 break;
1004 }
1005
1006 return std::unique_ptr<LArRodBlockStructure>();
1007}
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition hcg.cxx:130

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

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

844{
845#ifndef NDEBUG
846 ATH_MSG_DEBUG("Prepare LArRodBlockStructure. Got a fragement of size " << n);
847#endif
848
849 //Get version and blocktype form header
850 eformat::helper::Version ver(robFrag.rod_version());
851 const uint16_t rodMinorVersion=ver.minor_version();
852 const uint32_t rodBlockType=robFrag.rod_detev_type()&0xff;
853 LArRodBlockStructure* BlStruct = prepareBlockStructure1 (rodMinorVersion, rodBlockType);
854 if (!BlStruct) {
855 return nullptr;
856 }
857
858 if (!BlStruct->setFragment(p,n)) {
859 constexpr int maxMess = 100;
860 static std::atomic<int> nMess = 1;
861 int thismess = nMess++;
862 if (thismess <= maxMess) {
863 ATH_MSG_ERROR("Could not set fragment (wrong number of samples in data ?) - container will not be filled");
864 if (thismess == maxMess)
865 ATH_MSG_ERROR("This message will not be repeated");
866 }
867 return NULL;
868 }
869#ifndef NDEBUG
870 ATH_MSG_VERBOSE("Set Fragment at address "<< &(p[0]) << " " << p[5]);
871#endif
872
873 BlStruct->setGain(RequestedGain); //Will be ignored if BlockStructure does not support fixed gains.
874 //FIXME: Very ugly hack! See explanation in LArRodDecoder.h
875 if (m_firstSample) {
876 BlStruct->setFirstSample(m_firstSample);
877 }
878 return BlStruct;
879}
LArRodBlockStructure::setGain
virtual int setGain(const int GainValue)
Definition LArRodBlockStructure.cxx:200
LArRodBlockStructure::setFirstSample
void setFirstSample(const int rearrangeFirstSample)
Definition LArRodBlockStructure.h:166

◆ prepareBlockStructure1()

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

Definition at line 808 of file LArRodDecoder.cxx.

809{
810 const unsigned MAXMINOR = 12;
811 const unsigned MAXTYPE = 10;
812
813 if (rodMinorVersion > MAXMINOR || robBlockType > MAXTYPE) {
814 ATH_MSG_ERROR("Bad Rod block type " << robBlockType
815 << " / " << rodMinorVersion);
816 return nullptr;
817 }
818 std::vector<std::unique_ptr<LArRodBlockStructure> >& blstructs =
819 *m_blstructs.get();
820 unsigned int index = robBlockType * (MAXMINOR+1) + rodMinorVersion;
821 if (blstructs.empty()) {
822 blstructs.resize ((MAXMINOR+1)*(MAXTYPE+1));
823 }
824 if (!blstructs[index]) {
825 blstructs[index] = makeBlockStructure (robBlockType, rodMinorVersion);
826 }
827 if (!blstructs[index]) {
828 ATH_MSG_ERROR("Bad Rod block type " << robBlockType
829 << " / " << rodMinorVersion);
830 return nullptr;
831 }
832
833#ifndef NDEBUG
834 ATH_MSG_DEBUG("Found version " << rodMinorVersion << " of Rod block type " << robBlockType);
835#endif
836
837 return blstructs[index].get();
838}
LArRodDecoder::makeBlockStructure
std::unique_ptr< LArRodBlockStructure > makeBlockStructure(unsigned int rodBlockType, unsigned int rodMinorVersion) const
Definition LArRodDecoder.cxx:883
DeMoScan.index
str index
Definition DeMoScan.py:362

◆ 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.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
AthCommonDataStore::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 > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ 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.

364 {
365 handlesArray.renounce();
366 }

◆ 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.

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

◆ setsecfeb()

void LArRodDecoder::setsecfeb ( HWIdentifier feb)
inline

Definition at line 145 of file LArRodDecoder.h.

145{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.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
312 std::vector<SG::VarHandleKey*> keys = a->keys();
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

◆ writeFebInfo()

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

Definition at line 379 of file LArRodDecoder.h.

381 {
382 coll.addfebenergy(febene);
383 }

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 393 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.

210{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 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 399 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 398 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:
Generated on for ATLAS Offline Software by doxygen 1.16.1