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

#include <LArPhysWavePredictor.h>

Inheritance diagram for LArPhysWavePredictor:
Collaboration diagram for LArPhysWavePredictor:

Public Member Functions

 LArPhysWavePredictor (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~LArPhysWavePredictor ()
 
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 ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

void notFoundMsg (const HWIdentifier chid, const int gain, const char *value)
 
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< LArBadChannelContm_BCKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"}
 
SG::ReadCondHandleKey< LArOnOffIdMappingm_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
 
SG::ReadCondHandleKey< LArOnOffIdMappingm_cablingKeySC {this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"}
 
LArBadChannelMask m_bcMask
 
Gaudi::Property< std::vector< std::string > > m_problemsToMask {this,"ProblemsToMask",{}, "Bad-Channel categories to mask"}
 
const LArOnlineID_Basem_onlineHelper =nullptr
 
const CaloCell_Base_IDm_caloCellId =nullptr
 
bool m_testmode
 
bool m_storeEmpty
 
bool m_dumpMphysMcali
 
bool m_normalizeCali
 
bool m_isSC
 
std::vector< std::string > m_keyCali
 
std::string m_keyPhys
 
std::string m_keyMphysMcali
 
std::string m_keyIdealPhys
 
std::string m_keyFcal
 
std::string m_groupingType
 
bool m_useJOCaliPulseParams
 
double m_Tcali
 
double m_Fstep
 
bool m_useJODetCellParams
 
double m_Omega0
 
double m_Taur
 
bool m_isHEC
 
bool m_useJOTdrift
 
std::vector< double > m_Tdrift
 
bool m_doubleTriangle
 
std::vector< double > m_Tdrift2
 
std::vector< double > m_wTriangle2
 
bool m_useJOPhysCaliTdiff
 
int m_timeShiftByIndex
 
bool m_timeShiftByHelper
 
bool m_timeShiftByLayer
 
std::vector< unsigned int > m_TshiftLayer
 
bool m_timeShiftByFEB
 
int m_timeShiftGuardRegion
 
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 26 of file LArPhysWavePredictor.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

◆ LArPhysWavePredictor()

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

Definition at line 48 of file LArPhysWavePredictor.cxx.

49  : AthAlgorithm(name, pSvcLocator),
50  m_groupingType("FeedThrough") // SubDetector, Single, FeedThrough
51 {
52  declareProperty("TestMode", m_testmode = false);
53  declareProperty("StoreEmpty", m_storeEmpty = false);
54  declareProperty("isSC", m_isSC = false);
55 
56  m_keyCali.clear() ;
57  declareProperty("KeyCaliList", m_keyCali); // Keys of LArCaliWaveContainers
58  declareProperty("KeyPhys", m_keyPhys = "LArPhysWave") ; // Key of LArPhysWaveContainer
59  declareProperty("KeyIdealPhys", m_keyIdealPhys = "LArPhysWaveHECIdeal") ; // added by FT
60  declareProperty("KeyFcal", m_keyFcal = "FCALFromTB") ; // added by FT
61  declareProperty("KeyMphysMcali", m_keyMphysMcali = "LArMphysOverMcal") ; // Key of LArMphysOverMcalComplete
62  declareProperty("DumpMphysMcali", m_dumpMphysMcali = false ) ; // for debugging
63  declareProperty("NormalizeCali", m_normalizeCali = false ) ; // for debugging
64  declareProperty("isHEC", m_isHEC = false ) ;
65 
66  //
67  // jobOptions for calibration pulse paramers (Tcali, Fstep)
68  //
69  declareProperty("UseCaliPulseParamsFromJO", m_useJOCaliPulseParams = false );
70  declareProperty("Tcali", m_Tcali = 450. );
71  declareProperty("Fstep", m_Fstep = 0.07 );
72 
73  declareProperty("UseDetCellParamsFromJO" , m_useJODetCellParams = false );
74  declareProperty("Omega0", m_Omega0 = 0. ); // Omega0 == 0 will skip injection point correction
75  declareProperty("Taur", m_Taur = 0. );
76 
77  //
78  // jobOptions for drift time of predicted pulses (Tdrift)
79  //
80  declareProperty("UseTdriftFromJO", m_useJOTdrift = false );
81  m_Tdrift.clear();
82  double default_Tdrift[4] = { 420 , 475 , 475 , 475 } ;
83  for ( unsigned i=0;i<4;i++) m_Tdrift.push_back(default_Tdrift[i]);
84  declareProperty("Tdrift", m_Tdrift) ;
85  m_Tdrift2.clear();
86  double default_Tdrift2[4] = { 1200. , 1200. , 1200. , 1200. } ;
87  for ( unsigned i=0;i<4;i++) m_Tdrift2.push_back(default_Tdrift2[i]);
88  declareProperty("Tdrift2", m_Tdrift2) ;
89  m_wTriangle2.clear();
90  double default_wTriangle2[4] = { 0.01 , 0.01 , 0.01 , 0.01 } ;
91  for ( unsigned i=0;i<4;i++) m_wTriangle2.push_back(default_wTriangle2[i]);
92  declareProperty("WeightTriangle2", m_wTriangle2) ;
93  declareProperty("UseDoubleTriangle", m_doubleTriangle = false );
94 
95  //
96  // jobOptions for time shift of predicted pulses
97  //
98  declareProperty("UseTimeShiftFromJO", m_useJOPhysCaliTdiff = false );
99  declareProperty("TimeShiftByIndex" , m_timeShiftByIndex = 0);
100  declareProperty("TimeShiftByHelper", m_timeShiftByHelper = false);
101  declareProperty("TimeShiftByLayer", m_timeShiftByLayer = false) ;
102  declareProperty("TimeShiftByFEB", m_timeShiftByFEB = false) ;
103  declareProperty("TimeShiftGuardRegion", m_timeShiftGuardRegion = 0 ) ;
104  m_TshiftLayer.clear();
105  unsigned int default_TshiftLayer[4] = { 0 , 0 , 0 , 0 } ;
106  for ( unsigned i=0;i<4;i++) m_TshiftLayer.push_back(default_TshiftLayer[i]);
107  declareProperty("Tshift",m_TshiftLayer) ;
108 
109  // Grouping type
110  declareProperty("GroupingType", m_groupingType);
111 }

◆ ~LArPhysWavePredictor()

LArPhysWavePredictor::~LArPhysWavePredictor ( )
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 LArPhysWavePredictor::execute ( )
inline

Definition at line 34 of file LArPhysWavePredictor.h.

34 {return StatusCode::SUCCESS;}

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

Definition at line 36 of file LArPhysWavePredictor.h.

36 {return StatusCode::SUCCESS;}

◆ initialize()

StatusCode LArPhysWavePredictor::initialize ( )

Definition at line 118 of file LArPhysWavePredictor.cxx.

119 {
120  if ( ! m_doubleTriangle ) {
121  ATH_MSG_INFO( "Using standard triangular ionization pulse" ) ;
122  } else {
123  ATH_MSG_INFO( "Using refined ionization pulse (double triangle)" ) ;
124  }
125 
126  StatusCode sc;
127  if ( m_isSC ) {
128  const LArOnline_SuperCellID* ll;
129  ATH_CHECK(detStore()->retrieve(ll, "LArOnline_SuperCellID"));
131  ATH_MSG_DEBUG("Found the LArOnlineID helper");
132  const CaloCell_SuperCell_ID* scid;
133  ATH_CHECK(detStore()->retrieve(scid, "CaloCell_SuperCell_ID" ));
134  m_caloCellId= (const CaloCell_Base_ID*)scid;
135 
136  } else { // m_isSC
137  const LArOnlineID* ll;
138  ATH_CHECK(detStore()->retrieve(ll, "LArOnlineID") );
140  ATH_MSG_DEBUG(" Found the LArOnlineID helper. ");
141  const CaloCell_ID* cid;
142  ATH_CHECK(detStore()->retrieve(cid, "CaloCell_ID" ));
143  m_caloCellId= (const CaloCell_Base_ID*)cid;
144  }
145 
146  ATH_CHECK( m_BCKey.initialize() );
150 
151  return StatusCode::SUCCESS ;
152 }

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

◆ notFoundMsg()

void LArPhysWavePredictor::notFoundMsg ( const HWIdentifier  chid,
const int  gain,
const char *  value 
)
private

Definition at line 731 of file LArPhysWavePredictor.cxx.

731  {
733  const LArBadChannelCont* bcCont{*bcContHdl};
734 
735  if (m_bcMask.cellShouldBeMasked(bcCont,chid)) {
736  ATH_MSG_WARNING( "Cannot access " << value << " for known bad channel channel " << m_onlineHelper->channel_name(chid)
737  << ", gain = " << gain << ". Will use jobO setting." ) ;
738  }
739  else {
740  LArBadChanBitPacking packer;
741  const LArBadChannel bc = bcCont->status(chid);
742  const std::string badChanStatus=packer.stringStatus(bc);
743 
744  ATH_MSG_ERROR( "Cannot access " << value << " for channel " << m_onlineHelper->channel_name(chid)
745  << ", gain = " << gain << " BC status=[" << badChanStatus << "]. Will use jobO setting." );
746  }
747  }

◆ 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 LArPhysWavePredictor::stop ( )

Definition at line 167 of file LArPhysWavePredictor.cxx.

168 {
169  ATH_MSG_INFO( "... in stop()" ) ;
170 
171  LArWaveHelper larWaveHelper;
172 
173  // Get access to the Detector Store
174  //StoreGateSvc* detStore;
175  //StatusCode sc = service("DetectorStore",detStore);
176  //if (sc!=StatusCode::SUCCESS) {
177  // ATH_MSG_ERROR( "Cannot get DetectorStore!" );
178  // return sc;
179  //}
180 
181  // Retrieve LArPhysWaveTool
182  ToolHandle<LArPhysWaveTool> larPhysWaveTool("LArPhysWaveTool");
183  StatusCode sc=larPhysWaveTool.retrieve();
184  if (sc!=StatusCode::SUCCESS) {
185  ATH_MSG_ERROR( " Can't get LArPhysWaveTool " );
186  return sc;
187  }
188 
189  // Retrieve LArPhysWaveHECTool // added by FT
190  ToolHandle<LArPhysWaveHECTool> larPhysWaveHECTool("LArPhysWaveHECTool");
191  if(m_isSC || m_isHEC){
192  sc=larPhysWaveHECTool.retrieve();
193  if (sc!=StatusCode::SUCCESS) {
194  ATH_MSG_ERROR( " Can't get LArPhysWaveHECTool " );
195  return sc;
196  }}
197 
198 
199  // Retrieve cabling
200  const LArOnOffIdMapping* cabling(nullptr);
201  if( m_isSC ){
203  cabling = {*cablingHdl};
204  if(!cabling) {
205  ATH_MSG_ERROR("Do not have mapping object " << m_cablingKeySC.key());
206  return StatusCode::FAILURE;
207  }
208  }else{
210  cabling = {*cablingHdl};
211  if(!cabling) {
212  ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
213  return StatusCode::FAILURE;
214  }
215  }
216 
217  // Get parameters from detStore (access through abtract interfaces)
218  const ILArCaliPulseParams* larCaliPulseParams = nullptr;
219  const ILArDetCellParams* larDetCellParams = nullptr;
220  const ILArTdrift* larTdrift = nullptr;
221  const ILArPhysCaliTdiff* larPhysCaliTdiff = nullptr;
222 
223  if ( !m_useJOCaliPulseParams ) {
224  sc = detStore()->retrieve(larCaliPulseParams);
225  if ( sc == StatusCode::FAILURE ) {
226  ATH_MSG_WARNING( "Cannot retrieve LArCaliPulseParams" ) ;
227  return sc;
228  } else {
229  ATH_MSG_INFO( "LArCaliPulseParams successfully retrieved" ) ;
230  }
231  }
232 
233  if ( !m_useJODetCellParams ) {
234  if (!m_isHEC ) {
235  sc = detStore()->retrieve(larDetCellParams);
236  if ( sc == StatusCode::FAILURE ) {
237  ATH_MSG_WARNING( "Cannot retrieve LArDetCellParams" );
238  return sc;
239  }else {
240  ATH_MSG_INFO( "LArDetCellParams successfully retrieved" );
241  }
242  }else{
243  m_useJODetCellParams = true ;
244  }
245  }
246 
247  if ( !m_useJOTdrift ) {
248  sc = detStore()->retrieve(larTdrift);
249  if ( sc == StatusCode::FAILURE ) {
250  ATH_MSG_WARNING( "Cannot retrieve LArTdriftComplete" );
251  return sc;
252  }else {
253  ATH_MSG_INFO( "LArTdriftComplete successfully retrieved" );
254  }
255  }
256 
257  if ( !m_useJOPhysCaliTdiff ) {
258  sc = detStore()->retrieve(larPhysCaliTdiff);
259  if ( sc == StatusCode::FAILURE ) {
260  ATH_MSG_WARNING( "Cannot retrieve LArPhysCaliTdiff" );
261  return sc;
262  }else {
263  ATH_MSG_INFO( "LArPhysCaliTdiff successfully retrieved" );
264  }
265  }
266 
267  const ILArFEBTimeOffset* larFebTshift = nullptr;
268  if ( m_useJOPhysCaliTdiff ) { // no LArPhysCaliTdiffComplete found, or manual time shift selected
269  if ( m_timeShiftByHelper ) {
270  ATH_MSG_INFO( "Will use helper class for start time." );
271  m_timeShiftByIndex = -1 ;
272  m_timeShiftByLayer = false ;
273  m_timeShiftByFEB = false ;
274  }
275  if ( m_timeShiftByIndex != -1 ) {
276  ATH_MSG_INFO( "Manually shifting pulses by time index " << m_timeShiftByIndex );
277  m_timeShiftByLayer = false ;
278  m_timeShiftByFEB = false ;
279  }
280  if ( m_timeShiftByLayer ) {
281  ATH_MSG_INFO( "Manually shifting pulses by *layer-dependent* time indexes." );
282  m_timeShiftByFEB = false ;
283  }
284  if ( m_timeShiftByFEB ) {
285  ATH_MSG_INFO( "Manually shifting pulses by *FEB* time indexes." );
286  sc = detStore()->retrieve(larFebTshift);
287  if (sc.isFailure())
288  larFebTshift = nullptr;
289  }
290  }
291 
292  const LArPhysWaveContainer *fcalPhysWaves=nullptr;
293 
294  if ( m_isSC ) { //retrieve FCAL phys waves from COOL
295  sc = detStore()->retrieve(fcalPhysWaves, m_keyFcal);
296  if ( sc.isFailure() || !fcalPhysWaves) {
297  ATH_MSG_WARNING( "Cannot retrieve FCAL Phys waves" );
298  return sc;
299  }else {
300  ATH_MSG_INFO( "LArPhysWave fro FCAL successfully retrieved" );
301  }
302  }
303 
304  int nchannel = 0 ;
305 
306  // Create LArPhysWaveContainer for predicted physics waveforms
307  std::unique_ptr<LArPhysWaveContainer> larPhysWaveContainer = std::make_unique<LArPhysWaveContainer>();
308 
309  sc=larPhysWaveContainer->setGroupingType(m_groupingType,msg());
310  if (sc.isFailure()) {
311  ATH_MSG_ERROR( "Failed to set groupingType for LArPhysWaveContainer object" );
312  return sc;
313  }
314 
315  sc=larPhysWaveContainer->initialize();
316  if (sc.isFailure()) {
317  ATH_MSG_ERROR( "Failed initialize LArPhysWaveContainer object" );
318  return sc;
319  }
320 
321  // Create LArMphysOverMcalComplete for predicted Mphys/Mcali
322  std::unique_ptr<LArMphysOverMcalComplete> MphysOverMcalComplete = std::make_unique<LArMphysOverMcalComplete>();
323  sc=MphysOverMcalComplete->setGroupingType(m_groupingType,msg());
324  if (sc.isFailure()) {
325  ATH_MSG_ERROR( "Failed to set groupingType for LArMphysOverMcalComplete object" );
326  return sc;
327  }
328 
329  sc=MphysOverMcalComplete->initialize();
330  if (sc.isFailure()) {
331  ATH_MSG_ERROR( "Failed initialize LArMphysOverMcalComplete object" );
332  return sc;
333  }
334 
335  FILE* f = nullptr;
336  if (m_dumpMphysMcali) {
337  f = fopen("MphysOverMcali.dat","w");
338  fprintf(f,"# Region Layer Eta Phi Gain MphysMcali\n");
339  }
340  FileCloser fcloser (f);
341 
342  std::vector<int> nTotal;
343  std::vector<int> noTcali;
344  std::vector<int> noFstep;
345  std::vector<int> noOmega0;
346  std::vector<int> noTaur;
347  std::vector<int> noTdrift;
348  std::vector<int> noTdiff;
349 
350  unsigned maxgain = m_isSC ? CaloGain::LARNGAIN : 1;
351  for ( unsigned i=0; i<maxgain; ++i ) {
352  nTotal.push_back(0);
353  noTcali.push_back(0);
354  noFstep.push_back(0);
355  noOmega0.push_back(0);
356  noTaur.push_back(0);
357  noTdrift.push_back(0);
358  noTdiff.push_back(0);
359  }
360 
362  // Get current LArPhysWaveContainer
363  const LArPhysWaveContainer* larIdealPhysWaveContainer=nullptr;
364  if(m_isHEC || m_isSC){
365  ATH_CHECK(detStore()->retrieve(larIdealPhysWaveContainer,m_keyIdealPhys));
366  ATH_MSG_INFO("LArPhysWaveContainer with (key = " << m_keyIdealPhys << ") reading from StoreGate" );
367  }
369 
370  // get the calibration waveforms from the detector store
371 
372  int NPhysWave=0;
373  int NMPMC=0;
374 
375  for (const std::string& key : m_keyCali) { // Loop over all LArCaliWave containers that are to be processed
376 
377  // Get current LArCaliWaveContainer
378  const LArCaliWaveContainer* caliWaveContainer;
379  sc = detStore()->retrieve(caliWaveContainer,key);
380  if (sc.isFailure()) {
381  //log << MSG::INF0 << "LArCaliWaveContainer (key = " << key << ") not found in StoreGate" );
382  continue;
383  }
384  if ( caliWaveContainer == nullptr ) {
385  ATH_MSG_INFO( "LArCaliWaveContainer (key = " << key << ") is empty" );
386  continue;
387  }
388 
389  ATH_MSG_INFO( "Processing LArCaliWaveContainer from StoreGate, key = " << key );
390 
391  for ( unsigned gain = CaloGain::LARHIGHGAIN ; gain < CaloGain::LARNGAIN ; ++ gain ) { // loop over gain in the current LArCaliWAveContainer
392 
393  ATH_MSG_INFO( "Now processing gain = " << gain << " in LArCaliWaveContainer with key = " << key );
394 
395 
396  // loop over current cali wave container
398  const_iterator itVec = caliWaveContainer->begin(gain);
399  const_iterator itVec_e = caliWaveContainer->end(gain);
400  for (; itVec != itVec_e; ++itVec) { // loop over channels for a given gain
401 
402  for (const LArCaliWave& larCaliWave : *itVec) { // loop over DAC values for a given channel
403 
404  ATH_MSG_DEBUG((*itVec).size() << " LArCaliWaves found for channel " << m_onlineHelper->channel_name(itVec.channelId()) << " 0x"
405  << std::hex << itVec.channelId().get_identifier32().get_compact() << std::dec);
406  const HWIdentifier chid = itVec.channelId();
407  //
408  // region and layer information are needed
409  Identifier id;
410  try {
411  id = cabling->cnvToIdentifier(chid);
412  } catch (LArID_Exception & execpt) {
413  ATH_MSG_ERROR( "LArCabling exception caught for channel 0x" << MSG::hex << chid << MSG::dec
414  << ". Skipping channel." ) ;
415  continue ;
416  }
417 
418  int region = m_caloCellId->region(id);
419  int layer = m_caloCellId->sampling(id);
420 
421  if ( nchannel < 100 || ( nchannel < 1000 && nchannel%100==0 ) || nchannel%1000==0 )
422  ATH_MSG_INFO( "Processing calibration waveform number " << nchannel );
423 
424  if(m_onlineHelper->isFCALchannel(chid)) {
425  if(!m_isSC) continue; // Skip if it is FCAL ini standard readout
426  LArPhysWave fcalw;
427  fcalw = fcalPhysWaves->get(chid,0);
428 
429  // we need full length phys wave (truncation during merging
430  if(fcalw.getSize()<768) {
431  std::vector<double> amp;
432  amp.resize(768, 0.); // TODO: from where to take this number ? To be fixed later
433  const std::vector<double>& fvec = fcalw.getWave();
434  std::copy(fvec.begin(), fvec.end(), amp.begin());
435  LArPhysWave ptmp(amp, fcalw.getDt(), fcalw.getFlag());
436  larPhysWaveContainer->setPdata(chid,ptmp, gain);
437  } else {
438  larPhysWaveContainer->setPdata(chid,fcalw, gain);
439  }
440 
441  continue;
442  } //isFCALchannel
443 
444 
445  if ( larCaliWave.getFlag() == LArWave::dac0 ) continue ; // skip dac0 waves
446  // TODO: here we should add a DAC selection mechanism for TCM method
447 
448  nTotal[gain]++; // counter of processed pulse per gain
449 
450  ATH_MSG_VERBOSE("Predicting physics waveform for channel 0x" << MSG::hex << chid << MSG::dec
451  << " (gain = " << gain << " - DAC = " << larCaliWave.getDAC() << ")");
452 
453  // calibration pulse copy (working around the const iterator to be able to manipulate it...)
454  LArCaliWave theLArCaliWave = larCaliWave;
455  ++nchannel;
456 
457  if ( !cabling->isOnlineConnected(chid) ) { // unconnected channel : skipping ...
458  ATH_MSG_VERBOSE("Unconnected channel 0x" << MSG::hex << chid << MSG::dec
459  << ". Skipping channel.");
460  continue ;
461  }
462 
463  // Get the parameters corresponding to current LArCaliWave
464  float Tcali;
465  float Fstep;
466  float Omega0;
467  float Taur;
468  float Tdrift;
469  int Tdiff;
470 
471  // LArCaliPulseParams: if not fould, will use jobOptions values
472  if ( !m_useJOCaliPulseParams ) {
473  Tcali = larCaliPulseParams->Tcal(chid,gain) ;
474 
475  if ( Tcali <= 1.0+LArCaliPulseParamsComplete::ERRORCODE ) {
476  notFoundMsg(chid,gain,"Tcali");
477  Tcali = m_Tcali;
478  noTcali[gain]++;
479  }
480  Fstep = larCaliPulseParams->Fstep(chid,gain) ;
481  if ( Fstep <= 1.0+LArCaliPulseParamsComplete::ERRORCODE ) {
482  notFoundMsg(chid,gain,"Fstep");
483  Fstep = m_Fstep;
484  noFstep[gain]++;
485  }
486  } else {
487  Tcali = m_Tcali;
488  Fstep = m_Fstep;
489  }
490 
491  // LArDetCellParams: if not found, will not apply injection point correction
492  if ( !m_useJODetCellParams ) {
493  Omega0 = larDetCellParams->Omega0(chid,gain) ;
494  if ( Omega0 <= 1.0+LArDetCellParamsComplete::ERRORCODE ) {
495  notFoundMsg(chid,gain,"Omega0");
496  Omega0 = m_Omega0;
497  noOmega0[gain]++;
498  }
499  Taur = larDetCellParams->Taur(chid,gain) ;
500  if ( Taur <= 1.0+LArDetCellParamsComplete::ERRORCODE ) {
501  notFoundMsg(chid,gain,"Taur");
502  Taur = m_Taur;
503  noTaur[gain]++;
504  }
505  } else {
506  Omega0 = m_Omega0;
507  Taur = m_Taur;
508  }
509 
510  // LArTdrift: if not found will be set to jobOptions settings (or defaults if none) according to layer
511  if ( !m_useJOTdrift ) {
512  Tdrift = larTdrift->Tdrift(chid) ;
513  if ( Tdrift <= 1.0+LArTdriftComplete::ERRORCODE ) {
514  notFoundMsg(chid,gain,"Tdrift");
515  //ATH_MSG_ERROR( "Cannot access Tdrift for channel 0x" << MSG::hex << chid << MSG::dec
516  // << ". Will use jobOption setting." ) ;
517  if ( layer>=0 && layer<4 )
518  Tdrift = m_Tdrift[layer]; // Set drift time according to layer
519  else
520  Tdrift = 475.; // very crude!
521  noTdrift[gain]++;
522  }
523  } else { // use jobOptions settings
524  if ( layer>=0 && layer<4 )
525  Tdrift = m_Tdrift[layer]; // Set drift time according to layer
526  else
527  Tdrift = 475.; // very crude!
528  }
529 
530 
531  // LArPhysCaliTdiff: if not found, will use jobOptions settings
532  Tdiff = 0 ; // default value if everything else fails...
533  if ( !m_useJOPhysCaliTdiff ) {
534  Tdiff = (int)larPhysCaliTdiff->Tdiff(chid,gain) ;
535  if ( Tdiff <= 1.0+LArPhysCaliTdiffComplete::ERRORCODE ) {
536  notFoundMsg(chid,gain,"Tdiff");
537  Tdiff = 0 ;
538  m_useJOPhysCaliTdiff = true ;
539  noTdiff[gain]++;
540  }
541  }
542  if ( m_useJOPhysCaliTdiff ) {
543  if ( m_timeShiftByHelper ) {
544  Tdiff = larWaveHelper.getStart(theLArCaliWave) ;
545  Tdiff -= m_timeShiftGuardRegion ;
546  }
547  if ( m_timeShiftByIndex != 0 ) {
548  Tdiff = m_timeShiftByIndex;
549  }
550  if ( m_timeShiftByLayer ) {
551  Tdiff = m_TshiftLayer[layer] ;
552  }
553  if ( m_timeShiftByFEB && larFebTshift ) {
554  const HWIdentifier febid = m_onlineHelper->feb_Id(chid);
555  Tdiff = (int)larFebTshift->TimeOffset(febid);
556  Tdiff -= m_timeShiftGuardRegion ;
557  }
558  }
559 
560  // Fill the LArWFParams structure to be used by the LArPhysWaveTool
561  float Tshaper = 15. ;
562  float Amplitude = 1. ;
563  LArWFParams wfParams(Tcali,Fstep,Tdrift,Omega0,Taur,Tshaper,Amplitude);
564  wfParams.setFlag( 0 ) ; // this should contain the method used to find parameters and the gain
565  wfParams.setTdiff(Tdiff);
566 
567  ATH_MSG_VERBOSE( "wfParams: " << Tcali << " " <<Fstep<<" " <<Tdrift<<" "<<Omega0<<" "<<Taur<<" "<<Tdiff<<" "<<layer<<" "<<region );
568  // calibration pulse normalization
569  // (should be done here instead than in LArPhysWaveTool to get
570  // the correct Mphys/Mcali in case of double triangle prediction)
571  if ( m_normalizeCali ) {
572  double peak = theLArCaliWave.getSample(larWaveHelper.getMax(theLArCaliWave));
573  ATH_MSG_VERBOSE("Channel 0x" << MSG::hex << chid << MSG::dec << " -> Applying normalisation (CaliWave peak = " << peak << ")");
574  if ( peak <=0 ) {
575  ATH_MSG_WARNING( "Peak value <=0 , cannot normalize!" ) ;
576  } else {
577  theLArCaliWave = LArCaliWave( (theLArCaliWave*(1./peak)).getWave(),
578  theLArCaliWave.getErrors(),
579  theLArCaliWave.getTriggers(),
580  theLArCaliWave.getDt(),
581  theLArCaliWave.getDAC(),
582  theLArCaliWave.getIsPulsedInt(),
583  theLArCaliWave.getFlag() );
584  }
585  }
586 
587  //
588  // Predict the Physics Waveform
589  //
590  LArPhysWave larPhysWave;
591  float MphysMcali ;
592  //if(larIdealPhysWaveContainer && m_caloCellId->is_lar_hec(id)) {
593  // decide by online helper, not sure if offline is working for SC
594  if(larIdealPhysWaveContainer && m_onlineHelper->isHECchannel(chid)) {
595  const LArPhysWave& laridealPhysWave = larIdealPhysWaveContainer -> get(chid,gain);
596  int LArWaveFlag=LArWave::predCali; // 111 - for HEC Wave
597  //int LArIdealPhysWaveFlag=LArWave::predCali; // 111 - for HEC Wave
598  ATH_MSG_DEBUG( "Using HEC tool to predict LArPhysWave for channel " << chid.get_identifier32().get_compact());
599 
600  sc = larPhysWaveHECTool->makeLArPhysWaveHEC(wfParams,theLArCaliWave,larPhysWave,laridealPhysWave,MphysMcali,chid,gain,LArWaveFlag);
601 
602  //laridealPhysWave.setFlag( LArIdealPhysWaveFlag ) ;
603  }
604  else {
605  ATH_MSG_DEBUG( "Using EM tool to predict LArPhysWave for channel 0x" << chid.get_identifier32().get_compact() );
606  sc = larPhysWaveTool->makeLArPhysWave(wfParams,theLArCaliWave,region,layer,larPhysWave,MphysMcali);
607  }
608  if (sc.isFailure()) {
609  ATH_MSG_FATAL( "Cannot predict LArPhysWave for channel " << chid.get_identifier32().get_compact() );
610  continue;
611  }
612  larPhysWave.setFlag( LArWave::predCali ) ;
613 
614  if ( m_doubleTriangle ) { // mix of Tdrift ...
615  ATH_MSG_DEBUG("Applying double triangle correction");
616  if ( region==0 && layer>=0 && layer<4 && m_wTriangle2[layer]>0 ) { // EMB: set drift times and weight according to layer
617  LArWFParams wfParams2 = wfParams ;
618  wfParams2.setTdrift(m_Tdrift2[layer]);
619  LArPhysWave larPhysWave2;
620  float MphysMcali2 ;
621  sc = larPhysWaveTool->makeLArPhysWave(wfParams2,theLArCaliWave,region,layer,larPhysWave2,MphysMcali2);
622  if (sc.isFailure()) {
623  ATH_MSG_FATAL( "Cannot predict LArPhysWave for channel 0x" << MSG::hex << chid << MSG::dec << "with double triangle." );
624  continue;
625  }
626  larPhysWave = LArPhysWave ( ( larPhysWave*(1.-m_wTriangle2[layer])+larPhysWave2*m_wTriangle2[layer] ).getWave() ,
627  larPhysWave.getDt(),
628  larPhysWave.getFlag() ) ;
629  // Double-triagle predicion was used, Mphys/Mcali should be recomputed...
630  MphysMcali = larPhysWave.getSample(larWaveHelper.getMax(larPhysWave))/theLArCaliWave.getSample(larWaveHelper.getMax(theLArCaliWave));
631  } else {
632  ATH_MSG_WARNING( "Double triangle implemented only for EMB, skip channel!" ) ;
633  }
634  } // end if 2nd triangle
635 
636  // Apply time shift...
637  if ( Tdiff !=0 ) {
638  ATH_MSG_DEBUG("Time shift for channel " << (itVec.channelId()).get_compact() << " is "
639  << Tdiff << " samples (" << Tdiff*larPhysWave.getDt() << " ns)");
640  larPhysWave = LArPhysWave( (larWaveHelper.translate(larPhysWave,-Tdiff,0)).getWave() ,
641  larPhysWave.getDt(),
642  larPhysWave.getFlag() ) ;
643  }
644 
645  // Add predicted physics wave to container
646  larPhysWaveContainer->setPdata(chid,larPhysWave,gain);
647  NPhysWave++;
648 
649  // Add Mphys/Mcali to container
650  if (MphysMcali<=0.) {
652  }
653  ATH_MSG_VERBOSE("Channel 0x" << MSG::hex << chid << MSG::dec << " -> Mphys/Mcali = " << MphysMcali);
654  MphysOverMcalComplete->set(chid,gain,MphysMcali);
655  NMPMC++;
656  if ( m_dumpMphysMcali ) {
657  int eta = m_caloCellId->eta(id);
658  int phi = m_caloCellId->phi(id);
659  fprintf( f , "%2d %2d %3d %3d %2u %8.3f \n", region, layer, eta, phi, gain, MphysMcali ) ;
660  } //end if m_dumpMphysMcal
661 
662  } // end loop over DAC value for a given cell
663  if ( m_testmode && nchannel>=1 ) break;
664  } // end loop over cells for a given gain
665  if ( m_testmode && nchannel>=1 ) break;
666  } // end loop over gains for a give container
667  if ( m_testmode && nchannel>=1 ) break;
668  } // End loop over all CaliWave containers
669 
670  //ATH_MSG_INFO( " Summary : Number of cells with a PhysWave values computed : " << larPhysWaveContainer->totalNumberOfConditions() );
671  //ATH_MSG_INFO( " Summary : Number of cells with a MphysOverMcal values computed : " << MphysOverMcalComplete->totalNumberOfConditions() );
672  ATH_MSG_INFO( " Summary : Number of cells with a PhysWave values computed : " << NPhysWave );
673  ATH_MSG_INFO( " Summary : Number of cells with a MphysOverMcal values computed : " << NMPMC );
674  ATH_MSG_INFO( " Summary : Number of Barrel PS cells side A or C (connected+unconnected): 3904+ 192 " );
675  ATH_MSG_INFO( " Summary : Number of Barrel cells side A or C (connected+unconnected): 50944+2304 " );
676  ATH_MSG_INFO( " Summary : Number of EMEC cells side A or C (connected+unconnected): 31872+3456 " );
677  ATH_MSG_INFO( " Summary : Number of HEC cells side A or C (connected+unconnected): 2816+ 256 " );
678  ATH_MSG_INFO( " Summary : Number of FCAL cells side A or C (connected+unconnected): 1762+ 30 " );
679 
680  ATH_MSG_DEBUG("LArPhysWaveContainer->totalNumberOfConditions() = " << larPhysWaveContainer->totalNumberOfConditions());
681  ATH_MSG_DEBUG("LArMphysOverMcalComplete->totalNumberOfConditions() = " << MphysOverMcalComplete->totalNumberOfConditions());
682 
683  // final report
684  ATH_MSG_INFO( "\n Final report \n" );
685  for ( unsigned theGain = CaloGain::LARHIGHGAIN ; theGain < CaloGain::LARNGAIN ; ++theGain ) {
686 
687  ATH_MSG_INFO( " *** Gain = " << theGain << " ***" );
688  if ( !m_useJOCaliPulseParams ) {
689  ATH_MSG_INFO( "\t" << noTcali[theGain] << " / " << nTotal[theGain] << " channel(s) missing Tcali" );
690  ATH_MSG_INFO( "\t" << noFstep[theGain] << " / " << nTotal[theGain] << " channel(s) missing Fstep" );
691  }
692  if ( !m_useJODetCellParams ) {
693  ATH_MSG_INFO( "\t" << noOmega0[theGain] << " / " << nTotal[theGain] << " channel(s) missing Omega0" );
694  ATH_MSG_INFO( "\t" << noTaur[theGain] << " / " << nTotal[theGain] << " channel(s) missing Taur" );
695  }
696  if ( !m_useJOTdrift )
697  ATH_MSG_INFO( "\t" << noTdrift[theGain] << " / " << nTotal[theGain] << " channel(s) missing Tdrift" );
698  if ( !m_useJOPhysCaliTdiff )
699  ATH_MSG_INFO( "\t" << noTdiff[theGain] << " / " << nTotal[theGain] << " channel(s) missing Tdiff" );
700  }
701  ATH_MSG_INFO( "\n" );
702 
703  // Record LArPhysWaveContainer to DetectorStore
704  sc = detStore()->record(std::move(larPhysWaveContainer),m_keyPhys);
705  if (sc.isFailure()) {
706  ATH_MSG_FATAL( "Cannot record LArPhysWaveContainer to StoreGate! key=" << m_keyPhys );
707  return StatusCode::FAILURE;
708  }
709 
710  // Record LArMphysOverMcalComplete to DetectorStore
711  sc = detStore()->record(std::move(MphysOverMcalComplete),m_keyMphysMcali);
712  if (sc.isFailure()) {
713  ATH_MSG_FATAL( "Cannot record LArMphysOverMcalComplete to StoreGate! key=" << m_keyMphysMcali );
714  return StatusCode::FAILURE;
715  }
716 
717  // Symlink LArMphysOverMcalComplete to ILArMphysOverMcal for further use
718  ATH_MSG_DEBUG("Trying to symlink ILArMphysOverMcal with LArMphysOverMcalComplete...");
720  if (sc.isFailure()) {
721  ATH_MSG_FATAL( "Could not symlink ILArMphysOverMcal with LArMphysOverMcalComplete." );
722  return StatusCode::FAILURE;
723  }
724  ATH_MSG_INFO( "ILArMphysOverMcal symlink with LArMphysOverMcalComplete successfully" ) ;
725 
726  ATH_MSG_INFO( "LArPhysWavePredictor finalized!" );
727 
728  return StatusCode::SUCCESS;
729 }

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

SG::ReadCondHandleKey<LArBadChannelCont> LArPhysWavePredictor::m_BCKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"}
private

Definition at line 40 of file LArPhysWavePredictor.h.

◆ m_bcMask

LArBadChannelMask LArPhysWavePredictor::m_bcMask
private

Definition at line 44 of file LArPhysWavePredictor.h.

◆ m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArPhysWavePredictor::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
private

Definition at line 41 of file LArPhysWavePredictor.h.

◆ m_cablingKeySC

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

Definition at line 42 of file LArPhysWavePredictor.h.

◆ m_caloCellId

const CaloCell_Base_ID* LArPhysWavePredictor::m_caloCellId =nullptr
private

Definition at line 49 of file LArPhysWavePredictor.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_doubleTriangle

bool LArPhysWavePredictor::m_doubleTriangle
private

Definition at line 76 of file LArPhysWavePredictor.h.

◆ m_dumpMphysMcali

bool LArPhysWavePredictor::m_dumpMphysMcali
private

Definition at line 52 of file LArPhysWavePredictor.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_Fstep

double LArPhysWavePredictor::m_Fstep
private

Definition at line 66 of file LArPhysWavePredictor.h.

◆ m_groupingType

std::string LArPhysWavePredictor::m_groupingType
private

Definition at line 62 of file LArPhysWavePredictor.h.

◆ m_isHEC

bool LArPhysWavePredictor::m_isHEC
private

Definition at line 72 of file LArPhysWavePredictor.h.

◆ m_isSC

bool LArPhysWavePredictor::m_isSC
private

Definition at line 54 of file LArPhysWavePredictor.h.

◆ m_keyCali

std::vector<std::string> LArPhysWavePredictor::m_keyCali
private

Definition at line 56 of file LArPhysWavePredictor.h.

◆ m_keyFcal

std::string LArPhysWavePredictor::m_keyFcal
private

Definition at line 60 of file LArPhysWavePredictor.h.

◆ m_keyIdealPhys

std::string LArPhysWavePredictor::m_keyIdealPhys
private

Definition at line 59 of file LArPhysWavePredictor.h.

◆ m_keyMphysMcali

std::string LArPhysWavePredictor::m_keyMphysMcali
private

Definition at line 58 of file LArPhysWavePredictor.h.

◆ m_keyPhys

std::string LArPhysWavePredictor::m_keyPhys
private

Definition at line 57 of file LArPhysWavePredictor.h.

◆ m_normalizeCali

bool LArPhysWavePredictor::m_normalizeCali
private

Definition at line 53 of file LArPhysWavePredictor.h.

◆ m_Omega0

double LArPhysWavePredictor::m_Omega0
private

Definition at line 69 of file LArPhysWavePredictor.h.

◆ m_onlineHelper

const LArOnlineID_Base* LArPhysWavePredictor::m_onlineHelper =nullptr
private

Definition at line 48 of file LArPhysWavePredictor.h.

◆ m_problemsToMask

Gaudi::Property<std::vector<std::string> > LArPhysWavePredictor::m_problemsToMask {this,"ProblemsToMask",{}, "Bad-Channel categories to mask"}
private

Definition at line 45 of file LArPhysWavePredictor.h.

◆ m_storeEmpty

bool LArPhysWavePredictor::m_storeEmpty
private

Definition at line 51 of file LArPhysWavePredictor.h.

◆ m_Taur

double LArPhysWavePredictor::m_Taur
private

Definition at line 70 of file LArPhysWavePredictor.h.

◆ m_Tcali

double LArPhysWavePredictor::m_Tcali
private

Definition at line 65 of file LArPhysWavePredictor.h.

◆ m_Tdrift

std::vector<double> LArPhysWavePredictor::m_Tdrift
private

Definition at line 75 of file LArPhysWavePredictor.h.

◆ m_Tdrift2

std::vector<double> LArPhysWavePredictor::m_Tdrift2
private

Definition at line 77 of file LArPhysWavePredictor.h.

◆ m_testmode

bool LArPhysWavePredictor::m_testmode
private

Definition at line 50 of file LArPhysWavePredictor.h.

◆ m_timeShiftByFEB

bool LArPhysWavePredictor::m_timeShiftByFEB
private

Definition at line 85 of file LArPhysWavePredictor.h.

◆ m_timeShiftByHelper

bool LArPhysWavePredictor::m_timeShiftByHelper
private

Definition at line 82 of file LArPhysWavePredictor.h.

◆ m_timeShiftByIndex

int LArPhysWavePredictor::m_timeShiftByIndex
private

Definition at line 81 of file LArPhysWavePredictor.h.

◆ m_timeShiftByLayer

bool LArPhysWavePredictor::m_timeShiftByLayer
private

Definition at line 83 of file LArPhysWavePredictor.h.

◆ m_timeShiftGuardRegion

int LArPhysWavePredictor::m_timeShiftGuardRegion
private

Definition at line 86 of file LArPhysWavePredictor.h.

◆ m_TshiftLayer

std::vector<unsigned int> LArPhysWavePredictor::m_TshiftLayer
private

Definition at line 84 of file LArPhysWavePredictor.h.

◆ m_useJOCaliPulseParams

bool LArPhysWavePredictor::m_useJOCaliPulseParams
private

Definition at line 64 of file LArPhysWavePredictor.h.

◆ m_useJODetCellParams

bool LArPhysWavePredictor::m_useJODetCellParams
private

Definition at line 68 of file LArPhysWavePredictor.h.

◆ m_useJOPhysCaliTdiff

bool LArPhysWavePredictor::m_useJOPhysCaliTdiff
private

Definition at line 80 of file LArPhysWavePredictor.h.

◆ m_useJOTdrift

bool LArPhysWavePredictor::m_useJOTdrift
private

Definition at line 74 of file LArPhysWavePredictor.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_wTriangle2

std::vector<double> LArPhysWavePredictor::m_wTriangle2
private

Definition at line 78 of file LArPhysWavePredictor.h.


The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArPhysWavePredictor::m_onlineHelper
const LArOnlineID_Base * m_onlineHelper
Definition: LArPhysWavePredictor.h:48
LArBadChanBitPacking
Definition: LArBadChanBitPacking.h:13
ILArPhysCaliTdiff::Tdiff
virtual const float & Tdiff(const HWIdentifier &id, int gain) const =0
LArPhysWavePredictor::m_timeShiftGuardRegion
int m_timeShiftGuardRegion
Definition: LArPhysWavePredictor.h:86
LArPhysWavePredictor::m_Fstep
double m_Fstep
Definition: LArPhysWavePredictor.h:66
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
LArPhysWavePredictor::m_problemsToMask
Gaudi::Property< std::vector< std::string > > m_problemsToMask
Definition: LArPhysWavePredictor.h:45
LArConditionsContainer::setPdata
void setPdata(const HWIdentifier id, const T &payload, unsigned int gain=0)
put payload in persistent data
CaloCell_Base_ID::region
int region(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
detail::ll
long long ll
Definition: PrimitiveHelpers.h:47
LArWave::getSize
size_t getSize() const
number of time samples
Definition: LArWave.h:62
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ILArDetCellParams::ERRORCODE
@ ERRORCODE
Definition: ILArDetCellParams.h:29
LArWaveHelper::getStart
unsigned getStart(const LArWave &theWave) const
Definition: LArWaveHelper.cxx:409
LArWave::getFlag
unsigned getFlag() const
flag: ...
Definition: LArWave.h:178
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
LArWaveFlag
int LArWaveFlag
Definition: LArPhysWaveHECTool.cxx:57
LArParamsProperties::MphysOverMcalComplete
@ MphysOverMcalComplete
Definition: LArParamsProperties.h:85
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
LArPhysWavePredictor::m_Taur
double m_Taur
Definition: LArPhysWavePredictor.h:70
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
ILArFEBTimeOffset::TimeOffset
virtual float TimeOffset(const HWIdentifier fId) const =0
ILArDetCellParams
Definition: ILArDetCellParams.h:13
LArWave::dac0
@ dac0
Definition: LArWave.h:125
LArWave::getWave
const std::vector< double > & getWave() const
Wave parameters.
Definition: LArWave.h:167
LArBadXCont
Conditions-Data class holding LAr Bad Channel or Bad Feb information.
Definition: LArBadChannelCont.h:28
LArPhysWavePredictor::m_useJOPhysCaliTdiff
bool m_useJOPhysCaliTdiff
Definition: LArPhysWavePredictor.h:80
LArConditionsContainerDB::iteratorT
Declaration of const iterator.
Definition: LArConditionsContainerDB.h:72
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
ILArPhysCaliTdiff::ERRORCODE
@ ERRORCODE
Definition: ILArPhysCaliTdiff.h:29
LArWFParams::setTdrift
void setTdrift(double tdrift)
Definition: LArWFParams.h:228
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
LArWave::getDt
const double & getDt() const
delta time
Definition: LArWave.h:50
LArWaveHelper::translate
LArWave translate(const LArWave &theWave, int nShift, double baseline=0.) const
Definition: LArWaveHelper.cxx:11
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
LArBadChannelMask::buildBitMask
StatusCode buildBitMask(const std::vector< std::string > &problemsToMask, MsgStream &msg)
Definition: LArBadChannelMask.cxx:10
LArWaveHelper
Definition: LArWaveHelper.h:14
LArCaliWave::getDAC
int getDAC() const
DAC value.
Definition: LArCaliWave.h:156
athena.value
value
Definition: athena.py:124
LArWFParams
Definition: LArWFParams.h:20
LArPhysWavePredictor::m_groupingType
std::string m_groupingType
Definition: LArPhysWavePredictor.h:62
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
LArWaveHelper::getMax
unsigned int getMax(const LArWave &theWave) const
return index of maximum sample
Definition: LArWaveHelper.cxx:89
HWIdentifier
Definition: HWIdentifier.h:13
LArBadChannelMask::cellShouldBeMasked
bool cellShouldBeMasked(const LArBadChannelCont *bcCont, const HWIdentifier &hardwareId) const
Definition: LArBadChannelMask.h:42
CaloGain::LARNGAIN
@ LARNGAIN
Definition: CaloGain.h:19
ILArCaliPulseParams::Tcal
virtual const float & Tcal(const HWIdentifier &id, int gain) const =0
LArPhysWave
Definition: LArPhysWave.h:14
LArPhysWavePredictor::m_timeShiftByFEB
bool m_timeShiftByFEB
Definition: LArPhysWavePredictor.h:85
Identifier32::get_compact
value_type get_compact() const
Get the compact id.
Definition: Identifier32.h:44
LArPhysWavePredictor::m_wTriangle2
std::vector< double > m_wTriangle2
Definition: LArPhysWavePredictor.h:78
LArPhysWaveContainer
Liquid Argon Physics Wave Container.
Definition: LArPhysWaveContainer.h:23
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
LArCaliWaveContainer
Liquid Argon Cumulative Wave Container.
Definition: LArCaliWaveContainer.h:33
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
ILArCaliPulseParams::ERRORCODE
@ ERRORCODE
Definition: ILArCaliPulseParams.h:32
LArPhysWavePredictor::m_normalizeCali
bool m_normalizeCali
Definition: LArPhysWavePredictor.h:53
ILArCaliPulseParams::Fstep
virtual const float & Fstep(const HWIdentifier &id, int gain) const =0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
LArPhysWavePredictor::m_isHEC
bool m_isHEC
Definition: LArPhysWavePredictor.h:72
LArPhysWavePredictor::m_caloCellId
const CaloCell_Base_ID * m_caloCellId
Definition: LArPhysWavePredictor.h:49
ILArTdrift
Definition: ILArTdrift.h:12
LArConditionsContainer::totalNumberOfConditions
unsigned int totalNumberOfConditions() const
Statistics: total number of conditions.
LArOnlineID_Base::isFCALchannel
bool isFCALchannel(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1653
LArWave::getSample
const double & getSample(const unsigned int i) const
Amplitude per time bin.
Definition: LArWave.h:53
LArPhysWavePredictor::m_useJODetCellParams
bool m_useJODetCellParams
Definition: LArPhysWavePredictor.h:68
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
LArCaliWave
Definition: LArCaliWave.h:44
LArWave::predCali
@ predCali
Definition: LArWave.h:129
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
ILArFEBTimeOffset
Definition: ILArFEBTimeOffset.h:11
LArPhysWavePredictor::m_doubleTriangle
bool m_doubleTriangle
Definition: LArPhysWavePredictor.h:76
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
LArConditionsContainer::end
ConstConditionsMapIterator end(unsigned int gain) const
end of all channels for this gain
CaloCell_SuperCell_ID
Helper class for offline supercell identifiers.
Definition: CaloCell_SuperCell_ID.h:48
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArOnlineID_Base::isHECchannel
virtual bool isHECchannel(const HWIdentifier id) const =0
ILArDetCellParams::Omega0
virtual const float & Omega0(const HWIdentifier &id, int gain) const =0
CaloCell_Base_ID::sampling
int sampling(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LArPhysWavePredictor::m_BCKey
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey
Definition: LArPhysWavePredictor.h:40
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
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
LArPhysWavePredictor::notFoundMsg
void notFoundMsg(const HWIdentifier chid, const int gain, const char *value)
Definition: LArPhysWavePredictor.cxx:731
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
LArBadChannel
Definition: LArBadChannel.h:10
LArPhysWavePredictor::m_dumpMphysMcali
bool m_dumpMphysMcali
Definition: LArPhysWavePredictor.h:52
LArPhysWavePredictor::m_timeShiftByIndex
int m_timeShiftByIndex
Definition: LArPhysWavePredictor.h:81
CaloCell_Base_ID::eta
int eta(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
ILArTdrift::Tdrift
virtual const float & Tdrift(const HWIdentifier &id) const =0
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
hist_file_dump.f
f
Definition: hist_file_dump.py:135
LArPhysWavePredictor::m_keyMphysMcali
std::string m_keyMphysMcali
Definition: LArPhysWavePredictor.h:58
CaloCell_ID
Helper class for offline cell identifiers.
Definition: CaloCell_ID.h:34
LArPhysWavePredictor::m_timeShiftByHelper
bool m_timeShiftByHelper
Definition: LArPhysWavePredictor.h:82
LArPhysWavePredictor::m_keyIdealPhys
std::string m_keyIdealPhys
Definition: LArPhysWavePredictor.h:59
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
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
LArPhysWavePredictor::m_bcMask
LArBadChannelMask m_bcMask
Definition: LArPhysWavePredictor.h:44
LArPhysWavePredictor::m_useJOTdrift
bool m_useJOTdrift
Definition: LArPhysWavePredictor.h:74
LArPhysWavePredictor::m_storeEmpty
bool m_storeEmpty
Definition: LArPhysWavePredictor.h:51
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
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:227
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
LArPhysWavePredictor::m_Tcali
double m_Tcali
Definition: LArPhysWavePredictor.h:65
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArOnlineID
Definition: LArOnlineID.h:20
CaloGain::LARHIGHGAIN
@ LARHIGHGAIN
Definition: CaloGain.h:18
CaloCell_Base_ID::phi
int phi(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
LArOnline_SuperCellID
Definition: LArOnline_SuperCellID.h:20
LArPhysWavePredictor::m_Omega0
double m_Omega0
Definition: LArPhysWavePredictor.h:69
LArPhysWavePredictor::m_Tdrift2
std::vector< double > m_Tdrift2
Definition: LArPhysWavePredictor.h:77
ILArDetCellParams::Taur
virtual const float & Taur(const HWIdentifier &id, int gain) const =0
TLArBadChanBitPackingBase::stringStatus
std::string stringStatus(const LArBadChannel &bc) const
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
LArPhysWavePredictor::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArPhysWavePredictor.h:41
ILArPhysCaliTdiff
Definition: ILArPhysCaliTdiff.h:13
LArPhysWavePredictor::m_keyFcal
std::string m_keyFcal
Definition: LArPhysWavePredictor.h:60
a
TList * a
Definition: liststreamerinfos.cxx:10
LArPhysWavePredictor::m_Tdrift
std::vector< double > m_Tdrift
Definition: LArPhysWavePredictor.h:75
h
LArPhysWavePredictor::m_keyCali
std::vector< std::string > m_keyCali
Definition: LArPhysWavePredictor.h:56
LArPhysWavePredictor::m_timeShiftByLayer
bool m_timeShiftByLayer
Definition: LArPhysWavePredictor.h:83
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
LArPhysWavePredictor::m_keyPhys
std::string m_keyPhys
Definition: LArPhysWavePredictor.h:57
LArPhysWavePredictor::m_testmode
bool m_testmode
Definition: LArPhysWavePredictor.h:50
LArPhysWavePredictor::m_cablingKeySC
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKeySC
Definition: LArPhysWavePredictor.h:42
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LArPhysWavePredictor::m_isSC
bool m_isSC
Definition: LArPhysWavePredictor.h:54
ILArTdrift::ERRORCODE
@ ERRORCODE
Definition: ILArTdrift.h:27
LArConditionsContainer::begin
ConstConditionsMapIterator begin(unsigned int gain) const
get iterator for all channels for a gain
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
LArPhysWavePredictor::m_useJOCaliPulseParams
bool m_useJOCaliPulseParams
Definition: LArPhysWavePredictor.h:64
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
LArWave::setFlag
void setFlag(const unsigned flag)
set flag
Definition: LArWave.h:199
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
calibdata.copy
bool copy
Definition: calibdata.py:27
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
LArOnlineID_Base::channel_name
std::string channel_name(const HWIdentifier id) const
Return a string corresponding to a feedthrough name given an identifier.
Definition: LArOnlineID_Base.cxx:219
CaloCell_Base_ID
Helper base class for offline cell identifiers.
Definition: CaloCell_Base_ID.h:41
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
LArID_Exception
Exception class for LAr Identifiers.
Definition: LArID_Exception.h:20
LArPhysWavePredictor::m_TshiftLayer
std::vector< unsigned int > m_TshiftLayer
Definition: LArPhysWavePredictor.h:84
LArWaveCumul::getErrors
const std::vector< double > & getErrors() const
error vector
Definition: LArWaveCumul.h:138
ILArCaliPulseParams
Definition: ILArCaliPulseParams.h:14
fitman.k
k
Definition: fitman.py:528
ILArMphysOverMcal::ERRORCODE
@ ERRORCODE
Definition: ILArMphysOverMcal.h:29
ServiceHandle< ICondSvc >
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Identifier
Definition: IdentifierFieldParser.cxx:14
LArWaveCumul::getTriggers
const std::vector< int > & getTriggers() const
trigger vector
Definition: LArWaveCumul.h:150