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 msg(MSG::WARNING) << "RodStatus&0x" << std::hex << m_StatusNMask << " indicates corrupt data for FEB "<< std::hex << fId32 << std::dec <<". Ignored." << endmsg;
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 msg(MSG::WARNING) << "Checksum error:" << endmsg;
569 msg(MSG::WARNING) << " online checksum = " << MSG::hex << onsum << endmsg;
570 msg(MSG::WARNING) << " offline checksum = " << MSG::hex << offsum << endmsg;
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
631 return;
632}
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:474
LArRodBlockStructure::hasCalibBlock
virtual uint32_t hasCalibBlock() const
Definition LArRodBlockStructure.h:120
LArRodBlockStructure::getDelay
virtual uint16_t getDelay() const
Definition LArRodBlockStructure.h:457
LArRodBlockStructure::getPulsed
virtual bool getPulsed(unsigned channelNumber) const
Definition LArRodBlockStructure.h:445
LArRodBlockStructure::getDAC
virtual uint16_t getDAC() const
Definition LArRodBlockStructure.h:451
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:92
LArRodBlockStructure::getStepIndex
virtual uint16_t getStepIndex() const
Definition LArRodBlockStructure.h:469
LArRodBlockStructure::getNTrigger
virtual uint16_t getNTrigger() const
Definition LArRodBlockStructure.h:463
LArRodBlockStructure::offlineCheckSum
virtual uint32_t offlineCheckSum() const
Definition LArRodBlockStructure.cxx:161
LArRodBlockStructure::getStatus
virtual uint32_t getStatus() const
Definition LArRodBlockStructure.cxx:249
LArRodBlockStructure::onlineCheckSum
virtual uint32_t onlineCheckSum() const
Definition LArRodBlockStructure.cxx:153
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:846
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 634 of file LArRodDecoder.cxx.

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

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

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

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

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

723{
724 LArFebHeader* larFebHeader;
725 HWIdentifier FEBID;
726
727 LArRodBlockStructure* BlStruct=prepareBlockStructure(robFrag, p, n, RequestedGain);
728 if (!BlStruct) return;
729
730 do{
731 //Read first FEB. The header of this feb is combined with the ROD-Header
732
733 FEBID=HWIdentifier(Identifier32(BlStruct->getFEBID()));
734 unsigned int FEBID32 = FEBID.get_identifier32().get_compact();
735 if (!m_onlineHelper->isValidId(FEBID)) {
736 msg(MSG::WARNING) << "Invalid FEB identifer " << std:: hex << FEBID32 << std::dec << ". Skipping" << endmsg;
737 continue;
738 }
739
740 if(m_febExchange) {
741 if (FEBID32 == m_febId1) {
742 FEBID = HWIdentifier(Identifier32(m_febId2));
743 FEBID32 = FEBID.get_identifier32().get_compact();
744 }
745 else if(FEBID32 == m_febId2) {
746 FEBID = HWIdentifier(Identifier32(m_febId1));
747 FEBID32 = FEBID.get_identifier32().get_compact();
748 }
749 }
750
751 if (m_vFinalPreselection.size()) {
752 const unsigned int ftId=m_onlineHelper->feedthrough_Id(FEBID).get_identifier32().get_compact();
753 if (!std::binary_search(m_vFinalPreselection.begin(), m_vFinalPreselection.end(),ftId)) {
754 ATH_MSG_DEBUG("Feedthrough with id 0x" << std::hex << ftId << std::dec <<" not in preselection. Ignored.");
755 continue;
756 }
757 }
758
759
760
761 larFebHeader=new LArFebHeader(FEBID);
762 //setROD header data
763
764 larFebHeader->SetFormatVersion(robFrag.rod_version());
765 larFebHeader->SetSourceId(robFrag.rod_source_id());
766 larFebHeader->SetRunNumber(robFrag.rod_run_no());
767 larFebHeader->SetELVL1Id(robFrag.rod_lvl1_id());
768 larFebHeader->SetBCId(robFrag.rod_bc_id());
769 larFebHeader->SetLVL1TigType(robFrag.rod_lvl1_trigger_type());
770 larFebHeader->SetDetEventType(robFrag.rod_detev_type());
771
772 //set DSP data
773 const unsigned nsample=BlStruct->getNumberOfSamples();
774 const uint32_t status= BlStruct->getStatus();
775 larFebHeader->SetDspCodeVersion(BlStruct->getDspCodeVersion());
776 larFebHeader->SetDspEventCounter(BlStruct->getDspEventCounter());
777 larFebHeader->SetRodResults1Size(BlStruct->getResults1Size());
778 larFebHeader->SetRodResults2Size(BlStruct->getResults2Size());
779 larFebHeader->SetRodRawDataSize(BlStruct->getRawDataSize());
780 larFebHeader->SetNbSweetCells1(BlStruct->getNbSweetCells1());
781 larFebHeader->SetNbSweetCells2(BlStruct->getNbSweetCells2());
782 larFebHeader->SetNbSamples(nsample);
783 larFebHeader->SetOnlineChecksum(BlStruct->onlineCheckSum());
784 larFebHeader->SetOfflineChecksum(BlStruct->offlineCheckSum());
785
786 if(!BlStruct->hasControlWords()) {
787 larFebHeader->SetFebELVL1Id(robFrag.rod_lvl1_id());
788 larFebHeader->SetFebBCId(robFrag.rod_bc_id());
789 } else {
790 const uint16_t evtid = BlStruct->getCtrl1(0) & 0x1f;
791 const uint16_t bcid = BlStruct->getCtrl2(0) & 0x1fff;
792
793 larFebHeader->SetFebELVL1Id(evtid);
794 larFebHeader->SetFebBCId(bcid);
795 for(int iadc=0;iadc<16;iadc++) {
796 larFebHeader->SetFebCtrl1(BlStruct->getCtrl1(iadc));
797 larFebHeader->SetFebCtrl2(BlStruct->getCtrl2(iadc));
798 larFebHeader->SetFebCtrl3(BlStruct->getCtrl3(iadc));
799 }
800 for(unsigned int i = 0; i<nsample; i++ ) {
801 larFebHeader->SetFebSCA(BlStruct->getRadd(0,i) & 0xff);
802 }
803 }
804 larFebHeader->SetRodStatus(status);
805 coll.push_back(larFebHeader);
806
807 } while (BlStruct->nextFEB()); //Get NextFeb
808}
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:246
LArRodBlockStructure::getCtrl3
virtual uint16_t getCtrl3(uint32_t adc) const
Definition LArRodBlockStructure.cxx:248
LArRodBlockStructure::getResults1Size
virtual uint16_t getResults1Size() const
Definition LArRodBlockStructure.cxx:250
LArRodBlockStructure::getRawDataSize
virtual uint16_t getRawDataSize() const
Definition LArRodBlockStructure.cxx:252
LArRodBlockStructure::getDspCodeVersion
virtual uint32_t getDspCodeVersion() const
Definition LArRodBlockStructure.cxx:256
LArRodBlockStructure::getCtrl2
virtual uint16_t getCtrl2(uint32_t adc) const
Definition LArRodBlockStructure.cxx:247
LArRodBlockStructure::getRadd
virtual uint32_t getRadd(uint32_t adc, uint32_t sample) const
Definition LArRodBlockStructure.cxx:245
LArRodBlockStructure::getNbSweetCells2
virtual uint16_t getNbSweetCells2() const
Definition LArRodBlockStructure.cxx:254
LArRodBlockStructure::getNumberOfSamples
virtual uint32_t getNumberOfSamples() const
Definition LArRodBlockStructure.cxx:243
LArRodBlockStructure::hasControlWords
virtual uint32_t hasControlWords() const
Definition LArRodBlockStructure.h:124
LArRodBlockStructure::getResults2Size
virtual uint16_t getResults2Size() const
Definition LArRodBlockStructure.cxx:251
LArRodBlockStructure::getNbSweetCells1
virtual uint16_t getNbSweetCells1() const
Definition LArRodBlockStructure.cxx:253
LArRodBlockStructure::getDspEventCounter
virtual int32_t getDspEventCounter() const
Definition LArRodBlockStructure.cxx:262
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 226 of file LArRodDecoder.cxx.

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

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

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

813{
814 const unsigned MAXMINOR = 12;
815 const unsigned MAXTYPE = 10;
816
817 if (rodMinorVersion > MAXMINOR || robBlockType > MAXTYPE) {
818 msg(MSG::ERROR) << "Bad Rod block type " << robBlockType
819 << " / " << rodMinorVersion << endmsg;
820 return nullptr;
821 }
822 std::vector<std::unique_ptr<LArRodBlockStructure> >& blstructs =
823 *m_blstructs.get();
824 unsigned int index = robBlockType * (MAXMINOR+1) + rodMinorVersion;
825 if (blstructs.empty()) {
826 blstructs.resize ((MAXMINOR+1)*(MAXTYPE+1));
827 }
828 if (!blstructs[index]) {
829 blstructs[index] = makeBlockStructure (robBlockType, rodMinorVersion);
830 }
831 if (!blstructs[index]) {
832 msg(MSG::ERROR) << "Bad Rod block type " << robBlockType
833 << " / " << rodMinorVersion << endmsg;
834 return nullptr;
835 }
836
837#ifndef NDEBUG
838 ATH_MSG_DEBUG("Found version " << rodMinorVersion << " of Rod block type " << robBlockType);
839#endif
840
841 return blstructs[index].get();
842}
LArRodDecoder::makeBlockStructure
std::unique_ptr< LArRodBlockStructure > makeBlockStructure(unsigned int rodBlockType, unsigned int rodMinorVersion) const
Definition LArRodDecoder.cxx:887
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.14.0