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

#include <TileLaserLinearityCalibTool.h>

Inheritance diagram for TileLaserLinearityCalibTool:
Collaboration diagram for TileLaserLinearityCalibTool:

Public Member Functions

 TileLaserLinearityCalibTool (const std::string &type, const std::string &name, const IInterface *pParent)
 
virtual ~TileLaserLinearityCalibTool ()
 
virtual StatusCode initialize () override
 
virtual StatusCode initNtuple (int runNumber, int runType, TFile *rootfile) override
 
virtual StatusCode execute () override
 
virtual StatusCode finalizeCalculations () override
 
virtual StatusCode writeNtuple (int runNumber, int runType, TFile *rootfile) override
 
virtual StatusCode finalize () override
 
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 sysInitialize () override
 Perform system initialization for an algorithm. 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
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

int chanIsConnected (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

std::string m_toolNtuple
 
std::string m_rawChannelContainerName
 
std::string m_laserContainerName
 
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerKey
 
SG::ReadHandleKey< TileLaserObject > m_laserContainerKey
 
const TileHWID * m_tileHWID
 
const TileCablingService * m_cabling
 
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
 
int m_toolRunNo
 
int m_ADC_problem
 
int m_las_filter
 
double m_las_requ_amp
 
double m_hrate
 
double m_flow
 
double m_head_temp
 
double m_las_time
 
double(* m_LG_PMT )[NPMTS]
 
double(* m_LG_PMT_S )[NPMTS]
 
double(* m_LG_diode )[NDIODES]
 
double(* m_LG_diode_S )[NDIODES]
 
double(* m_HG_PMT )[NPMTS]
 
double(* m_HG_PMT_S )[NPMTS]
 
double(* m_HG_diode )[NDIODES]
 
double(* m_HG_diode_S )[NDIODES]
 
double(* m_mean )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
double(* m_mean_S )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
double(* m_LG_ratio )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
double(* m_LG_ratio_S )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
double(* m_LG_ratio2 )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
double(* m_LG_ratio2_S )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
double(* m_HG_ratio )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
double(* m_HG_ratio_S )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
double(* m_HG_ratio2 )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
double(* m_HG_ratio2_S )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
int(* m_entries )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
int m_PMT1_ADC_prev [2]
 
int m_PMT2_ADC_prev [2]
 
int m_first_filter
 
int m_last_evt_filter
 
int m_n_same_filt_evts
 
bool m_complete_turn
 
RunningStat *(* m_HG_diode_signal )[NDIODES]
 
RunningStat *(* m_HG_PMT_signal )[NPMTS]
 
RunningStat *(* m_LG_diode_signal )[NDIODES]
 
RunningStat *(* m_LG_PMT_signal )[NPMTS]
 
RunningStat *(* m_signal )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
RunningStat *(* m_LG_ratio_stat )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
RunningStat *(* m_LG_ratio2_stat )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
RunningStat *(* m_HG_ratio_stat )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
RunningStat *(* m_HG_ratio2_stat )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
 
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 42 of file TileLaserLinearityCalibTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TileLaserLinearityCalibTool()

TileLaserLinearityCalibTool::TileLaserLinearityCalibTool ( const std::string &  type,
const std::string &  name,
const IInterface *  pParent 
)

Definition at line 34 of file TileLaserLinearityCalibTool.cxx.

34  :
35  AthAlgTool(type, name, pParent),
36  m_tileHWID (nullptr),
37  m_cabling (nullptr),
38  m_toolRunNo(0),
39  m_ADC_problem(0),
40  m_las_filter(0),
41  m_las_requ_amp(0),
42  m_hrate(0),
43  m_flow(0),
44  m_head_temp(0),
45  m_las_time(0),
46  m_PMT1_ADC_prev(),
47  m_PMT2_ADC_prev(),
48  m_first_filter(0),
49  m_last_evt_filter(0),
50  m_n_same_filt_evts(0),
51  m_complete_turn(0)
52 {
53  declareInterface<ITileCalibTool>( this );
54  declareProperty("toolNtuple", m_toolNtuple="h3000");
55  declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
56 
57 // creating multi-dim arrays on the heap and initialize all elements to zeros
58  m_LG_PMT = new double[NFILTERS][NPMTS]();
59  m_LG_PMT_S = new double[NFILTERS][NPMTS]();
60  m_LG_diode = new double[NFILTERS][NDIODES]();
61  m_LG_diode_S = new double[NFILTERS][NDIODES]();
62  m_HG_PMT = new double[NFILTERS][NPMTS]();
63  m_HG_PMT_S = new double[NFILTERS][NPMTS]();
64  m_HG_diode = new double[NFILTERS][NDIODES]();
65  m_HG_diode_S = new double[NFILTERS][NDIODES]();
66  m_mean = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
67  m_mean_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
68  m_LG_ratio = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
69  m_LG_ratio_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
70  m_LG_ratio2 = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
71  m_LG_ratio2_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
72  m_HG_ratio = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
73  m_HG_ratio_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
74  m_HG_ratio2 = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
75  m_HG_ratio2_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
76  m_entries = new int[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
77  m_HG_diode_signal = new RunningStat*[NFILTERS][NDIODES]();
78  m_HG_PMT_signal = new RunningStat*[NFILTERS][NGAINS]();
79  m_LG_diode_signal = new RunningStat*[NFILTERS][NDIODES]();
80  m_LG_PMT_signal = new RunningStat*[NFILTERS][NGAINS]();
81  m_signal = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
82  m_LG_ratio_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
83  m_LG_ratio2_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
84  m_HG_ratio_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
85  m_HG_ratio2_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
86 }

◆ ~TileLaserLinearityCalibTool()

TileLaserLinearityCalibTool::~TileLaserLinearityCalibTool ( )
virtual

Definition at line 88 of file TileLaserLinearityCalibTool.cxx.

89 {
90 
91  delete[] m_LG_PMT;
92  delete[] m_LG_PMT_S;
93  delete[] m_LG_diode;
94  delete[] m_LG_diode_S;
95  delete[] m_HG_PMT;
96  delete[] m_HG_PMT_S;
97  delete[] m_HG_diode;
98  delete[] m_HG_diode_S;
99  delete[] m_mean;
100  delete[] m_mean_S;
101  delete[] m_LG_ratio;
102  delete[] m_LG_ratio_S;
103  delete[] m_LG_ratio2;
104  delete[] m_LG_ratio2_S;
105  delete[] m_HG_ratio;
106  delete[] m_HG_ratio_S;
107  delete[] m_HG_ratio2;
108  delete[] m_HG_ratio2_S;
109  delete[] m_entries;
110  delete[] m_HG_diode_signal;
111  delete[] m_HG_PMT_signal;
112  delete[] m_LG_diode_signal;
113  delete[] m_LG_PMT_signal;
114  delete[] m_signal;
115  delete[] m_LG_ratio_stat;
116  delete[] m_LG_ratio2_stat;
117  delete[] m_HG_ratio_stat;
118  delete[] m_HG_ratio2_stat;
119 
120 }

Member Function Documentation

◆ chanIsConnected()

int TileLaserLinearityCalibTool::chanIsConnected ( int  ros,
int  chan 
)
inlineprivate

Definition at line 136 of file TileLaserLinearityCalibTool.h.

136  {
137  if(m_cabling->channel2hole(ros,chan)<0) return 0; //negative means not connected
138  return 1;
139  }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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 TileLaserLinearityCalibTool::execute ( )
overridevirtual

Implements ITileCalibTool.

Definition at line 229 of file TileLaserLinearityCalibTool.cxx.

230 {
231  ATH_MSG_INFO ( "execute()" );
232 
233  const EventContext& ctx = Gaudi::Hive::currentContext();
234  const TileDQstatus* dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
235 
236  //
237  // Here we analyze a run with filter wheel moving
238  // we just keep the information from the first turn of the wheel
239  //
240 
241  if (m_complete_turn)
242  {
243  ATH_MSG_INFO ( "Filter wheel turn completed: stop here" );
244  return StatusCode::SUCCESS;
245  }
246 
247  ATH_MSG_DEBUG ( "Retrieving the LASER object and RawChannel" );
248 
249  SG::ReadHandle<TileRawChannelContainer> rawCnt(m_rawChannelContainerKey);
250  SG::ReadHandle<TileLaserObject> laserObj(m_laserContainerKey);
251 
252  ATH_CHECK( rawCnt.isValid() );
253  ATH_CHECK( laserObj.isValid() );
254 
255  // First we got event time (From 1/1/70)
256 
257  const uint32_t *cispar = dqStatus->cispar();
258 
259  m_las_time = static_cast<double>(cispar[10])+static_cast<double>(cispar[11])/1000000;
260 
261  //
262  // Then we could start getting the LASER informations
263  //
264 
265 
266  if (laserObj->getDiodeCurrOrd() == 0 || laserObj->getFiltNumber() == 0) // Sanity check
267  {
268  ATH_MSG_VERBOSE ( "Filter wheel moving: skip event !!" );
269  return StatusCode::SUCCESS; // This is expected for some events
270  }
271 
272  //
273  // Filter number is different from 0
274  // But we have to check few points in order to be sure
275  // that the wheel is stabilized
276  //
277 
278  m_las_filter = laserObj->getFiltNumber()-1; // Corrected filter position
279 
280  if (m_last_evt_filter == m_las_filter) // If the position the same as before??
281  {
282  m_n_same_filt_evts +=1;
283  }
284  else
285  {
286  m_n_same_filt_evts = 0;
287  }
288 
289  m_last_evt_filter = m_las_filter;
290 
291 
292  //
293  // As long as we don't have a suffecient number of consecutive events
294  // with the same filter (200), we consider that we are not stable and thus
295  // we reject the entire event
296  //
297 
298  if (m_n_same_filt_evts < 200) // Sanity check
299  {
300  ATH_MSG_WARNING ( "Still in a non stable area, wait a bit !!" );
301  return StatusCode::SUCCESS; // This is expected for some events
302  }
303 
304  //
305  // Then we get the diodes signals and store them
306  //
307 
308  double LG_diode[10];
309  double HG_diode[10];
310 
311  for(int i=0; i<10; ++i)
312  {
313  LG_diode[i] = static_cast<double>(laserObj->getDiodeADC(i,0)-laserObj->getDiodePedestal(i,0));
314  HG_diode[i] = static_cast<double>(laserObj->getDiodeADC(i,1)-laserObj->getDiodePedestal(i,1));
315  } // FOR
316 
317  for(int i=0; i<10; ++i){
318  m_LG_diode_signal[m_las_filter][i]->Push(LG_diode[i]);
319  m_HG_diode_signal[m_las_filter][i]->Push(HG_diode[i]);
320  } // FOR
321 
322  for(int i=0; i<2; ++i){
323  m_LG_PMT_signal[m_las_filter][i]->Push(laserObj->getPMADC(i,0)-laserObj->getPMPedestal(i,0));
324  m_HG_PMT_signal[m_las_filter][i]->Push(laserObj->getPMADC(i,1)-laserObj->getPMPedestal(i,1));
325  } // FOR
326 
327  // Check that the ADC has really sent a new information
328 
329  if (laserObj->getPMADC(0,0) == m_PMT1_ADC_prev[0] &&
330  laserObj->getPMADC(1,0) == m_PMT2_ADC_prev[0])
331  {
332  m_ADC_problem = 1;
333  ATH_MSG_WARNING ( "There is perhaps an ADC problem with this event" );
334  }
335  if (laserObj->getPMADC(0,1) == m_PMT1_ADC_prev[1] &&
336  laserObj->getPMADC(1,1) == m_PMT2_ADC_prev[1])
337  {
338  m_ADC_problem = 1;
339  ATH_MSG_WARNING ( "There is perhaps an ADC problem with this event" );
340  }
341 
342  m_PMT1_ADC_prev[0] = laserObj->getPMADC(0,0);
343  m_PMT2_ADC_prev[0] = laserObj->getPMADC(1,0);
344  m_PMT1_ADC_prev[1] = laserObj->getPMADC(0,1);
345  m_PMT2_ADC_prev[1] = laserObj->getPMADC(1,1);
346 
347  // Next parameters are constants, don't need to update them more than once
348 
349  if (m_hrate == 0)
350  {
351  m_first_filter = laserObj->getFiltNumber()-1; // The first filter position
352  m_hrate = laserObj->getHumidity();
353  m_flow = laserObj->getGasFlux();
354  m_head_temp = laserObj->getPumpDiodeTemp();
355  m_las_requ_amp = laserObj->getDiodeCurrOrd();
356  }
357 
358  //
359  // Are we back to the first wheel position??
360  // If so we stop here because otherwise
361  // we have systematic shifts with filter wheel position
362  //
363 
364  if (m_las_filter==m_first_filter)
365  {
366  int previous_filter = (m_first_filter+7)%8;
367  if (m_HG_PMT_signal[previous_filter][0]->NumDataValues()>400 || m_LG_PMT_signal[previous_filter][0]->NumDataValues()>400)
368  {
369  m_complete_turn=true; // Yes, stop here
370  ATH_MSG_INFO ( "Filter wheel turn completed: stop here" );
371  return StatusCode::SUCCESS;
372  }
373  }
374 
375  //
376  // Then we could loop over all the channels, and get the correction factor
377  //
378 
379 
380  // Create iterator over RawChannelContainer
381  TileRawChannelUnit::UNIT RChUnit = rawCnt->get_unit();
382  TileRawChannelContainer::const_iterator itColl = rawCnt->begin();
383  TileRawChannelContainer::const_iterator itCollEnd = rawCnt->end();
384 
385  // Go through all TileRawChannelCollections
386  for(; itColl != itCollEnd; ++itColl)
387  {
388 
389  // go through all TileRawChannels in collection
390  TileRawChannelCollection::const_iterator it = (*itColl)->begin();
391  for(; it != (*itColl)->end(); ++it)
392  {
393 
394  // get adcHash
395  HWIdentifier hwid=(*it)->adc_HWID();
396  int ros = m_tileHWID->ros(hwid)-1; // LBA=0 LBC=1 EBA=2 EBC=3
397  int drawer = m_tileHWID->drawer(hwid); // 0 to 63
398  int chan = m_tileHWID->channel(hwid); // 0 to 47 channel not PMT
399  int gain = m_tileHWID->adc(hwid); // low=0 high=1
400 
401  // amp has to be in PicoCoulombs, here we are mixing gains
402  float amp = (*it)->amplitude();
403  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros+1,drawer);
404 
405 
406 
407  // check if channel is connected
408  if( !chanIsConnected(ros+1,chan) ) continue;
409 
410  // Don't enable negative or null energies
411  if ( amp <= 0.) continue;
412 
413  float ampInPicoCoulombs = m_tileToolEmscale->channelCalib(drawerIdx, chan, gain, amp, RChUnit, TileRawChannelUnit::PicoCoulombs);
414 
415  //
416  // Here we do an outlier removal when enough events have been collected
417  // (Mean and RMS are computed in the same pass
418  //)
419  // Useful when the filter wheel is moving again (the signal could become bad again)
420  //
421 
422  if (m_signal[m_las_filter][ros][drawer][chan][gain]->NumDataValues()>400)
423  {
424  double current_mean = m_signal[m_las_filter][ros][drawer][chan][gain]->Mean();
425  double current_RMS = m_signal[m_las_filter][ros][drawer][chan][gain]->StandardDeviation();
426 
427  if (fabs(ampInPicoCoulombs-current_mean)>5*current_RMS) // 5 sigmas away, not normal
428  {
429  ATH_MSG_VERBOSE ( "Rejecting an outlier. If there are a lot this means filter wheel will soon move again!" );
430  }
431  else
432  {
433  m_signal[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs);
434 
435  if (HG_diode[0] != 0)
436  {
437  m_HG_ratio_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/HG_diode[0]);
438  m_HG_ratio2_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/(laserObj->getPMADC(0,1)-laserObj->getPMPedestal(0,1)));
439  }
440 
441  if (LG_diode[0] != 0)
442  {
443  m_LG_ratio_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/LG_diode[0]);
444  m_LG_ratio2_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/(laserObj->getPMADC(0,0)-laserObj->getPMPedestal(0,0)));
445  }
446 
447  }
448  }
449  else
450  {
451  if (ros == 2 && drawer == 0 && chan == 1)
452  ATH_MSG_VERBOSE ( m_las_filter+1 <<" / " << gain <<" / " << ampInPicoCoulombs <<" / "
453  << m_signal[m_las_filter][ros][drawer][chan][gain]->Mean()
454  << " / " << m_signal[m_las_filter][ros][drawer][chan][gain]->StandardDeviation() );
455 
456  m_signal[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs);
457 
458  if (HG_diode[0] != 0)
459  {
460  m_HG_ratio_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/HG_diode[0]);
461  m_HG_ratio2_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/(laserObj->getPMADC(0,1)-laserObj->getPMPedestal(0,1)));
462  }
463 
464  if (LG_diode[0] != 0)
465  {
466  m_LG_ratio_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/LG_diode[0]);
467  m_LG_ratio2_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/(laserObj->getPMADC(0,0)-laserObj->getPMPedestal(0,0)));
468  }
469 
470  }
471  } // End of the loop over the TileRawChannelCollection
472  } // End of the loop over the TileRawChannelContainer
473 
474  return StatusCode::SUCCESS;
475 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

◆ finalize()

StatusCode TileLaserLinearityCalibTool::finalize ( )
overridevirtual

Implements ITileCalibTool.

Definition at line 639 of file TileLaserLinearityCalibTool.cxx.

640 {
641  ATH_MSG_INFO ( "finalize()" );
642  return StatusCode::SUCCESS;
643 }

◆ finalizeCalculations()

StatusCode TileLaserLinearityCalibTool::finalizeCalculations ( )
overridevirtual

Implements ITileCalibTool.

Definition at line 484 of file TileLaserLinearityCalibTool.cxx.

485 {
486  ATH_MSG_INFO ( "execute()" );
487 
488  for(int f=0; f<NFILTERS; ++f)
489  {
490  for(int d=0; d<NPMTS; ++d)
491  {
492  m_LG_PMT[f][d] = m_LG_PMT_signal[f][d]->Mean();
493  m_LG_PMT_S[f][d] = m_LG_PMT_signal[f][d]->StandardDeviation();
494 
495  m_HG_PMT[f][d] = m_HG_PMT_signal[f][d]->Mean();
496  m_HG_PMT_S[f][d] = m_HG_PMT_signal[f][d]->StandardDeviation();
497  }
498  }
499 
500  for(int f=0; f<NFILTERS; ++f)
501  {
502  for(int d=0; d<NPARTITIONS; ++d)
503  {
504  m_LG_diode[f][d] = m_LG_diode_signal[f][d]->Mean();
505  m_LG_diode_S[f][d] = m_LG_diode_signal[f][d]->StandardDeviation();
506 
507  m_HG_diode[f][d] = m_HG_diode_signal[f][d]->Mean();
508  m_HG_diode_S[f][d] = m_HG_diode_signal[f][d]->StandardDeviation();
509  }
510  }
511 
512  for(int f=0; f<NFILTERS; ++f)
513  {
514  for(int i=0; i<NPARTITIONS; ++i)
515  {
516  for(int j=0; j<NDRAWERS; ++j)
517  {
518  for(int k=0; k<NCHANNELS; ++k)
519  {
520  for(int l=0; l<NGAINS; ++l)
521  {
522  m_mean[f][i][j][k][l] = m_signal[f][i][j][k][l]->Mean();
523  m_mean_S[f][i][j][k][l] = m_signal[f][i][j][k][l]->StandardDeviation();
524 
525  m_LG_ratio[f][i][j][k][l] = m_LG_ratio_stat[f][i][j][k][l]->Mean();
526  m_LG_ratio_S[f][i][j][k][l] = m_LG_ratio_stat[f][i][j][k][l]->StandardDeviation();
527  m_LG_ratio2[f][i][j][k][l] = m_LG_ratio2_stat[f][i][j][k][l]->Mean();
528  m_LG_ratio2_S[f][i][j][k][l] = m_LG_ratio2_stat[f][i][j][k][l]->StandardDeviation();
529  m_HG_ratio[f][i][j][k][l] = m_HG_ratio_stat[f][i][j][k][l]->Mean();
530  m_HG_ratio_S[f][i][j][k][l] = m_HG_ratio_stat[f][i][j][k][l]->StandardDeviation();
531  m_HG_ratio2[f][i][j][k][l] = m_HG_ratio2_stat[f][i][j][k][l]->Mean();
532  m_HG_ratio2_S[f][i][j][k][l] = m_HG_ratio2_stat[f][i][j][k][l]->StandardDeviation();
533  m_entries[f][i][j][k][l] = m_signal[f][i][j][k][l]->NumDataValues();
534  }
535  }
536  }
537  }
538  }
539 
540  // remove all RunningStat objects from memory
541 
542  for(int f=0; f<NFILTERS; ++f)
543  {
544  for(int d=0; d<NPMTS; ++d)
545  {
546  delete m_LG_PMT_signal[f][d];
547  delete m_HG_PMT_signal[f][d];
548  }
549  }
550 
551  for(int f=0; f<NFILTERS; ++f)
552  {
553  for(int d=0; d<NPARTITIONS; ++d)
554  {
555  delete m_LG_diode_signal[f][d];
556  delete m_HG_diode_signal[f][d];
557  }
558  }
559 
560  for(int f=0; f<NFILTERS; ++f) // Filter
561  {
562  for(int i=0; i<NPARTITIONS; ++i) // Partition
563  {
564  for(int j=0; j<NDRAWERS; ++j) // Module
565  {
566  for(int k=0; k<NCHANNELS; ++k) // Channel
567  {
568  for(int l=0; l<NGAINS; ++l) // Gain
569  {
570  delete m_signal[f][i][j][k][l];
571  delete m_HG_ratio_stat[f][i][j][k][l];
572  delete m_HG_ratio2_stat[f][i][j][k][l];
573  delete m_LG_ratio_stat[f][i][j][k][l];
574  delete m_LG_ratio2_stat[f][i][j][k][l];
575  }
576  }
577  }
578  }
579  }
580 
581  return StatusCode::SUCCESS;
582 }

◆ initialize()

StatusCode TileLaserLinearityCalibTool::initialize ( )
overridevirtual

Implements ITileCalibTool.

Definition at line 131 of file TileLaserLinearityCalibTool.cxx.

132 {
133 
134  ATH_MSG_INFO ( "initialize()" );
135 
136  // Reset local parameters
137  // For parameter definition, see the header file
138  //
139 
140  m_complete_turn = false;
141 
142  m_toolRunNo = 0;
143  m_ADC_problem = 0;
144  m_las_filter = 0;
145  m_las_requ_amp = 0;
146  m_hrate = 0;
147  m_flow = 0;
148  m_head_temp = 0;
149  m_las_time = 0;
150  m_PMT1_ADC_prev[0]= 0;
151  m_PMT2_ADC_prev[0]= 0;
152  m_PMT1_ADC_prev[1]= 0;
153  m_PMT2_ADC_prev[1]= 0;
154 
155  m_last_evt_filter = 0;
156  m_n_same_filt_evts = 0;
157 
158  for(int f=0; f<NFILTERS; ++f)
159  {
160  for(int d=0; d<NPMTS; ++d)
161  {
162  m_LG_PMT_signal[f][d] = new RunningStat();
163  m_HG_PMT_signal[f][d] = new RunningStat();
164  }
165  }
166 
167  for(int f=0; f<NFILTERS; ++f)
168  {
169  for(int d=0; d<NPARTITIONS; ++d)
170  {
171  m_LG_diode_signal[f][d] = new RunningStat();
172  m_HG_diode_signal[f][d] = new RunningStat();
173  }
174  }
175 
176  for(int f=0; f<NFILTERS; ++f) // Filter
177  {
178  for(int i=0; i<NPARTITIONS; ++i) // Partition
179  {
180  for(int j=0; j<NDRAWERS; ++j) // Module
181  {
182  for(int k=0; k<NCHANNELS; ++k) // Channel
183  {
184  for(int l=0; l<NGAINS; ++l) // Gain
185  {
186  m_signal[f][i][j][k][l] = new RunningStat();
187  m_HG_ratio_stat[f][i][j][k][l] = new RunningStat();
188  m_HG_ratio2_stat[f][i][j][k][l] = new RunningStat();
189  m_LG_ratio_stat[f][i][j][k][l] = new RunningStat();
190  m_LG_ratio2_stat[f][i][j][k][l] = new RunningStat();
191  }
192  }
193  }
194  }
195  }
196 
197 
198  ATH_CHECK( detStore()->retrieve(m_tileHWID) );
199  ATH_CHECK( m_tileToolEmscale.retrieve() );
200 
201  ATH_CHECK( m_rawChannelContainerKey.initialize() );
202  ATH_CHECK( m_laserContainerKey.initialize() );
203 
204  m_cabling = TileCablingService::getInstance();
205 
206  CHECK( m_dqStatusKey.initialize() );
207 
208  return StatusCode::SUCCESS;
209 }

◆ initNtuple()

StatusCode TileLaserLinearityCalibTool::initNtuple ( int  runNumber,
int  runType,
TFile *  rootfile 
)
overridevirtual

Implements ITileCalibTool.

Definition at line 211 of file TileLaserLinearityCalibTool.cxx.

212 {
213  ATH_MSG_INFO ( "initialize(" << runNumber << "," << runType << "," << rootFile << ")" );
214  return StatusCode::SUCCESS;
215 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ interfaceID()

static const InterfaceID& ITileCalibTool::interfaceID ( )
inlinestaticinherited

Definition at line 21 of file ITileCalibTool.h.

21 { return IID_ITileCalibTool; }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::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< AlgTool >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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  }

◆ writeNtuple()

StatusCode TileLaserLinearityCalibTool::writeNtuple ( int  runNumber,
int  runType,
TFile *  rootfile 
)
overridevirtual

Implements ITileCalibTool.

Definition at line 593 of file TileLaserLinearityCalibTool.cxx.

594 {
595  ATH_MSG_INFO ( "finalize(" << runNumber << "," << runType << "," << rootFile << ")" );
596 
597  // Create output tree
598 
599  m_toolRunNo = runNumber;
600 
601  TTree *t = new TTree(m_toolNtuple.c_str(), "TileLaserCalib-Ntuple");
602  t->Branch("RunNumber",&m_toolRunNo, "runNo/I");
603  t->Branch("ADC_status",&m_ADC_problem, "ADC/I");
604  t->Branch("RequestedAmp",&m_las_requ_amp, "requamp/D");
605  t->Branch("Humidity",&m_hrate,"humid/D");
606  t->Branch("AirFlow",&m_flow,"flow/D");
607  t->Branch("HeadTemp",&m_head_temp,"htemp/D");
608  t->Branch("Time",&m_las_time, "timeofrun/D");
609  t->Branch("LG_PMT_Signal",m_LG_PMT, "LG_PMT1[8][2]/D");
610  t->Branch("LG_PMT_Sigma_Signal",m_LG_PMT_S, "LG_PMT1_s[8][2]/D");
611  t->Branch("HG_PMT_Signal",m_HG_PMT, "HG_PMT1[8][2]/D");
612  t->Branch("HG_PMT_Sigma_Signal",m_HG_PMT_S, "HG_PMT1_s[8][2]/D");
613 
614  t->Branch("LG_Diode_Signal",m_LG_diode, "LG_diode[8][10]/D");
615  t->Branch("LG_Diode_Sigma_Signal",m_LG_diode_S, "LG_diode_s[8][10]/D");
616  t->Branch("HG_Diode_Signal",m_HG_diode, "HG_diode[8][10]/D");
617  t->Branch("HG_Diode_Sigma_Signal",m_HG_diode_S, "HG_diode_s[8][10]/D");
618 
619  t->Branch("Signal",*m_mean,"signal[8][4][64][48][2]/D");
620  t->Branch("Sigma_Signal",*m_mean_S,"signal_s[8][4][64][48][2]/D");
621  t->Branch("LG_Ratio",*m_LG_ratio,"LG_signal_cor[8][4][64][48][2]/D");
622  t->Branch("LG_Sigma_Ratio",*m_LG_ratio_S,"LG_signal_cor_s[8][4][64][48][2]/D");
623  t->Branch("LG_Ratio2",*m_LG_ratio2,"LG_signal_cor2[8][4][64][48][2]/D");
624  t->Branch("LG_Sigma_Ratio2",*m_LG_ratio2_S,"LG_signal_cor2_s[8][4][64][48][2]/D");
625  t->Branch("HG_Ratio",*m_HG_ratio,"HG_signal_cor[8][4][64][48][2]/D");
626  t->Branch("HG_Sigma_Ratio",*m_HG_ratio_S,"HG_signal_cor_s[8][4][64][48][2]/D");
627  t->Branch("HG_Ratio2",*m_HG_ratio2,"HG_signal_cor2[8][4][64][48][2]/D");
628  t->Branch("HG_Sigma_Ratio2",*m_HG_ratio2_S,"HG_signal_cor2_s[8][4][64][48][2]/D");
629  t->Branch("Entries",*m_entries,"n_LASER_entries[8][4][64][48][2]/I");
630 
631 
632  // Fill with current values (i.e. tree will have only one entry for this whole run)
633  t->Fill();
634  t->Write();
635 
636  return StatusCode::SUCCESS;
637 }

Member Data Documentation

◆ m_ADC_problem

int TileLaserLinearityCalibTool::m_ADC_problem
private

Definition at line 85 of file TileLaserLinearityCalibTool.h.

◆ m_cabling

const TileCablingService* TileLaserLinearityCalibTool::m_cabling
private

Definition at line 71 of file TileLaserLinearityCalibTool.h.

◆ m_complete_turn

bool TileLaserLinearityCalibTool::m_complete_turn
private

Definition at line 123 of file TileLaserLinearityCalibTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_dqStatusKey

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

Definition at line 63 of file TileLaserLinearityCalibTool.h.

◆ m_entries

int(* TileLaserLinearityCalibTool::m_entries)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 110 of file TileLaserLinearityCalibTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_first_filter

int TileLaserLinearityCalibTool::m_first_filter
private

Definition at line 118 of file TileLaserLinearityCalibTool.h.

◆ m_flow

double TileLaserLinearityCalibTool::m_flow
private

Definition at line 89 of file TileLaserLinearityCalibTool.h.

◆ m_head_temp

double TileLaserLinearityCalibTool::m_head_temp
private

Definition at line 90 of file TileLaserLinearityCalibTool.h.

◆ m_HG_diode

double(* TileLaserLinearityCalibTool::m_HG_diode)[NDIODES]
private

Definition at line 98 of file TileLaserLinearityCalibTool.h.

◆ m_HG_diode_S

double(* TileLaserLinearityCalibTool::m_HG_diode_S)[NDIODES]
private

Definition at line 99 of file TileLaserLinearityCalibTool.h.

◆ m_HG_diode_signal

RunningStat*(* TileLaserLinearityCalibTool::m_HG_diode_signal)[NDIODES]
private

Definition at line 125 of file TileLaserLinearityCalibTool.h.

◆ m_HG_PMT

double(* TileLaserLinearityCalibTool::m_HG_PMT)[NPMTS]
private

Definition at line 96 of file TileLaserLinearityCalibTool.h.

◆ m_HG_PMT_S

double(* TileLaserLinearityCalibTool::m_HG_PMT_S)[NPMTS]
private

Definition at line 97 of file TileLaserLinearityCalibTool.h.

◆ m_HG_PMT_signal

RunningStat*(* TileLaserLinearityCalibTool::m_HG_PMT_signal)[NPMTS]
private

Definition at line 126 of file TileLaserLinearityCalibTool.h.

◆ m_HG_ratio

double(* TileLaserLinearityCalibTool::m_HG_ratio)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 106 of file TileLaserLinearityCalibTool.h.

◆ m_HG_ratio2

double(* TileLaserLinearityCalibTool::m_HG_ratio2)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 108 of file TileLaserLinearityCalibTool.h.

◆ m_HG_ratio2_S

double(* TileLaserLinearityCalibTool::m_HG_ratio2_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 109 of file TileLaserLinearityCalibTool.h.

◆ m_HG_ratio2_stat

RunningStat*(* TileLaserLinearityCalibTool::m_HG_ratio2_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 133 of file TileLaserLinearityCalibTool.h.

◆ m_HG_ratio_S

double(* TileLaserLinearityCalibTool::m_HG_ratio_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 107 of file TileLaserLinearityCalibTool.h.

◆ m_HG_ratio_stat

RunningStat*(* TileLaserLinearityCalibTool::m_HG_ratio_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 132 of file TileLaserLinearityCalibTool.h.

◆ m_hrate

double TileLaserLinearityCalibTool::m_hrate
private

Definition at line 88 of file TileLaserLinearityCalibTool.h.

◆ m_las_filter

int TileLaserLinearityCalibTool::m_las_filter
private

Definition at line 86 of file TileLaserLinearityCalibTool.h.

◆ m_las_requ_amp

double TileLaserLinearityCalibTool::m_las_requ_amp
private

Definition at line 87 of file TileLaserLinearityCalibTool.h.

◆ m_las_time

double TileLaserLinearityCalibTool::m_las_time
private

Definition at line 91 of file TileLaserLinearityCalibTool.h.

◆ m_laserContainerKey

SG::ReadHandleKey<TileLaserObject> TileLaserLinearityCalibTool::m_laserContainerKey
private
Initial value:
{this,
"TileLaserObject", "TileLaserObject", "Input Tile laser object"}

Definition at line 67 of file TileLaserLinearityCalibTool.h.

◆ m_laserContainerName

std::string TileLaserLinearityCalibTool::m_laserContainerName
private

Definition at line 62 of file TileLaserLinearityCalibTool.h.

◆ m_last_evt_filter

int TileLaserLinearityCalibTool::m_last_evt_filter
private

Definition at line 120 of file TileLaserLinearityCalibTool.h.

◆ m_LG_diode

double(* TileLaserLinearityCalibTool::m_LG_diode)[NDIODES]
private

Definition at line 94 of file TileLaserLinearityCalibTool.h.

◆ m_LG_diode_S

double(* TileLaserLinearityCalibTool::m_LG_diode_S)[NDIODES]
private

Definition at line 95 of file TileLaserLinearityCalibTool.h.

◆ m_LG_diode_signal

RunningStat*(* TileLaserLinearityCalibTool::m_LG_diode_signal)[NDIODES]
private

Definition at line 127 of file TileLaserLinearityCalibTool.h.

◆ m_LG_PMT

double(* TileLaserLinearityCalibTool::m_LG_PMT)[NPMTS]
private

Definition at line 92 of file TileLaserLinearityCalibTool.h.

◆ m_LG_PMT_S

double(* TileLaserLinearityCalibTool::m_LG_PMT_S)[NPMTS]
private

Definition at line 93 of file TileLaserLinearityCalibTool.h.

◆ m_LG_PMT_signal

RunningStat*(* TileLaserLinearityCalibTool::m_LG_PMT_signal)[NPMTS]
private

Definition at line 128 of file TileLaserLinearityCalibTool.h.

◆ m_LG_ratio

double(* TileLaserLinearityCalibTool::m_LG_ratio)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 102 of file TileLaserLinearityCalibTool.h.

◆ m_LG_ratio2

double(* TileLaserLinearityCalibTool::m_LG_ratio2)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 104 of file TileLaserLinearityCalibTool.h.

◆ m_LG_ratio2_S

double(* TileLaserLinearityCalibTool::m_LG_ratio2_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 105 of file TileLaserLinearityCalibTool.h.

◆ m_LG_ratio2_stat

RunningStat*(* TileLaserLinearityCalibTool::m_LG_ratio2_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 131 of file TileLaserLinearityCalibTool.h.

◆ m_LG_ratio_S

double(* TileLaserLinearityCalibTool::m_LG_ratio_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 103 of file TileLaserLinearityCalibTool.h.

◆ m_LG_ratio_stat

RunningStat*(* TileLaserLinearityCalibTool::m_LG_ratio_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 130 of file TileLaserLinearityCalibTool.h.

◆ m_mean

double(* TileLaserLinearityCalibTool::m_mean)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 100 of file TileLaserLinearityCalibTool.h.

◆ m_mean_S

double(* TileLaserLinearityCalibTool::m_mean_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 101 of file TileLaserLinearityCalibTool.h.

◆ m_n_same_filt_evts

int TileLaserLinearityCalibTool::m_n_same_filt_evts
private

Definition at line 121 of file TileLaserLinearityCalibTool.h.

◆ m_PMT1_ADC_prev

int TileLaserLinearityCalibTool::m_PMT1_ADC_prev[2]
private

Definition at line 115 of file TileLaserLinearityCalibTool.h.

◆ m_PMT2_ADC_prev

int TileLaserLinearityCalibTool::m_PMT2_ADC_prev[2]
private

Definition at line 116 of file TileLaserLinearityCalibTool.h.

◆ m_rawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileLaserLinearityCalibTool::m_rawChannelContainerKey
private
Initial value:
{this,
"TileRawChannelContainer", "TileRawChannelOpt2", "Input Tile raw channel container"}

Definition at line 65 of file TileLaserLinearityCalibTool.h.

◆ m_rawChannelContainerName

std::string TileLaserLinearityCalibTool::m_rawChannelContainerName
private

Definition at line 61 of file TileLaserLinearityCalibTool.h.

◆ m_signal

RunningStat*(* TileLaserLinearityCalibTool::m_signal)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
private

Definition at line 129 of file TileLaserLinearityCalibTool.h.

◆ m_tileHWID

const TileHWID* TileLaserLinearityCalibTool::m_tileHWID
private

Definition at line 70 of file TileLaserLinearityCalibTool.h.

◆ m_tileToolEmscale

ToolHandle<TileCondToolEmscale> TileLaserLinearityCalibTool::m_tileToolEmscale
private
Initial value:
{this,
"TileCondToolEmscale", "TileCondToolEmscale", "Tile em scale tool"}

Definition at line 72 of file TileLaserLinearityCalibTool.h.

◆ m_toolNtuple

std::string TileLaserLinearityCalibTool::m_toolNtuple
private

Definition at line 59 of file TileLaserLinearityCalibTool.h.

◆ m_toolRunNo

int TileLaserLinearityCalibTool::m_toolRunNo
private

Definition at line 84 of file TileLaserLinearityCalibTool.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileLaserLinearityCalibTool::m_LG_diode
double(* m_LG_diode)[NDIODES]
Definition: TileLaserLinearityCalibTool.h:94
NFILTERS
#define NFILTERS
Definition: TileLaserLinearityCalibTool.h:23
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TileLaserLinearityCalibTool::m_LG_ratio2_stat
RunningStat *(* m_LG_ratio2_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:131
NPMTS
#define NPMTS
Definition: TileLaserDefaultCalibTool.h:32
TileLaserLinearityCalibTool::m_HG_ratio2_S
double(* m_HG_ratio2_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:109
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TileLaserLinearityCalibTool::m_HG_diode
double(* m_HG_diode)[NDIODES]
Definition: TileLaserLinearityCalibTool.h:98
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
TileLaserLinearityCalibTool::m_first_filter
int m_first_filter
Definition: TileLaserLinearityCalibTool.h:118
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
hist_file_dump.d
d
Definition: hist_file_dump.py:137
TileLaserLinearityCalibTool::m_flow
double m_flow
Definition: TileLaserLinearityCalibTool.h:89
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
TileLaserLinearityCalibTool::m_last_evt_filter
int m_last_evt_filter
Definition: TileLaserLinearityCalibTool.h:120
skel.it
it
Definition: skel.GENtoEVGEN.py:423
TileLaserLinearityCalibTool::m_LG_diode_S
double(* m_LG_diode_S)[NDIODES]
Definition: TileLaserLinearityCalibTool.h:95
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
TileLaserLinearityCalibTool::m_hrate
double m_hrate
Definition: TileLaserLinearityCalibTool.h:88
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TileLaserLinearityCalibTool::m_entries
int(* m_entries)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:110
TileRawChannelUnit::PicoCoulombs
@ PicoCoulombs
Definition: TileRawChannelUnit.h:18
HWIdentifier
Definition: HWIdentifier.h:13
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileLaserLinearityCalibTool::m_n_same_filt_evts
int m_n_same_filt_evts
Definition: TileLaserLinearityCalibTool.h:121
TileLaserLinearityCalibTool::m_LG_ratio2
double(* m_LG_ratio2)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:104
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
NGAINS
#define NGAINS
Definition: TileLaserDefaultCalibTool.h:34
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TileLaserLinearityCalibTool::m_PMT1_ADC_prev
int m_PMT1_ADC_prev[2]
Definition: TileLaserLinearityCalibTool.h:115
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
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
NPARTITIONS
#define NPARTITIONS
Definition: TileLaserDefaultCalibTool.h:35
RunningStat
Definition: TileLaserDefaultCalibTool.h:232
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
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileLaserLinearityCalibTool::m_las_requ_amp
double m_las_requ_amp
Definition: TileLaserLinearityCalibTool.h:87
TileLaserLinearityCalibTool::m_LG_PMT_signal
RunningStat *(* m_LG_PMT_signal)[NPMTS]
Definition: TileLaserLinearityCalibTool.h:128
lumiFormat.i
int i
Definition: lumiFormat.py:92
TileLaserLinearityCalibTool::m_mean
double(* m_mean)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:100
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
TileLaserLinearityCalibTool::m_head_temp
double m_head_temp
Definition: TileLaserLinearityCalibTool.h:90
TileLaserLinearityCalibTool::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileLaserLinearityCalibTool.h:70
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TileLaserLinearityCalibTool::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition: TileLaserLinearityCalibTool.h:72
TileLaserLinearityCalibTool::m_dqStatusKey
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
Definition: TileLaserLinearityCalibTool.h:63
TileLaserLinearityCalibTool::m_HG_diode_S
double(* m_HG_diode_S)[NDIODES]
Definition: TileLaserLinearityCalibTool.h:99
TileLaserLinearityCalibTool::m_HG_ratio_S
double(* m_HG_ratio_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:107
RunningStat::Push
void Push(double x)
Definition: TileLaserDefaultCalibTool.h:244
NCHANNELS
#define NCHANNELS
Definition: TileLaserDefaultCalibTool.h:38
TileLaserLinearityCalibTool::m_LG_ratio2_S
double(* m_LG_ratio2_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:105
TileLaserLinearityCalibTool::m_HG_ratio2
double(* m_HG_ratio2)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:108
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
makeComparison.rootFile
rootFile
Definition: makeComparison.py:27
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
NDRAWERS
#define NDRAWERS
Definition: TileLaserDefaultCalibTool.h:36
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
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
TileLaserLinearityCalibTool::m_HG_PMT
double(* m_HG_PMT)[NPMTS]
Definition: TileLaserLinearityCalibTool.h:96
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
TileLaserLinearityCalibTool::m_PMT2_ADC_prev
int m_PMT2_ADC_prev[2]
Definition: TileLaserLinearityCalibTool.h:116
TileLaserLinearityCalibTool::m_HG_diode_signal
RunningStat *(* m_HG_diode_signal)[NDIODES]
Definition: TileLaserLinearityCalibTool.h:125
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
python.OnlineISConfiguration.runType
def runType
Definition: OnlineISConfiguration.py:112
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
RunningStat::Mean
double Mean() const
Definition: TileLaserDefaultCalibTool.h:280
TileLaserLinearityCalibTool::m_toolNtuple
std::string m_toolNtuple
Definition: TileLaserLinearityCalibTool.h:59
TileLaserLinearityCalibTool::m_cabling
const TileCablingService * m_cabling
Definition: TileLaserLinearityCalibTool.h:71
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
TileLaserLinearityCalibTool::m_LG_ratio
double(* m_LG_ratio)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:102
TileLaserLinearityCalibTool::m_toolRunNo
int m_toolRunNo
Definition: TileLaserLinearityCalibTool.h:84
TileLaserLinearityCalibTool::m_laserContainerKey
SG::ReadHandleKey< TileLaserObject > m_laserContainerKey
Definition: TileLaserLinearityCalibTool.h:67
RunningStat::NumDataValues
int NumDataValues() const
Definition: TileLaserDefaultCalibTool.h:279
TileLaserLinearityCalibTool::m_LG_ratio_stat
RunningStat *(* m_LG_ratio_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:130
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
TileLaserLinearityCalibTool::chanIsConnected
int chanIsConnected(int ros, int chan)
Definition: TileLaserLinearityCalibTool.h:136
TileLaserLinearityCalibTool::m_HG_PMT_signal
RunningStat *(* m_HG_PMT_signal)[NPMTS]
Definition: TileLaserLinearityCalibTool.h:126
TileLaserLinearityCalibTool::m_LG_PMT_S
double(* m_LG_PMT_S)[NPMTS]
Definition: TileLaserLinearityCalibTool.h:93
TileLaserLinearityCalibTool::m_LG_diode_signal
RunningStat *(* m_LG_diode_signal)[NDIODES]
Definition: TileLaserLinearityCalibTool.h:127
TileLaserLinearityCalibTool::m_HG_PMT_S
double(* m_HG_PMT_S)[NPMTS]
Definition: TileLaserLinearityCalibTool.h:97
TileDQstatus::cispar
const uint32_t * cispar() const
CIS parameters.
Definition: TileDQstatus.h:152
TileLaserLinearityCalibTool::m_complete_turn
bool m_complete_turn
Definition: TileLaserLinearityCalibTool.h:123
TileLaserLinearityCalibTool::m_las_time
double m_las_time
Definition: TileLaserLinearityCalibTool.h:91
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
RunningStat::StandardDeviation
double StandardDeviation() const
Definition: TileLaserDefaultCalibTool.h:282
a
TList * a
Definition: liststreamerinfos.cxx:10
TileLaserLinearityCalibTool::m_mean_S
double(* m_mean_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:101
h
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TileCablingService::channel2hole
static int channel2hole(int ros, int channel)
Definition: TileCablingService.cxx:1946
TileLaserLinearityCalibTool::m_HG_ratio2_stat
RunningStat *(* m_HG_ratio2_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:133
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
TileLaserLinearityCalibTool::m_ADC_problem
int m_ADC_problem
Definition: TileLaserLinearityCalibTool.h:85
TileLaserLinearityCalibTool::m_rawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerKey
Definition: TileLaserLinearityCalibTool.h:65
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
NDIODES
#define NDIODES
Definition: TileLaserDefaultCalibTool.h:29
TileLaserLinearityCalibTool::m_HG_ratio
double(* m_HG_ratio)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:106
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
TileLaserLinearityCalibTool::m_HG_ratio_stat
RunningStat *(* m_HG_ratio_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:132
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TileLaserLinearityCalibTool::m_las_filter
int m_las_filter
Definition: TileLaserLinearityCalibTool.h:86
LArMonTransforms.Mean
def Mean(inputs)
Definition: LArMonTransforms.py:438
TileLaserLinearityCalibTool::m_signal
RunningStat *(* m_signal)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:129
fitman.k
k
Definition: fitman.py:528
TileLaserLinearityCalibTool::m_LG_ratio_S
double(* m_LG_ratio_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
Definition: TileLaserLinearityCalibTool.h:103
TileLaserLinearityCalibTool::m_LG_PMT
double(* m_LG_PMT)[NPMTS]
Definition: TileLaserLinearityCalibTool.h:92
Generated on Fri Jun 28 2024 22:03:26 for ATLAS Offline Software by   doxygen 1.8.18