ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
LArCalibDigitsAccumulator Class Reference

Emulator of DSP code in accumulation calibration mode. More...

#include <LArCalibDigitsAccumulator.h>

Inheritance diagram for LArCalibDigitsAccumulator:
Collaboration diagram for LArCalibDigitsAccumulator:

Classes

class  LArAccumulated
 Class of intermediate accumulations. More...
 

Public Member Functions

 LArCalibDigitsAccumulator (const std::string &name, ISvcLocator *pSvcLocator)
 
StatusCode initialize ()
 
StatusCode execute ()
 
StatusCode finalize ()
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

static std::string getPatternName (const std::string &gain, bool isPulsed, int delay, int dac)
 

Private Attributes

ToolHandle< ICaloSuperCellIDToolm_sc2ccMappingTool
 
SG::ReadCondHandleKey< LArCalibLineMappingm_calibMapKey {this,"CalibCablingKey","LArCalibLineMap","SG Key of LArCalibLineMapping object"}
 
SG::ReadCondHandleKey< LArCalibLineMappingm_calibMapSCKey {this,"CalibMapSCKey","LArCalibIdMapSC","SG Key of calib line mapping object"}
 
SG::ReadCondHandleKey< LArOnOffIdMappingm_cablingKey {this, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"}
 
SG::ReadCondHandleKey< LArOnOffIdMappingm_cablingKeySC {this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"}
 
const LArOnlineID_Basem_onlineHelper
 
int m_delay
 Store delay. More...
 
std::string m_calibAccuDigitContainerName
 LArAccumulatedCalibDigitContainer name. More...
 
std::vector< std::string > m_keylist
 list of key for input digit container (=gain) More...
 
unsigned int m_nStepTrigger
 Number of intermediate accumulations (JO property) More...
 
double m_delayScale
 Set delay scale. More...
 
bool m_keepPulsed
 Tells you whether you keep only pulsed cells or all cells. More...
 
bool m_isSC
 Tells you whether you run on SuperCells or Cells. More...
 
bool m_keepFullyPulsedSC
 Tells you whether you keep only fully pulsed supercells or all supercells. More...
 
double m_DropPercentTrig
 Percentage of the used triggers that we will skip over at the end, in order ot ensure that the accumulation is done, even if there are lots of missing events from SC. More...
 
std::map< std::string, std::vector< LArAccumulated > > m_Accumulated_map
 Vector (index=hash ID) of accumulation quantities. More...
 
unsigned int m_event_counter
 Event counter. More...
 
unsigned int m_eventNb = 0U
 
int m_sampleShift
 Samples to shift by, usually used in the case of SCs. More...
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Emulator of DSP code in accumulation calibration mode.

Version
$Id: LArCalibDigitsAccumulator.h,v 1.8 2008-06-12 14:51:35 lafaye Exp $
Author
Sandrine Laplace lapla.nosp@m.ce@l.nosp@m.app.i.nosp@m.n2p3.nosp@m..fr
Date
22-January-2006 Input to this algorithm are LArCalibDigits. These LArCalibDigits are accumulated (sum and squared sum)over a number of triggers given by the calibration run settings. Intermediate sums are also computed if the JO property "StepOfTriggers" is set to a larger number than one. The output of the algorithm is a LArAccumulatedCalibDigitContainer.

Definition at line 33 of file LArCalibDigitsAccumulator.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ LArCalibDigitsAccumulator()

LArCalibDigitsAccumulator::LArCalibDigitsAccumulator ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 15 of file LArCalibDigitsAccumulator.cxx.

15  :
16  AthAlgorithm(name, pSvcLocator),
17  m_sc2ccMappingTool("CaloSuperCellIDTool"),
18  m_onlineHelper(nullptr),
19  m_sampleShift(0)
20 {
21  declareProperty("LArAccuCalibDigitContainerName",m_calibAccuDigitContainerName, "LArAccumulatedCalibDigits");
22  declareProperty("KeyList",m_keylist);
23  declareProperty("StepOfTriggers",m_nStepTrigger=1);
24  declareProperty("DelayScale",m_delayScale=1*ns);
25  declareProperty("KeepOnlyPulsed",m_keepPulsed=false);
26  declareProperty("KeepFullyPulsedSC",m_keepFullyPulsedSC=false);
27  declareProperty("DropPercentTrig",m_DropPercentTrig=10);
28  declareProperty("isSC",m_isSC=false);
29  declareProperty("SampleShift",m_sampleShift=0);
30  m_delay=-1;
32 }

Member Function Documentation

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::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  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  t,
const SG::NotHandleType  
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::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;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::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() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::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; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode LArCalibDigitsAccumulator::execute ( )

first check if there is a -1 and continue

why this is not reset to -1 each event, does not make sense

assuming sizeSamples>m_sampleShift, is there a protection for this somehwere?

Definition at line 73 of file LArCalibDigitsAccumulator.cxx.

74 {
75 
76  StatusCode sc;
77 
78  if ( m_event_counter < 100 || m_event_counter%100==0 )
79  ATH_MSG_INFO( "Processing event " << m_event_counter );
81 
82  const LArCalibLineMapping *clcabling = nullptr;
84  clcabling =*clHdl;
85  if(!clcabling) {
86  ATH_MSG_WARNING( "Do not have calib line mapping from key " << m_calibMapKey.key() );
87  return StatusCode::FAILURE;
88  }
89 
90  const LArCalibLineMapping *clcablingSC = nullptr;
91  if(m_isSC) {
93  clcablingSC =*clHdl;
94  if(!clcablingSC) {
95  ATH_MSG_WARNING( "Do not have calib line mapping from key " << m_calibMapSCKey.key() );
96  return StatusCode::FAILURE;
97  }
98  }
99 
100  // new here ====
101  const LArOnOffIdMapping* cabling(nullptr);
102  const LArOnOffIdMapping* cablingLeg(nullptr);
103  if( m_isSC ){
105  cabling = {*cablingHdl};
106  if(!cabling) {
107  ATH_MSG_ERROR("Do not have mapping object " << m_cablingKeySC.key());
108  return StatusCode::FAILURE;
109  }
110 
112  cablingLeg = {*cablingHdlLeg};
113  if(!cablingLeg) {
114  ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
115  return StatusCode::FAILURE;
116  }
117  }
118 
119  // =============
120 
121 
122 
123  // pointer to input container
124  const LArCalibDigitContainer* calibDigitContainer=nullptr;
125 
126  // Event info
127  const xAOD::EventInfo* thisEventInfo = nullptr;
128  ATH_CHECK( evtStore()->retrieve(thisEventInfo) );
129  unsigned eventNb = thisEventInfo->eventNumber();
130  // retrieve calibration settings
131  const LArCalibParams* calibParams;
132  sc=detStore()->retrieve(calibParams,"LArCalibParams");
133  if (sc.isFailure())
134  {ATH_MSG_ERROR( "Cannot load LArCalibParams from DetStore." );
135  return StatusCode::FAILURE;
136  }
137 
138  unsigned int sizeSteps = (m_nStepTrigger>1 ? (m_nStepTrigger+1):1);
139 
140  // retrieve input calibDigits
141 
142  //Loop over all containers that are to be processed (e.g. different gains)
143  for (const std::string& key : m_keylist) {
144 
145  sc=evtStore()->retrieve(calibDigitContainer,key);
146  if(sc.isFailure()) {
147  ATH_MSG_ERROR( "Can't retrieve LArCalibDigitContainer with key " << key << "from StoreGate." );
148  return StatusCode::SUCCESS;
149  }else{
150  ATH_MSG_DEBUG( "Retrieved LArCalibDigitContainer with key " << key << " from StoreGate." );
151  }
152 
153  if(calibDigitContainer->empty()) {
154  ATH_MSG_DEBUG( "LArCalibDigitContainer with key=" << key << " is empty " );
155  }else{
156  ATH_MSG_DEBUG( "LArCalibDigitContainer with key=" << key << " has size = " << calibDigitContainer->size() );
157  }
158 
159  // counter of triggers
160  std::vector<unsigned int> ntrigger, nTriggerPerStep, nStepTrigger, iStepTrigger;
161  // effective number of triggers: per channel
162  ntrigger.resize(calibDigitContainer->size(),0);
163  // asked number of triggers (from calib settings): per FEB
164  nTriggerPerStep.resize(m_onlineHelper->febHashMax(),0);
165  nStepTrigger.resize(m_onlineHelper->febHashMax(),0);
166  iStepTrigger.resize(m_onlineHelper->febHashMax(),0);
167 
168  // output container
169  LArAccumulatedCalibDigitContainer* larAccuCalibDigitContainer = new LArAccumulatedCalibDigitContainer();
170  //Loop over all cells
171  for (const LArCalibDigit* digit : *calibDigitContainer) {
172  if(m_keepPulsed && !digit->isPulsed()) continue;
173 
174  // identificators
175  HWIdentifier chid=digit->hardwareID();
176  const HWIdentifier febid=m_onlineHelper->feb_Id(chid);
177  const IdentifierHash febhash = m_onlineHelper->feb_Hash(febid);
178  const IdentifierHash hashid = m_onlineHelper->channel_Hash(chid);
179 
180 
181 
183 
184  std::vector<Identifier> ccellIds(0);
185  unsigned numPulsedLeg = 0;
186  unsigned numCL = 0;
187  if( m_isSC ){
188 
190  bool hasInvalid=false;
191  for(auto s : digit->samples()){
192  if(s<0){
193  hasInvalid=true;
194  break;
195  }
196  }
197  if(hasInvalid) continue;
198 
199  Identifier myofflineID = cabling->cnvToIdentifier(digit->hardwareID()) ;
200  ccellIds = m_sc2ccMappingTool->superCellToOfflineID( myofflineID );
201  for (Identifier id : ccellIds) {// loop cells in sc
202  HWIdentifier cellLegHWID = cablingLeg->createSignalChannelID(id);
203  const std::vector<HWIdentifier>& calibLineLeg = clcabling->calibSlotLine(cellLegHWID);
204  numCL += calibLineLeg.size();
205  for (HWIdentifier calibLineHWID : calibLineLeg) {// loop legacy calib lines
206  if ( calibParams->isPulsed(eventNb,calibLineHWID) ){
207  numPulsedLeg += 1;
208  ATH_MSG_DEBUG("SC "<< chid << " constituent cell "<< cellLegHWID << " calib line "<< calibLineHWID<< " not pulsed");
209  }else{
210  if ( digit->isPulsed() ) ATH_MSG_WARNING("SC "<< chid << " constituent cell "<< cellLegHWID << " calib line "<< calibLineHWID<< " not pulsed");}
211  }//end calib line Leg loop
212  }//end legacy cell loop
213  if ( digit->isPulsed() && numPulsedLeg != numCL ){ //(int)(ccellIds.size()) ){
214  ATH_MSG_WARNING("Number of pulsed legacy cells does not equal number of calibration lines "<<chid<<"!! LArParams counter = " << numPulsedLeg << ", SC2CCMappingTool = " << ccellIds.size() << ", num CLs = "<< numCL);
215 
216  if(m_keepFullyPulsedSC){ // && numPulsedLeg < (int)(ccellIds.size())){
217  ATH_MSG_WARNING("Discarding this SC ("<<chid<<") as it is not fully pulsed");
218  continue;
219  }
220  }
221  ATH_MSG_DEBUG("SC "<<chid<<" pulsed cells "<< numPulsedLeg <<" or "<< ccellIds.size()<<", "<<numCL<<" calibration lines");
222  } // end m_isSC
223 
225 
226  // BELOW: DIRTY HACK BECAUSE THERE SEEMS TO BE A BUG IN THE CABLINGSVC CONCERNING THE CALIBLINES.
227  // get calibration settings
228  const std::vector<HWIdentifier>& calibLineID = m_isSC ? clcablingSC->calibSlotLine(chid) : clcabling->calibSlotLine(chid);
229  HWIdentifier calibModuleID;
230  if(!calibLineID.empty()){
231  calibModuleID=m_onlineHelper->calib_module_Id(calibLineID[0]);
232  nTriggerPerStep[febhash] = calibParams->NTrigger(calibModuleID);
233  ATH_MSG_DEBUG( "Ntrigger per step = " << nTriggerPerStep[febhash] );
234  if(nTriggerPerStep[febhash] > 1000) nTriggerPerStep[febhash]=100; // very dirty !!!
235  }else{
236 
237  nTriggerPerStep[febhash] = 100; // very dirty !!
238  }
239 
240  // cell is pulsed ?
241  bool isPulsed = digit->isPulsed();
242 
243  //First cell to be processed, set delay
244  if (m_delay==-1) {
245  m_delay=digit->delay();
246  }
247  else{
248  // next cells: should be the same delay
249  if (m_delay!=digit->delay()) {
250  ATH_MSG_DEBUG( "Delay is changing to " << digit->delay() << " from " << m_delay << ": book a new LArAccumulatedCalibDigitContainer" );
251  m_delay=digit->delay();
252  }
253  }
254 
255  std::string patternName = getPatternName(key, isPulsed, m_delay, digit->DAC());
256 
257  std::map<std::string, std::vector<LArAccumulated> >::iterator accIter=m_Accumulated_map.find(patternName);
258  if(accIter==m_Accumulated_map.end()){
259  accIter=m_Accumulated_map.insert(std::make_pair(patternName,std::vector<LArAccumulated>(m_onlineHelper->channelHashMax()))).first;
260  }
261 
262  CaloGain::CaloGain gain=digit->gain();
263  if (gain<0 || gain>CaloGain::LARNGAIN)
264  {ATH_MSG_ERROR( "Found not-matching gain number ("<< (int)gain <<")" );
265  delete larAccuCalibDigitContainer;
266  return StatusCode::FAILURE;
267  }
268 
269  // object to be filled for each cell
270  LArAccumulated& cellAccumulated = accIter->second[hashid];
271  cellAccumulated.m_onlineId=chid.get_identifier32().get_compact();
272 
273  // trigger counter for each cell
274  cellAccumulated.m_ntrigger++;
275  ATH_MSG_DEBUG( "chid = " << chid << ", trigger = " << cellAccumulated.m_ntrigger << ", DAC = " << digit->DAC()<<", Delay = "<<digit->delay()<<", isPulsed? "<<digit->isPulsed() );
276 
277  // at first trigger, initialize vectors
278  unsigned int sizeSamples = digit->samples().size();
279  ATH_MSG_DEBUG( "sizeSteps = " << sizeSteps << ", # of samples = " << sizeSamples );
280 
281  if(cellAccumulated.m_ntrigger==1){
282  cellAccumulated.m_sum.clear();
283  cellAccumulated.m_sum2.clear();
284  cellAccumulated.m_sum.resize(sizeSamples,0);
285  cellAccumulated.m_sum2.resize(sizeSamples,0);
286  }
287 
289  for(unsigned int j=0;j<sizeSamples;j++){
290  int digis;
291  if(j-m_sampleShift >= sizeSamples){
292  digis=digit->samples()[sizeSamples-1];
293  cellAccumulated.m_sum[j] += digis;
294  cellAccumulated.m_sum2[j] += digis*digis;
295  }
296  else if((int)j-m_sampleShift<0){
297  digis=digit->samples()[0];
298  cellAccumulated.m_sum[j] += digis;
299  cellAccumulated.m_sum2[j] += digis*digis;
300  } else{
301  digis=digit->samples()[j-m_sampleShift];
302  cellAccumulated.m_sum[j] += digis;
303  cellAccumulated.m_sum2[j] += digis*digis;
304  }
305  }
306 
307  // when reached total number of triggers for this step, fill LArAccumulatedCalibDigit and reset number of triggers
308  unsigned int ntrigUsed = nTriggerPerStep[febhash];
309  if ( m_isSC && m_DropPercentTrig != 0 ){
310  ntrigUsed -= ntrigUsed*(m_DropPercentTrig/100);
311  }
312 
313  if(cellAccumulated.m_ntrigger==ntrigUsed){
314  ATH_MSG_DEBUG( "filling LArAccumulatedCalibDigit " );
315  ATH_MSG_DEBUG( "chid = " << chid << ", gain = " << gain << ", DAC = " << digit->DAC() << ", isPulsed = " << isPulsed << ", delay = " << m_delay << ", trigPerStep = " << nTriggerPerStep[febhash] << ", istep = " << iStepTrigger[febhash] );
316 
317 
318  LArAccumulatedCalibDigit* accuCalibDigit;
319  if ( m_isSC ){
320  ATH_MSG_DEBUG("Channel "<<chid<<" DAC "<< digit->DAC()<< " will multiply by "<<numPulsedLeg<< " = "<<digit->DAC()*numPulsedLeg<<" is pulsed??? "<<isPulsed);
321  accuCalibDigit = new LArAccumulatedCalibDigit(chid,gain,sizeSamples,(int32_t)(digit->DAC()*numPulsedLeg),(uint16_t)m_delay,isPulsed,0,0);
322  }else{
323  accuCalibDigit = new LArAccumulatedCalibDigit(chid,gain,sizeSamples,(uint16_t)digit->DAC(),(uint16_t)m_delay,isPulsed,0,0);
324  }
325 
326 
327  accuCalibDigit->setAddSubStep(cellAccumulated.m_sum,cellAccumulated.m_sum2,ntrigUsed);
328  iStepTrigger[febhash]++;
329 
330  std::vector<float> mean = accuCalibDigit->mean();
331  std::vector<float> RMS = accuCalibDigit->RMS();
332 
333  for(unsigned int i=0;i<mean.size();i++){
334  ATH_MSG_DEBUG( "mean["<<i<<"] = " << mean[i] );
335  ATH_MSG_DEBUG( "RMS["<<i<<"] = " << RMS[i] );
336  }
337 
338  larAccuCalibDigitContainer->push_back(accuCalibDigit);
339 
340  cellAccumulated.m_nused = cellAccumulated.m_ntrigger;
341  cellAccumulated.m_ntrigger = 0;
342  }
343 
344  }// loop over cells in container
345 
346 
347  larAccuCalibDigitContainer->setDelayScale(m_delayScale);
348  sc = evtStore()->record(larAccuCalibDigitContainer,key);
349  if (sc!=StatusCode::SUCCESS)
350  {ATH_MSG_WARNING( "Unable to record LArAccumulatedCalibDigitContainer with key " << key << " from DetectorStore. " );
351  }
352  else
353  ATH_MSG_DEBUG( "Recorded succesfully LArAccumulatedCalibDigitContainer with key " << key << " with size " << larAccuCalibDigitContainer->size());
354 
355  sc = evtStore()->setConst(larAccuCalibDigitContainer);
356  if (sc.isFailure()) {
357  ATH_MSG_ERROR( " Cannot lock LArAccumulatedCalibDigitContainer " );
358  return(StatusCode::FAILURE);
359  }
360 
361 
362  } // loop over key container
363  return StatusCode::SUCCESS;
364 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

StatusCode LArCalibDigitsAccumulator::finalize ( )

assuming 100 per step

Definition at line 373 of file LArCalibDigitsAccumulator.cxx.

373  {
374 
375  if ( !m_isSC ) return StatusCode::SUCCESS;
376  int ntrigUsed = 100 - 100*(m_DropPercentTrig/100);
377  for(auto &acc : m_Accumulated_map){
378  std::string pattern=acc.first;
379  for(auto &sc : acc.second){
380  if(sc.m_onlineId && sc.m_nused != ntrigUsed){
381  ATH_MSG_WARNING("Not enough triggers for pattern " << pattern << " channel OnlineID " << sc.m_onlineId << " ntriggers " << sc.m_ntrigger );
382  }
383  }
384  }
385 
386  return StatusCode::SUCCESS;
387 
388 }

◆ getPatternName()

std::string LArCalibDigitsAccumulator::getPatternName ( const std::string &  gain,
bool  isPulsed,
int  delay,
int  dac 
)
staticprivate

Definition at line 366 of file LArCalibDigitsAccumulator.cxx.

366  {
367  std::ostringstream ss;
368  ss<<gain<<"_"<<isPulsed<<"_"<<delay<<"_"<<dac;
369  return ss.str();
370 }

◆ initialize()

StatusCode LArCalibDigitsAccumulator::initialize ( )

Definition at line 35 of file LArCalibDigitsAccumulator.cxx.

35  {
36 
37  m_eventNb=0;
38  // retrieve online ID helper
39  StatusCode sc;
42 
43  if(m_isSC){
44  const LArOnline_SuperCellID *scid;
45  sc = detStore()->retrieve(scid, "LArOnline_SuperCellID");
46  if (sc.isFailure()) {
47  ATH_MSG_ERROR( "Could not get LArOnline_SuperCellID helper !" );
48  return sc;
49  } else {
50  m_onlineHelper = static_cast<const LArOnlineID_Base*>(scid);
51  ATH_MSG_DEBUG("Found the LArOnlineID helper");
52  }
53  ATH_CHECK( m_sc2ccMappingTool.retrieve() );
56  } else {
57  const LArOnlineID* ll;
58  sc = detStore()->retrieve(ll, "LArOnlineID");
59  if (sc.isFailure()) {
60  ATH_MSG_ERROR( "Could not get LArOnlineID helper !" );
61  return sc;
62  } else {
63  m_onlineHelper = static_cast<const LArOnlineID_Base*>(ll);
64  ATH_MSG_DEBUG(" Found the LArOnlineID helper. ");
65  }
66  } //m_isSC
67 
68  return StatusCode::SUCCESS;
69 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::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< Algorithm > >::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.

◆ 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< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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  }

Member Data Documentation

◆ m_Accumulated_map

std::map<std::string, std::vector<LArAccumulated> > LArCalibDigitsAccumulator::m_Accumulated_map
private

Vector (index=hash ID) of accumulation quantities.

Definition at line 123 of file LArCalibDigitsAccumulator.h.

◆ m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCalibDigitsAccumulator::m_cablingKey {this, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"}
private

Definition at line 70 of file LArCalibDigitsAccumulator.h.

◆ m_cablingKeySC

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCalibDigitsAccumulator::m_cablingKeySC {this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"}
private

Definition at line 71 of file LArCalibDigitsAccumulator.h.

◆ m_calibAccuDigitContainerName

std::string LArCalibDigitsAccumulator::m_calibAccuDigitContainerName
private

◆ m_calibMapKey

SG::ReadCondHandleKey<LArCalibLineMapping> LArCalibDigitsAccumulator::m_calibMapKey {this,"CalibCablingKey","LArCalibLineMap","SG Key of LArCalibLineMapping object"}
private

Definition at line 64 of file LArCalibDigitsAccumulator.h.

◆ m_calibMapSCKey

SG::ReadCondHandleKey<LArCalibLineMapping> LArCalibDigitsAccumulator::m_calibMapSCKey {this,"CalibMapSCKey","LArCalibIdMapSC","SG Key of calib line mapping object"}
private

Definition at line 67 of file LArCalibDigitsAccumulator.h.

◆ m_delay

int LArCalibDigitsAccumulator::m_delay
private

Store delay.

Definition at line 78 of file LArCalibDigitsAccumulator.h.

◆ m_delayScale

double LArCalibDigitsAccumulator::m_delayScale
private

Set delay scale.

Definition at line 98 of file LArCalibDigitsAccumulator.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_DropPercentTrig

double LArCalibDigitsAccumulator::m_DropPercentTrig
private

Percentage of the used triggers that we will skip over at the end, in order ot ensure that the accumulation is done, even if there are lots of missing events from SC.

Definition at line 118 of file LArCalibDigitsAccumulator.h.

◆ m_event_counter

unsigned int LArCalibDigitsAccumulator::m_event_counter
private

Event counter.

Definition at line 128 of file LArCalibDigitsAccumulator.h.

◆ m_eventNb

unsigned int LArCalibDigitsAccumulator::m_eventNb = 0U
private

Definition at line 129 of file LArCalibDigitsAccumulator.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_isSC

bool LArCalibDigitsAccumulator::m_isSC
private

Tells you whether you run on SuperCells or Cells.

Definition at line 108 of file LArCalibDigitsAccumulator.h.

◆ m_keepFullyPulsedSC

bool LArCalibDigitsAccumulator::m_keepFullyPulsedSC
private

Tells you whether you keep only fully pulsed supercells or all supercells.

Definition at line 113 of file LArCalibDigitsAccumulator.h.

◆ m_keepPulsed

bool LArCalibDigitsAccumulator::m_keepPulsed
private

Tells you whether you keep only pulsed cells or all cells.

Definition at line 103 of file LArCalibDigitsAccumulator.h.

◆ m_keylist

std::vector<std::string> LArCalibDigitsAccumulator::m_keylist
private

list of key for input digit container (=gain)

Definition at line 88 of file LArCalibDigitsAccumulator.h.

◆ m_nStepTrigger

unsigned int LArCalibDigitsAccumulator::m_nStepTrigger
private

Number of intermediate accumulations (JO property)

Definition at line 93 of file LArCalibDigitsAccumulator.h.

◆ m_onlineHelper

const LArOnlineID_Base* LArCalibDigitsAccumulator::m_onlineHelper
private

Definition at line 73 of file LArCalibDigitsAccumulator.h.

◆ m_sampleShift

int LArCalibDigitsAccumulator::m_sampleShift
private

Samples to shift by, usually used in the case of SCs.

Definition at line 134 of file LArCalibDigitsAccumulator.h.

◆ m_sc2ccMappingTool

ToolHandle<ICaloSuperCellIDTool> LArCalibDigitsAccumulator::m_sc2ccMappingTool
private

Definition at line 62 of file LArCalibDigitsAccumulator.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
mergePhysValFiles.pattern
pattern
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:25
LArAccumulatedCalibDigit
Data class for calibration ADC samples preprocessed by the DSP.
Definition: LArAccumulatedCalibDigit.h:42
LArOnlineID_Base::channel_Hash
IdentifierHash channel_Hash(HWIdentifier channelId) const
Create channel_hash from channel_Id.
Definition: LArOnlineID_Base.cxx:1632
mean
void mean(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
Definition: dependence.cxx:254
LArAccumulatedCalibDigitContainer::setDelayScale
void setDelayScale(const double scale)
set the delay Scale
Definition: LArAccumulatedCalibDigitContainer.h:35
LArOnlineID_Base::febHashMax
size_type febHashMax(void) const
define feb hash tables max size
Definition: LArOnlineID_Base.cxx:1892
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
detail::ll
long long ll
Definition: PrimitiveHelpers.h:47
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
LArCalibDigitsAccumulator::m_nStepTrigger
unsigned int m_nStepTrigger
Number of intermediate accumulations (JO property)
Definition: LArCalibDigitsAccumulator.h:93
LArCalibParams::NTrigger
unsigned NTrigger(const HWIdentifier calibModuleID) const
Definition: LArCalibParams.cxx:195
LArCalibDigitsAccumulator::m_keylist
std::vector< std::string > m_keylist
list of key for input digit container (=gain)
Definition: LArCalibDigitsAccumulator.h:88
LArCalibDigitsAccumulator::m_DropPercentTrig
double m_DropPercentTrig
Percentage of the used triggers that we will skip over at the end, in order ot ensure that the accumu...
Definition: LArCalibDigitsAccumulator.h:118
LArCalibDigitsAccumulator::m_keepPulsed
bool m_keepPulsed
Tells you whether you keep only pulsed cells or all cells.
Definition: LArCalibDigitsAccumulator.h:103
LArCalibLineMapping::calibSlotLine
const std::vector< HWIdentifier > & calibSlotLine(const HWIdentifier id) const
Definition: LArCalibLineMapping.cxx:15
LArCalibDigitsAccumulator::m_sampleShift
int m_sampleShift
Samples to shift by, usually used in the case of SCs.
Definition: LArCalibDigitsAccumulator.h:134
LArCalibDigitsAccumulator::m_isSC
bool m_isSC
Tells you whether you run on SuperCells or Cells.
Definition: LArCalibDigitsAccumulator.h:108
LArCalibLineMapping
Definition: LArCalibLineMapping.h:17
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
LArCalibParams
Definition: LArCalibParams.h:28
LArCalibDigitsAccumulator::m_event_counter
unsigned int m_event_counter
Event counter.
Definition: LArCalibDigitsAccumulator.h:128
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
Identifier::get_identifier32
Identifier32 get_identifier32() const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
LArOnlineID_Base::calib_module_Id
HWIdentifier calib_module_Id(int barrel_ec, int pos_neg, int feedthrough, int slot) const
Build calibration module identifier from fields.
Definition: LArOnlineID_Base.h:573
LArCalibDigitsAccumulator::getPatternName
static std::string getPatternName(const std::string &gain, bool isPulsed, int delay, int dac)
Definition: LArCalibDigitsAccumulator.cxx:366
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
HWIdentifier
Definition: HWIdentifier.h:13
CaloGain::LARNGAIN
@ LARNGAIN
Definition: CaloGain.h:19
Identifier32::get_compact
value_type get_compact() const
Get the compact id.
Definition: Identifier32.h:44
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
LArCalibDigitsAccumulator::m_Accumulated_map
std::map< std::string, std::vector< LArAccumulated > > m_Accumulated_map
Vector (index=hash ID) of accumulation quantities.
Definition: LArCalibDigitsAccumulator.h:123
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
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
LArCalibDigitsAccumulator::m_eventNb
unsigned int m_eventNb
Definition: LArCalibDigitsAccumulator.h:129
LArCalibDigitContainer
Container class for LArCalibDigit.
Definition: LArCalibDigitContainer.h:19
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
LArCalibDigitsAccumulator::m_delayScale
double m_delayScale
Set delay scale.
Definition: LArCalibDigitsAccumulator.h:98
lumiFormat.i
int i
Definition: lumiFormat.py:85
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LArAccumulatedCalibDigit::RMS
std::vector< float > RMS() const
Calculates and returns the RMS value of each ADC sample.
Definition: LArAccumulatedCalibDigit.cxx:50
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
LArCalibParams::isPulsed
bool isPulsed(const unsigned event, const HWIdentifier calibLineID) const
Definition: LArCalibParams.cxx:151
LArCalibDigitsAccumulator::m_calibAccuDigitContainerName
std::string m_calibAccuDigitContainerName
LArAccumulatedCalibDigitContainer name.
Definition: LArCalibDigitsAccumulator.h:83
AthenaPoolTestRead.acc
acc
Definition: AthenaPoolTestRead.py:16
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
delay
double delay(std::size_t d)
Definition: JetTrigTimerTest.cxx:11
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
LArOnlineID_Base::feb_Id
HWIdentifier feb_Id(int barrel_ec, int pos_neg, int feedthrough, int slot) const
Create feb_Id from fields.
Definition: LArOnlineID_Base.cxx:1479
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
integrator_ascii2db.dac
dac
Definition: integrator_ascii2db.py:126
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
LArCalibDigitsAccumulator::m_calibMapKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapKey
Definition: LArCalibDigitsAccumulator.h:64
LArAccumulatedCalibDigit::mean
std::vector< float > mean() const
Calculates and returns the Mean value of each ADC sample.
Definition: LArAccumulatedCalibDigit.cxx:36
DiTauMassTools::HistInfo::RMS
@ RMS
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:35
LArOnlineID_Base
Helper for the Liquid Argon Calorimeter cell identifiers.
Definition: LArOnlineID_Base.h:105
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
LArCalibDigitsAccumulator::m_cablingKeySC
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKeySC
Definition: LArCalibDigitsAccumulator.h:71
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
LArCalibDigit
Base class for LArDigits taken during calibration runs.
Definition: LArCalibDigit.h:29
LArOnlineID_Base::channelHashMax
size_type channelHashMax(void) const
Define channel hash tables max size.
Definition: LArOnlineID_Base.cxx:1897
LArCalibDigitsAccumulator::m_keepFullyPulsedSC
bool m_keepFullyPulsedSC
Tells you whether you keep only fully pulsed supercells or all supercells.
Definition: LArCalibDigitsAccumulator.h:113
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArOnlineID
Definition: LArOnlineID.h:20
LArCalibDigitsAccumulator::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArCalibDigitsAccumulator.h:70
LArOnline_SuperCellID
Definition: LArOnline_SuperCellID.h:20
LArCalibDigitsAccumulator::m_delay
int m_delay
Store delay.
Definition: LArCalibDigitsAccumulator.h:78
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
LArAccumulatedCalibDigit::setAddSubStep
bool setAddSubStep(const std::vector< uint64_t > &sampleSum, const std::vector< uint64_t > &sample2Sum, const uint32_t nTriggerPerStep)
Sum up with another substep.
Definition: LArAccumulatedCalibDigit.cxx:112
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
LArCalibDigitsAccumulator::m_onlineHelper
const LArOnlineID_Base * m_onlineHelper
Definition: LArCalibDigitsAccumulator.h:73
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
LArCalibDigitsAccumulator::m_calibMapSCKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapSCKey
Definition: LArCalibDigitsAccumulator.h:67
LArAccumulatedCalibDigitContainer
Container class for LArAccumulatedCalibDigit.
Definition: LArAccumulatedCalibDigitContainer.h:25
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
LArOnlineID_Base::feb_Hash
IdentifierHash feb_Hash(HWIdentifier febId) const
Create feb hash identifiers from feb identifiers.
Definition: LArOnlineID_Base.cxx:1512
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
LArCalibDigitsAccumulator::m_sc2ccMappingTool
ToolHandle< ICaloSuperCellIDTool > m_sc2ccMappingTool
Definition: LArCalibDigitsAccumulator.h:62
fitman.k
k
Definition: fitman.py:528
python.SystemOfUnits.ns
float ns
Definition: SystemOfUnits.py:146
ServiceHandle< ICondSvc >
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Identifier
Definition: IdentifierFieldParser.cxx:14