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

◆ 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 367 of file LArCalibDigitsAccumulator.cxx.

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

◆ getPatternName()

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

Definition at line 360 of file LArCalibDigitsAccumulator.cxx.

360  {
361  std::ostringstream ss;
362  ss<<gain<<"_"<<isPulsed<<"_"<<delay<<"_"<<dac;
363  return ss.str();
364 }

◆ 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 = (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 {
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:26
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
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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:110
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:360
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
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:210
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
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:14
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:228
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:623
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
python.SystemOfUnits.ns
int ns
Definition: SystemOfUnits.py:130
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
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.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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
ServiceHandle< ICondSvc >
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Identifier
Definition: IdentifierFieldParser.cxx:14