Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Types | Public Member Functions | Protected Member Functions | Static Protected Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
TRTToTCondAlg Class Reference

#include <TRTToTCondAlg.h>

Inheritance diagram for TRTToTCondAlg:
Collaboration diagram for TRTToTCondAlg:

Public Types

enum  EDataBaseType { kOldDB, kNewDB, kNewDBOccCorr }
 

Public Member Functions

 TRTToTCondAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TRTToTCondAlg () override
 
virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
virtual StatusCode finalize () override
 
StatusCode update1 (TRTDedxcorrection &Dedxcorrection, const CondAttrListVec *channel_values)
 
StatusCode update2 (TRTDedxcorrection &Dedxcorrection, const CondAttrListCollection *attrListColl)
 
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...
 

Static Protected Member Functions

static void updateOldDBParameters (TRTDedxcorrection &Dedxcollection, std::map< std::string, std::vector< float > > &result_dict)
 
static void updateNewDBParameters (TRTDedxcorrection &Dedxcorrection, std::map< std::string, std::vector< float > > &result_dict)
 
static void updateOccupancyCorrectionParameters (TRTDedxcorrection &Dedxcorrection, std::map< std::string, std::vector< float > > &result_dict)
 

Private Types

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

SG::ReadCondHandleKey< CondAttrListVec > m_VecReadKey {this,"ToTVecReadKey","/TRT/Calib/ToT/ToTVectors","ToTVec in-key"}
 
SG::ReadCondHandleKey< CondAttrListCollection > m_ValReadKey {this,"ToTValReadKey","/TRT/Calib/ToT/ToTValue","ToTVal in-key"}
 
SG::WriteCondHandleKey< TRTDedxcorrection > m_WriteKey {this,"ToTWriteKey","Dedxcorrection","Dedxcorrection out-key"}
 
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
 

Static Private Attributes

static const std::vector< std::string > m_dictNamesOldDB
 
static const std::vector< std::string > m_dictNamesNewDB
 

Detailed Description

Definition at line 19 of file TRTToTCondAlg.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

◆ EDataBaseType

enum TRTToTCondAlg::EDataBaseType
Enumerator
kOldDB 
kNewDB 
kNewDBOccCorr 

Definition at line 28 of file TRTToTCondAlg.h.

28 {kOldDB,kNewDB,kNewDBOccCorr};

Constructor & Destructor Documentation

◆ TRTToTCondAlg()

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

Definition at line 23 of file TRTToTCondAlg.cxx.

25  : ::AthAlgorithm(name,pSvcLocator)
26 {}

◆ ~TRTToTCondAlg()

TRTToTCondAlg::~TRTToTCondAlg ( )
overridevirtualdefault

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

Definition at line 41 of file TRTToTCondAlg.cxx.

42 {
43  ATH_MSG_DEBUG("execute " << name());
44 
45  // ____________ Construct Write Cond Handle and check its validity ____________
46 
47  SG::WriteCondHandle<TRTDedxcorrection> writeHandle{m_WriteKey};
48 
49  // Do we have a valid Write Cond Handle for current time?
50  if(writeHandle.isValid()) {
51  ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid."
52  << ". In theory this should not be called, but may happen"
53  << " if multiple concurrent events are being processed out of order.");
54 
55  return StatusCode::SUCCESS;
56  }
57 
58 
59 
60  // ____________ Compute the Write Cond Object (Dedxcorrections) ____________
61  SG::ReadCondHandle<CondAttrListVec> readVecHandle{m_VecReadKey};
62  const CondAttrListVec* channel_values{*readVecHandle};
63  if(channel_values==nullptr) {
64  ATH_MSG_ERROR(" Problem reading TRT/Calib/ToT/ToTVectors cond object");
65  return StatusCode::FAILURE;
66  }
67 
68  // ____________ Construct new Write Cond Object ____________
69  auto Dedxcorrection = std::make_unique<TRTDedxcorrection>();
70 
71  ATH_CHECK( update1( *Dedxcorrection, channel_values ) );
72 
73  SG::ReadCondHandle<CondAttrListCollection> readValHandle{m_ValReadKey};
74  const CondAttrListCollection* attrListColl{*readValHandle};
75  if(attrListColl==nullptr) {
76  ATH_MSG_ERROR(" Problem reading TRT/Calib/ToT/ToTValue cond object");
77  return StatusCode::FAILURE;
78  }
79  ATH_CHECK( update2( *Dedxcorrection, attrListColl ) );
80 
81 
82  //__________ Assign range of Dedxcorrection to that of the ReadHandle___________
83  EventIDRange rangeW;
84 
85  if(!readVecHandle.range(rangeW)) {
86  ATH_MSG_ERROR("Failed to retrieve validity range for " << readVecHandle.key());
87  return StatusCode::FAILURE;
88  }
89 
90  // Record CDO
91  if(writeHandle.record(rangeW,std::move(Dedxcorrection)).isFailure()) {
92  ATH_MSG_ERROR("Could not record " << writeHandle.key()
93  << " with EventRange " << rangeW
94  << " into Conditions Store");
95  return StatusCode::FAILURE;
96  }
97 
98 
99  return StatusCode::SUCCESS;
100 }

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

◆ finalize()

StatusCode TRTToTCondAlg::finalize ( )
overridevirtual

Definition at line 102 of file TRTToTCondAlg.cxx.

103 {
104  ATH_MSG_DEBUG("finalize " << name());
105  return StatusCode::SUCCESS;
106 }

◆ initialize()

StatusCode TRTToTCondAlg::initialize ( )
overridevirtual

Definition at line 29 of file TRTToTCondAlg.cxx.

30 {
31  // Read key
32  ATH_CHECK( m_VecReadKey.initialize() );
33  ATH_CHECK( m_ValReadKey.initialize() );
34 
35  // Register write handle
36  ATH_CHECK( m_WriteKey.initialize() );
37 
38  return StatusCode::SUCCESS;
39 }

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

◆ update1()

StatusCode TRTToTCondAlg::update1 ( TRTDedxcorrection &  Dedxcorrection,
const CondAttrListVec *  channel_values 
)

Definition at line 108 of file TRTToTCondAlg.cxx.

108  {
109  // Determine which version of DB constants to use based on the length
110  ATH_MSG_DEBUG("Size of channel_values[]="<<channel_values->size()<<"");
111  int dataBaseType = kNewDB;
112  if(channel_values->size()<19695) {
113  dataBaseType = kOldDB;
114  } else if (channel_values->size()>19695) {
115  dataBaseType = kNewDBOccCorr;
116  }
117  const std::vector<std::string>& dictNames = (dataBaseType==kOldDB) ? m_dictNamesOldDB : m_dictNamesNewDB;
118 
119  std::map<std::string,std::vector<float> > resultDict;
120  // Read all vectors of values from DB entries and store by name in map
121  CondAttrListVec::const_iterator channel = channel_values->begin();
122  unsigned int channelIndex = 0;
123  std::vector<float> currentArrayValues = {};
124  for (; channel != channel_values->end(); ++channel) {
125  if (channelIndex != channel->first){
126  if(!currentArrayValues.empty()) resultDict[dictNames[channelIndex]] = currentArrayValues;
127  channelIndex = channel->first;
128  currentArrayValues.clear();
129  }
130  currentArrayValues.push_back(channel->second["array_value"].data<float>());
131  }
132  resultDict[dictNames[channelIndex]] = std::move(currentArrayValues);
133 
134  // update dEdx corrections from dictionary depending on the DB version
135  if(dataBaseType==kNewDB or dataBaseType==kNewDBOccCorr) {
136  updateNewDBParameters(Dedxcorrection, resultDict);
137  ATH_MSG_DEBUG ("update():: Reading new database is done!");
138  if (dataBaseType==kNewDBOccCorr) {
139  updateOccupancyCorrectionParameters(Dedxcorrection, resultDict);
140  ATH_MSG_DEBUG ("update():: Reading new database with occupancy correction is done!");
141  }
142  return StatusCode::SUCCESS;
143  } else if(dataBaseType==kOldDB) {
144  ATH_MSG_WARNING ("update():: Old COOL database tag!");
145  updateOldDBParameters(Dedxcorrection, resultDict);
146  ATH_MSG_DEBUG ("update():: Reading old database is done!");
147  return StatusCode::SUCCESS;
148  }
149  return StatusCode::FAILURE;
150 }

◆ update2()

StatusCode TRTToTCondAlg::update2 ( TRTDedxcorrection &  Dedxcorrection,
const CondAttrListCollection *  attrListColl 
)

Definition at line 482 of file TRTToTCondAlg.cxx.

482  {
483 
484  int dataBaseType = kNewDB;
485  if(attrListColl->size() < 2) dataBaseType = kOldDB;
486 
487  CondAttrListCollection::const_iterator first = attrListColl->begin();
488  CondAttrListCollection::const_iterator last = attrListColl->end();
489 
490  if(dataBaseType==kNewDB) {
491  for (int index=0; first != last; ++first,++index) {
492  const coral::AttributeList& attrList = (*first).second;
493  Dedxcorrection.paraDivideByLengthDedxP1[index] = attrList["paraL_dEdx_p1"].data<float>();
494  Dedxcorrection.paraDivideByLengthDedxP2[index] = attrList["paraL_dEdx_p2"].data<float>();
495  Dedxcorrection.paraDivideByLengthDedxP3[index] = attrList["paraL_dEdx_p3"].data<float>();
496  Dedxcorrection.paraDivideByLengthDedxP4[index] = attrList["paraL_dEdx_p4"].data<float>();
497  Dedxcorrection.paraDivideByLengthDedxP5[index] = attrList["paraL_dEdx_p5"].data<float>();
498 
499  Dedxcorrection.paraDedxP1[index] = attrList["para_dEdx_p1"].data<float>();
500  Dedxcorrection.paraDedxP2[index] = attrList["para_dEdx_p2"].data<float>();
501  Dedxcorrection.paraDedxP3[index] = attrList["para_dEdx_p3"].data<float>();
502  Dedxcorrection.paraDedxP4[index] = attrList["para_dEdx_p4"].data<float>();
503  Dedxcorrection.paraDedxP5[index] = attrList["para_dEdx_p5"].data<float>();
504 
505  Dedxcorrection.normOffsetData[index] = attrList["norm_offset_data"].data<float>();
506  Dedxcorrection.normSlopeTot[index] = attrList["norm_slope_tot"].data<float>();
507  Dedxcorrection.normSlopeTotDivideByLength[index] = attrList["norm_slope_totl"].data<float>();
508  Dedxcorrection.normOffsetTot[index] = attrList["norm_offset_tot"].data<float>();
509  Dedxcorrection.normOffsetTotDivideByLength[index] = attrList["norm_offset_totl"].data<float>();
510  Dedxcorrection.normNzero[index]=attrList["norm_nzero"].data<int>();
511  }
512  } else {
513  ATH_MSG_WARNING ("update2():: Old COOL database tag!");
514  // return update2_Old();
515  for (; first != last; ++first) {
516  const coral::AttributeList& attrList = (*first).second;
517  for(int gasType=0; gasType<3; gasType++) {
518  Dedxcorrection.paraDivideByLengthDedxP1[gasType] = attrList["paraL_dEdx_p1"].data<float>();
519  Dedxcorrection.paraDivideByLengthDedxP2[gasType] = attrList["paraL_dEdx_p2"].data<float>();
520  Dedxcorrection.paraDivideByLengthDedxP3[gasType] = attrList["paraL_dEdx_p3"].data<float>();
521  Dedxcorrection.paraDivideByLengthDedxP4[gasType] = attrList["paraL_dEdx_p4"].data<float>();
522  Dedxcorrection.paraDivideByLengthDedxP5[gasType] = attrList["paraL_dEdx_p5"].data<float>();
523 
524  Dedxcorrection.paraDedxP1[gasType] = attrList["para_dEdx_p1"].data<float>();
525  Dedxcorrection.paraDedxP2[gasType] = attrList["para_dEdx_p2"].data<float>();
526  Dedxcorrection.paraDedxP3[gasType] = attrList["para_dEdx_p3"].data<float>();
527  Dedxcorrection.paraDedxP4[gasType] = attrList["para_dEdx_p4"].data<float>();
528  Dedxcorrection.paraDedxP5[gasType] = attrList["para_dEdx_p5"].data<float>();
529 
530  Dedxcorrection.normOffsetData[gasType] = attrList["norm_offset_data"].data<float>();
531  Dedxcorrection.normSlopeTot[gasType] = attrList["norm_slope_tot"].data<float>();
532  Dedxcorrection.normSlopeTotDivideByLength[gasType] = attrList["norm_slope_totl"].data<float>();
533  Dedxcorrection.normOffsetTot[gasType] = attrList["norm_offset_tot"].data<float>();
534  Dedxcorrection.normOffsetTotDivideByLength[gasType] = attrList["norm_offset_totl"].data<float>();
535  Dedxcorrection.normNzero[gasType]=attrList["norm_nzero"].data<int>();
536  }
537  }
538  }
539 
540  return StatusCode::SUCCESS;
541 }

◆ updateNewDBParameters()

void TRTToTCondAlg::updateNewDBParameters ( TRTDedxcorrection &  Dedxcorrection,
std::map< std::string, std::vector< float > > &  result_dict 
)
staticprotected

Definition at line 168 of file TRTToTCondAlg.cxx.

168  {
169  // fill Xenon +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
170  for (unsigned int ind=0; ind < 4; ++ind) {
171  Dedxcorrection.resolution[0][ind]=result_dict["resolution_Xe"][ind];
172  }
173 
174  for (unsigned int ind=0; ind < 4; ++ind) {
175  Dedxcorrection.resolutionElectron[0][ind]=result_dict["resolution_e_Xe"][ind];
176  }
177 
178  for (unsigned int ind=0; ind < 3240; ++ind) {
179  Dedxcorrection.paraLongCorrRZMC[0][ind]=result_dict["para_long_corrRZ_Xe"][ind];
180  }
181 
182  for (unsigned int ind=0; ind < 216; ++ind) {
183  Dedxcorrection.paraShortCorrRZMC[0][ind]=result_dict["para_short_corrRZ_Xe"][ind];
184  }
185 
186  for (unsigned int ind=0; ind < 630; ++ind) {
187  Dedxcorrection.paraLongCorrRZDivideByLengthMC[0][ind]=result_dict["para_long_corrRZLXe"][ind];
188  }
189 
190  for (unsigned int ind=0; ind < 63; ++ind) {
191  Dedxcorrection.paraShortCorrRZDivideByLengthMC[0][ind]=result_dict["para_short_corrRZLXe"][ind];
192  }
193 
194  for (unsigned int ind=0; ind < 252; ++ind) {
195  Dedxcorrection.paraEndCorrRZDivideByLengthMC[0][ind]=result_dict["para_end_corrRZLXe"][ind];
196  }
197 
198  for (unsigned int ind=0; ind < 3240; ++ind) {
199  Dedxcorrection.paraLongCorrRZ[0][ind]=result_dict["para_long_corrRZ_Xe"][ind];
200  }
201 
202  for (unsigned int ind=0; ind < 216; ++ind) {
203  Dedxcorrection.paraShortCorrRZ[0][ind]=result_dict["para_short_corrRZ_Xe"][ind];
204  }
205 
206  for (unsigned int ind=0; ind < 630; ++ind) {
207  Dedxcorrection.paraLongCorrRZDivideByLengthDATA[0][ind]=result_dict["para_long_corrRZLXe"][ind];
208  }
209 
210  for (unsigned int ind=0; ind < 63; ++ind) {
211  Dedxcorrection.paraShortCorrRZDivideByLengthDATA[0][ind]=result_dict["para_short_corrRZLXe"][ind];
212  }
213 
214  for (unsigned int ind=0; ind < 252; ++ind) {
215  Dedxcorrection.paraEndCorrRZDivideByLengthDATA[0][ind]=result_dict["para_end_corrRZLXe"][ind];
216  }
217 
218  for (unsigned int ind=0; ind < 336; ++ind) {
219  Dedxcorrection.paraEndCorrRZ[0][ind]=result_dict["para_end_corrRZ_Xe"][ind];
220  }
221 
222  for (unsigned int ind=0; ind < 336; ++ind) {
223  Dedxcorrection.paraEndCorrRZMC[0][ind]=result_dict["para_end_corrRZ_Xe"][ind];
224  }
225 
226 
227 
228  for (unsigned int ind=0; ind < 560; ++ind) {
229  Dedxcorrection.paraEndMimicToXeDATA[0][ind]=result_dict["para_end_mimicToXeXe"][ind];
230  }
231  for (unsigned int ind=0; ind < 560; ++ind) {
232  Dedxcorrection.paraEndMimicToXeMC[0][ind]=result_dict["para_end_mimicToXeXe"][ind];
233  }
234  for (unsigned int ind=0; ind < 180; ++ind) {
235  Dedxcorrection.paraShortMimicToXeDATA[0][ind]=result_dict["para_short_mimicToXeXe"][ind];
236  }
237  for (unsigned int ind=0; ind < 180; ++ind) {
238  Dedxcorrection.paraShortMimicToXeMC[0][ind]=result_dict["para_short_mimicToXeXe"][ind];
239  }
240  for (unsigned int ind=0; ind < 1080; ++ind) {
241  Dedxcorrection.paraLongMimicToXeDATA[0][ind]=result_dict["para_long_mimicToXeXe"][ind];
242  }
243  for (unsigned int ind=0; ind < 1080; ++ind) {
244  Dedxcorrection.paraLongMimicToXeMC[0][ind]=result_dict["para_long_mimicToXeXe"][ind];
245  }
246 
247  // fill Argon +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
248  for (unsigned int ind=0; ind < 4; ++ind) {
249  Dedxcorrection.resolution[1][ind]=result_dict["resolution_Ar"][ind];
250  }
251 
252  for (unsigned int ind=0; ind < 4; ++ind) {
253  Dedxcorrection.resolutionElectron[1][ind]=result_dict["resolution_e_Ar"][ind];
254  }
255 
256  for (unsigned int ind=0; ind < 3240; ++ind) {
257  Dedxcorrection.paraLongCorrRZMC[1][ind]=result_dict["para_long_corrRZ_Ar"][ind];
258  }
259 
260  for (unsigned int ind=0; ind < 216; ++ind) {
261  Dedxcorrection.paraShortCorrRZMC[1][ind]=result_dict["para_short_corrRZ_Ar"][ind];
262  }
263 
264  for (unsigned int ind=0; ind < 630; ++ind) {
265  Dedxcorrection.paraLongCorrRZDivideByLengthMC[1][ind]=result_dict["para_long_corrRZLAr"][ind];
266  }
267 
268  for (unsigned int ind=0; ind < 63; ++ind) {
269  Dedxcorrection.paraShortCorrRZDivideByLengthMC[1][ind]=result_dict["para_short_corrRZLAr"][ind];
270  }
271 
272  for (unsigned int ind=0; ind < 252; ++ind) {
273  Dedxcorrection.paraEndCorrRZDivideByLengthMC[1][ind]=result_dict["para_end_corrRZLAr"][ind];
274  }
275 
276  for (unsigned int ind=0; ind < 3240; ++ind) {
277  Dedxcorrection.paraLongCorrRZ[1][ind]=result_dict["para_long_corrRZ_Ar"][ind];
278  }
279 
280  for (unsigned int ind=0; ind < 216; ++ind) {
281  Dedxcorrection.paraShortCorrRZ[1][ind]=result_dict["para_short_corrRZ_Ar"][ind];
282  }
283 
284  for (unsigned int ind=0; ind < 630; ++ind) {
285  Dedxcorrection.paraLongCorrRZDivideByLengthDATA[1][ind]=result_dict["para_long_corrRZLAr"][ind];
286  }
287 
288  for (unsigned int ind=0; ind < 63; ++ind) {
289  Dedxcorrection.paraShortCorrRZDivideByLengthDATA[1][ind]=result_dict["para_short_corrRZLAr"][ind];
290  }
291 
292  for (unsigned int ind=0; ind < 252; ++ind) {
293  Dedxcorrection.paraEndCorrRZDivideByLengthDATA[1][ind]=result_dict["para_end_corrRZLAr"][ind];
294  }
295 
296  for (unsigned int ind=0; ind < 336; ++ind) {
297  Dedxcorrection.paraEndCorrRZ[1][ind]=result_dict["para_end_corrRZ_Ar"][ind];
298  }
299 
300  for (unsigned int ind=0; ind < 336; ++ind) {
301  Dedxcorrection.paraEndCorrRZMC[1][ind]=result_dict["para_end_corrRZ_Ar"][ind];
302  }
303 
304 
305 
306  for (unsigned int ind=0; ind < 560; ++ind) {
307  Dedxcorrection.paraEndMimicToXeDATA[1][ind]=result_dict["para_end_mimicToXeAr"][ind];
308  }
309  for (unsigned int ind=0; ind < 560; ++ind) {
310  Dedxcorrection.paraEndMimicToXeMC[1][ind]=result_dict["para_end_mimicToXeAr"][ind];
311  }
312  for (unsigned int ind=0; ind < 180; ++ind) {
313  Dedxcorrection.paraShortMimicToXeDATA[1][ind]=result_dict["para_short_mimicToXeAr"][ind];
314  }
315  for (unsigned int ind=0; ind < 180; ++ind) {
316  Dedxcorrection.paraShortMimicToXeMC[1][ind]=result_dict["para_short_mimicToXeAr"][ind];
317  }
318  for (unsigned int ind=0; ind < 1080; ++ind) {
319  Dedxcorrection.paraLongMimicToXeDATA[1][ind]=result_dict["para_long_mimicToXeAr"][ind];
320  }
321  for (unsigned int ind=0; ind < 1080; ++ind) {
322  Dedxcorrection.paraLongMimicToXeMC[1][ind]=result_dict["para_long_mimicToXeAr"][ind];
323  }
324 
325  // fill Krypton +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
326  for (unsigned int ind=0; ind < 4; ++ind) {
327  Dedxcorrection.resolution[2][ind]=result_dict["resolution_Kr"][ind];
328  }
329 
330  for (unsigned int ind=0; ind < 4; ++ind) {
331  Dedxcorrection.resolutionElectron[2][ind]=result_dict["resolution_e_Kr"][ind];
332  }
333 
334  for (unsigned int ind=0; ind < 3240; ++ind) {
335  Dedxcorrection.paraLongCorrRZMC[2][ind]=result_dict["para_long_corrRZ_Kr"][ind];
336  }
337 
338  for (unsigned int ind=0; ind < 216; ++ind) {
339  Dedxcorrection.paraShortCorrRZMC[2][ind]=result_dict["para_short_corrRZ_Kr"][ind];
340  }
341 
342  for (unsigned int ind=0; ind < 630; ++ind) {
343  Dedxcorrection.paraLongCorrRZDivideByLengthMC[2][ind]=result_dict["para_long_corrRZLKr"][ind];
344  }
345 
346  for (unsigned int ind=0; ind < 63; ++ind) {
347  Dedxcorrection.paraShortCorrRZDivideByLengthMC[2][ind]=result_dict["para_short_corrRZLKr"][ind];
348  }
349 
350  for (unsigned int ind=0; ind < 252; ++ind) {
351  Dedxcorrection.paraEndCorrRZDivideByLengthMC[2][ind]=result_dict["para_end_corrRZLKr"][ind];
352  }
353 
354  for (unsigned int ind=0; ind < 3240; ++ind) {
355  Dedxcorrection.paraLongCorrRZ[2][ind]=result_dict["para_long_corrRZ_Kr"][ind];
356  }
357 
358  for (unsigned int ind=0; ind < 216; ++ind) {
359  Dedxcorrection.paraShortCorrRZ[2][ind]=result_dict["para_short_corrRZ_Kr"][ind];
360  }
361 
362  for (unsigned int ind=0; ind < 630; ++ind) {
363  Dedxcorrection.paraLongCorrRZDivideByLengthDATA[2][ind]=result_dict["para_long_corrRZLKr"][ind];
364  }
365 
366  for (unsigned int ind=0; ind < 63; ++ind) {
367  Dedxcorrection.paraShortCorrRZDivideByLengthDATA[2][ind]=result_dict["para_short_corrRZLKr"][ind];
368  }
369 
370  for (unsigned int ind=0; ind < 252; ++ind) {
371  Dedxcorrection.paraEndCorrRZDivideByLengthDATA[2][ind]=result_dict["para_end_corrRZLKr"][ind];
372  }
373 
374  for (unsigned int ind=0; ind < 336; ++ind) {
375  Dedxcorrection.paraEndCorrRZ[2][ind]=result_dict["para_end_corrRZ_Kr"][ind];
376  }
377 
378  for (unsigned int ind=0; ind < 336; ++ind) {
379  Dedxcorrection.paraEndCorrRZMC[2][ind]=result_dict["para_end_corrRZ_Kr"][ind];
380  }
381 
382 
383 
384  for (unsigned int ind=0; ind < 560; ++ind) {
385  Dedxcorrection.paraEndMimicToXeDATA[2][ind]=result_dict["para_end_mimicToXeKr"][ind];
386  }
387  for (unsigned int ind=0; ind < 560; ++ind) {
388  Dedxcorrection.paraEndMimicToXeMC[2][ind]=result_dict["para_end_mimicToXeKr"][ind];
389  }
390  for (unsigned int ind=0; ind < 180; ++ind) {
391  Dedxcorrection.paraShortMimicToXeDATA[2][ind]=result_dict["para_short_mimicToXeKr"][ind];
392  }
393  for (unsigned int ind=0; ind < 180; ++ind) {
394  Dedxcorrection.paraShortMimicToXeMC[2][ind]=result_dict["para_short_mimicToXeKr"][ind];
395  }
396  for (unsigned int ind=0; ind < 1080; ++ind) {
397  Dedxcorrection.paraLongMimicToXeDATA[2][ind]=result_dict["para_long_mimicToXeKr"][ind];
398  }
399  for (unsigned int ind=0; ind < 1080; ++ind) {
400  Dedxcorrection.paraLongMimicToXeMC[2][ind]=result_dict["para_long_mimicToXeKr"][ind];
401  }
402 }

◆ updateOccupancyCorrectionParameters()

void TRTToTCondAlg::updateOccupancyCorrectionParameters ( TRTDedxcorrection &  Dedxcorrection,
std::map< std::string, std::vector< float > > &  result_dict 
)
staticprotected

Definition at line 152 of file TRTToTCondAlg.cxx.

152  {
153  // fill occupancy calibration parameters
154  for (unsigned int ind=0; ind < TRTDedxcorrection::nParametersHitBaseddEdx; ++ind) {
155  Dedxcorrection.hitOccPar[ind]=result_dict["HitOccPar"][ind];
156  }
157  for (unsigned int ind=0; ind < TRTDedxcorrection::nParametersTrackBaseddEdx; ++ind) {
158  Dedxcorrection.trackOccPar0NoHt[ind]=result_dict["TrackOccPar0_noHT"][ind];
159  Dedxcorrection.trackOccPar1NoHt[ind]=result_dict["TrackOccPar1_noHT"][ind];
160  Dedxcorrection.trackOccPar2NoHt[ind]=result_dict["TrackOccPar2_noHT"][ind];
161 
162  Dedxcorrection.trackOccPar0[ind]=result_dict["TrackOccPar0"][ind];
163  Dedxcorrection.trackOccPar1[ind]=result_dict["TrackOccPar1"][ind];
164  Dedxcorrection.trackOccPar2[ind]=result_dict["TrackOccPar2"][ind];
165  }
166 }

◆ updateOldDBParameters()

void TRTToTCondAlg::updateOldDBParameters ( TRTDedxcorrection &  Dedxcollection,
std::map< std::string, std::vector< float > > &  result_dict 
)
staticprotected

Definition at line 406 of file TRTToTCondAlg.cxx.

406  {
407  for(int gasType = 0; gasType<3; gasType++) { // loop over gas types
408  for (unsigned int ind=0; ind < 4; ++ind) {
409  Dedxcorrection.resolution[gasType][ind]=result_dict["resolution"][ind];
410  }
411 
412  for (unsigned int ind=0; ind < 4; ++ind) {
413  Dedxcorrection.resolutionElectron[gasType][ind]=result_dict["resolution_e"][ind];
414  }
415 
416  for (unsigned int ind=0; ind < 3240; ++ind) {
417  Dedxcorrection.paraLongCorrRZMC[gasType][ind]=result_dict["para_long_corrRZ_MC"][ind];
418  }
419 
420  for (unsigned int ind=0; ind < 216; ++ind) {
421  Dedxcorrection.paraShortCorrRZMC[gasType][ind]=result_dict["para_short_corrRZ_MC"][ind];
422  }
423 
424  for (unsigned int ind=0; ind < 630; ++ind) {
425  Dedxcorrection.paraLongCorrRZDivideByLengthMC[gasType][ind]=result_dict["para_long_corrRZL_MC"][ind];
426  }
427 
428  for (unsigned int ind=0; ind < 63; ++ind) {
429  Dedxcorrection.paraShortCorrRZDivideByLengthMC[gasType][ind]=result_dict["para_short_corrRZL_MC"][ind];
430  }
431 
432  for (unsigned int ind=0; ind < 252; ++ind) {
433  Dedxcorrection.paraEndCorrRZDivideByLengthMC[gasType][ind]=result_dict["para_end_corrRZL_MC"][ind];
434  }
435 
436  for (unsigned int ind=0; ind < 3240; ++ind) {
437  Dedxcorrection.paraLongCorrRZ[gasType][ind]=result_dict["para_long_corrRZ_MC"][ind];
438  }
439 
440  for (unsigned int ind=0; ind < 216; ++ind) {
441  Dedxcorrection.paraShortCorrRZ[gasType][ind]=result_dict["para_short_corrRZ_MC"][ind];
442  }
443 
444  for (unsigned int ind=0; ind < 630; ++ind) {
445  Dedxcorrection.paraLongCorrRZDivideByLengthDATA[gasType][ind]=result_dict["para_long_corrRZL_MC"][ind];
446  }
447 
448  for (unsigned int ind=0; ind < 63; ++ind) {
449  Dedxcorrection.paraShortCorrRZDivideByLengthDATA[gasType][ind]=result_dict["para_short_corrRZL_MC"][ind];
450  }
451 
452  for (unsigned int ind=0; ind < 252; ++ind) {
453  Dedxcorrection.paraEndCorrRZDivideByLengthDATA[gasType][ind]=result_dict["para_end_corrRZL_MC"][ind];
454  }
455 
456  for (unsigned int ind=0; ind < 336; ++ind) {
457  Dedxcorrection.paraEndCorrRZ[gasType][ind]=result_dict["para_end_corrRZ_MC"][ind];
458  }
459 
460  for (unsigned int ind=0; ind < 336; ++ind) {
461  Dedxcorrection.paraEndCorrRZMC[gasType][ind]=result_dict["para_end_corrRZ_MC"][ind];
462  }
463 
464  // Setting aditional corrections
465  for (unsigned int ind=0; ind < 560; ++ind) {
466  Dedxcorrection.paraEndMimicToXeMC[gasType][ind] = 1.;
467  Dedxcorrection.paraEndMimicToXeDATA[gasType][ind] = 1.;
468  }
469 
470  for (unsigned int ind=0; ind < 180; ++ind) {
471  Dedxcorrection.paraShortMimicToXeMC[gasType][ind] = 1.;
472  Dedxcorrection.paraShortMimicToXeDATA[gasType][ind] = 1.;
473  }
474 
475  for (unsigned int ind=0; ind < 1080; ++ind) {
476  Dedxcorrection.paraLongMimicToXeMC[gasType][ind] = 1.;
477  Dedxcorrection.paraLongMimicToXeDATA[gasType][ind] = 1.;
478  }
479  }
480 }

◆ 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_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_dictNamesNewDB

const std::vector< std::string > TRTToTCondAlg::m_dictNamesNewDB
staticprivate
Initial value:
= {"para_end_corrRZLXe","para_end_corrRZ_Xe","para_end_mimicToXeXe",
"para_long_corrRZLXe","para_long_corrRZ_Xe","para_long_mimicToXeXe","para_short_corrRZLXe",
"para_short_corrRZ_Xe","para_short_mimicToXeXe","resolution_Xe","resolution_e_Xe","para_end_corrRZLAr",
"para_end_corrRZ_Ar","para_end_mimicToXeAr","para_long_corrRZLAr","para_long_corrRZ_Ar",
"para_long_mimicToXeAr","para_short_corrRZLAr","para_short_corrRZ_Ar","para_short_mimicToXeAr",
"resolution_Ar","resolution_e_Ar","para_end_corrRZLKr","para_end_corrRZ_Kr","para_end_mimicToXeKr",
"para_long_corrRZLKr","para_long_corrRZ_Kr","para_long_mimicToXeKr","para_short_corrRZLKr",
"para_short_corrRZ_Kr","para_short_mimicToXeKr","resolution_Kr","resolution_e_Kr",
"HitOccPar", "TrackOccPar0", "TrackOccPar0_noHT", "TrackOccPar1", "TrackOccPar1_noHT", "TrackOccPar2", "TrackOccPar2_noHT"}

Definition at line 43 of file TRTToTCondAlg.h.

◆ m_dictNamesOldDB

const std::vector< std::string > TRTToTCondAlg::m_dictNamesOldDB
staticprivate
Initial value:
= {"resolution","resolution_e","para_long_corrRZ_MC",
"para_short_corrRZ_MC","para_end_corrRZ_MC","para_long_corrRZL_MC",
"para_short_corrRZL_MC","para_end_corrRZL_MC"}

Definition at line 42 of file TRTToTCondAlg.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_ValReadKey

SG::ReadCondHandleKey<CondAttrListCollection> TRTToTCondAlg::m_ValReadKey {this,"ToTValReadKey","/TRT/Calib/ToT/ToTValue","ToTVal in-key"}
private

Definition at line 39 of file TRTToTCondAlg.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_VecReadKey

SG::ReadCondHandleKey<CondAttrListVec> TRTToTCondAlg::m_VecReadKey {this,"ToTVecReadKey","/TRT/Calib/ToT/ToTVectors","ToTVec in-key"}
private

Definition at line 38 of file TRTToTCondAlg.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_WriteKey

SG::WriteCondHandleKey<TRTDedxcorrection> TRTToTCondAlg::m_WriteKey {this,"ToTWriteKey","Dedxcorrection","Dedxcorrection out-key"}
private

Definition at line 40 of file TRTToTCondAlg.h.

The documentation for this class was generated from the following files:
CondAttrListCollection::end
const_iterator end() const
Definition: CondAttrListCollection.h:315
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
TRTToTCondAlg::kOldDB
@ kOldDB
Definition: TRTToTCondAlg.h:28
TRTToTCondAlg::m_ValReadKey
SG::ReadCondHandleKey< CondAttrListCollection > m_ValReadKey
Definition: TRTToTCondAlg.h:39
TRTToTCondAlg::update1
StatusCode update1(TRTDedxcorrection &Dedxcorrection, const CondAttrListVec *channel_values)
Definition: TRTToTCondAlg.cxx:108
index
Definition: index.py:1
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TRTToTCondAlg::m_VecReadKey
SG::ReadCondHandleKey< CondAttrListVec > m_VecReadKey
Definition: TRTToTCondAlg.h:38
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
TRTToTCondAlg::kNewDBOccCorr
@ kNewDBOccCorr
Definition: TRTToTCondAlg.h:28
CondAttrListCollection::begin
const_iterator begin() const
Access to Chan/AttributeList pairs via iterators.
Definition: CondAttrListCollection.h:309
TRTDedxcorrection::nParametersHitBaseddEdx
static constexpr int nParametersHitBaseddEdx
Definition: TRTDedxcorrection.h:12
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
python.PyKernel.AttributeList
AttributeList
Definition: PyKernel.py:36
TRTToTCondAlg::update2
StatusCode update2(TRTDedxcorrection &Dedxcorrection, const CondAttrListCollection *attrListColl)
Definition: TRTToTCondAlg.cxx:482
TRTToTCondAlg::updateOldDBParameters
static void updateOldDBParameters(TRTDedxcorrection &Dedxcollection, std::map< std::string, std::vector< float > > &result_dict)
Definition: TRTToTCondAlg.cxx:406
CondAttrListCollection
This class is a collection of AttributeLists where each one is associated with a channel number....
Definition: CondAttrListCollection.h:52
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
CondAttrListVec::size
size_type size() const
Definition: CondAttrListVec.h:216
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TRTToTCondAlg::updateNewDBParameters
static void updateNewDBParameters(TRTDedxcorrection &Dedxcorrection, std::map< std::string, std::vector< float > > &result_dict)
Definition: TRTToTCondAlg.cxx:168
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
TRTDedxcorrection::nParametersTrackBaseddEdx
static constexpr int nParametersTrackBaseddEdx
Definition: TRTDedxcorrection.h:11
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.
CondAttrListVec
Definition: CondAttrListVec.h:31
TRTToTCondAlg::updateOccupancyCorrectionParameters
static void updateOccupancyCorrectionParameters(TRTDedxcorrection &Dedxcorrection, std::map< std::string, std::vector< float > > &result_dict)
Definition: TRTToTCondAlg.cxx:152
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
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
CondAttrListVec::end
const_iterator end() const
Definition: CondAttrListVec.h:213
TRTToTCondAlg::m_WriteKey
SG::WriteCondHandleKey< TRTDedxcorrection > m_WriteKey
Definition: TRTToTCondAlg.h:40
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
TRTToTCondAlg::m_dictNamesOldDB
static const std::vector< std::string > m_dictNamesOldDB
Definition: TRTToTCondAlg.h:42
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
CondAttrListVec::const_iterator
AttrListVec::const_iterator const_iterator
Definition: CondAttrListVec.h:36
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TRTToTCondAlg::m_dictNamesNewDB
static const std::vector< std::string > m_dictNamesNewDB
Definition: TRTToTCondAlg.h:43
CondAttrListCollection::size
size_type size() const
number of Chan/AttributeList pairs
Definition: CondAttrListCollection.h:322
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
DeMoScan.index
string index
Definition: DeMoScan.py:364
a
TList * a
Definition: liststreamerinfos.cxx:10
h
CondAttrListVec::begin
const_iterator begin() const
Definition: CondAttrListVec.h:210
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CondAttrListCollection::const_iterator
ChanAttrListMap::const_iterator const_iterator
Definition: CondAttrListCollection.h:63
Dedxcorrection
Definition: TRT_ToT_Corrections.h:9
DeMoScan.first
bool first
Definition: DeMoScan.py:536
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
TRTToTCondAlg::kNewDB
@ kNewDB
Definition: TRTToTCondAlg.h:28
SG::WriteCondHandle
Definition: WriteCondHandle.h:26
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
Generated on Mon Apr 14 2025 21:50:29 for ATLAS Offline Software by   doxygen 1.8.18