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

#include <L1CaloCondAlg.h>

Inheritance diagram for L1CaloCondAlg:
Collaboration diagram for L1CaloCondAlg:

Public Member Functions

 L1CaloCondAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
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

enum  PprKeys { PPRCHANCALIB = 0, PPRCHANCOMMON = 1, PPRCHANHIGHMU = 2, PPRCHANLOWMU = 3 }
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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

Private Attributes

Gaudi::Property< std::string > m_timingRegime {this,"timingRegime","","String-> Calib1, Calib2 or Physics"}
 
Gaudi::Property< std::string > m_strategy {this,"strategy","","String-> empty, HighMu or LowMu"}
 
Gaudi::Property< bool > m_usePhysicsRegime { this, "UsePhysicsRegime", false, "Allow use of Physics timing regime" }
 
Gaudi::Property< bool > m_useCalib1Regime { this, "UseCalib1Regime", false, "Allow use of Calib1 timing regime" }
 
Gaudi::Property< bool > m_useCalib2Regime { this, "UseCalib2Regime", false, "Allow use of Calib2 timing regime" }
 
SG::ReadCondHandleKeyArray< CondAttrListCollection > m_physicsKeys { this, "PhysicsKeys", {}, "" }
 
SG::ReadCondHandleKeyArray< CondAttrListCollection > m_calib1Keys { this, "Calib1Keys", {}, "" }
 
SG::ReadCondHandleKeyArray< CondAttrListCollection > m_calib2Keys { this, "Calib2Keys", {}, "" }
 
SG::ReadCondHandleKey< CondAttrListCollection > m_disabledTowers { this, "DisabledTowers", "/TRIGGER/L1Calo/V1/Conditions/DisabledTowers", "DisabledTowers" }
 
SG::ReadCondHandleKey< CondAttrListCollection > m_derivedRunPars { this, "DerivedRunPars", "/TRIGGER/L1Calo/V1/Conditions/DerivedRunPars", "DerivedRunPars"}
 
SG::ReadCondHandleKey< CondAttrListCollection > m_ppmDeadChannels { this, "PpmDeadChannels", "/TRIGGER/L1Calo/V1/Calibration/PpmDeadChannels","PpmDeadChannels" }
 
SG::ReadCondHandleKey< CondAttrListCollection > m_ppmFineTimeRefs { this, "PpmFineTimeRefs" ,"/TRIGGER/L1Calo/V1/References/FineTimeReferences", "PpmFineTimeRefs"}
 
SG::ReadCondHandleKey< CondAttrListCollection > m_runParameters { this, "RunParameters" ,"/TRIGGER/L1Calo/V1/Conditions/RunParameters", "RunParameters"}
 
SG::ReadCondHandleKey< CondAttrListCollection > m_pprChanDefaults { this, "PprChanDefaults" ,"/TRIGGER/L1Calo/V2/Configuration/PprChanDefaults", "PprChanDefaults"}
 
SG::ReadCondHandleKey< CondAttrListCollection > m_pprChanStrategy { this, "PprChanStrategy", "/TRIGGER/L1Calo/V2/Configuration/PprChanStrategy", "PprChanStrategy"}
 
SG::ReadCondHandleKey< CondAttrListCollection > m_readoutConfig { this, "ReadoutConfig", "/TRIGGER/L1Calo/V2/Configuration/ReadoutConfig", "ReadoutConfig"}
 
SG::ReadCondHandleKey< CondAttrListCollection > m_readoutConfigJSON { this, "ReadoutConfigJSON", "/TRIGGER/L1Calo/V2/Configuration/ReadoutConfigJSON", "ReadoutConfigJSON"}
 
SG::WriteCondHandleKey< L1CaloDisabledTowersContainer > m_disabledTowersContainer {this,"OutputKeyDisTowers","L1CaloDisabledTowersContainer"}
 
SG::WriteCondHandleKey< L1CaloDerivedRunParsContainer > m_derivedRunParsContainer {this, "OutputKeyDerRunsPars", "L1CaloDerivedRunParsContainer"}
 
SG::WriteCondHandleKey< L1CaloPprChanCalibContainer > m_pprChanCalibContainer { this, "OutputKeyPPr", "L1CaloPprChanCalibContainer"}
 
SG::WriteCondHandleKey< L1CaloPprChanDefaultsContainer > m_pprChanDefaultsContainer { this, "OutputKeyDef", "L1CaloPprChanDefaultsContainer"}
 
SG::WriteCondHandleKey< L1CaloPpmFineTimeRefsContainer > m_ppmFineTimeRefsContainer { this, "OutputKeyTimeRefs", "L1CaloPpmFineTimeRefsContainer"}
 
SG::WriteCondHandleKey< L1CaloRunParametersContainer > m_runParametersContainer { this, "OutputKeyRunParameters", "L1CaloRunParametersContainer"}
 
SG::WriteCondHandleKey< L1CaloPprChanStrategyContainer > m_pprChanStrategyContainer { this, "OutputKeyPprChanStrategy", "L1CaloPprChanStrategyContainer"}
 
SG::WriteCondHandleKey< L1CaloPpmDeadChannelsContainer > m_ppmDeadChannelsContainer { this, "OutputKeyPpmDeadChannels", "L1CaloPpmDeadChannelsContainer"}
 
SG::WriteCondHandleKey< L1CaloPprConditionsContainerRun2 > m_pprConditionsContainer { this, "OutputKeyPprConditionsRun2", "L1CaloPprConditionsContainerRun2"}
 
SG::WriteCondHandleKey< L1CaloPprDisabledChannelContainerRun2 > m_pprDisabledChannelContainer { this, "OutputKeyDisabledChannelRun2", "L1CaloPprDisabledChannelContainerRun2"}
 
SG::WriteCondHandleKey< L1CaloReadoutConfigContainer > m_readoutConfigContainer { this, "OutputKeyReadoutConfig", "L1CaloReadoutConfigContainer"}
 
SG::WriteCondHandleKey< L1CaloReadoutConfigContainerJSON > m_readoutConfigContainerJSON { this, "OutputKeyReadoutConfigJSON", "L1CaloReadoutConfigContainerJSON"}
 
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 27 of file L1CaloCondAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ PprKeys

enum L1CaloCondAlg::PprKeys
private
Enumerator
PPRCHANCALIB 
PPRCHANCOMMON 
PPRCHANHIGHMU 
PPRCHANLOWMU 

Definition at line 52 of file L1CaloCondAlg.h.

52  {
53  // Should correspond with the name list in initialize().
54  PPRCHANCALIB = 0,
55  PPRCHANCOMMON = 1,
56  PPRCHANHIGHMU = 2,
57  PPRCHANLOWMU = 3
58  };

Constructor & Destructor Documentation

◆ L1CaloCondAlg()

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

Definition at line 13 of file L1CaloCondAlg.cxx.

13  : AthAlgorithm( name, pSvcLocator )
14 
15 
16 
17 {
18 
19 }

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;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, 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 L1CaloCondAlg::execute ( )
overridevirtual

Definition at line 99 of file L1CaloCondAlg.cxx.

100 {
101 
102  ATH_MSG_DEBUG( "start execute " << name() );
103  ATH_MSG_DEBUG("readConditions() ");
104 
105 
106 
107 
108  // Defining condition container to be saved
109 
110  SG::WriteCondHandle<L1CaloDisabledTowersContainer> writeHandleDisTowers{m_disabledTowersContainer};
111 
112  SG::WriteCondHandle<L1CaloDerivedRunParsContainer> writeHandleDerRunPars{m_derivedRunParsContainer};
113 
114  SG::WriteCondHandle<L1CaloPprChanCalibContainer> writeHandlePprChanCalib{m_pprChanCalibContainer};
115 
116  SG::WriteCondHandle<L1CaloPprChanDefaultsContainer> writeHandlePprChanDefaults{m_pprChanDefaultsContainer};
117 
118  SG::WriteCondHandle<L1CaloPpmFineTimeRefsContainer> writeHandlePpmFineTimeRefs{m_ppmFineTimeRefsContainer};
119 
120  SG::WriteCondHandle<L1CaloRunParametersContainer> writeHandleRunParameters{m_runParametersContainer};
121 
122  SG::WriteCondHandle<L1CaloPprChanStrategyContainer> writeHandlePprChanStrategy{m_pprChanStrategyContainer};
123 
124  SG::WriteCondHandle<L1CaloPpmDeadChannelsContainer> writeHandlePpmDeadChannels{m_ppmDeadChannelsContainer};
125 
126  SG::WriteCondHandle<L1CaloPprConditionsContainerRun2> writeHandlePprConditions{m_pprConditionsContainer};
127 
128  SG::WriteCondHandle<L1CaloPprDisabledChannelContainerRun2> writeHandlePprDisabledChannel{m_pprDisabledChannelContainer};
129 
130  SG::WriteCondHandle<L1CaloReadoutConfigContainer> writeHandleReadoutConfig{m_readoutConfigContainer};
131 
132  SG::WriteCondHandle<L1CaloReadoutConfigContainerJSON> writeHandleReadoutConfigJSON{m_readoutConfigContainerJSON};
133 
134 
135 
136 
137  // Reading timing regime from database, and defining cool database folder for reading FIR coefficients
138 
139  SG::ReadCondHandle<CondAttrListCollection> readHandleDerRunPars(m_derivedRunPars);
140  const CondAttrListCollection* readCdo_DerRunPars(*readHandleDerRunPars);
141  if (readCdo_DerRunPars == 0) {
142  ATH_MSG_ERROR("Null pointer to the read conditions object");
143  return StatusCode::FAILURE;
144  }
145 
146  auto writeCdoDerRunPars = std::make_unique<L1CaloDerivedRunParsContainer>();
147 
148  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapDerRunPars;
149  if (readCdo_DerRunPars) {
150  ATH_MSG_DEBUG("AttrListCollection for Derivated Run Parameters= "<<readCdo_DerRunPars);
151  condAttrListCollectionMapDerRunPars[ m_derivedRunPars.key() ] = readCdo_DerRunPars;
152  writeCdoDerRunPars->makeTransient(condAttrListCollectionMapDerRunPars);
153 
154  }
155 
156  std::string timingRegime ;
157  if (m_timingRegime.empty()) {
158  timingRegime = std::cbegin(*writeCdoDerRunPars)->timingRegime();
159  }
160  else {
161  timingRegime = m_timingRegime;
162  }
163 
164  ATH_MSG_DEBUG("timing regime --> "<< timingRegime );
165 
166  SG::ReadCondHandleKeyArray<CondAttrListCollection>* pprKeys = nullptr;
167  if (timingRegime == "Physics") {
168  pprKeys = &m_physicsKeys;
169  }
170  else if (timingRegime == "Calib1") {
171  pprKeys = &m_calib1Keys;
172  }
173  else if (timingRegime == "Calib2") {
174  pprKeys = &m_calib2Keys;
175  }
176  else {
177  ATH_MSG_ERROR( "Bad timing regime " << timingRegime <<
178  "; must be one of Physics, Calib1, Calib2" );
179  return StatusCode::FAILURE;
180  }
181 
182  // Strategy
183 
184  SG::ReadCondHandle<CondAttrListCollection> readHandlePprChanStrategy(m_pprChanStrategy);
185  const CondAttrListCollection* readCdo_PprChanStrategy(*readHandlePprChanStrategy);
186 
187  if (readCdo_PprChanStrategy == 0) {
188  ATH_MSG_ERROR("Null pointer to the read conditions object");
189  return StatusCode::FAILURE;
190  }
191  auto writeCdoPprChanStrategy = std::make_unique<L1CaloPprChanStrategyContainer>();
192 
193  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapPprChanStrategy;
194  if (readCdo_PprChanStrategy) {
195  ATH_MSG_DEBUG("AttrListCollection for Ppr Chan Strategy= "<<readCdo_PprChanStrategy);
196  condAttrListCollectionMapPprChanStrategy[ m_pprChanStrategy.key() ] = readCdo_PprChanStrategy;
197  writeCdoPprChanStrategy->makeTransient(condAttrListCollectionMapPprChanStrategy);
198 
199  }
200 
201 
202 
203  std::string strategy;
204 
205 
206  if (m_strategy.empty()) {
207 
208  for(const auto& it: *writeCdoPprChanStrategy){
209  if (it.timingRegime() == timingRegime){
210  strategy = it.strategy();
211 
212  }
213  }}
214 
215  else{
216  strategy = m_strategy;
217  }
218 
219  ATH_MSG_DEBUG("strategy selected --> " << strategy);
220 
221  const std::string keyPprChanCalib= (*pprKeys)[PPRCHANCALIB].key();
222 
223  SG::ReadCondHandle<CondAttrListCollection> readHandleDisTowers(m_disabledTowers);
224  const CondAttrListCollection* readCdo_DisTowers(*readHandleDisTowers);
225 
226  SG::ReadCondHandle<CondAttrListCollection> readHandlePprChanCalib((*pprKeys)[PPRCHANCALIB]);
227  const CondAttrListCollection* readCdo_PprChanCalib(*readHandlePprChanCalib);
228 
229  SG::ReadCondHandle<CondAttrListCollection> readHandlePprChanDefaults(m_pprChanDefaults);
230  const CondAttrListCollection* readCdo_PprChanDefaults(*readHandlePprChanDefaults);
231 
232  SG::ReadCondHandle<CondAttrListCollection> readHandlePpmFineTimeRefs(m_ppmFineTimeRefs);
233  const CondAttrListCollection* readCdo_PpmFineTimeRefs(*readHandlePpmFineTimeRefs);
234 
235  SG::ReadCondHandle<CondAttrListCollection> readHandleRunParameters(m_runParameters);
236  const CondAttrListCollection* readCdo_RunParameters(*readHandleRunParameters);
237 
238  SG::ReadCondHandle<CondAttrListCollection> readHandlePpmDeadChannels(m_ppmDeadChannels);
239  const CondAttrListCollection* readCdo_PpmDeadChannels(*readHandlePpmDeadChannels);
240 
241  SG::ReadCondHandle<CondAttrListCollection> readHandleReadoutConfig(m_readoutConfig);
242  const CondAttrListCollection* readCdo_ReadoutConfig(*readHandleReadoutConfig);
243 
244 
245  SG::ReadCondHandle<CondAttrListCollection> readHandleReadoutConfigJSON(m_readoutConfigJSON);
246  const CondAttrListCollection* readCdo_ReadoutConfigJSON(*readHandleReadoutConfigJSON);
247  CondAttrListCollection::const_iterator itr;
248 
249 
250  if (readCdo_DisTowers == 0) {
251  ATH_MSG_ERROR("Null pointer to the read conditions object");
252  return StatusCode::FAILURE;
253  }
254 
255 
256  if (readCdo_PprChanCalib == 0) {
257  ATH_MSG_ERROR("Null pointer to the read conditions object");
258  return StatusCode::FAILURE;
259  }
260 
261  if (readCdo_PprChanDefaults == 0) {
262  ATH_MSG_ERROR("Null pointer to the read conditions object");
263  return StatusCode::FAILURE;
264  }
265 
266  if (readCdo_PpmFineTimeRefs == 0) {
267  ATH_MSG_ERROR("Null pointer to the read conditions object");
268  return StatusCode::FAILURE;
269  }
270 
271 
272  if (readCdo_RunParameters == 0) {
273  ATH_MSG_ERROR("Null pointer to the read conditions object");
274  return StatusCode::FAILURE;
275  }
276 
277  if (readCdo_PpmDeadChannels == 0) {
278  ATH_MSG_ERROR("Null pointer to the read conditions object");
279  return StatusCode::FAILURE;
280  }
281 
282 
283  if (readCdo_ReadoutConfig == 0) {
284  ATH_MSG_ERROR("Null pointer to the read conditions object");
285  return StatusCode::FAILURE;
286  }
287 
288 
289 
290 
291 
292 
293  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandleDisTowers.fullKey() << " readCdo_DisTower->size()= " << readCdo_DisTowers->size());
294  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandleDerRunPars.fullKey() << " readCdo_DerRunPars->size()= " << readCdo_DerRunPars->size());
295  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandlePprChanCalib.fullKey() << " readCdo_PprChanCalib->size()= " << readCdo_PprChanCalib->size());
296  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandlePprChanDefaults.fullKey() << " readCdo_PprChanDefaults->size()= " << readCdo_PprChanDefaults->size());
297  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandlePpmFineTimeRefs.fullKey() << " readCdo_PpmFineTimeRefs->size()= " << readCdo_PpmFineTimeRefs->size());
298  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandleRunParameters.fullKey() << " readCdo_RunParameters->size()= " << readCdo_RunParameters->size());
299  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandlePprChanStrategy.fullKey() << " readCdo_PprChanStrategy->size()= " << readCdo_PprChanStrategy->size());
300  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandlePpmDeadChannels.fullKey() << " readCdo_PpmDeadChannels->size()= " << readCdo_PpmDeadChannels->size());
301  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandleReadoutConfig.fullKey() << " readCdo_ReadoutConfig->size()= " << readCdo_ReadoutConfig->size());
302  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandleReadoutConfigJSON.fullKey() << " readCdo_ReadoutConfigJSON->size()= " << readCdo_ReadoutConfigJSON->size());
303 
304 
305 
306 
307  auto writeCdoDisTowers = std::make_unique<L1CaloDisabledTowersContainer>();
308  auto writeCdoPprChanCalib = std::make_unique<L1CaloPprChanCalibContainer>();
309  auto writeCdoPprChanDefaults = std::make_unique<L1CaloPprChanDefaultsContainer>();
310  auto writeCdoPpmFineTimeRefs = std::make_unique<L1CaloPpmFineTimeRefsContainer>();
311  auto writeCdoRunParameters = std::make_unique<L1CaloRunParametersContainer>();
312  auto writeCdoPpmDeadChannels = std::make_unique<L1CaloPpmDeadChannelsContainer>();
313  auto writeCdoPprConditions = std::make_unique<L1CaloPprConditionsContainerRun2>();
314  auto writeCdoPprDisabledChannel = std::make_unique<L1CaloPprDisabledChannelContainerRun2>();
315  auto writeCdoReadoutConfig = std::make_unique<L1CaloReadoutConfigContainer>();
316  auto writeCdoReadoutConfigJSON = std::make_unique<L1CaloReadoutConfigContainerJSON>();
317 
318 
319 
320 
321  // Filling the condition container
322  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapDisTowers;
323  if (readCdo_DisTowers) {
324  ATH_MSG_DEBUG("AttrListCollection for Disabled Towers= "<<readCdo_DisTowers);
325  condAttrListCollectionMapDisTowers[ m_disabledTowers.key() ] = readCdo_DisTowers;
326  writeCdoDisTowers->makeTransient(condAttrListCollectionMapDisTowers);
327  }
328 
329 
330  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapPprChanCalib;
331  if (readCdo_PprChanCalib) {
332  ATH_MSG_DEBUG("AttrListCollection for Ppr Channel Calib = "<<readCdo_PprChanCalib);
333  condAttrListCollectionMapPprChanCalib[keyPprChanCalib] = readCdo_PprChanCalib;
334  writeCdoPprChanCalib->makeTransient(condAttrListCollectionMapPprChanCalib);
335 
336  }
337 
338 
339 
340 
341  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapPprChanDefaults;
342  if (readCdo_PprChanDefaults) {
343  ATH_MSG_DEBUG("AttrListCollection for Ppr Channel Defaults = "<<readCdo_PprChanDefaults);
344  condAttrListCollectionMapPprChanDefaults[ m_pprChanDefaults.key() ] = readCdo_PprChanDefaults;
345  writeCdoPprChanDefaults->makeTransient(condAttrListCollectionMapPprChanDefaults);
346 
347  }
348 
349 
350  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapPpmFineTimeRefs;
351  if (readCdo_PpmFineTimeRefs) {
352  ATH_MSG_DEBUG("AttrListCollection for Ppm FineTime Refs = "<<readCdo_PpmFineTimeRefs);
353  condAttrListCollectionMapPpmFineTimeRefs[ m_ppmFineTimeRefs.key() ] = readCdo_PpmFineTimeRefs;
354  writeCdoPpmFineTimeRefs->makeTransient(condAttrListCollectionMapPpmFineTimeRefs);
355 
356  }
357 
358 
359  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapRunParameters;
360  if (readCdo_RunParameters) {
361  ATH_MSG_DEBUG("AttrListCollection for Run Parameters = "<<readCdo_RunParameters);
362  condAttrListCollectionMapRunParameters[ m_runParameters.key() ] = readCdo_RunParameters;
363  writeCdoRunParameters->makeTransient(condAttrListCollectionMapRunParameters);
364 
365  }
366 
367 
368  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapPpmDeadChannels;
369  if (readCdo_PpmDeadChannels) {
370  ATH_MSG_DEBUG("AttrListCollection for Ppm Dead Channels= "<<readCdo_PpmDeadChannels);
371  condAttrListCollectionMapPpmDeadChannels[ m_ppmDeadChannels.key() ] = readCdo_PpmDeadChannels;
372  writeCdoPpmDeadChannels->makeTransient(condAttrListCollectionMapPpmDeadChannels);
373 
374  }
375 
376  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapReadoutConfig;
377  if (readCdo_ReadoutConfig) {
378  ATH_MSG_DEBUG("AttrListCollection for ReadoutConfig= "<<readCdo_ReadoutConfig);
379  condAttrListCollectionMapReadoutConfig[ m_readoutConfig.key() ] = readCdo_ReadoutConfig;
380  writeCdoReadoutConfig->makeTransient(condAttrListCollectionMapReadoutConfig);
381 
382  }
383 
384  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapReadoutConfigJSON;
385  if (readCdo_ReadoutConfigJSON) {
386  ATH_MSG_DEBUG("AttrListCollection for ReadoutConfigJSON= "<<readCdo_ReadoutConfigJSON);
387  condAttrListCollectionMapReadoutConfigJSON[ m_readoutConfigJSON.key() ] = readCdo_ReadoutConfigJSON;
388  writeCdoReadoutConfigJSON->makeTransient(condAttrListCollectionMapReadoutConfigJSON);
389 
390  }
391 
392  // Filling DisableChannels Contianer
393  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapDisableChannels;
394  condAttrListCollectionMapDisableChannels[keyPprChanCalib] = readCdo_PprChanCalib;
395  condAttrListCollectionMapDisableChannels[ m_disabledTowers.key() ] = readCdo_DisTowers;
396  condAttrListCollectionMapDisableChannels[ m_ppmDeadChannels.key() ] = readCdo_PpmDeadChannels;
397  writeCdoPprDisabledChannel->makeTransient(condAttrListCollectionMapDisableChannels);
398 
399 
400  // Event range definition
401 
402  EventIDRange range_DisTowers;
403  if ( !readHandleDisTowers.range(range_DisTowers) ) {
404  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandleDisTowers.key());
405  return StatusCode::FAILURE;
406  }
407 
408  ATH_MSG_DEBUG("Range of input is Disable Towers" << range_DisTowers);
409 
410  EventIDRange range_DerRunPars;
411  if ( !readHandleDerRunPars.range(range_DerRunPars) ) {
412  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandleDerRunPars.key());
413  return StatusCode::FAILURE;
414  }
415 
416  ATH_MSG_DEBUG("Range of input is DerRunPars" << range_DerRunPars);
417 
418 
419  EventIDRange range_PprChanCalib;
420  if ( !readHandlePprChanCalib.range(range_PprChanCalib) ) {
421  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandlePprChanCalib.key());
422  return StatusCode::FAILURE;
423  }
424 
425  ATH_MSG_DEBUG("Range of input is PprChanCalib" << range_PprChanCalib);
426 
427 
428 
429 
430  EventIDRange range_PprChanDefaults;
431  if ( !readHandlePprChanDefaults.range(range_PprChanDefaults) ) {
432  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandlePprChanDefaults.key());
433  return StatusCode::FAILURE;
434  }
435 
436  ATH_MSG_DEBUG("Range of input is PprChanDefaults" << range_PprChanDefaults);
437  writeHandlePprConditions.addDependency( range_PprChanDefaults );
438 
439 
440  EventIDRange range_PpmFineTimeRefs;
441  if ( !readHandlePpmFineTimeRefs.range(range_PpmFineTimeRefs) ) {
442  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandlePpmFineTimeRefs.key());
443  return StatusCode::FAILURE;
444  }
445 
446  ATH_MSG_DEBUG("Range of input is PpmFineTimeRefs" << range_PpmFineTimeRefs);
447 
448 
449 
450  EventIDRange range_RunParameters;
451  if ( !readHandleRunParameters.range(range_RunParameters) ) {
452  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandleRunParameters.key());
453  return StatusCode::FAILURE;
454  }
455 
456  ATH_MSG_DEBUG("Range of input is RunParameters" << range_RunParameters);
457 
458 
459  EventIDRange range_PprChanStrategy;
460  if ( !readHandlePprChanStrategy.range(range_PprChanStrategy) ) {
461  ATH_MSG_DEBUG("Failed to retrieve validity range for " << readHandlePprChanStrategy.key());
462  return StatusCode::FAILURE;
463  }
464 
465  ATH_MSG_DEBUG("Range of input is PprChanStrategy" << range_PprChanStrategy);
466 
467 
468  EventIDRange range_PpmDeadChannels;
469  if ( !readHandlePpmDeadChannels.range(range_PpmDeadChannels) ) {
470  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandlePpmDeadChannels.key());
471  return StatusCode::FAILURE;
472  }
473  ATH_MSG_DEBUG("Range of input is PpmDeadChannels" << range_PpmDeadChannels);
474 
475 
476 
477  EventIDRange range_ReadoutConfig;
478  if ( !readHandleReadoutConfig.range(range_ReadoutConfig) ) {
479  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandleReadoutConfig.key());
480  return StatusCode::FAILURE;
481  }
482  ATH_MSG_DEBUG("Range of input is Readout Config" << range_ReadoutConfig);
483 
484 
485  EventIDRange range_ReadoutConfigJSON;
486  if ( !readHandleReadoutConfigJSON.range(range_ReadoutConfigJSON) ) {
487  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandleReadoutConfigJSON.key());
488  return StatusCode::FAILURE;
489  }
490  ATH_MSG_DEBUG("Range of input is Readout Config JSON" << range_ReadoutConfigJSON);
491 
492 
493 
494  // Adding PprDisabledChannel dependencies
495  writeHandlePprDisabledChannel.addDependency(readHandlePpmDeadChannels);
496  writeHandlePprDisabledChannel.addDependency(readHandlePprChanCalib);
497  writeHandlePprDisabledChannel.addDependency(readHandleDisTowers);
498 
499 
500 
501  // Saving condition containers
502 
503 
504  if (writeHandleDisTowers.record(range_DisTowers, std::move(writeCdoDisTowers)).isFailure()) {
505  ATH_MSG_FATAL("Could not record " << writeHandleDisTowers.key()
506  << " with EventRange " << range_DisTowers
507  << " into Conditions Store");
508  return StatusCode::FAILURE;
509  }
510 
511 
512  if (writeHandleDerRunPars.record(range_DerRunPars, std::move(writeCdoDerRunPars)).isFailure()) {
513  ATH_MSG_FATAL("Could not record " << writeHandleDerRunPars.key()
514  << " with EventRange " << range_DerRunPars
515  << " into Conditions Store");
516  return StatusCode::FAILURE;
517  }
518 
519 
520  if (writeHandlePprChanCalib.record(range_PprChanCalib, std::move(writeCdoPprChanCalib)).isFailure()) {
521  ATH_MSG_FATAL("Could not record " << writeHandlePprChanCalib.key()
522  << " with EventRange " << range_PprChanCalib
523  << " into Conditions Store");
524  return StatusCode::FAILURE;
525  }
526 
527 
528 
529 
530  if (writeHandlePprChanDefaults.record(range_PprChanDefaults, std::move(writeCdoPprChanDefaults)).isFailure()) {
531  ATH_MSG_FATAL("Could not record " << writeHandlePprChanDefaults.key()
532  << " with EventRange " << range_PprChanDefaults
533  << " into Conditions Store");
534  return StatusCode::FAILURE;
535  }
536 
537 
538  if (writeHandlePpmFineTimeRefs.record(range_PpmFineTimeRefs, std::move(writeCdoPpmFineTimeRefs)).isFailure()) {
539  ATH_MSG_FATAL("Could not record " << writeHandlePpmFineTimeRefs.key()
540  << " with EventRange " << range_PpmFineTimeRefs
541  << " into Conditions Store");
542  return StatusCode::FAILURE;
543  }
544 
545 
546 
547  if (writeHandleRunParameters.record(range_RunParameters, std::move(writeCdoRunParameters)).isFailure()) {
548  ATH_MSG_FATAL("Could not record " << writeHandleRunParameters.key()
549  << " with EventRange " << range_RunParameters
550  << " into Conditions Store");
551  return StatusCode::FAILURE;
552  }
553 
554 
555 
556  if (writeHandlePprChanStrategy.record(range_PprChanStrategy, std::move(writeCdoPprChanStrategy)).isFailure()) {
557  ATH_MSG_FATAL("Could not record " << writeHandlePprChanStrategy.key()
558  << " with EventRange " << range_PprChanStrategy
559  << " into Conditions Store");
560  return StatusCode::FAILURE;
561  }
562 
563 
564 
565  if (writeHandlePpmDeadChannels.record(range_PpmDeadChannels, std::move(writeCdoPpmDeadChannels)).isFailure()) {
566  ATH_MSG_FATAL("Could not record " << writeHandlePpmDeadChannels.key()
567  << " with EventRange " << range_PpmDeadChannels
568  << " into Conditions Store");
569  return StatusCode::FAILURE;
570  }
571 
572 
573  if (writeHandleReadoutConfig.record(range_ReadoutConfig, std::move(writeCdoReadoutConfig)).isFailure()) {
574  ATH_MSG_FATAL("Could not record " << writeHandleReadoutConfig.key()
575  << " with EventRange " << range_ReadoutConfig
576  << " into Conditions Store");
577  return StatusCode::FAILURE;
578  }
579 
580 
581 
582  if (writeHandleReadoutConfigJSON.record(range_ReadoutConfigJSON, std::move(writeCdoReadoutConfigJSON)).isFailure()) {
583  ATH_MSG_FATAL("Could not record " << writeHandleReadoutConfigJSON.key()
584  << " with EventRange " << range_ReadoutConfigJSON
585  << " into Conditions Store");
586  return StatusCode::FAILURE;
587  }
588 
589 
590 
591 
592  if (writeHandlePprDisabledChannel.record(std::move(writeCdoPprDisabledChannel)).isFailure()) {
593  ATH_MSG_FATAL("Could not record " << writeHandlePprDisabledChannel.key()
594  << " into Conditions Store");
595  return StatusCode::FAILURE;
596  }
597 
598 
599  // Saving L1CaloConditionContianerRun2 depending on the strategy selected (to read FIR coefficients)
600 
601 
602  std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMapCond;
603  if (!strategy.empty()){
604 
605 
606  const std::string keyPprChanCommon = (*pprKeys)[PPRCHANCOMMON].key();
607 
608  SG::ReadCondHandleKey<CondAttrListCollection>* pprChanStrategy = nullptr;
609  if (strategy == "HighMu") {
610  pprChanStrategy = &(*pprKeys)[PPRCHANHIGHMU];
611  }
612  else if (strategy == "LowMu") {
613  pprChanStrategy = &(*pprKeys)[PPRCHANLOWMU];
614  }
615  else {
616  ATH_MSG_ERROR( "Bad strategy " << strategy <<
617  "; should be either HighMu or LowMu" );
618  return StatusCode::FAILURE;
619  }
620  const std::string keyPprChanStrategy = pprChanStrategy->key();
621 
622 
623  ATH_MSG_DEBUG("Entering to !strategy.empty() option --> strategy " << strategy);
624  ATH_MSG_DEBUG("PprChanCommon folder " << keyPprChanCommon );
625  ATH_MSG_DEBUG("PprChanStrategy folder " << keyPprChanStrategy);
626 
627 
628 
629  SG::ReadCondHandle<CondAttrListCollection> readHandlePprChanCommon((*pprKeys)[PPRCHANCOMMON]);
630  const CondAttrListCollection* readCdo_PprChanCommon(*readHandlePprChanCommon);
631 
632  SG::ReadCondHandle<CondAttrListCollection> readHandlePprChanStrategy(*pprChanStrategy);
633  const CondAttrListCollection* readCdo_PprChanStrategy(*readHandlePprChanStrategy);
634 
635  if (readCdo_PprChanCommon == 0) {
636  ATH_MSG_ERROR("Null pointer to the read conditions object");
637  return StatusCode::FAILURE;
638  }
639 
640  if (readCdo_PprChanStrategy == 0) {
641  ATH_MSG_ERROR("Null pointer to the read conditions object");
642  return StatusCode::FAILURE;
643  }
644 
645 
646  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandlePprChanCommon.fullKey() << " readCdo_PprChanCommon->size()= " << readCdo_PprChanCommon->size());
647  ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandlePprChanStrategy.fullKey() << " readCdo_PprChanMu->size()= " << readCdo_PprChanStrategy->size());
648 
649  condAttrListCollectionMapCond[ keyPprChanCommon ] = readCdo_PprChanCommon;
650  condAttrListCollectionMapCond[ keyPprChanStrategy ] = readCdo_PprChanStrategy;
651  condAttrListCollectionMapCond[ m_pprChanDefaults.key() ] = readCdo_PprChanDefaults;
652 
653  writeCdoPprConditions->makeTransient(condAttrListCollectionMapCond);
654 
655 
656  EventIDRange range_PprChanCommon;
657  if ( !readHandlePprChanCommon.range(range_PprChanCommon) ) {
658  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandlePprChanCommon.key());
659  return StatusCode::FAILURE;
660  }
661 
662  ATH_MSG_DEBUG("Range of input is PprChanCommon" << range_PprChanCommon);
663  writeHandlePprConditions.addDependency(range_PprChanCommon);
664 
665 
666  EventIDRange range_PprChanStrategy;
667  if ( !readHandlePprChanStrategy.range(range_PprChanStrategy) ) {
668  ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandlePprChanStrategy.key());
669  return StatusCode::FAILURE;
670  }
671 
672  ATH_MSG_DEBUG("Range of input is PprChanMu" << range_PprChanStrategy);
673  writeHandlePprConditions.addDependency(range_PprChanStrategy);
674 
675 
676 
677  }
678  else {
679 
680 
681 
682 
683  condAttrListCollectionMapCond[ keyPprChanCalib ] = readCdo_PprChanCalib;
684  condAttrListCollectionMapCond[ m_pprChanDefaults.key() ] = readCdo_PprChanDefaults;
685  writeCdoPprConditions->makeTransient(condAttrListCollectionMapCond);
686  writeHandlePprConditions.addDependency(range_PprChanCalib);
687 
688  ATH_MSG_DEBUG("Entering to strategy.empty() option");
689  ATH_MSG_DEBUG("PprChanCalib folder " << keyPprChanCalib );
690 
691 
692  }
693 
694 
695 
696 
697 
698  if (writeHandlePprConditions.record(std::move(writeCdoPprConditions)).isFailure()) {
699  ATH_MSG_FATAL("Could not record " << writeHandlePprConditions.key()
700  << " into Conditions Store");
701  return StatusCode::FAILURE;
702  }
703 
704 
705 
706 
707 
708 
709 
710  ATH_MSG_DEBUG("recorded new " << writeHandleDisTowers.key() << " with range " << writeHandleDisTowers.getRange() << " into Conditions Store");
711  ATH_MSG_DEBUG("recorded new " << writeHandleDerRunPars.key() << " with range " << writeHandleDerRunPars.getRange() << " into Conditions Store");
712  ATH_MSG_DEBUG("recorded new " << writeHandlePprChanCalib.key() << " with range " << writeHandlePprChanCalib.getRange() << " into Conditions Store");
713  ATH_MSG_DEBUG("recorded new " << writeHandlePprChanDefaults.key() << " with range " << writeHandlePprChanDefaults.getRange() << " into Conditions Store");
714  ATH_MSG_DEBUG("recorded new " << writeHandlePpmFineTimeRefs.key() << " with range " << writeHandlePpmFineTimeRefs.getRange() << " into Conditions Store");
715  ATH_MSG_DEBUG("recorded new " << writeHandleRunParameters.key() << " with range " << writeHandleRunParameters.getRange() << " into Conditions Store");
716  ATH_MSG_DEBUG("recorded new " << writeHandlePprChanStrategy.key() << " with range " << writeHandlePprChanStrategy.getRange() << " into Conditions Store");
717  ATH_MSG_DEBUG("recorded new " << writeHandlePpmDeadChannels.key() << " with range " << writeHandlePpmDeadChannels.getRange() << " into Conditions Store");
718  ATH_MSG_DEBUG("recorded new " << writeHandlePprConditions.key() << " with range " << writeHandlePprConditions.getRange() << " into Conditions Store");
719  ATH_MSG_DEBUG("recorded new " << writeHandleReadoutConfig.key() << " with range " << writeHandleReadoutConfig.getRange() << " into Conditions Store");
720  ATH_MSG_DEBUG("recorded new " << writeHandleReadoutConfigJSON.key() << " with range " << writeHandleReadoutConfigJSON.getRange() << " into Conditions Store");
721  ATH_MSG_DEBUG("recorded new " << writeHandlePprDisabledChannel.key() << " with range " << writeHandlePprDisabledChannel.getRange() << " into Conditions Store");
722 
723 
724 
725  return StatusCode::SUCCESS;
726 
727 }

◆ 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()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ initialize()

StatusCode L1CaloCondAlg::initialize ( )
overridevirtual

Definition at line 25 of file L1CaloCondAlg.cxx.

26 {
27 
28  ATH_MSG_DEBUG( "initialize " << name() );
29 
30 
31 
32  // Disabled Towers
33  ATH_CHECK( m_disabledTowers.initialize() );
34  ATH_CHECK( m_disabledTowersContainer.initialize() );
35 
36 
37  // Derived Run Pars
38  ATH_CHECK(m_derivedRunPars.initialize() );
39  ATH_CHECK(m_derivedRunParsContainer.initialize() );
40 
41  // Ppr Channel Calib
42  ATH_CHECK(m_pprChanCalibContainer.initialize() );
43 
44  // Cond Container
45  ATH_CHECK(m_pprConditionsContainer.initialize() );
46 
47 
48  // Ppr Defaults Calib
49  ATH_CHECK(m_pprChanDefaults.initialize() );
50  ATH_CHECK(m_pprChanDefaultsContainer.initialize() );
51 
52  // Ppr FineTime Refs
53  ATH_CHECK(m_ppmFineTimeRefs.initialize() );
54  ATH_CHECK(m_ppmFineTimeRefsContainer.initialize() );
55 
56  // Run Parameters
57  ATH_CHECK(m_runParameters.initialize() );
58  ATH_CHECK(m_runParametersContainer.initialize() );
59 
60  // PprChanStrategy
61  ATH_CHECK(m_pprChanStrategy.initialize() );
62  ATH_CHECK(m_pprChanStrategyContainer.initialize() );
63 
64 
65  // Ppm Dead Channels
66  ATH_CHECK(m_ppmDeadChannels.initialize() );
67  ATH_CHECK(m_ppmDeadChannelsContainer.initialize() );
68 
69 
70  // Disabled Channel
71  ATH_CHECK(m_pprDisabledChannelContainer.initialize() );
72 
73  // Readout Config
74  ATH_CHECK( m_readoutConfig.initialize() );
75  ATH_CHECK( m_readoutConfigContainer.initialize() );
76 
77  // Readout Config JSON (Run 3)
78  ATH_CHECK( m_readoutConfigJSON.initialize() );
79  ATH_CHECK( m_readoutConfigContainerJSON.initialize() );
80 
81  static const std::string pprFolderBase = "/TRIGGER/L1Calo/V2/Calibration/";
82  // Should correspond with the PprKeys enum.
83  for (const std::string s : { "PprChanCalib", "PprChanCommon",
84  "PprChanHighMu", "PprChanLowMu" })
85  {
86  m_physicsKeys.push_back (pprFolderBase + "Physics/" + s);
87  m_calib1Keys.push_back (pprFolderBase + "Calib1/" + s);
88  m_calib2Keys.push_back (pprFolderBase + "Calib2/" + s);
89  }
90  ATH_CHECK ( m_physicsKeys.initialize (m_usePhysicsRegime) );
91  ATH_CHECK( m_calib1Keys.initialize (m_useCalib1Regime) );
92  ATH_CHECK( m_calib2Keys.initialize (m_useCalib2Regime) );
93 
94  return StatusCode::SUCCESS;
95 
96 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
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_calib1Keys

SG::ReadCondHandleKeyArray<CondAttrListCollection> L1CaloCondAlg::m_calib1Keys { this, "Calib1Keys", {}, "" }
private

Definition at line 62 of file L1CaloCondAlg.h.

◆ m_calib2Keys

SG::ReadCondHandleKeyArray<CondAttrListCollection> L1CaloCondAlg::m_calib2Keys { this, "Calib2Keys", {}, "" }
private

Definition at line 64 of file L1CaloCondAlg.h.

◆ m_derivedRunPars

SG::ReadCondHandleKey<CondAttrListCollection> L1CaloCondAlg::m_derivedRunPars { this, "DerivedRunPars", "/TRIGGER/L1Calo/V1/Conditions/DerivedRunPars", "DerivedRunPars"}
private

Definition at line 69 of file L1CaloCondAlg.h.

◆ m_derivedRunParsContainer

SG::WriteCondHandleKey<L1CaloDerivedRunParsContainer> L1CaloCondAlg::m_derivedRunParsContainer {this, "OutputKeyDerRunsPars", "L1CaloDerivedRunParsContainer"}
private

Definition at line 85 of file L1CaloCondAlg.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_disabledTowers

SG::ReadCondHandleKey<CondAttrListCollection> L1CaloCondAlg::m_disabledTowers { this, "DisabledTowers", "/TRIGGER/L1Calo/V1/Conditions/DisabledTowers", "DisabledTowers" }
private

Definition at line 68 of file L1CaloCondAlg.h.

◆ m_disabledTowersContainer

SG::WriteCondHandleKey<L1CaloDisabledTowersContainer> L1CaloCondAlg::m_disabledTowersContainer {this,"OutputKeyDisTowers","L1CaloDisabledTowersContainer"}
private

Definition at line 84 of file L1CaloCondAlg.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_physicsKeys

SG::ReadCondHandleKeyArray<CondAttrListCollection> L1CaloCondAlg::m_physicsKeys { this, "PhysicsKeys", {}, "" }
private

Definition at line 60 of file L1CaloCondAlg.h.

◆ m_ppmDeadChannels

SG::ReadCondHandleKey<CondAttrListCollection> L1CaloCondAlg::m_ppmDeadChannels { this, "PpmDeadChannels", "/TRIGGER/L1Calo/V1/Calibration/PpmDeadChannels","PpmDeadChannels" }
private

Definition at line 70 of file L1CaloCondAlg.h.

◆ m_ppmDeadChannelsContainer

SG::WriteCondHandleKey<L1CaloPpmDeadChannelsContainer> L1CaloCondAlg::m_ppmDeadChannelsContainer { this, "OutputKeyPpmDeadChannels", "L1CaloPpmDeadChannelsContainer"}
private

Definition at line 91 of file L1CaloCondAlg.h.

◆ m_ppmFineTimeRefs

SG::ReadCondHandleKey<CondAttrListCollection> L1CaloCondAlg::m_ppmFineTimeRefs { this, "PpmFineTimeRefs" ,"/TRIGGER/L1Calo/V1/References/FineTimeReferences", "PpmFineTimeRefs"}
private

Definition at line 71 of file L1CaloCondAlg.h.

◆ m_ppmFineTimeRefsContainer

SG::WriteCondHandleKey<L1CaloPpmFineTimeRefsContainer> L1CaloCondAlg::m_ppmFineTimeRefsContainer { this, "OutputKeyTimeRefs", "L1CaloPpmFineTimeRefsContainer"}
private

Definition at line 88 of file L1CaloCondAlg.h.

◆ m_pprChanCalibContainer

SG::WriteCondHandleKey<L1CaloPprChanCalibContainer> L1CaloCondAlg::m_pprChanCalibContainer { this, "OutputKeyPPr", "L1CaloPprChanCalibContainer"}
private

Definition at line 86 of file L1CaloCondAlg.h.

◆ m_pprChanDefaults

SG::ReadCondHandleKey<CondAttrListCollection> L1CaloCondAlg::m_pprChanDefaults { this, "PprChanDefaults" ,"/TRIGGER/L1Calo/V2/Configuration/PprChanDefaults", "PprChanDefaults"}
private

Definition at line 77 of file L1CaloCondAlg.h.

◆ m_pprChanDefaultsContainer

SG::WriteCondHandleKey<L1CaloPprChanDefaultsContainer> L1CaloCondAlg::m_pprChanDefaultsContainer { this, "OutputKeyDef", "L1CaloPprChanDefaultsContainer"}
private

Definition at line 87 of file L1CaloCondAlg.h.

◆ m_pprChanStrategy

SG::ReadCondHandleKey<CondAttrListCollection> L1CaloCondAlg::m_pprChanStrategy { this, "PprChanStrategy", "/TRIGGER/L1Calo/V2/Configuration/PprChanStrategy", "PprChanStrategy"}
private

Definition at line 78 of file L1CaloCondAlg.h.

◆ m_pprChanStrategyContainer

SG::WriteCondHandleKey<L1CaloPprChanStrategyContainer> L1CaloCondAlg::m_pprChanStrategyContainer { this, "OutputKeyPprChanStrategy", "L1CaloPprChanStrategyContainer"}
private

Definition at line 90 of file L1CaloCondAlg.h.

◆ m_pprConditionsContainer

SG::WriteCondHandleKey<L1CaloPprConditionsContainerRun2> L1CaloCondAlg::m_pprConditionsContainer { this, "OutputKeyPprConditionsRun2", "L1CaloPprConditionsContainerRun2"}
private

Definition at line 92 of file L1CaloCondAlg.h.

◆ m_pprDisabledChannelContainer

SG::WriteCondHandleKey<L1CaloPprDisabledChannelContainerRun2> L1CaloCondAlg::m_pprDisabledChannelContainer { this, "OutputKeyDisabledChannelRun2", "L1CaloPprDisabledChannelContainerRun2"}
private

Definition at line 93 of file L1CaloCondAlg.h.

◆ m_readoutConfig

SG::ReadCondHandleKey<CondAttrListCollection> L1CaloCondAlg::m_readoutConfig { this, "ReadoutConfig", "/TRIGGER/L1Calo/V2/Configuration/ReadoutConfig", "ReadoutConfig"}
private

Definition at line 79 of file L1CaloCondAlg.h.

◆ m_readoutConfigContainer

SG::WriteCondHandleKey<L1CaloReadoutConfigContainer> L1CaloCondAlg::m_readoutConfigContainer { this, "OutputKeyReadoutConfig", "L1CaloReadoutConfigContainer"}
private

Definition at line 94 of file L1CaloCondAlg.h.

◆ m_readoutConfigContainerJSON

SG::WriteCondHandleKey<L1CaloReadoutConfigContainerJSON> L1CaloCondAlg::m_readoutConfigContainerJSON { this, "OutputKeyReadoutConfigJSON", "L1CaloReadoutConfigContainerJSON"}
private

Definition at line 95 of file L1CaloCondAlg.h.

◆ m_readoutConfigJSON

SG::ReadCondHandleKey<CondAttrListCollection> L1CaloCondAlg::m_readoutConfigJSON { this, "ReadoutConfigJSON", "/TRIGGER/L1Calo/V2/Configuration/ReadoutConfigJSON", "ReadoutConfigJSON"}
private

Definition at line 80 of file L1CaloCondAlg.h.

◆ m_runParameters

SG::ReadCondHandleKey<CondAttrListCollection> L1CaloCondAlg::m_runParameters { this, "RunParameters" ,"/TRIGGER/L1Calo/V1/Conditions/RunParameters", "RunParameters"}
private

Definition at line 72 of file L1CaloCondAlg.h.

◆ m_runParametersContainer

SG::WriteCondHandleKey<L1CaloRunParametersContainer> L1CaloCondAlg::m_runParametersContainer { this, "OutputKeyRunParameters", "L1CaloRunParametersContainer"}
private

Definition at line 89 of file L1CaloCondAlg.h.

◆ m_strategy

Gaudi::Property<std::string> L1CaloCondAlg::m_strategy {this,"strategy","","String-> empty, HighMu or LowMu"}
private

Definition at line 43 of file L1CaloCondAlg.h.

◆ m_timingRegime

Gaudi::Property<std::string> L1CaloCondAlg::m_timingRegime {this,"timingRegime","","String-> Calib1, Calib2 or Physics"}
private

Definition at line 42 of file L1CaloCondAlg.h.

◆ m_useCalib1Regime

Gaudi::Property<bool> L1CaloCondAlg::m_useCalib1Regime { this, "UseCalib1Regime", false, "Allow use of Calib1 timing regime" }
private

Definition at line 47 of file L1CaloCondAlg.h.

◆ m_useCalib2Regime

Gaudi::Property<bool> L1CaloCondAlg::m_useCalib2Regime { this, "UseCalib2Regime", false, "Allow use of Calib2 timing regime" }
private

Definition at line 49 of file L1CaloCondAlg.h.

◆ m_usePhysicsRegime

Gaudi::Property<bool> L1CaloCondAlg::m_usePhysicsRegime { this, "UsePhysicsRegime", false, "Allow use of Physics timing regime" }
private

Definition at line 45 of file L1CaloCondAlg.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
xAOD::strategy
strategy
Definition: L2CombinedMuon_v1.cxx:107
L1CaloCondAlg::m_pprChanCalibContainer
SG::WriteCondHandleKey< L1CaloPprChanCalibContainer > m_pprChanCalibContainer
Definition: L1CaloCondAlg.h:86
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
L1CaloCondAlg::m_pprChanDefaultsContainer
SG::WriteCondHandleKey< L1CaloPprChanDefaultsContainer > m_pprChanDefaultsContainer
Definition: L1CaloCondAlg.h:87
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
L1CaloCondAlg::m_readoutConfigContainerJSON
SG::WriteCondHandleKey< L1CaloReadoutConfigContainerJSON > m_readoutConfigContainerJSON
Definition: L1CaloCondAlg.h:95
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
L1CaloCondAlg::m_readoutConfigJSON
SG::ReadCondHandleKey< CondAttrListCollection > m_readoutConfigJSON
Definition: L1CaloCondAlg.h:80
skel.it
it
Definition: skel.GENtoEVGEN.py:423
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
L1CaloCondAlg::m_pprChanStrategy
SG::ReadCondHandleKey< CondAttrListCollection > m_pprChanStrategy
Definition: L1CaloCondAlg.h:78
SG::HandleKeyArray
Definition: StoreGate/StoreGate/HandleKeyArray.h:38
L1CaloCondAlg::m_pprDisabledChannelContainer
SG::WriteCondHandleKey< L1CaloPprDisabledChannelContainerRun2 > m_pprDisabledChannelContainer
Definition: L1CaloCondAlg.h:93
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
L1CaloCondAlg::PPRCHANHIGHMU
@ PPRCHANHIGHMU
Definition: L1CaloCondAlg.h:56
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
CondAttrListCollection
This class is a collection of AttributeLists where each one is associated with a channel number....
Definition: CondAttrListCollection.h:52
L1CaloCondAlg::m_strategy
Gaudi::Property< std::string > m_strategy
Definition: L1CaloCondAlg.h:43
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
L1CaloCondAlg::m_pprChanStrategyContainer
SG::WriteCondHandleKey< L1CaloPprChanStrategyContainer > m_pprChanStrategyContainer
Definition: L1CaloCondAlg.h:90
L1CaloCondAlg::m_useCalib1Regime
Gaudi::Property< bool > m_useCalib1Regime
Definition: L1CaloCondAlg.h:48
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
L1CaloCondAlg::m_ppmDeadChannelsContainer
SG::WriteCondHandleKey< L1CaloPpmDeadChannelsContainer > m_ppmDeadChannelsContainer
Definition: L1CaloCondAlg.h:91
L1CaloCondAlg::m_pprConditionsContainer
SG::WriteCondHandleKey< L1CaloPprConditionsContainerRun2 > m_pprConditionsContainer
Definition: L1CaloCondAlg.h:92
L1CaloCondAlg::m_timingRegime
Gaudi::Property< std::string > m_timingRegime
Definition: L1CaloCondAlg.h:42
L1CaloCondAlg::m_derivedRunParsContainer
SG::WriteCondHandleKey< L1CaloDerivedRunParsContainer > m_derivedRunParsContainer
Definition: L1CaloCondAlg.h:85
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
L1CaloCondAlg::m_useCalib2Regime
Gaudi::Property< bool > m_useCalib2Regime
Definition: L1CaloCondAlg.h:50
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
L1CaloCondAlg::m_derivedRunPars
SG::ReadCondHandleKey< CondAttrListCollection > m_derivedRunPars
Definition: L1CaloCondAlg.h:69
L1CaloCondAlg::m_calib2Keys
SG::ReadCondHandleKeyArray< CondAttrListCollection > m_calib2Keys
Definition: L1CaloCondAlg.h:65
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
L1CaloCondAlg::m_runParameters
SG::ReadCondHandleKey< CondAttrListCollection > m_runParameters
Definition: L1CaloCondAlg.h:72
L1CaloCondAlg::m_physicsKeys
SG::ReadCondHandleKeyArray< CondAttrListCollection > m_physicsKeys
Definition: L1CaloCondAlg.h:61
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
L1CaloCondAlg::m_calib1Keys
SG::ReadCondHandleKeyArray< CondAttrListCollection > m_calib1Keys
Definition: L1CaloCondAlg.h:63
L1CaloCondAlg::m_usePhysicsRegime
Gaudi::Property< bool > m_usePhysicsRegime
Definition: L1CaloCondAlg.h:46
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
L1CaloCondAlg::m_disabledTowersContainer
SG::WriteCondHandleKey< L1CaloDisabledTowersContainer > m_disabledTowersContainer
Definition: L1CaloCondAlg.h:84
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
L1CaloCondAlg::PPRCHANCALIB
@ PPRCHANCALIB
Definition: L1CaloCondAlg.h:54
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
L1CaloCondAlg::PPRCHANLOWMU
@ PPRCHANLOWMU
Definition: L1CaloCondAlg.h:57
L1CaloCondAlg::m_readoutConfig
SG::ReadCondHandleKey< CondAttrListCollection > m_readoutConfig
Definition: L1CaloCondAlg.h:79
SG::ReadCondHandleKey< CondAttrListCollection >
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
a
TList * a
Definition: liststreamerinfos.cxx:10
h
L1CaloCondAlg::m_readoutConfigContainer
SG::WriteCondHandleKey< L1CaloReadoutConfigContainer > m_readoutConfigContainer
Definition: L1CaloCondAlg.h:94
L1CaloCondAlg::m_ppmFineTimeRefs
SG::ReadCondHandleKey< CondAttrListCollection > m_ppmFineTimeRefs
Definition: L1CaloCondAlg.h:71
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CondAttrListCollection::const_iterator
ChanAttrListMap::const_iterator const_iterator
Definition: CondAttrListCollection.h:63
L1CaloCondAlg::m_disabledTowers
SG::ReadCondHandleKey< CondAttrListCollection > m_disabledTowers
Definition: L1CaloCondAlg.h:68
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
L1CaloCondAlg::m_runParametersContainer
SG::WriteCondHandleKey< L1CaloRunParametersContainer > m_runParametersContainer
Definition: L1CaloCondAlg.h:89
L1CaloCondAlg::m_pprChanDefaults
SG::ReadCondHandleKey< CondAttrListCollection > m_pprChanDefaults
Definition: L1CaloCondAlg.h:77
L1CaloCondAlg::m_ppmDeadChannels
SG::ReadCondHandleKey< CondAttrListCollection > m_ppmDeadChannels
Definition: L1CaloCondAlg.h:70
SG::WriteCondHandle
Definition: WriteCondHandle.h:26
L1CaloCondAlg::PPRCHANCOMMON
@ PPRCHANCOMMON
Definition: L1CaloCondAlg.h:55
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
L1CaloCondAlg::m_ppmFineTimeRefsContainer
SG::WriteCondHandleKey< L1CaloPpmFineTimeRefsContainer > m_ppmFineTimeRefsContainer
Definition: L1CaloCondAlg.h:88
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
Generated on Fri Jul 5 2024 21:48:54 for ATLAS Offline Software by   doxygen 1.8.18