ATLAS Offline Software
Loading...
Searching...
No Matches
TileTBAANtuple.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3*/
4
5//*****************************************************************************
6// Filename : TileTBAANtuple.cxx
7// Author : Luca Fiorini
8// Created : Mar, 2007
9//
10// DESCRIPTION:
11// Implement the algorithm to save TB Beam ROD dataX
12//
13// HISTORY:
14//
15// BUGS:
16//
17//*****************************************************************************
18
19//Gaudi Includes
20//#include "GaudiKernel/ITHistSvc.h"
21
22//Event info
23#include "xAODEventInfo/EventInfo.h"
24
25#include "PathResolver/PathResolver.h"
26#include "StoreGate/ReadCondHandle.h"
27
28#include <cmath>
29
30//Calo includes
31#include "CaloIdentifier/CaloCell_ID.h"
32#include "CaloIdentifier/CaloID.h"
33
34//TileCalo includes
35#include "CaloIdentifier/TileID.h"
36#include "TileIdentifier/TileHWID.h"
37#include "TileIdentifier/TileTBFrag.h"
38#include "TileCalibBlobObjs/TileCalibUtils.h"
39#include "TileConditions/TileCablingService.h"
40#include "TileByteStream/TileBeamElemContByteStreamCnv.h"
41#include "TileByteStream/TileLaserObjByteStreamCnv.h"
42#include "TileTBRec/TileTBAANtuple.h"
43
44#include <fstream>
45#include <sstream>
46
47#define WRONG_SAMPLE(frag,chan,size) \
48msg(MSG::ERROR) << "Wrong no. of samples (" << size \
49 << ") for channel " << chan \
50 << " in frag 0x"<<MSG::hex << frag << MSG::dec \
51 << " - " << BeamFragName[frag&0x1F] << endmsg;
52
53#define WRONG_CHANNEL(frag,chan) \
54msg(MSG::ERROR) << "Wrong channel " << chan \
55 << " in frag 0x"<<MSG::hex << frag << MSG::dec \
56 << " - " << BeamFragName[frag&0x1F] << endmsg;
57
58#define FRAG_FOUND(frag,chan,size) \
59if (msgLvl(MSG::DEBUG)) \
60 msg(MSG::DEBUG) << "Found channel " << chan \
61 << " in frag 0x"<<MSG::hex << frag << MSG::dec \
62 << " - " << BeamFragName[frag&0x1F] \
63 << " of size " << size << endmsg;
64
65
66#define SIGNAL_FOUND(frag,chan,amplitude) \
67if (msgLvl(MSG::DEBUG)) \
68 msg(MSG::DEBUG) << "Found channel " << chan \
69 << " in frag 0x"<<MSG::hex << frag << MSG::dec \
70 << " - " << BeamFragName[frag&0x1F] \
71 << " with amp=" << amplitude << endmsg;
72
73#define MAX_DRAWERS 256
74#define N_CHANS 48
75#define N_DMUS 16
76
77// Constructor & deconstructor
81
82TileTBAANtuple::TileTBAANtuple(const std::string& name, ISvcLocator* pSvcLocator)
83 : AthAlgorithm(name, pSvcLocator)
84 , m_thistSvc("THistSvc", name)
85 , m_rchUnit(TileRawChannelUnit::MegaElectronVolts)
86 , m_dspUnit(TileRawChannelUnit::ADCcounts)
87{
88
89 char frg[6] = "0x000";
90 m_beamFragList.clear();
91 for (unsigned int i=0; i<sizeof(m_beamIdList)/sizeof(bool); ++i) {
92 m_beamIdList[i] = false;
93 // no coins trig by default (this is the case for 2004)
94 if (i <= ECAL_ADC_FRAG || i >= COMMON_ADC1_FRAG ) {
95 sprintf(frg,"0x%3.3x",i);
96 m_beamFragList.value().push_back((std::string)frg);
97 }
98 }
99
100}
101
102StatusCode TileTBAANtuple::initialize() {
103 ATH_CHECK( m_samplingFractionKey.initialize(SG::AllowEmpty) );
104 m_saveFelixData = !(m_digitsContainerFlxKey.empty() && m_flxOptRawChannelContainerKey.empty() && m_flxFitRawChannelContainerKey.empty());
105
106 ATH_CHECK( m_digitsContainerKey.initialize(SG::AllowEmpty) );
107 ATH_CHECK( m_digitsContainerFlxKey.initialize(SG::AllowEmpty) );
108 ATH_CHECK( m_beamElemContainerKey.initialize(SG::AllowEmpty) );
109 ATH_CHECK( m_flatRawChannelContainerKey.initialize(SG::AllowEmpty) );
110 ATH_CHECK( m_fitRawChannelContainerKey.initialize(SG::AllowEmpty) );
111 ATH_CHECK( m_optRawChannelContainerKey.initialize(SG::AllowEmpty) );
112 ATH_CHECK( m_dspRawChannelContainerKey.initialize(SG::AllowEmpty) );
113 ATH_CHECK( m_fitcRawChannelContainerKey.initialize(SG::AllowEmpty) );
114 ATH_CHECK( m_flxFitRawChannelContainerKey.initialize(SG::AllowEmpty) );
115 ATH_CHECK( m_flxOptRawChannelContainerKey.initialize(SG::AllowEmpty) );
116 ATH_CHECK( m_laserObjectKey.initialize(SG::AllowEmpty) );
117 ATH_CHECK( m_hitContainerKey.initialize(SG::AllowEmpty) );
118 ATH_CHECK( m_hitVectorKey.initialize(SG::AllowEmpty) );
119 ATH_CHECK( m_cellContainerKey.initialize(!m_cellContainerKey.empty() && m_completeNtuple && m_TBperiod < 2015) );
120
121 ATH_CHECK( m_tileToolEmscale.retrieve() );
122 ATH_CHECK( m_adderFilterAlgTool.retrieve(EnableTool{m_unpackAdder}) );
123
124 ATH_CHECK( m_dqStatusKey.initialize(SG::AllowEmpty) );
125
126 return StatusCode::SUCCESS;
127}
128
135StatusCode TileTBAANtuple::ntuple_initialize(const EventContext& ctx) {
136
137 CHECK( m_thistSvc.retrieve() );
138
139 // find TileCablingService
140 m_cabling = TileCablingService::getInstance();
141
142 // retrieve TileID helper from det store
143
144 CHECK( detStore()->retrieve(m_tileID) );
145
146 CHECK( detStore()->retrieve(m_tileHWID) );
147
148 if (m_nSamples < 0) {
149 m_nSamples = 7;
150 }
151 if (m_nSamplesFlx < 0) {
152 m_nSamplesFlx = m_saveFelixData ? 32 : 0;
153 }
154
155 if (m_TBperiod >= 2015) {
156 m_unpackAdder = false;
157
158 if (m_TBperiod == 2015) {
159 m_nDrawers = 2;
160 m_drawerList.value().resize(m_nDrawers);
161 m_drawerType.value().resize(m_nDrawers);
162 m_drawerList[0] = "0x200"; m_drawerType[0] = 2; // barrel neg
163 m_drawerList[1] = "0x401"; m_drawerType[1] = 4; // ext.barrel neg
164 } else if (m_TBperiod == 2016 || m_TBperiod == 2018 || m_TBperiod == 2021 || m_TBperiod == 2022) {
165 m_nDrawers = 5;
166 m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
167 m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
168 m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
169 m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
170 m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
171 m_drawerList[4] = "0x402"; m_drawerType[4] = 4; // ext.barrel neg
172 } else if (m_TBperiod == 2017) {
173 m_nDrawers = 6;
174 m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
175 m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
176 m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
177 m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
178 m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
179 m_drawerList[4] = "0x203"; m_drawerType[4] = 2; // barrel neg
180 m_drawerList[5] = "0x402"; m_drawerType[5] = 4; // ext.barrel neg
181 } else if (m_TBperiod == 2019) {
182 m_nDrawers = 7;
183 m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
184 m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
185 m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
186 m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
187 m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
188 m_drawerList[4] = "0x203"; m_drawerType[4] = 2; // barrel neg
189 m_drawerList[5] = "0x402"; m_drawerType[5] = 4; // ext.barrel neg
190 m_drawerList[6] = "0x405"; m_drawerType[6] = 4; // ext.barrel neg
191 }
192
193 if (m_TBperiod < 2016) {
194 setupBeamChambersTB2015();
195 } else if (m_TBperiod < 2021) {
196 setupBeamChambersTB2016_2020();
197 } else {
198 // Strating from 2021 the following properties should be setup via JO
199 checkIsPropertySetup(m_beamBC1X1, "BC1X1");
200 checkIsPropertySetup(m_beamBC1X2, "BC1X2");
201 checkIsPropertySetup(m_beamBC1Y1, "BC1Y1");
202 checkIsPropertySetup(m_beamBC1Y2, "BC1Y2");
203 checkIsPropertySetup(m_beamBC1Z, "BC1Z");
204 checkIsPropertySetup(m_beamBC1Z_0, "BC1Z_0");
205 checkIsPropertySetup(m_beamBC1Z_90, "BC1Z_90");
206 checkIsPropertySetup(m_beamBC1Z_min90, "BC1Z_min90");
207
208 checkIsPropertySetup(m_beamBC2X1, "BC2X1");
209 checkIsPropertySetup(m_beamBC2X2, "BC2X2");
210 checkIsPropertySetup(m_beamBC2Y1, "BC2Y1");
211 checkIsPropertySetup(m_beamBC2Y2, "BC2Y2");
212 checkIsPropertySetup(m_beamBC2Z, "BC2Z");
213 checkIsPropertySetup(m_beamBC2Z_0, "BC2Z_0");
214 checkIsPropertySetup(m_beamBC2Z_90, "BC2Z_90");
215 checkIsPropertySetup(m_beamBC2Z_min90, "BC2Z_min90");
216 }
217
218 } else {
219 setupBeamChambersBeforeTB2015();
220 }
221
222
223 if (m_unpackAdder) {
224 // get TileRawChannelBuilderFlatFilter for adder energy calculation
225
226 StatusCode sc;
227 sc &= m_adderFilterAlgTool->setProperty("TileRawChannelContainer", "TileAdderFlat");
228 sc &= m_adderFilterAlgTool->setProperty("calibrateEnergy", "true");
229
230 sc &= m_adderFilterAlgTool->setProperty("PedStart", "0");
231 sc &= m_adderFilterAlgTool->setProperty("PedLength", "1");
232 sc &= m_adderFilterAlgTool->setProperty("PedOffset", "0");
233 sc &= m_adderFilterAlgTool->setProperty("SignalStart", "1");
234 sc &= m_adderFilterAlgTool->setProperty("SignalLength", "15");
235 sc &= m_adderFilterAlgTool->setProperty("FilterLength", "5");
236 sc &= m_adderFilterAlgTool->setProperty("FrameLength", "16");
237 sc &= m_adderFilterAlgTool->setProperty("DeltaCutLo", "9.5");
238 sc &= m_adderFilterAlgTool->setProperty("DeltaCutHi", "9.5");
239 sc &= m_adderFilterAlgTool->setProperty("RMSCutLo", "1.0");
240 sc &= m_adderFilterAlgTool->setProperty("RMSCutHi", "1.0");
241 if (sc.isFailure()) {
242 ATH_MSG_ERROR("Failure setting properties of " << m_adderFilterAlgTool);
243 return StatusCode::FAILURE;
244 }
245 }
246
247 if (m_finalUnit < TileRawChannelUnit::ADCcounts
248 || m_finalUnit > TileRawChannelUnit::OnlineMegaElectronVolts) {
249
250 m_finalUnit = -1;
251 if (!m_useDspUnits && m_calibrateEnergy) {
252 m_useDspUnits = true;
253 ATH_MSG_INFO( "Final offline units are not set, will use DSP units" );
254 }
255 }
256
257 if (!m_calibrateEnergy) {
258 if (m_useDspUnits) {
259 ATH_MSG_INFO( "calibrateEnergy is disabled, don't want to use DSP units" );
260 m_useDspUnits = false;
261 }
262 }
263
264 ATH_MSG_INFO( "TestBeam period " << m_TBperiod.value() );
265 ATH_MSG_INFO( "calibMode " << m_calibMode.value() );
266 ATH_MSG_INFO( "calibrateEnergy " << m_calibrateEnergy.value() );
267 ATH_MSG_INFO( "offlineUnits " << m_finalUnit.value() );
268 ATH_MSG_INFO( "useDspUnits " << m_useDspUnits.value() );
269 ATH_MSG_INFO( "number of samples " << m_nSamples.value() );
270
271
272 msg(MSG::INFO) << "drawerList " << MSG::hex;
273 unsigned int size = m_drawerList.size();
274 for (unsigned int dr = 0; dr < size; ++dr) {
275 int frag = strtol(m_drawerList[dr].data(), NULL, 0);
276 if (frag >= 0) {
277 m_drawerMap[frag] = dr;
278 if (dr == m_drawerType.size()) m_drawerType.value().push_back(frag >> 8);
279 msg(MSG::INFO) << " 0x" << frag;
280 } else {
281 msg(MSG::INFO) << " " << m_drawerList[dr];
282 // put negative number in first element (flag to read frag ID from data)
283 m_drawerList[0] = m_drawerList[dr];
284 m_drawerList.value().resize(1);
285 // m_drawerType.clear();
286 m_drawerMap.clear();
287 size = 0;
288 break;
289 }
290 }
291 if (size == 0) {
292 if (m_drawerList.size() > 0)
293 msg(MSG::INFO) << " - negative number, will read frag IDs from the data" << MSG::dec << endmsg;
294 else
295 msg(MSG::INFO) << "is empty, no drawer fragments in ntuple" << MSG::dec << endmsg;
296 } else {
297 msg(MSG::INFO) << MSG::dec << endmsg;
298
299 size = m_drawerType.size();
300 if (size < m_nDrawers) {
301 m_drawerType.value().resize(m_nDrawers);
302 for (; size < m_nDrawers; ++size)
303 m_drawerType[size] = 0;
304 }
305
306 msg(MSG::INFO) << MSG::INFO << "drawerType ";
307 for (unsigned int dr = 0; dr < size; ++dr)
308 msg(MSG::INFO) << " " << m_drawerType[dr];
309 msg(MSG::INFO) << endmsg;
310
311 if (size > m_nDrawers) {
312 ATH_MSG_INFO( "increasing m_nDrawers from " << m_nDrawers << " to " << size );
313 m_nDrawers = size;
314 }
315 }
316
317 msg(MSG::INFO) << MSG::INFO << "Beam Frag List " << MSG::hex;
318 size = m_beamFragList.size();
319 for (unsigned int dr = 0; dr < size; ++dr) {
320 int frag = strtol(m_beamFragList[dr].data(), NULL, 0);
321 if (frag >= 0) {
322 m_beamIdList[frag & 0x1F] = true;
323 msg(MSG::INFO) << " 0x" << frag;
324 }
325 }
326 if (size == 0) {
327 msg(MSG::INFO) << "is empty, no beam fragments in ntuple" << MSG::dec << endmsg;
328 } else {
329 msg(MSG::INFO) << MSG::dec << endmsg;
330 }
331
332 // set event number to 0 before first event
333 m_evtNr = 0;
334 m_calibrateEnergyThisEvent = m_calibrateEnergy;
335
336 // find event and beam ROD header, calib mode for digitizers
337
341 if (m_evtNr == 0) {
342 if (m_unpackAdder) // in 2003 event number starts from 1
343 ++m_evtNr;
344 }
345
346 if (initList(ctx).isFailure()) {
347 ATH_MSG_ERROR( " Error during drawer list initialization" );
348 }
349
350 if (m_saveFelixData && initListFlx(ctx).isFailure()) {
351 ATH_MSG_ERROR( " Error during drawer list initialization" );
352 }
353
354 if (initNTuple().isFailure()) {
355 ATH_MSG_ERROR( " Error during ntuple initialization" );
356 }
357
358 ATH_MSG_INFO( "initialization completed" );
359 return StatusCode::SUCCESS;
360}
361
362StatusCode TileTBAANtuple::execute(const EventContext& ctx) {
363
364 const TileDQstatus* dqStatus = (!m_dqStatusKey.empty()) ? SG::makeHandle(m_dqStatusKey, ctx).get() : nullptr;
365
366 if (m_evtNr < 0) {
367
368 //bool calibMode = (m_beamInfo->calibMode() == 1);
369 //if ( calibMode != m_calibMode ) {
370 // ATH_MSG_INFO( "Calib mode from data is " << calibMode );
371 // ATH_MSG_INFO( " Overwriting calib mode " );
372 // m_calibMode = calibMode;
373 //}
374
375 if (ntuple_initialize(ctx).isFailure()) {
376 ATH_MSG_ERROR( "ntuple_initialize failed" );
377 }
378
379 }
380
381 m_dspFlags = 0;
382 if (ntuple_clear().isFailure()) {
383 ATH_MSG_ERROR( "ntuple_clear failed" );
384 }
385
386 if (m_evtNr % 1000 == 0)
387 ATH_MSG_INFO( m_evtNr << " events processed so far" );
388
389 m_run = ctx.eventID().run_number();
390 m_evt = ctx.eventID().event_number();
391
392 //Get timestamp of the event
393 if (ctx.eventID().time_stamp() > 0) {
394 m_evTime = ctx.eventID().time_stamp();
395 }
396
397 // store BeamElements
398 bool empty = storeBeamElements(ctx).isFailure();
399
400 //store Laser Object
401 empty &= storeLaser(ctx).isFailure();
402
403 if (m_drawerMap.size() > 0) {
404
405 // store TileDigits
406 if (m_nSamples > 0) {
407 empty &= (storeDigits(ctx, m_digitsContainerKey, dqStatus).isFailure());
408 }
409 if (m_nSamplesFlx > 0) {
410 empty &= (storeDigitsFlx(ctx, m_digitsContainerFlxKey).isFailure());
411 }
412
413 // store TileRawChannels
414 // start from DSP channels - so we can find out what is the DSP units
415 empty &= (storeRawChannels(ctx, m_dspRawChannelContainerKey, m_calibMode, &m_eDspVec, &m_tDspVec, &m_chi2DspVec, nullptr, true).isFailure());
416 empty &= (storeRawChannels(ctx, m_fitRawChannelContainerKey, m_calibMode, &m_efitVec, &m_tfitVec, &m_chi2Vec, &m_pedfitVec).isFailure());
417 empty &= (storeRawChannels(ctx, m_flxFitRawChannelContainerKey, true, &m_eflxfitVec, &m_tflxfitVec, &m_chi2flxfitVec, &m_pedflxfitVec).isFailure());
418 empty &= (storeRawChannels(ctx, m_optRawChannelContainerKey, m_calibMode, &m_eOptVec, &m_tOptVec, &m_chi2OptVec, &m_pedOptVec).isFailure());
419 empty &= (storeRawChannels(ctx, m_flxOptRawChannelContainerKey, true, &m_eflxoptVec, &m_tflxoptVec, &m_chi2flxoptVec, &m_pedflxoptVec).isFailure());
420 empty &= (storeRawChannels(ctx, m_fitcRawChannelContainerKey, m_calibMode, &m_efitcVec, &m_tfitcVec, &m_chi2cVec, &m_pedfitcVec).isFailure());
421 empty &= (storeRawChannels(ctx, m_flatRawChannelContainerKey, m_calibMode, &m_eneVec, &m_timeVec, &m_chi2FlatVec, &m_pedFlatVec).isFailure());
422
423 empty &= (storeHitVector(ctx).isFailure());
424 empty &= (storeHitContainer(ctx).isFailure());
425 }
426
427
428 if (m_completeNtuple && m_TBperiod < 2015) {
429 // store energy per sampling from all calorimeters
430 empty &= (storeCells(ctx).isFailure());
431 }
432
433 // increase event nr
434 // this number can be different from real event number if we skip events
435
436 if (empty) {
437 ATH_MSG_WARNING( "Error in execute " );
438 }
439
440 m_ntuplePtr->Fill();
441
442 ++m_evtNr;
443
444 // Execution completed.
445 ATH_MSG_DEBUG( "execute() completed successfully" );
446
447 return StatusCode::SUCCESS;
448}
449
450//
451// Here the LASER object is opened and corresponding variable are stored
452//
453
454
455StatusCode TileTBAANtuple::storeLaser(const EventContext& ctx) {
456
457 if (m_laserObjectKey.empty()) { // empty name, nothing to do
458 return StatusCode::FAILURE;
459 }
460
461 // Read Hit Vector from TDS
462 const TileLaserObject* laserObj = SG::makeHandle (m_laserObjectKey, ctx).get();
463
464 m_las_BCID = laserObj->getBCID();
465
466 m_las_Filt = laserObj->getFiltNumber();
467 m_las_ReqAmp = laserObj->getDiodeCurrOrd();
468 m_las_MeasAmp = laserObj->getDiodeCurrMeas();
469
470
471 m_las_D1_ADC = laserObj->getDiodeADC(0);
472 m_las_D2_ADC = laserObj->getDiodeADC(1);
473 m_las_D3_ADC = laserObj->getDiodeADC(2);
474 m_las_D4_ADC = laserObj->getDiodeADC(3);
475
476 m_las_D1_Ped = laserObj->getDiodePedestal(0);
477 m_las_D2_Ped = laserObj->getDiodePedestal(1);
478 m_las_D3_Ped = laserObj->getDiodePedestal(2);
479 m_las_D4_Ped = laserObj->getDiodePedestal(3);
480
481 m_las_D1_Ped_RMS = laserObj->getDiodeSigmaPedestal(0);
482 m_las_D2_Ped_RMS = laserObj->getDiodeSigmaPedestal(1);
483 m_las_D3_Ped_RMS = laserObj->getDiodeSigmaPedestal(2);
484 m_las_D4_Ped_RMS = laserObj->getDiodeSigmaPedestal(3);
485
486 m_las_D1_Alpha = laserObj->getAlpha(0);
487 m_las_D2_Alpha = laserObj->getAlpha(1);
488 m_las_D3_Alpha = laserObj->getAlpha(2);
489 m_las_D4_Alpha = laserObj->getAlpha(3);
490
491 m_las_D1_Alpha_RMS = laserObj->getSigmaAlpha(0);
492 m_las_D2_Alpha_RMS = laserObj->getSigmaAlpha(1);
493 m_las_D3_Alpha_RMS = laserObj->getSigmaAlpha(2);
494 m_las_D4_Alpha_RMS = laserObj->getSigmaAlpha(3);
495
496 m_las_D1_AlphaPed = laserObj->getPedestalAlpha(0);
497 m_las_D2_AlphaPed = laserObj->getPedestalAlpha(1);
498 m_las_D3_AlphaPed = laserObj->getPedestalAlpha(2);
499 m_las_D4_AlphaPed = laserObj->getPedestalAlpha(3);
500
501 m_las_D1_AlphaPed_RMS = laserObj->getSigmaPedAlpha(0);
502 m_las_D2_AlphaPed_RMS = laserObj->getSigmaPedAlpha(1);
503 m_las_D3_AlphaPed_RMS = laserObj->getSigmaPedAlpha(2);
504 m_las_D4_AlphaPed_RMS = laserObj->getSigmaPedAlpha(3);
505
506 m_las_PMT1_ADC = laserObj->getPMADC(0);
507 m_las_PMT2_ADC = laserObj->getPMADC(1);
508
509 m_las_PMT1_TDC = laserObj->getTDC(0);
510 m_las_PMT2_TDC = laserObj->getTDC(1);
511
512 m_las_PMT1_Ped = laserObj->getPMPedestal(0);
513 m_las_PMT2_Ped = laserObj->getPMPedestal(1);
514
515 m_las_PMT1_Ped_RMS = laserObj->getPMSigmaPedestal(0);
516 m_las_PMT2_Ped_RMS = laserObj->getPMSigmaPedestal(1);
517
518 m_las_Temperature = laserObj->getPumpDiodeTemp();
519
520 ATH_MSG_DEBUG( "storeLaser() completed" );
521
522 return StatusCode::SUCCESS;
523}
524
525StatusCode TileTBAANtuple::storeBeamElements(const EventContext& ctx) {
526
527 if ( m_beamElemContainerKey.empty()) {
528 return StatusCode::SUCCESS;
529 }
530
531 // Read Beam Elements from TES
532 const TileBeamElemContainer* beamElemCnt = SG::makeHandle (m_beamElemContainerKey, ctx).get();
533
534 TileBeamElemContainer::const_iterator collItr = beamElemCnt->begin();
535 TileBeamElemContainer::const_iterator lastColl = beamElemCnt->end();
536
537 if ( m_completeNtuple ) {
538 // Store ROD header info from collection (just from first one)
539 int nDrawersAll = m_nDrawers.value() + m_nDrawersFlx.value();
540 if ( collItr!=lastColl ) {
541 m_l1ID.at(nDrawersAll) = (*collItr)->getLvl1Id();
542 m_l1Type.at(nDrawersAll) = (*collItr)->getLvl1Type();
543 m_evType.at(nDrawersAll) = (*collItr)->getDetEvType();
544 m_evBCID.at(nDrawersAll) = (*collItr)->getRODBCID();
545 } else {
546 m_l1ID.at(nDrawersAll) = 0xFFFFFFFF;
547 m_l1Type.at(nDrawersAll) = 0xFFFFFFFF;
548 m_evType.at(nDrawersAll) = 0xFFFFFFFF;
549 m_evBCID.at(nDrawersAll) = 0xFFFFFFFF;
550 }
551 }
552
553
554 m_trigType = 0;
555
556 for(; collItr != lastColl; ++collItr) {
557
558 TileBeamElemCollection::const_iterator beamItr=(*collItr)->begin();
559 TileBeamElemCollection::const_iterator lastBeam=(*collItr)->end();
560
561 if (msgLvl(MSG::VERBOSE)) {
562
563 for (; beamItr != lastBeam; ++beamItr) {
564 HWIdentifier id = (*beamItr)->adc_HWID();
565 std::vector<uint32_t> digits = (*beamItr)->get_digits();
566 msg(MSG::VERBOSE) << " --- TileBeamElem -- Identifier " << m_tileHWID->to_string(id)
567 << MSG::hex << " frag: 0x" << (*collItr)->identify()
568 << MSG::dec << " channel " << m_tileHWID->channel(id)
569 << " digits size " << digits.size() << endmsg;
570 msg(MSG::VERBOSE) << " --- TileBeamElem -- BeamElem : ";
571 for (unsigned int k = 0; k < digits.size(); k++)
572 msg(MSG::VERBOSE) << digits[k] << " ";
573 msg(MSG::VERBOSE) << endmsg;
574 }
575 //restore iterator
576 beamItr = (*collItr)->begin();
577 }
578
579 int frag = (*collItr)->identify();
580 ATH_MSG_DEBUG( " frag: " << frag );
581 ATH_MSG_DEBUG( " trigType " << (*collItr)->getLvl1Type() );
582
583 if ( m_trigType == 0 && (*collItr)->getLvl1Type() != 0 ) // take it from the ROD header
584 m_trigType = (*collItr)->getLvl1Type();
585
586 // unpack only fragments which we want to store in ntuple
587 if ( m_beamIdList[frag&0x1F] ) {
588
589 for (; beamItr != lastBeam; ++beamItr) {
590
591 HWIdentifier id = (*beamItr)->adc_HWID();
592 std::vector<uint32_t> digits = (*beamItr)->get_digits();
593 int cha = m_tileHWID->channel(id);
594 int dsize = digits.size();
595
596 if ( dsize <= 0 ) {
597
598 WRONG_SAMPLE(frag,cha,dsize);
599
600 } else if ( dsize != 16 && frag == ADD_FADC_FRAG ) {
601
602 WRONG_SAMPLE(frag,cha,dsize);
603
604 } else if ( dsize != 1 && frag != ADD_FADC_FRAG &&
605 frag != BEAM_TDC_FRAG && frag != COMMON_TDC1_FRAG &&
606 frag != COMMON_TOF_FRAG && frag != COMMON_TDC2_FRAG &&
607 !(frag == ECAL_ADC_FRAG)) {
608
609 WRONG_SAMPLE(frag,cha,dsize);
610
611 } else {
612
613 uint32_t amplitude = digits[0];
614 SIGNAL_FOUND(frag, cha, amplitude);
615
616 switch (frag) {
617
618 case BEAM_TDC_FRAG:
619
620 FRAG_FOUND(frag,cha,dsize);
621 if(cha < 8) m_btdc1[cha] = amplitude;
622 else if(cha < 16) m_btdc2[cha-8] = amplitude;
623 else WRONG_CHANNEL(frag,cha);
624 break;
625
626 case BEAM_ADC_FRAG:
627
628 if ( m_TBperiod >= 2015 ) {
629 switch(cha) {
630 // BEAM
631 case 0: m_s1cou = amplitude; break;
632 case 1: m_s2cou = amplitude; break;
633 case 2: m_s3cou = amplitude; break;
634 case 3: m_cher1 = amplitude; break; // ATH_MSG_VERBOSE("load beam adc " << m_cher1); break;
635 case 4: m_cher2 = amplitude; break;
636 case 5: m_muTag = amplitude; break;
637 case 6: m_muHalo= amplitude; break;
638 case 7: m_muVeto= amplitude; break;
639 default: WRONG_CHANNEL(frag, cha);
640 }
641 } else if ( m_unpackAdder ) {
642 switch(cha) {
643 // BEAM
644 case 0: m_s1cou = amplitude; break;
645 case 1: m_s2cou = amplitude; break;
646 case 2: m_s3cou = amplitude; break;
647 case 3: m_cher1 = amplitude; break; // swap of Cher1
648 case 4: m_muTag = amplitude; break; // and S4 in 2003 data
649 case 5: m_cher2 = amplitude; break;
650 case 6: m_muHalo= amplitude; break;
651 case 7: m_muVeto= amplitude; break;
652 // LASER
653 case 8: m_las0 = amplitude; break;
654 case 9: m_las1 = amplitude; break;
655 case 10: m_las2 = amplitude; break;
656 case 11: m_las3 = amplitude; break;
657 case 12: m_lasExtra[0] = amplitude; break;
658 case 13: m_lasExtra[1] = amplitude; break;
659 case 14: m_lasExtra[2] = amplitude; break;
660 case 15: m_lasExtra[3] = amplitude; break;
661 default: WRONG_CHANNEL(frag, cha);
662 }
663 } else { // 2004 data
664 switch(cha) {
665 // BEAM
666 case 0: m_sc1 = amplitude; break;
667 case 1: m_sc2 = amplitude; break;
668 case 2:
669 case 3:
670 case 4:
671 case 5:
672 case 6:
673 case 7: break;
674 default: WRONG_CHANNEL(frag, cha);
675 }
676 }
677 break;
678
679 case MUON_ADC_FRAG:
680
681 // first 14 are m_muBack
682 if(cha < 14) m_muBack[cha] = amplitude;
683 // last 2 are m_muCalib
684 else if (cha < 16) m_muCalib[cha - 14] = amplitude;
685 else WRONG_CHANNEL(frag, cha);
686 break;
687
688 case ADDR_ADC_FRAG:
689
690 // second half of Muon Wall in 2004
691 if(cha < 6) m_muBack[cha + 8] = amplitude;
692 // last 2 are m_muCalib
693 else if (cha < 8) m_muCalib[cha - 6] = amplitude;
694 else WRONG_CHANNEL(frag,cha);
695 break;
696
697 case LASE_PTN_FRAG:
698
699 if (cha == 0) {
700 // laser pattern unit
701 m_lasFlag = amplitude;
702 if (amplitude & 0xFF00) m_trigType = amplitude >> 8;
703 } else {
704 WRONG_CHANNEL(frag, cha);
705 }
706 break;
707
708 case LASE_ADC_FRAG:
709
710 // laser in 2004
711 switch(cha) {
712 case 0: m_las0 = amplitude; break;
713 case 1: m_las1 = amplitude; break;
714 case 2: m_las2 = amplitude; break;
715 case 3: m_las3 = amplitude; break;
716 case 4: m_lasExtra[0] = amplitude; break;
717 case 5: m_lasExtra[1] = amplitude; break;
718 case 6: m_lasExtra[2] = amplitude; break;
719 case 7: m_lasExtra[3] = amplitude; break;
720 default: WRONG_CHANNEL(frag,cha);
721 }
722 break;
723
724 case ADD_FADC_FRAG:
725
726 if (m_unpackAdder) {
727
728 for (int k = 0; k < dsize; k++) {
729 //m_addx[k]=k;
730 //check how the matrix is filled
731 m_adder[cha][k] = digits[k];
732 }
733 // FlatFiler adders
734 double ene, tim;
735 m_adderFilterAlgTool->flatFilter(digits, 0, ene, tim);
736 m_eneAdd[cha] = ene;
737 m_timeAdd[cha] = tim;
738 }
739
740 break;
741
742 case ECAL_ADC_FRAG:
743
744 if (m_TBperiod > 2015) {
745
746 if(cha < 15) {
747 m_qdc[cha] = amplitude;
748 ATH_MSG_VERBOSE( "QDC: " << cha << " amp: " << amplitude);
749 } else if (cha == 15) {
750 for (int idx = 0; idx < dsize && idx < 18; ++idx) {
751 m_qdc[idx + 15] = digits[idx];
752 ATH_MSG_VERBOSE("QDC2: " << cha << " amp: " << amplitude);
753 }
754 } else {
755 WRONG_CHANNEL(frag, cha);
756 }
757
758 } else {
759 if(cha < 8) m_ecal[cha] = amplitude;
760 else WRONG_CHANNEL(frag, cha);
761 }
762
763 break;
764
765 case DIGI_PAR_FRAG:
766
767 if(cha < 16) m_cispar[cha] = amplitude; //m_cispar->at(cha)=amplitude;
768 else WRONG_CHANNEL(frag,cha);
769 break;
770
771 case COMMON_ADC1_FRAG:
772 if (m_TBperiod > 2015) {
773 if (cha < 16) {
774 if (m_run > 2211444) {
775 switch(cha) {
776 // BEAM
777 case 0: m_s1cou = amplitude; break;
778 case 1: m_s2cou = amplitude; break;
779 case 2: {
780 if (m_run < 2310000) {
781 m_muBack[10] = amplitude;
782 } else {
783 m_s3cou = amplitude;
784 }
785 }
786 break;
787 case 3: m_cher1 = amplitude; break;
788 case 4: m_cher2 = amplitude; break;
789 case 5: m_cher3 = amplitude; break;
790 default: m_muBack[cha - 6] = amplitude;
791 }
792 } else {
793 switch(cha) {
794 // BEAM
795 case 0: m_s1cou = amplitude; break;
796 case 1: m_s2cou = amplitude; break;
797 case 2: m_s3cou = amplitude; break;
798 case 3: m_cher1 = amplitude; break;
799 case 4: m_cher2 = amplitude; break;
800 case 5: m_cher3 = amplitude; break;
801 }
802 }
803 } else {
804 WRONG_CHANNEL(frag, cha);
805 }
806 } else {
807 switch(cha) {
808 // BEAM
809 case 0: m_s1cou = amplitude; break;
810 case 1: m_s2cou = amplitude; break;
811 case 2: m_s3cou = amplitude; break;
812 case 3: m_muTag = amplitude; break;
813 case 4: m_cher1 = amplitude; break;
814 case 5: m_cher2 = amplitude; break;
815 case 6: m_muHalo= amplitude; break;
816 case 7: m_muVeto= amplitude; break;
817 default: WRONG_CHANNEL(frag, cha);
818 }
819 }
820 break;
821
822 case COMMON_ADC2_FRAG:
823
824 if (m_TBperiod > 2015) {
825 if(cha < 14) {
826 m_muBack[cha] = amplitude;
827 } else {
828 WRONG_CHANNEL(frag, cha);
829 }
830 } else {
831 if ( ! m_unpackAdder ) {
832 switch(cha) {
833 // BEAM
834 case 0: break;
835 case 1: m_s2extra = amplitude; break;
836 case 2: m_s3extra = amplitude; break;
837 case 3:
838 case 4:
839 case 5:
840 case 6:
841 case 7: break;
842 default: WRONG_CHANNEL(frag, cha);
843 }
844 }
845 }
846 break;
847
848 case COMMON_PTN_FRAG:
849 if (m_run > 2310000 && cha < 16) {
850 m_scaler[cha] = amplitude;
851 } else if (cha == 0) {
852 m_commonPU = amplitude;
853 } else {
854 WRONG_CHANNEL(frag, cha);
855 }
856 break;
857
858 case COMMON_TOF_FRAG:
859
860 if (m_TBperiod >= 2022) {
861 if (cha > 11) { // The first 12 channels are (can be) connected to BC1 and BC2, the last 4 channels are supposed to be TOF
862 if(cha < 16) {
863 m_tof[cha] = amplitude;
864 ATH_MSG_VERBOSE( "TOF: " << cha << " amp: " << amplitude);
865 } else {
866 WRONG_CHANNEL(frag, cha);
867 }
868 break;
869 }
870 // Fall through to case COMMON_TDC1_FRAG to unpack the first 12 channels of BC1 and BC2
871 [[fallthrough]]; // silent the warning on fall through
872 } else if (m_TBperiod > 2015) {
873
874 if(cha < 16) {
875 m_tof[cha] = amplitude;
876 ATH_MSG_VERBOSE( "TOF: " << cha << " amp: " << amplitude);
877 } else {
878 WRONG_CHANNEL(frag, cha);
879 }
880 break;
881 } else {
882 if(cha < 8) m_tof[cha] = amplitude;
883 else WRONG_CHANNEL(frag, cha);
884 break;
885 }
886
887 case COMMON_TDC1_FRAG:
888
889 FRAG_FOUND(frag,cha,dsize);
890 if ((cha > 11) && (cha < 16) && (m_run > 2211136)) {
891 m_tof[cha] = amplitude;
892 ATH_MSG_VERBOSE( "TOF: " << cha << " amp: " << amplitude);
893 } if(cha < 16) {
894 m_btdc1[cha] = amplitude;
895 ATH_MSG_VERBOSE( "TDC: " << cha << " amp: " << amplitude);
896 if (m_btdcNhit[cha]==0) {
897 m_btdc2[cha] = amplitude;
898 }
899 (*m_btdc)[cha].push_back(amplitude);
900 ++m_btdcNhit[cha];
901 } else WRONG_CHANNEL(frag, cha);
902 break;
903
904 case COMMON_TDC2_FRAG:
905
906 FRAG_FOUND(frag,cha,dsize);
907 if(cha < 16) m_btdc2[cha] = amplitude;
908 else WRONG_CHANNEL(frag, cha);
909 break;
910
911 case COIN_TRIG1_FRAG:
912
913 if(cha < 3) {
914 int idx = cha * 32;
915 for (int ibit = 0; ibit < 32; ++ibit){
916 m_coincTrig1[idx++] = (amplitude >> ibit) & 1;
917 }
918 } else if (cha == 3) {
919 m_coincFlag1 = amplitude;
920 } else WRONG_CHANNEL(frag, cha);
921
922 break;
923
924 case COIN_TRIG2_FRAG:
925
926 if(cha < 3) {
927 int idx = cha * 32;
928 for (int ibit=0; ibit < 32; ++ibit){
929 m_coincTrig2[idx++] = (amplitude >> ibit) & 1;
930 }
931 } else if (cha == 3) {
932 m_coincFlag2 = amplitude;
933 } else WRONG_CHANNEL(frag, cha);
934
935 break;
936
937 case COIN_TRIG3_FRAG:
938
939 if(cha < 3) {
940 int idx = cha * 32;
941 for (int ibit = 0; ibit < 32; ++ibit){
942 m_coincTrig3[idx++] = (amplitude >> ibit) & 1;
943 }
944 } else if (cha == 3) {
945 m_coincFlag3 = amplitude;
946 } else WRONG_CHANNEL(frag,cha);
947
948 break;
949
950 case COIN_TRIG4_FRAG:
951
952 if(cha < 3) {
953 int idx = cha * 32;
954 for (int ibit = 0; ibit < 32; ++ibit){
955 m_coincTrig4[idx++] = (amplitude >> ibit) & 1;
956 }
957 } else if (cha == 3) {
958 m_coincFlag4 = amplitude;
959 } else WRONG_CHANNEL(frag, cha);
960
961 break;
962
963 case COIN_TRIG5_FRAG:
964
965 if(cha < 3) {
966 int idx = cha * 32;
967 for (int ibit = 0; ibit < 32; ++ibit){
968 m_coincTrig5[idx++] = (amplitude >> ibit) & 1;
969 }
970 } else if (cha == 3) {
971 m_coincFlag5 = amplitude;
972 } else WRONG_CHANNEL(frag, cha);
973
974 break;
975
976 case COIN_TRIG6_FRAG:
977
978 if(cha < 3) {
979 int idx = cha * 32;
980 for (int ibit = 0; ibit < 32; ++ibit){
981 m_coincTrig6[idx++] = (amplitude >> ibit) & 1;
982 }
983 } else if (cha == 3) {
984 m_coincFlag6 = amplitude;
985 } else WRONG_CHANNEL(frag, cha);
986
987 break;
988
989 case COIN_TRIG7_FRAG:
990
991 if(cha < 3) {
992 int idx = cha * 32;
993 for (int ibit = 0; ibit < 32; ++ibit){
994 m_coincTrig7[idx++] = (amplitude >> ibit) & 1;
995 }
996 } else if (cha == 3) {
997 m_coincFlag7 = amplitude;
998 } else WRONG_CHANNEL(frag,cha);
999
1000 break;
1001
1002 case COIN_TRIG8_FRAG:
1003
1004 if(cha < 3) {
1005 int idx = cha * 32;
1006 for (int ibit = 0; ibit < 32; ++ibit){
1007 m_coincTrig8[idx++] = (amplitude >> ibit) & 1;
1008 }
1009 } else if (cha == 3) {
1010 m_coincFlag8 = amplitude;
1011 } else WRONG_CHANNEL(frag, cha);
1012
1013 break;
1014
1015 default:
1016 break;
1017 }
1018 }
1019 }
1020 }
1021 }
1022
1023 for (int i=0; i<8; ++i) {
1024 if (m_btdcNhit[i] > 1) ++m_btdcNchMultiHit[i>>2];
1025 }
1026 // calculate beam coords in Beam Chambers
1027 if ( m_TBperiod >= 2015 ) {
1028
1029// For BC1
1030// -------
1031// m_xCha1 = -0.0462586 + (-0.175666)*(m_btdc1[1] - m_btdc1[0]);
1032// m_yCha1 = -0.051923 + (-0.176809)*(m_btdc1[2] - m_btdc1[3]);
1033//
1034// For BC2
1035// -------
1036// m_xCha2 = 0.25202 + (-0.18053)*(m_btdc1[5] - m_btdc1[4]);
1037// m_yCha2 = 0.0431688 + (-0.181128)*(m_btdc1[6] - m_btdc1[7]);
1038
1039 if (m_run > 2211444) {
1040 m_xCha1 = m_beamBC1X1 + m_beamBC1X2*(m_btdc1[8] - m_btdc1[0]);
1041 m_yCha1 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc1[9] - m_btdc1[3]);
1042 } else {
1043 m_xCha1 = m_beamBC1X1 + m_beamBC1X2*(m_btdc1[1] - m_btdc1[0]);
1044 m_yCha1 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc1[2] - m_btdc1[3]);
1045 }
1046 if (m_run > 612543 && m_run< 614141) {
1047 m_xCha2 = m_beamBC2X1 + m_beamBC2X2*(m_btdc1[5] - m_btdc1[6]);
1048 m_yCha2 = m_beamBC2Y1 + m_beamBC2Y2*(m_btdc1[4] - m_btdc1[7]);
1049 } else {
1050 m_xCha2 = m_beamBC2X1 + m_beamBC2X2*(m_btdc1[5] - m_btdc1[4]);
1051 m_yCha2 = m_beamBC2Y1 + m_beamBC2Y2*(m_btdc1[6] - m_btdc1[7]);
1052 }
1053
1054 // Using the first value from the TDC
1055 if (m_run > 2211444) {
1056 m_xCha1_0 = m_beamBC1X1 + m_beamBC1X2*(m_btdc2[8] - m_btdc2[0]);
1057 m_yCha1_0 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc2[9] - m_btdc2[3]);
1058 } else {
1059 m_xCha1_0 = m_beamBC1X1 + m_beamBC1X2*(m_btdc2[1] - m_btdc2[0]);
1060 m_yCha1_0 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc2[2] - m_btdc2[3]);
1061 }
1062 m_xCha2_0 = m_beamBC2X1 + m_beamBC2X2*(m_btdc2[5] - m_btdc2[4]);
1063 m_yCha2_0 = m_beamBC2Y1 + m_beamBC2Y2*(m_btdc2[6] - m_btdc2[7]);
1064
1065 m_tjitter = m_btdc1[8];
1066 m_tscTOF = m_btdc1[14];
1067
1068 m_xImp = m_xCha2 + (m_xCha2 - m_xCha1)*m_beamBC2Z/(m_beamBC1Z - m_beamBC2Z);
1069 m_yImp = m_yCha2 + (m_yCha2 - m_yCha1)*m_beamBC2Z/(m_beamBC1Z - m_beamBC2Z);
1070
1071// Work in progress
1072
1073 m_xImp_0 = m_xCha2_0 + (m_xCha2_0 - m_xCha1_0)*m_beamBC2Z_0/(m_beamBC1Z_0 - m_beamBC2Z_0);
1074 m_yImp_0 = m_yCha2_0 + (m_yCha2_0 - m_yCha1_0)*m_beamBC2Z_0/(m_beamBC1Z_0 - m_beamBC2Z_0);
1075 m_xImp_90 = m_xCha2_0 + (m_xCha2_0 - m_xCha1_0)*m_beamBC2Z_90/(m_beamBC1Z_90 - m_beamBC2Z_90);
1076 m_yImp_90 = m_yCha2_0 + (m_yCha2_0 - m_yCha1_0)*m_beamBC2Z_90/(m_beamBC1Z_90 - m_beamBC2Z_90);
1077 m_xImp_min90 = m_xCha2_0 + (m_xCha2_0 - m_xCha1_0)*m_beamBC2Z_min90/(m_beamBC1Z_min90 - m_beamBC2Z_min90);
1078 m_yImp_min90 = m_yCha2_0 + (m_yCha2_0 - m_yCha1_0)*m_beamBC2Z_min90/(m_beamBC1Z_min90 - m_beamBC2Z_min90);
1080
1081 if (m_run > 2211444) {
1082 ATH_MSG_DEBUG( "BC1x : ( "<< m_btdc1[0] <<" - "<< m_btdc1[8] <<" )\t" << m_xCha1 );
1083 ATH_MSG_DEBUG( "BC1y : ( "<< m_btdc1[2] <<" - "<< m_btdc1[9] <<" )\t" << m_yCha1 );
1084 } else {
1085 ATH_MSG_DEBUG( "BC1x : ( "<< m_btdc1[0] <<" - "<< m_btdc1[1] <<" )\t" << m_xCha1 );
1086 ATH_MSG_DEBUG( "BC1y : ( "<< m_btdc1[2] <<" - "<< m_btdc1[3] <<" )\t" << m_yCha1 );
1087 }
1088 ATH_MSG_DEBUG( "BC2x : ( "<< m_btdc1[4] <<" - "<< m_btdc1[5] <<" )\t" << m_xCha2 );
1089 ATH_MSG_DEBUG( "BC2y : ( "<< m_btdc1[6] <<" - "<< m_btdc1[7] <<" )\t" << m_yCha2 );
1090
1091 } else if ( m_unpackAdder ) { // this is 2003 data
1092
1093 if ( m_beamIdList[BEAM_TDC_FRAG] ) {
1094 m_xCha1 = m_beamBC1X1 + m_beamBC1X2*(m_btdc1[6] - m_btdc1[7]); // last two channels of TDC !!!
1095 m_yCha1 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc1[2] - m_btdc1[3]);
1096 m_xCha2 = m_beamBC2X1 + m_beamBC2X2*(m_btdc2[0] - m_btdc2[1]);
1097 m_yCha2 = m_beamBC2Y1 + m_beamBC2Y2*(m_btdc2[2] - m_btdc2[3]);
1098
1099 m_xImp = m_xCha2 + (m_xCha2 - m_xCha1)*m_beamBC2Z/(m_beamBC1Z - m_beamBC2Z);
1100 m_yImp = m_yCha2 + (m_yCha2 - m_yCha1)*m_beamBC2Z/(m_beamBC1Z - m_beamBC2Z);
1101 }
1102
1103 } else { // this is 2004 data
1104
1105 if ( m_beamIdList[COMMON_TDC1_FRAG] ) {
1106 m_yChN2 = m_beamBN2Y1 + m_beamBN2Y2*(m_btdc1[0] - m_btdc1[1]);
1107 m_xChN2 = m_beamBN2X1 + m_beamBN2X2*(m_btdc1[2] - m_btdc1[3]);
1108 m_yChN1 = m_beamBN1Y1 + m_beamBN1Y2*(m_btdc1[4] - m_btdc1[5]);
1109 m_xChN1 = m_beamBN1X1 + m_beamBN1X2*(m_btdc1[6] - m_btdc1[7]);
1110
1111 m_yCha0 = m_beamBC0Y1 + m_beamBC0Y2*(m_btdc1[8] - m_btdc1[9]);
1112 m_xCha0 = m_beamBC0X1 + m_beamBC0X2*(m_btdc1[10]- m_btdc1[11]);
1113
1114 ATH_MSG_DEBUG( "BC-2x : ( "<< m_btdc1[2] <<" - "<< m_btdc1[3] <<" )\t" <<m_xChN2 );
1115 ATH_MSG_DEBUG( "BC-2y : ( "<< m_btdc1[0] <<" - "<< m_btdc1[1] <<" )\t" <<m_yChN2 );
1116 ATH_MSG_DEBUG( "BC-1x : ( "<< m_btdc1[6] <<" - "<< m_btdc1[7] <<" )\t" <<m_xChN1 );
1117 ATH_MSG_DEBUG( "BC-1y : ( "<< m_btdc1[4] <<" - "<< m_btdc1[5] <<" )\t" <<m_yChN1 );
1118 ATH_MSG_DEBUG( "BC0x : ( "<< m_btdc1[10] <<" - "<< m_btdc1[11] <<" )\t" <<m_xCha0 );
1119 ATH_MSG_DEBUG( "BC0y : ( "<< m_btdc1[8] <<" - "<< m_btdc1[9] <<" )\t" <<m_yCha0 );
1120
1121 }
1122
1123 if ( m_beamIdList[COMMON_TDC2_FRAG] ) {
1124 m_yCha1 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc2[0] - m_btdc2[1]);
1125 m_xCha1 = m_beamBC1X1 + m_beamBC1X2*(m_btdc2[2] - m_btdc2[3]);
1126 m_yCha2 = m_beamBC2Y1 + m_beamBC2Y2*(m_btdc2[4] - m_btdc2[5]);
1127 m_xCha2 = m_beamBC2X1 + m_beamBC2X2*(m_btdc2[6] - m_btdc2[7]);
1128
1129 m_xImp = 0.0;
1130 m_yImp = 0.0;
1131
1132 ATH_MSG_DEBUG( "BC1x : ( "<< m_btdc2[2] <<" - "<< m_btdc2[3] <<" )\t" <<m_xCha1 );
1133 ATH_MSG_DEBUG( "BC1y : ( "<< m_btdc2[0] <<" - "<< m_btdc2[1] <<" )\t" <<m_yCha1 );
1134 ATH_MSG_DEBUG( "BC2x : ( "<< m_btdc2[6] <<" - "<< m_btdc2[7] <<" )\t" <<m_xCha2 );
1135 ATH_MSG_DEBUG( "BC2y : ( "<< m_btdc2[4] <<" - "<< m_btdc2[5] <<" )\t" <<m_yCha2 );
1136
1137 }
1138
1139 if ( m_beamIdList[COMMON_TDC1_FRAG] && m_beamIdList[COMMON_TDC2_FRAG] ) {
1140
1142 // Get run number and eta
1143 if ( 0==m_runNumber ){
1144 const xAOD::EventInfo* eventInfo(0);
1145 if (evtStore()->retrieve(eventInfo).isFailure()){
1146 ATH_MSG_ERROR( "No EventInfo object found! Can't read run number!" );
1147 m_runNumber = -1;
1148 } else {
1149 m_runNumber = eventInfo->runNumber();
1150 getEta();
1151 }
1152 }
1154
1155 // Computation of X,Y imp on TileCal/LAr front
1156 float tanBx = (m_xCha1-m_xCha0) / (m_beamBC0Z - m_beamBC1Z);
1157 float tanBy = (m_yCha1-m_yCha0) / (m_beamBC0Z - m_beamBC1Z);
1158
1159 float Ximp = m_xCha1 + m_beamBC1Z * tanBx;
1160 float Yimp = m_yCha1 + m_beamBC1Z * tanBy;
1161
1162 if ( 0.0 != cos(m_theta) * (1 + tanBx * tan(m_theta)) ){
1163 m_xImp = (Ximp + m_radius *(tanBx * (cos(m_theta) - 1) -sin(m_theta))) / (cos(m_theta) * (1 + tanBx * tan(m_theta)));
1164 m_yImp = Yimp + tanBy * (m_radius * (1 - cos(m_theta)) -Ximp * sin(m_theta)) / (cos(m_theta) * (1+tanBx * tan(m_theta)));
1165 }
1166 }
1167 }
1168
1169
1170 // do not apply Cesium and Laser calibration for CIS events
1171 // m_calibrateEnergyThisEvent = m_calibrateEnergy && (m_trigType != 8);
1172
1173 return StatusCode::SUCCESS;
1174}
1175
1176
1181 */
1182StatusCode TileTBAANtuple::storeRawChannels(const EventContext& ctx
1183 , const SG::ReadHandleKey<TileRawChannelContainer>& containerKey
1184 , bool calib_mode
1185 , std::vector<std::array<float, MAX_CHAN>>* eneVec
1186 , std::vector<std::array<float, MAX_CHAN>>* timeVec
1187 , std::vector<std::array<float, MAX_CHAN>>* chi2Vec
1188 , std::vector<std::array<float, MAX_CHAN>>* pedVec
1189 , bool saveDQstatus)
1190{
1191
1192
1193 if (containerKey.empty()) {// empty name, nothing to do
1194 return StatusCode::FAILURE;
1195 }
1196
1197 bool isFELIX = containerKey.key().find("Flx") != std::string::npos;
1198 int nDrawers = isFELIX ? m_nDrawersFlx : m_nDrawers;
1199 std::map<unsigned int, unsigned int, std::less<unsigned int>>& drawerMap = (isFELIX) ? m_drawerFlxMap : m_drawerMap;
1200
1201 // get named container
1202 const TileRawChannelContainer* rcCnt = SG::makeHandle (containerKey, ctx).get();
1203
1204 TileRawChannelUnit::UNIT rChUnit = rcCnt->get_unit();
1205 ATH_MSG_DEBUG( "RawChannel unit is " << rChUnit );
1206
1207
1208 if (rChUnit >= TileRawChannelUnit::OnlineADCcounts) { // this is container with DSP results
1209 m_dspUnit = rChUnit;
1210 m_dspFlags = rcCnt->get_bsflags() >> 16;
1211 ATH_MSG_DEBUG( "DSP flag is 0x" << MSG::hex << m_dspFlags << MSG::dec << " DSP unit is " << m_dspUnit );
1212
1213 } else if ((m_useDspUnits || m_finalUnit >= TileRawChannelUnit::OnlineADCcounts)
1214 && rChUnit != TileRawChannelUnit::ADCcounts) {
1215
1216 ATH_MSG_ERROR( "RawChannel units are not ADC counts, can't apply DSP-like calibration" );
1217 return StatusCode::FAILURE;
1218 }
1219
1220 if (m_calibrateEnergyThisEvent) {
1221 if (m_useDspUnits) { // calibrate a-la online
1222 m_rchUnit = m_dspUnit;
1223 } else { // convert to final units
1224 m_rchUnit = (TileRawChannelUnit::UNIT)m_finalUnit.value();
1225 }
1226 } else {
1227 m_rchUnit = rChUnit;
1228 }
1229
1230 ATH_MSG_DEBUG( "Final RawChannel unit is " << m_rchUnit );
1231
1232 // drawerIndex is 0 - m_nDrawers-1, fragType is 1-4 B+/B-/EB+/EB-
1233 int drawerIndex, fragType;
1234
1235 // Go through all TileRawChannelCollections
1236 for (const TileRawChannelCollection* rawChannelCollection : *rcCnt) {
1237 // determine type
1238 int fragId = rawChannelCollection->identify();
1239 int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
1240
1241 drawerMap_iterator itr = drawerMap.find(fragId);
1242 if ( itr != drawerMap.end() ) {
1243 drawerIndex = (*itr).second;
1244 } else {
1245 drawerIndex= -1;
1246 }
1247
1248 if (drawerIndex < 0) {
1249 if ( !rawChannelCollection->empty() )
1250 ATH_MSG_DEBUG( "frag id 0x" << MSG::hex << fragId << MSG::dec << " was not found among valid frag IDs when storing TRC!" );
1251 } else {
1252 fragType = isFELIX ? fragId >> 8 : m_drawerType[drawerIndex];
1253 ATH_MSG_DEBUG( "TRC (" << containerKey.key()
1254 << ") Event# " << m_evtNr
1255 << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1256 << " index "<< drawerIndex );
1257
1258 // go through all TileRawChannels in collection
1259 for (const TileRawChannel* rch : *rawChannelCollection) {
1260 int index = drawerIndex;
1261 HWIdentifier hwid = rch->adc_HWID();
1262
1263 // determine channel and gain
1264 int channel = m_tileHWID->channel(hwid);
1265 int gain = m_tileHWID->adc(hwid);
1266
1267 if (calib_mode) {
1268 // gain, if hi add m_nDrawers to index
1269 if (gain == 1) index += nDrawers;
1270 }
1271
1273 double energy = rch->amplitude();
1274 if (m_rchUnit != rChUnit) {
1275 if (m_rchUnit < TileRawChannelUnit::OnlineOffset)
1276 energy = m_tileToolEmscale->channelCalib(drawerIdx, channel, gain, energy, rChUnit, m_rchUnit);
1277 else
1278 energy = m_tileToolEmscale->channelCalibOnl(drawerIdx, channel, gain, energy, m_rchUnit);
1279 }
1280
1281 // cabling for testbeam (convert to pmt#-1)
1282 if ((m_TBperiod < 2015 ||
1283 (m_TBperiod==2015 && fragType<3) ||
1284 ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1285 (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1286 (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1287 (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1288 (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1289 && fragType > 0 && m_pmtOrder)
1290 channel = digiChannel2PMT(fragType, channel);
1291
1292 eneVec->at(index)[channel] = energy;
1293 timeVec->at(index)[channel] = rch->time();
1294 if (chi2Vec) {
1295 chi2Vec->at(index)[channel] = rch->quality();
1296 }
1297 if (pedVec) {
1298 pedVec->at(index)[channel] = rch->pedestal();
1299 }
1300
1301 ATH_MSG_DEBUG( "TRC ene=" << energy
1302 << " time=" << rch->time()
1303 << " chi2=" << rch->quality()
1304 << " ped=" << rch->pedestal()
1305 << " pmt-1=" << channel
1306 << " index " << index );
1307
1308 }
1309
1310 if (saveDQstatus && !isFELIX) {
1311
1312 int index1 = drawerIndex, index2 = drawerIndex + 1;
1313 if (calib_mode) index2 += m_nDrawers;
1314
1315 for (int index = index1; index < index2; index += m_nDrawers) {
1316
1317 m_ROD_GlobalCRCVec.at(index) = rawChannelCollection->getFragGlobalCRC() & 1;
1318 m_ROD_DMUMaskVec.at(index)[0] = rawChannelCollection->getFragRODChipMask();
1319 m_ROD_DMUMaskVec.at(index)[1] = rawChannelCollection->getFragFEChipMask();
1320
1321 for (unsigned int dmu = 0; dmu < MAX_DMU; ++dmu) {
1322
1323 m_ROD_DMUBCIDVec.at(index)[dmu] = (rawChannelCollection->getFragBCID() >> dmu) & 1;
1324 m_ROD_DMUmemoryErrVec.at(index)[dmu] = (rawChannelCollection->getFragMemoryPar() >> dmu) & 1;
1325 m_ROD_DMUSstrobeErrVec.at(index)[dmu] = (rawChannelCollection->getFragSstrobe() >> dmu) & 1;
1326 m_ROD_DMUDstrobeErrVec.at(index)[dmu] = (rawChannelCollection->getFragDstrobe() >> dmu) & 1;
1327 m_ROD_DMUHeadformatErrVec.at(index)[dmu] = (rawChannelCollection->getFragHeaderBit() >> dmu) & 1;
1328 m_ROD_DMUDataformatErrVec.at(index)[dmu] = (rawChannelCollection->getFragSampleBit() >> dmu) & 1;
1329 }
1330 }
1331 }
1332 }
1333 }
1334
1335 return StatusCode::SUCCESS;
1336}
1337
1338
1343 */
1344StatusCode TileTBAANtuple::storeDigits(const EventContext& ctx, const SG::ReadHandleKey<TileDigitsContainer>& containerKey, const TileDQstatus* dqStatus) {
1345
1346 if (containerKey.empty()) { // empty name, nothing to do
1347 return StatusCode::FAILURE;
1348 }
1349
1350 // Read Digits from TES
1351 const TileDigitsContainer* digitsCnt = SG::makeHandle (containerKey, ctx).get();
1352
1353 bool emptyColl = true;
1354
1355 // drawerIndex is 0 - m_nDrawers-1, fragType is 1-4 B+/B-/EB+/EB-
1356 int drawerIndex, fragType, channel;
1357
1358 std::vector<float> sampleVec;
1359 std::vector<uint32_t> headerVec;
1360 std::vector<uint32_t> headerVecHi;
1361 uint32_t CRCmask;
1362 uint32_t fe_crc;
1363 uint32_t rod_crc;
1364
1365 // Go through all TileDigitsCollections
1366 for (const TileDigitsCollection* digitsCollection : * digitsCnt) {
1367 // determine type of frag
1368 int fragId = digitsCollection->identify();
1369 int ros = (fragId >> 8);
1370 int drawer = fragId & 0x3F;
1371
1372 drawerMap_iterator itr = m_drawerMap.find(fragId);
1373 if ( itr != m_drawerMap.end() ) {
1374 drawerIndex = (*itr).second;
1375 } else {
1376 drawerIndex= -1;
1377 }
1378
1379 if (drawerIndex < 0) {
1380 if ( !digitsCollection->empty() )
1381 ATH_MSG_DEBUG( "frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing TRC!" );
1382
1383 } else {
1384 fragType = m_drawerType[drawerIndex];
1385
1386 ATH_MSG_DEBUG( "Event# " << m_evtNr
1387 << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1388 << " index " << drawerIndex
1389 << " Calib " << m_calibMode );
1390
1391 ATH_MSG_DEBUG( " Size=" << digitsCollection->getFragSize()
1392 << " BCID=" << digitsCollection->getFragBCID()<<MSG::hex
1393 << " CRC=0x" << (digitsCollection->getFragCRC()&0xffff)
1394 << " DMUMask=0x" << (digitsCollection->getFragDMUMask()&0xffff)<<MSG::dec );
1395
1396 ATH_MSG_DEBUG( " Lvl1ID=" << digitsCollection->getLvl1Id()
1397 << " Lvl1Type=" << digitsCollection->getLvl1Type()
1398 << " EvBCID=" << digitsCollection->getRODBCID()
1399 << " EvType=" << digitsCollection->getDetEvType() );
1400
1401 ATH_MSG_DEBUG( " Header=" << digitsCollection->getFragChipHeaderWords() );
1402
1403 if (m_completeNtuple) {
1408 m_l1ID.at(drawerIndex) = digitsCollection->getLvl1Id();
1409 m_l1Type.at(drawerIndex) = digitsCollection->getLvl1Type();
1410 m_evType.at(drawerIndex) = digitsCollection->getDetEvType();
1411 m_evBCID.at(drawerIndex) = digitsCollection->getRODBCID();
1412 // store FrBCID
1413 m_frBCID.at(drawerIndex) = digitsCollection->getFragBCID();
1414 }
1415
1416 if(m_calibMode) {
1417 // Digits in calib mode
1418 // check gain for first digits in collection
1419
1420 int dcnt=0;
1421 int drawerIndexHi = drawerIndex + m_nDrawers;
1422 // non empty collection
1423 if (!digitsCollection->empty()) {
1424 // store evtnr, bcid,crc, size
1425 // Same for lo and hi, because they come from the same fragment
1426 m_rodBCIDVec.at(drawerIndex) = digitsCollection->getRODBCID();
1427 m_sizeVec.at(drawerIndex) = digitsCollection->getFragSize();
1428 m_sizeVec.at(drawerIndexHi) = digitsCollection->getFragSize();
1429 m_evtVec.at(drawerIndex) = m_evtNr;
1430 m_evtVec.at(drawerIndexHi) = m_evtNr;
1431
1432 headerVec = digitsCollection->getFragChipHeaderWords();
1433 headerVecHi = digitsCollection->getFragChipHeaderWordsHigh();
1434 CRCmask = digitsCollection->getFragDMUMask(); //mask of FE+ROD DMU crc check (16bit+16bit) 0xffffffff == All ok
1435 fe_crc = CRCmask & 0xFFFF;
1436 rod_crc = CRCmask >> 16;
1437
1438 unsigned int headsize = std::min(16U, static_cast<unsigned int>(headerVec.size()));
1439 unsigned int headsizehi = std::min(16U, static_cast<unsigned int>(headerVecHi.size()));
1440
1441 for (unsigned int ih = 0; ih < headsize; ++ih) {
1442
1443 m_bcidVec.at(drawerIndex)[ih] = (headerVec[ih] & 0xFFF);
1444 m_DMUheaderVec.at(drawerIndex)[ih] = headerVec[ih];
1445 m_DMUformatErrVec.at(drawerIndex)[ih] = CheckDMUFormat(headerVec[ih]);
1446 m_DMUparityErrVec.at(drawerIndex)[ih] = CheckDMUParity(headerVec[ih]);
1447 m_DMUmemoryErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 25 & 0x1);
1448 m_DMUSstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 24 & 0x1);
1449 m_DMUDstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 23 & 0x1);
1450 m_feCRCVec.at(drawerIndex)[ih] = (fe_crc >> ih & 0x1);
1451 m_rodCRCVec.at(drawerIndex)[ih] = (rod_crc >> ih & 0x1);
1452
1453 if (dqStatus) {
1454 m_DMUHeadparityErrVec.at(drawerIndex)[ih] = dqStatus->checkHeaderParityErr(ros, drawer, ih, 0);
1455 m_DMUDataparityErrVec.at(drawerIndex)[ih] = dqStatus->checkSampleParityErr(ros, drawer, ih, 0);
1456 }
1457 }
1458
1459 for (unsigned int ihhi = 0; ihhi < headsizehi; ++ihhi) {
1460 m_bcidVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] & 0xFFF);
1461 m_DMUheaderVec.at(drawerIndexHi)[ihhi] = headerVecHi[ihhi];
1462 m_DMUformatErrVec.at(drawerIndexHi)[ihhi] = CheckDMUFormat(headerVecHi[ihhi]);
1463 m_DMUparityErrVec.at(drawerIndexHi)[ihhi] = CheckDMUParity(headerVecHi[ihhi]);
1464 m_DMUmemoryErrVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] >> 25 & 0x1);
1465 m_DMUSstrobeErrVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] >> 24 & 0x1);
1466 m_DMUDstrobeErrVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] >> 23 & 0x1);
1467 m_feCRCVec.at(drawerIndex)[ihhi] = -1; //Variables must be filled anyway, empty variables are not allowed
1468 m_rodCRCVec.at(drawerIndex)[ihhi] = -1; //Variables must be filled anyway, empty variables are not allowed
1469
1470 if (dqStatus) {
1471 m_DMUHeadparityErrVec.at(drawerIndex)[ihhi] = dqStatus->checkHeaderParityErr(ros, drawer, ihhi, 1);
1472 m_DMUDataparityErrVec.at(drawerIndex)[ihhi] = dqStatus->checkSampleParityErr(ros, drawer, ihhi, 1);
1473 }
1474 }
1475
1476 m_slinkCRCVec.at(drawerIndex)[0] = (digitsCollection->getFragCRC() >> 16) & 0xffff;
1477 m_dmuMaskVec.at(drawerIndex)[0] = (digitsCollection->getFragDMUMask() >> 16) & 0xffff;
1478 m_slinkCRCVec.at(drawerIndex)[1] = digitsCollection->getFragCRC() & 0xffff;
1479 m_dmuMaskVec.at(drawerIndex)[1] = digitsCollection->getFragDMUMask() & 0xffff;
1480
1481 m_slinkCRCVec.at(drawerIndexHi)[0] = (digitsCollection->getFragCRC() >> 16) & 0xffff;
1482 m_dmuMaskVec.at(drawerIndexHi)[0] = (digitsCollection->getFragDMUMask() >> 16) & 0xffff;
1483 m_slinkCRCVec.at(drawerIndexHi)[1] = digitsCollection->getFragCRC() & 0xffff;
1484 m_dmuMaskVec.at(drawerIndexHi)[1] = digitsCollection->getFragDMUMask() & 0xffff;
1485
1486 // go through all TileDigits in collection
1487 for (const TileDigits* tile_digits : *digitsCollection) {
1488
1489 emptyColl = false;
1490
1491 HWIdentifier hwid = tile_digits->adc_HWID();
1492 // determine gain
1493 int gain = m_tileHWID->adc(hwid);
1494 // add m_nDrawers to index if hi gain
1495 int index = (gain == 1) ? drawerIndexHi : drawerIndex;
1496 int nSamplesInDrawer = m_nSamplesInDrawer[index];
1497
1498 // determine channel
1499 channel = m_tileHWID->channel(hwid);
1500 // cabling for testbeam (convert to pmt#-1)
1501
1502 if ((m_TBperiod < 2015 ||
1503 (m_TBperiod==2015 && fragType<3) ||
1504 ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1505 (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1506 (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1507 (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1508 (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1509 && fragType > 0 && m_pmtOrder)
1510
1511 channel = digiChannel2PMT(fragType, channel);
1512
1513
1514 // gain determined for all digits in collection
1515 m_gainVec.at(index)[channel] = gain;
1516 ATH_MSG_DEBUG( "Storing TD for channel: " << channel
1517 << " with gain " << m_tileHWID->adc(hwid)
1518 << " index " << index );
1519
1520 // get digits
1521 sampleVec = tile_digits->samples();
1522 int siz = sampleVec.size();
1523
1524 if (msgLvl(MSG::DEBUG)) {
1525 msg(MSG::DEBUG) << "Digits(" << siz << ")." << (dcnt++) << " {";
1526 for (int i = 0; i < siz; i++) {
1527 msg(MSG::DEBUG) << static_cast<int>(sampleVec[i]) << " ";
1528 }
1529
1530 if (siz > nSamplesInDrawer) {
1531 msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1532 } else {
1533 msg(MSG::DEBUG) << "}" << endmsg;
1534 }
1535 }
1536
1537 if (siz > nSamplesInDrawer) siz = nSamplesInDrawer;
1538 std::transform(sampleVec.begin(), sampleVec.begin() + siz, &m_sampleVec.at(index).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1539 }
1540 }
1541 } else {
1542 // Digits in normal mode
1543 // store evtnr, bcid,crc, size
1544 m_rodBCIDVec.at(drawerIndex) = digitsCollection->getRODBCID();
1545 m_sizeVec.at(drawerIndex) = digitsCollection->getFragSize();
1546 m_evtVec.at(drawerIndex) = m_evtNr;
1547
1548 headerVec = digitsCollection->getFragChipHeaderWords();
1549 CRCmask = digitsCollection->getFragDMUMask(); //mask of FE+ROD DMU crc check (16bit+16bit) 0xffffffff == All ok
1550 fe_crc = CRCmask & 0xFFFF;
1551 rod_crc = CRCmask >> 16;
1552
1553 int headsize = headerVec.size();
1554
1555 for (int ih = 0; ih < headsize; ++ih) {
1556 m_bcidVec.at(drawerIndex)[ih] = (headerVec[ih] & 0xFFF);
1557 m_DMUheaderVec.at(drawerIndex)[ih] = headerVec[ih];
1558 m_DMUformatErrVec.at(drawerIndex)[ih] = CheckDMUFormat(headerVec[ih]);
1559 m_DMUparityErrVec.at(drawerIndex)[ih] = CheckDMUParity(headerVec[ih]);
1560 m_DMUmemoryErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 25 & 0x1);
1561 m_DMUSstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 24 & 0x1);
1562 m_DMUDstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 23 & 0x1);
1563 m_feCRCVec.at(drawerIndex)[ih] = (fe_crc >> ih & 0x1);
1564 m_rodCRCVec.at(drawerIndex)[ih] = (rod_crc >> ih & 0x1);
1565
1566 if (dqStatus) {
1567 m_DMUHeadparityErrVec.at(drawerIndex)[ih] = dqStatus->checkHeaderParityErr(ros, drawer, ih, 0);
1568 m_DMUDataparityErrVec.at(drawerIndex)[ih] = dqStatus->checkSampleParityErr(ros, drawer, ih, 0);
1569 }
1570 }
1571
1572 m_slinkCRCVec.at(drawerIndex)[0] = (digitsCollection->getFragCRC() >> 16) & 0xffff;
1573 m_dmuMaskVec.at(drawerIndex)[0] = (digitsCollection->getFragDMUMask() >> 16) & 0xffff;
1574 m_slinkCRCVec.at(drawerIndex)[1] = digitsCollection->getFragCRC() & 0xffff;
1575 m_dmuMaskVec.at(drawerIndex)[1] = digitsCollection->getFragDMUMask() & 0xffff;
1576
1577 int nSamplesInDrawer = m_nSamplesInDrawer[drawerIndex];
1578
1579 int dcnt = 0;
1580 // go through all TileDigits in collection
1581 for (const TileDigits* tile_digits : *digitsCollection) {
1582 emptyColl = false;
1583
1584 HWIdentifier hwid = tile_digits->adc_HWID();
1585 // determine channel
1586 channel = m_tileHWID->channel(hwid);
1587 // cabling for testbeam
1588 if ((m_TBperiod < 2015 ||
1589 (m_TBperiod==2015 && fragType<3) ||
1590 ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1591 (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1592 (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1593 (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1594 (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1595 && fragType > 0 && m_pmtOrder)
1596 channel = digiChannel2PMT(fragType, channel);
1597
1598 // gain
1599 m_gainVec.at(drawerIndex)[channel] = m_tileHWID->adc(hwid);
1600 ATH_MSG_DEBUG( "Storing TD for channel: " << channel
1601 << " with gain " << m_tileHWID->adc(hwid) );
1602
1603 // get digits
1604 sampleVec = tile_digits->samples();
1605 int siz = sampleVec.size();
1606 if (msgLvl(MSG::DEBUG)) {
1607 msg(MSG::DEBUG) << "Digits(" << siz << ")." << (dcnt++) << " {";
1608
1609 for (int i = 0; i < siz; i++) {
1610 msg(MSG::DEBUG) << static_cast<int>(sampleVec[i]) << " ";
1611 }
1612
1613 if (siz > nSamplesInDrawer) {
1614 msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1615 } else {
1616 msg(MSG::DEBUG) << "}" << endmsg;
1617 }
1618 }
1619
1620 if (siz > nSamplesInDrawer) siz = nSamplesInDrawer;
1621 std::transform(sampleVec.begin(), sampleVec.begin() + siz, &m_sampleVec.at(drawerIndex).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1622 }
1623 }
1624 }
1625 // next container
1626 }
1627
1628 if (emptyColl)
1629 return StatusCode::FAILURE;
1630 else
1631 return StatusCode::SUCCESS;
1632}
1633
1634
1635StatusCode TileTBAANtuple::storeDigitsFlx(const EventContext& ctx, const SG::ReadHandleKey<TileDigitsContainer>& containerKey) {
1636
1637 if (containerKey.empty()) { // empty name, nothing to do
1638 return StatusCode::FAILURE;
1639 }
1640
1641 // Read Digits from TES
1642 const TileDigitsContainer* digitsCntFlx = SG::makeHandle (containerKey, ctx).get();
1643
1644 bool emptyColl = true;
1645
1646 // drawerIndex is 0 - m_nDrawersFlx-1, fragType is 1-4 B+/B-/EB+/EB-
1647 int drawerIndex, channel;
1648
1649 std::vector<float> sampleVecLo;
1650 std::vector<float> sampleVecHi;
1651 // Go through all TileDigitsCollections
1652 for (const TileDigitsCollection* digitsCollection : *digitsCntFlx) {
1653 // determine type of frag
1654 int fragId = digitsCollection->identify();
1655 drawerMap_iterator itr = m_drawerFlxMap.find(fragId);
1656 if ( itr != m_drawerFlxMap.end() ) {
1657 drawerIndex = (*itr).second;
1658 } else {
1659 drawerIndex = -1;
1660 }
1661
1662 if (drawerIndex < 0) {
1663 if ( !digitsCollection->empty() )
1664 ATH_MSG_DEBUG( "FELIX frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing TRC!" );
1665
1666 } else {
1667
1668 ATH_MSG_DEBUG( "Event# " << m_evtNr
1669 << " FELIX Frag id 0x" << MSG::hex << fragId << MSG::dec
1670 << " index " << drawerIndex);
1671
1672 ATH_MSG_DEBUG( " Size=" << digitsCollection->getFragSize());
1673
1674 ATH_MSG_DEBUG( " Lvl1ID=" << digitsCollection->getLvl1Id()
1675 << " EvBCID=" << digitsCollection->getRODBCID()
1676 << " EvType=" << digitsCollection->getDetEvType() );
1677 ATH_MSG_DEBUG( " Headers = "<< digitsCollection->getFragExtraWords() );
1678
1679 if (m_completeNtuple) {
1684 int index = drawerIndex + m_nDrawers;
1685 m_l1ID.at(index) = digitsCollection->getLvl1Id();
1686 m_l1Type.at(index) = digitsCollection->getLvl1Type();
1687 m_evType.at(index) = digitsCollection->getDetEvType();
1688 m_evBCID.at(index) = digitsCollection->getRODBCID();
1689 // store FrBCID
1690 m_frBCID.at(index) = digitsCollection->getFragBCID();
1691 }
1692
1693 // Digits in calib mode
1694 // check gain for first digits in collection
1695
1696
1697 std::vector<uint32_t> extraWords = digitsCollection->getFragExtraWords();
1698 if (extraWords.size() >= 10 * MAX_MINIDRAWER) {
1699
1700 std::reference_wrapper<std::array<int,MAX_MINIDRAWER>>
1701 md[] = {m_mdL1idflxVec.at(drawerIndex), m_mdBcidflxVec.at(drawerIndex),
1702 m_mdModuleflxVec.at(drawerIndex), m_mdRunTypeflxVec.at(drawerIndex),
1703 m_mdRunflxVec.at(drawerIndex), m_mdPedLoflxVec.at(drawerIndex),
1704 m_mdPedHiflxVec.at(drawerIndex), m_mdChargeflxVec.at(drawerIndex),
1705 m_mdChargeTimeflxVec.at(drawerIndex), m_mdCapacitorflxVec.at(drawerIndex)};
1706
1707 auto it = extraWords.begin();
1708 for (int i = 0; i < 10; ++i) {
1709 std::copy(it + i * MAX_MINIDRAWER, it + (i + 1) * MAX_MINIDRAWER, &md[i].get()[0]);
1710 }
1711
1712 }
1713
1714 int dcnt=0;
1715 // non empty collection
1716 if(!digitsCollection->empty()) {
1717 int drawerIndexHi = drawerIndex + m_nDrawersFlx;
1718 // store evtnr, bcid,crc, size
1719 if (m_bsInput) {
1720 m_rodBCIDflxVec.at(drawerIndex) = digitsCollection->getRODBCID();
1721 m_sizeflxVec.at(drawerIndex) = digitsCollection->getFragSize();
1722 m_evtflxVec.at(drawerIndex) = m_evtNr;
1723 }
1724
1725 // go through all TileDigits in collection
1726 for (const TileDigits* tile_digits : *digitsCollection) {
1727 emptyColl = false;
1728 HWIdentifier hwid = tile_digits->adc_HWID();
1729 // determine gain
1730 int gain = m_tileHWID->adc(hwid);
1731 // add m_nDrawersFlx to index if hi gain
1732 int index = (gain == 1) ? drawerIndexHi : drawerIndex;
1733
1734 // determine channel
1735 channel = m_tileHWID->channel(hwid);
1736 // cabling for testbeam (convert to pmt#-1)
1737
1738 // gain determined for all digits in collection
1739 m_gainflxVec.at(index)[channel] = gain;
1740 ATH_MSG_DEBUG( "Storing TD for channel: " << channel
1741 << " with gain " << m_tileHWID->adc(hwid)
1742 << " index " << index );
1743
1744 // get digits
1745 if (gain == 0) {
1746 sampleVecLo = tile_digits->samples();
1747 } else if (gain == 1) {
1748 sampleVecHi = tile_digits->samples();
1749 }
1750
1751 int sizLo = sampleVecLo.size();
1752 int sizHi = sampleVecHi.size();
1753
1754 int nSamplesInDrawer = m_nSamplesFlxInDrawer[index];
1755
1756 if (msgLvl(MSG::DEBUG)) {
1757 if (sizLo > 0 ){
1758 msg(MSG::DEBUG) << "Low gain Digits(" << sizLo << ")." << (dcnt++) << " {";
1759 for (int i = 0; i < sizLo; i++) {
1760 msg(MSG::DEBUG) << static_cast<int>(sampleVecLo[i]) << " ";
1761 }
1762
1763 if (sizLo > nSamplesInDrawer) {
1764 msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1765 } else {
1766 msg(MSG::DEBUG) << "}" << endmsg;
1767 }
1768 }
1769
1770 if (sizHi > 0 ){
1771 msg(MSG::DEBUG) << "High gain Digits(" << sizHi << ")." << (dcnt++) << " {";
1772 for (int i = 0; i < sizHi; i++) {
1773 msg(MSG::DEBUG) << static_cast<int>(sampleVecHi[i]) << " ";
1774 }
1775
1776 if (sizHi > nSamplesInDrawer) {
1777 msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1778 } else {
1779 msg(MSG::DEBUG) << "}" << endmsg;
1780 }
1781 }
1782
1783
1784 }
1785 if (sizLo > nSamplesInDrawer) sizLo = nSamplesInDrawer;
1786 if (sizHi > nSamplesInDrawer) sizHi = nSamplesInDrawer;
1787 std::transform(sampleVecLo.begin(), sampleVecLo.begin() + sizLo, &m_sampleflxVec.at(index).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1788 std::transform(sampleVecHi.begin(), sampleVecHi.begin() + sizHi, &m_sampleflxVec.at(index).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1789 sampleVecLo.clear();
1790 sampleVecHi.clear();
1791 }
1792 }
1793 }
1794 // next container
1795 }
1796
1797 if (emptyColl)
1798 return StatusCode::FAILURE;
1799 else
1800 return StatusCode::SUCCESS;
1801}
1802
1803
1804/*
1807 */
1808StatusCode TileTBAANtuple::storeHitVector(const EventContext& ctx) {
1809
1810 if (m_hitVectorKey.empty()) { // empty name, nothing to do
1811 return StatusCode::FAILURE;
1812 }
1813
1814 // Read Hit Vector from TDS
1815 const TileHitVector* hitVec = SG::makeHandle (m_hitVectorKey, ctx).get();
1816
1817 ATH_MSG_DEBUG( "Event# " << m_evtNr << " reading Hit Vector");
1818
1819 SG::ReadCondHandle<TileSamplingFraction> samplingFraction(m_samplingFractionKey, ctx);
1820 ATH_CHECK( samplingFraction.isValid() );
1821
1822 // Go through all TileHit
1823 for (const TileHit& cinp : *hitVec) {
1824
1825 // get hits
1826 HWIdentifier hwid = cinp.pmt_HWID();
1827
1828 // determine type of frag
1829 int fragId = m_tileHWID->frag(hwid);
1830 drawerMap_iterator itr = m_drawerMap.find(fragId);
1831 int drawerIndex = ( itr != m_drawerMap.end() ) ? static_cast<int>((*itr).second) : -1;
1832
1833 if (drawerIndex < 0) {
1834 ATH_MSG_WARNING( "frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing HITS!" );
1835
1836 } else {
1837 int fragType = m_drawerType[drawerIndex];
1838 storeHit(&cinp,fragType,fragId,m_ehitVec.at(drawerIndex),m_thitVec.at(drawerIndex), *samplingFraction);
1839 }
1840 }
1841
1842 if (hitVec->empty())
1843 return StatusCode::FAILURE;
1844 else
1845 return StatusCode::SUCCESS;
1846}
1847
1848
1852 */
1853StatusCode TileTBAANtuple::storeHitContainer(const EventContext& ctx) {
1854
1855 if (m_hitContainerKey.empty()) { // empty name, nothing to do
1856 return StatusCode::FAILURE;
1857 }
1858
1859 // Read Hit Vector from TDS
1860 const TileHitContainer* hitCnt = SG::makeHandle (m_hitContainerKey, ctx).get();
1861
1862 SG::ReadCondHandle<TileSamplingFraction> samplingFraction(m_samplingFractionKey, ctx);
1863 ATH_CHECK( samplingFraction.isValid() );
1864
1865 bool emptyColl = true;
1866
1867 // Go through all TileHitCollections
1868 for (const TileHitCollection* hitCollection : *hitCnt) {
1869
1870 // determine type of frag
1871 int fragId = hitCollection->identify();
1872 drawerMap_iterator itr = m_drawerMap.find(fragId);
1873 int drawerIndex = ( itr != m_drawerMap.end() ) ? static_cast<int>((*itr).second) : -1;
1874
1875 if (drawerIndex < 0) {
1876 if ( !hitCollection->empty() )
1877 ATH_MSG_WARNING( "frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing HITS!" );
1878
1879 } else {
1880 int fragType = m_drawerType[drawerIndex];
1881
1882 ATH_MSG_DEBUG( "Event# " << m_evtNr
1883 << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1884 << " index " << drawerIndex );
1885
1886 if (emptyColl) emptyColl = hitCollection->empty();
1887 // go through all TileHit in collection
1888 for (const TileHit* cinp : *hitCollection) {
1889 storeHit(cinp,fragType,fragId,m_ehitCnt.at(drawerIndex),m_thitCnt.at(drawerIndex),*samplingFraction);
1890 }
1891 }
1892 }
1893
1894 if (emptyColl)
1895 return StatusCode::FAILURE;
1896 else
1897 return StatusCode::SUCCESS;
1898}
1899
1900void TileTBAANtuple::storeHit(const TileHit *cinp, int fragType, int fragId,
1901 std::array<float, MAX_CHAN>& ehitVec,
1902 std::array<float, MAX_CHAN>& thitVec,
1903 const TileSamplingFraction* samplingFraction) {
1904
1905 // determine channel
1906 HWIdentifier hwid = cinp->pmt_HWID();
1907 int channel = m_tileHWID->channel(hwid);
1908
1909 int size = cinp->size();
1910 if (msgLvl(MSG::VERBOSE)) {
1911 msg(MSG::VERBOSE) << "hit hwid="
1912 << m_tileHWID->to_string(hwid, -1) << " ener=";
1913
1914 for (int i = 0; i < size; ++i)
1915 msg(MSG::VERBOSE) << cinp->energy(i) << " ";
1916
1917 msg(MSG::VERBOSE) << "time=";
1918 for (int i = 0; i < size; ++i)
1919 msg(MSG::VERBOSE) << cinp->time(i) << " ";
1920
1921 msg(MSG::VERBOSE) << endmsg;
1922 }
1923
1924 double ehit=0.0, thit=0.0;
1925 for(int i=0;i<size;++i) {
1926
1927 double e = cinp->energy(i);
1928 double t = cinp->time(i);
1929
1930 if (-75.<t && t<75.) {
1931 ehit += e;
1932 thit += e*t;
1933 }
1934 }
1935
1936 if (ehit!=0) {
1937 thit /= ehit;
1938 // conversion factor from hit energy to final energy units
1939 int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
1940 ehit *= samplingFraction->getSamplingFraction(drawerIdx, channel);
1941 if (m_rchUnit != TileRawChannelUnit::MegaElectronVolts) {
1942 ehit /= m_tileToolEmscale->channelCalib(drawerIdx, channel, TileID::HIGHGAIN, 1.,
1943 m_rchUnit, TileRawChannelUnit::MegaElectronVolts);
1944 }
1945 } else {
1946 thit=0.0;
1947 }
1948
1949 // cabling for testbeam
1950 if ((m_TBperiod < 2015 ||
1951 (m_TBperiod==2015 && fragType<3) ||
1952 ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1953 (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1954 (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1955 (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1956 (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1957 && fragType > 0 && m_pmtOrder)
1958 channel = digiChannel2PMT(fragType, channel);
1959
1960 ehitVec[channel] = ehit;
1961 thitVec[channel] = thit;
1962
1963 ATH_MSG_DEBUG( "HIT ene=" << ehit
1964 << " time=" << thit
1965 << " pmt-1=" << channel
1966 << " index " << m_drawerMap.at(fragId) );
1967
1968}
1969StatusCode TileTBAANtuple::ntuple_clear() {
1970
1971 TRIGGER_clearBranch();
1972
1973 if (m_beamIdList[MUON_ADC_FRAG] || m_beamIdList[ADDR_ADC_FRAG]) {
1974 MUON_clearBranch();
1975 }
1976
1977 if (m_beamIdList[ECAL_ADC_FRAG]) {
1978 ECAL_clearBranch();
1979 if (m_TBperiod > 2015) QDC_clearBranch();
1980 }
1981
1982 LASER_clearBranch();
1983
1984 if (m_unpackAdder) {
1985 if (m_beamIdList[ADD_FADC_FRAG]) {
1986 ADDER_clearBranch();
1987 }
1988 }
1989
1990 if (m_beamIdList[DIGI_PAR_FRAG & 0x1F]) {
1991 CISPAR_clearBranch();
1992 }
1993
1994 if (((m_TBperiod >= 2015 || m_unpackAdder) && m_beamIdList[BEAM_ADC_FRAG])
1995 || (!m_unpackAdder && m_beamIdList[COMMON_ADC1_FRAG])
1996 || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
1997 BEAM_clearBranch();
1998 ATH_MSG_VERBOSE( "clear branch");
1999 }
2000
2001 if (m_completeNtuple && m_TBperiod < 2015) {
2002 ENETOTAL_clearBranch();
2003 }
2004
2005 COINCBOARD_clearBranch();
2006
2007 DIGI_clearBranch(); // working now
2008 if (m_saveFelixData) {
2009 FELIX_clearBranch();
2010 }
2011
2012 HIT_clearBranch();
2013 ATH_MSG_DEBUG( "clear() successfully" );
2014
2015 return StatusCode::SUCCESS;
2016}
2017
2018
2019StatusCode TileTBAANtuple::initNTuple(void) {
2020 MsgStream log(msgSvc(), name());
2021
2022 m_evtVec.clear();
2023 m_bcidVec.clear();
2024 m_DMUheaderVec.clear();
2025 m_DMUformatErrVec.clear();
2026 m_DMUparityErrVec.clear();
2027 m_DMUmemoryErrVec.clear();
2028 m_DMUDstrobeErrVec.clear();
2029 m_DMUSstrobeErrVec.clear();
2030 m_DMUHeadparityErrVec.clear();
2031 m_DMUDataparityErrVec.clear();
2032 m_rodBCIDVec.clear();
2033 m_sizeVec.clear();
2034 m_dmuMaskVec.clear();
2035 m_slinkCRCVec.clear();
2036 m_gainVec.clear();
2037 m_sampleVec.clear();
2038 m_feCRCVec.clear();
2039 m_rodCRCVec.clear();
2040
2041 m_evtflxVec.clear();
2042 m_rodBCIDflxVec.clear();
2043 m_sizeflxVec.clear();
2044 m_gainflxVec.clear();
2045 m_sampleflxVec.clear();
2046
2047 m_eneVec.clear();
2048 m_timeVec.clear();
2049 m_pedFlatVec.clear();
2050 m_chi2FlatVec.clear();
2051
2052 m_efitVec.clear();
2053 m_tfitVec.clear();
2054 m_pedfitVec.clear();
2055 m_chi2Vec.clear();
2056
2057 m_efitcVec.clear();
2058 m_tfitcVec.clear();
2059 m_pedfitcVec.clear();
2060 m_chi2cVec.clear();
2061
2062 m_eOptVec.clear();
2063 m_tOptVec.clear();
2064 m_pedOptVec.clear();
2065 m_chi2OptVec.clear();
2066
2067 m_eflxfitVec.clear();
2068 m_tflxfitVec.clear();
2069 m_pedflxfitVec.clear();
2070 m_chi2flxfitVec.clear();
2071
2072 m_eflxoptVec.clear();
2073 m_tflxoptVec.clear();
2074 m_pedflxoptVec.clear();
2075 m_chi2flxoptVec.clear();
2076
2077 m_eDspVec.clear();
2078 m_tDspVec.clear();
2079 m_chi2DspVec.clear();
2080
2081 m_ROD_GlobalCRCVec.clear();
2082 m_ROD_DMUBCIDVec.clear();
2083 m_ROD_DMUmemoryErrVec.clear();
2084 m_ROD_DMUSstrobeErrVec.clear();
2085 m_ROD_DMUDstrobeErrVec.clear();
2086 m_ROD_DMUHeadformatErrVec.clear();
2087 m_ROD_DMUDataformatErrVec.clear();
2088 m_ROD_DMUMaskVec.clear();
2089
2090 //Ntuple creation
2091
2092 auto tree = std::make_unique<TTree>(m_ntupleID.value().c_str(), "TileBEAM-Ntuple");
2093 tree->SetMaxTreeSize(m_treeSize);
2094 m_ntuplePtr = tree.get();
2095 if (m_thistSvc->regTree("/" + m_streamName + "/" + m_ntupleID, std::move(tree)).isFailure()) {
2096 ATH_MSG_ERROR( "Problem registering TileRec Tree" );
2097 m_ntupleCreated = false;
2098 } else {
2099 m_ntupleCreated = true;
2100 }
2101
2102 TRIGGER_addBranch();
2103 MUON_addBranch();
2104
2105 if (m_TBperiod < 2015) {
2106 ECAL_addBranch();
2107 LASER_addBranch();
2108 ADDER_addBranch();
2109 ENETOTAL_addBranch();
2110 COINCBOARD_addBranch();
2111 }
2112
2113 if (m_TBperiod > 2015) {
2114 QDC_addBranch();
2115 }
2116
2117 CISPAR_addBranch();
2118 BEAM_addBranch();
2119 DIGI_addBranch(); //working now
2120 if (m_saveFelixData) {
2121 FELIX_addBranch();
2122 }
2123
2124 HIT_addBranch();
2125
2126 return StatusCode::SUCCESS;
2127}
2128
2129StatusCode TileTBAANtuple::storeCells(const EventContext& ctx) {
2130
2131 if (m_cellContainerKey.empty()) { // empty name, nothing to do
2132 return StatusCode::FAILURE;
2133 }
2134
2135 //Retrieve Cell collection from SG
2136 const CaloCellContainer* cellContainer = SG::makeHandle (m_cellContainerKey, ctx).get();
2137
2138 //Loop over all cells in container. Sum up the Energy and fill 2DHistograms
2139 ATH_MSG_DEBUG( "succeeded retrieving cellContainer from SG" );
2140
2141 ATH_MSG_DEBUG( "TileTBAANtuple : about to iterate over CaloCells" );
2142
2143 m_LarEne[0] = m_LarEne[1] = m_LarEne[2] = m_LarEne[3] = 0.0;
2144 m_BarEne[0] = m_BarEne[1] = m_BarEne[2] = 0.0;
2145 m_ExtEne[0] = m_ExtEne[1] = m_ExtEne[2] = 0.0;
2146 m_GapEne[0] = m_GapEne[1] = m_GapEne[2] = 0.0;
2147
2148 for (const CaloCell* cell : *cellContainer) {
2149 //Decode cell information
2150 const double energy = cell->energy();
2151 const CaloDetDescrElement* caloDDE = cell->caloDDE(); //pointer to the DetectorDescriptionElement
2152 const CaloCell_ID::CaloSample sampl = caloDDE->getSampling(); //To which sampling belongs this cell?
2153
2154 if (sampl == CaloCell_ID::PreSamplerB) {
2155 m_LarEne[0] += energy;
2156 } else if (sampl == CaloCell_ID::EMB1) {
2157 m_LarEne[1] += energy;
2158 } else if (sampl == CaloCell_ID::EMB2) {
2159 m_LarEne[2] += energy;
2160 } else if (sampl == CaloCell_ID::EMB3) {
2161 m_LarEne[3] += energy;
2162 } else if (sampl == CaloCell_ID::TileBar0) {
2163 m_BarEne[0] += energy;
2164 } else if (sampl == CaloCell_ID::TileBar1) {
2165 m_BarEne[1] += energy;
2166 } else if (sampl == CaloCell_ID::TileBar2) {
2167 m_BarEne[2] += energy;
2168 } else if (sampl == CaloCell_ID::TileExt0) {
2169 m_ExtEne[0] += energy;
2170 } else if (sampl == CaloCell_ID::TileExt1) {
2171 m_ExtEne[1] += energy;
2172 } else if (sampl == CaloCell_ID::TileExt2) {
2173 m_ExtEne[2] += energy;
2174 } else if (sampl == CaloCell_ID::TileGap1) {
2175 m_GapEne[1] += energy;
2176 } else if (sampl == CaloCell_ID::TileGap2) {
2177 m_GapEne[2] += energy;
2178 } else if (sampl == CaloCell_ID::TileGap3) {
2179 m_GapEne[0] += energy;
2180 }
2181 }
2182
2183 return StatusCode::SUCCESS;
2184}
2185
2186
2187
2188StatusCode TileTBAANtuple::initList(const EventContext& ctx) {
2189
2190 unsigned int size = m_drawerList.size();
2191
2192 if (size > 0) {
2193
2194 if (m_digitsContainerKey.empty()) { // empty name, nothing to do
2195
2196 ATH_MSG_WARNING( "can't retrieve Digits from TDS" );
2197 ATH_MSG_WARNING( "can't set up fragment list for ntuple" );
2198
2199 if (m_nSamples != 0) {
2200 ATH_MSG_WARNING( "Disable digit samples in ntuple" );
2201 m_nSamples = 0;
2202 }
2203
2204 return StatusCode::SUCCESS;
2205 }
2206
2207 // Read Digits from TES
2208 const TileDigitsContainer* digitsCnt = SG::makeHandle (m_digitsContainerKey, ctx).get();
2209
2210 int frag = strtol(m_drawerList[0].data(), NULL, 0);
2211 if (frag < 0) { // setup frags IDs from the data
2212
2213 std::vector<unsigned int> frags;
2214 // Go through all TileDigitsCollections
2215 for (const TileDigitsCollection* digitsCollection : *digitsCnt) {
2216 if (!digitsCollection->empty()) {
2217 // determine type of frag
2218 frags.push_back(digitsCollection->identify());
2219 }
2220 }
2221 size = frags.size();
2222
2223 if (size > 0) {
2224
2225 if (size < m_nDrawers) {
2226 ATH_MSG_INFO( "decreasing m_nDrawers from " << m_nDrawers << " to " << size );
2227 m_nDrawers = size;
2228 }
2229
2230 unsigned int rosOrder[5] = { 2, 1, 3, 4, 0 };
2231 unsigned int dr = 0;
2232 char frg[6] = "0x000";
2233
2234 m_drawerList.clear();
2235 // m_drawerType.clear();
2236 m_drawerMap.clear();
2237
2238 msg(MSG::INFO) << "setting drawerList from data " << MSG::hex;
2239 for (unsigned int ir = 0; ir < 5; ++ir) {
2240 for (unsigned int i = 0; i < size; ++i) {
2241 unsigned int frag = frags[i];
2242 if (frag >> 8 == rosOrder[ir]) {
2243 sprintf(frg, "0x%3.3x", frag);
2244 m_drawerList.value().push_back((std::string) frg);
2245 if (dr == m_drawerType.size()) m_drawerType.value().push_back(frag >> 8);
2246 m_drawerMap[frag] = dr;
2247 msg(MSG::INFO) << " 0x" << frag;
2248 ++dr;
2249 }
2250 }
2251 }
2252
2253 msg(MSG::INFO) << MSG::dec << endmsg;
2254
2255 size = m_drawerType.size();
2256 if (size < m_nDrawers) {
2257 m_drawerType.value().resize(m_nDrawers);
2258 for (; size < m_nDrawers; ++size)
2259 m_drawerType[size] = 0;
2260 }
2261
2262 msg(MSG::INFO) << MSG::INFO << "drawerType ";
2263 for (unsigned int dr = 0; dr < size; ++dr)
2264 msg(MSG::INFO) << " " << m_drawerType[dr];
2265 msg(MSG::INFO) << endmsg;
2266
2267 if (size > m_nDrawers) {
2268 ATH_MSG_INFO( "increasing m_nDrawers from " << m_nDrawers << " to " << size );
2269 m_nDrawers = size;
2270 }
2271
2272 if (size < 1) size = 1;
2273 if (m_eventsPerFile == 0) {
2274 m_eventsPerFile = static_cast<int>(200 / size) * 1000;
2275 ATH_MSG_INFO( "Number of events per file was 0, set it to 200k/" << size << " = " << m_eventsPerFile );
2276 }
2277
2278 } else {
2279
2280 ATH_MSG_ERROR( "can't find any TileDigits collections" );
2281 ATH_MSG_ERROR( "can't set up fragment list for ntuple" );
2282 }
2283 }
2284
2285 // once again - check number of samples in the data
2286 // but do not print any ERRORs now
2287
2288 // Go through all TileDigitsCollections
2289 for (const TileDigitsCollection* digitsCollection : *digitsCnt) {
2290 if (!digitsCollection->empty()) {
2291 int siz = digitsCollection->front()->samples().size();
2292 m_nSamplesInDrawerMap[digitsCollection->identify()] = siz;
2293 if (siz > m_nSamples && m_nSamples != 0) {
2294 ATH_MSG_WARNING( "Increasing number of digit samples in ntuple from " << m_nSamples << " to " << siz );
2295 m_nSamples = siz;
2296 }
2297 }
2298 }
2299 }
2300
2301 return StatusCode::SUCCESS;
2302}
2303
2304
2305StatusCode TileTBAANtuple::initListFlx(const EventContext& ctx) {
2306
2307 unsigned int listSize = m_drawerList.size();
2308
2309 if (listSize > 0) {
2310
2311 if (m_digitsContainerFlxKey.empty()) { // empty name, nothing to do
2312
2313 ATH_MSG_WARNING( "can't retrieve FELIX Digits from TDS" );
2314 ATH_MSG_WARNING( "can't set up FELIX fragment list for ntuple" );
2315
2316 if (m_nSamples != 0) {
2317 ATH_MSG_WARNING( "Disable FELIX digit samples in ntuple" );
2318 m_nSamplesFlx = 0;
2319 }
2320
2321 return StatusCode::SUCCESS;
2322 }
2323
2324 // Read Digits from TES
2325 const TileDigitsContainer* digitsCntFlx = SG::makeHandle (m_digitsContainerFlxKey, ctx).get();
2326
2327 if (listSize == m_nDrawers) {
2328 // Only legacy drawers in the list, setup FELIX frags IDs from the data
2329
2330 std::vector<unsigned int> frags;
2331 // Go through all TileDigitsCollections
2332 for (const TileDigitsCollection* digitsCollection : *digitsCntFlx) {
2333 if (!digitsCollection->empty()) {
2334 // Determine type of frag
2335 frags.push_back(digitsCollection->identify());
2336 }
2337 }
2338
2339 unsigned int nFrags = frags.size();
2340
2341 if (nFrags > 0) {
2342
2343 if (nFrags != m_nDrawersFlx) {
2344 ATH_MSG_INFO( "changing m_nDrawersFlx from " << m_nDrawersFlx.value() << " to " << nFrags );
2345 m_nDrawersFlx = nFrags;
2346 }
2347
2348 m_drawerFlxMap.clear();
2349
2350 std::ostringstream os;
2351 os << "setting FELIX drawers from data " << std::hex;
2352 unsigned int drawerIndex = 0;
2353 for (unsigned int frag : frags) {
2354 m_drawerFlxMap[frag] = drawerIndex;
2355 os << " 0x" << frag;
2356 ++drawerIndex;
2357 }
2358 os << std::dec;
2359
2360 ATH_MSG_INFO(os.str());
2361
2362 if (m_eventsPerFile == 0) {
2363 int nDrawersAll = m_nDrawers.value() + m_nDrawersFlx.value();
2364 m_eventsPerFile = static_cast<int>(200 / nDrawersAll) * 1000;
2365 ATH_MSG_INFO( "Number of events per file was 0, set it to 200k/" << nDrawersAll << " = " << m_eventsPerFile );
2366 }
2367
2368 } else {
2369 ATH_MSG_ERROR( "can't find any FELIX TileDigits collections" );
2370 ATH_MSG_ERROR( "can't set up FELIX fragment list for ntuple" );
2371 }
2372 }
2373
2374
2375 // once again - check number of samples in the data
2376 // but do not print any ERRORs now
2377
2378 for (const TileDigitsCollection* digitsCollection : *digitsCntFlx) {
2379 if (!digitsCollection->empty()) {
2380 int siz = digitsCollection->front()->samples().size();
2381 m_nSamplesFlxInDrawerMap[digitsCollection->identify()] = siz;
2382 if (siz > m_nSamplesFlx && m_nSamplesFlx != 0) {
2383 ATH_MSG_WARNING( "Increasing number of FELIX digit samples in ntuple from " << m_nSamplesFlx << " to " << siz );
2384 m_nSamplesFlx = siz;
2385 }
2386 }
2387 }
2388 }
2389
2390 return StatusCode::SUCCESS;
2391}
2392
2393
2394
2396void TileTBAANtuple::getEta() {
2397
2398 // Get eta from an ASCII file with the following structure :
2399 // runnumber eta
2400
2401 ATH_MSG_INFO( "Get eta for run " << m_runNumber );
2402
2403 // Find the full path to filename:
2404 std::string fileName = PathResolver::find_file(m_etaFileName, "DATAPATH");
2405 ATH_MSG_INFO( "Reading file " << fileName );
2406
2407 if (fileName.size() == 0) {
2408
2409 ATH_MSG_WARNING( "Could not find input file " << m_etaFileName );
2410 ATH_MSG_WARNING( "Skip reading of eta value " );
2411
2412 } else {
2413
2414 std::ifstream etafile;
2415 etafile.open(fileName.c_str());
2416
2417 if (etafile.good()) {
2418
2419 int runNumber = 0;
2420 float eta = 0;
2421 //coverity[TAINTED_SCALAR]
2422 while ((runNumber != m_runNumber) && (!etafile.eof())) {
2423 etafile >> runNumber >> eta;
2424 }
2425
2426 if (runNumber != m_runNumber) {
2427 ATH_MSG_INFO( "Run " << m_runNumber << " has not been found, keep eta and theta at zero" );
2428
2429 m_eta = m_theta = 0.0;
2430 } else {
2431 m_eta = eta;
2432 m_theta = (M_PI_2 - 2 * atan(exp(m_eta)));
2433 ATH_MSG_INFO( "Run " << m_runNumber << " has been found with eta=" << m_eta << ", theta =" << m_theta );
2434
2435 }
2436
2437 } else {
2438
2439 ATH_MSG_WARNING( "Problem with file " << fileName );
2440 ATH_MSG_WARNING( "Skip reading of eta value " );
2441
2442 }
2443
2444 etafile.close();
2445 }
2446}
2447
2450//
2465//
2466*/
2470//
2472*/
2473void TileTBAANtuple::TRIGGER_addBranch(void)
2474{
2475
2476 m_ntuplePtr->Branch("EvTime",&m_evTime,"EvTime/I");
2477 m_ntuplePtr->Branch("Run",&m_run,"Run/I");
2478 m_ntuplePtr->Branch("Evt",&m_evt,"Evt/I");
2479 m_ntuplePtr->Branch("Trig",&m_trigType,"Trig/S");
2480 m_ntuplePtr->Branch("DSPflags",&m_dspFlags,"DSPflags/I");
2481 m_ntuplePtr->Branch("DSPunits",&m_dspUnit,"DSPunits/S");
2482 m_ntuplePtr->Branch("OFLunits",&m_rchUnit,"OFLunits/S");
2483
2484 if ( m_completeNtuple ) {
2485 int nDrawersAll = m_nDrawers.value() + m_nDrawersFlx.value();
2486 if (nDrawersAll > 0) {
2487 m_l1ID.resize(nDrawersAll + 1);
2488 m_l1Type.resize(nDrawersAll + 1);
2489 m_evType.resize(nDrawersAll + 1);
2490 m_evBCID.resize(nDrawersAll + 1);
2491 m_frBCID.resize(nDrawersAll);
2492 }
2493
2494 // Info from ROD headers
2495 // m_nDrawers drawers separately (i.e. with duplications) + Beam ROD
2496 m_ntuplePtr->Branch("L1ID",&m_l1ID);
2497 m_ntuplePtr->Branch("L1Type",&m_l1Type);
2498 m_ntuplePtr->Branch("EvType",&m_evType);
2499 m_ntuplePtr->Branch("EvBCID",&m_evBCID);
2500 m_ntuplePtr->Branch("FrBCID",&m_frBCID);
2501 }
2502
2503
2504}
2505
2509//
2511*/
2512void TileTBAANtuple::MUON_addBranch(void)
2513{
2514
2515 if ( m_beamIdList[MUON_ADC_FRAG] ||
2516 m_beamIdList[ADDR_ADC_FRAG] )
2517 {
2518 m_ntuplePtr->Branch("MuBackHit",&m_muBackHit,"MuBackHit/F");
2519 m_ntuplePtr->Branch("MuBackSum",&m_muBackSum,"MuBackSum/F");
2520
2521 if (m_TBperiod < 2015) {
2522 m_ntuplePtr->Branch("MuBack",&m_muBack,"m_muBack[14]");
2523 m_ntuplePtr->Branch("MuCalib",&m_muCalib,"m_muCalib[2]");
2524 } else if (m_TBperiod == 2015) {
2525 m_ntuplePtr->Branch("MuBack",&m_muBack,"MuBack[8]/F");
2526 } else {
2527 m_ntuplePtr->Branch("MuBack",&m_muBack,"MuBack[12]/F");
2528 }
2529 }
2530
2531
2532}
2533
2537//
2539*/
2540void TileTBAANtuple::ECAL_addBranch(void)
2541{
2542
2543 if (m_beamIdList[ECAL_ADC_FRAG]) {
2544 m_ntuplePtr->Branch("Ecal",&m_ecal,"m_ecal[8]/F");
2545 }
2546
2547}
2548
2552//
2554*/
2555void TileTBAANtuple::QDC_addBranch(void)
2556{
2557
2558 if (m_beamIdList[ECAL_ADC_FRAG]) {
2559 for(unsigned i=0; i<33; ++i){ m_qdc[i]=0.0; }
2560 m_ntuplePtr->Branch("qdc", &m_qdc, "qdc[33]/i");
2561 }
2562
2563}
2564
2565
2568//Clear Tree TRIGGER variables
2569//
2571*/
2572void TileTBAANtuple::TRIGGER_clearBranch(void) {
2573
2574 m_evTime = 0;
2575 m_run = 0;
2576 m_evt = 0;
2577 m_trigType = 0;
2578
2579 if (m_completeNtuple) {
2580 std::fill(m_l1ID.begin(), m_l1ID.end(), 0);
2581 std::fill(m_l1Type.begin(), m_l1Type.end(), 0);
2582 std::fill(m_evType.begin(), m_evType.end(), 0);
2583 std::fill(m_evBCID.begin(), m_evBCID.end(), 0);
2584 std::fill(m_frBCID.begin(), m_frBCID.end(), 0);
2585 }
2586}
2587
2590//Clear Tree MUON variables
2591//
2593*/
2594void TileTBAANtuple::MUON_clearBranch(void) {
2595 m_muBackHit = 0.;
2596 m_muBackSum = 0.;
2597
2598}
2599
2602//Clear Tree ECAL variables
2603//
2605*/
2606void TileTBAANtuple::ECAL_clearBranch(void)
2607{
2608
2609}
2610
2613//Clear Tree QDC variables
2614//
2616*/
2617void TileTBAANtuple::QDC_clearBranch(void)
2618{
2619 for(unsigned i=0; i<33; ++i){ m_qdc[i]=0.0; }
2620}
2621
2622
2626//
2628*/
2629void TileTBAANtuple::LASER_addBranch(void) {
2630
2631 if (!m_laserObjectKey.empty() > 0) {
2632
2633 m_ntuplePtr->Branch("LASER_BCID", &m_las_BCID, "LASER_BCID/I");
2634
2635 m_ntuplePtr->Branch("LASER_FILTER", &m_las_Filt, "LASER_FILTER/I");
2636 m_ntuplePtr->Branch("LASER_REQAMP", &m_las_ReqAmp, "LASER_REQAMP/D");
2637 m_ntuplePtr->Branch("LASER_MEASAMP", &m_las_MeasAmp, "LASER_MEASAMP/D");
2638
2639 m_ntuplePtr->Branch("LASER_Diode_1_ADC", &m_las_D1_ADC, "LASER_Diode_1_ADC/I");
2640 m_ntuplePtr->Branch("LASER_Diode_2_ADC", &m_las_D2_ADC, "LASER_Diode_2_ADC/I");
2641 m_ntuplePtr->Branch("LASER_Diode_3_ADC", &m_las_D3_ADC, "LASER_Diode_3_ADC/I");
2642 m_ntuplePtr->Branch("LASER_Diode_4_ADC", &m_las_D4_ADC, "LASER_Diode_4_ADC/I");
2643
2644 m_ntuplePtr->Branch("LASER_Diode_1_Ped", &m_las_D1_Ped, "LASER_Diode_1_Ped/D");
2645 m_ntuplePtr->Branch("LASER_Diode_2_Ped", &m_las_D2_Ped, "LASER_Diode_2_Ped/D");
2646 m_ntuplePtr->Branch("LASER_Diode_3_Ped", &m_las_D3_Ped, "LASER_Diode_3_Ped/D");
2647 m_ntuplePtr->Branch("LASER_Diode_4_Ped", &m_las_D4_Ped, "LASER_Diode_4_Ped/D");
2648
2649 m_ntuplePtr->Branch("LASER_Diode_1_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_1_Ped_RMS/D");
2650 m_ntuplePtr->Branch("LASER_Diode_2_Ped_RMS", &m_las_D2_Ped_RMS, "LASER_Diode_2_Ped_RMS/D");
2651 m_ntuplePtr->Branch("LASER_Diode_3_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_3_Ped_RMS/D");
2652 m_ntuplePtr->Branch("LASER_Diode_4_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_4_Ped_RMS/D");
2653
2654 m_ntuplePtr->Branch("LASER_Diode_1_Alpha", &m_las_D1_Alpha, "LASER_Diode_1_Alpha/D");
2655 m_ntuplePtr->Branch("LASER_Diode_2_Alpha", &m_las_D2_Alpha, "LASER_Diode_2_Alpha/D");
2656 m_ntuplePtr->Branch("LASER_Diode_3_Alpha", &m_las_D3_Alpha, "LASER_Diode_3_Alpha/D");
2657 m_ntuplePtr->Branch("LASER_Diode_4_Alpha", &m_las_D4_Alpha, "LASER_Diode_4_Alpha/D");
2658
2659 m_ntuplePtr->Branch("LASER_Diode_1_Alpha_RMS", &m_las_D1_Alpha_RMS, "LASER_Diode_1_Alpha_RMS/D");
2660 m_ntuplePtr->Branch("LASER_Diode_2_Alpha_RMS", &m_las_D2_Alpha_RMS, "LASER_Diode_2_Alpha_RMS/D");
2661 m_ntuplePtr->Branch("LASER_Diode_3_Alpha_RMS", &m_las_D3_Alpha_RMS, "LASER_Diode_3_Alpha_RMS/D");
2662 m_ntuplePtr->Branch("LASER_Diode_4_Alpha_RMS", &m_las_D4_Alpha_RMS, "LASER_Diode_4_Alpha_RMS/D");
2663
2664 m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed", &m_las_D1_AlphaPed, "LASER_Diode_1_AlphaPed/D");
2665 m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed", &m_las_D2_AlphaPed, "LASER_Diode_2_AlphaPed/D");
2666 m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed", &m_las_D3_AlphaPed, "LASER_Diode_3_AlphaPed/D");
2667 m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed", &m_las_D4_AlphaPed, "LASER_Diode_4_AlphaPed/D");
2668
2669 m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed_RMS", &m_las_D1_AlphaPed_RMS, "LASER_Diode_1_AlphaPed_RMS/D");
2670 m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed_RMS", &m_las_D2_AlphaPed_RMS, "LASER_Diode_2_AlphaPed_RMS/D");
2671 m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed_RMS", &m_las_D3_AlphaPed_RMS, "LASER_Diode_3_AlphaPed_RMS/D");
2672 m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed_RMS", &m_las_D4_AlphaPed_RMS, "LASER_Diode_4_AlphaPed_RMS/D");
2673
2674 m_ntuplePtr->Branch("LASER_PMT_1_ADC", &m_las_PMT1_ADC, "LASER_PMT_1_ADC/I");
2675 m_ntuplePtr->Branch("LASER_PMT_2_ADC", &m_las_PMT2_ADC, "LASER_PMT_2_ADC/I");
2676
2677 m_ntuplePtr->Branch("LASER_PMT_1_TDC", &m_las_PMT1_TDC, "LASER_PMT_1_TDC/I");
2678 m_ntuplePtr->Branch("LASER_PMT_2_TDC", &m_las_PMT2_TDC, "LASER_PMT_2_TDC/I");
2679
2680 m_ntuplePtr->Branch("LASER_PMT_1_Ped", &m_las_PMT1_Ped, "LASER_PMT_1_Ped/D");
2681 m_ntuplePtr->Branch("LASER_PMT_2_Ped", &m_las_PMT2_Ped, "LASER_PMT_2_Ped/D");
2682
2683 m_ntuplePtr->Branch("LASER_PMT_1_Ped_RMS", &m_las_PMT1_Ped_RMS, "LASER_PMT_1_Ped_RMS/D");
2684 m_ntuplePtr->Branch("LASER_PMT_2_Ped_RMS", &m_las_PMT2_Ped_RMS, "LASER_PMT_2_Ped_RMS/D");
2685
2686 m_ntuplePtr->Branch("LASER_HEAD_Temp", &m_las_Temperature, "LASER_HEAD_Temp/D");
2687 }
2688
2689 if (m_beamIdList[LASE_PTN_FRAG]) {
2690 m_ntuplePtr->Branch("LasFlag", &m_lasFlag, "LasFlag/s");
2691 }
2692
2693 if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2694 || (!m_unpackAdder && m_beamIdList[LASE_ADC_FRAG])) {
2695 m_ntuplePtr->Branch("Las0", &m_las0, "Las0/F");
2696 m_ntuplePtr->Branch("Las1", &m_las1, "Las1/F");
2697 m_ntuplePtr->Branch("Las2", &m_las2, "Las2/F");
2698 m_ntuplePtr->Branch("Las3", &m_las3, "Las3/F");
2699 m_ntuplePtr->Branch("LasExtra", &m_lasExtra, "m_lasExtra[4]/F");
2700 }
2701
2702}
2703
2706//Clear Tree LASER variables
2707//
2709*/
2710void TileTBAANtuple::LASER_clearBranch(void)
2711{
2712
2713 if (!m_laserObjectKey.empty()) {
2714
2715 m_las_BCID = 0;
2716 m_las_D1_ADC = 0;
2717 m_las_D2_ADC = 0;
2718 m_las_D3_ADC = 0;
2719 m_las_D4_ADC = 0;
2720
2721 m_las_D1_Ped = 0;
2722 m_las_D2_Ped = 0;
2723 m_las_D3_Ped = 0;
2724 m_las_D4_Ped = 0;
2725
2726 m_las_D1_Alpha = 0;
2727 m_las_D2_Alpha = 0;
2728 m_las_D3_Alpha = 0;
2729 m_las_D4_Alpha = 0;
2730
2731 m_las_PMT1_ADC = 0;
2732 m_las_PMT2_ADC = 0;
2733
2734 m_las_PMT1_TDC = 0;
2735 m_las_PMT2_TDC = 0;
2736
2737 m_las_PMT1_Ped = 0;
2738 m_las_PMT2_Ped = 0;
2739 }
2740
2741 if (m_beamIdList[LASE_PTN_FRAG]) {
2742 m_lasFlag=0;
2743 }
2744
2745 if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2746 || (!m_unpackAdder && m_beamIdList[LASE_ADC_FRAG])) {
2747
2748 m_las0 = 0.;
2749 m_las1 = 0.;
2750 m_las2 = 0.;
2751 m_las3 = 0.;
2752
2753 }
2754}
2755
2759//
2761*/
2762void TileTBAANtuple::ADDER_addBranch(void) {
2763
2764 if (m_unpackAdder) {
2765 if (m_beamIdList[ADD_FADC_FRAG]) {
2766 m_adder.resize(16);
2767 m_adderPayload.resize(16*16);
2768 for (int j = 0; j < 16; j++) {
2769 m_adder[j] = m_adderPayload.data() + j * 16;
2770 }
2771
2772 m_ntuplePtr->Branch("Adder", *m_adder.data(), "m_adder[16][16]/I");
2773 m_ntuplePtr->Branch("EneAdd", &m_eneAdd, "m_eneAdd[16]/F");
2774 m_ntuplePtr->Branch("TimeAdd", &m_timeAdd, "m_timeAdd[16]/F");
2775 }
2776 }
2777}
2778
2781//Clear Tree ADDER variables
2782//
2784*/
2785void TileTBAANtuple::ADDER_clearBranch(void)
2786{
2787
2788
2789}
2790
2794//
2796*/
2797void TileTBAANtuple::CISPAR_addBranch(void) {
2798
2799 if (m_beamIdList[DIGI_PAR_FRAG & 0x1F]) {
2800
2801 m_ntuplePtr->Branch("cispar", m_cispar, "cispar[16]/I");
2802 }
2803}
2804
2807//Clear Tree CISPAR variables
2808//
2810*/
2811void TileTBAANtuple::CISPAR_clearBranch(void)
2812{
2813 memset(m_cispar,-1,sizeof(m_cispar));
2814}
2815
2816
2820//
2822*/
2823void TileTBAANtuple::BEAM_addBranch(void) {
2824
2825 if (((m_TBperiod >= 2015 || m_unpackAdder) && m_beamIdList[BEAM_ADC_FRAG])
2826 || ((!m_unpackAdder || m_TBperiod >= 2022) && m_beamIdList[COMMON_ADC1_FRAG])) {
2827
2828 m_ntuplePtr->Branch("S1cou", &m_s1cou, "S1cou/S");
2829 m_ntuplePtr->Branch("S2cou", &m_s2cou, "S2cou/S");
2830 if (m_TBperiod >= 2016 && m_TBperiod < 2022) {
2831 m_ntuplePtr->Branch("Cher3", &m_s3cou, "Cher3/S"); // dropped S3 in favor of Cher3 in September 2016 TB
2832 // m_ntuplePtr->Branch("SpmFinger", &m_muVeto, "SmpFinger/S"); // muVeto replaced by SPM for testing
2833 m_ntuplePtr->Branch("SiPM1", &m_muTag, "SiPM1/S"); // muTag replaced by SiPM1 for testing
2834 m_ntuplePtr->Branch("SiPM2", &m_muHalo, "SiPM2/S");// muHalo repalce by SiPM1 for testing
2835 } else {
2836 m_ntuplePtr->Branch("S3cou", &m_s3cou, "S3cou/S");
2837 }
2838
2839 m_ntuplePtr->Branch("Cher1", &m_cher1, "Cher1/S");
2840 m_ntuplePtr->Branch("Cher2", &m_cher2, "Cher2/S");
2841 if (m_TBperiod >= 2022) {
2842 m_ntuplePtr->Branch("Cher3", &m_cher3, "Cher3/S");
2843 }
2844
2845 if (m_TBperiod < 2015) {
2846 m_ntuplePtr->Branch("MuTag", &m_muTag, "MuTag/S");
2847 m_ntuplePtr->Branch("MuHalo", &m_muHalo, "MuHalo/S");
2848 m_ntuplePtr->Branch("MuVeto", &m_muVeto, "MuVeto/S");
2849 //} else if (m_TBperiod == 2015) {
2850 // nothing
2851 } else if (m_TBperiod >= 2016) {
2852 m_ntuplePtr->Branch("SCalo1", &m_muTag, "SCalo1/S");
2853 m_ntuplePtr->Branch("SCalo2", &m_muHalo, "SCalo2/S");
2854 //m_ntuplePtr->Branch("SCalo3", &m_muVeto, "SCalo3/S");
2855 }
2856 }
2857
2858 if (m_TBperiod >= 2015) {
2859 if (m_beamIdList[COMMON_TDC1_FRAG] || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2860 m_btdc = new std::vector<std::vector<int> >(16);
2861 m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1[16]/I");
2862 m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2[16]/I");
2863 m_ntuplePtr->Branch("btdc", &m_btdc);
2864 m_ntuplePtr->Branch("tjitter", &m_tjitter, "tjitter/I");
2865 m_ntuplePtr->Branch("tscTOF", &m_tscTOF, "tscTOF/I");
2866 m_ntuplePtr->Branch("btdcNhit", m_btdcNhit, "btdcNhit[16]/I");
2867 m_ntuplePtr->Branch("btdcNchMultiHit", m_btdcNchMultiHit, "btdcNchMultiHit[2]/I");
2868 }
2869 if (m_beamIdList[COMMON_TOF_FRAG]) {
2870 m_ntuplePtr->Branch("tof", &m_tof, "m_tof[16]/I");
2871 }
2872 if (m_beamIdList[COMMON_PTN_FRAG]) {
2873 m_ntuplePtr->Branch("scaler", &m_scaler, "m_scaler[16]/I");
2874 }
2875 } else if (!m_unpackAdder) {
2876 if (m_beamIdList[COMMON_ADC2_FRAG]) {
2877 m_ntuplePtr->Branch("S2extra", &m_s2extra, "S2extra/S");
2878 m_ntuplePtr->Branch("S2cou", &m_s3extra, "S3extra/S");
2879 }
2880 if (m_beamIdList[BEAM_ADC_FRAG]) {
2881 m_ntuplePtr->Branch("SC1", &m_sc1, "SC1/S");
2882 m_ntuplePtr->Branch("SC2", &m_sc2, "SC2/S");
2883 }
2884 if (m_beamIdList[COMMON_PTN_FRAG]) {
2885 m_ntuplePtr->Branch("pu", &m_commonPU, "pu/S");
2886 }
2887 if (m_beamIdList[COMMON_TOF_FRAG]) {
2888 m_ntuplePtr->Branch("tof", &m_tof, "m_tof[8]/I");
2889 }
2890 if (m_beamIdList[COMMON_TDC1_FRAG]) {
2891 m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1/I");
2892 }
2893 if (m_beamIdList[COMMON_TDC2_FRAG]) {
2894 m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2/I");
2895 }
2896
2897 if (m_beamIdList[COMMON_TDC1_FRAG]) {
2898 m_ntuplePtr->Branch("XchN2", &m_xChN2, "XchN2/F");
2899 m_ntuplePtr->Branch("YchN2", &m_yChN2, "YchN2/F");
2900 m_ntuplePtr->Branch("XchN1", &m_xChN1, "XchN1/F");
2901 m_ntuplePtr->Branch("YchN1", &m_yChN1, "YchN1/F");
2902 }
2903 if (m_beamIdList[COMMON_TDC2_FRAG]) {
2904 m_ntuplePtr->Branch("Xcha0", &m_xCha0, "Xcha0/F");
2905 m_ntuplePtr->Branch("Ycha0", &m_yCha0, "Ycha0/F");
2906 }
2907 } else {
2908 if (m_beamIdList[BEAM_TDC_FRAG]) {
2909 m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1[16]/I");
2910 m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2[16]/I");
2911 }
2912 }
2913
2914 if ((m_TBperiod >= 2015 && m_beamIdList[COMMON_TDC1_FRAG])
2915 || (m_unpackAdder && m_beamIdList[BEAM_TDC_FRAG])
2916 || (!m_unpackAdder && m_beamIdList[COMMON_TDC2_FRAG])
2917 || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2918
2919 m_ntuplePtr->Branch("Xcha1", &m_xCha1, "Xcha1/F");
2920 m_ntuplePtr->Branch("Ycha1", &m_yCha1, "Ycha1/F");
2921 m_ntuplePtr->Branch("Xcha2", &m_xCha2, "Xcha2/F");
2922 m_ntuplePtr->Branch("Ycha2", &m_yCha2, "Ycha2/F");
2923 m_ntuplePtr->Branch("Xcha1_0", &m_xCha1_0, "Xcha1_0/F");
2924 m_ntuplePtr->Branch("Ycha1_0", &m_yCha1_0, "Ycha1_0/F");
2925 m_ntuplePtr->Branch("Xcha2_0", &m_xCha2_0, "Xcha2_0/F");
2926 m_ntuplePtr->Branch("Ycha2_0", &m_yCha2_0, "Ycha2_0/F");
2927 m_ntuplePtr->Branch("Ximp", &m_xImp, "Ximp/F");
2928 m_ntuplePtr->Branch("Yimp", &m_yImp, "Yimp/F");
2929 m_ntuplePtr->Branch("Ximp_0", &m_xImp_0, "Ximp_0/F");
2930 m_ntuplePtr->Branch("Yimp_0", &m_yImp_0, "Yimp_0/F");
2931 m_ntuplePtr->Branch("Ximp_90", &m_xImp_90, "Ximp_90/F");
2932 m_ntuplePtr->Branch("Yimp_90", &m_yImp_90, "Yimp_90/F");
2933 m_ntuplePtr->Branch("Ximp_min90", &m_xImp_min90, "Ximp_min90/F");
2934 m_ntuplePtr->Branch("Yimp_min90", &m_yImp_min90, "Yimp_min90/F");
2935 }
2936
2937}
2938
2941//Clear Tree BEAM variables
2942//
2944*/
2945void TileTBAANtuple::BEAM_clearBranch(void) {
2946
2947 if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2948 || (!m_unpackAdder && m_beamIdList[COMMON_ADC1_FRAG])) {
2949
2950 m_s1cou = 0;
2951 m_s2cou = 0;
2952 m_s3cou = 0;
2953 m_cher1 = 0;
2954 m_cher2 = 0;
2955 m_cher3 = 0;
2956 m_muTag = 0;
2957 m_muHalo = 0;
2958 m_muVeto = 0;
2959 }
2960 if (!m_unpackAdder) {
2961 if (m_beamIdList[COMMON_ADC2_FRAG]) {
2962
2963 m_s2extra = 0;
2964 m_s3extra = 0;
2965 }
2966 if (m_beamIdList[BEAM_ADC_FRAG]) {
2967 m_sc1 = 0;
2968 m_sc2 = 0;
2969 }
2970 if (m_beamIdList[COMMON_PTN_FRAG]) {
2971 m_commonPU = 0;
2972 }
2973 if (m_beamIdList[COMMON_TDC1_FRAG]) {
2974 m_xChN2 = 0.;
2975 m_yChN2 = 0.;
2976 m_xChN1 = 0.;
2977 m_yChN1 = 0.;
2978 }
2979 if (m_beamIdList[COMMON_TDC2_FRAG]) {
2980 m_xCha0 = 0.;
2981 m_yCha0 = 0.;
2982 }
2983 }
2984
2985 if ((m_TBperiod >= 2015 && m_beamIdList[COMMON_TDC1_FRAG])
2986 || (m_unpackAdder && m_beamIdList[BEAM_TDC_FRAG])
2987 || (!m_unpackAdder && m_beamIdList[COMMON_TDC2_FRAG])
2988 || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2989
2990 m_xCha1 = 0.;
2991 m_yCha1 = 0.;
2992 m_xCha2 = 0.;
2993 m_yCha2 = 0.;
2994 m_xCha1_0 = 0.;
2995 m_yCha1_0 = 0.;
2996 m_xCha2_0 = 0.;
2997 m_yCha2_0 = 0.;
2998 m_xImp = 0.;
2999 m_yImp = 0.;
3000 }
3001
3002 m_muBack.fill(0.0F);
3003
3004 for (int i=0; i<16; i+=2) {
3005 m_tof[i] = +0xFFFF;
3006 m_tof[i+1] = -0xFFFF;
3007 }
3008
3009 for (int i=0; i<16; i+=2) {
3010 m_btdc1[i] = +0xFFFF;
3011 m_btdc1[i+1] = -0xFFFF;
3012 }
3013
3014 for (int i=0; i<16; i+=2) {
3015 m_btdc2[i] = +0xFFFF;
3016 m_btdc2[i+1] = -0xFFFF;
3017 }
3018
3019 if (m_btdc) {
3020 for (std::vector<int>& btdc_amplitudes : *m_btdc) {
3021 btdc_amplitudes.clear();
3022 }
3023 }
3024
3025 memset(&m_scaler, 0, sizeof(m_scaler));
3026
3027 memset(m_btdcNhit,0,sizeof(m_btdcNhit));
3028 memset(m_btdcNchMultiHit,0,sizeof(m_btdcNchMultiHit));
3029}
3030
3034//
3036*/
3037void TileTBAANtuple::ENETOTAL_addBranch(void)
3038{
3039 if (m_completeNtuple) {
3040 m_ntuplePtr->Branch("LarSmp", &m_LarEne, "m_LarEne[4]/F");
3041 m_ntuplePtr->Branch("BarSmp", &m_BarEne, "m_BarEne[3]/F");
3042 m_ntuplePtr->Branch("ExtSmp", &m_ExtEne, "m_ExtEne[3]/F");
3043 m_ntuplePtr->Branch("GapSmp", &m_GapEne, "m_GapEne[3]/F");
3044 }
3045}
3046
3049//Clear Tree ENETOTAL variables
3050//
3052*/
3053void TileTBAANtuple::ENETOTAL_clearBranch(void)
3054{
3055
3056
3057}
3058
3062//
3064*/
3065void TileTBAANtuple::COINCBOARD_addBranch(void) {
3066 if (m_beamIdList[COIN_TRIG1_FRAG]) {
3067 m_ntuplePtr->Branch("CoincTrig1", &m_coincTrig1, "m_coincTrig1[96]/I");
3068 m_ntuplePtr->Branch("CoincFlag1", &m_coincFlag1, "CoincFlag1/I");
3069 }
3070
3071 if (m_beamIdList[COIN_TRIG2_FRAG]) {
3072 m_ntuplePtr->Branch("CoincTrig2", &m_coincTrig2, "m_coincTrig2[96]/I");
3073 m_ntuplePtr->Branch("CoincFlag2", &m_coincFlag2, "CoincFlag2/I");
3074 }
3075
3076 if (m_beamIdList[COIN_TRIG3_FRAG]) {
3077 m_ntuplePtr->Branch("CoincTrig3", &m_coincTrig3, "m_coincTrig3[96]/I");
3078 m_ntuplePtr->Branch("CoincFlag3", &m_coincFlag3, "CoincFlag3/I");
3079 }
3080
3081 if (m_beamIdList[COIN_TRIG4_FRAG]) {
3082 m_ntuplePtr->Branch("CoincTrig4", &m_coincTrig4, "m_coincTrig4[96]/I");
3083 m_ntuplePtr->Branch("CoincFlag4", &m_coincFlag4, "CoincFlag4/I");
3084 }
3085 if (m_beamIdList[COIN_TRIG5_FRAG]) {
3086 m_ntuplePtr->Branch("CoincTrig5", &m_coincTrig5, "m_coincTrig5[96]/I");
3087 m_ntuplePtr->Branch("CoincFlag5", &m_coincFlag5, "CoincFlag5/I");
3088 }
3089
3090 if (m_beamIdList[COIN_TRIG6_FRAG]) {
3091 m_ntuplePtr->Branch("CoincTrig6", &m_coincTrig6, "m_coincTrig6[96]/I");
3092 m_ntuplePtr->Branch("CoincFlag6", &m_coincFlag6, "CoincFlag6/I");
3093 }
3094
3095 if (m_beamIdList[COIN_TRIG7_FRAG]) {
3096 m_ntuplePtr->Branch("CoincTrig7", &m_coincTrig7, "m_coincTrig7[96]/I");
3097 m_ntuplePtr->Branch("CoincFlag7", &m_coincFlag7, "CoincFlag7/I");
3098 }
3099
3100 if (m_beamIdList[COIN_TRIG8_FRAG]) {
3101 m_ntuplePtr->Branch("CoincTrig8", &m_coincTrig8, "m_coincTrig8[96]/I");
3102 m_ntuplePtr->Branch("CoincFlag8", &m_coincFlag8, "CoincFlag8/I");
3103 }
3104
3105}
3106
3109//Clear Tree COINCBOARD variables
3110//
3112*/
3113void TileTBAANtuple::COINCBOARD_clearBranch(void)
3114{
3115
3116
3117
3118}
3119
3123//
3125*/
3126void TileTBAANtuple::DIGI_addBranch(void)
3127{
3128
3129
3132 m_bcidVec.reserve(MAX_DRAWERS);
3133 m_DMUheaderVec.reserve(MAX_DRAWERS);
3134 m_DMUformatErrVec.reserve(MAX_DRAWERS);
3135 m_DMUparityErrVec.reserve(MAX_DRAWERS);
3136 m_DMUmemoryErrVec.reserve(MAX_DRAWERS);
3137 m_DMUDstrobeErrVec.reserve(MAX_DRAWERS);
3138 m_DMUHeadparityErrVec.reserve(MAX_DRAWERS);
3139 m_DMUDataparityErrVec.reserve(MAX_DRAWERS);
3140 m_DMUSstrobeErrVec.reserve(MAX_DRAWERS);
3141 m_dmuMaskVec.reserve(MAX_DRAWERS);
3142 m_slinkCRCVec.reserve(MAX_DRAWERS);
3143 m_gainVec.reserve(MAX_DRAWERS);
3144 m_sampleVec.reserve(MAX_DRAWERS);
3145 m_feCRCVec.reserve(MAX_DRAWERS);
3146 m_rodCRCVec.reserve(MAX_DRAWERS);
3147 m_eneVec.reserve(MAX_DRAWERS);
3148 m_timeVec.reserve(MAX_DRAWERS);
3149 m_pedFlatVec.reserve(MAX_DRAWERS);
3150 m_chi2FlatVec.reserve(MAX_DRAWERS);
3151 m_efitVec.reserve(MAX_DRAWERS);
3152 m_tfitVec.reserve(MAX_DRAWERS);
3153 m_pedfitVec.reserve(MAX_DRAWERS);
3154 m_chi2Vec.reserve(MAX_DRAWERS);
3155 m_efitcVec.reserve(MAX_DRAWERS);
3156 m_tfitcVec.reserve(MAX_DRAWERS);
3157 m_pedfitcVec.reserve(MAX_DRAWERS);
3158 m_chi2cVec.reserve(MAX_DRAWERS);
3159 m_eOptVec.reserve(MAX_DRAWERS);
3160 m_tOptVec.reserve(MAX_DRAWERS);
3161 m_pedOptVec.reserve(MAX_DRAWERS);
3162 m_chi2OptVec.reserve(MAX_DRAWERS);
3163 m_eDspVec.reserve(MAX_DRAWERS);
3164 m_tDspVec.reserve(MAX_DRAWERS);
3165 m_chi2DspVec.reserve(MAX_DRAWERS);
3166 m_ROD_GlobalCRCVec.reserve(MAX_DRAWERS);
3167 m_ROD_DMUBCIDVec.reserve(MAX_DRAWERS);
3168 m_ROD_DMUmemoryErrVec.reserve(MAX_DRAWERS);
3169 m_ROD_DMUSstrobeErrVec.reserve(MAX_DRAWERS);
3170 m_ROD_DMUDstrobeErrVec.reserve(MAX_DRAWERS);
3171 m_ROD_DMUHeadformatErrVec.reserve(MAX_DRAWERS);
3172 m_ROD_DMUDataformatErrVec.reserve(MAX_DRAWERS);
3173 m_ROD_DMUMaskVec.reserve(MAX_DRAWERS);
3174
3175 std::ostringstream oss;
3176 oss << m_nSamples;
3177 std::string nSampStr=oss.str();
3178
3179 unsigned int listSize = std::min(m_nDrawers.value(), static_cast<unsigned int>(m_drawerMap.size()));
3180
3181 if (listSize > 0) {
3182
3183 std::string digit[10] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
3184 std::vector<std::string> suffixArr;
3185 unsigned int length;
3186 bool testbeam = TileCablingService::getInstance()->getTestBeam();
3187
3188 if (m_calibMode) {
3189
3190 length = 2 * m_nDrawers;
3191 suffixArr.resize(length);
3192
3193 for (unsigned int i = 0; i < listSize; ++i) {
3194 unsigned int ros = m_drawerType[i];
3195 unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3196 std::string digits;
3197 if (m_TBperiod >= 2010) {
3198 ++drawer; // count modules from 1
3199 digits = digit[drawer / 10] + digit[drawer % 10];
3200 } else if (testbeam) {
3201 digits = digit[drawer & 7];
3202 } else {
3203 ++drawer; // count modules from 1
3204 digits = digit[drawer / 10] + digit[drawer % 10];
3205 }
3206
3207 if (ros == 0) {
3208 std::string suff = m_drawerList[i];
3209 suff.replace(suff.find("0x"), 2, "");
3210 suffixArr[i] = suff + "lo";
3211 suffixArr[i + m_nDrawers] = suff + "hi";
3212 } else {
3213 suffixArr[i] = m_rosName[ros] + digits + "lo";
3214 suffixArr[i + m_nDrawers] = m_rosName[ros] + digits + "hi";
3215 }
3216 }
3217 } else {
3218
3219 length = m_nDrawers;
3220 suffixArr.resize(length);
3221
3222 for (unsigned int i = 0; i < listSize; ++i) {
3223 unsigned int ros = m_drawerType[i];
3224 unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3225 std::string digits;
3226 if (m_TBperiod >= 2010) {
3227 ++drawer; // count modules from 1
3228 digits = digit[drawer / 10] + digit[drawer % 10];
3229 } else if (testbeam) {
3230 digits = digit[drawer & 7];
3231 } else {
3232 ++drawer; // count modules from 1
3233 digits = digit[drawer / 10] + digit[drawer % 10];
3234 }
3235
3236 if (ros == 0) {
3237 std::string suff = m_drawerList[i];
3238 suff.replace(suff.find("0x"), 2, "");
3239 suffixArr[i] = std::move(suff);
3240 } else {
3241 suffixArr[i] = m_rosName[ros] + digits;
3242 }
3243 }
3244 }
3245
3246 m_nSamplesInDrawer.reserve(length);
3247
3248 m_evtVec.resize(length);
3249 m_rodBCIDVec.resize(length);
3250 m_sizeVec.resize(length);
3251 m_ROD_GlobalCRCVec.resize(length);
3252
3253 for (unsigned int i = 0; i < length; i++) {
3254
3255 int nSamplesInDrawer(m_nSamples);
3256 int frag = std::stoi(m_drawerList[i%m_nDrawers], nullptr, 0);
3257
3258 auto it = m_nSamplesInDrawerMap.find(frag);
3259 if (it != m_nSamplesInDrawerMap.end()) {
3260 nSamplesInDrawer = it->second;
3261 }
3262 m_nSamplesInDrawer.push_back(nSamplesInDrawer);
3263
3264 m_bcidVec.push_back(std::array<int, MAX_DMU>()); // U
3265 m_DMUheaderVec.push_back(std::array<uint32_t, MAX_DMU>()); // U32
3266 m_DMUformatErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3267 m_DMUparityErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3268 m_DMUmemoryErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3269 m_DMUDstrobeErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3270 m_DMUSstrobeErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3271 m_DMUHeadparityErrVec.push_back(std::array<short, MAX_DMU>());
3272 m_DMUDataparityErrVec.push_back(std::array<short, MAX_DMU>());
3273
3274 m_dmuMaskVec.push_back(std::array<int, 2>()); // U(2)
3275 m_slinkCRCVec.push_back(std::array<int, 2>()); // U(2)
3276 m_gainVec.push_back(std::array<int, MAX_CHAN>()); // U(48/96)
3277 m_sampleVec.push_back(std::make_unique<int[]>(MAX_CHAN * nSamplesInDrawer)); // U(48/96,9)
3278 m_feCRCVec.push_back(std::array<int, MAX_DMU>()); //U
3279 m_rodCRCVec.push_back(std::array<int, MAX_DMU>()); //U
3280
3281 m_eneVec.push_back(std::array<float, MAX_CHAN>());
3282 m_timeVec.push_back(std::array<float, MAX_CHAN>());
3283 m_pedFlatVec.push_back(std::array<float, MAX_CHAN>());
3284 m_chi2FlatVec.push_back(std::array<float, MAX_CHAN>());
3285
3286 m_efitVec.push_back(std::array<float, MAX_CHAN>());
3287 m_tfitVec.push_back(std::array<float, MAX_CHAN>());
3288 m_pedfitVec.push_back(std::array<float, MAX_CHAN>());
3289 m_chi2Vec.push_back(std::array<float, MAX_CHAN>());
3290
3291 m_efitcVec.push_back(std::array<float, MAX_CHAN>());
3292 m_tfitcVec.push_back(std::array<float, MAX_CHAN>());
3293 m_pedfitcVec.push_back(std::array<float, MAX_CHAN>());
3294 m_chi2cVec.push_back(std::array<float, MAX_CHAN>());
3295
3296 m_eOptVec.push_back(std::array<float, MAX_CHAN>());
3297 m_tOptVec.push_back(std::array<float, MAX_CHAN>());
3298 m_pedOptVec.push_back(std::array<float, MAX_CHAN>());
3299 m_chi2OptVec.push_back(std::array<float, MAX_CHAN>());
3300
3301 m_eDspVec.push_back(std::array<float, MAX_CHAN>());
3302 m_tDspVec.push_back(std::array<float, MAX_CHAN>());
3303 m_chi2DspVec.push_back(std::array<float, MAX_CHAN>());
3304
3305 m_ROD_DMUBCIDVec.push_back(std::array<short, MAX_DMU>());
3306 m_ROD_DMUmemoryErrVec.push_back(std::array<short, MAX_DMU>());
3307 m_ROD_DMUSstrobeErrVec.push_back(std::array<short, MAX_DMU>());
3308 m_ROD_DMUDstrobeErrVec.push_back(std::array<short, MAX_DMU>());
3309 m_ROD_DMUHeadformatErrVec.push_back(std::array<short, MAX_DMU>());
3310 m_ROD_DMUDataformatErrVec.push_back(std::array<short, MAX_DMU>());
3311 m_ROD_DMUMaskVec.push_back(std::array<short, 2>());
3312
3313 if (i % m_nDrawers < listSize) {
3314
3315 ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3316 // create ntuple layout
3317 if (m_bsInput) {
3318 m_ntuplePtr->Branch(("Evt"+suffixArr[i]).c_str(), &m_evtVec.data()[i], ("Evt"+suffixArr[i]+"/I").c_str()); // int
3319 m_ntuplePtr->Branch(("rodBCID"+suffixArr[i]).c_str(), &m_rodBCIDVec.data()[i], ("rodBCID"+suffixArr[i]+"/S").c_str());//int
3320 m_ntuplePtr->Branch(("Size"+suffixArr[i]).c_str(), &m_sizeVec.data()[i], ("Size"+suffixArr[i]+"/S").c_str()); // short
3321 m_ntuplePtr->Branch(("BCID"+suffixArr[i]).c_str(), &m_bcidVec.back(), ("bcid"+suffixArr[i]+"[16]/I").c_str()); // int
3322 m_ntuplePtr->Branch(("DMUheader"+suffixArr[i]).c_str(), &m_DMUheaderVec.back(), ("DMUheader"+suffixArr[i]+"[16]/i").c_str()); // uint32
3323 m_ntuplePtr->Branch(("DMUformatErr"+suffixArr[i]).c_str(), &m_DMUformatErrVec.back(), ("DMUformatErr"+suffixArr[i]+"[16]/S").c_str()); // short
3324 m_ntuplePtr->Branch(("DMUparityErr"+suffixArr[i]).c_str(), &m_DMUparityErrVec.back(), ("DMUparityErr"+suffixArr[i]+"[16]/S").c_str()); // short
3325 m_ntuplePtr->Branch(("DMUmemoryErr"+suffixArr[i]).c_str(), &m_DMUmemoryErrVec.back(), ("DMUmemoryErr"+suffixArr[i]+"[16]/S").c_str()); // short
3326 m_ntuplePtr->Branch(("DMUSstrobeErr"+suffixArr[i]).c_str(), &m_DMUSstrobeErrVec.back(), ("DMUSstrobeErr"+suffixArr[i]+"[16]/S").c_str()); // short
3327 m_ntuplePtr->Branch(("DMUDstrobeErr"+suffixArr[i]).c_str(), &m_DMUDstrobeErrVec.back(), ("DMUDstrobeErr"+suffixArr[i]+"[16]/S").c_str()); // short
3328 m_ntuplePtr->Branch(("DMUMask"+suffixArr[i]).c_str(), &m_dmuMaskVec.back(), ("dmumask"+suffixArr[i]+"[2]/I").c_str()); // int
3329 m_ntuplePtr->Branch(("SlinkCRC"+suffixArr[i]).c_str(), &m_slinkCRCVec.back(), ("crc"+suffixArr[i]+"[2]/I").c_str()); // int
3330 m_ntuplePtr->Branch(("DMUHeadparityErr"+suffixArr[i]).c_str(), &m_DMUHeadparityErrVec.back(), ("DMUHeadparityErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3331 m_ntuplePtr->Branch(("DMUDataparityErr"+suffixArr[i]).c_str(), &m_DMUDataparityErrVec.back(), ("DMUDataparityErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3332 }
3333
3334 m_ntuplePtr->Branch(("Gain"+suffixArr[i]).c_str(),&m_gainVec.back(), ("gain"+suffixArr[i]+"[48]/I").c_str()); // int
3335
3336 if (nSamplesInDrawer > 0) {
3337 nSampStr = std::to_string(nSamplesInDrawer);
3338 m_ntuplePtr->Branch(("Sample" + suffixArr[i]).c_str(), m_sampleVec.back().get(),
3339 ("sample" + suffixArr[i] + "[48]["+nSampStr+"]/I").c_str()); // size m_nsample and type int
3340 }
3341
3342 if (m_bsInput) {
3343 m_ntuplePtr->Branch(("feCRC" + suffixArr[i]).c_str(), &m_feCRCVec.back(), ("fe_crc" + suffixArr[i] + "[16]/I").c_str()); // int
3344 m_ntuplePtr->Branch(("rodCRC" + suffixArr[i]).c_str(), &m_rodCRCVec.back(), ("rod_crc" + suffixArr[i] + "[16]/I").c_str()); // int
3345 }
3346
3347 if (!m_flatRawChannelContainerKey.empty()) {
3348
3349 m_ntuplePtr->Branch(("Ene" + suffixArr[i]).c_str(), &m_eneVec.back(), ("ene" + suffixArr[i] + "[48]/F").c_str()); // float
3350 m_ntuplePtr->Branch(("Time" + suffixArr[i]).c_str(), &m_timeVec.back(), ("time" + suffixArr[i] + "[48]/F").c_str()); // float
3351 m_ntuplePtr->Branch(("Ped" + suffixArr[i]).c_str(), &m_pedFlatVec.back(), ("pedflat" + suffixArr[i] + "[48]/F").c_str()); // float
3352 m_ntuplePtr->Branch(("Chi2ene" + suffixArr[i]).c_str(), &m_chi2FlatVec.back(), ("chiflat" + suffixArr[i] + "[48]/F").c_str()); // float
3353
3354 }
3355
3356 if (!m_fitRawChannelContainerKey.empty()) {
3357
3358 m_ntuplePtr->Branch(("Efit" + suffixArr[i]).c_str(), &m_efitVec.back(), ("efit" + suffixArr[i] + "[48]/F").c_str()); // float
3359 m_ntuplePtr->Branch(("Tfit" + suffixArr[i]).c_str(), &m_tfitVec.back(), ("tfit" + suffixArr[i] + "[48]/F").c_str()); // float
3360 m_ntuplePtr->Branch(("Pedfit" + suffixArr[i]).c_str(), &m_pedfitVec.back(), ("pedfit" + suffixArr[i] + "[48]/F").c_str()); // float
3361 m_ntuplePtr->Branch(("Chi2fit" + suffixArr[i]).c_str(), &m_chi2Vec.back(), ("chifit" + suffixArr[i] + "[48]/F").c_str()); // float
3362
3363 }
3364
3365 if (!m_fitcRawChannelContainerKey.empty()) {
3366
3367 m_ntuplePtr->Branch(("Efitc" + suffixArr[i]).c_str(), &m_efitcVec.back(), ("efitc" + suffixArr[i] + "[48]/F").c_str()); // float
3368 m_ntuplePtr->Branch(("Tfitc" + suffixArr[i]).c_str(), &m_tfitcVec.back(), ("tfitc" + suffixArr[i] + "[48]/F").c_str()); // float
3369 m_ntuplePtr->Branch(("Pedfitc" + suffixArr[i]).c_str(), &m_pedfitcVec.back(), ("pedfitc" + suffixArr[i] + "[48]/F").c_str()); // float
3370 m_ntuplePtr->Branch(("Chi2fitc" + suffixArr[i]).c_str(), &m_chi2cVec.back(), ("chifitc" + suffixArr[i] + "[48]/F").c_str()); // float
3371
3372 }
3373
3374 if (!m_optRawChannelContainerKey.empty()) {
3375
3376 m_ntuplePtr->Branch(("Eopt"+suffixArr[i]).c_str(), &m_eOptVec.back(), ("eOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3377 m_ntuplePtr->Branch(("Topt"+suffixArr[i]).c_str(), &m_tOptVec.back(), ("tOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3378 m_ntuplePtr->Branch(("Pedopt"+suffixArr[i]).c_str(), &m_pedOptVec.back(), ("pedOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3379 m_ntuplePtr->Branch(("Chi2opt"+suffixArr[i]).c_str(), &m_chi2OptVec.back(), ("chiOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3380
3381 }
3382
3383 if (!m_dspRawChannelContainerKey.empty()) {
3384
3385 m_ntuplePtr->Branch(("Edsp"+suffixArr[i]).c_str(), &m_eDspVec.back(), ("eDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3386 m_ntuplePtr->Branch(("Tdsp"+suffixArr[i]).c_str(), &m_tDspVec.back(), ("tDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3387 m_ntuplePtr->Branch(("Chi2dsp"+suffixArr[i]).c_str(), &m_chi2DspVec.back(), ("chiDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3388 m_ntuplePtr->Branch(("ROD_GlobalCRC"+suffixArr[i]).c_str(), &m_ROD_GlobalCRCVec.data()[i], ("ROD_GlobalCRC"+suffixArr[i]+"/s").c_str()); // unsigned short
3389 m_ntuplePtr->Branch(("ROD_DMUBCID"+suffixArr[i]).c_str(), &m_ROD_DMUBCIDVec.back(), ("ROD_DMUBCID"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3390 m_ntuplePtr->Branch(("ROD_DMUmemoryErr"+suffixArr[i]).c_str(), &m_ROD_DMUmemoryErrVec.back(), ("ROD_DMUmemoryErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3391 m_ntuplePtr->Branch(("ROD_DMUSstrobeErr"+suffixArr[i]).c_str(), &m_ROD_DMUSstrobeErrVec.back(), ("ROD_DMUSstrobeErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3392 m_ntuplePtr->Branch(("ROD_DMUDstrobeErr"+suffixArr[i]).c_str(), &m_ROD_DMUDstrobeErrVec.back(), ("ROD_DMUDstrobeErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3393 m_ntuplePtr->Branch(("ROD_DMUHeadformatErr"+suffixArr[i]).c_str(), &m_ROD_DMUHeadformatErrVec.back(), ("ROD_DMUHeadformatErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3394 m_ntuplePtr->Branch(("ROD_DMUDataformatErr"+suffixArr[i]).c_str(), &m_ROD_DMUDataformatErrVec.back(), ("ROD_DMUDataformatErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3395 m_ntuplePtr->Branch(("ROD_DMUMask"+suffixArr[i]).c_str(), &m_ROD_DMUMaskVec.back(), ("ROD_DMUMask"+suffixArr[i]+"[2]/s").c_str()); // unsigned short
3396
3397 }
3398 }
3399 }
3400 }
3401}
3402
3407*/
3408void TileTBAANtuple::DIGI_clearBranch(void)
3409{
3410 clear_init_minus1(m_evtVec);
3411 clear_init_minus1(m_rodBCIDVec);
3412 clear_init_minus1(m_sizeVec);
3413
3414 clear_init_minus1(m_bcidVec);
3415 clear_init_zero(m_DMUheaderVec);
3416 clear_init_minus1(m_DMUformatErrVec);
3417 clear_init_minus1(m_DMUparityErrVec);
3418 clear_init_minus1(m_DMUmemoryErrVec);
3419 clear_init_minus1(m_DMUDstrobeErrVec);
3420 clear_init_minus1(m_DMUSstrobeErrVec);
3421 clear_init_minus1(m_DMUDataparityErrVec);
3422 clear_init_minus1(m_DMUHeadparityErrVec);
3423
3424 clear_init_minus1(m_ROD_GlobalCRCVec);
3425 clear_init_minus1(m_ROD_DMUBCIDVec);
3426 clear_init_minus1(m_ROD_DMUmemoryErrVec);
3427 clear_init_minus1(m_ROD_DMUSstrobeErrVec);
3428 clear_init_minus1(m_ROD_DMUDstrobeErrVec);
3429 clear_init_minus1(m_ROD_DMUHeadformatErrVec);
3430 clear_init_minus1(m_ROD_DMUDataformatErrVec);
3431 clear_init_minus1(m_ROD_DMUMaskVec);
3432
3433 clear_init_minus1(m_dmuMaskVec);
3434 clear_init_minus1(m_slinkCRCVec);
3435 clear_init_minus1(m_gainVec);
3436 clear_samples(m_sampleVec, m_nSamplesInDrawer);
3437 clear_init_minus1(m_feCRCVec);
3438 clear_init_minus1(m_rodCRCVec);
3439
3440 clear_init_zero(m_eneVec);
3441 clear_init_zero(m_timeVec);
3442 clear_init_zero(m_pedFlatVec);
3443 clear_init_zero(m_chi2FlatVec);
3444 clear_init_zero(m_efitVec);
3445 clear_init_zero(m_tfitVec);
3446 clear_init_zero(m_pedfitVec);
3447 clear_init_zero(m_chi2Vec);
3448 clear_init_zero(m_efitcVec);
3449 clear_init_zero(m_tfitcVec);
3450 clear_init_zero(m_pedfitcVec);
3451 clear_init_zero(m_chi2cVec);
3452 clear_init_zero(m_eOptVec);
3453 clear_init_zero(m_tOptVec);
3454 clear_init_zero(m_pedOptVec);
3455 clear_init_zero(m_chi2OptVec);
3456 clear_init_zero(m_eDspVec);
3457 clear_init_zero(m_tDspVec);
3458 clear_init_zero(m_chi2DspVec);
3459
3460}
3461
3462
3463void TileTBAANtuple::FELIX_addBranch(void)
3464{
3465
3466 m_rodBCIDflxVec.reserve(MAX_DRAWERS);
3467 m_sizeflxVec.reserve(MAX_DRAWERS);
3468 m_evtflxVec.reserve(MAX_DRAWERS);
3469
3470 m_eflxfitVec.reserve(MAX_DRAWERS);
3471 m_tflxfitVec.reserve(MAX_DRAWERS);
3472 m_chi2flxfitVec.reserve(MAX_DRAWERS);
3473 m_pedflxfitVec.reserve(MAX_DRAWERS);
3474 m_eflxoptVec.reserve(MAX_DRAWERS);
3475 m_tflxoptVec.reserve(MAX_DRAWERS);
3476 m_chi2flxoptVec.reserve(MAX_DRAWERS);
3477 m_pedflxoptVec.reserve(MAX_DRAWERS);
3478 m_gainflxVec.reserve(MAX_DRAWERS);
3479 m_sampleflxVec.reserve(MAX_DRAWERS);
3480
3481 m_mdL1idflxVec.reserve(MAX_DRAWERS);
3482 m_mdBcidflxVec.reserve(MAX_DRAWERS);
3483 m_mdModuleflxVec.reserve(MAX_DRAWERS);
3484 m_mdRunTypeflxVec.reserve(MAX_DRAWERS);
3485 m_mdPedLoflxVec.reserve(MAX_DRAWERS);
3486 m_mdPedHiflxVec.reserve(MAX_DRAWERS);
3487 m_mdRunflxVec.reserve(MAX_DRAWERS);
3488 m_mdChargeflxVec.reserve(MAX_DRAWERS);
3489 m_mdChargeTimeflxVec.reserve(MAX_DRAWERS);
3490 m_mdCapacitorflxVec.reserve(MAX_DRAWERS);
3491
3492 std::string nSampStrFlx = std::to_string(m_nSamplesFlx);
3493 unsigned int listSize = std::min(m_nDrawersFlx.value(), static_cast<unsigned int>(m_drawerFlxMap.size()));
3494
3495 bool testbeam = TileCablingService::getInstance()->getTestBeam();
3496 std::vector<std::string> moduleNames(m_nDrawersFlx, "");
3497 unsigned int length = 2 * m_nDrawersFlx;
3498 std::vector<std::string> suffixArr(length, "");
3499 m_nSamplesFlxInDrawer.resize(length);
3500
3501 for (const std::pair<const unsigned int, unsigned int>& fragAndDrawer : m_drawerFlxMap) {
3502 unsigned int frag = fragAndDrawer.first;
3503 unsigned int ros = frag >> 8;
3504 unsigned int drawer = frag & 0x3F;
3505 unsigned int drawerIndex = fragAndDrawer.second;
3506
3507 std::ostringstream drawerName;
3508 drawerName << m_rosName[ros];
3509 if (testbeam) {
3510 drawerName << (drawer & 7);
3511 } else {
3512 ++drawer; // count modules from 1
3513 drawerName << std::setw(2) << std::setfill('0') << drawer;
3514 }
3515
3516 moduleNames.at(drawerIndex) = drawerName.str();
3517 suffixArr.at(drawerIndex) = drawerName.str() + "lo";
3518 suffixArr.at(drawerIndex + m_nDrawersFlx) = drawerName.str() + "hi";
3519
3520 int nSamples(m_nSamplesFlx);
3521 auto it = m_nSamplesFlxInDrawerMap.find(frag);
3522 if (it != m_nSamplesFlxInDrawerMap.end()) {
3523 nSamples = it->second;
3524 }
3525
3526 m_nSamplesFlxInDrawer[drawerIndex] = nSamples;
3527 m_nSamplesFlxInDrawer[drawerIndex + m_nDrawersFlx] = nSamples;
3528 }
3529
3530 m_rodBCIDflxVec.resize(m_nDrawersFlx);
3531 m_sizeflxVec.resize(m_nDrawersFlx);
3532 m_evtflxVec.resize(m_nDrawersFlx);
3533
3534 for (unsigned int i = 0; i < length; ++i) {
3535
3536 int nSamplesInDrawer = m_nSamplesFlxInDrawer[i];
3537
3538 m_eflxfitVec.push_back(std::array<float, MAX_CHAN>());
3539 m_tflxfitVec.push_back(std::array<float, MAX_CHAN>());
3540 m_pedflxfitVec.push_back(std::array<float, MAX_CHAN>());
3541 m_chi2flxfitVec.push_back(std::array<float, MAX_CHAN>());
3542
3543 m_eflxoptVec.push_back(std::array<float, MAX_CHAN>());
3544 m_tflxoptVec.push_back(std::array<float, MAX_CHAN>());
3545 m_pedflxoptVec.push_back(std::array<float, MAX_CHAN>());
3546 m_chi2flxoptVec.push_back(std::array<float, MAX_CHAN>());
3547
3548 if (i < m_nDrawersFlx) {
3549 m_mdL1idflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3550 m_mdBcidflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3551 m_mdModuleflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3552 m_mdRunTypeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3553 m_mdPedLoflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3554 m_mdPedHiflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3555 m_mdRunflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3556 m_mdChargeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3557 m_mdChargeTimeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3558 m_mdCapacitorflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3559
3560 std::string suffix = moduleNames[i];
3561 ATH_MSG_DEBUG( "Adding items for " << suffix );
3562
3563 if (m_bsInput) {
3564 m_ntuplePtr->Branch(("FlxEvt"+suffix).c_str(), &m_evtflxVec.data()[i]); // int
3565 m_ntuplePtr->Branch(("FlxRodBCID"+suffix).c_str(), &m_rodBCIDflxVec.data()[i]);//int
3566 m_ntuplePtr->Branch(("FlxSize"+suffix).c_str(), &m_sizeflxVec.data()[i]); // short
3567 }
3568
3569 m_ntuplePtr->Branch(("FlxL1ID"+suffix).c_str(), &m_mdL1idflxVec.back()); // int
3570 m_ntuplePtr->Branch(("FlxBCID"+suffix).c_str(), &m_mdBcidflxVec.back()); // int
3571 m_ntuplePtr->Branch(("FlxModule"+suffix).c_str(), &m_mdModuleflxVec.back()); // int
3572 m_ntuplePtr->Branch(("FlxRun"+suffix).c_str(), &m_mdRunflxVec.back()); // int
3573 m_ntuplePtr->Branch(("FlxRunType"+suffix).c_str(), &m_mdRunTypeflxVec.back()); // int
3574 m_ntuplePtr->Branch(("FlxPedLo"+suffix).c_str(), &m_mdPedLoflxVec.back()); // int
3575 m_ntuplePtr->Branch(("FlxPedHi"+suffix).c_str(), &m_mdPedHiflxVec.back()); // int
3576 m_ntuplePtr->Branch(("FlxCharge"+suffix).c_str(), &m_mdChargeflxVec.back()); // int
3577 m_ntuplePtr->Branch(("FlxChargeTime"+suffix).c_str(), &m_mdChargeTimeflxVec.back()); // int
3578 m_ntuplePtr->Branch(("FlxCapacitor"+suffix).c_str(), &m_mdCapacitorflxVec.back()); // int
3579
3580 }
3581
3582 m_gainflxVec.push_back(std::array<int, MAX_CHAN>());
3583 m_sampleflxVec.push_back(std::make_unique<int[]>(MAX_CHAN * nSamplesInDrawer)); // U(48/96,9)
3584
3585 if (i % m_nDrawersFlx < listSize) {
3586 ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3587
3588 m_ntuplePtr->Branch(("FlxGain"+suffixArr[i]).c_str(), &m_gainflxVec.back()); // int
3589
3590 if (nSamplesInDrawer > 0) {
3591 nSampStrFlx = std::to_string(nSamplesInDrawer);
3592 m_ntuplePtr->Branch(("FlxSample" + suffixArr[i]).c_str(), m_sampleflxVec.back().get(),
3593 ("Flxsample" + suffixArr[i] + "[48]["+nSampStrFlx+"]/I").c_str()); // size m_nsample and type int
3594 }
3595
3596 if (!m_flxFitRawChannelContainerKey.empty()) {
3597 m_ntuplePtr->Branch(("FlxEfit" + suffixArr[i]).c_str(), &m_eflxfitVec.back()); // float
3598 m_ntuplePtr->Branch(("FlxTfit" + suffixArr[i]).c_str(), &m_tflxfitVec.back()); // float
3599 m_ntuplePtr->Branch(("FlxPedfit" + suffixArr[i]).c_str(), &m_pedflxfitVec.back()); // float
3600 m_ntuplePtr->Branch(("FlxChi2fit" + suffixArr[i]).c_str(), &m_chi2flxfitVec.back()); // float
3601 }
3602
3603 if (!m_flxOptRawChannelContainerKey.empty()) {
3604 m_ntuplePtr->Branch(("FlxEOpt" + suffixArr[i]).c_str(), &m_eflxoptVec.back()); // float
3605 m_ntuplePtr->Branch(("FlxTOpt" + suffixArr[i]).c_str(), &m_tflxoptVec.back()); // float
3606 m_ntuplePtr->Branch(("FlxPedOpt" + suffixArr[i]).c_str(), &m_pedflxoptVec.back()); // float
3607 m_ntuplePtr->Branch(("FlxChi2Opt" + suffixArr[i]).c_str(), &m_chi2flxoptVec.back()); // float
3608 }
3609 }
3610 }
3611}
3612
3613
3614
3645
3649//
3651*/
3652void TileTBAANtuple::HIT_addBranch(void)
3653{
3654 m_ehitVec.clear();
3655 m_thitVec.clear();
3656 m_ehitCnt.clear();
3657 m_thitCnt.clear();
3658
3659 m_ehitVec.reserve(MAX_DRAWERS);
3660 m_thitVec.reserve(MAX_DRAWERS);
3661 m_ehitCnt.reserve(MAX_DRAWERS);
3662 m_thitCnt.reserve(MAX_DRAWERS);
3663
3664 unsigned int listSize = std::min(m_nDrawers.value(), static_cast<unsigned int>(m_drawerMap.size()));
3665
3666 if (listSize > 0) {
3667
3668 std::string digit[10] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
3669 std::vector<std::string> suffixArr;
3670 unsigned int length;
3671 bool testbeam = TileCablingService::getInstance()->getTestBeam();
3672
3673 length = m_nDrawers;
3674 suffixArr.resize(length);
3675
3676 for (unsigned int i = 0; i < listSize; ++i) {
3677 unsigned int ros = m_drawerType[i];
3678 unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3679 std::string digits;
3680 if (m_TBperiod >= 2010) {
3681 ++drawer; // count modules from 1
3682 digits = digit[drawer / 10] + digit[drawer % 10];
3683 } else if (testbeam) {
3684 digits = digit[drawer & 7];
3685 } else {
3686 ++drawer; // count modules from 1
3687 digits = digit[drawer / 10] + digit[drawer % 10];
3688 }
3689
3690 if (ros == 0) {
3691 std::string suff = m_drawerList[i];
3692 suff.replace(suff.find("0x"), 2, "");
3693 suffixArr[i] = std::move(suff);
3694 } else {
3695 suffixArr[i] = m_rosName[ros] + digits;
3696 }
3697 }
3698
3699 for (unsigned int i = 0; i < length; i++) {
3700
3701 if (i % m_nDrawers < listSize)
3702 ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3703
3704 m_ehitVec.push_back(std::array<float, MAX_CHAN>());
3705 m_thitVec.push_back(std::array<float, MAX_CHAN>());
3706 m_ehitCnt.push_back(std::array<float, MAX_CHAN>());
3707 m_thitCnt.push_back(std::array<float, MAX_CHAN>());
3708
3709 if (i%m_nDrawers < listSize) {
3710
3711 if (!m_hitVectorKey.empty()) {
3712
3713 if (i % m_nDrawers < listSize)
3714 ATH_MSG_DEBUG( "Adding G4 hit info for " << suffixArr[i] );
3715
3716 m_ntuplePtr->Branch(("EhitG4"+suffixArr[i]).c_str(),&m_ehitVec.back(),("eHitG4"+suffixArr[i]+"[48]/F").c_str());
3717 m_ntuplePtr->Branch(("ThitG4"+suffixArr[i]).c_str(),&m_thitVec.back(),("tHitG4"+suffixArr[i]+"[48]/F").c_str());
3718 }
3719
3720 if (!m_hitContainerKey.empty()) {
3721
3722 if (i % m_nDrawers < listSize)
3723 ATH_MSG_DEBUG( "Adding G4 corrected hit info for " << suffixArr[i] );
3724
3725 m_ntuplePtr->Branch(("EhitSim"+suffixArr[i]).c_str(),&m_ehitCnt.back(),("eHitSim"+suffixArr[i]+"[48]/F").c_str());
3726 m_ntuplePtr->Branch(("ThitSim"+suffixArr[i]).c_str(),&m_thitCnt.back(),("tHitSim"+suffixArr[i]+"[48]/F").c_str());
3727 }
3728 }
3729 }
3730 }
3731}
3732
3737*/
3745
3746template<typename T>
3747void TileTBAANtuple::clear_init_minus1(std::vector<T>& vec) {
3748 std::fill(vec.begin(), vec.end(), static_cast<T>(-1));
3749}
3750
3751template<typename T, size_t N>
3752void TileTBAANtuple::clear_init_minus1(std::vector<std::array<T,N>>& vec) {
3753 for (std::array<T,N>& arr : vec) {
3754 std::fill(arr.begin(), arr.end(), static_cast<T>(-1));
3755 }
3756}
3757
3758template<typename T, size_t N>
3759void TileTBAANtuple::clear_init_zero(std::vector<std::array<T,N>>& vec) {
3760 for (std::array<T,N>& arr : vec) {
3761 std::fill(arr.begin(), arr.end(), static_cast<T>(0));
3762 }
3763}
3764
3765void TileTBAANtuple::clear_samples(std::vector<std::unique_ptr<int []>> & vec, const std::vector<int>& nsamples, int nchan)
3766{
3767 for (unsigned int i = 0; i < vec.size(); ++i) {
3768 std::fill(vec[i].get(), vec[i].get() + nsamples.at(i) * nchan, -1);
3769 }
3770}
3771
3772void TileTBAANtuple::setupBeamChambersBeforeTB2015(void) {
3773 // Setup default value for the following properties, if they are not setup via JO
3774 setupPropertyDefaultValue(m_beamBC1X1, -0.938, "BC1X1");
3775 setupPropertyDefaultValue(m_beamBC1X2, 0.1747, "BC1X2");
3776 setupPropertyDefaultValue(m_beamBC1Y1, 0.125, "BC1Y1");
3777 setupPropertyDefaultValue(m_beamBC1Y2, 0.1765, "BC1Y2");
3778 setupPropertyDefaultValue(m_beamBC1Z, 13788.0, "BC1Z");
3779 setupPropertyDefaultValue(m_beamBC1Z_0, 13788.0, "BC1Z_0");
3780 setupPropertyDefaultValue(m_beamBC1Z_90, 13788.0, "BC1Z_90");
3781 setupPropertyDefaultValue(m_beamBC1Z_min90, 13788.0, "BC1Z_min90");
3782
3783 setupPropertyDefaultValue(m_beamBC2X1, -0.9369, "BC2X1");
3784 setupPropertyDefaultValue(m_beamBC2X2, 0.191, "BC2X2");
3785 setupPropertyDefaultValue(m_beamBC2Y1, -1.29, "BC2Y1");
3786 setupPropertyDefaultValue(m_beamBC2Y2, 0.187, "BC2Y2");
3787 setupPropertyDefaultValue(m_beamBC2Z, 9411.0, "BC2Z");
3788 setupPropertyDefaultValue(m_beamBC2Z_0, 9411.0, "BC2Z_0");
3789 setupPropertyDefaultValue(m_beamBC2Z_90, 9411.0, "BC2Z_90");
3790 setupPropertyDefaultValue(m_beamBC2Z_min90, 9411.0, "BC2Z_min90");
3791}
3792
3793void TileTBAANtuple::setupBeamChambersTB2015(void) {
3794 setupPropertyDefaultValue(m_beamBC1X1, -0.0462586, "BC1X1");
3795 setupPropertyDefaultValue(m_beamBC1X2, -0.175666, "BC1X2");
3796 setupPropertyDefaultValue(m_beamBC1Y1, -0.051923, "BC1Y1");
3797 setupPropertyDefaultValue(m_beamBC1Y2, -0.176809, "BC1Y2");
3798 setupPropertyDefaultValue(m_beamBC1Z, 13000. + 2760, "BC1Z");
3799 setupPropertyDefaultValue(m_beamBC1Z_0, 13788.0, "BC1Z_0");
3800 setupPropertyDefaultValue(m_beamBC1Z_90, 13788.0, "BC1Z_90");
3801 setupPropertyDefaultValue(m_beamBC1Z_min90, 13788.0, "BC1Z_min90");
3802
3803 setupPropertyDefaultValue(m_beamBC2X1, 0.25202, "BC2X1");
3804 setupPropertyDefaultValue(m_beamBC2X2, -0.18053, "BC2X2");
3805 setupPropertyDefaultValue(m_beamBC2Y1, 0.0431688, "BC2Y1");
3806 setupPropertyDefaultValue(m_beamBC2Y2, -0.181128, "BC2Y2");
3807 setupPropertyDefaultValue(m_beamBC2Z, 2760, "BC2Z");
3808 setupPropertyDefaultValue(m_beamBC2Z_0, 9411.0, "BC2Z_0");
3809 setupPropertyDefaultValue(m_beamBC2Z_90, 9411.0, "BC2Z_90");
3810 setupPropertyDefaultValue(m_beamBC2Z_min90, 9411.0, "BC2Z_min90");
3811}
3812
3813void TileTBAANtuple::setupBeamChambersTB2016_2020(void) {
3814 // 2016 settings:
3815 //
3816 // https://pcata007.cern.ch/elog/TB2016/88
3817 //
3818 //
3819 // The calibration has been done with the following runs :
3820 // BC1:
3821 // Center : 610212
3822 // Left/up : 610210
3823 // Right/down : 610209
3824 //
3825 // BC2:
3826 // Center : 610256
3827 // Left/up : 610321
3828 // Right/down : 610320
3829 //
3830 // Here are the new constants :
3831 //
3832 // BC1
3833 // horizontal slope = -0.171928
3834 // horizontal offset = -0.047624
3835 //
3836 // vertical slope = -0.172942
3837 // vertical offset = -0.0958677
3838 //
3839 // BC2
3840 // horizontal slope = -0.175698
3841 // horizontal offset = -1.04599
3842 //
3843 // vertical slope = -0.174535
3844 // vertical offset = -3.10666
3845
3846 // June 2016 calibration
3847 //m_beamBC1X1 = -0.047624;
3848 //m_beamBC1X2 = -0.171928;
3849 //m_beamBC1Y1 = -0.0958677;
3850 //m_beamBC1Y2 = -0.172942;
3851 //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3852
3853 //m_beamBC2X1 = -1.04599;
3854 //m_beamBC2X2 = -0.175698;
3855 //m_beamBC2Y1 = -3.10666;
3856 //m_beamBC2Y2 = -0.174535;
3857 //m_beamBC2Z = 2760 /* 2600. */;
3858
3859 // September 2016 calibration, https://pcata007.cern.ch/elog/TB2016/300 (joakim.olsson@cern.ch)
3860 //m_beamBC1X1 = 0.100857923042;
3861 //m_beamBC1X2 = -0.172098;
3862 //m_beamBC1Y1 = -0.133045996607;
3863 //m_beamBC1Y2 = -0.172855178323;
3864 //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3865 //
3866 //m_beamBC2X1 = 0.271555258578 ;
3867 //m_beamBC2X2 = -0.173463 ;
3868 //m_beamBC2Y1 = 0.305483228502;
3869 //m_beamBC2Y2 = -0.173805131744 ;
3870 //m_beamBC2Z = 2760 /* 2600. */;
3871
3872 // June 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3873 //m_beamBC1X1 = 0.153584934082;
3874 //m_beamBC1X2 = -0.175220;
3875 //m_beamBC1Y1 = -0.493246053303;
3876 //m_beamBC1Y2 = -0.176567356723;
3877 //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3878 //
3879 //m_beamBC2X1 = 0.414611893278;
3880 //m_beamBC2X2 = -0.176122;
3881 //m_beamBC2Y1 = 0.150807740888;
3882 //m_beamBC2Y2 = -0.173472808704;
3883 //m_beamBC2Z = 2760 /* 2600. */;
3884
3885 // August 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3886 //m_beamBC1X1 = 0.181797;
3887 //m_beamBC1X2 = -0.175657;
3888 //m_beamBC1Y1 = -0.128910;
3889 //m_beamBC1Y2 = -0.175965;
3890 //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3891 //
3892 //m_beamBC2X1 = 0.611502;
3893 //m_beamBC2X2 = -0.183116;
3894 //m_beamBC2Y1 = 0.541212;
3895 //m_beamBC2Y2 = -0.183115;
3896 //m_beamBC2Z = 2760 /* 2600. */;
3897
3898 // September 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3899 //m_beamBC1X1 = 0.181797;
3900 //m_beamBC1X2 = -0.175657;
3901 //m_beamBC1Y1 = -0.128910;
3902 //m_beamBC1Y2 = -0.175965;
3903 //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3904
3905 //m_beamBC2X1 = 0.622896039922;
3906 //m_beamBC2X2 = -0.176735;
3907 //m_beamBC2Y1 = 0.195954125116;
3908 //m_beamBC2Y2 = -0.176182117624;
3909 //m_beamBC2Z = 2760 /* 2600. */;
3910
3911 // September 2017 calibration with additional precision from Survey
3912 setupPropertyDefaultValue(m_beamBC1X1, 0.681797, "BC1X1");
3913 setupPropertyDefaultValue(m_beamBC1X2, -0.175657, "BC1X2");
3914 setupPropertyDefaultValue(m_beamBC1Y1, -2.02891, "BC1Y1");
3915 setupPropertyDefaultValue(m_beamBC1Y2, -0.175965, "BC1Y2");
3916 setupPropertyDefaultValue(m_beamBC1Z, 17348.8, "BC1Z");
3917 setupPropertyDefaultValue(m_beamBC1Z_0, 17348.8, "BC1Z_0");
3918 setupPropertyDefaultValue(m_beamBC1Z_90, 15594.05, "BC1Z_90");
3919 setupPropertyDefaultValue(m_beamBC1Z_min90, 15571.8, "BC1Z_min90");
3920
3921 setupPropertyDefaultValue(m_beamBC2X1, -24.377104, "BC2X1");
3922 setupPropertyDefaultValue(m_beamBC2X2, -0.176735, "BC2X2");
3923 setupPropertyDefaultValue(m_beamBC2Y1, 17.895954, "BC2Y1");
3924 setupPropertyDefaultValue(m_beamBC2Y2, -0.176182117624, "BC2Y2");
3925 setupPropertyDefaultValue(m_beamBC2Z, 4404.2, "BC2Z");
3926 setupPropertyDefaultValue(m_beamBC2Z_0, 4420.7, "BC2Z_0");
3927 setupPropertyDefaultValue(m_beamBC2Z_90, 2649.45, "BC2Z_90");
3928 setupPropertyDefaultValue(m_beamBC2Z_min90, 2627.2, "BC2Z_min90");
3929
3930}
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
CaloCell_ID.h
vec
std::vector< size_t > vec
Definition CombinationsGeneratorTest.cxx:9
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition Control/AthenaKernel/AthenaKernel/errorcheck.h:422
length
double length(const pvec &v)
Definition FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
size
size_t size() const
Number of registered mappings.
TileHitVector
AtlasHitsVector< TileHit > TileHitVector
Definition TileHitVector.h:28
WRONG_CHANNEL
#define WRONG_CHANNEL(frag, chan)
Definition TileTBAANtuple.cxx:53
SIGNAL_FOUND
#define SIGNAL_FOUND(frag, chan, amplitude)
Definition TileTBAANtuple.cxx:66
MAX_DRAWERS
#define MAX_DRAWERS
Definition TileTBAANtuple.cxx:73
FRAG_FOUND
#define FRAG_FOUND(frag, chan, size)
Definition TileTBAANtuple.cxx:58
WRONG_SAMPLE
#define WRONG_SAMPLE(frag, chan, size)
Definition TileTBAANtuple.cxx:47
COIN_TRIG4_FRAG
#define COIN_TRIG4_FRAG
Definition TileTBFrag.h:35
COIN_TRIG2_FRAG
#define COIN_TRIG2_FRAG
Definition TileTBFrag.h:33
MUON_ADC_FRAG
#define MUON_ADC_FRAG
Definition TileTBFrag.h:25
COIN_TRIG7_FRAG
#define COIN_TRIG7_FRAG
Definition TileTBFrag.h:38
COIN_TRIG5_FRAG
#define COIN_TRIG5_FRAG
Definition TileTBFrag.h:36
COIN_TRIG8_FRAG
#define COIN_TRIG8_FRAG
Definition TileTBFrag.h:39
COIN_TRIG6_FRAG
#define COIN_TRIG6_FRAG
Definition TileTBFrag.h:37
LASE_ADC_FRAG
#define LASE_ADC_FRAG
Definition TileTBFrag.h:28
LASE_PTN_FRAG
#define LASE_PTN_FRAG
Definition TileTBFrag.h:27
COMMON_TDC2_FRAG
#define COMMON_TDC2_FRAG
Definition TileTBFrag.h:47
COMMON_PTN_FRAG
#define COMMON_PTN_FRAG
Definition TileTBFrag.h:48
COMMON_ADC1_FRAG
#define COMMON_ADC1_FRAG
Definition TileTBFrag.h:43
COMMON_ADC2_FRAG
#define COMMON_ADC2_FRAG
Definition TileTBFrag.h:44
COMMON_TDC1_FRAG
#define COMMON_TDC1_FRAG
Definition TileTBFrag.h:46
BEAM_TDC_FRAG
#define BEAM_TDC_FRAG
Definition TileTBFrag.h:23
COIN_TRIG3_FRAG
#define COIN_TRIG3_FRAG
Definition TileTBFrag.h:34
DIGI_PAR_FRAG
#define DIGI_PAR_FRAG
Definition TileTBFrag.h:41
COMMON_TOF_FRAG
#define COMMON_TOF_FRAG
Definition TileTBFrag.h:45
COIN_TRIG1_FRAG
#define COIN_TRIG1_FRAG
Definition TileTBFrag.h:32
ADDR_ADC_FRAG
#define ADDR_ADC_FRAG
Definition TileTBFrag.h:26
BEAM_ADC_FRAG
#define BEAM_ADC_FRAG
Definition TileTBFrag.h:24
ADD_FADC_FRAG
#define ADD_FADC_FRAG
Definition TileTBFrag.h:29
ECAL_ADC_FRAG
#define ECAL_ADC_FRAG
Definition TileTBFrag.h:30
empty
static const Attributes_t empty
Definition XmlStreamer.cxx:16
AthAlgorithm::AthAlgorithm
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor with parameters:
Definition AthAlgorithm.cxx:21
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition AthCommonMsg.h:30
AtlasHitsVector::empty
bool empty() const
Definition AtlasHitsVector.h:128
CaloCellContainer
Container class for CaloCell.
Definition CaloCellContainer.h:55
CaloCell_ID::CaloSample
CaloSampling::CaloSample CaloSample
Definition CaloCell_ID.h:53
CaloCell
Data object for each calorimeter readout cell.
Definition CaloCell.h:57
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell.
Definition Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
DataVector::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Standard const_iterator.
Definition DataVector.h:838
DataVector::get
const T * get(size_type n) const
Access an element, as an rvalue.
IdentifiableContainerMT::const_iterator
Definition IdentifiableContainerMT.h:82
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition IdentifiableContainerMT.h:248
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition IdentifiableContainerMT.h:242
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path)
Definition PathResolver.cxx:220
SG::ReadHandleKey
Property holding a SG store/key/clid from which a ReadHandle is made.
Definition StoreGate/StoreGate/ReadHandleKey.h:40
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition TileCablingService.cxx:24
TileCalibUtils::getDrawerIdxFromFragId
static unsigned int getDrawerIdxFromFragId(unsigned int fragId)
Returns a drawer hash from fragId This function assumes drawer context (i.e.
Definition TileCalibUtils.cxx:71
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition TileDQstatus.h:49
TileDQstatus::checkHeaderParityErr
int checkHeaderParityErr(int partition, int drawer, int dmu, int gain) const
returns 1 if DMU has header word parity error
Definition TileDQstatus.h:117
TileDQstatus::checkSampleParityErr
int checkSampleParityErr(int partition, int drawer, int dmu, int gain) const
returns 1 if DMU has data word parity error
Definition TileDQstatus.h:125
TileHit::pmt_HWID
HWIdentifier pmt_HWID(void) const
Return pmt hardware ID (== channel ID).
Definition TileHit.cxx:125
TileHit::time
float time(int ind=0) const
Return time of ind-th sub-hit.
Definition TileSimEvent/TileSimEvent/TileHit.h:97
TileHit::energy
float energy(int ind=0) const
Return energy of ind-th sub-hit.
Definition TileSimEvent/TileSimEvent/TileHit.h:95
TileHit::size
int size(void) const
Return length of energy/time vectors.
Definition TileSimEvent/TileSimEvent/TileHit.h:99
TileLaserObject::getFiltNumber
int getFiltNumber() const
Definition TileLaserObject.h:229
TileLaserObject::getSigmaPedAlpha
double getSigmaPedAlpha(const unsigned int i, const unsigned int gain=0) const
Definition TileLaserObject.cxx:180
TileLaserObject::getSigmaAlpha
double getSigmaAlpha(const unsigned int i, const unsigned int gain=0) const
Definition TileLaserObject.cxx:152
TileLaserObject::getPedestalAlpha
double getPedestalAlpha(const unsigned int i, const unsigned int gain=0) const
Definition TileLaserObject.cxx:166
TileLaserObject::getPumpDiodeTemp
double getPumpDiodeTemp() const
Definition TileLaserObject.h:234
TileLaserObject::getPMADC
int getPMADC(const unsigned int j, const unsigned int gain=0) const
Definition TileLaserObject.cxx:195
TileLaserObject::getPMSigmaPedestal
double getPMSigmaPedestal(const unsigned int j, const unsigned int gain=0) const
Definition TileLaserObject.cxx:237
TileLaserObject::getAlpha
double getAlpha(const unsigned int i, const unsigned int gain=0) const
Definition TileLaserObject.cxx:138
TileLaserObject::getDiodeCurrOrd
double getDiodeCurrOrd() const
Definition TileLaserObject.h:219
TileLaserObject::getDiodeADC
int getDiodeADC(const unsigned int i, const unsigned int gain=0) const
Definition TileLaserObject.cxx:95
TileLaserObject::getDiodeSigmaPedestal
double getDiodeSigmaPedestal(const unsigned int i, const unsigned int gain=0) const
Definition TileLaserObject.cxx:123
TileLaserObject::getBCID
int getBCID() const
Definition TileLaserObject.h:335
TileLaserObject::getDiodePedestal
double getDiodePedestal(const unsigned int i, const unsigned int gain=0) const
Definition TileLaserObject.cxx:109
TileLaserObject::getTDC
int getTDC(const unsigned int j, const unsigned int gain=0) const
Definition TileLaserObject.cxx:209
TileLaserObject::getDiodeCurrMeas
double getDiodeCurrMeas() const
Definition TileLaserObject.h:224
TileLaserObject::getPMPedestal
double getPMPedestal(const unsigned int j, const unsigned int gain=0) const
Definition TileLaserObject.cxx:223
TileRawDataContainer::get_bsflags
uint32_t get_bsflags() const
Definition TileRawDataContainer.h:64
TileSamplingFraction
Condition object to keep and provide Tile Calorimeter sampling fraction and number of photoelectrons.
Definition TileSamplingFraction.h:16
TileSamplingFraction::getSamplingFraction
float getSamplingFraction(unsigned int drawerIdx, unsigned int channel) const
Return Tile Calorimeter sampling fraction.
Definition TileSamplingFraction.h:53
TileTBAANtuple::m_pedflxfitVec
std::vector< std::array< float, MAX_CHAN > > m_pedflxfitVec
Definition TileTBAANtuple.h:554
TileTBAANtuple::m_gainVec
std::vector< std::array< int, MAX_CHAN > > m_gainVec
Definition TileTBAANtuple.h:526
TileTBAANtuple::m_tfitcVec
std::vector< std::array< float, MAX_CHAN > > m_tfitcVec
Definition TileTBAANtuple.h:540
TileTBAANtuple::m_hitVectorKey
SG::ReadHandleKey< TileHitVector > m_hitVectorKey
Definition TileTBAANtuple.h:150
TileTBAANtuple::ENETOTAL_clearBranch
void ENETOTAL_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ENETOTAL vari...
Definition TileTBAANtuple.cxx:3053
TileTBAANtuple::ntuple_initialize
StatusCode ntuple_initialize(const EventContext &ctx)
Alg standard interface function LF TODO: We could have a problem with the new feature introduced by S...
Definition TileTBAANtuple.cxx:135
TileTBAANtuple::m_chi2DspVec
std::vector< std::array< float, MAX_CHAN > > m_chi2DspVec
Definition TileTBAANtuple.h:549
TileTBAANtuple::m_beamBN1Y1
Gaudi::Property< float > m_beamBN1Y1
Definition TileTBAANtuple.h:195
TileTBAANtuple::m_beamBC1Y2
Gaudi::Property< float > m_beamBC1Y2
Definition TileTBAANtuple.h:207
TileTBAANtuple::storeRawChannels
StatusCode storeRawChannels(const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, bool calibMode, std::vector< std::array< float, MAX_CHAN > > *eneVec, std::vector< std::array< float, MAX_CHAN > > *timeVec, std::vector< std::array< float, MAX_CHAN > > *chi2Vec, std::vector< std::array< float, MAX_CHAN > > *pedVec, bool saveDQstatus=false)
/ Fill ntuple with data from TRC.
Definition TileTBAANtuple.cxx:1182
TileTBAANtuple::m_beamBC2Z_90
Gaudi::Property< float > m_beamBC2Z_90
Definition TileTBAANtuple.h:219
TileTBAANtuple::initList
StatusCode initList(const EventContext &ctx)
Definition TileTBAANtuple.cxx:2188
TileTBAANtuple::m_beamBC0Z
Gaudi::Property< float > m_beamBC0Z
Definition TileTBAANtuple.h:202
TileTBAANtuple::m_LarEne
std::array< float, 4 > m_LarEne
Definition TileTBAANtuple.h:580
TileTBAANtuple::m_coincTrig2
std::array< unsigned int, 96 > m_coincTrig2
Definition TileTBAANtuple.h:586
TileTBAANtuple::m_beamBN2Y1
Gaudi::Property< float > m_beamBN2Y1
Definition TileTBAANtuple.h:190
TileTBAANtuple::storeBeamElements
StatusCode storeBeamElements(const EventContext &ctx)
Definition TileTBAANtuple.cxx:525
TileTBAANtuple::m_nSamplesFlx
Gaudi::Property< int > m_nSamplesFlx
Definition TileTBAANtuple.h:174
TileTBAANtuple::DIGI_addBranch
void DIGI_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree DIGI variables...
Definition TileTBAANtuple.cxx:3126
TileTBAANtuple::m_tileHWID
const TileHWID * m_tileHWID
Definition TileTBAANtuple.h:627
TileTBAANtuple::m_btdc
std::vector< std::vector< int > > * m_btdc
Definition TileTBAANtuple.h:473
TileTBAANtuple::m_coincTrig6
std::array< unsigned int, 96 > m_coincTrig6
Definition TileTBAANtuple.h:590
TileTBAANtuple::m_btdc1
std::array< int, 16 > m_btdc1
Definition TileTBAANtuple.h:470
TileTBAANtuple::m_sizeVec
std::vector< short > m_sizeVec
Definition TileTBAANtuple.h:506
TileTBAANtuple::FELIX_addBranch
void FELIX_addBranch(void)
Definition TileTBAANtuple.cxx:3463
TileTBAANtuple::m_ecal
std::array< float, 8 > m_ecal
Definition TileTBAANtuple.h:372
TileTBAANtuple::CheckDMUParity
short CheckDMUParity(uint32_t header)
Parity of the DMU header should be odd.
Definition TileTBAANtuple.h:311
TileTBAANtuple::ADDER_addBranch
void ADDER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree ADDER variable...
Definition TileTBAANtuple.cxx:2762
TileTBAANtuple::m_ExtEne
std::array< float, 3 > m_ExtEne
Definition TileTBAANtuple.h:582
TileTBAANtuple::m_l1Type
std::vector< int > m_l1Type
Definition TileTBAANtuple.h:360
TileTBAANtuple::m_beamFragList
Gaudi::Property< std::vector< std::string > > m_beamFragList
Definition TileTBAANtuple.h:186
TileTBAANtuple::m_dqStatusKey
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
Definition TileTBAANtuple.h:162
TileTBAANtuple::m_nSamplesFlxInDrawer
std::vector< int > m_nSamplesFlxInDrawer
Definition TileTBAANtuple.h:633
TileTBAANtuple::MUON_clearBranch
void MUON_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree MUON variable...
Definition TileTBAANtuple.cxx:2594
TileTBAANtuple::initListFlx
StatusCode initListFlx(const EventContext &ctx)
Definition TileTBAANtuple.cxx:2305
TileTBAANtuple::m_treeSize
Gaudi::Property< Long64_t > m_treeSize
Definition TileTBAANtuple.h:179
TileTBAANtuple::m_DMUheaderVec
std::vector< std::array< uint32_t, MAX_DMU > > m_DMUheaderVec
Definition TileTBAANtuple.h:516
TileTBAANtuple::m_mdBcidflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdBcidflxVec
Definition TileTBAANtuple.h:570
TileTBAANtuple::m_beamBC1X2
Gaudi::Property< float > m_beamBC1X2
Definition TileTBAANtuple.h:205
TileTBAANtuple::m_tDspVec
std::vector< std::array< float, MAX_CHAN > > m_tDspVec
Definition TileTBAANtuple.h:548
TileTBAANtuple::m_frBCID
std::vector< int > m_frBCID
Definition TileTBAANtuple.h:363
TileTBAANtuple::ADDER_clearBranch
void ADDER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ADDER variabl...
Definition TileTBAANtuple.cxx:2785
TileTBAANtuple::m_ntupleID
Gaudi::Property< std::string > m_ntupleID
Definition TileTBAANtuple.h:181
TileTBAANtuple::m_adder
std::vector< int * > m_adder
Definition TileTBAANtuple.h:444
TileTBAANtuple::m_fitRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitRawChannelContainerKey
Definition TileTBAANtuple.h:126
TileTBAANtuple::m_ROD_DMUDstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUDstrobeErrVec
Definition TileTBAANtuple.h:564
TileTBAANtuple::m_cabling
const TileCablingService * m_cabling
Definition TileTBAANtuple.h:628
TileTBAANtuple::storeLaser
StatusCode storeLaser(const EventContext &ctx)
Definition TileTBAANtuple.cxx:455
TileTBAANtuple::m_beamBC1Z
Gaudi::Property< float > m_beamBC1Z
Definition TileTBAANtuple.h:208
TileTBAANtuple::m_flxOptRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flxOptRawChannelContainerKey
Definition TileTBAANtuple.h:141
TileTBAANtuple::m_mdChargeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdChargeflxVec
Definition TileTBAANtuple.h:576
TileTBAANtuple::m_GapEne
std::array< float, 3 > m_GapEne
Definition TileTBAANtuple.h:583
TileTBAANtuple::ENETOTAL_addBranch
void ENETOTAL_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree ENETOTAL varia...
Definition TileTBAANtuple.cxx:3037
TileTBAANtuple::m_mdChargeTimeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdChargeTimeflxVec
Definition TileTBAANtuple.h:577
TileTBAANtuple::m_beamBC1Z_min90
Gaudi::Property< float > m_beamBC1Z_min90
Definition TileTBAANtuple.h:211
TileTBAANtuple::m_tflxoptVec
std::vector< std::array< float, MAX_CHAN > > m_tflxoptVec
Definition TileTBAANtuple.h:556
TileTBAANtuple::m_las_D2_AlphaPed_RMS
double m_las_D2_AlphaPed_RMS
Definition TileTBAANtuple.h:415
TileTBAANtuple::m_drawerList
Gaudi::Property< std::vector< std::string > > m_drawerList
Definition TileTBAANtuple.h:184
TileTBAANtuple::m_beamBC2X2
Gaudi::Property< float > m_beamBC2X2
Definition TileTBAANtuple.h:214
TileTBAANtuple::m_fitcRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitcRawChannelContainerKey
Definition TileTBAANtuple.h:135
TileTBAANtuple::m_etaFileName
Gaudi::Property< std::string > m_etaFileName
Definition TileTBAANtuple.h:223
TileTBAANtuple::m_rchUnit
TileRawChannelUnit::UNIT m_rchUnit
Unit for TileRawChannels (ADC, pCb, MeV).
Definition TileTBAANtuple.h:622
TileTBAANtuple::QDC_addBranch
void QDC_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add QDC variables to th...
Definition TileTBAANtuple.cxx:2555
TileTBAANtuple::m_mdCapacitorflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdCapacitorflxVec
Definition TileTBAANtuple.h:578
TileTBAANtuple::m_nDrawersFlx
Gaudi::Property< unsigned int > m_nDrawersFlx
Definition TileTBAANtuple.h:176
TileTBAANtuple::m_chi2OptVec
std::vector< std::array< float, MAX_CHAN > > m_chi2OptVec
Definition TileTBAANtuple.h:546
TileTBAANtuple::setupBeamChambersTB2016_2020
void setupBeamChambersTB2016_2020(void)
Definition TileTBAANtuple.cxx:3813
TileTBAANtuple::m_las_PMT1_Ped_RMS
double m_las_PMT1_Ped_RMS
Definition TileTBAANtuple.h:428
TileTBAANtuple::m_finalUnit
Gaudi::Property< int > m_finalUnit
Definition TileTBAANtuple.h:167
TileTBAANtuple::m_thitCnt
std::vector< std::array< float, MAX_CHAN > > m_thitCnt
Definition TileTBAANtuple.h:618
TileTBAANtuple::m_chi2cVec
std::vector< std::array< float, MAX_CHAN > > m_chi2cVec
Definition TileTBAANtuple.h:542
TileTBAANtuple::m_flxFitRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flxFitRawChannelContainerKey
Definition TileTBAANtuple.h:138
TileTBAANtuple::m_beamBN2Y2
Gaudi::Property< float > m_beamBN2Y2
Definition TileTBAANtuple.h:191
TileTBAANtuple::m_chi2flxfitVec
std::vector< std::array< float, MAX_CHAN > > m_chi2flxfitVec
Definition TileTBAANtuple.h:553
TileTBAANtuple::m_mdPedLoflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdPedLoflxVec
Definition TileTBAANtuple.h:573
TileTBAANtuple::m_calibrateEnergyThisEvent
bool m_calibrateEnergyThisEvent
Definition TileTBAANtuple.h:620
TileTBAANtuple::storeHitContainer
StatusCode storeHitContainer(const EventContext &ctx)
/ Fill Ntuple with MC truth info from simulation / Namely, hit energies corrected by photoelectron st...
Definition TileTBAANtuple.cxx:1853
TileTBAANtuple::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition TileTBAANtuple.h:342
TileTBAANtuple::m_beamBC2Z_0
Gaudi::Property< float > m_beamBC2Z_0
Definition TileTBAANtuple.h:218
TileTBAANtuple::m_completeNtuple
Gaudi::Property< bool > m_completeNtuple
Definition TileTBAANtuple.h:170
TileTBAANtuple::m_calibrateEnergy
Gaudi::Property< bool > m_calibrateEnergy
Definition TileTBAANtuple.h:165
TileTBAANtuple::m_beamBC2X1
Gaudi::Property< float > m_beamBC2X1
Definition TileTBAANtuple.h:213
TileTBAANtuple::m_ehitVec
std::vector< std::array< float, MAX_CHAN > > m_ehitVec
Definition TileTBAANtuple.h:615
TileTBAANtuple::m_coincTrig7
std::array< unsigned int, 96 > m_coincTrig7
Definition TileTBAANtuple.h:591
TileTBAANtuple::m_mdRunTypeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdRunTypeflxVec
Definition TileTBAANtuple.h:572
TileTBAANtuple::m_sizeflxVec
std::vector< short > m_sizeflxVec
Definition TileTBAANtuple.h:510
TileTBAANtuple::MUON_addBranch
void MUON_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add MUON variables to t...
Definition TileTBAANtuple.cxx:2512
TileTBAANtuple::setupBeamChambersBeforeTB2015
void setupBeamChambersBeforeTB2015(void)
Definition TileTBAANtuple.cxx:3772
TileTBAANtuple::CheckDMUFormat
short CheckDMUFormat(uint32_t header)
bit_31 of the DMU header must be 1 and bit_17 of the DMU header must be 0
Definition TileTBAANtuple.h:302
TileTBAANtuple::m_beamBC2Z
Gaudi::Property< float > m_beamBC2Z
Definition TileTBAANtuple.h:217
TileTBAANtuple::m_pedflxoptVec
std::vector< std::array< float, MAX_CHAN > > m_pedflxoptVec
Definition TileTBAANtuple.h:558
TileTBAANtuple::storeCells
StatusCode storeCells(const EventContext &ctx)
Definition TileTBAANtuple.cxx:2129
TileTBAANtuple::m_eflxoptVec
std::vector< std::array< float, MAX_CHAN > > m_eflxoptVec
Definition TileTBAANtuple.h:555
TileTBAANtuple::m_beamBC1Y1
Gaudi::Property< float > m_beamBC1Y1
Definition TileTBAANtuple.h:206
TileTBAANtuple::setupPropertyDefaultValue
void setupPropertyDefaultValue(float property, float defaultValue, const std::string &name)
Definition TileTBAANtuple.h:328
TileTBAANtuple::m_radius
Gaudi::Property< float > m_radius
Definition TileTBAANtuple.h:222
TileTBAANtuple::m_dspRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_dspRawChannelContainerKey
Definition TileTBAANtuple.h:132
TileTBAANtuple::setupBeamChambersTB2015
void setupBeamChambersTB2015(void)
Definition TileTBAANtuple.cxx:3793
TileTBAANtuple::m_btdc2
std::array< int, 16 > m_btdc2
Definition TileTBAANtuple.h:471
TileTBAANtuple::m_drawerType
Gaudi::Property< std::vector< int > > m_drawerType
Definition TileTBAANtuple.h:185
TileTBAANtuple::m_laserObjectKey
SG::ReadHandleKey< TileLaserObject > m_laserObjectKey
Definition TileTBAANtuple.h:144
TileTBAANtuple::m_nSamplesInDrawer
std::vector< int > m_nSamplesInDrawer
Definition TileTBAANtuple.h:632
TileTBAANtuple::m_mdRunflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdRunflxVec
Definition TileTBAANtuple.h:575
TileTBAANtuple::m_samplingFractionKey
SG::ReadCondHandleKey< TileSamplingFraction > m_samplingFractionKey
Name of TileSamplingFraction in condition store.
Definition TileTBAANtuple.h:111
TileTBAANtuple::m_pedfitVec
std::vector< std::array< float, MAX_CHAN > > m_pedfitVec
Definition TileTBAANtuple.h:537
TileTBAANtuple::TileTBAANtuple
TileTBAANtuple(const std::string &name, ISvcLocator *pSvcLocator)
Definition TileTBAANtuple.cxx:82
TileTBAANtuple::LASER_addBranch
void LASER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree LASER variable...
Definition TileTBAANtuple.cxx:2629
TileTBAANtuple::m_eOptVec
std::vector< std::array< float, MAX_CHAN > > m_eOptVec
Definition TileTBAANtuple.h:543
TileTBAANtuple::m_bcidVec
std::vector< std::array< int, MAX_DMU > > m_bcidVec
Definition TileTBAANtuple.h:515
TileTBAANtuple::m_digitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
Definition TileTBAANtuple.h:114
TileTBAANtuple::m_mdPedHiflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdPedHiflxVec
Definition TileTBAANtuple.h:574
TileTBAANtuple::m_ROD_DMUMaskVec
std::vector< std::array< short, 2 > > m_ROD_DMUMaskVec
Definition TileTBAANtuple.h:567
TileTBAANtuple::m_feCRCVec
std::vector< std::array< int, MAX_DMU > > m_feCRCVec
Definition TileTBAANtuple.h:528
TileTBAANtuple::m_sampleVec
std::vector< std::unique_ptr< int[]> > m_sampleVec
Definition TileTBAANtuple.h:527
TileTBAANtuple::initNTuple
StatusCode initNTuple(void)
Definition TileTBAANtuple.cxx:2019
TileTBAANtuple::m_drawerMap
std::map< unsigned int, unsigned int, std::less< unsigned int > > m_drawerMap
Definition TileTBAANtuple.h:603
TileTBAANtuple::m_las_D3_AlphaPed_RMS
double m_las_D3_AlphaPed_RMS
Definition TileTBAANtuple.h:416
TileTBAANtuple::m_muBack
std::array< float, 14 > m_muBack
Definition TileTBAANtuple.h:368
TileTBAANtuple::m_l1ID
std::vector< int > m_l1ID
Definition TileTBAANtuple.h:359
TileTBAANtuple::m_tfitVec
std::vector< std::array< float, MAX_CHAN > > m_tfitVec
Definition TileTBAANtuple.h:536
TileTBAANtuple::m_hitContainerKey
SG::ReadHandleKey< TileHitContainer > m_hitContainerKey
Definition TileTBAANtuple.h:147
TileTBAANtuple::m_mdModuleflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdModuleflxVec
Definition TileTBAANtuple.h:571
TileTBAANtuple::m_beamBC0X1
Gaudi::Property< float > m_beamBC0X1
Definition TileTBAANtuple.h:198
TileTBAANtuple::m_adderPayload
std::vector< int > m_adderPayload
Definition TileTBAANtuple.h:445
TileTBAANtuple::m_chi2flxoptVec
std::vector< std::array< float, MAX_CHAN > > m_chi2flxoptVec
Definition TileTBAANtuple.h:557
TileTBAANtuple::m_pedFlatVec
std::vector< std::array< float, MAX_CHAN > > m_pedFlatVec
Definition TileTBAANtuple.h:533
TileTBAANtuple::m_ROD_DMUSstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUSstrobeErrVec
Definition TileTBAANtuple.h:563
TileTBAANtuple::digiChannel2PMT
int digiChannel2PMT(int fragType, int chan)
Definition TileTBAANtuple.h:296
TileTBAANtuple::HIT_clearBranch
void HIT_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree HIT variable...
Definition TileTBAANtuple.cxx:3738
TileTBAANtuple::TRIGGER_clearBranch
void TRIGGER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER varia...
Definition TileTBAANtuple.cxx:2572
TileTBAANtuple::LASER_clearBranch
void LASER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree LASER variabl...
Definition TileTBAANtuple.cxx:2710
TileTBAANtuple::m_beamBN1X1
Gaudi::Property< float > m_beamBN1X1
Definition TileTBAANtuple.h:193
TileTBAANtuple::m_DMUformatErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUformatErrVec
Definition TileTBAANtuple.h:517
TileTBAANtuple::CISPAR_addBranch
void CISPAR_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variabl...
Definition TileTBAANtuple.cxx:2797
TileTBAANtuple::CISPAR_clearBranch
void CISPAR_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variab...
Definition TileTBAANtuple.cxx:2811
TileTBAANtuple::m_timeAdd
std::array< float, 16 > m_timeAdd
Definition TileTBAANtuple.h:447
TileTBAANtuple::m_DMUDataparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUDataparityErrVec
Definition TileTBAANtuple.h:523
TileTBAANtuple::m_coincTrig1
std::array< unsigned int, 96 > m_coincTrig1
Definition TileTBAANtuple.h:585
TileTBAANtuple::m_nSamplesFlxInDrawerMap
std::map< int, int > m_nSamplesFlxInDrawerMap
Definition TileTBAANtuple.h:631
TileTBAANtuple::m_DMUHeadparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUHeadparityErrVec
Definition TileTBAANtuple.h:522
TileTBAANtuple::clear_init_minus1
void clear_init_minus1(std::vector< T > &vec)
Definition TileTBAANtuple.cxx:3747
TileTBAANtuple::m_dspUnit
TileRawChannelUnit::UNIT m_dspUnit
Unit for TileRawChannels in DSP.
Definition TileTBAANtuple.h:623
TileTBAANtuple::m_efitcVec
std::vector< std::array< float, MAX_CHAN > > m_efitcVec
Definition TileTBAANtuple.h:539
TileTBAANtuple::m_qdc
std::array< uint32_t, 33 > m_qdc
Definition TileTBAANtuple.h:375
TileTBAANtuple::m_beamBN1X2
Gaudi::Property< float > m_beamBN1X2
Definition TileTBAANtuple.h:194
TileTBAANtuple::storeDigitsFlx
StatusCode storeDigitsFlx(const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey)
Definition TileTBAANtuple.cxx:1635
TileTBAANtuple::m_chi2FlatVec
std::vector< std::array< float, MAX_CHAN > > m_chi2FlatVec
Definition TileTBAANtuple.h:534
TileTBAANtuple::m_nSamples
Gaudi::Property< int > m_nSamples
Definition TileTBAANtuple.h:173
TileTBAANtuple::m_DMUmemoryErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUmemoryErrVec
Definition TileTBAANtuple.h:519
TileTBAANtuple::m_thitVec
std::vector< std::array< float, MAX_CHAN > > m_thitVec
Definition TileTBAANtuple.h:616
TileTBAANtuple::HIT_addBranch
void HIT_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree HIT variables ...
Definition TileTBAANtuple.cxx:3652
TileTBAANtuple::m_las_D4_AlphaPed_RMS
double m_las_D4_AlphaPed_RMS
Definition TileTBAANtuple.h:417
TileTBAANtuple::m_beamBC1X1
Gaudi::Property< float > m_beamBC1X1
Definition TileTBAANtuple.h:204
TileTBAANtuple::m_evType
std::vector< int > m_evType
Definition TileTBAANtuple.h:362
TileTBAANtuple::m_beamBC1Z_90
Gaudi::Property< float > m_beamBC1Z_90
Definition TileTBAANtuple.h:210
TileTBAANtuple::m_eventsPerFile
Gaudi::Property< int > m_eventsPerFile
Definition TileTBAANtuple.h:178
TileTBAANtuple::m_pedfitcVec
std::vector< std::array< float, MAX_CHAN > > m_pedfitcVec
Definition TileTBAANtuple.h:541
TileTBAANtuple::m_eflxfitVec
std::vector< std::array< float, MAX_CHAN > > m_eflxfitVec
Definition TileTBAANtuple.h:551
TileTBAANtuple::m_ROD_DMUmemoryErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUmemoryErrVec
Definition TileTBAANtuple.h:562
TileTBAANtuple::m_ROD_GlobalCRCVec
std::vector< short > m_ROD_GlobalCRCVec
Definition TileTBAANtuple.h:560
TileTBAANtuple::m_ROD_DMUHeadformatErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUHeadformatErrVec
Definition TileTBAANtuple.h:565
TileTBAANtuple::m_slinkCRCVec
std::vector< std::array< int, 2 > > m_slinkCRCVec
Definition TileTBAANtuple.h:525
TileTBAANtuple::m_tof
std::array< int, 16 > m_tof
Definition TileTBAANtuple.h:469
TileTBAANtuple::m_las_D1_AlphaPed_RMS
double m_las_D1_AlphaPed_RMS
Definition TileTBAANtuple.h:414
TileTBAANtuple::m_beamBN2X2
Gaudi::Property< float > m_beamBN2X2
Definition TileTBAANtuple.h:189
TileTBAANtuple::m_eDspVec
std::vector< std::array< float, MAX_CHAN > > m_eDspVec
Definition TileTBAANtuple.h:547
TileTBAANtuple::m_BarEne
std::array< float, 3 > m_BarEne
Definition TileTBAANtuple.h:581
TileTBAANtuple::m_nDrawers
Gaudi::Property< unsigned int > m_nDrawers
Definition TileTBAANtuple.h:175
TileTBAANtuple::m_streamName
Gaudi::Property< std::string > m_streamName
Definition TileTBAANtuple.h:180
TileTBAANtuple::m_flatRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flatRawChannelContainerKey
Definition TileTBAANtuple.h:123
TileTBAANtuple::m_adderFilterAlgTool
ToolHandle< TileRawChannelBuilderFlatFilter > m_adderFilterAlgTool
Definition TileTBAANtuple.h:159
TileTBAANtuple::m_las_PMT2_Ped_RMS
double m_las_PMT2_Ped_RMS
Definition TileTBAANtuple.h:429
TileTBAANtuple::m_efitVec
std::vector< std::array< float, MAX_CHAN > > m_efitVec
Definition TileTBAANtuple.h:535
TileTBAANtuple::m_ehitCnt
std::vector< std::array< float, MAX_CHAN > > m_ehitCnt
Definition TileTBAANtuple.h:617
TileTBAANtuple::m_las_D4_Alpha_RMS
double m_las_D4_Alpha_RMS
Definition TileTBAANtuple.h:407
TileTBAANtuple::m_beamBC1Z_0
Gaudi::Property< float > m_beamBC1Z_0
Definition TileTBAANtuple.h:209
TileTBAANtuple::m_eneVec
std::vector< std::array< float, MAX_CHAN > > m_eneVec
Definition TileTBAANtuple.h:531
TileTBAANtuple::FELIX_clearBranch
void FELIX_clearBranch(void)
Definition TileTBAANtuple.cxx:3615
TileTBAANtuple::m_muCalib
std::array< float, 2 > m_muCalib
Definition TileTBAANtuple.h:369
TileTBAANtuple::m_rodCRCVec
std::vector< std::array< int, MAX_DMU > > m_rodCRCVec
Definition TileTBAANtuple.h:529
TileTBAANtuple::m_cellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_cellContainerKey
Definition TileTBAANtuple.h:153
TileTBAANtuple::TRIGGER_addBranch
void TRIGGER_addBranch(void)
///////////////////////////////////////////////////////////////////////////
Definition TileTBAANtuple.cxx:2473
TileTBAANtuple::m_ROD_DMUDataformatErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUDataformatErrVec
Definition TileTBAANtuple.h:566
TileTBAANtuple::m_TBperiod
Gaudi::Property< int > m_TBperiod
Definition TileTBAANtuple.h:177
TileTBAANtuple::m_las_D2_Alpha_RMS
double m_las_D2_Alpha_RMS
Definition TileTBAANtuple.h:405
TileTBAANtuple::m_coincTrig8
std::array< unsigned int, 96 > m_coincTrig8
Definition TileTBAANtuple.h:592
TileTBAANtuple::initialize
virtual StatusCode initialize() override
Definition TileTBAANtuple.cxx:102
TileTBAANtuple::m_coincTrig4
std::array< unsigned int, 96 > m_coincTrig4
Definition TileTBAANtuple.h:588
TileTBAANtuple::m_eneAdd
std::array< float, 16 > m_eneAdd
Definition TileTBAANtuple.h:446
TileTBAANtuple::storeDigits
StatusCode storeDigits(const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey, const TileDQstatus *dqStatus=nullptr)
/ Fill Ntuple with info from TileDigits / Return true if the collection is empty, / which means that ...
Definition TileTBAANtuple.cxx:1344
TileTBAANtuple::m_scaler
std::array< int, 16 > m_scaler
Definition TileTBAANtuple.h:472
TileTBAANtuple::clear_init_zero
void clear_init_zero(std::vector< std::array< T, N > > &vec)
Definition TileTBAANtuple.cxx:3759
TileTBAANtuple::m_bsInput
Gaudi::Property< bool > m_bsInput
Definition TileTBAANtuple.h:171
TileTBAANtuple::execute
virtual StatusCode execute(const EventContext &ctx) override
Execute method.
Definition TileTBAANtuple.cxx:362
TileTBAANtuple::ECAL_clearBranch
void ECAL_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ECAL variable...
Definition TileTBAANtuple.cxx:2606
TileTBAANtuple::m_lasExtra
std::array< float, 4 > m_lasExtra
Definition TileTBAANtuple.h:438
TileTBAANtuple::BEAM_clearBranch
void BEAM_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree BEAM variable...
Definition TileTBAANtuple.cxx:2945
TileTBAANtuple::m_coincTrig3
std::array< unsigned int, 96 > m_coincTrig3
Definition TileTBAANtuple.h:587
TileTBAANtuple::m_las_D1_Alpha_RMS
double m_las_D1_Alpha_RMS
Definition TileTBAANtuple.h:404
TileTBAANtuple::m_tflxfitVec
std::vector< std::array< float, MAX_CHAN > > m_tflxfitVec
Definition TileTBAANtuple.h:552
TileTBAANtuple::QDC_clearBranch
void QDC_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree QDC variables
Definition TileTBAANtuple.cxx:2617
TileTBAANtuple::m_mdL1idflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdL1idflxVec
Definition TileTBAANtuple.h:569
TileTBAANtuple::m_drawerFlxMap
std::map< unsigned int, unsigned int, std::less< unsigned int > > m_drawerFlxMap
Definition TileTBAANtuple.h:604
TileTBAANtuple::m_beamBC0Y1
Gaudi::Property< float > m_beamBC0Y1
Definition TileTBAANtuple.h:200
TileTBAANtuple::m_beamBN1Y2
Gaudi::Property< float > m_beamBN1Y2
Definition TileTBAANtuple.h:196
TileTBAANtuple::m_ROD_DMUBCIDVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUBCIDVec
Definition TileTBAANtuple.h:561
TileTBAANtuple::m_beamBC2Z_min90
Gaudi::Property< float > m_beamBC2Z_min90
Definition TileTBAANtuple.h:220
TileTBAANtuple::ECAL_addBranch
void ECAL_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add ECAL variables to t...
Definition TileTBAANtuple.cxx:2540
TileTBAANtuple::m_sampleflxVec
std::vector< std::unique_ptr< int[]> > m_sampleflxVec
Definition TileTBAANtuple.h:513
TileTBAANtuple::m_evtflxVec
std::vector< int > m_evtflxVec
Definition TileTBAANtuple.h:508
TileTBAANtuple::m_DMUparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUparityErrVec
Definition TileTBAANtuple.h:518
TileTBAANtuple::m_DMUDstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUDstrobeErrVec
Definition TileTBAANtuple.h:520
TileTBAANtuple::m_beamBC0Y2
Gaudi::Property< float > m_beamBC0Y2
Definition TileTBAANtuple.h:201
TileTBAANtuple::DIGI_clearBranch
void DIGI_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variabl...
Definition TileTBAANtuple.cxx:3408
TileTBAANtuple::m_gainflxVec
std::vector< std::array< int, MAX_CHAN > > m_gainflxVec
Definition TileTBAANtuple.h:512
TileTBAANtuple::m_DMUSstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUSstrobeErrVec
Definition TileTBAANtuple.h:521
TileTBAANtuple::storeHit
void storeHit(const TileHit *hit, int fragType, int fragId, std::array< float, MAX_CHAN > &ehitVec, std::array< float, MAX_CHAN > &thitVec, const TileSamplingFraction *samplingFraction)
Definition TileTBAANtuple.cxx:1900
TileTBAANtuple::m_beamBC0X2
Gaudi::Property< float > m_beamBC0X2
Definition TileTBAANtuple.h:199
TileTBAANtuple::m_beamIdList
bool m_beamIdList[32]
Definition TileTBAANtuple.h:607
TileTBAANtuple::m_coincTrig5
std::array< unsigned int, 96 > m_coincTrig5
Definition TileTBAANtuple.h:589
TileTBAANtuple::m_beamBN2X1
Gaudi::Property< float > m_beamBN2X1
Definition TileTBAANtuple.h:188
TileTBAANtuple::ntuple_clear
StatusCode ntuple_clear()
Definition TileTBAANtuple.cxx:1969
TileTBAANtuple::m_calibMode
Gaudi::Property< bool > m_calibMode
Definition TileTBAANtuple.h:168
TileTBAANtuple::m_digitsContainerFlxKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerFlxKey
Definition TileTBAANtuple.h:117
TileTBAANtuple::COINCBOARD_clearBranch
void COINCBOARD_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree COINCBOARD va...
Definition TileTBAANtuple.cxx:3113
TileTBAANtuple::m_rodBCIDflxVec
std::vector< short > m_rodBCIDflxVec
Definition TileTBAANtuple.h:509
TileTBAANtuple::BEAM_addBranch
void BEAM_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree BEAM variables...
Definition TileTBAANtuple.cxx:2823
TileTBAANtuple::m_beamBC2Y2
Gaudi::Property< float > m_beamBC2Y2
Definition TileTBAANtuple.h:216
TileTBAANtuple::m_las_D3_Alpha_RMS
double m_las_D3_Alpha_RMS
Definition TileTBAANtuple.h:406
TileTBAANtuple::m_nSamplesInDrawerMap
std::map< int, int > m_nSamplesInDrawerMap
Definition TileTBAANtuple.h:630
TileTBAANtuple::drawerMap_iterator
std::map< unsignedint, unsignedint, std::less< unsignedint > >::iterator drawerMap_iterator
Definition TileTBAANtuple.h:605
TileTBAANtuple::m_timeVec
std::vector< std::array< float, MAX_CHAN > > m_timeVec
Definition TileTBAANtuple.h:532
TileTBAANtuple::m_pmtOrder
Gaudi::Property< bool > m_pmtOrder
Definition TileTBAANtuple.h:172
TileTBAANtuple::m_optRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_optRawChannelContainerKey
Definition TileTBAANtuple.h:129
TileTBAANtuple::m_tileID
const TileID * m_tileID
Definition TileTBAANtuple.h:626
TileTBAANtuple::m_chi2Vec
std::vector< std::array< float, MAX_CHAN > > m_chi2Vec
Definition TileTBAANtuple.h:538
TileTBAANtuple::m_beamElemContainerKey
SG::ReadHandleKey< TileBeamElemContainer > m_beamElemContainerKey
Definition TileTBAANtuple.h:120
TileTBAANtuple::m_beamBC2Y1
Gaudi::Property< float > m_beamBC2Y1
Definition TileTBAANtuple.h:215
TileTBAANtuple::m_rosName
Gaudi::Property< std::vector< std::string > > m_rosName
Definition TileTBAANtuple.h:183
TileTBAANtuple::m_rodBCIDVec
std::vector< short > m_rodBCIDVec
Definition TileTBAANtuple.h:505
TileTBAANtuple::m_tOptVec
std::vector< std::array< float, MAX_CHAN > > m_tOptVec
Definition TileTBAANtuple.h:544
TileTBAANtuple::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition TileTBAANtuple.h:156
TileTBAANtuple::m_evBCID
std::vector< int > m_evBCID
Definition TileTBAANtuple.h:361
TileTBAANtuple::m_dmuMaskVec
std::vector< std::array< int, 2 > > m_dmuMaskVec
Definition TileTBAANtuple.h:524
TileTBAANtuple::m_unpackAdder
Gaudi::Property< bool > m_unpackAdder
Definition TileTBAANtuple.h:169
TileTBAANtuple::COINCBOARD_addBranch
void COINCBOARD_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree COINCBOARD var...
Definition TileTBAANtuple.cxx:3065
TileTBAANtuple::m_pedOptVec
std::vector< std::array< float, MAX_CHAN > > m_pedOptVec
Definition TileTBAANtuple.h:545
TileTBAANtuple::clear_samples
void clear_samples(std::vector< std::unique_ptr< int[]> > &vec, const std::vector< int > &nsamples, int nchan=MAX_CHAN)
Definition TileTBAANtuple.cxx:3765
TileTBAANtuple::m_useDspUnits
Gaudi::Property< bool > m_useDspUnits
Definition TileTBAANtuple.h:166
TileTBAANtuple::m_evtVec
std::vector< int > m_evtVec
Definition TileTBAANtuple.h:504
TileTBAANtuple::checkIsPropertySetup
void checkIsPropertySetup(float property, const std::string &name)
Definition TileTBAANtuple.h:322
TileTBAANtuple::storeHitVector
StatusCode storeHitVector(const EventContext &ctx)
Definition TileTBAANtuple.cxx:1808
Tile_Base_ID::HIGHGAIN
@ HIGHGAIN
Definition Tile_Base_ID.h:56
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
ir
int ir
counter of the current depth
Definition fastadd.cxx:49
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition hcg.cxx:132
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition ReadCondHandle.h:269
index
Definition index.py:1
xAOD::EventInfo
EventInfo_v1 EventInfo
Definition of the latest event info version.
Definition IEventInfoCnvTool.h:16
tree
TChain * tree
Definition tile_monitor.h:30
Generated on for ATLAS Offline Software by doxygen 1.16.1