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

#include <LArCaliWaveBuilderXtalk.h>

Inheritance diagram for LArCaliWaveBuilderXtalk:
Collaboration diagram for LArCaliWaveBuilderXtalk:

Public Member Functions

 LArCaliWaveBuilderXtalk (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~LArCaliWaveBuilderXtalk ()
 
StatusCode initialize ()
 
StatusCode execute ()
 
StatusCode stop ()
 
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 std::map< int, LArCaliWaveWaveMap
 
typedef LArConditionsContainer< WaveMapWaveContainer
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

StatusCode initializeCabling (const LArOnOffIdMapping *cabling, const LArCalibLineMapping *clCont)
 
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...
 

Private Attributes

SG::ReadCondHandleKey< LArOnOffIdMappingm_cablingKey {this, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"}
 
SG::ReadCondHandleKey< LArCalibLineMappingm_CLKey {this, "CalibLineKey", "LArCalibLineMap", "SG calib line key"}
 
std::vector< std::string > m_keylist
 
std::vector< std::string > m_keylistproperty
 
std::string m_keyoutput
 
std::string m_groupingType
 
WaveContainer m_waves
 
const LArOnlineIDm_onlineHelper
 
std::vector< HWIdentifierm_CalibLineHW
 
int m_feedthroughNumber
 
int m_posOrNeg
 
int m_barrelEndcap
 
std::string m_calibPattern
 
std::string m_partition
 
bool m_isSpecialCrate
 
std::string m_emecSpecialRegion
 
bool m_isInnerWheel
 
unsigned m_event_counter
 
int m_NStep
 
float m_SamplingPeriod
 
float m_dt
 
int m_ADCsatur
 
int m_cutOnSample
 
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

Definition at line 68 of file LArCaliWaveBuilderXtalk.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

◆ WaveContainer

Definition at line 136 of file LArCaliWaveBuilderXtalk.h.

◆ WaveMap

typedef std::map<int, LArCaliWave> LArCaliWaveBuilderXtalk::WaveMap
private

Definition at line 135 of file LArCaliWaveBuilderXtalk.h.

Constructor & Destructor Documentation

◆ LArCaliWaveBuilderXtalk()

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

Definition at line 25 of file LArCaliWaveBuilderXtalk.cxx.

26  : AthAlgorithm(name, pSvcLocator),
27  m_groupingType("ExtendedFeedThrough"), // SubDetector, Single, FeedThrough
28  m_onlineHelper(nullptr),
29  m_posOrNeg(0),
30  m_barrelEndcap(0),
31  m_isInnerWheel(0),
32  m_event_counter(0),
33  m_dt(0)
34 //=========================================================================================================
35 {
37  declareProperty("KeyOutput", m_keyoutput="LArCaliWave");
38  declareProperty("SamplingPeriod", m_SamplingPeriod=1./(40.08*megahertz));
39  declareProperty("NSteps", m_NStep=24); //Number of DelaySteps. FIXME: Try to get this information for somewhere else
40  declareProperty("ADCsaturation", m_ADCsatur=0);
41  declareProperty("GroupingType", m_groupingType);
42 
43  // Description of the required pulsed channel to have the caliwaves reconstructed
44  // PartitionPulsed = "BarrelA", "EndcapA", "BarrelC", "EndcapC"
45  declareProperty("PartitionPulsed", m_partition);
46 
47  // For EMEC special crates
48  declareProperty("SpecialCrate", m_isSpecialCrate=false);
49  declareProperty("SpecialRegion", m_emecSpecialRegion="OuterWheel"); // OuterWheel / InnerWheel
50 
51  // FeedthroughPul = [1-32] (Barrel) [1-24] (Endcap)
52  // used to detect the right calibration pattern
53  // please ensure that this FT has no bad channels / disconnected FEB
54  declareProperty("FeedthroughPul", m_feedthroughNumber=1);
55 
56  // CalibPattern = "StripSinglexx", "MiddleSinglexx", "BackSinglexx",
57  // EMB : xx = [1-4] (Strip) xx = [1-8] (Middle) xx = [1-4] (Back)
58  // EMEC : xx = [1-4] (Strip) xx = [1-4] (Middle) xx = [1-4] (Back)
59  // and xx = [1-4] (Middle) xx = [1-4] (Back) for inner wheel
60  declareProperty("CalibPattern", m_calibPattern="StripSingle1");
61 
62  // Allow to cut waves
63  // consider only the N=CutOnSample first samples to reduce needed memory (0 = no cut)
64  declareProperty("CutOnSample", m_cutOnSample=0);
65 }

◆ ~LArCaliWaveBuilderXtalk()

LArCaliWaveBuilderXtalk::~LArCaliWaveBuilderXtalk ( )
default

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 LArCaliWaveBuilderXtalk::execute ( )

Definition at line 357 of file LArCaliWaveBuilderXtalk.cxx.

359 {
361  const LArOnOffIdMapping* cabling{*cablingHdl};
362  if(!cabling) {
363  ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
364  return StatusCode::FAILURE;
365  }
366 
368  const LArCalibLineMapping *clCont {*clHdl};
369  if(!clCont) {
370  ATH_MSG_ERROR("Do not have calibration mapping object " << m_CLKey.key());
371  return StatusCode::FAILURE;
372  }
373 
374  if (m_event_counter==0) {
375  ATH_CHECK ( initializeCabling(cabling, clCont) );
376  }
377 
378  // Print progression
379  if ( m_event_counter < 100 || ( m_event_counter < 1000 && m_event_counter%100==0 ) || m_event_counter%1000==0 )
380  ATH_MSG_INFO ( "Processing event " << m_event_counter );
381  m_event_counter++ ;
382 
383  if (m_keylist.empty()) {
384  ATH_MSG_ERROR ( "Key list is empty! No containers to process!" );
385  return StatusCode::FAILURE;
386  }
387 
388  const LArAccumulatedCalibDigitContainer* larAccumulatedCalibDigitContainer = nullptr;
389 
390  std::vector<std::string>::const_iterator key_it=m_keylist.begin();
391  std::vector<std::string>::const_iterator key_it_e=m_keylist.end();
392 
393  for (;key_it!=key_it_e; ++key_it) { //Loop over all containers that are to be processed (e.g. different gains)
394 
395  StatusCode sc = evtStore()->retrieve(larAccumulatedCalibDigitContainer,*key_it);
396  if (sc.isFailure()) {
397  ATH_MSG_WARNING ( "Cannot read LArAccumulatedCalibDigitContainer from StoreGate! key=" << *key_it );
398  continue; // Try next container
399  }
400 
401  LArAccumulatedCalibDigitContainer::const_iterator it=larAccumulatedCalibDigitContainer->begin();
402  LArAccumulatedCalibDigitContainer::const_iterator it_end=larAccumulatedCalibDigitContainer->end();
403 
404  if (it == it_end) {
405  ATH_MSG_DEBUG ( "LArAccumulatedCalibDigitContainer with key=" << *key_it << " is empty " );
406  continue; // at this event LArAccumulatedCalibDigitContainer is empty, do not even try to loop on it...
407  }
408 
409  const float delayScale = larAccumulatedCalibDigitContainer->getDelayScale();
410  const float deltaDelay = 25*ns/(delayScale*m_NStep);
411 
412  // Check whether this "event" (LArAccumulatedDigit) is relevant for our studies
413  bool relevantForXtalk = false;
414 
415  // for print purpose
416  std::vector<int> nbOfEventSlot; // Number of 'events' per slot
417  nbOfEventSlot.resize(15);
418 
419  std::vector<int> nbOfEventPart; // Number of 'events' per Subdetector/layer
420  nbOfEventPart.resize(8);
421  int sideA=0; // Number of 'events' in A side
422  int sideC=0; // Number of 'events' in C side
423 
424 
425  // Loop over all cells as long as no interesting pulsed cell is found
426  do{
427 
428  const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine((*it)->hardwareID());
429  if (!calibLine.empty()) {
431 
432  if (((*it)->isPulsed()) && (found != m_CalibLineHW.end()))
433  relevantForXtalk = true;
434 
435 // if (m_onlineHelper->slot((*it)->hardwareID()) == 2 && m_onlineHelper->channel((*it)->hardwareID())<10)
436 // log << MSG::DEBUG << "Relevant ? HW id ->" << m_onlineHelper->show_to_string((*it)->hardwareID()) << "Calib -> " << m_onlineHelper->show_to_string(calibLine[0]) << "Pulsed ?" << (*it)->isPulsed() << endmsg;
437 
438  }
439 
440  if ((*it)->isPulsed()){
441  int iSlot = m_onlineHelper->slot((*it)->hardwareID());
442  int ibarrel_ec = m_onlineHelper->barrel_ec((*it)->hardwareID());
443  int ipos_neg = m_onlineHelper->pos_neg((*it)->hardwareID());
444 
445  nbOfEventSlot[iSlot-1]++;
446 
447  if (ipos_neg==1) sideA++;
448  else sideC++;
449 
450  if (!m_onlineHelper->isEmEndcapSpecialOnline((*it)->hardwareID())){ // do not count EMEC Special entries
451  if (iSlot==1) nbOfEventPart[4*ibarrel_ec]++; // PS
452  else if (iSlot < 9 - ibarrel_ec) nbOfEventPart[4*ibarrel_ec + 1]++; // Front
453  else if (iSlot > 10 - ibarrel_ec) nbOfEventPart[4*ibarrel_ec + 2]++; // Middle
454  else nbOfEventPart[4*ibarrel_ec + 3]++; // Back
455  }
456  }
457 
458  ++it;
459  }
460  while ((!relevantForXtalk) && (it != it_end));// End of loop on cell to determine whether this event is relevant for xtalk study
461 
462  // Debug : print number of events per slot
463  /*
464  log << MSG::DEBUG << "[Slot-Nevents]: ";
465  for (int jj=0; jj<15; jj++){
466  log << MSG::DEBUG << "[" << jj << "-" << nbOfEventSlot[jj] << "] ";
467  }
468  log << MSG::DEBUG << " - Shall I keep this? " << relevantForXtalk << endmsg;
469  */
470 
471  // Debug : print number of events per detector region
472  msg() << MSG::DEBUG << "Event nb " << m_event_counter - 1<< " - " ;
473  msg() << MSG::DEBUG << "Entries : EMB PS/F/M/B=" << nbOfEventPart[0] << "/" << nbOfEventPart[1] << "/" << nbOfEventPart[2] << "/" << nbOfEventPart[3];
474  msg() << MSG::DEBUG << " - EMEC Std PS/F/M/B=" << nbOfEventPart[4] << "/" << nbOfEventPart[5] << "/" << nbOfEventPart[6] << "/" << nbOfEventPart[7];
475  msg() << MSG::DEBUG << " - A/(A+C)=" << (sideA+sideC==0 ? -1 : float(sideA)/float(sideA+sideC));
476  if (!relevantForXtalk)
477  msg() << MSG::DEBUG << " - don't keep (partition/pattern)" << endmsg;
478  else
479  msg() << MSG::DEBUG << " - KEEP THIS EVENT" << endmsg;
480 
481 
482  // Process relevant events
483  if (relevantForXtalk){
484  bool hasbeenprinted = false;
485  for (it=larAccumulatedCalibDigitContainer->begin();it!=it_end; ++it) { // Loop over all cells
486 
487  HWIdentifier chid=(*it)->hardwareID();
488 
489  // FT selection for EMEC
490  if (m_barrelEndcap==1) {
491  int iFT = m_onlineHelper->feedthrough(chid);
492  if (m_isSpecialCrate)
493  if (m_isInnerWheel) {if (iFT!=3 && iFT!=10 && iFT!=16 && iFT!=22) continue;}
494  else {if (iFT!=2 && iFT!=9 && iFT!=15 && iFT!=21) continue;}
495  else if (iFT==2 || iFT==9 || iFT==15 || iFT==21 || iFT==3 || iFT==10 || iFT==16 || iFT==22 || iFT==6)
496  continue;
497  }
498 
499  // Process only channels that are in the studied partition
500  if ( (m_barrelEndcap == m_onlineHelper->barrel_ec(chid)) && (m_posOrNeg == m_onlineHelper->pos_neg(chid)) ){
501 
502  if (!hasbeenprinted){
503  ATH_MSG_DEBUG ( "This event is relevant for the studied partition" );
504  hasbeenprinted = true;
505  }
506 
507  CaloGain::CaloGain gain=(*it)->gain();
508 
509  if (gain<0 || gain>CaloGain::LARNGAIN) {
510  ATH_MSG_ERROR ( "Found not-matching gain number ("<< (int)gain <<")" );
511  return StatusCode::FAILURE;
512  }
513 
514  // transform sampleSum vector from uint32_t to double
515  // Allow to cut waves : consider only first samples to reduce needed memory (0 = no cut)
516  std::vector<double> samplesum;
517  std::vector < uint64_t >::const_iterator samplesum_it=(*it)->sampleSum().begin();
518  std::vector < uint64_t >::const_iterator samplesum_it_e=(*it)->sampleSum().end();
519  int nSample=m_cutOnSample;
520  do {
521  samplesum.push_back((double)(*samplesum_it));
522  ++samplesum_it;
523  --nSample;
524  }
525  while ( (samplesum_it!=samplesum_it_e) && (nSample!=0) );
526 
527  // transform sample2Sum vector from uint32_t to double
528  // Allow to cut waves : consider only first samples to reduce needed memory (0 = no cut)
529  std::vector<double> sample2sum;
530  std::vector < uint64_t >::const_iterator sample2sum_it=(*it)->sample2Sum().begin();
531  std::vector < uint64_t >::const_iterator sample2sum_it_e=(*it)->sample2Sum().end();
532  nSample=m_cutOnSample;
533  do {
534  sample2sum.push_back((double)(*sample2sum_it));
535  ++sample2sum_it;
536  --nSample;
537  }
538  while ( (sample2sum_it!=sample2sum_it_e) && (nSample!=0) );
539 
540  WaveMap& waveMap = m_waves.get(chid,gain);
541  WaveMap::iterator itm = waveMap.find((*it)->DAC());
542 
543  if ( itm == waveMap.end() ) { // A new LArCaliWave is booked
544  LArCaliWave wave(samplesum.size()*m_NStep, m_dt, (*it)->DAC(), 0x1, LArWave::meas ) ;
545 
546  // Be careful! Don't call addAccumulatedEvent() twice!!!
547  // cf. LArCaliwaveBuilder ref. 1.38
548  //wave.addAccumulatedEvent((int)roundf((*it)->delay()/deltaDelay), m_NStep,
549  // samplesum, sample2sum, (*it)->nTriggers());
550 
551  itm = (waveMap.insert(WaveMap::value_type((*it)->DAC(), wave))).first;
552  }//else { // A LArCaliWave for this channel/DAC is already existing
553 
554  (*itm).second.addAccumulatedEvent((int)roundf((*it)->delay()/deltaDelay), m_NStep,
555  samplesum, sample2sum, (*it)->nTriggers());
556  } // End of test on studied partition
557  } //End loop over all cells
558  } // End of relevantForXtalk test
559  } //End loop over all containers
560 
561  return StatusCode::SUCCESS;
562 }

◆ 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 LArCaliWaveBuilderXtalk::finalize ( )
inline

Definition at line 120 of file LArCaliWaveBuilderXtalk.h.

◆ initialize()

StatusCode LArCaliWaveBuilderXtalk::initialize ( )

Definition at line 73 of file LArCaliWaveBuilderXtalk.cxx.

75 {
76 
77  MsgStream log(msgSvc(), name());
78  log << MSG::INFO << "Initialize LArCaliWaveBuilderXtalk" << endmsg;
79 
80  // Set barrel_ec and pos_neg from PartitionPulsed
81  m_barrelEndcap = 0; m_posOrNeg = 0;
82  if (m_partition == "BarrelC") {m_barrelEndcap = 0; m_posOrNeg = 0;}
83  else if (m_partition == "BarrelA") {m_barrelEndcap = 0; m_posOrNeg = 1;}
84  else if (m_partition == "EndcapC") {m_barrelEndcap = 1; m_posOrNeg = 0;}
85  else if (m_partition == "EndcapA") {m_barrelEndcap = 1; m_posOrNeg = 1;}
86  else {
87  ATH_MSG_ERROR ( "Can't find partition " << m_partition << " ! Use BarrelC instead." );
88  }
89  ATH_MSG_INFO ( "Partition : " << m_partition << " (barrel_ec=" << m_barrelEndcap << " ; pos_neg=" << m_posOrNeg << ")" );
90 
91  // Test m_isSpecialCrate, set m_isInnerWheel, and check FT number for EMEC
92  if (m_barrelEndcap==1) {
93 
94  // EMEC special crates
95  if (m_isSpecialCrate){
96 
97  TString emecSpecialRegion_test = TString(m_emecSpecialRegion.c_str());
98  emecSpecialRegion_test.ToLower();
99  if (emecSpecialRegion_test.Contains("inner"))
100  m_isInnerWheel = true;
101  else {
102  m_isInnerWheel = false;
103  if (! emecSpecialRegion_test.Contains("outer"))
104  ATH_MSG_WARNING ( "Can't read EMEC special region (Inner/Outer Wheel) - set SpecialRegion to OuterWheel." );
105  }
106 
107  if (!m_isInnerWheel){ // EMEC outer wheel special crates
109  ATH_MSG_WARNING ( "FeedthroughPul=" << m_feedthroughNumber << ". For EMEC outer wheel special crates studies one should use FT = 2, 9, 15 or 21." );
110  ATH_MSG_WARNING ( "Set FeedthroughPul to 2.");
112  }
113  ATH_MSG_INFO ( "Look at EM end-cap outer wheel special crates. Check calibration patterns with FT number " << m_feedthroughNumber );
114  }
115  else { // EMEC inner wheel (special crates)
117  ATH_MSG_WARNING ( "FeedthroughPul=" << m_feedthroughNumber << ". For EMEC inner wheel studies one should use FT = 3, 10, 16 or 22." );
118  ATH_MSG_WARNING ( "Set FeedthroughPul to 3.");
120  }
121  ATH_MSG_INFO ( "Look at EM end-cap inner wheel (special crates). Check calibration patterns with FT number " << m_feedthroughNumber );
122  }
123 
124  }
125 
126  // EMEC standard crates
127  else {
128  if (m_feedthroughNumber==6
131  || m_feedthroughNumber>24) {
132  ATH_MSG_WARNING ( "FeedthroughPul=" << m_feedthroughNumber << " : not in EMEC standard crates." );
133  ATH_MSG_WARNING ( "Set FeedthroughPul to 1.");
135  }
136  ATH_MSG_INFO ( "Look at EM end-cap standard crates. Check calibration patterns with FT number " << m_feedthroughNumber );
137  }
138  } else {
139  // EM Barrel
140  ATH_MSG_INFO ( "Look at EM barrel. Check calibration patterns with FT number " << m_feedthroughNumber );
141  }
142 
143 
144  if (m_keylistproperty.empty()) // Not key list given
145  {
146  m_keylistproperty.emplace_back("HIGH");
147  m_keylistproperty.emplace_back("MEDIUM");
148  m_keylistproperty.emplace_back("LOW");
149  }
151 
152  //FIXME probably useless because m_wave isn't written anywhere
153  ATH_CHECK( m_waves.setGroupingType(m_groupingType,msg()) );
155 
156  m_event_counter=0;
157 
158  //m_dt=25*ns/m_NStep;
160 
161  ATH_CHECK( detStore()->retrieve(m_onlineHelper, "LArOnlineID") );
164 
165  return StatusCode::SUCCESS;
166 }

◆ initializeCabling()

StatusCode LArCaliWaveBuilderXtalk::initializeCabling ( const LArOnOffIdMapping cabling,
const LArCalibLineMapping clCont 
)
private

Definition at line 169 of file LArCaliWaveBuilderXtalk.cxx.

171 {
172  // bug in LArTools, on-off map doesn't work at initialization stage
173 
174  ATH_MSG_INFO ( "Consider only partition " << m_partition );
175 
176  // Temporary solution to create onoff map as long as it is not done in calibSlotLine()
177  // WAITING FOR A FIX in LArTools
179  ATH_MSG_INFO ( "Dummy ids - TEMPORARY " << m_onlineHelper->show_to_string(cellId) );
180 
181 
182  // Fill the m_CalibLineHW vector,containing all the calib line HW id
183  // that are required to be pulsed
184  // The m_calibPattern string is given in the job option
185 
186 
187  //--------------------------------------------------
188  // EM BARREL
189 
190  if (m_partition == "BarrelA" || m_partition == "BarrelC") {
191 
192  // StripSingle pattern
193  if( m_calibPattern.find("StripSingle",0) != std::string::npos ){
194  HWIdentifier theConsidChannel;
195  int pulsedSlot = 2;
196  if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,1);
197  if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,2);
198  if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,3);
199  if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,4);
200 
201  const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
202 
203  ATH_MSG_INFO ( "Considered Online Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
204  ATH_MSG_DEBUG ( "Number of associated calib line " << calibLine.size() );
205  if (!calibLine.empty()) {
206  m_CalibLineHW.push_back(calibLine[0]);
207  ATH_MSG_INFO ( "Calib line" << m_onlineHelper->show_to_string(calibLine[0]) );
208  }
209  }
210 
211  // MiddleSingle pattern
212  if( m_calibPattern.find("MiddleSingle",0) != std::string::npos ){
213  HWIdentifier theConsidChannel;
214  int pulsedSlot = 11;
215  if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,3);
216  if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,2);
217  if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,7);
218  if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,6);
219  if (m_calibPattern.find('5',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,67);
220  if (m_calibPattern.find('6',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,66);
221  if (m_calibPattern.find('7',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,71);
222  if (m_calibPattern.find('8',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,70);
223 
224  const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
225  ATH_MSG_INFO ( "Considered Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
226  if (!calibLine.empty()) {
227  m_CalibLineHW.push_back(calibLine[0]);
228  ATH_MSG_INFO ( "Calib Line " << m_onlineHelper->show_to_string(calibLine[0]) );
229  }
230  }
231 
232  // BackSingle pattern
233  if ( m_calibPattern.find("BackSingle",0) != std::string::npos){
234  HWIdentifier theConsidChannel;
235  int pulsedSlot = 9;
236  if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,3);
237  if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,2);
238  if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,7);
239  if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,6);
240 
241  const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
242  ATH_MSG_INFO ( "Considered Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
243  if (!calibLine.empty()) {
244  m_CalibLineHW.push_back(calibLine[0]);
245  ATH_MSG_INFO ( "Calib Line " << m_onlineHelper->show_to_string(calibLine[0]) );
246  }
247  }
248 
249  } // End of barrel treatment
250 
251 
252  //--------------------------------------------------
253  // EM ENDCAP
254 
255 
256  else{
257 
258  // StripSingle pattern
259  if (m_isInnerWheel && m_isSpecialCrate && m_calibPattern.find("StripSingle",0) != std::string::npos )
260  ATH_MSG_WARNING ( "There is no StripSingle pattern for EMEC inner wheel. You should try another pattern (MiddleSingle[1-4] or BackSingle[1-4])." );
261  else if( m_calibPattern.find("StripSingle",0) != std::string::npos ){
262  HWIdentifier theConsidChannel;
263 
264  int pulsedSlot = 2; // EMEC outer wheel standard crates
265  if (m_isSpecialCrate) pulsedSlot = 5; // EMEC outer wheel special crates
266 
267  if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,1);
268  if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,2);
269  if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,3);
270  if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,4);
271 
272  const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
273 
274  ATH_MSG_INFO ( "Considered Online Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
275  ATH_MSG_DEBUG ( "Number of associated calib line " << calibLine.size() );
276  if (!calibLine.empty()) {
277  m_CalibLineHW.push_back(calibLine[0]);
278  ATH_MSG_INFO ( "Calib line" << m_onlineHelper->show_to_string(calibLine[0]) );
279  }
280  }
281 
282  // MiddleSingle pattern
283  if( m_calibPattern.find("MiddleSingle",0) != std::string::npos ){
284  HWIdentifier theConsidChannel;
285 
286  int pulsedSlot = 10; // EMEC outer wheel (standard and special crates)
287  int pulsedCell1 = 1;
288  int pulsedCell2 = 2;
289  int pulsedCell3 = 7;
290  int pulsedCell4 = 6;
291  if (m_isInnerWheel && m_isSpecialCrate){ // EMEC inner wheel
292  pulsedSlot = 1;
293  pulsedCell1 = 1;
294  pulsedCell2 = 0;
295  pulsedCell3 = 2;
296  pulsedCell4 = 3;
297  }
298 
299  if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell1);
300  if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell2);
301  if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell3);
302  if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell4);
303 
304  const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
305 
306  ATH_MSG_INFO ( "Considered Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
307  ATH_MSG_DEBUG ( "Number of associated calib line " << calibLine.size() );
308  if (!calibLine.empty()) {
309  m_CalibLineHW.push_back(calibLine[0]);
310  ATH_MSG_INFO ( "Calib Line " << m_onlineHelper->show_to_string(calibLine[0]) );
311  }
312  }// End of MiddleSingle pattern
313 
314  // BackSingle pattern
315  if ( m_calibPattern.find("BackSingle",0) != std::string::npos){
316  HWIdentifier theConsidChannel;
317 
318  int pulsedSlot = 8; // EMEC standard crates
319  int pulsedCell1 = 1;
320  int pulsedCell2 = 2;
321  int pulsedCell3 = 33;
322  int pulsedCell4 = 34;
323  if (m_isInnerWheel && m_isSpecialCrate){ // EMEC inner wheel
324  pulsedSlot = 2;
325  pulsedCell1 = 1;
326  pulsedCell2 = 0;
327  pulsedCell3 = 2;
328  pulsedCell4 = 3;
329  }
330  else if (m_isSpecialCrate) { // EMEC outer wheel special crates
331  pulsedSlot = 9;
332  pulsedCell1 = 2;
333  pulsedCell2 = 1;
334  pulsedCell3 = 17;
335  pulsedCell4 = 18;
336  }
337 
338  if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell1);
339  if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell2);
340  if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell3);
341  if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell4);
342 
343  const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
344  ATH_MSG_INFO ( "Considered Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
345  if (!calibLine.empty()) {
346  m_CalibLineHW.push_back(calibLine[0]);
347  ATH_MSG_INFO ( "Calib Line " << m_onlineHelper->show_to_string(calibLine[0]) );
348  }
349  }// End of BackSingle pattern
350 
351  };// End of endcap treatment
352 
353  return StatusCode::SUCCESS;
354 }

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

◆ stop()

StatusCode LArCaliWaveBuilderXtalk::stop ( )

get iterator for all channels for a gain

Definition at line 565 of file LArCaliWaveBuilderXtalk.cxx.

567 {
568  // Create wave container using feedthru grouping and initialize
569  auto caliWaveContainer = std::make_unique<LArCaliWaveContainer>();
570 
571  ATH_CHECK( caliWaveContainer->setGroupingType(m_groupingType,msg()) );
572  ATH_MSG_DEBUG ( "Set groupingType for LArCaliWaveContainer object" );
573 
574  ATH_CHECK( caliWaveContainer->initialize() );
575  ATH_MSG_DEBUG ( "Initialized LArCaliWaveContainer object" );
576 
577  // Note : sometimes a Segmentation fault happen at this stage
578  // not yet solved
579  //
580  // Extract of the thread :
581  // > Caught signal 11(Segmentation fault). Details:
582  // > errno = 0, code = 1 (address not mapped to object)
583  // > #10 <signal handler called>
584  // > #11 cpp_alloc (size=52, nothrow=false) at src/tcmalloc.cc:354
585  // > #12 0xf7fd7a69 in operator new (size=52) at src/tcmalloc.cc:3104
586  // > #13 0xf775a306 in std::vector<unsigned int, std::allocator<unsigned int> >::operator= ()
587  // > #14 0xee8b63d7 in LArCondFEBIdChanMap::addFEBIdVector ()
588  // > #15 0xee8b03c4 in LArConditionsContainerBase::initGrouping ()
589  // > #16 0xee8b2c82 in LArConditionsContainerBase::initializeBase ()
590  // > #17 0xeed5f872 in LArConditionsContainer<LArCaliWaveVec>::initialize ()
591 
593  const LArOnOffIdMapping* cabling{*cablingHdl};
594  if(!cabling) {
595  ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
596  return StatusCode::FAILURE;
597  }
598 
599 
600  LArWaveHelper wHelper;
601  int NCaliWave=0;
602 
603  // Loop over all gains
604  for (unsigned k=0;k<(int)CaloGain::LARNGAIN;k++) {
605 
607 
611 
612  HWIdentifier lastId;
613 
614  for (; cell_it!=cell_it_e; ++cell_it) {
615 
616  // Get id of this cell - use id from first cell in map
617  //
618  // Some accumulations may be empty and we must skip this
619  // cell. WaveContainer has all 128 channels for each FEB
620  // with at least ONE being read out.
621  //
622 
623  const HWIdentifier hwId = cell_it.channelId();
624  if (!cabling->isOnlineConnected(hwId)) continue; //Ignore disconnected channels
625 
626  const WaveMap& waveMap = (*cell_it);
627  if (waveMap.empty()) {
628  ATH_MSG_INFO ( "Empty accumulated wave. Last id: " << MSG::hex
629  << lastId << MSG::dec );
630  continue;
631  }
632 
633  lastId = hwId; // save previous id for debug printout
634 
635  // FT selection for EMEC
636  if (m_barrelEndcap==1) {
637  int iFT = m_onlineHelper->feedthrough(hwId);
638  if (m_isSpecialCrate)
639  if (m_isInnerWheel) {if (iFT!=3 && iFT!=10 && iFT!=16 && iFT!=22) continue;}
640  else {if (iFT!=2 && iFT!=9 && iFT!=15 && iFT!=21) continue;}
641  else if (iFT==2 || iFT==9 || iFT==15 || iFT==21 || iFT==3 || iFT==10 || iFT==16 || iFT==22 || iFT==6)
642  continue;
643  }
644 
645  // Get the vector of waves for this chid,gain
646  LArCaliWaveContainer::LArCaliWaves& dacWaves = caliWaveContainer->get(hwId, gain);
647 
648  std::map<int, LArCaliWave>::const_iterator dac_it = cell_it->begin();
649  std::map<int, LArCaliWave>::const_iterator dac_it_e = cell_it->end();
650 
651  for (; dac_it != dac_it_e; ++dac_it) {
652 
653  const LArCaliWave& thisWave = dac_it->second ;
654  float pedAve = 0.;
655 
656  double waveMax = thisWave.getSample( wHelper.getMax(thisWave) ) ;
657  if ( m_ADCsatur>0 && waveMax>m_ADCsatur ) {
658  ATH_MSG_INFO ( "Absolute ADC saturation at DAC = " << thisWave.getDAC() << " ... skip!" );
659  continue ;
660  } else {
661 
662  LArCaliWave newWave( ((thisWave)+(-pedAve)).getWave() ,
663  thisWave.getErrors(),
664  thisWave.getTriggers(),
665  thisWave.getDt(),
666  thisWave.getDAC(),
667  thisWave.getIsPulsedInt(),
668  thisWave.getFlag() );
669 
670  dacWaves.push_back(newWave);
671  NCaliWave++;
672  }
673  } // end of loop DACs
674 
675  // intermediate map cleanup (save memory)
676  cell_it->clear();
677 
678  } //end loop cells
679 
680  } //end loop over m_keyList
681 
682  ATH_MSG_INFO ( "Summary : Number of cells with a CaliWave reconstructed : " << NCaliWave );
683  ATH_MSG_INFO ( "Size of LAr calibration waves container : " << caliWaveContainer->size() );
684 
685  // Record in detector store with key (m_keyoutput)
686  ATH_CHECK( detStore()->record(std::move(caliWaveContainer), m_keyoutput) );
687 
688  ATH_MSG_INFO ( "LArCaliWaveBuilderXtalk has finished." );
689  return StatusCode::SUCCESS;
690 }

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

int LArCaliWaveBuilderXtalk::m_ADCsatur
private

Definition at line 158 of file LArCaliWaveBuilderXtalk.h.

◆ m_barrelEndcap

int LArCaliWaveBuilderXtalk::m_barrelEndcap
private

Definition at line 145 of file LArCaliWaveBuilderXtalk.h.

◆ m_cablingKey

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

Definition at line 124 of file LArCaliWaveBuilderXtalk.h.

◆ m_CalibLineHW

std::vector<HWIdentifier> LArCaliWaveBuilderXtalk::m_CalibLineHW
private

Definition at line 141 of file LArCaliWaveBuilderXtalk.h.

◆ m_calibPattern

std::string LArCaliWaveBuilderXtalk::m_calibPattern
private

Definition at line 147 of file LArCaliWaveBuilderXtalk.h.

◆ m_CLKey

SG::ReadCondHandleKey<LArCalibLineMapping> LArCaliWaveBuilderXtalk::m_CLKey {this, "CalibLineKey", "LArCalibLineMap", "SG calib line key"}
private

Definition at line 125 of file LArCaliWaveBuilderXtalk.h.

◆ m_cutOnSample

int LArCaliWaveBuilderXtalk::m_cutOnSample
private

Definition at line 160 of file LArCaliWaveBuilderXtalk.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_dt

float LArCaliWaveBuilderXtalk::m_dt
private

Definition at line 157 of file LArCaliWaveBuilderXtalk.h.

◆ m_emecSpecialRegion

std::string LArCaliWaveBuilderXtalk::m_emecSpecialRegion
private

Definition at line 151 of file LArCaliWaveBuilderXtalk.h.

◆ m_event_counter

unsigned LArCaliWaveBuilderXtalk::m_event_counter
private

Definition at line 154 of file LArCaliWaveBuilderXtalk.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_feedthroughNumber

int LArCaliWaveBuilderXtalk::m_feedthroughNumber
private

Definition at line 143 of file LArCaliWaveBuilderXtalk.h.

◆ m_groupingType

std::string LArCaliWaveBuilderXtalk::m_groupingType
private

Definition at line 132 of file LArCaliWaveBuilderXtalk.h.

◆ m_isInnerWheel

bool LArCaliWaveBuilderXtalk::m_isInnerWheel
private

Definition at line 152 of file LArCaliWaveBuilderXtalk.h.

◆ m_isSpecialCrate

bool LArCaliWaveBuilderXtalk::m_isSpecialCrate
private

Definition at line 150 of file LArCaliWaveBuilderXtalk.h.

◆ m_keylist

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

Definition at line 129 of file LArCaliWaveBuilderXtalk.h.

◆ m_keylistproperty

std::vector<std::string> LArCaliWaveBuilderXtalk::m_keylistproperty
private

Definition at line 130 of file LArCaliWaveBuilderXtalk.h.

◆ m_keyoutput

std::string LArCaliWaveBuilderXtalk::m_keyoutput
private

Definition at line 131 of file LArCaliWaveBuilderXtalk.h.

◆ m_NStep

int LArCaliWaveBuilderXtalk::m_NStep
private

Definition at line 155 of file LArCaliWaveBuilderXtalk.h.

◆ m_onlineHelper

const LArOnlineID* LArCaliWaveBuilderXtalk::m_onlineHelper
private

Definition at line 139 of file LArCaliWaveBuilderXtalk.h.

◆ m_partition

std::string LArCaliWaveBuilderXtalk::m_partition
private

Definition at line 148 of file LArCaliWaveBuilderXtalk.h.

◆ m_posOrNeg

int LArCaliWaveBuilderXtalk::m_posOrNeg
private

Definition at line 144 of file LArCaliWaveBuilderXtalk.h.

◆ m_SamplingPeriod

float LArCaliWaveBuilderXtalk::m_SamplingPeriod
private

Definition at line 156 of file LArCaliWaveBuilderXtalk.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.

◆ m_waves

WaveContainer LArCaliWaveBuilderXtalk::m_waves
private

Definition at line 137 of file LArCaliWaveBuilderXtalk.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
LArCaliWaveBuilderXtalk::m_barrelEndcap
int m_barrelEndcap
Definition: LArCaliWaveBuilderXtalk.h:145
LArCaliWaveBuilderXtalk::m_emecSpecialRegion
std::string m_emecSpecialRegion
Definition: LArCaliWaveBuilderXtalk.h:151
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
LArWave::getFlag
unsigned getFlag() const
flag: ...
Definition: LArWave.h:178
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LArCaliWaveBuilderXtalk::m_feedthroughNumber
int m_feedthroughNumber
Definition: LArCaliWaveBuilderXtalk.h:143
LArCalibLineMapping::calibSlotLine
const std::vector< HWIdentifier > & calibSlotLine(const HWIdentifier id) const
Definition: LArCalibLineMapping.cxx:15
LArCaliWaveBuilderXtalk::m_isSpecialCrate
bool m_isSpecialCrate
Definition: LArCaliWaveBuilderXtalk.h:150
LArCalibLineMapping
Definition: LArCalibLineMapping.h:17
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
skel.it
it
Definition: skel.GENtoEVGEN.py:396
LArCaliWaveBuilderXtalk::m_dt
float m_dt
Definition: LArCaliWaveBuilderXtalk.h:157
LArWave::getDt
const double & getDt() const
delta time
Definition: LArWave.h:50
LArOnlineID_Base::slot
int slot(const HWIdentifier id) const
Return the slot number of a hardware cell identifier: slot = [1,15] Slot-ID in top part of the crat...
Definition: LArOnlineID_Base.cxx:1957
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
LArWaveHelper
Definition: LArWaveHelper.h:14
LArCaliWaveBuilderXtalk::m_posOrNeg
int m_posOrNeg
Definition: LArCaliWaveBuilderXtalk.h:144
LArCaliWave::getDAC
int getDAC() const
DAC value.
Definition: LArCaliWave.h:156
LArCaliWaveBuilderXtalk::m_keylistproperty
std::vector< std::string > m_keylistproperty
Definition: LArCaliWaveBuilderXtalk.h:130
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
LArCaliWaveBuilderXtalk::m_isInnerWheel
bool m_isInnerWheel
Definition: LArCaliWaveBuilderXtalk.h:152
LArWaveHelper::getMax
unsigned int getMax(const LArWave &theWave) const
return index of maximum sample
Definition: LArWaveHelper.cxx:89
HWIdentifier
Definition: HWIdentifier.h:13
CaloGain::LARNGAIN
@ LARNGAIN
Definition: CaloGain.h:19
LArOnlineID_Base::barrel_ec
int barrel_ec(const HWIdentifier id) const
Return the position barrel or endcap of a hardware cell identifier: barrel_ec = [0,...
Definition: LArOnlineID_Base.cxx:1938
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
LArCaliWaveBuilderXtalk::m_waves
WaveContainer m_waves
Definition: LArCaliWaveBuilderXtalk.h:137
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
LArCaliWave::getIsPulsedInt
int getIsPulsedInt() const
isPulsed value
Definition: LArCaliWave.h:163
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
LArCaliWaveBuilderXtalk::m_NStep
int m_NStep
Definition: LArCaliWaveBuilderXtalk.h:155
LArCaliWaveBuilderXtalk::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArCaliWaveBuilderXtalk.h:124
LArCaliWaveBuilderXtalk::m_event_counter
unsigned m_event_counter
Definition: LArCaliWaveBuilderXtalk.h:154
LArWave::getSample
const double & getSample(const unsigned int i) const
Amplitude per time bin.
Definition: LArWave.h:53
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
LArCaliWaveBuilderXtalk::m_SamplingPeriod
float m_SamplingPeriod
Definition: LArCaliWaveBuilderXtalk.h:156
python.SystemOfUnits.megahertz
int megahertz
Definition: SystemOfUnits.py:127
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
LArCaliWave
Definition: LArCaliWave.h:44
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
LArConditionsContainer::end
ConstConditionsMapIterator end(unsigned int gain) const
end of all channels for this gain
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArConditionsContainer::get
ConstReference get(const HWIdentifier id, unsigned int gain=0) const
get data with online identifier
LArCaliWaveBuilderXtalk::m_ADCsatur
int m_ADCsatur
Definition: LArCaliWaveBuilderXtalk.h:158
LArOnlineID_Base::channel_Id
HWIdentifier channel_Id(int barrel_ec, int pos_neg, int feedthrough, int slot, int channel) const
create channel identifier from fields
Definition: LArOnlineID_Base.cxx:1565
LArOnlineID_Base::pos_neg
int pos_neg(const HWIdentifier id) const
Return the side of a hardware cell identifier pos_neg = [0,1] positive-side or negative-side Barrel...
Definition: LArOnlineID_Base.cxx:1950
LArCaliWaveVec
Definition: LArCaliWave.h:91
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LArCaliWaveBuilderXtalk::m_partition
std::string m_partition
Definition: LArCaliWaveBuilderXtalk.h:148
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
LArCaliWaveBuilderXtalk::m_CLKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_CLKey
Definition: LArCaliWaveBuilderXtalk.h:125
LArConditionsContainer< WaveMap >::ConditionsMapIterator
ConditionsMap::iterator ConditionsMapIterator
Definition: LArConditionsContainer.h:87
LArCaliWaveBuilderXtalk::m_CalibLineHW
std::vector< HWIdentifier > m_CalibLineHW
Definition: LArCaliWaveBuilderXtalk.h:141
RPDUtils::sideA
unsigned constexpr int sideA
Definition: RPDUtils.h:16
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
LArCaliWaveBuilderXtalk::initializeCabling
StatusCode initializeCabling(const LArOnOffIdMapping *cabling, const LArCalibLineMapping *clCont)
Definition: LArCaliWaveBuilderXtalk.cxx:169
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArOnlineID_Base::isEmEndcapSpecialOnline
bool isEmEndcapSpecialOnline(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1771
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
WaveMap
std::map< int, LArCaliWave > WaveMap
Definition: LArCaliWaveAverage.cxx:18
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
LArOnlineID_Base::feedthrough
int feedthrough(const HWIdentifier id) const
Return the feedthrough of a hardware cell identifier : feedthrough = [0,31] Barrel - A/C side or H/...
Definition: LArOnlineID_Base.cxx:1944
LArCaliWaveBuilderXtalk::m_calibPattern
std::string m_calibPattern
Definition: LArCaliWaveBuilderXtalk.h:147
a
TList * a
Definition: liststreamerinfos.cxx:10
LArWave::meas
@ meas
Definition: LArWave.h:122
h
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
AtlasDetectorID::show_to_string
std::string show_to_string(Identifier id, const IdContext *context=0, char sep='.') const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:574
LArAccumulatedCalibDigitContainer::getDelayScale
double getDelayScale() const
get the delay Scale
Definition: LArAccumulatedCalibDigitContainer.h:38
LArConditionsContainer::initialize
virtual StatusCode initialize()
Initialization done after creation or read back - derived classes may augment the functionality.
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DeMoScan.first
bool first
Definition: DeMoScan.py:536
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LArCaliWaveBuilderXtalk::m_groupingType
std::string m_groupingType
Definition: LArCaliWaveBuilderXtalk.h:132
RPDUtils::sideC
unsigned constexpr int sideC
Definition: RPDUtils.h:15
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
LArConditionsContainer::begin
ConstConditionsMapIterator begin(unsigned int gain) const
get iterator for all channels for a gain
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
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
LArCaliWaveBuilderXtalk::m_keylist
std::vector< std::string > m_keylist
Definition: LArCaliWaveBuilderXtalk.h:129
LArCaliWaveBuilderXtalk::m_keyoutput
std::string m_keyoutput
Definition: LArCaliWaveBuilderXtalk.h:131
LArAccumulatedCalibDigitContainer
Container class for LArAccumulatedCalibDigit.
Definition: LArAccumulatedCalibDigitContainer.h:25
LArCaliWaveBuilderXtalk::m_onlineHelper
const LArOnlineID * m_onlineHelper
Definition: LArCaliWaveBuilderXtalk.h:139
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
readCCLHist.float
float
Definition: readCCLHist.py:83
LArWaveCumul::getErrors
const std::vector< double > & getErrors() const
error vector
Definition: LArWaveCumul.h:138
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
LArCaliWaveBuilderXtalk::m_cutOnSample
int m_cutOnSample
Definition: LArCaliWaveBuilderXtalk.h:160
Identifier
Definition: IdentifierFieldParser.cxx:14
LArWaveCumul::getTriggers
const std::vector< int > & getTriggers() const
trigger vector
Definition: LArWaveCumul.h:150