Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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 735 of file LArPhysWavePredictor.cxx.

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

◆ 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  if (!f) {
339  ATH_MSG_ERROR("Cannot open file `MphysOverMcali.dat' for write");
340  return StatusCode::FAILURE;
341  }
342  fprintf(f,"# Region Layer Eta Phi Gain MphysMcali\n");
343  }
344  FileCloser fcloser (f);
345 
346  std::vector<int> nTotal;
347  std::vector<int> noTcali;
348  std::vector<int> noFstep;
349  std::vector<int> noOmega0;
350  std::vector<int> noTaur;
351  std::vector<int> noTdrift;
352  std::vector<int> noTdiff;
353 
354  unsigned maxgain = m_isSC ? CaloGain::LARNGAIN : 1;
355  for ( unsigned i=0; i<maxgain; ++i ) {
356  nTotal.push_back(0);
357  noTcali.push_back(0);
358  noFstep.push_back(0);
359  noOmega0.push_back(0);
360  noTaur.push_back(0);
361  noTdrift.push_back(0);
362  noTdiff.push_back(0);
363  }
364 
366  // Get current LArPhysWaveContainer
367  const LArPhysWaveContainer* larIdealPhysWaveContainer=nullptr;
368  if(m_isHEC || m_isSC){
369  ATH_CHECK(detStore()->retrieve(larIdealPhysWaveContainer,m_keyIdealPhys));
370  ATH_MSG_INFO("LArPhysWaveContainer with (key = " << m_keyIdealPhys << ") reading from StoreGate" );
371  }
373 
374  // get the calibration waveforms from the detector store
375 
376  int NPhysWave=0;
377  int NMPMC=0;
378 
379  for (const std::string& key : m_keyCali) { // Loop over all LArCaliWave containers that are to be processed
380 
381  // Get current LArCaliWaveContainer
382  const LArCaliWaveContainer* caliWaveContainer;
383  sc = detStore()->retrieve(caliWaveContainer,key);
384  if (sc.isFailure()) {
385  //log << MSG::INF0 << "LArCaliWaveContainer (key = " << key << ") not found in StoreGate" );
386  continue;
387  }
388  if ( caliWaveContainer == nullptr ) {
389  ATH_MSG_INFO( "LArCaliWaveContainer (key = " << key << ") is empty" );
390  continue;
391  }
392 
393  ATH_MSG_INFO( "Processing LArCaliWaveContainer from StoreGate, key = " << key );
394 
395  for ( unsigned gain = CaloGain::LARHIGHGAIN ; gain < CaloGain::LARNGAIN ; ++ gain ) { // loop over gain in the current LArCaliWAveContainer
396 
397  ATH_MSG_INFO( "Now processing gain = " << gain << " in LArCaliWaveContainer with key = " << key );
398 
399 
400  // loop over current cali wave container
402  const_iterator itVec = caliWaveContainer->begin(gain);
403  const_iterator itVec_e = caliWaveContainer->end(gain);
404  for (; itVec != itVec_e; ++itVec) { // loop over channels for a given gain
405 
406  for (const LArCaliWave& larCaliWave : *itVec) { // loop over DAC values for a given channel
407 
408  ATH_MSG_DEBUG((*itVec).size() << " LArCaliWaves found for channel " << m_onlineHelper->channel_name(itVec.channelId()) << " 0x"
409  << std::hex << itVec.channelId().get_identifier32().get_compact() << std::dec);
410  const HWIdentifier chid = itVec.channelId();
411  //
412  // region and layer information are needed
413  Identifier id;
414  try {
415  id = cabling->cnvToIdentifier(chid);
416  } catch (LArID_Exception & execpt) {
417  ATH_MSG_ERROR( "LArCabling exception caught for channel 0x" << MSG::hex << chid << MSG::dec
418  << ". Skipping channel." ) ;
419  continue ;
420  }
421 
422  int region = m_caloCellId->region(id);
423  int layer = m_caloCellId->sampling(id);
424 
425  if ( nchannel < 100 || ( nchannel < 1000 && nchannel%100==0 ) || nchannel%1000==0 )
426  ATH_MSG_INFO( "Processing calibration waveform number " << nchannel );
427 
428  if(m_onlineHelper->isFCALchannel(chid)) {
429  if(!m_isSC) continue; // Skip if it is FCAL ini standard readout
430  LArPhysWave fcalw;
431  fcalw = fcalPhysWaves->get(chid,0);
432 
433  // we need full length phys wave (truncation during merging
434  if(fcalw.getSize()<768) {
435  std::vector<double> amp;
436  amp.resize(768, 0.); // TODO: from where to take this number ? To be fixed later
437  const std::vector<double>& fvec = fcalw.getWave();
438  std::copy(fvec.begin(), fvec.end(), amp.begin());
439  LArPhysWave ptmp(amp, fcalw.getDt(), fcalw.getFlag());
440  larPhysWaveContainer->setPdata(chid,ptmp, gain);
441  } else {
442  larPhysWaveContainer->setPdata(chid,fcalw, gain);
443  }
444 
445  continue;
446  } //isFCALchannel
447 
448 
449  if ( larCaliWave.getFlag() == LArWave::dac0 ) continue ; // skip dac0 waves
450  // TODO: here we should add a DAC selection mechanism for TCM method
451 
452  nTotal[gain]++; // counter of processed pulse per gain
453 
454  ATH_MSG_VERBOSE("Predicting physics waveform for channel 0x" << MSG::hex << chid << MSG::dec
455  << " (gain = " << gain << " - DAC = " << larCaliWave.getDAC() << ")");
456 
457  // calibration pulse copy (working around the const iterator to be able to manipulate it...)
458  LArCaliWave theLArCaliWave = larCaliWave;
459  ++nchannel;
460 
461  if ( !cabling->isOnlineConnected(chid) ) { // unconnected channel : skipping ...
462  ATH_MSG_VERBOSE("Unconnected channel 0x" << MSG::hex << chid << MSG::dec
463  << ". Skipping channel.");
464  continue ;
465  }
466 
467  // Get the parameters corresponding to current LArCaliWave
468  float Tcali;
469  float Fstep;
470  float Omega0;
471  float Taur;
472  float Tdrift;
473  int Tdiff;
474 
475  // LArCaliPulseParams: if not fould, will use jobOptions values
476  if ( !m_useJOCaliPulseParams ) {
477  Tcali = larCaliPulseParams->Tcal(chid,gain) ;
478 
479  if ( Tcali <= 1.0+LArCaliPulseParamsComplete::ERRORCODE ) {
480  notFoundMsg(chid,gain,"Tcali");
481  Tcali = m_Tcali;
482  noTcali[gain]++;
483  }
484  Fstep = larCaliPulseParams->Fstep(chid,gain) ;
485  if ( Fstep <= 1.0+LArCaliPulseParamsComplete::ERRORCODE ) {
486  notFoundMsg(chid,gain,"Fstep");
487  Fstep = m_Fstep;
488  noFstep[gain]++;
489  }
490  } else {
491  Tcali = m_Tcali;
492  Fstep = m_Fstep;
493  }
494 
495  // LArDetCellParams: if not found, will not apply injection point correction
496  if ( !m_useJODetCellParams ) {
497  Omega0 = larDetCellParams->Omega0(chid,gain) ;
498  if ( Omega0 <= 1.0+LArDetCellParamsComplete::ERRORCODE ) {
499  notFoundMsg(chid,gain,"Omega0");
500  Omega0 = m_Omega0;
501  noOmega0[gain]++;
502  }
503  Taur = larDetCellParams->Taur(chid,gain) ;
504  if ( Taur <= 1.0+LArDetCellParamsComplete::ERRORCODE ) {
505  notFoundMsg(chid,gain,"Taur");
506  Taur = m_Taur;
507  noTaur[gain]++;
508  }
509  } else {
510  Omega0 = m_Omega0;
511  Taur = m_Taur;
512  }
513 
514  // LArTdrift: if not found will be set to jobOptions settings (or defaults if none) according to layer
515  if ( !m_useJOTdrift ) {
516  Tdrift = larTdrift->Tdrift(chid) ;
517  if ( Tdrift <= 1.0+LArTdriftComplete::ERRORCODE ) {
518  notFoundMsg(chid,gain,"Tdrift");
519  //ATH_MSG_ERROR( "Cannot access Tdrift for channel 0x" << MSG::hex << chid << MSG::dec
520  // << ". Will use jobOption setting." ) ;
521  if ( layer>=0 && layer<4 )
522  Tdrift = m_Tdrift[layer]; // Set drift time according to layer
523  else
524  Tdrift = 475.; // very crude!
525  noTdrift[gain]++;
526  }
527  } else { // use jobOptions settings
528  if ( layer>=0 && layer<4 )
529  Tdrift = m_Tdrift[layer]; // Set drift time according to layer
530  else
531  Tdrift = 475.; // very crude!
532  }
533 
534 
535  // LArPhysCaliTdiff: if not found, will use jobOptions settings
536  Tdiff = 0 ; // default value if everything else fails...
537  if ( !m_useJOPhysCaliTdiff ) {
538  Tdiff = (int)larPhysCaliTdiff->Tdiff(chid,gain) ;
539  if ( Tdiff <= 1.0+LArPhysCaliTdiffComplete::ERRORCODE ) {
540  notFoundMsg(chid,gain,"Tdiff");
541  Tdiff = 0 ;
542  m_useJOPhysCaliTdiff = true ;
543  noTdiff[gain]++;
544  }
545  }
546  if ( m_useJOPhysCaliTdiff ) {
547  if ( m_timeShiftByHelper ) {
548  Tdiff = larWaveHelper.getStart(theLArCaliWave) ;
549  Tdiff -= m_timeShiftGuardRegion ;
550  }
551  if ( m_timeShiftByIndex != 0 ) {
552  Tdiff = m_timeShiftByIndex;
553  }
554  if ( m_timeShiftByLayer ) {
555  Tdiff = m_TshiftLayer[layer] ;
556  }
557  if ( m_timeShiftByFEB && larFebTshift ) {
558  const HWIdentifier febid = m_onlineHelper->feb_Id(chid);
559  Tdiff = (int)larFebTshift->TimeOffset(febid);
560  Tdiff -= m_timeShiftGuardRegion ;
561  }
562  }
563 
564  // Fill the LArWFParams structure to be used by the LArPhysWaveTool
565  float Tshaper = 15. ;
566  float Amplitude = 1. ;
567  LArWFParams wfParams(Tcali,Fstep,Tdrift,Omega0,Taur,Tshaper,Amplitude);
568  wfParams.setFlag( 0 ) ; // this should contain the method used to find parameters and the gain
569  wfParams.setTdiff(Tdiff);
570 
571  ATH_MSG_VERBOSE( "wfParams: " << Tcali << " " <<Fstep<<" " <<Tdrift<<" "<<Omega0<<" "<<Taur<<" "<<Tdiff<<" "<<layer<<" "<<region );
572  // calibration pulse normalization
573  // (should be done here instead than in LArPhysWaveTool to get
574  // the correct Mphys/Mcali in case of double triangle prediction)
575  if ( m_normalizeCali ) {
576  double peak = theLArCaliWave.getSample(larWaveHelper.getMax(theLArCaliWave));
577  ATH_MSG_VERBOSE("Channel 0x" << MSG::hex << chid << MSG::dec << " -> Applying normalisation (CaliWave peak = " << peak << ")");
578  if ( peak <=0 ) {
579  ATH_MSG_WARNING( "Peak value <=0 , cannot normalize!" ) ;
580  } else {
581  theLArCaliWave = LArCaliWave( (theLArCaliWave*(1./peak)).getWave(),
582  theLArCaliWave.getErrors(),
583  theLArCaliWave.getTriggers(),
584  theLArCaliWave.getDt(),
585  theLArCaliWave.getDAC(),
586  theLArCaliWave.getIsPulsedInt(),
587  theLArCaliWave.getFlag() );
588  }
589  }
590 
591  //
592  // Predict the Physics Waveform
593  //
594  LArPhysWave larPhysWave;
595  float MphysMcali ;
596  //if(larIdealPhysWaveContainer && m_caloCellId->is_lar_hec(id)) {
597  // decide by online helper, not sure if offline is working for SC
598  if(larIdealPhysWaveContainer && m_onlineHelper->isHECchannel(chid)) {
599  const LArPhysWave& laridealPhysWave = larIdealPhysWaveContainer -> get(chid,gain);
600  int LArWaveFlag=LArWave::predCali; // 111 - for HEC Wave
601  //int LArIdealPhysWaveFlag=LArWave::predCali; // 111 - for HEC Wave
602  ATH_MSG_DEBUG( "Using HEC tool to predict LArPhysWave for channel " << chid.get_identifier32().get_compact());
603 
604  sc = larPhysWaveHECTool->makeLArPhysWaveHEC(wfParams,theLArCaliWave,larPhysWave,laridealPhysWave,MphysMcali,chid,gain,LArWaveFlag);
605 
606  //laridealPhysWave.setFlag( LArIdealPhysWaveFlag ) ;
607  }
608  else {
609  ATH_MSG_DEBUG( "Using EM tool to predict LArPhysWave for channel 0x" << chid.get_identifier32().get_compact() );
610  sc = larPhysWaveTool->makeLArPhysWave(wfParams,theLArCaliWave,region,layer,larPhysWave,MphysMcali);
611  }
612  if (sc.isFailure()) {
613  ATH_MSG_FATAL( "Cannot predict LArPhysWave for channel " << chid.get_identifier32().get_compact() );
614  continue;
615  }
616  larPhysWave.setFlag( LArWave::predCali ) ;
617 
618  if ( m_doubleTriangle ) { // mix of Tdrift ...
619  ATH_MSG_DEBUG("Applying double triangle correction");
620  if ( region==0 && layer>=0 && layer<4 && m_wTriangle2[layer]>0 ) { // EMB: set drift times and weight according to layer
621  LArWFParams wfParams2 = wfParams ;
622  wfParams2.setTdrift(m_Tdrift2[layer]);
623  LArPhysWave larPhysWave2;
624  float MphysMcali2 ;
625  sc = larPhysWaveTool->makeLArPhysWave(wfParams2,theLArCaliWave,region,layer,larPhysWave2,MphysMcali2);
626  if (sc.isFailure()) {
627  ATH_MSG_FATAL( "Cannot predict LArPhysWave for channel 0x" << MSG::hex << chid << MSG::dec << "with double triangle." );
628  continue;
629  }
630  larPhysWave = LArPhysWave ( ( larPhysWave*(1.-m_wTriangle2[layer])+larPhysWave2*m_wTriangle2[layer] ).getWave() ,
631  larPhysWave.getDt(),
632  larPhysWave.getFlag() ) ;
633  // Double-triagle predicion was used, Mphys/Mcali should be recomputed...
634  MphysMcali = larPhysWave.getSample(larWaveHelper.getMax(larPhysWave))/theLArCaliWave.getSample(larWaveHelper.getMax(theLArCaliWave));
635  } else {
636  ATH_MSG_WARNING( "Double triangle implemented only for EMB, skip channel!" ) ;
637  }
638  } // end if 2nd triangle
639 
640  // Apply time shift...
641  if ( Tdiff !=0 ) {
642  ATH_MSG_DEBUG("Time shift for channel " << (itVec.channelId()).get_compact() << " is "
643  << Tdiff << " samples (" << Tdiff*larPhysWave.getDt() << " ns)");
644  larPhysWave = LArPhysWave( (larWaveHelper.translate(larPhysWave,-Tdiff,0)).getWave() ,
645  larPhysWave.getDt(),
646  larPhysWave.getFlag() ) ;
647  }
648 
649  // Add predicted physics wave to container
650  larPhysWaveContainer->setPdata(chid,larPhysWave,gain);
651  NPhysWave++;
652 
653  // Add Mphys/Mcali to container
654  if (MphysMcali<=0.) {
656  }
657  ATH_MSG_VERBOSE("Channel 0x" << MSG::hex << chid << MSG::dec << " -> Mphys/Mcali = " << MphysMcali);
658  MphysOverMcalComplete->set(chid,gain,MphysMcali);
659  NMPMC++;
660  if ( m_dumpMphysMcali ) {
661  int eta = m_caloCellId->eta(id);
662  int phi = m_caloCellId->phi(id);
663  fprintf( f , "%2d %2d %3d %3d %2u %8.3f \n", region, layer, eta, phi, gain, MphysMcali ) ;
664  } //end if m_dumpMphysMcal
665 
666  } // end loop over DAC value for a given cell
667  if ( m_testmode && nchannel>=1 ) break;
668  } // end loop over cells for a given gain
669  if ( m_testmode && nchannel>=1 ) break;
670  } // end loop over gains for a give container
671  if ( m_testmode && nchannel>=1 ) break;
672  } // End loop over all CaliWave containers
673 
674  //ATH_MSG_INFO( " Summary : Number of cells with a PhysWave values computed : " << larPhysWaveContainer->totalNumberOfConditions() );
675  //ATH_MSG_INFO( " Summary : Number of cells with a MphysOverMcal values computed : " << MphysOverMcalComplete->totalNumberOfConditions() );
676  ATH_MSG_INFO( " Summary : Number of cells with a PhysWave values computed : " << NPhysWave );
677  ATH_MSG_INFO( " Summary : Number of cells with a MphysOverMcal values computed : " << NMPMC );
678  ATH_MSG_INFO( " Summary : Number of Barrel PS cells side A or C (connected+unconnected): 3904+ 192 " );
679  ATH_MSG_INFO( " Summary : Number of Barrel cells side A or C (connected+unconnected): 50944+2304 " );
680  ATH_MSG_INFO( " Summary : Number of EMEC cells side A or C (connected+unconnected): 31872+3456 " );
681  ATH_MSG_INFO( " Summary : Number of HEC cells side A or C (connected+unconnected): 2816+ 256 " );
682  ATH_MSG_INFO( " Summary : Number of FCAL cells side A or C (connected+unconnected): 1762+ 30 " );
683 
684  ATH_MSG_DEBUG("LArPhysWaveContainer->totalNumberOfConditions() = " << larPhysWaveContainer->totalNumberOfConditions());
685  ATH_MSG_DEBUG("LArMphysOverMcalComplete->totalNumberOfConditions() = " << MphysOverMcalComplete->totalNumberOfConditions());
686 
687  // final report
688  ATH_MSG_INFO( "\n Final report \n" );
689  for ( unsigned theGain = CaloGain::LARHIGHGAIN ; theGain < CaloGain::LARNGAIN ; ++theGain ) {
690 
691  ATH_MSG_INFO( " *** Gain = " << theGain << " ***" );
692  if ( !m_useJOCaliPulseParams ) {
693  ATH_MSG_INFO( "\t" << noTcali[theGain] << " / " << nTotal[theGain] << " channel(s) missing Tcali" );
694  ATH_MSG_INFO( "\t" << noFstep[theGain] << " / " << nTotal[theGain] << " channel(s) missing Fstep" );
695  }
696  if ( !m_useJODetCellParams ) {
697  ATH_MSG_INFO( "\t" << noOmega0[theGain] << " / " << nTotal[theGain] << " channel(s) missing Omega0" );
698  ATH_MSG_INFO( "\t" << noTaur[theGain] << " / " << nTotal[theGain] << " channel(s) missing Taur" );
699  }
700  if ( !m_useJOTdrift )
701  ATH_MSG_INFO( "\t" << noTdrift[theGain] << " / " << nTotal[theGain] << " channel(s) missing Tdrift" );
702  if ( !m_useJOPhysCaliTdiff )
703  ATH_MSG_INFO( "\t" << noTdiff[theGain] << " / " << nTotal[theGain] << " channel(s) missing Tdiff" );
704  }
705  ATH_MSG_INFO( "\n" );
706 
707  // Record LArPhysWaveContainer to DetectorStore
708  sc = detStore()->record(std::move(larPhysWaveContainer),m_keyPhys);
709  if (sc.isFailure()) {
710  ATH_MSG_FATAL( "Cannot record LArPhysWaveContainer to StoreGate! key=" << m_keyPhys );
711  return StatusCode::FAILURE;
712  }
713 
714  // Record LArMphysOverMcalComplete to DetectorStore
715  sc = detStore()->record(std::move(MphysOverMcalComplete),m_keyMphysMcali);
716  if (sc.isFailure()) {
717  ATH_MSG_FATAL( "Cannot record LArMphysOverMcalComplete to StoreGate! key=" << m_keyMphysMcali );
718  return StatusCode::FAILURE;
719  }
720 
721  // Symlink LArMphysOverMcalComplete to ILArMphysOverMcal for further use
722  ATH_MSG_DEBUG("Trying to symlink ILArMphysOverMcal with LArMphysOverMcalComplete...");
724  if (sc.isFailure()) {
725  ATH_MSG_FATAL( "Could not symlink ILArMphysOverMcal with LArMphysOverMcalComplete." );
726  return StatusCode::FAILURE;
727  }
728  ATH_MSG_INFO( "ILArMphysOverMcal symlink with LArMphysOverMcalComplete successfully" ) ;
729 
730  ATH_MSG_INFO( "LArPhysWavePredictor finalized!" );
731 
732  return StatusCode::SUCCESS;
733 }

◆ 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
LArWaveHelper::getStart
unsigned getStart(const LArWave &theWave) const
Definition: LArWaveHelper.cxx:409
LArWave::getFlag
unsigned getFlag() const
flag: ...
Definition: LArWave.h:178
LArWaveFlag
int LArWaveFlag
Definition: LArPhysWaveHECTool.cxx:57
LArParamsProperties::MphysOverMcalComplete
@ MphysOverMcalComplete
Definition: LArParamsProperties.h:85
ILArMphysOverMcal::ERRORCODE
@ ERRORCODE
Definition: ILArMphysOverMcal.h:29
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::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
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
ILArTdrift::ERRORCODE
@ ERRORCODE
Definition: ILArTdrift.h:27
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
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
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
ILArDetCellParams::ERRORCODE
@ ERRORCODE
Definition: ILArDetCellParams.h:29
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
ILArCaliPulseParams::ERRORCODE
@ ERRORCODE
Definition: ILArCaliPulseParams.h:32
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:735
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:37
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:141
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
LArWave::dac0
@ dac0
Definition: LArWave.h:125
LArWave::predCali
@ predCali
Definition: LArWave.h:129
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:239
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
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
ILArPhysCaliTdiff::ERRORCODE
@ ERRORCODE
Definition: ILArPhysCaliTdiff.h:29
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
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
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
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:629
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
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