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

#include <TileDigiNoiseCalibAlg.h>

Inheritance diagram for TileDigiNoiseCalibAlg:
Collaboration diagram for TileDigiNoiseCalibAlg:

Public Member Functions

 TileDigiNoiseCalibAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TileDigiNoiseCalibAlg ()
 
virtual StatusCode initialize () override
 Only array initialization is done here All the helpers initialization is done at the first event. More...
 
virtual StatusCode execute () override
 Main method. More...
 
virtual StatusCode finalize () override
 The output ntuple is created in finalize method. More...
 
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  trigtype {
  Unknown = 0, Phys = 1, Las = 2, Ped = 4,
  Cis = 8
}
 
using Tile = TileCalibUtils
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode FirstEvt_initialize ()
 Initialization done at the first event. More...
 
StatusCode fillDigits (const TileDQstatus *theDQstatus)
 fillDigits is called at every events. More...
 
void finalDigits ()
 finalDigits is called during finalize Here the average Ped, m_lfn, m_hfn and covariance are calculated. More...
 
void StoreRunInfo (const TileDQstatus *dqStatus)
 StoreRunInfo is called only during the first event. More...
 
int digiChannel2PMT (int ros, int chan)
 
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

bool m_calibMode
 
bool m_usePMT
 
bool m_doAvgCorr
 
bool m_doRobustCov
 
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
 
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
 
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
 
ToolHandle< TileRawChannelBuilderFlatFilter > m_adderFilterAlgTool
 
TileBeamElemContByteStreamCnv * m_beamCnv
 
const TileCablingService * m_cabling
 
TileOFCorrelation * m_tileOFCorrelation
 
const TileID * m_tileID
 
const TileHWID * m_tileHWID
 
const uint32_t * m_cispar
 
std::string m_ntupleID
 
std::string m_file
 
int64_t m_treeSize
 
int m_nSamples
 
std::string m_digitsContainer
 
std::string m_beamElemContainer
 
std::string m_dspRawChannelContainer
 
double(* m_sumPed2 )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
double(* m_sumRms2 )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
double(* m_meanAmp )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
double(* m_meanAmp_ij )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
int m_evtNr
 
int(* m_evt )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
int m_time
 
int m_year
 
int m_month
 
int m_day
 
int m_yday
 
int m_hour
 
int m_min
 
int m_run
 
int m_trigType
 
uint8_t(* m_ros )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
uint8_t(* m_drawer )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
uint8_t(* m_channel )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
bool(* m_gain )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
float(* m_ped )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
float(* m_lfn )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
float(* m_hfn )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
 
float(* m_noise_cov )[Tile::MAX_DRAWER][Tile::MAX_GAIN]
 
float(* m_auto_corr )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NVALS]
 
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 46 of file TileDigiNoiseCalibAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

◆ Tile

using TileDigiNoiseCalibAlg::Tile = TileCalibUtils
private

Definition at line 124 of file TileDigiNoiseCalibAlg.h.

Member Enumeration Documentation

◆ trigtype

enum TileDigiNoiseCalibAlg::trigtype
private
Enumerator
Unknown 
Phys 
Las 
Ped 
Cis 

Definition at line 58 of file TileDigiNoiseCalibAlg.h.

58  {
59  Unknown = 0
60  , Phys = 1
61  , Las = 2
62  , Ped = 4
63  , Cis = 8
64  };

Constructor & Destructor Documentation

◆ TileDigiNoiseCalibAlg()

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

Definition at line 43 of file TileDigiNoiseCalibAlg.cxx.

44  : AthAlgorithm(name, pSvcLocator)
45  , m_beamCnv(nullptr)
46  , m_cabling(nullptr)
47  , m_tileOFCorrelation(nullptr)
48  , m_tileID(nullptr)
49  , m_tileHWID(nullptr)
50  , m_cispar(nullptr)
51 // , m_nDrawers(0)
52  , m_time(0)
53  , m_year(0)
54  , m_month(0)
55  , m_day(0)
56  , m_yday(0)
57  , m_hour(0)
58  , m_min(0)
59  , m_trigType(0)
60 {
61  declareProperty("TileBeamElemContainer", m_beamElemContainer = "TileBeamElemCnt");
62  /* declareProperty("TileRawChannelContainerFlat", m_flatRawChannelContainer = "TileRawChannelFlat");
63  declareProperty("TileRawChannelContainerFit", m_fitRawChannelContainer = ""); // don't create
64  declareProperty("TileRawChannelContainerOpt", m_optRawChannelContainer = ""); // by default */
65  declareProperty("TileRawChannelContainerDsp", m_dspRawChannelContainer = "TileRawChannelCnt");
66  declareProperty("CalibMode", m_calibMode = true);
67  declareProperty("usePMT", m_usePMT = false);
68  declareProperty("RunNumber", m_run = 0);
69  declareProperty("FileNamePrefix", m_file = "Digi_NoiseCalib");
70  declareProperty("NtupleID", m_ntupleID = "Digi_NoiseCalib");
71  declareProperty("TreeSize", m_treeSize = 16000000000LL);
72  declareProperty("NSamples", m_nSamples = 7);
73  declareProperty("DoAvgCorr", m_doAvgCorr = false);
74  declareProperty("DoRobustCov", m_doRobustCov = false);
75  declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
76 
77  m_run = 0;
78  m_evtNr = -1;
79 
80  m_sumPed2 = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
81  m_sumRms2 = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
82  m_meanAmp = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
83  m_meanAmp_ij = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_CHAN][Tile::MAX_GAIN]();
84  m_evt = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
85  m_ros = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
86  m_drawer = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
87  m_channel = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
88  m_gain = new bool[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
89  m_ped = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
90  m_lfn = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
91  m_hfn = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
92  m_noise_cov = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_GAIN]();
93  m_auto_corr = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NVALS]();
94 }

◆ ~TileDigiNoiseCalibAlg()

TileDigiNoiseCalibAlg::~TileDigiNoiseCalibAlg ( )
virtual

Definition at line 96 of file TileDigiNoiseCalibAlg.cxx.

96  {
97 
98  delete[] m_sumPed2;
99  delete[] m_sumRms2;
100  delete[] m_meanAmp;
101  delete[] m_meanAmp_ij;
102  delete[] m_evt;
103  delete[] m_ros;
104  delete[] m_drawer;
105  delete[] m_channel;
106  delete[] m_gain;
107  delete[] m_ped;
108  delete[] m_lfn;
109  delete[] m_hfn;
110  delete[] m_noise_cov;
111  delete[] m_auto_corr;
112 }

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

◆ digiChannel2PMT()

int TileDigiNoiseCalibAlg::digiChannel2PMT ( int  ros,
int  chan 
)
inlineprivate

Definition at line 72 of file TileDigiNoiseCalibAlg.h.

72  {
73  return (abs(m_cabling->channel2hole(ros, chan)) - 1);
74  }

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

Main method.

Definition at line 195 of file TileDigiNoiseCalibAlg.cxx.

195  {
196 
197  const EventContext& ctx = Gaudi::Hive::currentContext();
198  const TileDQstatus * dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
199 
200  StatusCode sc;
201  bool empty(false);
202 
203  if (m_evtNr < 0) {
204 
205  if (FirstEvt_initialize().isFailure()) {
206  ATH_MSG_ERROR( "FirstEvt_initialize failed" );
207  }
208 
209  bool calibMode = (dqStatus->calibMode() == 1);
210  if (calibMode != m_calibMode) {
211  ATH_MSG_INFO( "Calib mode from data is " );
212  ATH_MSG_INFO( " Overwriting calib mode " );
213  m_calibMode = calibMode;
214  }
215 
216  m_cispar = dqStatus->cispar();
217  StoreRunInfo(dqStatus); // done only once
218  }
219 
220  m_cispar = dqStatus->cispar();
221  if (m_evtNr % 1000 == 0)
222  ATH_MSG_WARNING( m_evtNr << " events processed so far" );
223 
224  // store TileDigits
225  if (m_nSamples > 0) sc = fillDigits (dqStatus);
226  empty &= (sc.isFailure());
227 
228  if (empty) {
229  ATH_MSG_WARNING( "Error in execute " );
230  }
231  ++m_evtNr;
232  return StatusCode::SUCCESS;
233 }

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

◆ fillDigits()

StatusCode TileDigiNoiseCalibAlg::fillDigits ( const TileDQstatus *  theDQstatus)
private

fillDigits is called at every events.

Statistics is summed for Average, RMS and covariance calculations

Definition at line 378 of file TileDigiNoiseCalibAlg.cxx.

378  {
379 /*---------------------------------------------------------*/
380 
381  SG::ReadHandle<TileDigitsContainer> digitsCnt(m_digitsContainerKey);
382  ATH_CHECK( digitsCnt.isValid() );
383 
384  TileDigitsContainer::const_iterator collItr = digitsCnt->begin();
385  TileDigitsContainer::const_iterator lastColl = digitsCnt->end();
386 
387  for (; collItr != lastColl; ++collItr) {
388 
389  TileDigitsCollection::const_iterator digitsItr = (*collItr)->begin();
390  TileDigitsCollection::const_iterator lastDigits = (*collItr)->end();
391 
392  if (digitsItr != lastDigits) { //loop over all the drawers in the data
393 
394  HWIdentifier adc_id = (*digitsItr)->adc_HWID();
395  int ros = m_tileHWID->ros(adc_id);
396  // IMPORTANT! ros for TileCal partitions goes like LBA=1 LBC=2 EBA=3 EBC=4
397 
398  int drawer = m_tileHWID->drawer(adc_id);
399  // IMPORTANT! Drawers are from 0 to 63!
400 
401  double mean_tmp[48][16][2] = {};
402 
403 
404  for (; digitsItr != lastDigits; ++digitsItr) { // loop over all channels in the drawer
405 
406  adc_id = (*digitsItr)->adc_HWID();
407  int chan = m_tileHWID->channel(adc_id);
408  if (m_usePMT) {
409  chan = digiChannel2PMT(ros, chan); // IMPORTANT: 0-47 PMT format!
410  // by default we use CHANNELS.
411  // PMTs usage is possible by switching on m_usePMT
412  }
413  int gain = m_tileHWID->adc(adc_id);
414 
415  std::vector<float> vdigits = (*digitsItr)->samples();
416 
417  // Needed to calculate the AutoCorrealtion matrix at end of run
418  //m_tileOFCorrelation->RunningCorrelation(vdigits,ros-1,drawer,chan,gain,msg(),false,m_nSamples,100);
419 
420  // if (theDQstatus->isChEmpty(ros, drawer, chan)) {
421  // ATH_MSG_DEBUG( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
422  // << " channel: " << chan
423  // << " ADC: " << gain
424  // << " because empty" );
425  // continue;
426  // }
427 
428  // If DQ problem, do not fill calib ntuple
429  if (m_calibMode == 1) {// Bigain: check indivual adc's
430  if (!(theDQstatus->isAdcDQgood(ros, drawer, chan, gain))) {
431  ATH_MSG_DEBUG( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
432  << " channel: " << chan
433  << " ADC: " << gain
434  << " due to DQ error found." );
435  continue;
436  }
437  } else {// monogain, just check channel
438 
439  if (!(theDQstatus->isChanDQgood(ros, drawer, chan))) {
440  ATH_MSG_DEBUG( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
441  << " channel: " << chan
442  << " due to DQ error found." );
443  continue;
444  }
445  }
446 
447  double meansamp = 0.0;
448  double rmssamp = 0.0;
449  unsigned int dsize = vdigits.size();
450 
451  if (dsize > 16) {
452  ATH_MSG_ERROR( "length of digits vector " << dsize << " - greater than 16 !" );
453  dsize = 16;
454  }
455 
456  for (unsigned int i = 0; i < dsize; ++i) {
457  double dig = vdigits[i];
458  meansamp += dig;
459  rmssamp += dig * dig;
460  mean_tmp[chan][i][gain] = dig;
461  }
462  if (dsize > 0) {
463  m_ped[ros][drawer][chan][gain] += vdigits[0];
464  m_sumPed2[ros][drawer][chan][gain] += vdigits[0] * vdigits[0];
465 
466  if (dsize > 1) {
467  m_evt[ros][drawer][chan][gain]++;
468  meansamp /= dsize;
469  rmssamp = rmssamp / dsize - meansamp * meansamp;
470  rmssamp = (rmssamp > 0.0) ? sqrt(rmssamp * dsize / (dsize - 1)) : 0.0;
471  m_hfn[ros][drawer][chan][gain] += rmssamp;
472  m_sumRms2[ros][drawer][chan][gain] += rmssamp * rmssamp;
473  }
474  }
475 
476  // Fill event-by-event correlation values
477  if (m_doAvgCorr)
478  m_tileOFCorrelation->RunningCorrelation(vdigits, ros - 1, drawer, chan, gain, msg(), false, m_nSamples, 100);
479  else
480  m_tileOFCorrelation->Sum(vdigits, ros - 1, drawer, chan, gain, msg(), false, m_nSamples, m_doRobustCov);
481 
482  } // loop over channels
483 
484  //For cor&cov
485  for (int sample = 0; sample < m_nSamples; ++sample) {
486  for (unsigned int gain = 0; gain < TileCalibUtils::MAX_GAIN; ++gain) {
487  for (unsigned int chan_i = 0; chan_i < TileCalibUtils::MAX_CHAN; ++chan_i) {
488  m_meanAmp[ros][drawer][chan_i][gain] += mean_tmp[chan_i][sample][gain];
489  for (unsigned int chan_j = 0; chan_j < TileCalibUtils::MAX_CHAN; ++chan_j)
490  m_meanAmp_ij[ros][drawer][chan_i][chan_j][gain] += mean_tmp[chan_i][sample][gain] * mean_tmp[chan_j][sample][gain];
491  }
492  }
493  }
494  } //check if Digits in module
495  } //loop over drawers
496 
497  return StatusCode::SUCCESS;
498 }

◆ finalDigits()

void TileDigiNoiseCalibAlg::finalDigits ( )
private

finalDigits is called during finalize Here the average Ped, m_lfn, m_hfn and covariance are calculated.

Definition at line 503 of file TileDigiNoiseCalibAlg.cxx.

503  {
504 /*---------------------------------------------------------*/
505 
506 
507  // Calculate AutoCorrealtion matrix
508  // --Average calculation (Assumes matrix is Toeplitz)
509  if (m_doAvgCorr)
510  m_tileOFCorrelation->CalcRunningCorrelation(msg(), m_nSamples, 100, false);
511  // --Rigorous calculation
512  else
513  m_tileOFCorrelation->CalcCorrelation(msg(), m_nSamples, false, m_doRobustCov);
514 
515  // Needed to store autoCorrelation matrix
516  float tmpCorr[9][9] = {};
517 
518 
519  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
520  for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
521  for (unsigned int gain = 0; gain < TileCalibUtils::MAX_GAIN; ++gain) {
522  for (unsigned int chan = 0; chan < TileCalibUtils::MAX_CHAN; ++chan) {
523 
524  m_ros[ros][drawer][chan][gain] = ros;
525  m_drawer[ros][drawer][chan][gain] = drawer;
526  m_channel[ros][drawer][chan][gain] = chan;
527  m_gain[ros][drawer][chan][gain] = gain;
528 
529  if (m_evt[ros][drawer][chan][gain] > 0) {
530  int nev = m_evt[ros][drawer][chan][gain];
531  m_ped[ros][drawer][chan][gain] /= nev;
532  double Ped = m_ped[ros][drawer][chan][gain];
533  m_hfn[ros][drawer][chan][gain] /= nev;
534 
535  if (nev > 1) {
536  double PedRMS = m_sumPed2[ros][drawer][chan][gain] / nev - Ped * Ped;
537  PedRMS = m_sumPed2[ros][drawer][chan][gain] / nev - Ped * Ped;
538  PedRMS = (PedRMS > 0.0) ? sqrt(PedRMS * nev / (nev - 1)) : 0.0;
539  m_lfn[ros][drawer][chan][gain] = PedRMS;
540  }
541  }
542 
543  // Get values from AutoCorrelation matrix
544  // matrix is symmetric, so only half-retrieved and stored
545  m_tileOFCorrelation->GetCorrelation(m_nSamples, tmpCorr, ros - 1, drawer, chan, gain);
546  //std::cout << "Printing AutoCorr values: " << std::endl;
547  int nVals = 0;
548  if (m_doRobustCov){ //save 28 elements for robust method
549  for (int i = 0; i < m_nSamples; i++) {
550  for (int j = i; j < m_nSamples; j++) {
551  //std::cout << "Auto Corr [" << i << "][" << j << "]:" << tmpCorr[i][j] << std::endl;
552  //std::cout << "Auto CorrSym [" << j << "][" << i << "]:" << tmpCorr[j][i] << std::endl;
553  m_auto_corr[ros][drawer][chan][gain][nVals] = tmpCorr[i][j];
554  nVals++;
555  }
556  }
557  } else {
558  for (int i = 0; i < m_nSamples; i++) {
559  for (int j = i+1; j < m_nSamples; j++) {
560  //std::cout << "Auto Corr [" << i << "][" << j << "]:" << tmpCorr[i][j] << std::endl;
561  //std::cout << "Auto CorrSym [" << j << "][" << i << "]:" << tmpCorr[j][i] << std::endl;
562  m_auto_corr[ros][drawer][chan][gain][nVals] = tmpCorr[i][j];
563  nVals++;
564  }
565  }
566  }
567 
568  } // end chan loop
569 
570  //Calculate covariance loop over chan_i, chan_j
571  if (m_evtNr * m_nSamples > 0) {
572  //replace m_evtNr with sqrt(m_evt[ch_i]*m_evt[ch_j])
573 
574  for (unsigned int chan_i = 0; chan_i < TileCalibUtils::MAX_CHAN; ++chan_i) {
575  m_meanAmp[ros][drawer][chan_i][gain] /= m_evtNr * m_nSamples;
576  for (unsigned int chan_j = 0; chan_j < TileCalibUtils::MAX_CHAN; ++chan_j)
577  m_meanAmp_ij[ros][drawer][chan_i][chan_j][gain] /= m_evtNr * m_nSamples;
578  }
579 
580  double covar[48][48];
581  double mean_cov_ii = 0.; // mean values of covar in diag terms
582  double mean_cov_ij = 0.; // mean values of covar in off diag terms
583 
584  for (unsigned int chan_i = 0; chan_i < TileCalibUtils::MAX_CHAN; ++chan_i) {
585  for (unsigned int chan_j = 0; chan_j < TileCalibUtils::MAX_CHAN; ++chan_j) {
586  covar[chan_i][chan_j] = m_meanAmp_ij[ros][drawer][chan_i][chan_j][gain] - m_meanAmp[ros][drawer][chan_i][gain] * m_meanAmp[ros][drawer][chan_j][gain];
587 
588  if (chan_j < chan_i) {
589  mean_cov_ij += covar[chan_i][chan_j]; //LF: we take C_ij with its sign
590  }
591  }
592  mean_cov_ii += covar[chan_i][chan_i];
593  }
594 
595  if (mean_cov_ii != 0.) {
596  m_noise_cov[ros][drawer][gain] = (2. * mean_cov_ij) / (mean_cov_ii * 47.); //(2*cov_ij/(48*47))/(cov_ii/48)
597 
598  } else {
599  m_noise_cov[ros][drawer][gain] = 0.;
600  }
601 
602  }
603  }
604  }
605  }
606 }

◆ finalize()

StatusCode TileDigiNoiseCalibAlg::finalize ( )
overridevirtual

The output ntuple is created in finalize method.

Definition at line 236 of file TileDigiNoiseCalibAlg.cxx.

236  {
237 
238  ATH_MSG_INFO( "Finalizing TileDigiNoiseCalibAlg" );
239 
240  finalDigits();
241 
242  std::ostringstream sStr;
243  std::string trig_str;
244 
245  if (m_trigType == Phys) trig_str = "Phys";
246  else if (m_trigType == Las) trig_str = "Las";
247  else if (m_trigType == Ped) trig_str = "Ped";
248  else if (m_trigType == Cis) trig_str = "Cis";
249  else {
250  ATH_MSG_WARNING( "Unknown trigger type " << m_trigType );
251  trig_str = "Unk";
252  }
253  sStr << m_file << "_" << m_run << "_" << trig_str << ".root";
254  m_file = sStr.str();
255  ATH_MSG_INFO( "Writing calibrations to file " << m_file );
256 
257  // Create output file: for now creating file for just this
258  // algorithm; want to add to ntuple file eventually??
259  TFile* fout = new TFile(m_file.c_str(), "recreate");
260 
261  // Create tree with branches
262  TTree* t = new TTree(m_ntupleID.c_str(), "TileCalib-Ntuple");
263 
264  t->Branch("RunNumber", &m_run, "RunNumber/I");
265  t->Branch("TrigType", &m_trigType, "TrigType/I");
266  t->Branch("Time", &m_time, "Time/I");
267  t->Branch("Year", &m_year, "Year/I");
268  t->Branch("Month", &m_month, "Month/I");
269  t->Branch("Day", &m_day, "Day/I");
270  t->Branch("YDay", &m_yday, "YDay/I");
271  t->Branch("Hour", &m_hour, "Hour/I");
272  t->Branch("Min", &m_min, "Min/I");
273  t->Branch("nSamples", &m_nSamples, "nSamples/I");
274  t->Branch("nEvt", &m_evtNr, "nEvt/I"); // events processed
275  t->Branch("ros", *m_ros, "ros[5][64][48][2]/b");
276  t->Branch("drawer", *m_drawer, "drawer[5][64][48][2]/b");
277  t->Branch("channel", *m_channel, "channel[5][64][48][2]/b");
278  t->Branch("gain", *m_gain, "gain[5][64][48][2]/O");
279  t->Branch("EvtGood", *m_evt, "Evt[5][64][48][2]/I"); // events used in the noise calculation for every channel
280  t->Branch("ped", *m_ped, "ped[5][64][48][2]/F");
281  t->Branch("lfn", *m_lfn, "lfn[5][64][48][2]/F");
282  t->Branch("hfn", *m_hfn, "hfn[5][64][48][2]/F");
283  t->Branch("noise_cov", *m_noise_cov, "noise_cov[5][64][2]/F");
284  // AutoCorrelation Matrix: Store only non-diagonal half of symmetric matrix
285  t->Branch("auto_corr", *m_auto_corr, "auto_corr[5][64][48][2][36]/F");
286 
287  // Fill with current values (i.e. tree will have only one entry for this whole run)
288 
289  t->Fill();
290  t->Write();
291 
292  fout->Close();
293 
294  return StatusCode::SUCCESS;
295 }

◆ FirstEvt_initialize()

StatusCode TileDigiNoiseCalibAlg::FirstEvt_initialize ( )
private

Initialization done at the first event.

All the helpers and data dependent variables are initialized here

Definition at line 131 of file TileDigiNoiseCalibAlg.cxx.

131  {
132 
133  // find TileCablingService
134  m_cabling = TileCablingService::getInstance();
135 
136  // retrieve TileID helper from det store
137  CHECK( detStore()->retrieve(m_tileID) );
138 
139  CHECK( detStore()->retrieve(m_tileHWID) );
140 
141  CHECK( m_adderFilterAlgTool.retrieve() );
142 
143  StatusCode sc;
144  sc &= m_adderFilterAlgTool->setProperty("TileRawChannelContainer", "TileAdderFlat");
145  sc &= m_adderFilterAlgTool->setProperty("calibrateEnergy", "true");
146  sc &= m_adderFilterAlgTool->setProperty("PedStart", "0");
147  sc &= m_adderFilterAlgTool->setProperty("PedLength", "1");
148  sc &= m_adderFilterAlgTool->setProperty("PedOffset", "0");
149  sc &= m_adderFilterAlgTool->setProperty("SignalStart", "1");
150  sc &= m_adderFilterAlgTool->setProperty("SignalLength", "15");
151  sc &= m_adderFilterAlgTool->setProperty("FilterLength", "5");
152  sc &= m_adderFilterAlgTool->setProperty("FrameLength", "16");
153  sc &= m_adderFilterAlgTool->setProperty("DeltaCutLo", "9.5");
154  sc &= m_adderFilterAlgTool->setProperty("DeltaCutHi", "9.5");
155  sc &= m_adderFilterAlgTool->setProperty("RMSCutLo", "1.0");
156  sc &= m_adderFilterAlgTool->setProperty("RMSCutHi", "1.0");
157 
158  if (sc.isFailure()) {
159  ATH_MSG_ERROR("Failure setting properties of " << m_adderFilterAlgTool);
160  return StatusCode::FAILURE;
161  }
162 
163  m_tileOFCorrelation = new TileOFCorrelation();
164  m_tileOFCorrelation->SetCorrelationZero(msg(), m_nSamples);
165 
166  ATH_MSG_INFO( "calibMode " << m_calibMode );
167  ATH_MSG_INFO( "number of samples " << m_nSamples );
168 
169  // set event number to 0 before first event
170  m_evtNr = 0;
171 
172  if (m_evtNr == 0) {
173  if (m_beamElemContainer.length() > 0) {
174  ServiceHandle<IConversionSvc> cnvSvc("ByteStreamCnvSvc", "");
175  if (cnvSvc.retrieve().isFailure()) {
176  ATH_MSG_ERROR( " Can't get ByteStreamCnvSvc " );
177  m_beamCnv = nullptr;
178  } else {
179  m_beamCnv = dynamic_cast<TileBeamElemContByteStreamCnv *>(cnvSvc->converter(ClassID_traits<TileBeamElemContainer>::ID()));
180  if (m_beamCnv == nullptr) {
181  ATH_MSG_ERROR( " Can't get TileBeamElemContByteStreamCnv " );
182  }
183  }
184 
185  } else {
186  m_beamCnv = nullptr;
187  }
188  }
189 
190  ATH_MSG_INFO( "initialization completed" );
191  return StatusCode::SUCCESS;
192 }

◆ initialize()

StatusCode TileDigiNoiseCalibAlg::initialize ( )
overridevirtual

Only array initialization is done here All the helpers initialization is done at the first event.

Definition at line 116 of file TileDigiNoiseCalibAlg.cxx.

116  {
117 
118  CHECK( m_dqStatusKey.initialize() );
119 
120  if (!m_eventInfoKey.key().empty()) {
121  ATH_CHECK( m_eventInfoKey.initialize() );
122  }
123  // TileDigitsContainer initialization
124  ATH_CHECK( m_digitsContainerKey.initialize() );
125 
126  return StatusCode::SUCCESS;
127 }

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

◆ StoreRunInfo()

void TileDigiNoiseCalibAlg::StoreRunInfo ( const TileDQstatus *  dqStatus)
private

StoreRunInfo is called only during the first event.

Definition at line 298 of file TileDigiNoiseCalibAlg.cxx.

298  {
299  if (not dqStatus){
300  m_time = 0;
301  m_year = 0;
302  m_month = 0;
303  m_day = 0;
304  m_yday = 0;
305  m_hour = 0;
306  m_min = 0;
307  m_trigType = 0;
308  ATH_MSG_WARNING( "TileDigiNoiseCalibAlg::StoreRunInfo : dqStatus pointer is null" );
309  return;
310  }
311  if (dqStatus->calibMode() == 1 && m_beamElemContainer.length() > 0) {// Bigain can use cispar
312  if (m_beamCnv) {
313  // std::cout << "LUCA m_time= "<< m_time << " bc_time_seconds= "<< m_beamCnv->eventFragment()->bc_time_seconds() <<
314  // " bc_time_nanoseconds= " << m_beamCnv->eventFragment()->bc_time_nanoseconds() << std::endl;
315  if (m_beamCnv->validBeamFrag()) {
316  m_run = m_beamCnv->robFragment()->rod_run_no(); // take it from beam ROD header
317  } else {
318  m_run = 0;
319  }
320  } else
321  m_run = 0;
322 
323  if (m_cispar) {
324  m_time = m_cispar[10]; //time in sc from 1970
325  m_trigType = m_cispar[12];
326  } else {
327  m_time = 0;
328  m_year = 0;
329  m_month = 0;
330  m_day = 0;
331  m_yday = 0;
332  m_hour = 0;
333  m_min = 0;
334  m_trigType = 0;
335  }
336  } else {// monogain can use eventinfo
337 
338  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
339  if ( !eventInfo.isValid() ) {
340  ATH_MSG_ERROR( "No EventInfo object found! Can't read run number!" );
341  m_run = 0;
342  m_time = 0;
343  m_trigType = 0;
344  } else {
345  m_run = eventInfo->runNumber();
346  m_time = eventInfo->timeStamp();
347  if (!(eventInfo->eventType(xAOD::EventInfo::IS_CALIBRATION))) // if not calibration, physics
348  m_trigType = 1;
349  else
350  m_trigType = 0;
351  }
352 
353  }
354 
355  if (m_time != 0) {
356  struct tm t;
357  time_t t_time = m_time;
358  localtime_r(&t_time, &t);
359  m_year = t.tm_year + 1900;
360  m_month = t.tm_mon + 1;
361  m_day = t.tm_mday;
362  m_yday = t.tm_yday + 1;
363  m_hour = t.tm_hour;
364  m_min = t.tm_min;
365  } else {
366  m_year = 0;
367  m_month = 0;
368  m_day = 0;
369  m_yday = 0;
370  m_hour = 0;
371  m_min = 0;
372  }
373 }

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

ToolHandle<TileRawChannelBuilderFlatFilter> TileDigiNoiseCalibAlg::m_adderFilterAlgTool
private
Initial value:
{this,
"TileAdderFlatFilter","TileRawChannelBuilderFlatFilter/TileAdderFlatFilter","Tile adder flat filter"}

Definition at line 97 of file TileDigiNoiseCalibAlg.h.

◆ m_auto_corr

float(* TileDigiNoiseCalibAlg::m_auto_corr)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NVALS]
private

Definition at line 153 of file TileDigiNoiseCalibAlg.h.

◆ m_beamCnv

TileBeamElemContByteStreamCnv* TileDigiNoiseCalibAlg::m_beamCnv
private

Definition at line 99 of file TileDigiNoiseCalibAlg.h.

◆ m_beamElemContainer

std::string TileDigiNoiseCalibAlg::m_beamElemContainer
private

Definition at line 118 of file TileDigiNoiseCalibAlg.h.

◆ m_cabling

const TileCablingService* TileDigiNoiseCalibAlg::m_cabling
private

Definition at line 100 of file TileDigiNoiseCalibAlg.h.

◆ m_calibMode

bool TileDigiNoiseCalibAlg::m_calibMode
private

Definition at line 77 of file TileDigiNoiseCalibAlg.h.

◆ m_channel

uint8_t(* TileDigiNoiseCalibAlg::m_channel)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 147 of file TileDigiNoiseCalibAlg.h.

◆ m_cispar

const uint32_t* TileDigiNoiseCalibAlg::m_cispar
private

Definition at line 107 of file TileDigiNoiseCalibAlg.h.

◆ m_day

int TileDigiNoiseCalibAlg::m_day
private

Definition at line 139 of file TileDigiNoiseCalibAlg.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_digitsContainer

std::string TileDigiNoiseCalibAlg::m_digitsContainer
private

Definition at line 117 of file TileDigiNoiseCalibAlg.h.

◆ m_digitsContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileDigiNoiseCalibAlg::m_digitsContainerKey
private
Initial value:
{this,
"TileDigitsContainer", "TileDigitsCnt", "Tile digits container"}

Definition at line 91 of file TileDigiNoiseCalibAlg.h.

◆ m_doAvgCorr

bool TileDigiNoiseCalibAlg::m_doAvgCorr
private

Definition at line 84 of file TileDigiNoiseCalibAlg.h.

◆ m_doRobustCov

bool TileDigiNoiseCalibAlg::m_doRobustCov
private

Definition at line 88 of file TileDigiNoiseCalibAlg.h.

◆ m_dqStatusKey

SG::ReadHandleKey<TileDQstatus> TileDigiNoiseCalibAlg::m_dqStatusKey
private

Definition at line 90 of file TileDigiNoiseCalibAlg.h.

◆ m_drawer

uint8_t(* TileDigiNoiseCalibAlg::m_drawer)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 146 of file TileDigiNoiseCalibAlg.h.

◆ m_dspRawChannelContainer

std::string TileDigiNoiseCalibAlg::m_dspRawChannelContainer
private

Definition at line 122 of file TileDigiNoiseCalibAlg.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> TileDigiNoiseCalibAlg::m_eventInfoKey
private
Initial value:
{this,
"EventInfo", "EventInfo", "EventInfo key"}

Definition at line 93 of file TileDigiNoiseCalibAlg.h.

◆ m_evt

int(* TileDigiNoiseCalibAlg::m_evt)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 133 of file TileDigiNoiseCalibAlg.h.

◆ m_evtNr

int TileDigiNoiseCalibAlg::m_evtNr
private

Definition at line 132 of file TileDigiNoiseCalibAlg.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_file

std::string TileDigiNoiseCalibAlg::m_file
private

Definition at line 111 of file TileDigiNoiseCalibAlg.h.

◆ m_gain

bool(* TileDigiNoiseCalibAlg::m_gain)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 148 of file TileDigiNoiseCalibAlg.h.

◆ m_hfn

float(* TileDigiNoiseCalibAlg::m_hfn)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 151 of file TileDigiNoiseCalibAlg.h.

◆ m_hour

int TileDigiNoiseCalibAlg::m_hour
private

Definition at line 141 of file TileDigiNoiseCalibAlg.h.

◆ m_lfn

float(* TileDigiNoiseCalibAlg::m_lfn)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 150 of file TileDigiNoiseCalibAlg.h.

◆ m_meanAmp

double(* TileDigiNoiseCalibAlg::m_meanAmp)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 128 of file TileDigiNoiseCalibAlg.h.

◆ m_meanAmp_ij

double(* TileDigiNoiseCalibAlg::m_meanAmp_ij)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 129 of file TileDigiNoiseCalibAlg.h.

◆ m_min

int TileDigiNoiseCalibAlg::m_min
private

Definition at line 142 of file TileDigiNoiseCalibAlg.h.

◆ m_month

int TileDigiNoiseCalibAlg::m_month
private

Definition at line 138 of file TileDigiNoiseCalibAlg.h.

◆ m_noise_cov

float(* TileDigiNoiseCalibAlg::m_noise_cov)[Tile::MAX_DRAWER][Tile::MAX_GAIN]
private

Definition at line 152 of file TileDigiNoiseCalibAlg.h.

◆ m_nSamples

int TileDigiNoiseCalibAlg::m_nSamples
private

Definition at line 113 of file TileDigiNoiseCalibAlg.h.

◆ m_ntupleID

std::string TileDigiNoiseCalibAlg::m_ntupleID
private

Definition at line 110 of file TileDigiNoiseCalibAlg.h.

◆ m_ped

float(* TileDigiNoiseCalibAlg::m_ped)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 149 of file TileDigiNoiseCalibAlg.h.

◆ m_ros

uint8_t(* TileDigiNoiseCalibAlg::m_ros)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 145 of file TileDigiNoiseCalibAlg.h.

◆ m_run

int TileDigiNoiseCalibAlg::m_run
private

Definition at line 143 of file TileDigiNoiseCalibAlg.h.

◆ m_sumPed2

double(* TileDigiNoiseCalibAlg::m_sumPed2)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 126 of file TileDigiNoiseCalibAlg.h.

◆ m_sumRms2

double(* TileDigiNoiseCalibAlg::m_sumRms2)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
private

Definition at line 127 of file TileDigiNoiseCalibAlg.h.

◆ m_tileHWID

const TileHWID* TileDigiNoiseCalibAlg::m_tileHWID
private

Definition at line 105 of file TileDigiNoiseCalibAlg.h.

◆ m_tileID

const TileID* TileDigiNoiseCalibAlg::m_tileID
private

Definition at line 104 of file TileDigiNoiseCalibAlg.h.

◆ m_tileOFCorrelation

TileOFCorrelation* TileDigiNoiseCalibAlg::m_tileOFCorrelation
private

Definition at line 101 of file TileDigiNoiseCalibAlg.h.

◆ m_time

int TileDigiNoiseCalibAlg::m_time
private

Definition at line 136 of file TileDigiNoiseCalibAlg.h.

◆ m_treeSize

int64_t TileDigiNoiseCalibAlg::m_treeSize
private

Definition at line 112 of file TileDigiNoiseCalibAlg.h.

◆ m_trigType

int TileDigiNoiseCalibAlg::m_trigType
private

Definition at line 144 of file TileDigiNoiseCalibAlg.h.

◆ m_usePMT

bool TileDigiNoiseCalibAlg::m_usePMT
private

Definition at line 80 of file TileDigiNoiseCalibAlg.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_yday

int TileDigiNoiseCalibAlg::m_yday
private

Definition at line 140 of file TileDigiNoiseCalibAlg.h.

◆ m_year

int TileDigiNoiseCalibAlg::m_year
private

Definition at line 137 of file TileDigiNoiseCalibAlg.h.

The documentation for this class was generated from the following files:
TileBeamElemContByteStreamCnv::validBeamFrag
bool validBeamFrag() const
Definition: TileBeamElemContByteStreamCnv.h:67
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileDigiNoiseCalibAlg::m_treeSize
int64_t m_treeSize
Definition: TileDigiNoiseCalibAlg.h:112
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TileDigiNoiseCalibAlg::m_usePMT
bool m_usePMT
Definition: TileDigiNoiseCalibAlg.h:80
TileOFCorrelation::SetCorrelationZero
void SetCorrelationZero(MsgStream &log, int dignum)
Definition: TileOFCorrelation.cxx:78
TileOFCorrelation::CalcRunningCorrelation
void CalcRunningCorrelation(MsgStream &log, int dignum, int chthres, bool flag_7to9)
Definition: TileOFCorrelation.cxx:334
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
TileDQstatus::isChanDQgood
bool isChanDQgood(int partition, int drawer, int ch) const
returns status of single channel (if bigain, returns AND of ADCs' status
Definition: TileDQstatus.cxx:240
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TileDigiNoiseCalibAlg::m_sumRms2
double(* m_sumRms2)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:127
TileDQstatus::calibMode
uint32_t calibMode() const
Calibration mode.
Definition: TileDQstatus.h:148
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
TileDigiNoiseCalibAlg::m_adderFilterAlgTool
ToolHandle< TileRawChannelBuilderFlatFilter > m_adderFilterAlgTool
Definition: TileDigiNoiseCalibAlg.h:97
xAOD::EventInfo_v1::IS_CALIBRATION
@ IS_CALIBRATION
true: calibration, false: physics
Definition: EventInfo_v1.h:155
TileOFCorrelation::GetCorrelation
void GetCorrelation(int dignum, float tmpCorr[][9], int ros, int drawer, int chan, int gain)
Definition: TileOFCorrelation.cxx:385
TileBeamElemContByteStreamCnv::robFragment
const eformat::ROBFragment< const uint32_t * > * robFragment() const
Definition: TileBeamElemContByteStreamCnv.h:66
TileDigiNoiseCalibAlg::m_file
std::string m_file
Definition: TileDigiNoiseCalibAlg.h:111
TileOFCorrelation::CalcCorrelation
void CalcCorrelation(MsgStream &log, int dignum, bool flag_7to9, bool doRobustCov)
Definition: TileOFCorrelation.cxx:176
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
TileDigiNoiseCalibAlg::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: TileDigiNoiseCalibAlg.h:93
TileOFCorrelation::RunningCorrelation
void RunningCorrelation(std::vector< float > &digits, int ros, int drawer, int channel, int gain, MsgStream &log, bool debug, int &dignum, int chthres)
Definition: TileOFCorrelation.cxx:262
TileDigiNoiseCalibAlg::m_calibMode
bool m_calibMode
Definition: TileDigiNoiseCalibAlg.h:77
TileDigiNoiseCalibAlg::m_cispar
const uint32_t * m_cispar
Definition: TileDigiNoiseCalibAlg.h:107
TileDigiNoiseCalibAlg::m_ped
float(* m_ped)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:149
TileDigiNoiseCalibAlg::digiChannel2PMT
int digiChannel2PMT(int ros, int chan)
Definition: TileDigiNoiseCalibAlg.h:72
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
TileDigiNoiseCalibAlg::m_day
int m_day
Definition: TileDigiNoiseCalibAlg.h:139
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
TileDigiNoiseCalibAlg::m_hour
int m_hour
Definition: TileDigiNoiseCalibAlg.h:141
HWIdentifier
Definition: HWIdentifier.h:13
TileOFCorrelation
Definition: TileOFCorrelation.h:32
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileDigiNoiseCalibAlg::Unknown
@ Unknown
Definition: TileDigiNoiseCalibAlg.h:59
TileDigiNoiseCalibAlg::Phys
@ Phys
Definition: TileDigiNoiseCalibAlg.h:60
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TileDigiNoiseCalibAlg::m_evt
int(* m_evt)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:133
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TileCalibUtils::MAX_DRAWER
static const unsigned int MAX_DRAWER
Number of drawers in ROS 1-4.
Definition: TileCalibUtils.h:139
TileDigiNoiseCalibAlg::StoreRunInfo
void StoreRunInfo(const TileDQstatus *dqStatus)
StoreRunInfo is called only during the first event.
Definition: TileDigiNoiseCalibAlg.cxx:298
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
TileDigiNoiseCalibAlg::finalDigits
void finalDigits()
finalDigits is called during finalize Here the average Ped, m_lfn, m_hfn and covariance are calculate...
Definition: TileDigiNoiseCalibAlg.cxx:503
TileDigiNoiseCalibAlg::m_gain
bool(* m_gain)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:148
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
TileDigiNoiseCalibAlg::m_tileID
const TileID * m_tileID
Definition: TileDigiNoiseCalibAlg.h:104
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
TileDigiNoiseCalibAlg::Cis
@ Cis
Definition: TileDigiNoiseCalibAlg.h:63
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
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:116
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
lumiFormat.i
int i
Definition: lumiFormat.py:85
TileDigiNoiseCalibAlg::m_ros
uint8_t(* m_ros)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:145
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
dqt_zlumi_alleff_HIST.fout
fout
Definition: dqt_zlumi_alleff_HIST.py:59
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
TileDigiNoiseCalibAlg::m_evtNr
int m_evtNr
Definition: TileDigiNoiseCalibAlg.h:132
TileDigiNoiseCalibAlg::m_beamElemContainer
std::string m_beamElemContainer
Definition: TileDigiNoiseCalibAlg.h:118
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
TileDigiNoiseCalibAlg::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileDigiNoiseCalibAlg.h:105
TileDigiNoiseCalibAlg::m_lfn
float(* m_lfn)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:150
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
TileDigiNoiseCalibAlg::m_year
int m_year
Definition: TileDigiNoiseCalibAlg.h:137
TileDigiNoiseCalibAlg::m_doRobustCov
bool m_doRobustCov
Definition: TileDigiNoiseCalibAlg.h:88
TileDigiNoiseCalibAlg::m_cabling
const TileCablingService * m_cabling
Definition: TileDigiNoiseCalibAlg.h:100
TileDigiNoiseCalibAlg::m_doAvgCorr
bool m_doAvgCorr
Definition: TileDigiNoiseCalibAlg.h:84
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
TileDigiNoiseCalibAlg::FirstEvt_initialize
StatusCode FirstEvt_initialize()
Initialization done at the first event.
Definition: TileDigiNoiseCalibAlg.cxx:131
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TileCalibUtils::MAX_ROS
static const unsigned int MAX_ROS
Number of ROSs
Definition: TileCalibUtils.h:138
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
TileDigiNoiseCalibAlg::m_ntupleID
std::string m_ntupleID
Definition: TileDigiNoiseCalibAlg.h:110
TileBeamElemContByteStreamCnv
This AthConstConverter class provides conversion from ByteStream to TileBeamElemContainer.
Definition: TileBeamElemContByteStreamCnv.h:48
TileDQstatus::isAdcDQgood
bool isAdcDQgood(int partition, int drawer, int ch, int gain) const
returns status of single ADC returns False if there are any errors
Definition: TileDQstatus.cxx:178
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
TileDigiNoiseCalibAlg::m_min
int m_min
Definition: TileDigiNoiseCalibAlg.h:142
NVALS
#define NVALS
Definition: TileDigiNoiseCalibAlg.h:39
TileDigiNoiseCalibAlg::m_nSamples
int m_nSamples
Definition: TileDigiNoiseCalibAlg.h:113
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
TileDigiNoiseCalibAlg::m_meanAmp_ij
double(* m_meanAmp_ij)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:129
TileDigiNoiseCalibAlg::Ped
@ Ped
Definition: TileDigiNoiseCalibAlg.h:62
TileDigiNoiseCalibAlg::m_sumPed2
double(* m_sumPed2)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:126
TileDQstatus::cispar
const uint32_t * cispar() const
CIS parameters.
Definition: TileDQstatus.h:152
TileDigiNoiseCalibAlg::m_noise_cov
float(* m_noise_cov)[Tile::MAX_DRAWER][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:152
TileDigiNoiseCalibAlg::m_dqStatusKey
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
Definition: TileDigiNoiseCalibAlg.h:90
TileDigiNoiseCalibAlg::m_tileOFCorrelation
TileOFCorrelation * m_tileOFCorrelation
Definition: TileDigiNoiseCalibAlg.h:101
TileDigiNoiseCalibAlg::m_auto_corr
float(* m_auto_corr)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NVALS]
Definition: TileDigiNoiseCalibAlg.h:153
TileCalibUtils::getDrawerString
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
Definition: TileCalibUtils.cxx:145
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
TileDigiNoiseCalibAlg::fillDigits
StatusCode fillDigits(const TileDQstatus *theDQstatus)
fillDigits is called at every events.
Definition: TileDigiNoiseCalibAlg.cxx:378
a
TList * a
Definition: liststreamerinfos.cxx:10
TileDigiNoiseCalibAlg::m_yday
int m_yday
Definition: TileDigiNoiseCalibAlg.h:140
h
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
LArCellNtuple.nev
int nev
Definition: LArCellNtuple.py:135
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileCablingService::channel2hole
static int channel2hole(int ros, int channel)
Definition: TileCablingService.cxx:1946
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TileDigiNoiseCalibAlg::m_run
int m_run
Definition: TileDigiNoiseCalibAlg.h:143
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
TileDigiNoiseCalibAlg::m_meanAmp
double(* m_meanAmp)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:128
TileDigiNoiseCalibAlg::m_channel
uint8_t(* m_channel)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:147
TileDigiNoiseCalibAlg::m_beamCnv
TileBeamElemContByteStreamCnv * m_beamCnv
Definition: TileDigiNoiseCalibAlg.h:99
TileDigiNoiseCalibAlg::m_digitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
Definition: TileDigiNoiseCalibAlg.h:91
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
TileDigiNoiseCalibAlg::m_time
int m_time
Definition: TileDigiNoiseCalibAlg.h:136
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
TileDigiNoiseCalibAlg::Las
@ Las
Definition: TileDigiNoiseCalibAlg.h:61
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
TileDigiNoiseCalibAlg::m_dspRawChannelContainer
std::string m_dspRawChannelContainer
Definition: TileDigiNoiseCalibAlg.h:122
TileDigiNoiseCalibAlg::m_hfn
float(* m_hfn)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:151
TileCalibUtils::MAX_CHAN
static const unsigned int MAX_CHAN
Number of channels in drawer.
Definition: TileCalibUtils.h:141
TileDigiNoiseCalibAlg::m_drawer
uint8_t(* m_drawer)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileDigiNoiseCalibAlg.h:146
TileOFCorrelation::Sum
void Sum(std::vector< float > &digits, int ros, int drawer, int channel, int gain, MsgStream &log, bool debug, int &dignum, bool doRobustCov)
Definition: TileOFCorrelation.cxx:137
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TileDigiNoiseCalibAlg::m_month
int m_month
Definition: TileDigiNoiseCalibAlg.h:138
TileDigiNoiseCalibAlg::m_trigType
int m_trigType
Definition: TileDigiNoiseCalibAlg.h:144
fitman.k
k
Definition: fitman.py:528
ServiceHandle< IConversionSvc >
TileCalibUtils::MAX_GAIN
static const unsigned int MAX_GAIN
Number of gains per channel
Definition: TileCalibUtils.h:142
Generated on Thu Nov 7 2024 22:00:13 for ATLAS Offline Software by   doxygen 1.8.18