ATLAS Offline Software
Loading...
Searching...
No Matches
TileAANtuple.h
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3*/
4
5//****************************************************************************
42//****************************************************************************
43#ifndef TILEREC_TILEAANTUPLE_H
44#define TILEREC_TILEAANTUPLE_H
45
46// Tile includes
61
62// Athena includes
66
67// Gauid includes
68#include "GaudiKernel/ToolHandle.h"
69#include "GaudiKernel/ServiceHandle.h"
70#include "GaudiKernel/IFileMgr.h"
71
72#include <string>
73#include <stdint.h>
74
75#define N_ROS 4
76#define N_ROS2 8
77#define N_MODULES 64
78#define N_DRAWERS 256
79#define N_DMUS 16
80#define N_CHANS 48
81#define N_SAMPLES 7
82#define N_RODS 129
83#define N_CISPAR 110
84#define N_TMDBCHANS 8 // 4 in EB and 8 in B
85#define N_TMDBDECISIONS 4
86
87class TTree;
88
89class TileID;
90class TileHWID;
91class TileInfo;
94class TileL2Builder;
95class ITHistSvc;
96
97class TileAANtuple : public AthAlgorithm {
98 public:
99 //Constructor
100 TileAANtuple(const std::string& name, ISvcLocator* pSvcLocator);
101
102 //Destructor
103 virtual ~TileAANtuple();
104
105 //Gaudi Hooks
106 StatusCode ntuple_initialize(const EventContext& ctx,
107 const TileDQstatus& DQstatus);
108 StatusCode ntuple_clear();
109 StatusCode initialize();
110 StatusCode execute(const EventContext& ctx);
111 StatusCode finalize();
112
113 private:
114
115 StatusCode storeRawChannels(const EventContext& ctx
117 , float ene[N_ROS2][N_MODULES][N_CHANS]
118 , float time[N_ROS2][N_MODULES][N_CHANS]
119 , float chi2[N_ROS2][N_MODULES][N_CHANS]
120 , float ped[N_ROS2][N_MODULES][N_CHANS]
121 , bool fillAll);
122
123 StatusCode storeMFRawChannels(const EventContext& ctx
125 , float * ene
126 , float * time
127 , float chi2[N_ROS2][N_MODULES][N_CHANS]
128 , float ped[N_ROS2][N_MODULES][N_CHANS]
129 , bool fillAll);
130
131 StatusCode storeDigits(const EventContext& ctx
132 , const SG::ReadHandleKey<TileDigitsContainer>& containerKey
133 , short * sample
134 , short gain[N_ROS2][N_MODULES][N_CHANS]
135 , bool fillAll);
136
137 StatusCode storeTMDBDecision(const EventContext& ctx);
138 StatusCode storeTMDBDigits(const EventContext& ctx);
139 StatusCode storeTMDBRawChannel(const EventContext& ctxx);
140
141 StatusCode storeBeamElements(const TileDQstatus& DQstatus);
142 StatusCode storeLaser(const EventContext& ctx);
143 StatusCode storeDCS(const EventContext& ctx);
144
145 StatusCode initNTuple(const EventContext& ctx);
146
147 void fillCellMap(TTree* ntuplePtr, const EventContext& ctx);
148
149 void TRIGGER_addBranch(void);
150 void LASER_addBranch(void);
151 void CISPAR_addBranch(void);
152 void DIGI_addBranch(void);
153 void DCS_addBranch(void);
154 void TMDB_addBranch(void);
155
156 void TRIGGER_clearBranch(void);
157 void LASER_clearBranch(void);
158 void CISPAR_clearBranch(void);
159 void DIGI_clearBranch(void);
160 void TMDB_clearBranch(void);
161
162 inline int digiChannel2PMT(int fragType, int chan) {
163 return (abs(m_cabling->channel2hole(fragType, chan)) - 1);
164 }
165
168 inline short CheckDMUFormat(uint32_t header) {
169 if (((header >> 31 & 0x1) == 1) && ((header >> 17 & 0x1) == 0))
170 return 0; // no error
171 else
172 return 1; //error
173 }
174
175
177
178 inline short CheckDMUParity(uint32_t header) {
179 uint32_t parity(0);
180 for (int i = 0; i < 32; ++i)
181 parity += header >> i & 0x1;
182
183 if ((parity % 2) == 1)
184 return 0; //no error
185 else
186 return 1; //error
187 }
188
189 int m_evtNr{-1};
190
191 // Trigger items
192 int m_evTime{0};
193 int m_run{0};
194 int m_evt{0};
195 int m_lumiBlock{0};
196 int m_HHMMSS{0};
197 char m_dateTime[32]{};
198 int m_trigType{0};
199 uint32_t m_dspFlags{0};
200
201 int m_l1ID[N_RODS]{};
205
206 // Cispar
207 uint32_t m_cispar[N_CISPAR]{};
208
209 // Laser items
212
214 float m_las_ReqAmp{0};
217
218 struct Arrays {
219 // LASERI
227
232
233 // LASERII
234 int m_chan[32] = {0}; // Mean value for monitoring diodes, PMTs, phocal, CIS
235 float m_chan_Ped[32] = {0}; // Corresponding pedestal values
236 float m_chan_Led[32] = {0}; // Corresponding LED values
237 float m_chan_Lin[32] = {0}; // Corresponding linearity values
238 float m_chan_Alpha[32] = {0}; // Corresponding alpha peaks
239 float m_chan_SPed[32] = {0}; // Sigma of pedestal values
240 float m_chan_SLed[32] = {0}; // Sigma of LED values
241 float m_chan_SLin[32] = {0}; // Sigma of linearity values
242 float m_chan_SAlpha[32] = {0}; // Sigma of alpha peaks
243
244 // Digi/Energy items
245
246 short * m_sampleFlt = 0;
247 short m_gainFlt[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
248
249 short * m_sample = 0;
250 short m_gain[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
251
252 short m_rodBCID[N_ROS][N_MODULES] = {{0}};
253 short m_fragSize[N_ROS][N_MODULES] = {{0}};
254 uint16_t m_dmuMask[N_ROS][N_MODULES][2] = {{{0}}};
255 uint16_t m_slinkCRC[N_ROS][N_MODULES][2] = {{{0}}};
256
257 uint32_t m_DMUheader[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};
258 short m_DMUbcid[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};
264 short m_feCRC[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};
265 short m_rodCRC[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};
266
267 float m_ene[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
268 float m_time[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
269 float m_ped[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
270 float m_chi2[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
271
272 float m_eFit[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
273 float m_tFit[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
274 float m_pedFit[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
275 float m_chi2Fit[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
276
277 float m_eFitc[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
278 float m_tFitc[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
279 float m_pedFitc[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
280 float m_chi2Fitc[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
281
282 float m_eOpt[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
283 float m_tOpt[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
284 float m_pedOpt[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
285 float m_chi2Opt[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
286
287 float m_eQIE[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
288 float m_tQIE[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
289 float m_pedQIE[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
290 float m_chi2QIE[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
291
292 float m_eOF1[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
293 float m_tOF1[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
294 float m_pedOF1[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
295 float m_chi2OF1[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
296
297 float m_eDsp[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
298 float m_tDsp[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
299 float m_pedDsp[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
300 float m_chi2Dsp[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
301
302 float * m_eMF = 0;
303 float * m_tMF = 0;
304 float m_chi2MF[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
305 float m_pedMF[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
306
307 float m_eWiener[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
308 float m_tWiener[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};
311
313 short m_ROD_BCID[N_ROS][N_MODULES] = {{0}};
324 uint16_t m_ROD_DMUMask[N_ROS][N_MODULES][2] = {{{0}}};
325
326 float m_eTMDB[N_ROS][N_MODULES][N_TMDBCHANS] = {{{0}}}; // TMDB
327 unsigned char *m_sampleTMDB = 0;
328 unsigned char m_decisionTMDB[N_ROS][N_MODULES][N_TMDBDECISIONS] = {{{0}}}; // TMDB
329 unsigned char m_bcidTMDB[N_ROS][N_MODULES][3] = {{{0}}};
330
331 float m_TEMP[4][64][7] = {{{0}}};
332 float m_HV[4][64][48] = {{{0}}};
333 float m_HVSET[4][64][48] = {{{0}}};
334 int m_DRSTATES[4][64] = {{0}};
335 short m_HVSTATUS[4][64][48] = {{{0}}};
336 short m_DRSTATUS[4][64] = {{0}};
337 short m_CHSTATUS[4][64][48] = {{{0}}};
338 };
339 std::unique_ptr<Arrays> m_arrays;
340
341 bool m_qdctimeout{false};
342 bool m_tdctimeout{false};
343 int m_daqtype{0};
344 int m_nBadDr{0};
345 int m_nBadHV{0};
346 int m_nBadDCS{0};
347 int m_nBadDB{0};
349
350 Gaudi::Property<int> m_nSamples{this, "NSamples", 7, "Number of samples"};
351 Gaudi::Property<bool> m_reduced{this, "Reduced", false, "Reduced ntuple content"};
352 Gaudi::Property<int> m_compressSettings{this, "CompressionSettings", -1, "ROOT compression settings for output file (negative: do not change)"};
353
354 // jobOptions parameters - container names
355 SG::ReadHandleKey<TileDigitsContainer> m_digitsContainerKey{this, "TileDigitsContainer", "TileDigitsCnt", "Input Tile digits container key"};
356 SG::ReadHandleKey<TileDigitsContainer> m_fltDigitsContainerKey{this, "TileDigitsContainerFlt", "", "Input Tile filtered digits container key"};
357 SG::ReadHandleKey<TileBeamElemContainer> m_beamElemContainerKey{this, "TileBeamElemContainer", "TileBeamElemCnt", "Input Tile beam elements container key"};
358 SG::ReadHandleKey<TileRawChannelContainer> m_rawChannelContainerKey{this, "TileRawChannelContainer", "TileRawChannelCnt", "Input Tile raw channel container key"};
359 SG::ReadHandleKey<TileRawChannelContainer> m_fitRawChannelContainerKey{this, "TileRawChannelContainerFit", "", "Input Tile raw channel container key (Fit method)"};
360 SG::ReadHandleKey<TileRawChannelContainer> m_fitcRawChannelContainerKey{this, "TileRawChannelContainerFitCool", "", "Input Tile raw channel container key (Fit method with COOL pulse shape)"};
361 SG::ReadHandleKey<TileRawChannelContainer> m_optRawChannelContainerKey{this, "TileRawChannelContainerOpt", "", "Input Tile raw channel container key (Opt filter)"};
362 SG::ReadHandleKey<TileRawChannelContainer> m_qieRawChannelContainerKey{this, "TileRawChannelContainerQIE", "", "Input Tile raw channel container key (processed QIE data)"};
363 SG::ReadHandleKey<TileRawChannelContainer> m_dspRawChannelContainerKey{this, "TileRawChannelContainerDsp", "", "Input Tile raw channel container key (DSP)"};
364 SG::ReadHandleKey<TileRawChannelContainer> m_mfRawChannelContainerKey{this, "TileRawChannelContainerMF", "", "Input Tile raw channel container key (MF method)"};
365 SG::ReadHandleKey<TileRawChannelContainer> m_of1RawChannelContainerKey{this, "TileRawChannelContainerOF1", "", "Input Tile raw channel container key (OF1 method)"};
366 SG::ReadHandleKey<TileRawChannelContainer> m_wienerRawChannelContainerKey{this, "TileRawChannelContainerWiener", "", "Input Tile raw channel container key (Wiener filter)"};
367 SG::ReadHandleKey<TileLaserObject> m_laserObjectKey{this, "TileLaserObject", "", "Input Tile laser object key"};
368 SG::ReadHandleKey<TileRawChannelContainer> m_tileMuRcvRawChannelContainerKey{this, "TileMuRcvRawChannelContainer", "MuRcvRawChCnt", "Input TMDB raw channel container key"}; // TMDB
369 SG::ReadHandleKey<TileDigitsContainer> m_tileMuRcvDigitsContainerKey{this, "TileMuRcvDigitsContainer", "MuRcvDigitsCnt", "Input TMDB digits container key"}; // TMDB
370 SG::ReadHandleKey<TileMuonReceiverContainer> m_tileMuRcvContainerKey{this, "TileMuRcvContainer", "TileMuRcvCnt", "Input TMDB container key"}; // TMDB
371 SG::ReadHandleKey<TileL2Container> m_l2CntKey{this, "TileL2Cnt", "TileL2Cnt", "Input Tile L2 container key"};
372
373 // other jobOptions parameters
374 Gaudi::Property<bool> m_calibrateEnergy{this, "CalibrateEnergy", true, "Convert energy to new units or use amplitude from RawChannel directly"};
375 Gaudi::Property<bool> m_useDspUnits{this, "UseDspUnits", false, "Convert energy to units used in DSP"};
376 Gaudi::Property<bool> m_bsInput{this, "BSInput", true, "Bytestream file is used as input"};
377 Gaudi::Property<bool> m_pmtOrder{this, "PMTOrder", false, "Change channel ordering to PMT ordering in ntuple"};
378 Gaudi::Property<int> m_finalUnit{this, "OfflineUnits", TileRawChannelUnit::MegaElectronVolts, "Calibrate everything to this level"};
379 Gaudi::Property<bool> m_calibMode{this, "CalibMode", false, "If data should be put in calib mode"};
380 Gaudi::Property<bool> m_compareMode{this, "CompareMode", false, "If two sets of data should be compared (e.g. frag4 and frag5)"};
381 Gaudi::Property<bool> m_checkDCS{this, "CheckDCS", false, "If false, do not use TileDCS at all"};
382 Gaudi::Property<int> m_DCSBranches{this, "DCSBranches", 111111111, "Mask like 110101 - which DCS branches to fill"};
383
384 // energy units
387
388 // NTuple parameters
389 Gaudi::Property<std::string> m_streamName{this, "StreamName", "AANT", "Name of output stream for ntuple"};
390 Gaudi::Property<std::string> m_ntupleID{this, "NTupleID", "h2000", "ID of ntuple"};
391 Gaudi::Property<int64_t> m_treeSize{this, "TreeSize", 16000000000LL, "Max size of ROOT tree"};
392
393 // The ntuple
394 TTree* m_ntuplePtr{nullptr};
395 TTree* m_DCSntuplePtr{nullptr};
396
397 // handle to THistSvc
400 "FileMgr", "FileMgr", "The File manager service" };
401
402 // Identifiers
403 const TileID* m_tileID{nullptr};
404 const TileHWID* m_tileHWID{nullptr};
405
406 // Various tools
409
410 ToolHandle<ITileBadChanTool> m_tileBadChanTool{"TileBadChanTool"};
411
412 ToolHandle<TileCondToolEmscale> m_tileToolEmscale{this,
413 "TileCondToolEmscale", "TileCondToolEmscale", "Tile EM scale calibration tool"};
414
415 ToolHandle<ITileDCSTool> m_tileDCS{this, "TileDCSTool", "TileDCSTool", "Tile DCS tool"};
416
417 // variables to check SumEt in frag5
418 ToolHandle<TileL2Builder> m_l2Builder; //<! Pointer to TileL2Builder
429
430 Gaudi::Property<int> m_skipEvents{this, "SkipEvents", 0, "Number of events to skip before filling ntuple"};
431
432 std::vector<uint32_t> m_ROBID;
433
438 "TileCablingSvc", "TileCablingSvc", "The Tile cabling service" };
439
441 "ROBDataProviderSvc", "ROBDataProviderSvc", "The ROB data provider service" };
442
444 "TileDQstatus", "TileDQstatus", "TileDQstatus key" };
445
447 "TileHid2RESrcID", "TileHid2RESrcID", "TileHid2RESrcID key"};
448};
449
450#endif // TILEREC_TILEAANTUPLE_H
Property holding a SG store/key/clid from which a ReadHandle is made.
#define N_CISPAR
#define N_ROS
Filename : TileAANtuple.h Author : Alexander Solodkov (based on TileTBAANtuple) Created : April,...
#define N_MODULES
#define N_ROS2
#define N_DMUS
#define N_RODS
#define N_DRAWERS
#define N_CHANS
#define N_TMDBDECISIONS
#define N_TMDBCHANS
Information produced by TileDQstatusAlg (used to be done by TileBeamInfoProvider).
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Property holding a SG store/key/clid from which a ReadHandle is made.
Gaudi::Property< int > m_nSamples
number of samples
int m_l1ID[N_RODS]
Level1 ID from ROD header.
Gaudi::Property< int > m_compressSettings
float m_sumEt_yy[N_DRAWERS]
Sum Et calcualted inside DSP.
StatusCode storeTMDBDigits(const EventContext &ctx)
Gaudi::Property< bool > m_calibMode
If data should be put in calib mode.
StatusCode storeDCS(const EventContext &ctx)
float m_sumEt_zz[N_DRAWERS]
Sum Et recalculated offline using offline OF.
Gaudi::Property< bool > m_reduced
StatusCode execute(const EventContext &ctx)
Execute method.
StatusCode storeRawChannels(const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, float ene[N_ROS2][N_MODULES][N_CHANS], float time[N_ROS2][N_MODULES][N_CHANS], float chi2[N_ROS2][N_MODULES][N_CHANS], float ped[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
/ Fill ntuple with data from TRC.
StatusCode storeBeamElements(const TileDQstatus &DQstatus)
StatusCode finalize()
ServiceHandle< TileCablingSvc > m_cablingSvc
Name of Tile cabling service.
void TRIGGER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add TRIGGER variables t...
SG::ReadHandleKey< TileBeamElemContainer > m_beamElemContainerKey
virtual ~TileAANtuple()
void DIGI_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree DIGI variables...
Gaudi::Property< int64_t > m_treeSize
SG::ReadHandleKey< TileLaserObject > m_laserObjectKey
std::unique_ptr< Arrays > m_arrays
StatusCode initNTuple(const EventContext &ctx)
StatusCode storeTMDBRawChannel(const EventContext &ctxx)
uint32_t m_cispar[N_CISPAR]
StatusCode storeLaser(const EventContext &ctx)
float m_sumE_xx[N_DRAWERS]
Sum E recalculated offline using DSP raw channels.
Gaudi::Property< std::string > m_streamName
float m_las_MeasAmp
ToolHandle< ITileDCSTool > m_tileDCS
float m_sumEz_xx[N_DRAWERS]
Sum Ez recalculated offline using DSP raw channels.
Gaudi::Property< bool > m_pmtOrder
change channel ordering to pmt ordering in ntuple
Gaudi::Property< bool > m_checkDCS
if false, do not use TileDCS at all
float m_sumEz_yy[N_DRAWERS]
Sum Ez calcualted inside DSP.
void DCS_addBranch(void)
StatusCode initialize()
Alg standard interface function.
TileRawChannelUnit::UNIT m_rchUnit
Unit for TileRawChannels (ADC, pCb, MeV).
SG::ReadHandleKey< TileDigitsContainer > m_tileMuRcvDigitsContainerKey
StatusCode storeMFRawChannels(const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, float *ene, float *time, float chi2[N_ROS2][N_MODULES][N_CHANS], float ped[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
void LASER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree LASER variabl...
int m_run
run number
SG::ReadHandleKey< TileL2Container > m_l2CntKey
void CISPAR_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variabl...
ServiceHandle< IFileMgr > m_fileMgr
bool m_bad[N_ROS][N_MODULES][N_CHANS]
Gaudi::Property< bool > m_compareMode
If two sets of data should be compared (e.g.
TileRawChannelUnit::UNIT m_dspUnit
Unit for TileRawChannels in DSP.
void TMDB_addBranch(void)
const TileID * m_tileID
SG::ReadHandleKey< TileDQstatus > m_DQstatusKey
SG::ReadHandleKey< TileRawChannelContainer > m_of1RawChannelContainerKey
std::vector< uint32_t > m_ROBID
void fillCellMap(TTree *ntuplePtr, const EventContext &ctx)
///////////////////////////////////////////////////////////////////////////
TTree * m_DCSntuplePtr
Gaudi::Property< int > m_finalUnit
calibrate everything to this level
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
main Tile Calibration tool
ServiceHandle< IROBDataProviderSvc > m_robSvc
float m_sumEt_xx[N_DRAWERS]
Sum Et recalculated offline using DSP raw channels.
int digiChannel2PMT(int fragType, int chan)
StatusCode storeDigits(const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey, short *sample, short gain[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
/ Fill Ntuple with info from TileDigits / Return true if the collection is empty
TTree * m_ntuplePtr
SG::ReadHandleKey< TileRawChannelContainer > m_dspRawChannelContainerKey
int m_evt
event number in a run
Gaudi::Property< bool > m_calibrateEnergy
convert energy to new units or use amplitude from RawChannel directly
void TMDB_clearBranch(void)
SG::ReadHandleKey< TileDigitsContainer > m_fltDigitsContainerKey
StatusCode storeTMDBDecision(const EventContext &ctx)
ToolHandle< TileL2Builder > m_l2Builder
ServiceHandle< ITHistSvc > m_thistSvc
TileAANtuple(const std::string &name, ISvcLocator *pSvcLocator)
SG::ReadHandleKey< TileRawChannelContainer > m_wienerRawChannelContainerKey
Gaudi::Property< bool > m_bsInput
true if bytestream file is used
int m_evtNr
event counter
Gaudi::Property< int > m_DCSBranches
mask like 110101 - which DCS branches to fill
Gaudi::Property< int > m_skipEvents
Gaudi::Property< std::string > m_ntupleID
short CheckDMUFormat(uint32_t header)
bit_31 of the DMU header must be 1 and bit_17 of the DMU header must be 0
short CheckDMUParity(uint32_t header)
Parity of the DMU header should be odd.
SG::ReadHandleKey< TileRawChannelContainer > m_qieRawChannelContainerKey
int m_l1Type[N_RODS]
Level1 Type from ROD header.
int m_evTime
event time
float m_sumEz_zz[N_DRAWERS]
Sum Ez recalculated offline using offline OF.
int m_lumiBlock
lumiblock number in a run
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
uint32_t m_dspFlags
DSP flags from BS.
int m_trigType
trigger type (1=Phys, 2=Laser, 4=Ped, 8=CIS)
void CISPAR_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variab...
SG::ReadHandleKey< TileRawChannelContainer > m_fitcRawChannelContainerKey
Gaudi::Property< bool > m_useDspUnits
true if energy should be converted to units used in DSP
void DIGI_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variabl...
float m_sumE_zz[N_DRAWERS]
Sum E recalculated offline using offline OF.
void LASER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree LASER variable...
int m_HHMMSS
event time in HH:MM:SS
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerKey
SG::ReadCondHandleKey< TileHid2RESrcID > m_hid2RESrcIDKey
float m_sumE_yy[N_DRAWERS]
Sum E calcualted inside DSP.
const TileCablingService * m_cabling
cabling tool
SG::ReadHandleKey< TileRawChannelContainer > m_fitRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_mfRawChannelContainerKey
void TRIGGER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER varia...
SG::ReadHandleKey< TileMuonReceiverContainer > m_tileMuRcvContainerKey
int m_evType[N_RODS]
Event Type from ROD header.
SG::ReadHandleKey< TileRawChannelContainer > m_optRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_tileMuRcvRawChannelContainerKey
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Tile Bad Channel tool.
const TileDetDescrManager * m_tileMgr
Pointer to TileDetDescrManager.
int m_evBCID[N_RODS]
Event BCID from ROD header.
char m_dateTime[32]
event date and time
StatusCode ntuple_clear()
const TileHWID * m_tileHWID
float m_las_Temperature
StatusCode ntuple_initialize(const EventContext &ctx, const TileDQstatus &DQstatus)
This AthConstConverter class provides conversion from ByteStream to TileBeamElemContainer.
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Helper class for TileCal online (hardware) identifiers.
Definition TileHWID.h:49
Helper class for TileCal offline identifiers.
Definition TileID.h:67
double chi2(TH1 *h0, TH1 *h1)
float m_chi2Opt[N_ROS2][N_MODULES][N_CHANS]
float m_tWiener[N_ROS2][N_MODULES][N_CHANS]
float m_chi2Fitc[N_ROS2][N_MODULES][N_CHANS]
float m_pedDsp[N_ROS2][N_MODULES][N_CHANS]
float m_chi2Dsp[N_ROS2][N_MODULES][N_CHANS]
short m_rodCRC[N_ROS2][N_MODULES][N_DMUS]
float m_las_PMT_Ped_RMS[TileLaserObject::nbGains][TileLaserObject::nbPmts]
float m_chi2QIE[N_ROS2][N_MODULES][N_CHANS]
short m_fragSize[N_ROS][N_MODULES]
float m_time[N_ROS2][N_MODULES][N_CHANS]
short m_ROD_DMUrodCRC[N_ROS][N_MODULES][N_DMUS]
float m_chi2Fit[N_ROS2][N_MODULES][N_CHANS]
short m_DMUmemoryErr[N_ROS2][N_MODULES][N_DMUS]
uint16_t m_slinkCRC[N_ROS][N_MODULES][2]
short m_ROD_BCID[N_ROS][N_MODULES]
int m_las_PMT_TDC[TileLaserObject::nbGains][TileLaserObject::nbPmts]
float m_chi2[N_ROS2][N_MODULES][N_CHANS]
int m_las_PMT_ADC[TileLaserObject::nbGains][TileLaserObject::nbPmts]
float m_eTMDB[N_ROS][N_MODULES][N_TMDBCHANS]
float m_chi2Wiener[N_ROS2][N_MODULES][N_CHANS]
unsigned char m_bcidTMDB[N_ROS][N_MODULES][3]
float m_pedMF[N_ROS2][N_MODULES][N_CHANS]
float m_tQIE[N_ROS2][N_MODULES][N_CHANS]
float m_las_D_Alpha[TileLaserObject::nbGains][TileLaserObject::nbDiodes]
float m_ped[N_ROS2][N_MODULES][N_CHANS]
float m_tOF1[N_ROS2][N_MODULES][N_CHANS]
float m_TEMP[4][64][7]
uint16_t m_dmuMask[N_ROS][N_MODULES][2]
short m_CHSTATUS[4][64][48]
float m_las_D_Ped_RMS[TileLaserObject::nbGains][TileLaserObject::nbDiodes]
short m_DMUSstrobeErr[N_ROS2][N_MODULES][N_DMUS]
short m_DMUformatErr[N_ROS2][N_MODULES][N_DMUS]
unsigned char * m_sampleTMDB
short m_ROD_GlobalCRC[N_ROS][N_MODULES]
float m_pedFitc[N_ROS2][N_MODULES][N_CHANS]
float m_tDsp[N_ROS2][N_MODULES][N_CHANS]
int m_las_D_ADC[TileLaserObject::nbGains][TileLaserObject::nbDiodes]
short m_ROD_DMUHeadformatErr[N_ROS][N_MODULES][N_DMUS]
short m_DMUparityErr[N_ROS2][N_MODULES][N_DMUS]
float m_las_D_AlphaPed[TileLaserObject::nbGains][TileLaserObject::nbDiodes]
float m_tFit[N_ROS2][N_MODULES][N_CHANS]
float m_eWiener[N_ROS2][N_MODULES][N_CHANS]
float m_eFit[N_ROS2][N_MODULES][N_CHANS]
short m_ROD_DMUfeCRC[N_ROS][N_MODULES][N_DMUS]
float m_pedFit[N_ROS2][N_MODULES][N_CHANS]
short m_ROD_DMUmemoryErr[N_ROS][N_MODULES][N_DMUS]
float m_las_D_AlphaPed_RMS[TileLaserObject::nbGains][TileLaserObject::nbDiodes]
float m_HV[4][64][48]
float m_eOpt[N_ROS2][N_MODULES][N_CHANS]
float m_eQIE[N_ROS2][N_MODULES][N_CHANS]
unsigned char m_decisionTMDB[N_ROS][N_MODULES][N_TMDBDECISIONS]
float m_pedWiener[N_ROS2][N_MODULES][N_CHANS]
short m_ROD_DMUBCIDErr[N_ROS][N_MODULES][N_DMUS]
short m_feCRC[N_ROS2][N_MODULES][N_DMUS]
short m_ROD_DMUSstrobeErr[N_ROS][N_MODULES][N_DMUS]
short m_DMUbcid[N_ROS2][N_MODULES][N_DMUS]
short m_ROD_DMUDataformatErr[N_ROS][N_MODULES][N_DMUS]
float m_ene[N_ROS2][N_MODULES][N_CHANS]
short m_gainFlt[N_ROS2][N_MODULES][N_CHANS]
float m_pedOF1[N_ROS2][N_MODULES][N_CHANS]
short m_HVSTATUS[4][64][48]
float m_las_D_Alpha_RMS[TileLaserObject::nbGains][TileLaserObject::nbDiodes]
short m_rodBCID[N_ROS][N_MODULES]
float m_pedQIE[N_ROS2][N_MODULES][N_CHANS]
short m_ROD_DMUDataparityErr[N_ROS][N_MODULES][N_DMUS]
uint32_t m_DMUheader[N_ROS2][N_MODULES][N_DMUS]
short m_ROD_DMUDstrobeErr[N_ROS][N_MODULES][N_DMUS]
short m_gain[N_ROS2][N_MODULES][N_CHANS]
float m_eOF1[N_ROS2][N_MODULES][N_CHANS]
short m_DRSTATUS[4][64]
float m_eFitc[N_ROS2][N_MODULES][N_CHANS]
float m_chi2OF1[N_ROS2][N_MODULES][N_CHANS]
short m_DMUDstrobeErr[N_ROS2][N_MODULES][N_DMUS]
float m_pedOpt[N_ROS2][N_MODULES][N_CHANS]
float m_las_D_Ped[TileLaserObject::nbGains][TileLaserObject::nbDiodes]
float m_HVSET[4][64][48]
float m_chi2MF[N_ROS2][N_MODULES][N_CHANS]
float m_tOpt[N_ROS2][N_MODULES][N_CHANS]
uint16_t m_ROD_DMUMask[N_ROS][N_MODULES][2]
float m_eDsp[N_ROS2][N_MODULES][N_CHANS]
float m_tFitc[N_ROS2][N_MODULES][N_CHANS]
short m_ROD_DMUHeadparityErr[N_ROS][N_MODULES][N_DMUS]
float m_las_PMT_Ped[TileLaserObject::nbGains][TileLaserObject::nbPmts]