ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
TileTBAANtuple.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 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) \
48 msg(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) \
54 msg(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) \
59 if (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) \
67 if (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
82 TileTBAANtuple::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 
102 StatusCode 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_cellContainerKey.initialize(!m_cellContainerKey.empty() && m_completeNtuple && m_TBperiod < 2015) );
119 
120  ATH_CHECK( m_tileToolEmscale.retrieve() );
121  ATH_CHECK( m_adderFilterAlgTool.retrieve(EnableTool{m_unpackAdder}) );
122 
123  ATH_CHECK( m_dqStatusKey.initialize(SG::AllowEmpty) );
124 
125  return StatusCode::SUCCESS;
126 }
127 
134 StatusCode TileTBAANtuple::ntuple_initialize(const EventContext& ctx) {
135 
136  CHECK( m_thistSvc.retrieve() );
137 
138  // find TileCablingService
139  m_cabling = TileCablingService::getInstance();
140 
141  // retrieve TileID helper from det store
142 
143  CHECK( detStore()->retrieve(m_tileID) );
144 
145  CHECK( detStore()->retrieve(m_tileHWID) );
146 
147  if (m_nSamples < 0) {
148  m_nSamples = 7;
149  }
150  if (m_nSamplesFlx < 0) {
151  m_nSamplesFlx = m_saveFelixData ? 32 : 0;
152  }
153 
154  if (m_TBperiod >= 2015) {
155  m_unpackAdder = false;
156 
157  if (m_TBperiod == 2015) {
158  m_nDrawers = 2;
159  m_drawerList.value().resize(m_nDrawers);
160  m_drawerType.value().resize(m_nDrawers);
161  m_drawerList[0] = "0x200"; m_drawerType[0] = 2; // barrel neg
162  m_drawerList[1] = "0x401"; m_drawerType[1] = 4; // ext.barrel neg
163  } else if (m_TBperiod == 2016 || m_TBperiod == 2018 || m_TBperiod == 2021 || m_TBperiod == 2022) {
164  m_nDrawers = 5;
165  m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
166  m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
167  m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
168  m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
169  m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
170  m_drawerList[4] = "0x402"; m_drawerType[4] = 4; // ext.barrel neg
171  } else if (m_TBperiod == 2017) {
172  m_nDrawers = 6;
173  m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
174  m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
175  m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
176  m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
177  m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
178  m_drawerList[4] = "0x203"; m_drawerType[4] = 2; // barrel neg
179  m_drawerList[5] = "0x402"; m_drawerType[5] = 4; // ext.barrel neg
180  } else if (m_TBperiod == 2019) {
181  m_nDrawers = 7;
182  m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
183  m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
184  m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
185  m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
186  m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
187  m_drawerList[4] = "0x203"; m_drawerType[4] = 2; // barrel neg
188  m_drawerList[5] = "0x402"; m_drawerType[5] = 4; // ext.barrel neg
189  m_drawerList[6] = "0x405"; m_drawerType[6] = 4; // ext.barrel neg
190  }
191 
192  if (m_TBperiod < 2016) {
193  setupBeamChambersTB2015();
194  } else if (m_TBperiod < 2021) {
195  setupBeamChambersTB2016_2020();
196  } else {
197  // Strating from 2021 the following properties should be setup via JO
198  checkIsPropertySetup(m_beamBC1X1, "BC1X1");
199  checkIsPropertySetup(m_beamBC1X2, "BC1X2");
200  checkIsPropertySetup(m_beamBC1Y1, "BC1Y1");
201  checkIsPropertySetup(m_beamBC1Y2, "BC1Y2");
202  checkIsPropertySetup(m_beamBC1Z, "BC1Z");
203  checkIsPropertySetup(m_beamBC1Z_0, "BC1Z_0");
204  checkIsPropertySetup(m_beamBC1Z_90, "BC1Z_90");
205  checkIsPropertySetup(m_beamBC1Z_min90, "BC1Z_min90");
206 
207  checkIsPropertySetup(m_beamBC2X1, "BC2X1");
208  checkIsPropertySetup(m_beamBC2X2, "BC2X2");
209  checkIsPropertySetup(m_beamBC2Y1, "BC2Y1");
210  checkIsPropertySetup(m_beamBC2Y2, "BC2Y2");
211  checkIsPropertySetup(m_beamBC2Z, "BC2Z");
212  checkIsPropertySetup(m_beamBC2Z_0, "BC2Z_0");
213  checkIsPropertySetup(m_beamBC2Z_90, "BC2Z_90");
214  checkIsPropertySetup(m_beamBC2Z_min90, "BC2Z_min90");
215  }
216 
217  } else {
218  setupBeamChambersBeforeTB2015();
219  }
220 
221 
222  if (m_unpackAdder) {
223  // get TileRawChannelBuilderFlatFilter for adder energy calculation
224 
225  StatusCode sc;
226  sc &= m_adderFilterAlgTool->setProperty("TileRawChannelContainer", "TileAdderFlat");
227  sc &= m_adderFilterAlgTool->setProperty("calibrateEnergy", "true");
228 
229  sc &= m_adderFilterAlgTool->setProperty("PedStart", "0");
230  sc &= m_adderFilterAlgTool->setProperty("PedLength", "1");
231  sc &= m_adderFilterAlgTool->setProperty("PedOffset", "0");
232  sc &= m_adderFilterAlgTool->setProperty("SignalStart", "1");
233  sc &= m_adderFilterAlgTool->setProperty("SignalLength", "15");
234  sc &= m_adderFilterAlgTool->setProperty("FilterLength", "5");
235  sc &= m_adderFilterAlgTool->setProperty("FrameLength", "16");
236  sc &= m_adderFilterAlgTool->setProperty("DeltaCutLo", "9.5");
237  sc &= m_adderFilterAlgTool->setProperty("DeltaCutHi", "9.5");
238  sc &= m_adderFilterAlgTool->setProperty("RMSCutLo", "1.0");
239  sc &= m_adderFilterAlgTool->setProperty("RMSCutHi", "1.0");
240  if (sc.isFailure()) {
241  ATH_MSG_ERROR("Failure setting properties of " << m_adderFilterAlgTool);
242  return StatusCode::FAILURE;
243  }
244  }
245 
246  if (m_finalUnit < TileRawChannelUnit::ADCcounts
247  || m_finalUnit > TileRawChannelUnit::OnlineMegaElectronVolts) {
248 
249  m_finalUnit = -1;
250  if (!m_useDspUnits && m_calibrateEnergy) {
251  m_useDspUnits = true;
252  ATH_MSG_INFO( "Final offline units are not set, will use DSP units" );
253  }
254  }
255 
256  if (!m_calibrateEnergy) {
257  if (m_useDspUnits) {
258  ATH_MSG_INFO( "calibrateEnergy is disabled, don't want to use DSP units" );
259  m_useDspUnits = false;
260  }
261  }
262 
263  ATH_MSG_INFO( "TestBeam period " << m_TBperiod.value() );
264  ATH_MSG_INFO( "calibMode " << m_calibMode.value() );
265  ATH_MSG_INFO( "calibrateEnergy " << m_calibrateEnergy.value() );
266  ATH_MSG_INFO( "offlineUnits " << m_finalUnit.value() );
267  ATH_MSG_INFO( "useDspUnits " << m_useDspUnits.value() );
268  ATH_MSG_INFO( "number of samples " << m_nSamples.value() );
269 
270 
271  msg(MSG::INFO) << "drawerList " << MSG::hex;
272  unsigned int size = m_drawerList.size();
273  for (unsigned int dr = 0; dr < size; ++dr) {
274  int frag = strtol(m_drawerList[dr].data(), NULL, 0);
275  if (frag >= 0) {
276  m_drawerMap[frag] = dr;
277  if (dr == m_drawerType.size()) m_drawerType.value().push_back(frag >> 8);
278  msg(MSG::INFO) << " 0x" << frag;
279  } else {
280  msg(MSG::INFO) << " " << m_drawerList[dr];
281  // put negative number in first element (flag to read frag ID from data)
282  m_drawerList[0] = m_drawerList[dr];
283  m_drawerList.value().resize(1);
284  // m_drawerType.clear();
285  m_drawerMap.clear();
286  size = 0;
287  break;
288  }
289  }
290  if (size == 0) {
291  if (m_drawerList.size() > 0)
292  msg(MSG::INFO) << " - negative number, will read frag IDs from the data" << MSG::dec << endmsg;
293  else
294  msg(MSG::INFO) << "is empty, no drawer fragments in ntuple" << MSG::dec << endmsg;
295  } else {
296  msg(MSG::INFO) << MSG::dec << endmsg;
297 
298  size = m_drawerType.size();
299  if (size < m_nDrawers) {
300  m_drawerType.value().resize(m_nDrawers);
301  for (; size < m_nDrawers; ++size)
302  m_drawerType[size] = 0;
303  }
304 
305  msg(MSG::INFO) << MSG::INFO << "drawerType ";
306  for (unsigned int dr = 0; dr < size; ++dr)
307  msg(MSG::INFO) << " " << m_drawerType[dr];
308  msg(MSG::INFO) << endmsg;
309 
310  if (size > m_nDrawers) {
311  ATH_MSG_INFO( "increasing m_nDrawers from " << m_nDrawers << " to " << size );
312  m_nDrawers = size;
313  }
314  }
315 
316  msg(MSG::INFO) << MSG::INFO << "Beam Frag List " << MSG::hex;
317  size = m_beamFragList.size();
318  for (unsigned int dr = 0; dr < size; ++dr) {
319  int frag = strtol(m_beamFragList[dr].data(), NULL, 0);
320  if (frag >= 0) {
321  m_beamIdList[frag & 0x1F] = true;
322  msg(MSG::INFO) << " 0x" << frag;
323  }
324  }
325  if (size == 0) {
326  msg(MSG::INFO) << "is empty, no beam fragments in ntuple" << MSG::dec << endmsg;
327  } else {
328  msg(MSG::INFO) << MSG::dec << endmsg;
329  }
330 
331  // set event number to 0 before first event
332  m_evtNr = 0;
333  m_calibrateEnergyThisEvent = m_calibrateEnergy;
334 
335  // find event and beam ROD header, calib mode for digitizers
336 
340  if (m_evtNr == 0) {
341  if (m_unpackAdder) // in 2003 event number starts from 1
342  ++m_evtNr;
343  }
344 
345  if (initList(ctx).isFailure()) {
346  ATH_MSG_ERROR( " Error during drawer list initialization" );
347  }
348 
349  if (m_saveFelixData && initListFlx(ctx).isFailure()) {
350  ATH_MSG_ERROR( " Error during drawer list initialization" );
351  }
352 
353  if (initNTuple().isFailure()) {
354  ATH_MSG_ERROR( " Error during ntuple initialization" );
355  }
356 
357  ATH_MSG_INFO( "initialization completed" );
358  return StatusCode::SUCCESS;
359 }
360 
361 StatusCode TileTBAANtuple::execute() {
362 
363  const EventContext& ctx = Gaudi::Hive::currentContext();
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 
455 StatusCode 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 
525 StatusCode 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 
1182 StatusCode 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 
1344 StatusCode 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 
1635 StatusCode 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  */
1808 StatusCode 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() ) ? (*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 
1853 StatusCode 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() ) ? (*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 
1900 void 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.find(fragId)->second );
1967 
1968 }
1969 StatusCode 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 
2019 StatusCode 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 
2129 StatusCode 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 
2188 StatusCode 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 
2305 StatusCode 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 
2396 void 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  while ((runNumber != m_runNumber) && (!etafile.eof())) {
2422  etafile >> runNumber >> eta;
2423  }
2424 
2425  if (runNumber != m_runNumber) {
2426  ATH_MSG_INFO( "Run " << m_runNumber << " has not been found, keep eta and theta at zero" );
2427 
2428  m_eta = m_theta = 0.0;
2429  } else {
2430  m_eta = eta;
2431  m_theta = (M_PI_2 - 2 * atan(exp(m_eta)));
2432  ATH_MSG_INFO( "Run " << m_runNumber << " has been found with eta=" << m_eta << ", theta =" << m_theta );
2433 
2434  }
2435 
2436  } else {
2437 
2438  ATH_MSG_WARNING( "Problem with file " << fileName );
2439  ATH_MSG_WARNING( "Skip reading of eta value " );
2440 
2441  }
2442 
2443  etafile.close();
2444  }
2445 }
2446 
2449 
2464 
2469 
2471 
2472 void TileTBAANtuple::TRIGGER_addBranch(void)
2473 {
2474 
2475  m_ntuplePtr->Branch("EvTime",&m_evTime,"EvTime/I");
2476  m_ntuplePtr->Branch("Run",&m_run,"Run/I");
2477  m_ntuplePtr->Branch("Evt",&m_evt,"Evt/I");
2478  m_ntuplePtr->Branch("Trig",&m_trigType,"Trig/S");
2479  m_ntuplePtr->Branch("DSPflags",&m_dspFlags,"DSPflags/I");
2480  m_ntuplePtr->Branch("DSPunits",&m_dspUnit,"DSPunits/S");
2481  m_ntuplePtr->Branch("OFLunits",&m_rchUnit,"OFLunits/S");
2482 
2483  if ( m_completeNtuple ) {
2484  int nDrawersAll = m_nDrawers.value() + m_nDrawersFlx.value();
2485  if (nDrawersAll > 0) {
2486  m_l1ID.resize(nDrawersAll + 1);
2487  m_l1Type.resize(nDrawersAll + 1);
2488  m_evType.resize(nDrawersAll + 1);
2489  m_evBCID.resize(nDrawersAll + 1);
2490  m_frBCID.resize(nDrawersAll);
2491  }
2492 
2493  // Info from ROD headers
2494  // m_nDrawers drawers separately (i.e. with duplications) + Beam ROD
2495  m_ntuplePtr->Branch("L1ID",&m_l1ID);
2496  m_ntuplePtr->Branch("L1Type",&m_l1Type);
2497  m_ntuplePtr->Branch("EvType",&m_evType);
2498  m_ntuplePtr->Branch("EvBCID",&m_evBCID);
2499  m_ntuplePtr->Branch("FrBCID",&m_frBCID);
2500  }
2501 
2502 
2503 }
2504 
2508 
2510 
2511 void TileTBAANtuple::MUON_addBranch(void)
2512 {
2513 
2514  if ( m_beamIdList[MUON_ADC_FRAG] ||
2515  m_beamIdList[ADDR_ADC_FRAG] )
2516  {
2517  m_ntuplePtr->Branch("MuBackHit",&m_muBackHit,"MuBackHit/F");
2518  m_ntuplePtr->Branch("MuBackSum",&m_muBackSum,"MuBackSum/F");
2519 
2520  if (m_TBperiod < 2015) {
2521  m_ntuplePtr->Branch("MuBack",&m_muBack,"m_muBack[14]");
2522  m_ntuplePtr->Branch("MuCalib",&m_muCalib,"m_muCalib[2]");
2523  } else if (m_TBperiod == 2015) {
2524  m_ntuplePtr->Branch("MuBack",&m_muBack,"MuBack[8]/F");
2525  } else {
2526  m_ntuplePtr->Branch("MuBack",&m_muBack,"MuBack[12]/F");
2527  }
2528  }
2529 
2530 
2531 }
2532 
2536 
2538 
2539 void TileTBAANtuple::ECAL_addBranch(void)
2540 {
2541 
2542  if (m_beamIdList[ECAL_ADC_FRAG]) {
2543  m_ntuplePtr->Branch("Ecal",&m_ecal,"m_ecal[8]/F");
2544  }
2545 
2546 }
2547 
2551 
2553 
2554 void TileTBAANtuple::QDC_addBranch(void)
2555 {
2556 
2557  if (m_beamIdList[ECAL_ADC_FRAG]) {
2558  for(unsigned i=0; i<33; ++i){ m_qdc[i]=0.0; }
2559  m_ntuplePtr->Branch("qdc", &m_qdc, "qdc[33]/i");
2560  }
2561 
2562 }
2563 
2564 
2567 
2570 
2571 void TileTBAANtuple::TRIGGER_clearBranch(void) {
2572 
2573  m_evTime = 0;
2574  m_run = 0;
2575  m_evt = 0;
2576  m_trigType = 0;
2577 
2578  if (m_completeNtuple) {
2579  std::fill(m_l1ID.begin(), m_l1ID.end(), 0);
2580  std::fill(m_l1Type.begin(), m_l1Type.end(), 0);
2581  std::fill(m_evType.begin(), m_evType.end(), 0);
2582  std::fill(m_evBCID.begin(), m_evBCID.end(), 0);
2583  std::fill(m_frBCID.begin(), m_frBCID.end(), 0);
2584  }
2585 }
2586 
2589 
2592 
2593 void TileTBAANtuple::MUON_clearBranch(void) {
2594  m_muBackHit = 0.;
2595  m_muBackSum = 0.;
2596 
2597 }
2598 
2601 
2604 
2605 void TileTBAANtuple::ECAL_clearBranch(void)
2606 {
2607 
2608 }
2609 
2612 
2615 
2616 void TileTBAANtuple::QDC_clearBranch(void)
2617 {
2618  for(unsigned i=0; i<33; ++i){ m_qdc[i]=0.0; }
2619 }
2620 
2621 
2625 
2627 
2628 void TileTBAANtuple::LASER_addBranch(void) {
2629 
2630  if (!m_laserObjectKey.empty() > 0) {
2631 
2632  m_ntuplePtr->Branch("LASER_BCID", &m_las_BCID, "LASER_BCID/I");
2633 
2634  m_ntuplePtr->Branch("LASER_FILTER", &m_las_Filt, "LASER_FILTER/I");
2635  m_ntuplePtr->Branch("LASER_REQAMP", &m_las_ReqAmp, "LASER_REQAMP/D");
2636  m_ntuplePtr->Branch("LASER_MEASAMP", &m_las_MeasAmp, "LASER_MEASAMP/D");
2637 
2638  m_ntuplePtr->Branch("LASER_Diode_1_ADC", &m_las_D1_ADC, "LASER_Diode_1_ADC/I");
2639  m_ntuplePtr->Branch("LASER_Diode_2_ADC", &m_las_D2_ADC, "LASER_Diode_2_ADC/I");
2640  m_ntuplePtr->Branch("LASER_Diode_3_ADC", &m_las_D3_ADC, "LASER_Diode_3_ADC/I");
2641  m_ntuplePtr->Branch("LASER_Diode_4_ADC", &m_las_D4_ADC, "LASER_Diode_4_ADC/I");
2642 
2643  m_ntuplePtr->Branch("LASER_Diode_1_Ped", &m_las_D1_Ped, "LASER_Diode_1_Ped/D");
2644  m_ntuplePtr->Branch("LASER_Diode_2_Ped", &m_las_D2_Ped, "LASER_Diode_2_Ped/D");
2645  m_ntuplePtr->Branch("LASER_Diode_3_Ped", &m_las_D3_Ped, "LASER_Diode_3_Ped/D");
2646  m_ntuplePtr->Branch("LASER_Diode_4_Ped", &m_las_D4_Ped, "LASER_Diode_4_Ped/D");
2647 
2648  m_ntuplePtr->Branch("LASER_Diode_1_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_1_Ped_RMS/D");
2649  m_ntuplePtr->Branch("LASER_Diode_2_Ped_RMS", &m_las_D2_Ped_RMS, "LASER_Diode_2_Ped_RMS/D");
2650  m_ntuplePtr->Branch("LASER_Diode_3_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_3_Ped_RMS/D");
2651  m_ntuplePtr->Branch("LASER_Diode_4_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_4_Ped_RMS/D");
2652 
2653  m_ntuplePtr->Branch("LASER_Diode_1_Alpha", &m_las_D1_Alpha, "LASER_Diode_1_Alpha/D");
2654  m_ntuplePtr->Branch("LASER_Diode_2_Alpha", &m_las_D2_Alpha, "LASER_Diode_2_Alpha/D");
2655  m_ntuplePtr->Branch("LASER_Diode_3_Alpha", &m_las_D3_Alpha, "LASER_Diode_3_Alpha/D");
2656  m_ntuplePtr->Branch("LASER_Diode_4_Alpha", &m_las_D4_Alpha, "LASER_Diode_4_Alpha/D");
2657 
2658  m_ntuplePtr->Branch("LASER_Diode_1_Alpha_RMS", &m_las_D1_Alpha_RMS, "LASER_Diode_1_Alpha_RMS/D");
2659  m_ntuplePtr->Branch("LASER_Diode_2_Alpha_RMS", &m_las_D2_Alpha_RMS, "LASER_Diode_2_Alpha_RMS/D");
2660  m_ntuplePtr->Branch("LASER_Diode_3_Alpha_RMS", &m_las_D3_Alpha_RMS, "LASER_Diode_3_Alpha_RMS/D");
2661  m_ntuplePtr->Branch("LASER_Diode_4_Alpha_RMS", &m_las_D4_Alpha_RMS, "LASER_Diode_4_Alpha_RMS/D");
2662 
2663  m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed", &m_las_D1_AlphaPed, "LASER_Diode_1_AlphaPed/D");
2664  m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed", &m_las_D2_AlphaPed, "LASER_Diode_2_AlphaPed/D");
2665  m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed", &m_las_D3_AlphaPed, "LASER_Diode_3_AlphaPed/D");
2666  m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed", &m_las_D4_AlphaPed, "LASER_Diode_4_AlphaPed/D");
2667 
2668  m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed_RMS", &m_las_D1_AlphaPed_RMS, "LASER_Diode_1_AlphaPed_RMS/D");
2669  m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed_RMS", &m_las_D2_AlphaPed_RMS, "LASER_Diode_2_AlphaPed_RMS/D");
2670  m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed_RMS", &m_las_D3_AlphaPed_RMS, "LASER_Diode_3_AlphaPed_RMS/D");
2671  m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed_RMS", &m_las_D4_AlphaPed_RMS, "LASER_Diode_4_AlphaPed_RMS/D");
2672 
2673  m_ntuplePtr->Branch("LASER_PMT_1_ADC", &m_las_PMT1_ADC, "LASER_PMT_1_ADC/I");
2674  m_ntuplePtr->Branch("LASER_PMT_2_ADC", &m_las_PMT2_ADC, "LASER_PMT_2_ADC/I");
2675 
2676  m_ntuplePtr->Branch("LASER_PMT_1_TDC", &m_las_PMT1_TDC, "LASER_PMT_1_TDC/I");
2677  m_ntuplePtr->Branch("LASER_PMT_2_TDC", &m_las_PMT2_TDC, "LASER_PMT_2_TDC/I");
2678 
2679  m_ntuplePtr->Branch("LASER_PMT_1_Ped", &m_las_PMT1_Ped, "LASER_PMT_1_Ped/D");
2680  m_ntuplePtr->Branch("LASER_PMT_2_Ped", &m_las_PMT2_Ped, "LASER_PMT_2_Ped/D");
2681 
2682  m_ntuplePtr->Branch("LASER_PMT_1_Ped_RMS", &m_las_PMT1_Ped_RMS, "LASER_PMT_1_Ped_RMS/D");
2683  m_ntuplePtr->Branch("LASER_PMT_2_Ped_RMS", &m_las_PMT2_Ped_RMS, "LASER_PMT_2_Ped_RMS/D");
2684 
2685  m_ntuplePtr->Branch("LASER_HEAD_Temp", &m_las_Temperature, "LASER_HEAD_Temp/D");
2686  }
2687 
2688  if (m_beamIdList[LASE_PTN_FRAG]) {
2689  m_ntuplePtr->Branch("LasFlag", &m_lasFlag, "LasFlag/s");
2690  }
2691 
2692  if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2693  || (!m_unpackAdder && m_beamIdList[LASE_ADC_FRAG])) {
2694  m_ntuplePtr->Branch("Las0", &m_las0, "Las0/F");
2695  m_ntuplePtr->Branch("Las1", &m_las1, "Las1/F");
2696  m_ntuplePtr->Branch("Las2", &m_las2, "Las2/F");
2697  m_ntuplePtr->Branch("Las3", &m_las3, "Las3/F");
2698  m_ntuplePtr->Branch("LasExtra", &m_lasExtra, "m_lasExtra[4]/F");
2699  }
2700 
2701 }
2702 
2705 
2708 
2709 void TileTBAANtuple::LASER_clearBranch(void)
2710 {
2711 
2712  if (!m_laserObjectKey.empty()) {
2713 
2714  m_las_BCID = 0;
2715  m_las_D1_ADC = 0;
2716  m_las_D2_ADC = 0;
2717  m_las_D3_ADC = 0;
2718  m_las_D4_ADC = 0;
2719 
2720  m_las_D1_Ped = 0;
2721  m_las_D2_Ped = 0;
2722  m_las_D3_Ped = 0;
2723  m_las_D4_Ped = 0;
2724 
2725  m_las_D1_Alpha = 0;
2726  m_las_D2_Alpha = 0;
2727  m_las_D3_Alpha = 0;
2728  m_las_D4_Alpha = 0;
2729 
2730  m_las_PMT1_ADC = 0;
2731  m_las_PMT2_ADC = 0;
2732 
2733  m_las_PMT1_TDC = 0;
2734  m_las_PMT2_TDC = 0;
2735 
2736  m_las_PMT1_Ped = 0;
2737  m_las_PMT2_Ped = 0;
2738  }
2739 
2740  if (m_beamIdList[LASE_PTN_FRAG]) {
2741  m_lasFlag=0;
2742  }
2743 
2744  if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2745  || (!m_unpackAdder && m_beamIdList[LASE_ADC_FRAG])) {
2746 
2747  m_las0 = 0.;
2748  m_las1 = 0.;
2749  m_las2 = 0.;
2750  m_las3 = 0.;
2751 
2752  }
2753 }
2754 
2758 
2760 
2761 void TileTBAANtuple::ADDER_addBranch(void) {
2762 
2763  if (m_unpackAdder) {
2764  if (m_beamIdList[ADD_FADC_FRAG]) {
2765  m_adder = (int**) malloc(16 * sizeof(int *));
2766  m_adder[0] = (int*) malloc(16 * 16 * sizeof(int));
2767  for (int j = 1; j < 16; j++) {
2768  m_adder[j] = m_adder[0] + j * 16;
2769  }
2770 
2771  m_ntuplePtr->Branch("Adder", *m_adder, "m_adder[16][16]/I");
2772  m_ntuplePtr->Branch("EneAdd", &m_eneAdd, "m_eneAdd[16]/F");
2773  m_ntuplePtr->Branch("TimeAdd", &m_timeAdd, "m_timeAdd[16]/F");
2774  }
2775  }
2776 }
2777 
2780 
2783 
2784 void TileTBAANtuple::ADDER_clearBranch(void)
2785 {
2786 
2787 
2788 }
2789 
2793 
2795 
2796 void TileTBAANtuple::CISPAR_addBranch(void) {
2797 
2798  if (m_beamIdList[DIGI_PAR_FRAG & 0x1F]) {
2799 
2800  m_ntuplePtr->Branch("cispar", m_cispar, "cispar[16]/I");
2801  }
2802 }
2803 
2806 
2809 
2810 void TileTBAANtuple::CISPAR_clearBranch(void)
2811 {
2812  memset(m_cispar,-1,sizeof(m_cispar));
2813 }
2814 
2815 
2819 
2821 
2822 void TileTBAANtuple::BEAM_addBranch(void) {
2823 
2824  if (((m_TBperiod >= 2015 || m_unpackAdder) && m_beamIdList[BEAM_ADC_FRAG])
2825  || ((!m_unpackAdder || m_TBperiod >= 2022) && m_beamIdList[COMMON_ADC1_FRAG])) {
2826 
2827  m_ntuplePtr->Branch("S1cou", &m_s1cou, "S1cou/S");
2828  m_ntuplePtr->Branch("S2cou", &m_s2cou, "S2cou/S");
2829  if (m_TBperiod >= 2016 && m_TBperiod < 2022) {
2830  m_ntuplePtr->Branch("Cher3", &m_s3cou, "Cher3/S"); // dropped S3 in favor of Cher3 in September 2016 TB
2831  // m_ntuplePtr->Branch("SpmFinger", &m_muVeto, "SmpFinger/S"); // muVeto replaced by SPM for testing
2832  m_ntuplePtr->Branch("SiPM1", &m_muTag, "SiPM1/S"); // muTag replaced by SiPM1 for testing
2833  m_ntuplePtr->Branch("SiPM2", &m_muHalo, "SiPM2/S");// muHalo repalce by SiPM1 for testing
2834  } else {
2835  m_ntuplePtr->Branch("S3cou", &m_s3cou, "S3cou/S");
2836  }
2837 
2838  m_ntuplePtr->Branch("Cher1", &m_cher1, "Cher1/S");
2839  m_ntuplePtr->Branch("Cher2", &m_cher2, "Cher2/S");
2840  if (m_TBperiod >= 2022) {
2841  m_ntuplePtr->Branch("Cher3", &m_cher3, "Cher3/S");
2842  }
2843 
2844  if (m_TBperiod < 2015) {
2845  m_ntuplePtr->Branch("MuTag", &m_muTag, "MuTag/S");
2846  m_ntuplePtr->Branch("MuHalo", &m_muHalo, "MuHalo/S");
2847  m_ntuplePtr->Branch("MuVeto", &m_muVeto, "MuVeto/S");
2848  //} else if (m_TBperiod == 2015) {
2849  // nothing
2850  } else if (m_TBperiod >= 2016) {
2851  m_ntuplePtr->Branch("SCalo1", &m_muTag, "SCalo1/S");
2852  m_ntuplePtr->Branch("SCalo2", &m_muHalo, "SCalo2/S");
2853  //m_ntuplePtr->Branch("SCalo3", &m_muVeto, "SCalo3/S");
2854  }
2855  }
2856 
2857  if (m_TBperiod >= 2015) {
2858  if (m_beamIdList[COMMON_TDC1_FRAG] || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2859  m_btdc = new std::vector<std::vector<int> >(16);
2860  m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1[16]/I");
2861  m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2[16]/I");
2862  m_ntuplePtr->Branch("btdc", &m_btdc);
2863  m_ntuplePtr->Branch("tjitter", &m_tjitter, "tjitter/I");
2864  m_ntuplePtr->Branch("tscTOF", &m_tscTOF, "tscTOF/I");
2865  m_ntuplePtr->Branch("btdcNhit", m_btdcNhit, "btdcNhit[16]/I");
2866  m_ntuplePtr->Branch("btdcNchMultiHit", m_btdcNchMultiHit, "btdcNchMultiHit[2]/I");
2867  }
2868  if (m_beamIdList[COMMON_TOF_FRAG]) {
2869  m_ntuplePtr->Branch("tof", &m_tof, "m_tof[16]/I");
2870  }
2871  if (m_beamIdList[COMMON_PTN_FRAG]) {
2872  m_ntuplePtr->Branch("scaler", &m_scaler, "m_scaler[16]/I");
2873  }
2874  } else if (!m_unpackAdder) {
2875  if (m_beamIdList[COMMON_ADC2_FRAG]) {
2876  m_ntuplePtr->Branch("S2extra", &m_s2extra, "S2extra/S");
2877  m_ntuplePtr->Branch("S2cou", &m_s3extra, "S3extra/S");
2878  }
2879  if (m_beamIdList[BEAM_ADC_FRAG]) {
2880  m_ntuplePtr->Branch("SC1", &m_sc1, "SC1/S");
2881  m_ntuplePtr->Branch("SC2", &m_sc2, "SC2/S");
2882  }
2883  if (m_beamIdList[COMMON_PTN_FRAG]) {
2884  m_ntuplePtr->Branch("pu", &m_commonPU, "pu/S");
2885  }
2886  if (m_beamIdList[COMMON_TOF_FRAG]) {
2887  m_ntuplePtr->Branch("tof", &m_tof, "m_tof[8]/I");
2888  }
2889  if (m_beamIdList[COMMON_TDC1_FRAG]) {
2890  m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1/I");
2891  }
2892  if (m_beamIdList[COMMON_TDC2_FRAG]) {
2893  m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2/I");
2894  }
2895 
2896  if (m_beamIdList[COMMON_TDC1_FRAG]) {
2897  m_ntuplePtr->Branch("XchN2", &m_xChN2, "XchN2/F");
2898  m_ntuplePtr->Branch("YchN2", &m_yChN2, "YchN2/F");
2899  m_ntuplePtr->Branch("XchN1", &m_xChN1, "XchN1/F");
2900  m_ntuplePtr->Branch("YchN1", &m_yChN1, "YchN1/F");
2901  }
2902  if (m_beamIdList[COMMON_TDC2_FRAG]) {
2903  m_ntuplePtr->Branch("Xcha0", &m_xCha0, "Xcha0/F");
2904  m_ntuplePtr->Branch("Ycha0", &m_yCha0, "Ycha0/F");
2905  }
2906  } else {
2907  if (m_beamIdList[BEAM_TDC_FRAG]) {
2908  m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1[16]/I");
2909  m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2[16]/I");
2910  }
2911  }
2912 
2913  if ((m_TBperiod >= 2015 && m_beamIdList[COMMON_TDC1_FRAG])
2914  || (m_unpackAdder && m_beamIdList[BEAM_TDC_FRAG])
2915  || (!m_unpackAdder && m_beamIdList[COMMON_TDC2_FRAG])
2916  || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2917 
2918  m_ntuplePtr->Branch("Xcha1", &m_xCha1, "Xcha1/F");
2919  m_ntuplePtr->Branch("Ycha1", &m_yCha1, "Ycha1/F");
2920  m_ntuplePtr->Branch("Xcha2", &m_xCha2, "Xcha2/F");
2921  m_ntuplePtr->Branch("Ycha2", &m_yCha2, "Ycha2/F");
2922  m_ntuplePtr->Branch("Xcha1_0", &m_xCha1_0, "Xcha1_0/F");
2923  m_ntuplePtr->Branch("Ycha1_0", &m_yCha1_0, "Ycha1_0/F");
2924  m_ntuplePtr->Branch("Xcha2_0", &m_xCha2_0, "Xcha2_0/F");
2925  m_ntuplePtr->Branch("Ycha2_0", &m_yCha2_0, "Ycha2_0/F");
2926  m_ntuplePtr->Branch("Ximp", &m_xImp, "Ximp/F");
2927  m_ntuplePtr->Branch("Yimp", &m_yImp, "Yimp/F");
2928  m_ntuplePtr->Branch("Ximp_0", &m_xImp_0, "Ximp_0/F");
2929  m_ntuplePtr->Branch("Yimp_0", &m_yImp_0, "Yimp_0/F");
2930  m_ntuplePtr->Branch("Ximp_90", &m_xImp_90, "Ximp_90/F");
2931  m_ntuplePtr->Branch("Yimp_90", &m_yImp_90, "Yimp_90/F");
2932  m_ntuplePtr->Branch("Ximp_min90", &m_xImp_min90, "Ximp_min90/F");
2933  m_ntuplePtr->Branch("Yimp_min90", &m_yImp_min90, "Yimp_min90/F");
2934  }
2935 
2936 }
2937 
2940 
2943 
2944 void TileTBAANtuple::BEAM_clearBranch(void) {
2945 
2946  if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2947  || (!m_unpackAdder && m_beamIdList[COMMON_ADC1_FRAG])) {
2948 
2949  m_s1cou = 0;
2950  m_s2cou = 0;
2951  m_s3cou = 0;
2952  m_cher1 = 0;
2953  m_cher2 = 0;
2954  m_cher3 = 0;
2955  m_muTag = 0;
2956  m_muHalo = 0;
2957  m_muVeto = 0;
2958  }
2959  if (!m_unpackAdder) {
2960  if (m_beamIdList[COMMON_ADC2_FRAG]) {
2961 
2962  m_s2extra = 0;
2963  m_s3extra = 0;
2964  }
2965  if (m_beamIdList[BEAM_ADC_FRAG]) {
2966  m_sc1 = 0;
2967  m_sc2 = 0;
2968  }
2969  if (m_beamIdList[COMMON_PTN_FRAG]) {
2970  m_commonPU = 0;
2971  }
2972  if (m_beamIdList[COMMON_TDC1_FRAG]) {
2973  m_xChN2 = 0.;
2974  m_yChN2 = 0.;
2975  m_xChN1 = 0.;
2976  m_yChN1 = 0.;
2977  }
2978  if (m_beamIdList[COMMON_TDC2_FRAG]) {
2979  m_xCha0 = 0.;
2980  m_yCha0 = 0.;
2981  }
2982  }
2983 
2984  if ((m_TBperiod >= 2015 && m_beamIdList[COMMON_TDC1_FRAG])
2985  || (m_unpackAdder && m_beamIdList[BEAM_TDC_FRAG])
2986  || (!m_unpackAdder && m_beamIdList[COMMON_TDC2_FRAG])
2987  || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2988 
2989  m_xCha1 = 0.;
2990  m_yCha1 = 0.;
2991  m_xCha2 = 0.;
2992  m_yCha2 = 0.;
2993  m_xCha1_0 = 0.;
2994  m_yCha1_0 = 0.;
2995  m_xCha2_0 = 0.;
2996  m_yCha2_0 = 0.;
2997  m_xImp = 0.;
2998  m_yImp = 0.;
2999  }
3000 
3001  m_muBack.fill(0.0F);
3002 
3003  for (int i=0; i<16; i+=2) {
3004  m_tof[i] = +0xFFFF;
3005  m_tof[i+1] = -0xFFFF;
3006  }
3007 
3008  for (int i=0; i<16; i+=2) {
3009  m_btdc1[i] = +0xFFFF;
3010  m_btdc1[i+1] = -0xFFFF;
3011  }
3012 
3013  for (int i=0; i<16; i+=2) {
3014  m_btdc2[i] = +0xFFFF;
3015  m_btdc2[i+1] = -0xFFFF;
3016  }
3017 
3018  if (m_btdc) {
3019  for (std::vector<int>& btdc_amplitudes : *m_btdc) {
3020  btdc_amplitudes.clear();
3021  }
3022  }
3023 
3024  memset(&m_scaler, 0, sizeof(m_scaler));
3025 
3026  memset(m_btdcNhit,0,sizeof(m_btdcNhit));
3027  memset(m_btdcNchMultiHit,0,sizeof(m_btdcNchMultiHit));
3028 }
3029 
3033 
3035 
3036 void TileTBAANtuple::ENETOTAL_addBranch(void)
3037 {
3038  if (m_completeNtuple) {
3039  m_ntuplePtr->Branch("LarSmp", &m_LarEne, "m_LarEne[4]/F");
3040  m_ntuplePtr->Branch("BarSmp", &m_BarEne, "m_BarEne[3]/F");
3041  m_ntuplePtr->Branch("ExtSmp", &m_ExtEne, "m_ExtEne[3]/F");
3042  m_ntuplePtr->Branch("GapSmp", &m_GapEne, "m_GapEne[3]/F");
3043  }
3044 }
3045 
3048 
3051 
3052 void TileTBAANtuple::ENETOTAL_clearBranch(void)
3053 {
3054 
3055 
3056 }
3057 
3061 
3063 
3064 void TileTBAANtuple::COINCBOARD_addBranch(void) {
3065  if (m_beamIdList[COIN_TRIG1_FRAG]) {
3066  m_ntuplePtr->Branch("CoincTrig1", &m_coincTrig1, "m_coincTrig1[96]/I");
3067  m_ntuplePtr->Branch("CoincFlag1", &m_coincFlag1, "CoincFlag1/I");
3068  }
3069 
3070  if (m_beamIdList[COIN_TRIG2_FRAG]) {
3071  m_ntuplePtr->Branch("CoincTrig2", &m_coincTrig2, "m_coincTrig2[96]/I");
3072  m_ntuplePtr->Branch("CoincFlag2", &m_coincFlag2, "CoincFlag2/I");
3073  }
3074 
3075  if (m_beamIdList[COIN_TRIG3_FRAG]) {
3076  m_ntuplePtr->Branch("CoincTrig3", &m_coincTrig3, "m_coincTrig3[96]/I");
3077  m_ntuplePtr->Branch("CoincFlag3", &m_coincFlag3, "CoincFlag3/I");
3078  }
3079 
3080  if (m_beamIdList[COIN_TRIG4_FRAG]) {
3081  m_ntuplePtr->Branch("CoincTrig4", &m_coincTrig4, "m_coincTrig4[96]/I");
3082  m_ntuplePtr->Branch("CoincFlag4", &m_coincFlag4, "CoincFlag4/I");
3083  }
3084  if (m_beamIdList[COIN_TRIG5_FRAG]) {
3085  m_ntuplePtr->Branch("CoincTrig5", &m_coincTrig5, "m_coincTrig5[96]/I");
3086  m_ntuplePtr->Branch("CoincFlag5", &m_coincFlag5, "CoincFlag5/I");
3087  }
3088 
3089  if (m_beamIdList[COIN_TRIG6_FRAG]) {
3090  m_ntuplePtr->Branch("CoincTrig6", &m_coincTrig6, "m_coincTrig6[96]/I");
3091  m_ntuplePtr->Branch("CoincFlag6", &m_coincFlag6, "CoincFlag6/I");
3092  }
3093 
3094  if (m_beamIdList[COIN_TRIG7_FRAG]) {
3095  m_ntuplePtr->Branch("CoincTrig7", &m_coincTrig7, "m_coincTrig7[96]/I");
3096  m_ntuplePtr->Branch("CoincFlag7", &m_coincFlag7, "CoincFlag7/I");
3097  }
3098 
3099  if (m_beamIdList[COIN_TRIG8_FRAG]) {
3100  m_ntuplePtr->Branch("CoincTrig8", &m_coincTrig8, "m_coincTrig8[96]/I");
3101  m_ntuplePtr->Branch("CoincFlag8", &m_coincFlag8, "CoincFlag8/I");
3102  }
3103 
3104 }
3105 
3108 
3111 
3112 void TileTBAANtuple::COINCBOARD_clearBranch(void)
3113 {
3114 
3115 
3116 
3117 }
3118 
3122 
3124 
3125 void TileTBAANtuple::DIGI_addBranch(void)
3126 {
3127 
3128 
3131  m_bcidVec.reserve(MAX_DRAWERS);
3132  m_DMUheaderVec.reserve(MAX_DRAWERS);
3133  m_DMUformatErrVec.reserve(MAX_DRAWERS);
3134  m_DMUparityErrVec.reserve(MAX_DRAWERS);
3135  m_DMUmemoryErrVec.reserve(MAX_DRAWERS);
3136  m_DMUDstrobeErrVec.reserve(MAX_DRAWERS);
3137  m_DMUHeadparityErrVec.reserve(MAX_DRAWERS);
3138  m_DMUDataparityErrVec.reserve(MAX_DRAWERS);
3139  m_DMUSstrobeErrVec.reserve(MAX_DRAWERS);
3140  m_dmuMaskVec.reserve(MAX_DRAWERS);
3141  m_slinkCRCVec.reserve(MAX_DRAWERS);
3142  m_gainVec.reserve(MAX_DRAWERS);
3143  m_sampleVec.reserve(MAX_DRAWERS);
3144  m_feCRCVec.reserve(MAX_DRAWERS);
3145  m_rodCRCVec.reserve(MAX_DRAWERS);
3146  m_eneVec.reserve(MAX_DRAWERS);
3147  m_timeVec.reserve(MAX_DRAWERS);
3148  m_pedFlatVec.reserve(MAX_DRAWERS);
3149  m_chi2FlatVec.reserve(MAX_DRAWERS);
3150  m_efitVec.reserve(MAX_DRAWERS);
3151  m_tfitVec.reserve(MAX_DRAWERS);
3152  m_pedfitVec.reserve(MAX_DRAWERS);
3153  m_chi2Vec.reserve(MAX_DRAWERS);
3154  m_efitcVec.reserve(MAX_DRAWERS);
3155  m_tfitcVec.reserve(MAX_DRAWERS);
3156  m_pedfitcVec.reserve(MAX_DRAWERS);
3157  m_chi2cVec.reserve(MAX_DRAWERS);
3158  m_eOptVec.reserve(MAX_DRAWERS);
3159  m_tOptVec.reserve(MAX_DRAWERS);
3160  m_pedOptVec.reserve(MAX_DRAWERS);
3161  m_chi2OptVec.reserve(MAX_DRAWERS);
3162  m_eDspVec.reserve(MAX_DRAWERS);
3163  m_tDspVec.reserve(MAX_DRAWERS);
3164  m_chi2DspVec.reserve(MAX_DRAWERS);
3165  m_ROD_GlobalCRCVec.reserve(MAX_DRAWERS);
3166  m_ROD_DMUBCIDVec.reserve(MAX_DRAWERS);
3167  m_ROD_DMUmemoryErrVec.reserve(MAX_DRAWERS);
3168  m_ROD_DMUSstrobeErrVec.reserve(MAX_DRAWERS);
3169  m_ROD_DMUDstrobeErrVec.reserve(MAX_DRAWERS);
3170  m_ROD_DMUHeadformatErrVec.reserve(MAX_DRAWERS);
3171  m_ROD_DMUDataformatErrVec.reserve(MAX_DRAWERS);
3172  m_ROD_DMUMaskVec.reserve(MAX_DRAWERS);
3173 
3174  std::ostringstream oss;
3175  oss << m_nSamples;
3176  std::string nSampStr=oss.str();
3177 
3178  unsigned int listSize = std::min(m_nDrawers.value(), static_cast<unsigned int>(m_drawerMap.size()));
3179 
3180  if (listSize > 0) {
3181 
3182  std::string digit[10] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
3183  std::vector<std::string> suffixArr;
3184  unsigned int length;
3185  bool testbeam = TileCablingService::getInstance()->getTestBeam();
3186 
3187  if (m_calibMode) {
3188 
3189  length = 2 * m_nDrawers;
3190  suffixArr.resize(length);
3191 
3192  for (unsigned int i = 0; i < listSize; ++i) {
3193  unsigned int ros = m_drawerType[i];
3194  unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3195  std::string digits;
3196  if (m_TBperiod >= 2010) {
3197  ++drawer; // count modules from 1
3198  digits = digit[drawer / 10] + digit[drawer % 10];
3199  } else if (testbeam) {
3200  digits = digit[drawer & 7];
3201  } else {
3202  ++drawer; // count modules from 1
3203  digits = digit[drawer / 10] + digit[drawer % 10];
3204  }
3205 
3206  if (ros == 0) {
3207  std::string suff = m_drawerList[i];
3208  suff.replace(suff.find("0x"), 2, "");
3209  suffixArr[i] = suff + "lo";
3210  suffixArr[i + m_nDrawers] = suff + "hi";
3211  } else {
3212  suffixArr[i] = m_rosName[ros] + digits + "lo";
3213  suffixArr[i + m_nDrawers] = m_rosName[ros] + digits + "hi";
3214  }
3215  }
3216  } else {
3217 
3218  length = m_nDrawers;
3219  suffixArr.resize(length);
3220 
3221  for (unsigned int i = 0; i < listSize; ++i) {
3222  unsigned int ros = m_drawerType[i];
3223  unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3224  std::string digits;
3225  if (m_TBperiod >= 2010) {
3226  ++drawer; // count modules from 1
3227  digits = digit[drawer / 10] + digit[drawer % 10];
3228  } else if (testbeam) {
3229  digits = digit[drawer & 7];
3230  } else {
3231  ++drawer; // count modules from 1
3232  digits = digit[drawer / 10] + digit[drawer % 10];
3233  }
3234 
3235  if (ros == 0) {
3236  std::string suff = m_drawerList[i];
3237  suff.replace(suff.find("0x"), 2, "");
3238  suffixArr[i] = suff;
3239  } else {
3240  suffixArr[i] = m_rosName[ros] + digits;
3241  }
3242  }
3243  }
3244 
3245  m_nSamplesInDrawer.reserve(length);
3246 
3247  m_evtVec.resize(length);
3248  m_rodBCIDVec.resize(length);
3249  m_sizeVec.resize(length);
3250  m_ROD_GlobalCRCVec.resize(length);
3251 
3252  for (unsigned int i = 0; i < length; i++) {
3253 
3254  int nSamplesInDrawer(m_nSamples);
3255  int frag = std::stoi(m_drawerList[i%m_nDrawers], nullptr, 0);
3256 
3257  auto it = m_nSamplesInDrawerMap.find(frag);
3258  if (it != m_nSamplesInDrawerMap.end()) {
3259  nSamplesInDrawer = it->second;
3260  }
3261  m_nSamplesInDrawer.push_back(nSamplesInDrawer);
3262 
3263  m_bcidVec.push_back(std::array<int, MAX_DMU>()); // U
3264  m_DMUheaderVec.push_back(std::array<uint32_t, MAX_DMU>()); // U32
3265  m_DMUformatErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3266  m_DMUparityErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3267  m_DMUmemoryErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3268  m_DMUDstrobeErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3269  m_DMUSstrobeErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3270  m_DMUHeadparityErrVec.push_back(std::array<short, MAX_DMU>());
3271  m_DMUDataparityErrVec.push_back(std::array<short, MAX_DMU>());
3272 
3273  m_dmuMaskVec.push_back(std::array<int, 2>()); // U(2)
3274  m_slinkCRCVec.push_back(std::array<int, 2>()); // U(2)
3275  m_gainVec.push_back(std::array<int, MAX_CHAN>()); // U(48/96)
3276  m_sampleVec.push_back(std::make_unique<int[]>(MAX_CHAN * nSamplesInDrawer)); // U(48/96,9)
3277  m_feCRCVec.push_back(std::array<int, MAX_DMU>()); //U
3278  m_rodCRCVec.push_back(std::array<int, MAX_DMU>()); //U
3279 
3280  m_eneVec.push_back(std::array<float, MAX_CHAN>());
3281  m_timeVec.push_back(std::array<float, MAX_CHAN>());
3282  m_pedFlatVec.push_back(std::array<float, MAX_CHAN>());
3283  m_chi2FlatVec.push_back(std::array<float, MAX_CHAN>());
3284 
3285  m_efitVec.push_back(std::array<float, MAX_CHAN>());
3286  m_tfitVec.push_back(std::array<float, MAX_CHAN>());
3287  m_pedfitVec.push_back(std::array<float, MAX_CHAN>());
3288  m_chi2Vec.push_back(std::array<float, MAX_CHAN>());
3289 
3290  m_efitcVec.push_back(std::array<float, MAX_CHAN>());
3291  m_tfitcVec.push_back(std::array<float, MAX_CHAN>());
3292  m_pedfitcVec.push_back(std::array<float, MAX_CHAN>());
3293  m_chi2cVec.push_back(std::array<float, MAX_CHAN>());
3294 
3295  m_eOptVec.push_back(std::array<float, MAX_CHAN>());
3296  m_tOptVec.push_back(std::array<float, MAX_CHAN>());
3297  m_pedOptVec.push_back(std::array<float, MAX_CHAN>());
3298  m_chi2OptVec.push_back(std::array<float, MAX_CHAN>());
3299 
3300  m_eDspVec.push_back(std::array<float, MAX_CHAN>());
3301  m_tDspVec.push_back(std::array<float, MAX_CHAN>());
3302  m_chi2DspVec.push_back(std::array<float, MAX_CHAN>());
3303 
3304  m_ROD_DMUBCIDVec.push_back(std::array<short, MAX_DMU>());
3305  m_ROD_DMUmemoryErrVec.push_back(std::array<short, MAX_DMU>());
3306  m_ROD_DMUSstrobeErrVec.push_back(std::array<short, MAX_DMU>());
3307  m_ROD_DMUDstrobeErrVec.push_back(std::array<short, MAX_DMU>());
3308  m_ROD_DMUHeadformatErrVec.push_back(std::array<short, MAX_DMU>());
3309  m_ROD_DMUDataformatErrVec.push_back(std::array<short, MAX_DMU>());
3310  m_ROD_DMUMaskVec.push_back(std::array<short, 2>());
3311 
3312  if (i % m_nDrawers < listSize) {
3313 
3314  ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3315  // create ntuple layout
3316  if (m_bsInput) {
3317  m_ntuplePtr->Branch(("Evt"+suffixArr[i]).c_str(), &m_evtVec.data()[i], ("Evt"+suffixArr[i]+"/I").c_str()); // int
3318  m_ntuplePtr->Branch(("rodBCID"+suffixArr[i]).c_str(), &m_rodBCIDVec.data()[i], ("rodBCID"+suffixArr[i]+"/S").c_str());//int
3319  m_ntuplePtr->Branch(("Size"+suffixArr[i]).c_str(), &m_sizeVec.data()[i], ("Size"+suffixArr[i]+"/S").c_str()); // short
3320  m_ntuplePtr->Branch(("BCID"+suffixArr[i]).c_str(), &m_bcidVec.back(), ("bcid"+suffixArr[i]+"[16]/I").c_str()); // int
3321  m_ntuplePtr->Branch(("DMUheader"+suffixArr[i]).c_str(), &m_DMUheaderVec.back(), ("DMUheader"+suffixArr[i]+"[16]/i").c_str()); // uint32
3322  m_ntuplePtr->Branch(("DMUformatErr"+suffixArr[i]).c_str(), &m_DMUformatErrVec.back(), ("DMUformatErr"+suffixArr[i]+"[16]/S").c_str()); // short
3323  m_ntuplePtr->Branch(("DMUparityErr"+suffixArr[i]).c_str(), &m_DMUparityErrVec.back(), ("DMUparityErr"+suffixArr[i]+"[16]/S").c_str()); // short
3324  m_ntuplePtr->Branch(("DMUmemoryErr"+suffixArr[i]).c_str(), &m_DMUmemoryErrVec.back(), ("DMUmemoryErr"+suffixArr[i]+"[16]/S").c_str()); // short
3325  m_ntuplePtr->Branch(("DMUSstrobeErr"+suffixArr[i]).c_str(), &m_DMUSstrobeErrVec.back(), ("DMUSstrobeErr"+suffixArr[i]+"[16]/S").c_str()); // short
3326  m_ntuplePtr->Branch(("DMUDstrobeErr"+suffixArr[i]).c_str(), &m_DMUDstrobeErrVec.back(), ("DMUDstrobeErr"+suffixArr[i]+"[16]/S").c_str()); // short
3327  m_ntuplePtr->Branch(("DMUMask"+suffixArr[i]).c_str(), &m_dmuMaskVec.back(), ("dmumask"+suffixArr[i]+"[2]/I").c_str()); // int
3328  m_ntuplePtr->Branch(("SlinkCRC"+suffixArr[i]).c_str(), &m_slinkCRCVec.back(), ("crc"+suffixArr[i]+"[2]/I").c_str()); // int
3329  m_ntuplePtr->Branch(("DMUHeadparityErr"+suffixArr[i]).c_str(), &m_DMUHeadparityErrVec.back(), ("DMUHeadparityErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3330  m_ntuplePtr->Branch(("DMUDataparityErr"+suffixArr[i]).c_str(), &m_DMUDataparityErrVec.back(), ("DMUDataparityErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3331  }
3332 
3333  m_ntuplePtr->Branch(("Gain"+suffixArr[i]).c_str(),&m_gainVec.back(), ("gain"+suffixArr[i]+"[48]/I").c_str()); // int
3334 
3335  if (nSamplesInDrawer > 0) {
3336  nSampStr = std::to_string(nSamplesInDrawer);
3337  m_ntuplePtr->Branch(("Sample" + suffixArr[i]).c_str(), m_sampleVec.back().get(),
3338  ("sample" + suffixArr[i] + "[48]["+nSampStr+"]/I").c_str()); // size m_nsample and type int
3339  }
3340 
3341  if (m_bsInput) {
3342  m_ntuplePtr->Branch(("feCRC" + suffixArr[i]).c_str(), &m_feCRCVec.back(), ("fe_crc" + suffixArr[i] + "[16]/I").c_str()); // int
3343  m_ntuplePtr->Branch(("rodCRC" + suffixArr[i]).c_str(), &m_rodCRCVec.back(), ("rod_crc" + suffixArr[i] + "[16]/I").c_str()); // int
3344  }
3345 
3346  if (!m_flatRawChannelContainerKey.empty()) {
3347 
3348  m_ntuplePtr->Branch(("Ene" + suffixArr[i]).c_str(), &m_eneVec.back(), ("ene" + suffixArr[i] + "[48]/F").c_str()); // float
3349  m_ntuplePtr->Branch(("Time" + suffixArr[i]).c_str(), &m_timeVec.back(), ("time" + suffixArr[i] + "[48]/F").c_str()); // float
3350  m_ntuplePtr->Branch(("Ped" + suffixArr[i]).c_str(), &m_pedFlatVec.back(), ("pedflat" + suffixArr[i] + "[48]/F").c_str()); // float
3351  m_ntuplePtr->Branch(("Chi2ene" + suffixArr[i]).c_str(), &m_chi2FlatVec.back(), ("chiflat" + suffixArr[i] + "[48]/F").c_str()); // float
3352 
3353  }
3354 
3355  if (!m_fitRawChannelContainerKey.empty()) {
3356 
3357  m_ntuplePtr->Branch(("Efit" + suffixArr[i]).c_str(), &m_efitVec.back(), ("efit" + suffixArr[i] + "[48]/F").c_str()); // float
3358  m_ntuplePtr->Branch(("Tfit" + suffixArr[i]).c_str(), &m_tfitVec.back(), ("tfit" + suffixArr[i] + "[48]/F").c_str()); // float
3359  m_ntuplePtr->Branch(("Pedfit" + suffixArr[i]).c_str(), &m_pedfitVec.back(), ("pedfit" + suffixArr[i] + "[48]/F").c_str()); // float
3360  m_ntuplePtr->Branch(("Chi2fit" + suffixArr[i]).c_str(), &m_chi2Vec.back(), ("chifit" + suffixArr[i] + "[48]/F").c_str()); // float
3361 
3362  }
3363 
3364  if (!m_fitcRawChannelContainerKey.empty()) {
3365 
3366  m_ntuplePtr->Branch(("Efitc" + suffixArr[i]).c_str(), &m_efitcVec.back(), ("efitc" + suffixArr[i] + "[48]/F").c_str()); // float
3367  m_ntuplePtr->Branch(("Tfitc" + suffixArr[i]).c_str(), &m_tfitcVec.back(), ("tfitc" + suffixArr[i] + "[48]/F").c_str()); // float
3368  m_ntuplePtr->Branch(("Pedfitc" + suffixArr[i]).c_str(), &m_pedfitcVec.back(), ("pedfitc" + suffixArr[i] + "[48]/F").c_str()); // float
3369  m_ntuplePtr->Branch(("Chi2fitc" + suffixArr[i]).c_str(), &m_chi2cVec.back(), ("chifitc" + suffixArr[i] + "[48]/F").c_str()); // float
3370 
3371  }
3372 
3373  if (!m_optRawChannelContainerKey.empty()) {
3374 
3375  m_ntuplePtr->Branch(("Eopt"+suffixArr[i]).c_str(), &m_eOptVec.back(), ("eOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3376  m_ntuplePtr->Branch(("Topt"+suffixArr[i]).c_str(), &m_tOptVec.back(), ("tOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3377  m_ntuplePtr->Branch(("Pedopt"+suffixArr[i]).c_str(), &m_pedOptVec.back(), ("pedOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3378  m_ntuplePtr->Branch(("Chi2opt"+suffixArr[i]).c_str(), &m_chi2OptVec.back(), ("chiOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3379 
3380  }
3381 
3382  if (!m_dspRawChannelContainerKey.empty()) {
3383 
3384  m_ntuplePtr->Branch(("Edsp"+suffixArr[i]).c_str(), &m_eDspVec.back(), ("eDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3385  m_ntuplePtr->Branch(("Tdsp"+suffixArr[i]).c_str(), &m_tDspVec.back(), ("tDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3386  m_ntuplePtr->Branch(("Chi2dsp"+suffixArr[i]).c_str(), &m_chi2DspVec.back(), ("chiDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3387  m_ntuplePtr->Branch(("ROD_GlobalCRC"+suffixArr[i]).c_str(), &m_ROD_GlobalCRCVec.data()[i], ("ROD_GlobalCRC"+suffixArr[i]+"/s").c_str()); // unsigned short
3388  m_ntuplePtr->Branch(("ROD_DMUBCID"+suffixArr[i]).c_str(), &m_ROD_DMUBCIDVec.back(), ("ROD_DMUBCID"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3389  m_ntuplePtr->Branch(("ROD_DMUmemoryErr"+suffixArr[i]).c_str(), &m_ROD_DMUmemoryErrVec.back(), ("ROD_DMUmemoryErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3390  m_ntuplePtr->Branch(("ROD_DMUSstrobeErr"+suffixArr[i]).c_str(), &m_ROD_DMUSstrobeErrVec.back(), ("ROD_DMUSstrobeErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3391  m_ntuplePtr->Branch(("ROD_DMUDstrobeErr"+suffixArr[i]).c_str(), &m_ROD_DMUDstrobeErrVec.back(), ("ROD_DMUDstrobeErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3392  m_ntuplePtr->Branch(("ROD_DMUHeadformatErr"+suffixArr[i]).c_str(), &m_ROD_DMUHeadformatErrVec.back(), ("ROD_DMUHeadformatErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3393  m_ntuplePtr->Branch(("ROD_DMUDataformatErr"+suffixArr[i]).c_str(), &m_ROD_DMUDataformatErrVec.back(), ("ROD_DMUDataformatErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3394  m_ntuplePtr->Branch(("ROD_DMUMask"+suffixArr[i]).c_str(), &m_ROD_DMUMaskVec.back(), ("ROD_DMUMask"+suffixArr[i]+"[2]/s").c_str()); // unsigned short
3395 
3396  }
3397  }
3398  }
3399  }
3400 }
3401 
3406 
3407 void TileTBAANtuple::DIGI_clearBranch(void)
3408 {
3409  clear_init_minus1(m_evtVec);
3410  clear_init_minus1(m_rodBCIDVec);
3411  clear_init_minus1(m_sizeVec);
3412 
3413  clear_init_minus1(m_bcidVec);
3414  clear_init_zero(m_DMUheaderVec);
3415  clear_init_minus1(m_DMUformatErrVec);
3416  clear_init_minus1(m_DMUparityErrVec);
3417  clear_init_minus1(m_DMUmemoryErrVec);
3418  clear_init_minus1(m_DMUDstrobeErrVec);
3419  clear_init_minus1(m_DMUSstrobeErrVec);
3420  clear_init_minus1(m_DMUDataparityErrVec);
3421  clear_init_minus1(m_DMUHeadparityErrVec);
3422 
3423  clear_init_minus1(m_ROD_GlobalCRCVec);
3424  clear_init_minus1(m_ROD_DMUBCIDVec);
3425  clear_init_minus1(m_ROD_DMUmemoryErrVec);
3426  clear_init_minus1(m_ROD_DMUSstrobeErrVec);
3427  clear_init_minus1(m_ROD_DMUDstrobeErrVec);
3428  clear_init_minus1(m_ROD_DMUHeadformatErrVec);
3429  clear_init_minus1(m_ROD_DMUDataformatErrVec);
3430  clear_init_minus1(m_ROD_DMUMaskVec);
3431 
3432  clear_init_minus1(m_dmuMaskVec);
3433  clear_init_minus1(m_slinkCRCVec);
3434  clear_init_minus1(m_gainVec);
3435  clear_samples(m_sampleVec, m_nSamplesInDrawer);
3436  clear_init_minus1(m_feCRCVec);
3437  clear_init_minus1(m_rodCRCVec);
3438 
3439  clear_init_zero(m_eneVec);
3440  clear_init_zero(m_timeVec);
3441  clear_init_zero(m_pedFlatVec);
3442  clear_init_zero(m_chi2FlatVec);
3443  clear_init_zero(m_efitVec);
3444  clear_init_zero(m_tfitVec);
3445  clear_init_zero(m_pedfitVec);
3446  clear_init_zero(m_chi2Vec);
3447  clear_init_zero(m_efitcVec);
3448  clear_init_zero(m_tfitcVec);
3449  clear_init_zero(m_pedfitcVec);
3450  clear_init_zero(m_chi2cVec);
3451  clear_init_zero(m_eOptVec);
3452  clear_init_zero(m_tOptVec);
3453  clear_init_zero(m_pedOptVec);
3454  clear_init_zero(m_chi2OptVec);
3455  clear_init_zero(m_eDspVec);
3456  clear_init_zero(m_tDspVec);
3457  clear_init_zero(m_chi2DspVec);
3458 
3459 }
3460 
3461 
3462 void TileTBAANtuple::FELIX_addBranch(void)
3463 {
3464 
3465  m_rodBCIDflxVec.reserve(MAX_DRAWERS);
3466  m_sizeflxVec.reserve(MAX_DRAWERS);
3467  m_evtflxVec.reserve(MAX_DRAWERS);
3468 
3469  m_eflxfitVec.reserve(MAX_DRAWERS);
3470  m_tflxfitVec.reserve(MAX_DRAWERS);
3471  m_chi2flxfitVec.reserve(MAX_DRAWERS);
3472  m_pedflxfitVec.reserve(MAX_DRAWERS);
3473  m_eflxoptVec.reserve(MAX_DRAWERS);
3474  m_tflxoptVec.reserve(MAX_DRAWERS);
3475  m_chi2flxoptVec.reserve(MAX_DRAWERS);
3476  m_pedflxoptVec.reserve(MAX_DRAWERS);
3477  m_gainflxVec.reserve(MAX_DRAWERS);
3478  m_sampleflxVec.reserve(MAX_DRAWERS);
3479 
3480  m_mdL1idflxVec.reserve(MAX_DRAWERS);
3481  m_mdBcidflxVec.reserve(MAX_DRAWERS);
3482  m_mdModuleflxVec.reserve(MAX_DRAWERS);
3483  m_mdRunTypeflxVec.reserve(MAX_DRAWERS);
3484  m_mdPedLoflxVec.reserve(MAX_DRAWERS);
3485  m_mdPedHiflxVec.reserve(MAX_DRAWERS);
3486  m_mdRunflxVec.reserve(MAX_DRAWERS);
3487  m_mdChargeflxVec.reserve(MAX_DRAWERS);
3488  m_mdChargeTimeflxVec.reserve(MAX_DRAWERS);
3489  m_mdCapacitorflxVec.reserve(MAX_DRAWERS);
3490 
3491  std::string nSampStrFlx = std::to_string(m_nSamplesFlx);
3492  unsigned int listSize = std::min(m_nDrawersFlx.value(), static_cast<unsigned int>(m_drawerFlxMap.size()));
3493 
3494  bool testbeam = TileCablingService::getInstance()->getTestBeam();
3495  std::vector<std::string> moduleNames(m_nDrawersFlx, "");
3496  unsigned int length = 2 * m_nDrawersFlx;
3497  std::vector<std::string> suffixArr(length, "");
3498  m_nSamplesFlxInDrawer.resize(length);
3499 
3500  for (const std::pair<const unsigned int, unsigned int>& fragAndDrawer : m_drawerFlxMap) {
3501  unsigned int frag = fragAndDrawer.first;
3502  unsigned int ros = frag >> 8;
3503  unsigned int drawer = frag & 0x3F;
3504  unsigned int drawerIndex = fragAndDrawer.second;
3505 
3506  std::ostringstream drawerName;
3507  drawerName << m_rosName[ros];
3508  if (testbeam) {
3509  drawerName << (drawer & 7);
3510  } else {
3511  ++drawer; // count modules from 1
3512  drawerName << std::setw(2) << std::setfill('0') << drawer;
3513  }
3514 
3515  moduleNames.at(drawerIndex) = drawerName.str();
3516  suffixArr.at(drawerIndex) = drawerName.str() + "lo";
3517  suffixArr.at(drawerIndex + m_nDrawersFlx) = drawerName.str() + "hi";
3518 
3519  int nSamples(m_nSamplesFlx);
3520  auto it = m_nSamplesFlxInDrawerMap.find(frag);
3521  if (it != m_nSamplesFlxInDrawerMap.end()) {
3522  nSamples = it->second;
3523  }
3524 
3525  m_nSamplesFlxInDrawer[drawerIndex] = nSamples;
3526  m_nSamplesFlxInDrawer[drawerIndex + m_nDrawersFlx] = nSamples;
3527  }
3528 
3529  m_rodBCIDflxVec.resize(m_nDrawersFlx);
3530  m_sizeflxVec.resize(m_nDrawersFlx);
3531  m_evtflxVec.resize(m_nDrawersFlx);
3532 
3533  for (unsigned int i = 0; i < length; ++i) {
3534 
3535  int nSamplesInDrawer = m_nSamplesFlxInDrawer[i];
3536 
3537  m_eflxfitVec.push_back(std::array<float, MAX_CHAN>());
3538  m_tflxfitVec.push_back(std::array<float, MAX_CHAN>());
3539  m_pedflxfitVec.push_back(std::array<float, MAX_CHAN>());
3540  m_chi2flxfitVec.push_back(std::array<float, MAX_CHAN>());
3541 
3542  m_eflxoptVec.push_back(std::array<float, MAX_CHAN>());
3543  m_tflxoptVec.push_back(std::array<float, MAX_CHAN>());
3544  m_pedflxoptVec.push_back(std::array<float, MAX_CHAN>());
3545  m_chi2flxoptVec.push_back(std::array<float, MAX_CHAN>());
3546 
3547  if (i < m_nDrawersFlx) {
3548  m_mdL1idflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3549  m_mdBcidflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3550  m_mdModuleflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3551  m_mdRunTypeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3552  m_mdPedLoflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3553  m_mdPedHiflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3554  m_mdRunflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3555  m_mdChargeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3556  m_mdChargeTimeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3557  m_mdCapacitorflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3558 
3559  std::string suffix = moduleNames[i];
3560  ATH_MSG_DEBUG( "Adding items for " << suffix );
3561 
3562  if (m_bsInput) {
3563  m_ntuplePtr->Branch(("FlxEvt"+suffix).c_str(), &m_evtflxVec.data()[i]); // int
3564  m_ntuplePtr->Branch(("FlxRodBCID"+suffix).c_str(), &m_rodBCIDflxVec.data()[i]);//int
3565  m_ntuplePtr->Branch(("FlxSize"+suffix).c_str(), &m_sizeflxVec.data()[i]); // short
3566  }
3567 
3568  m_ntuplePtr->Branch(("FlxL1ID"+suffix).c_str(), &m_mdL1idflxVec.back()); // int
3569  m_ntuplePtr->Branch(("FlxBCID"+suffix).c_str(), &m_mdBcidflxVec.back()); // int
3570  m_ntuplePtr->Branch(("FlxModule"+suffix).c_str(), &m_mdModuleflxVec.back()); // int
3571  m_ntuplePtr->Branch(("FlxRun"+suffix).c_str(), &m_mdRunflxVec.back()); // int
3572  m_ntuplePtr->Branch(("FlxRunType"+suffix).c_str(), &m_mdRunTypeflxVec.back()); // int
3573  m_ntuplePtr->Branch(("FlxPedLo"+suffix).c_str(), &m_mdPedLoflxVec.back()); // int
3574  m_ntuplePtr->Branch(("FlxPedHi"+suffix).c_str(), &m_mdPedHiflxVec.back()); // int
3575  m_ntuplePtr->Branch(("FlxCharge"+suffix).c_str(), &m_mdChargeflxVec.back()); // int
3576  m_ntuplePtr->Branch(("FlxChargeTime"+suffix).c_str(), &m_mdChargeTimeflxVec.back()); // int
3577  m_ntuplePtr->Branch(("FlxCapacitor"+suffix).c_str(), &m_mdCapacitorflxVec.back()); // int
3578 
3579  }
3580 
3581  m_gainflxVec.push_back(std::array<int, MAX_CHAN>());
3582  m_sampleflxVec.push_back(std::make_unique<int[]>(MAX_CHAN * nSamplesInDrawer)); // U(48/96,9)
3583 
3584  if (i % m_nDrawersFlx < listSize) {
3585  ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3586 
3587  m_ntuplePtr->Branch(("FlxGain"+suffixArr[i]).c_str(), &m_gainflxVec.back()); // int
3588 
3589  if (nSamplesInDrawer > 0) {
3590  nSampStrFlx = std::to_string(nSamplesInDrawer);
3591  m_ntuplePtr->Branch(("FlxSample" + suffixArr[i]).c_str(), m_sampleflxVec.back().get(),
3592  ("Flxsample" + suffixArr[i] + "[48]["+nSampStrFlx+"]/I").c_str()); // size m_nsample and type int
3593  }
3594 
3595  if (!m_flxFitRawChannelContainerKey.empty()) {
3596  m_ntuplePtr->Branch(("FlxEfit" + suffixArr[i]).c_str(), &m_eflxfitVec.back()); // float
3597  m_ntuplePtr->Branch(("FlxTfit" + suffixArr[i]).c_str(), &m_tflxfitVec.back()); // float
3598  m_ntuplePtr->Branch(("FlxPedfit" + suffixArr[i]).c_str(), &m_pedflxfitVec.back()); // float
3599  m_ntuplePtr->Branch(("FlxChi2fit" + suffixArr[i]).c_str(), &m_chi2flxfitVec.back()); // float
3600  }
3601 
3602  if (!m_flxOptRawChannelContainerKey.empty()) {
3603  m_ntuplePtr->Branch(("FlxEOpt" + suffixArr[i]).c_str(), &m_eflxoptVec.back()); // float
3604  m_ntuplePtr->Branch(("FlxTOpt" + suffixArr[i]).c_str(), &m_tflxoptVec.back()); // float
3605  m_ntuplePtr->Branch(("FlxPedOpt" + suffixArr[i]).c_str(), &m_pedflxoptVec.back()); // float
3606  m_ntuplePtr->Branch(("FlxChi2Opt" + suffixArr[i]).c_str(), &m_chi2flxoptVec.back()); // float
3607  }
3608  }
3609  }
3610 }
3611 
3612 
3613 
3614 void TileTBAANtuple::FELIX_clearBranch(void)
3615 {
3616  clear_init_minus1(m_evtflxVec);
3617  clear_init_minus1(m_rodBCIDflxVec);
3618  clear_init_minus1(m_sizeflxVec);
3619 
3620  clear_init_minus1(m_gainflxVec);
3621  clear_samples(m_sampleflxVec, m_nSamplesFlxInDrawer);
3622 
3623  clear_init_zero(m_eflxfitVec);
3624  clear_init_zero(m_tflxfitVec );
3625  clear_init_zero(m_chi2flxfitVec);
3626  clear_init_zero(m_pedflxfitVec);
3627 
3628  clear_init_zero(m_eflxoptVec);
3629  clear_init_zero(m_tflxoptVec);
3630  clear_init_zero(m_chi2flxoptVec);
3631  clear_init_zero(m_pedflxoptVec);
3632 
3633  clear_init_minus1(m_mdL1idflxVec);
3634  clear_init_minus1(m_mdBcidflxVec);
3635  clear_init_minus1(m_mdModuleflxVec);
3636  clear_init_minus1(m_mdRunTypeflxVec);
3637  clear_init_minus1(m_mdRunflxVec);
3638  clear_init_minus1(m_mdChargeflxVec);
3639  clear_init_minus1(m_mdChargeTimeflxVec);
3640  clear_init_minus1(m_mdCapacitorflxVec);
3641  clear_init_minus1(m_mdPedLoflxVec);
3642  clear_init_minus1(m_mdPedHiflxVec);
3643 }
3644 
3648 
3650 
3651 void TileTBAANtuple::HIT_addBranch(void)
3652 {
3653  m_ehitVec.clear();
3654  m_thitVec.clear();
3655  m_ehitCnt.clear();
3656  m_thitCnt.clear();
3657 
3658  m_ehitVec.reserve(MAX_DRAWERS);
3659  m_thitVec.reserve(MAX_DRAWERS);
3660  m_ehitCnt.reserve(MAX_DRAWERS);
3661  m_thitCnt.reserve(MAX_DRAWERS);
3662 
3663  unsigned int listSize = std::min(m_nDrawers.value(), static_cast<unsigned int>(m_drawerMap.size()));
3664 
3665  if (listSize > 0) {
3666 
3667  std::string digit[10] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
3668  std::vector<std::string> suffixArr;
3669  unsigned int length;
3670  bool testbeam = TileCablingService::getInstance()->getTestBeam();
3671 
3672  length = m_nDrawers;
3673  suffixArr.resize(length);
3674 
3675  for (unsigned int i = 0; i < listSize; ++i) {
3676  unsigned int ros = m_drawerType[i];
3677  unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3678  std::string digits;
3679  if (m_TBperiod >= 2010) {
3680  ++drawer; // count modules from 1
3681  digits = digit[drawer / 10] + digit[drawer % 10];
3682  } else if (testbeam) {
3683  digits = digit[drawer & 7];
3684  } else {
3685  ++drawer; // count modules from 1
3686  digits = digit[drawer / 10] + digit[drawer % 10];
3687  }
3688 
3689  if (ros == 0) {
3690  std::string suff = m_drawerList[i];
3691  suff.replace(suff.find("0x"), 2, "");
3692  suffixArr[i] = suff;
3693  } else {
3694  suffixArr[i] = m_rosName[ros] + digits;
3695  }
3696  }
3697 
3698  for (unsigned int i = 0; i < length; i++) {
3699 
3700  if (i % m_nDrawers < listSize)
3701  ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3702 
3703  m_ehitVec.push_back(std::array<float, MAX_CHAN>());
3704  m_thitVec.push_back(std::array<float, MAX_CHAN>());
3705  m_ehitCnt.push_back(std::array<float, MAX_CHAN>());
3706  m_thitCnt.push_back(std::array<float, MAX_CHAN>());
3707 
3708  if (i%m_nDrawers < listSize) {
3709 
3710  if (!m_hitVectorKey.empty()) {
3711 
3712  if (i % m_nDrawers < listSize)
3713  ATH_MSG_DEBUG( "Adding G4 hit info for " << suffixArr[i] );
3714 
3715  m_ntuplePtr->Branch(("EhitG4"+suffixArr[i]).c_str(),&m_ehitVec.back(),("eHitG4"+suffixArr[i]+"[48]/F").c_str());
3716  m_ntuplePtr->Branch(("ThitG4"+suffixArr[i]).c_str(),&m_thitVec.back(),("tHitG4"+suffixArr[i]+"[48]/F").c_str());
3717  }
3718 
3719  if (!m_hitContainerKey.empty()) {
3720 
3721  if (i % m_nDrawers < listSize)
3722  ATH_MSG_DEBUG( "Adding G4 corrected hit info for " << suffixArr[i] );
3723 
3724  m_ntuplePtr->Branch(("EhitSim"+suffixArr[i]).c_str(),&m_ehitCnt.back(),("eHitSim"+suffixArr[i]+"[48]/F").c_str());
3725  m_ntuplePtr->Branch(("ThitSim"+suffixArr[i]).c_str(),&m_thitCnt.back(),("tHitSim"+suffixArr[i]+"[48]/F").c_str());
3726  }
3727  }
3728  }
3729  }
3730 }
3731 
3736 
3737 void TileTBAANtuple::HIT_clearBranch(void)
3738 {
3739  clear_init_zero(m_ehitVec);
3740  clear_init_zero(m_thitVec);
3741  clear_init_zero(m_ehitCnt);
3742  clear_init_zero(m_thitCnt);
3743 }
3744 
3745 template<typename T>
3746 void TileTBAANtuple::clear_init_minus1(std::vector<T>& vec) {
3747  std::fill(vec.begin(), vec.end(), static_cast<T>(-1));
3748 }
3749 
3750 template<typename T, size_t N>
3751 void TileTBAANtuple::clear_init_minus1(std::vector<std::array<T,N>>& vec) {
3752  for (std::array<T,N>& arr : vec) {
3753  std::fill(arr.begin(), arr.end(), static_cast<T>(-1));
3754  }
3755 }
3756 
3757 template<typename T, size_t N>
3758 void TileTBAANtuple::clear_init_zero(std::vector<std::array<T,N>>& vec) {
3759  for (std::array<T,N>& arr : vec) {
3760  std::fill(arr.begin(), arr.end(), static_cast<T>(0));
3761  }
3762 }
3763 
3764 void TileTBAANtuple::clear_samples(std::vector<std::unique_ptr<int []>> & vec, const std::vector<int>& nsamples, int nchan)
3765 {
3766  for (unsigned int i = 0; i < vec.size(); ++i) {
3767  std::fill(vec[i].get(), vec[i].get() + nsamples.at(i) * nchan, -1);
3768  }
3769 }
3770 
3771 void TileTBAANtuple::setupBeamChambersBeforeTB2015(void) {
3772  // Setup default value for the following properties, if they are not setup via JO
3773  setupPropertyDefaultValue(m_beamBC1X1, -0.938, "BC1X1");
3774  setupPropertyDefaultValue(m_beamBC1X2, 0.1747, "BC1X2");
3775  setupPropertyDefaultValue(m_beamBC1Y1, 0.125, "BC1Y1");
3776  setupPropertyDefaultValue(m_beamBC1Y2, 0.1765, "BC1Y2");
3777  setupPropertyDefaultValue(m_beamBC1Z, 13788.0, "BC1Z");
3778  setupPropertyDefaultValue(m_beamBC1Z_0, 13788.0, "BC1Z_0");
3779  setupPropertyDefaultValue(m_beamBC1Z_90, 13788.0, "BC1Z_90");
3780  setupPropertyDefaultValue(m_beamBC1Z_min90, 13788.0, "BC1Z_min90");
3781 
3782  setupPropertyDefaultValue(m_beamBC2X1, -0.9369, "BC2X1");
3783  setupPropertyDefaultValue(m_beamBC2X2, 0.191, "BC2X2");
3784  setupPropertyDefaultValue(m_beamBC2Y1, -1.29, "BC2Y1");
3785  setupPropertyDefaultValue(m_beamBC2Y2, 0.187, "BC2Y2");
3786  setupPropertyDefaultValue(m_beamBC2Z, 9411.0, "BC2Z");
3787  setupPropertyDefaultValue(m_beamBC2Z_0, 9411.0, "BC2Z_0");
3788  setupPropertyDefaultValue(m_beamBC2Z_90, 9411.0, "BC2Z_90");
3789  setupPropertyDefaultValue(m_beamBC2Z_min90, 9411.0, "BC2Z_min90");
3790 }
3791 
3792 void TileTBAANtuple::setupBeamChambersTB2015(void) {
3793  setupPropertyDefaultValue(m_beamBC1X1, -0.0462586, "BC1X1");
3794  setupPropertyDefaultValue(m_beamBC1X2, -0.175666, "BC1X2");
3795  setupPropertyDefaultValue(m_beamBC1Y1, -0.051923, "BC1Y1");
3796  setupPropertyDefaultValue(m_beamBC1Y2, -0.176809, "BC1Y2");
3797  setupPropertyDefaultValue(m_beamBC1Z, 13000. + 2760, "BC1Z");
3798  setupPropertyDefaultValue(m_beamBC1Z_0, 13788.0, "BC1Z_0");
3799  setupPropertyDefaultValue(m_beamBC1Z_90, 13788.0, "BC1Z_90");
3800  setupPropertyDefaultValue(m_beamBC1Z_min90, 13788.0, "BC1Z_min90");
3801 
3802  setupPropertyDefaultValue(m_beamBC2X1, 0.25202, "BC2X1");
3803  setupPropertyDefaultValue(m_beamBC2X2, -0.18053, "BC2X2");
3804  setupPropertyDefaultValue(m_beamBC2Y1, 0.0431688, "BC2Y1");
3805  setupPropertyDefaultValue(m_beamBC2Y2, -0.181128, "BC2Y2");
3806  setupPropertyDefaultValue(m_beamBC2Z, 2760, "BC2Z");
3807  setupPropertyDefaultValue(m_beamBC2Z_0, 9411.0, "BC2Z_0");
3808  setupPropertyDefaultValue(m_beamBC2Z_90, 9411.0, "BC2Z_90");
3809  setupPropertyDefaultValue(m_beamBC2Z_min90, 9411.0, "BC2Z_min90");
3810 }
3811 
3812 void TileTBAANtuple::setupBeamChambersTB2016_2020(void) {
3813  // 2016 settings:
3814  //
3815  // https://pcata007.cern.ch/elog/TB2016/88
3816  //
3817  //
3818  // The calibration has been done with the following runs :
3819  // BC1:
3820  // Center : 610212
3821  // Left/up : 610210
3822  // Right/down : 610209
3823  //
3824  // BC2:
3825  // Center : 610256
3826  // Left/up : 610321
3827  // Right/down : 610320
3828  //
3829  // Here are the new constants :
3830  //
3831  // BC1
3832  // horizontal slope = -0.171928
3833  // horizontal offset = -0.047624
3834  //
3835  // vertical slope = -0.172942
3836  // vertical offset = -0.0958677
3837  //
3838  // BC2
3839  // horizontal slope = -0.175698
3840  // horizontal offset = -1.04599
3841  //
3842  // vertical slope = -0.174535
3843  // vertical offset = -3.10666
3844 
3845  // June 2016 calibration
3846  //m_beamBC1X1 = -0.047624;
3847  //m_beamBC1X2 = -0.171928;
3848  //m_beamBC1Y1 = -0.0958677;
3849  //m_beamBC1Y2 = -0.172942;
3850  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3851 
3852  //m_beamBC2X1 = -1.04599;
3853  //m_beamBC2X2 = -0.175698;
3854  //m_beamBC2Y1 = -3.10666;
3855  //m_beamBC2Y2 = -0.174535;
3856  //m_beamBC2Z = 2760 /* 2600. */;
3857 
3858  // September 2016 calibration, https://pcata007.cern.ch/elog/TB2016/300 (joakim.olsson@cern.ch)
3859  //m_beamBC1X1 = 0.100857923042;
3860  //m_beamBC1X2 = -0.172098;
3861  //m_beamBC1Y1 = -0.133045996607;
3862  //m_beamBC1Y2 = -0.172855178323;
3863  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3864  //
3865  //m_beamBC2X1 = 0.271555258578 ;
3866  //m_beamBC2X2 = -0.173463 ;
3867  //m_beamBC2Y1 = 0.305483228502;
3868  //m_beamBC2Y2 = -0.173805131744 ;
3869  //m_beamBC2Z = 2760 /* 2600. */;
3870 
3871  // June 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3872  //m_beamBC1X1 = 0.153584934082;
3873  //m_beamBC1X2 = -0.175220;
3874  //m_beamBC1Y1 = -0.493246053303;
3875  //m_beamBC1Y2 = -0.176567356723;
3876  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3877  //
3878  //m_beamBC2X1 = 0.414611893278;
3879  //m_beamBC2X2 = -0.176122;
3880  //m_beamBC2Y1 = 0.150807740888;
3881  //m_beamBC2Y2 = -0.173472808704;
3882  //m_beamBC2Z = 2760 /* 2600. */;
3883 
3884  // August 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3885  //m_beamBC1X1 = 0.181797;
3886  //m_beamBC1X2 = -0.175657;
3887  //m_beamBC1Y1 = -0.128910;
3888  //m_beamBC1Y2 = -0.175965;
3889  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3890  //
3891  //m_beamBC2X1 = 0.611502;
3892  //m_beamBC2X2 = -0.183116;
3893  //m_beamBC2Y1 = 0.541212;
3894  //m_beamBC2Y2 = -0.183115;
3895  //m_beamBC2Z = 2760 /* 2600. */;
3896 
3897  // September 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3898  //m_beamBC1X1 = 0.181797;
3899  //m_beamBC1X2 = -0.175657;
3900  //m_beamBC1Y1 = -0.128910;
3901  //m_beamBC1Y2 = -0.175965;
3902  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3903 
3904  //m_beamBC2X1 = 0.622896039922;
3905  //m_beamBC2X2 = -0.176735;
3906  //m_beamBC2Y1 = 0.195954125116;
3907  //m_beamBC2Y2 = -0.176182117624;
3908  //m_beamBC2Z = 2760 /* 2600. */;
3909 
3910  // September 2017 calibration with additional precision from Survey
3911  setupPropertyDefaultValue(m_beamBC1X1, 0.681797, "BC1X1");
3912  setupPropertyDefaultValue(m_beamBC1X2, -0.175657, "BC1X2");
3913  setupPropertyDefaultValue(m_beamBC1Y1, -2.02891, "BC1Y1");
3914  setupPropertyDefaultValue(m_beamBC1Y2, -0.175965, "BC1Y2");
3915  setupPropertyDefaultValue(m_beamBC1Z, 17348.8, "BC1Z");
3916  setupPropertyDefaultValue(m_beamBC1Z_0, 17348.8, "BC1Z_0");
3917  setupPropertyDefaultValue(m_beamBC1Z_90, 15594.05, "BC1Z_90");
3918  setupPropertyDefaultValue(m_beamBC1Z_min90, 15571.8, "BC1Z_min90");
3919 
3920  setupPropertyDefaultValue(m_beamBC2X1, -24.377104, "BC2X1");
3921  setupPropertyDefaultValue(m_beamBC2X2, -0.176735, "BC2X2");
3922  setupPropertyDefaultValue(m_beamBC2Y1, 17.895954, "BC2Y1");
3923  setupPropertyDefaultValue(m_beamBC2Y2, -0.176182117624, "BC2Y2");
3924  setupPropertyDefaultValue(m_beamBC2Z, 4404.2, "BC2Z");
3925  setupPropertyDefaultValue(m_beamBC2Z_0, 4420.7, "BC2Z_0");
3926  setupPropertyDefaultValue(m_beamBC2Z_90, 2649.45, "BC2Z_90");
3927  setupPropertyDefaultValue(m_beamBC2Z_min90, 2627.2, "BC2Z_min90");
3928 
3929 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileTBAANtuple::m_sampleflxVec
std::vector< std::unique_ptr< int[]> > m_sampleflxVec
Definition: TileTBAANtuple.h:512
TileTBAANtuple::m_feCRCVec
std::vector< std::array< int, MAX_DMU > > m_feCRCVec
Definition: TileTBAANtuple.h:527
TileTBAANtuple::m_beamBC1Z_0
Gaudi::Property< float > m_beamBC1Z_0
Definition: TileTBAANtuple.h:209
TileTBAANtuple::m_xCha1
float m_xCha1
Definition: TileTBAANtuple.h:485
TileTBAANtuple::m_pedflxoptVec
std::vector< std::array< float, MAX_CHAN > > m_pedflxoptVec
Definition: TileTBAANtuple.h:557
TileTBAANtuple::m_coincTrig4
std::array< unsigned int, 96 > m_coincTrig4
Definition: TileTBAANtuple.h:587
TileRawChannelContainer
Definition: TileRawChannelContainer.h:13
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
COIN_TRIG7_FRAG
#define COIN_TRIG7_FRAG
Definition: TileTBFrag.h:38
TileSamplingFraction::getSamplingFraction
float getSamplingFraction(unsigned int drawerIdx, unsigned int channel) const
Return Tile Calorimeter sampling fraction.
Definition: TileSamplingFraction.h:53
TileTBAANtuple::m_coincFlag7
int m_coincFlag7
Definition: TileTBAANtuple.h:599
TileTBAANtuple::m_coincTrig3
std::array< unsigned int, 96 > m_coincTrig3
Definition: TileTBAANtuple.h:586
TileTBAANtuple::COINCBOARD_clearBranch
void COINCBOARD_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree COINCBOARD va...
Definition: TileTBAANtuple.cxx:3112
TileTBAANtuple::m_beamIdList
bool m_beamIdList[32]
Definition: TileTBAANtuple.h:606
TileRawChannelUnit
Definition: TileRawChannelUnit.h:13
TileTBAANtuple::m_beamBC0Z
Gaudi::Property< float > m_beamBC0Z
Definition: TileTBAANtuple.h:202
TileTBAANtuple::m_yChN2
float m_yChN2
Definition: TileTBAANtuple.h:479
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
TileTBAANtuple::m_ecal
std::array< float, 8 > m_ecal
Definition: TileTBAANtuple.h:372
TileLaserObject::getTDC
int getTDC(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:209
TileTBAANtuple::m_treeSize
Gaudi::Property< Long64_t > m_treeSize
Definition: TileTBAANtuple.h:179
TileTBAANtuple::m_mdChargeTimeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdChargeTimeflxVec
Definition: TileTBAANtuple.h:576
TileTBAANtuple::m_s1cou
uint32_t m_s1cou
Definition: TileTBAANtuple.h:452
TileTBAANtuple::m_calibMode
Gaudi::Property< bool > m_calibMode
Definition: TileTBAANtuple.h:168
TileTBAANtuple::m_beamBC1Y2
Gaudi::Property< float > m_beamBC1Y2
Definition: TileTBAANtuple.h:207
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
COMMON_TDC2_FRAG
#define COMMON_TDC2_FRAG
Definition: TileTBFrag.h:47
TileTBAANtuple::m_las_D4_AlphaPed
double m_las_D4_AlphaPed
Definition: TileTBAANtuple.h:412
TileTBAANtuple::m_coincFlag8
int m_coincFlag8
Definition: TileTBAANtuple.h:600
COMMON_PTN_FRAG
#define COMMON_PTN_FRAG
Definition: TileTBFrag.h:48
TileTBAANtuple::m_BarEne
std::array< float, 3 > m_BarEne
Definition: TileTBAANtuple.h:580
TileTBAANtuple::m_frBCID
std::vector< int > m_frBCID
Definition: TileTBAANtuple.h:363
CaloCell_ID_FCS::TileExt2
@ TileExt2
Definition: FastCaloSim_CaloCell_ID.h:39
TileTBAANtuple::m_chi2FlatVec
std::vector< std::array< float, MAX_CHAN > > m_chi2FlatVec
Definition: TileTBAANtuple.h:533
TileTBAANtuple::m_cellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_cellContainerKey
Definition: TileTBAANtuple.h:153
hotSpotInTAG.suffix
string suffix
Definition: hotSpotInTAG.py:186
TileTBAANtuple::m_DMUSstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUSstrobeErrVec
Definition: TileTBAANtuple.h:520
constants.EMB1
int EMB1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:53
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
TileTBAANtuple::m_xChN2
float m_xChN2
Definition: TileTBAANtuple.h:478
TileTBAANtuple::m_las_D4_ADC
int m_las_D4_ADC
Definition: TileTBAANtuple.h:387
TileTBAANtuple::m_las_D1_ADC
int m_las_D1_ADC
Definition: TileTBAANtuple.h:384
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
ADD_FADC_FRAG
#define ADD_FADC_FRAG
Definition: TileTBFrag.h:29
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TileTBAANtuple::m_yChN1
float m_yChN1
Definition: TileTBAANtuple.h:481
TileTBAANtuple::m_gainflxVec
std::vector< std::array< int, MAX_CHAN > > m_gainflxVec
Definition: TileTBAANtuple.h:511
TileTBAANtuple::m_slinkCRCVec
std::vector< std::array< int, 2 > > m_slinkCRCVec
Definition: TileTBAANtuple.h:524
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
Definition: PathResolver.cxx:251
TileTBAANtuple::m_muBack
std::array< float, 14 > m_muBack
Definition: TileTBAANtuple.h:368
TileTBAANtuple::m_las_ReqAmp
double m_las_ReqAmp
Definition: TileTBAANtuple.h:381
TileTBAANtuple::m_coincFlag4
int m_coincFlag4
Definition: TileTBAANtuple.h:596
TileTBAANtuple::m_las_PMT1_Ped
double m_las_PMT1_Ped
Definition: TileTBAANtuple.h:425
TileTBAANtuple::checkIsPropertySetup
void checkIsPropertySetup(float property, const std::string &name)
Definition: TileTBAANtuple.h:322
TileTBAANtuple::m_tof
std::array< int, 16 > m_tof
Definition: TileTBAANtuple.h:468
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
TileTBAANtuple::m_chi2cVec
std::vector< std::array< float, MAX_CHAN > > m_chi2cVec
Definition: TileTBAANtuple.h:541
TileTBAANtuple::m_mdRunTypeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdRunTypeflxVec
Definition: TileTBAANtuple.h:571
TileTBAANtuple::m_DMUparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUparityErrVec
Definition: TileTBAANtuple.h:517
TileTBAANtuple::m_tscTOF
int m_tscTOF
Definition: TileTBAANtuple.h:474
TileTBAANtuple::m_beamBC2Y2
Gaudi::Property< float > m_beamBC2Y2
Definition: TileTBAANtuple.h:216
TileTBAANtuple::FELIX_addBranch
void FELIX_addBranch(void)
Definition: TileTBAANtuple.cxx:3462
TileTBAANtuple::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition: TileTBAANtuple.h:156
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileTBAANtuple::m_sizeflxVec
std::vector< short > m_sizeflxVec
Definition: TileTBAANtuple.h:509
make_unique
std::unique_ptr< T > make_unique(Args &&... args)
Definition: SkimmingToolEXOT5.cxx:23
TileTBAANtuple::m_flatRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flatRawChannelContainerKey
Definition: TileTBAANtuple.h:123
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
TileTBAANtuple::m_las_PMT2_Ped
double m_las_PMT2_Ped
Definition: TileTBAANtuple.h:426
TileTBAANtuple::m_drawerFlxMap
std::map< unsigned int, unsigned int, std::less< unsigned int > > m_drawerFlxMap
Definition: TileTBAANtuple.h:603
TileTBAANtuple::m_las_Filt
int m_las_Filt
Definition: TileTBAANtuple.h:380
index
Definition: index.py:1
TileTBAANtuple::m_drawerType
Gaudi::Property< std::vector< int > > m_drawerType
Definition: TileTBAANtuple.h:185
TileTBAANtuple::m_rodBCIDVec
std::vector< short > m_rodBCIDVec
Definition: TileTBAANtuple.h:504
TileTBAANtuple::storeHitVector
StatusCode storeHitVector(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:1808
CaloCell_ID_FCS::TileExt0
@ TileExt0
Definition: FastCaloSim_CaloCell_ID.h:37
TileTBAANtuple::m_efitVec
std::vector< std::array< float, MAX_CHAN > > m_efitVec
Definition: TileTBAANtuple.h:534
CaloCell_ID_FCS::TileBar1
@ TileBar1
Definition: FastCaloSim_CaloCell_ID.h:32
TileLaserObject::getPumpDiodeTemp
double getPumpDiodeTemp() const
Definition: TileLaserObject.h:234
TileTBAANtuple::m_laserObjectKey
SG::ReadHandleKey< TileLaserObject > m_laserObjectKey
Definition: TileTBAANtuple.h:144
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
TileTBAANtuple::m_hitContainerKey
SG::ReadHandleKey< TileHitContainer > m_hitContainerKey
Definition: TileTBAANtuple.h:147
TileTBAANtuple::m_evBCID
std::vector< int > m_evBCID
Definition: TileTBAANtuple.h:361
TileTBAANtuple::m_DMUmemoryErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUmemoryErrVec
Definition: TileTBAANtuple.h:518
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
TileTBAANtuple::m_coincTrig7
std::array< unsigned int, 96 > m_coincTrig7
Definition: TileTBAANtuple.h:590
TileTBAANtuple::m_mdBcidflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdBcidflxVec
Definition: TileTBAANtuple.h:569
TileTBAANtuple::m_chi2OptVec
std::vector< std::array< float, MAX_CHAN > > m_chi2OptVec
Definition: TileTBAANtuple.h:545
tree
TChain * tree
Definition: tile_monitor.h:30
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
TileTBAANtuple::m_pedFlatVec
std::vector< std::array< float, MAX_CHAN > > m_pedFlatVec
Definition: TileTBAANtuple.h:532
TileTBAANtuple::CISPAR_addBranch
void CISPAR_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variabl...
Definition: TileTBAANtuple.cxx:2796
AtlasHitsVector
Definition: AtlasHitsVector.h:33
TileTBAANtuple::m_calibrateEnergyThisEvent
bool m_calibrateEnergyThisEvent
Definition: TileTBAANtuple.h:619
TileTBAANtuple::m_btdcNhit
int m_btdcNhit[16]
Definition: TileTBAANtuple.h:475
skel.it
it
Definition: skel.GENtoEVGEN.py:407
TileTBAANtuple::QDC_addBranch
void QDC_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add QDC variables to th...
Definition: TileTBAANtuple.cxx:2554
TileLaserObject::getAlpha
double getAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:138
CaloID.h
TileTBAANtuple::m_ntuplePtr
TTree * m_ntuplePtr
Definition: TileTBAANtuple.h:345
TileTBAANtuple::m_ROD_DMUBCIDVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUBCIDVec
Definition: TileTBAANtuple.h:560
TileTBAANtuple::m_muBackHit
float m_muBackHit
Definition: TileTBAANtuple.h:366
TileTBAANtuple::m_coincFlag3
int m_coincFlag3
Definition: TileTBAANtuple.h:595
TileTBAANtuple::m_samplingFractionKey
SG::ReadCondHandleKey< TileSamplingFraction > m_samplingFractionKey
Name of TileSamplingFraction in condition store.
Definition: TileTBAANtuple.h:111
WRONG_SAMPLE
#define WRONG_SAMPLE(frag, chan, size)
Definition: TileTBAANtuple.cxx:47
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:210
TileTBAANtuple::m_xImp_0
float m_xImp_0
Definition: TileTBAANtuple.h:496
TileTBAANtuple::m_mdCapacitorflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdCapacitorflxVec
Definition: TileTBAANtuple.h:577
TileTBAANtuple::m_pedOptVec
std::vector< std::array< float, MAX_CHAN > > m_pedOptVec
Definition: TileTBAANtuple.h:544
PlotCalibFromCool.nchan
nchan
Definition: PlotCalibFromCool.py:564
TileLaserObject::getDiodeCurrOrd
double getDiodeCurrOrd() const
Definition: TileLaserObject.h:219
TileTBAANtuple::m_eta
float m_eta
Definition: TileTBAANtuple.h:610
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TileTBAANtuple::m_ntupleID
Gaudi::Property< std::string > m_ntupleID
Definition: TileTBAANtuple.h:181
TileTBAANtuple::m_rodBCIDflxVec
std::vector< short > m_rodBCIDflxVec
Definition: TileTBAANtuple.h:508
TileHWID::frag
int frag(const HWIdentifier &id) const
extract frag field from HW identifier
Definition: TileHWID.h:181
TileTBAANtuple::m_beamBC0X2
Gaudi::Property< float > m_beamBC0X2
Definition: TileTBAANtuple.h:199
TileTBAANtuple::storeDigitsFlx
StatusCode storeDigitsFlx(const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey)
Definition: TileTBAANtuple.cxx:1635
DIGI_PAR_FRAG
#define DIGI_PAR_FRAG
Definition: TileTBFrag.h:41
COIN_TRIG8_FRAG
#define COIN_TRIG8_FRAG
Definition: TileTBFrag.h:39
ADDR_ADC_FRAG
#define ADDR_ADC_FRAG
Definition: TileTBFrag.h:26
TileTBAANtuple::m_drawerMap
std::map< unsigned int, unsigned int, std::less< unsigned int > > m_drawerMap
Definition: TileTBAANtuple.h:602
COMMON_TOF_FRAG
#define COMMON_TOF_FRAG
Definition: TileTBFrag.h:45
Tile_Base_ID::HIGHGAIN
@ HIGHGAIN
Definition: Tile_Base_ID.h:57
TileTBAANtuple::m_muBackSum
float m_muBackSum
Definition: TileTBAANtuple.h:367
TileTBAANtuple::m_finalUnit
Gaudi::Property< int > m_finalUnit
Definition: TileTBAANtuple.h:167
TileTBAANtuple::m_las_D1_AlphaPed
double m_las_D1_AlphaPed
Definition: TileTBAANtuple.h:409
TileTBAANtuple::m_mdModuleflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdModuleflxVec
Definition: TileTBAANtuple.h:570
TileTBAANtuple::m_tfitcVec
std::vector< std::array< float, MAX_CHAN > > m_tfitcVec
Definition: TileTBAANtuple.h:539
TileCalibUtils.h
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:9
TileTBAANtuple::m_yImp_90
float m_yImp_90
Definition: TileTBAANtuple.h:499
TileRawChannelUnit::OnlineADCcounts
@ OnlineADCcounts
Definition: TileRawChannelUnit.h:21
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
COMMON_ADC1_FRAG
#define COMMON_ADC1_FRAG
Definition: TileTBFrag.h:43
LASE_ADC_FRAG
#define LASE_ADC_FRAG
Definition: TileTBFrag.h:28
TileTBAANtuple::m_evtVec
std::vector< int > m_evtVec
Definition: TileTBAANtuple.h:503
TileTBAANtuple::HIT_addBranch
void HIT_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree HIT variables ...
Definition: TileTBAANtuple.cxx:3651
TileTBAANtuple::m_coincTrig6
std::array< unsigned int, 96 > m_coincTrig6
Definition: TileTBAANtuple.h:589
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
TileTBAANtuple::m_las_Temperature
double m_las_Temperature
Definition: TileTBAANtuple.h:431
TileTBAANtuple::TileTBAANtuple
TileTBAANtuple(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TileTBAANtuple.cxx:82
TileTBAANtuple::m_s2extra
int m_s2extra
Definition: TileTBAANtuple.h:462
TileTBAANtuple::LASER_clearBranch
void LASER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree LASER variabl...
Definition: TileTBAANtuple.cxx:2709
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TileTBAANtuple::m_las_PMT1_ADC
int m_las_PMT1_ADC
Definition: TileTBAANtuple.h:419
TileTBAANtuple::m_yImp_0
float m_yImp_0
Definition: TileTBAANtuple.h:497
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
TileTBAANtuple::m_eflxfitVec
std::vector< std::array< float, MAX_CHAN > > m_eflxfitVec
Definition: TileTBAANtuple.h:550
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
TileTBAANtuple::m_xCha0
float m_xCha0
Definition: TileTBAANtuple.h:482
SG::ReadHandleKey< TileRawChannelContainer >
TileTBAANtuple::ntuple_clear
StatusCode ntuple_clear()
Definition: TileTBAANtuple.cxx:1969
TileDigitsContainer
Definition: TileDigitsContainer.h:13
TileHitCollection
Definition: TileHitCollection.h:12
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
TileTBAANtuple::m_las_D3_AlphaPed_RMS
double m_las_D3_AlphaPed_RMS
Definition: TileTBAANtuple.h:416
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
TileTBAANtuple::m_beamBN1X2
Gaudi::Property< float > m_beamBN1X2
Definition: TileTBAANtuple.h:194
HWIdentifier
Definition: HWIdentifier.h:13
TileTBAANtuple::m_DMUheaderVec
std::vector< std::array< uint32_t, MAX_DMU > > m_DMUheaderVec
Definition: TileTBAANtuple.h:515
TileTBAANtuple::m_commonPU
int m_commonPU
Definition: TileTBAANtuple.h:441
TileTBAANtuple::m_muHalo
uint32_t m_muHalo
Definition: TileTBAANtuple.h:459
TileTBAANtuple::m_bsInput
Gaudi::Property< bool > m_bsInput
Definition: TileTBAANtuple.h:171
TileTBAANtuple::ENETOTAL_clearBranch
void ENETOTAL_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ENETOTAL vari...
Definition: TileTBAANtuple.cxx:3052
TileTBAANtuple::m_yCha2_0
float m_yCha2_0
Definition: TileTBAANtuple.h:492
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:134
TileTBAANtuple::m_las_MeasAmp
double m_las_MeasAmp
Definition: TileTBAANtuple.h:382
TileTBAANtuple::execute
virtual StatusCode execute() override
Definition: TileTBAANtuple.cxx:361
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileTBAANtuple::m_pedflxfitVec
std::vector< std::array< float, MAX_CHAN > > m_pedflxfitVec
Definition: TileTBAANtuple.h:553
TileHit::size
int size(void) const
Return length of energy/time vectors
Definition: TileSimEvent/TileSimEvent/TileHit.h:94
ReadCondHandle.h
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
TileTBAANtuple::m_xCha2_0
float m_xCha2_0
Definition: TileTBAANtuple.h:491
TileTBAANtuple::m_cher1
uint32_t m_cher1
Definition: TileTBAANtuple.h:455
TileID.h
BEAM_ADC_FRAG
#define BEAM_ADC_FRAG
Definition: TileTBFrag.h:24
TileTBAANtuple::m_useDspUnits
Gaudi::Property< bool > m_useDspUnits
Definition: TileTBAANtuple.h:166
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TileTBAANtuple::m_beamBN2X2
Gaudi::Property< float > m_beamBN2X2
Definition: TileTBAANtuple.h:189
TileTBAANtuple::m_beamBC2Z
Gaudi::Property< float > m_beamBC2Z
Definition: TileTBAANtuple.h:217
TileTBAANtuple::m_mdPedHiflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdPedHiflxVec
Definition: TileTBAANtuple.h:573
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_saveFelixData
bool m_saveFelixData
Definition: TileTBAANtuple.h:633
CaloCell_ID.h
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
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:3764
TileLaserObject::getPMADC
int getPMADC(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:195
TileTBAANtuple::m_tflxfitVec
std::vector< std::array< float, MAX_CHAN > > m_tflxfitVec
Definition: TileTBAANtuple.h:551
COMMON_TDC1_FRAG
#define COMMON_TDC1_FRAG
Definition: TileTBFrag.h:46
TileTBAANtuple::ENETOTAL_addBranch
void ENETOTAL_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree ENETOTAL varia...
Definition: TileTBAANtuple.cxx:3036
TileLaserObject::getFiltNumber
int getFiltNumber() const
Definition: TileLaserObject.h:229
TileTBAANtuple::m_lasFlag
int m_lasFlag
Definition: TileTBAANtuple.h:433
TileTBAANtuple::clear_init_zero
void clear_init_zero(std::vector< std::array< T, N >> &vec)
Definition: TileTBAANtuple.cxx:3758
TileTBAANtuple::ECAL_clearBranch
void ECAL_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ECAL variable...
Definition: TileTBAANtuple.cxx:2605
TileTBAANtuple::m_eneVec
std::vector< std::array< float, MAX_CHAN > > m_eneVec
Definition: TileTBAANtuple.h:530
TileLaserObject::getSigmaPedAlpha
double getSigmaPedAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:180
TileTBAANtuple::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition: TileTBAANtuple.h:342
TileTBAANtuple::m_beamBN1Y2
Gaudi::Property< float > m_beamBN1Y2
Definition: TileTBAANtuple.h:196
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
TileTBAANtuple::m_dmuMaskVec
std::vector< std::array< int, 2 > > m_dmuMaskVec
Definition: TileTBAANtuple.h:523
TileTBAANtuple::m_yImp_min90
float m_yImp_min90
Definition: TileTBAANtuple.h:501
TileTBAANtuple::m_s3extra
int m_s3extra
Definition: TileTBAANtuple.h:463
TileTBAANtuple::m_beamBN1X1
Gaudi::Property< float > m_beamBN1X1
Definition: TileTBAANtuple.h:193
TileTBAANtuple::m_dspRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_dspRawChannelContainerKey
Definition: TileTBAANtuple.h:132
TileTBAANtuple::m_cher3
uint32_t m_cher3
Definition: TileTBAANtuple.h:457
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TileTBAANtuple::FELIX_clearBranch
void FELIX_clearBranch(void)
Definition: TileTBAANtuple.cxx:3614
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
TileTBAANtuple::MAX_DMU
@ MAX_DMU
Definition: TileTBAANtuple.h:106
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
TileTBAANtuple::setupBeamChambersBeforeTB2015
void setupBeamChambersBeforeTB2015(void)
Definition: TileTBAANtuple.cxx:3771
TileTBAANtuple::m_beamBN2Y1
Gaudi::Property< float > m_beamBN2Y1
Definition: TileTBAANtuple.h:190
TileTBAANtuple::m_yCha1_0
float m_yCha1_0
Definition: TileTBAANtuple.h:490
FRAG_FOUND
#define FRAG_FOUND(frag, chan, size)
Definition: TileTBAANtuple.cxx:58
TileTBAANtuple::m_las3
float m_las3
Definition: TileTBAANtuple.h:437
TileTBAANtuple::m_tjitter
int m_tjitter
Definition: TileTBAANtuple.h:473
TileTBAANtuple::m_ExtEne
std::array< float, 3 > m_ExtEne
Definition: TileTBAANtuple.h:581
TileTBAANtuple::m_evTime
int m_evTime
Definition: TileTBAANtuple.h:352
TileTBAANtuple::m_calibrateEnergy
Gaudi::Property< bool > m_calibrateEnergy
Definition: TileTBAANtuple.h:165
TileTBAANtuple::m_beamBC2Z_0
Gaudi::Property< float > m_beamBC2Z_0
Definition: TileTBAANtuple.h:218
TileTBAANtuple::drawerMap_iterator
std::map< unsigned int, unsigned int, std::less< unsigned int > >::iterator drawerMap_iterator
Definition: TileTBAANtuple.h:604
TileHWID.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileTBAANtuple::setupBeamChambersTB2015
void setupBeamChambersTB2015(void)
Definition: TileTBAANtuple.cxx:3792
TileTBAANtuple::m_btdc2
std::array< int, 16 > m_btdc2
Definition: TileTBAANtuple.h:470
Trk::index1
@ index1
Definition: BoundarySurfaceFace.h:48
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
TileTBAANtuple::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileTBAANtuple.h:626
constants.EMB2
int EMB2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:54
TileTBAANtuple::m_beamBC1X2
Gaudi::Property< float > m_beamBC1X2
Definition: TileTBAANtuple.h:205
TileTBAANtuple::m_las_D1_Ped
double m_las_D1_Ped
Definition: TileTBAANtuple.h:389
TileCablingService.h
TileTBAANtuple::m_tDspVec
std::vector< std::array< float, MAX_CHAN > > m_tDspVec
Definition: TileTBAANtuple.h:547
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
TileSamplingFraction
Condition object to keep and provide Tile Calorimeter sampling fraction and number of photoelectrons.
Definition: TileSamplingFraction.h:16
TileTBAANtuple::m_runNumber
int m_runNumber
Definition: TileTBAANtuple.h:609
TileTBAANtuple::setupPropertyDefaultValue
void setupPropertyDefaultValue(float property, float defaultValue, const std::string &name)
Definition: TileTBAANtuple.h:328
COIN_TRIG6_FRAG
#define COIN_TRIG6_FRAG
Definition: TileTBFrag.h:37
TileTBAANtuple::m_nSamplesFlx
Gaudi::Property< int > m_nSamplesFlx
Definition: TileTBAANtuple.h:174
TileTBAANtuple::MAX_MINIDRAWER
@ MAX_MINIDRAWER
Definition: TileTBAANtuple.h:106
TileTBAANtuple::m_theta
float m_theta
Definition: TileTBAANtuple.h:611
lumiFormat.i
int i
Definition: lumiFormat.py:85
TileTBAANtuple::m_chi2Vec
std::vector< std::array< float, MAX_CHAN > > m_chi2Vec
Definition: TileTBAANtuple.h:537
COIN_TRIG1_FRAG
#define COIN_TRIG1_FRAG
Definition: TileTBFrag.h:32
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
TileTBAANtuple::m_evType
std::vector< int > m_evType
Definition: TileTBAANtuple.h:362
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_flxOptRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flxOptRawChannelContainerKey
Definition: TileTBAANtuple.h:141
TileTBAANtuple::m_tileID
const TileID * m_tileID
Definition: TileTBAANtuple.h:625
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
TileTBAANtuple::m_evtflxVec
std::vector< int > m_evtflxVec
Definition: TileTBAANtuple.h:507
TileTBAANtuple::m_sampleVec
std::vector< std::unique_ptr< int[]> > m_sampleVec
Definition: TileTBAANtuple.h:526
TileTBAANtuple::m_las0
float m_las0
Definition: TileTBAANtuple.h:434
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TileTBAANtuple::m_beamBN1Y1
Gaudi::Property< float > m_beamBN1Y1
Definition: TileTBAANtuple.h:195
TileRawDataContainer::get_bsflags
uint32_t get_bsflags() const
Definition: TileRawDataContainer.h:64
CaloCell_ID_FCS::TileGap2
@ TileGap2
Definition: FastCaloSim_CaloCell_ID.h:35
TileTBAANtuple::BEAM_addBranch
void BEAM_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree BEAM variables...
Definition: TileTBAANtuple.cxx:2822
WRONG_CHANNEL
#define WRONG_CHANNEL(frag, chan)
Definition: TileTBAANtuple.cxx:53
TileRawChannelUnit::OnlineOffset
@ OnlineOffset
Definition: TileRawChannelUnit.h:25
TileTBAANtuple::m_btdcNchMultiHit
int m_btdcNchMultiHit[2]
Definition: TileTBAANtuple.h:476
TileTBAANtuple::digiChannel2PMT
int digiChannel2PMT(int fragType, int chan)
Definition: TileTBAANtuple.h:296
TileTBAANtuple::m_muTag
uint32_t m_muTag
Definition: TileTBAANtuple.h:458
TileTBAANtuple::m_btdc
std::vector< std::vector< int > > * m_btdc
Definition: TileTBAANtuple.h:472
TileTBAANtuple::m_eventsPerFile
Gaudi::Property< int > m_eventsPerFile
Definition: TileTBAANtuple.h:178
TileTBAANtuple::m_ROD_DMUMaskVec
std::vector< std::array< short, 2 > > m_ROD_DMUMaskVec
Definition: TileTBAANtuple.h:566
TileTBAANtuple::m_mdPedLoflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdPedLoflxVec
Definition: TileTBAANtuple.h:572
TileTBAANtuple::initListFlx
StatusCode initListFlx(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:2305
TileTBAANtuple::m_beamBN2Y2
Gaudi::Property< float > m_beamBN2Y2
Definition: TileTBAANtuple.h:191
TileTBAANtuple::HIT_clearBranch
void HIT_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree HIT variable...
Definition: TileTBAANtuple.cxx:3737
CopyBlobFromCool.suff
suff
Definition: CopyBlobFromCool.py:121
TileTBAANtuple::setupBeamChambersTB2016_2020
void setupBeamChambersTB2016_2020(void)
Definition: TileTBAANtuple.cxx:3812
TileTBAANtuple::CheckDMUParity
short CheckDMUParity(uint32_t header)
Parity of the DMU header should be odd.
Definition: TileTBAANtuple.h:311
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
TileRawChannelUnit::MegaElectronVolts
@ MegaElectronVolts
Definition: TileRawChannelUnit.h:20
TileTBAANtuple::m_nDrawersFlx
Gaudi::Property< unsigned int > m_nDrawersFlx
Definition: TileTBAANtuple.h:176
TileTBAANtuple::m_drawerList
Gaudi::Property< std::vector< std::string > > m_drawerList
Definition: TileTBAANtuple.h:184
TileTBAANtuple::m_digitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
Definition: TileTBAANtuple.h:114
TileRawChannel
Definition: TileRawChannel.h:35
TileTBAANtuple::m_yImp
float m_yImp
Definition: TileTBAANtuple.h:494
TileTBAANtuple::m_beamElemContainerKey
SG::ReadHandleKey< TileBeamElemContainer > m_beamElemContainerKey
Definition: TileTBAANtuple.h:120
TileTBAANtuple::initialize
virtual StatusCode initialize() override
Definition: TileTBAANtuple.cxx:102
TileTBAANtuple::m_streamName
Gaudi::Property< std::string > m_streamName
Definition: TileTBAANtuple.h:180
TileTBAANtuple::m_beamBC2Z_min90
Gaudi::Property< float > m_beamBC2Z_min90
Definition: TileTBAANtuple.h:220
TileTBAANtuple::m_ehitVec
std::vector< std::array< float, MAX_CHAN > > m_ehitVec
Definition: TileTBAANtuple.h:614
TileTBAANtuple::m_l1ID
std::vector< int > m_l1ID
Definition: TileTBAANtuple.h:359
TileTBAANtuple::m_coincTrig2
std::array< unsigned int, 96 > m_coincTrig2
Definition: TileTBAANtuple.h:585
TileTBAANtuple.h
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:239
TileTBAANtuple::m_beamBC1Z
Gaudi::Property< float > m_beamBC1Z
Definition: TileTBAANtuple.h:208
BEAM_TDC_FRAG
#define BEAM_TDC_FRAG
Definition: TileTBFrag.h:23
TileTBAANtuple::storeCells
StatusCode storeCells(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:2129
TileTBAANtuple::m_beamBC2X1
Gaudi::Property< float > m_beamBC2X1
Definition: TileTBAANtuple.h:213
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
TileTBAANtuple::m_s3cou
uint32_t m_s3cou
Definition: TileTBAANtuple.h:454
TileTBAANtuple::m_cabling
const TileCablingService * m_cabling
Definition: TileTBAANtuple.h:627
TrigInDetValidation_Base.malloc
malloc
Definition: TrigInDetValidation_Base.py:132
TileTBAANtuple::m_completeNtuple
Gaudi::Property< bool > m_completeNtuple
Definition: TileTBAANtuple.h:170
TileTBAANtuple::initNTuple
StatusCode initNTuple(void)
Definition: TileTBAANtuple.cxx:2019
TileTBAANtuple::m_beamBC0Y1
Gaudi::Property< float > m_beamBC0Y1
Definition: TileTBAANtuple.h:200
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:79
TileTBAANtuple::m_nSamplesInDrawerMap
std::map< int, int > m_nSamplesInDrawerMap
Definition: TileTBAANtuple.h:629
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
TileTBAANtuple::m_sizeVec
std::vector< short > m_sizeVec
Definition: TileTBAANtuple.h:505
TileTBAANtuple::m_beamBN2X1
Gaudi::Property< float > m_beamBN2X1
Definition: TileTBAANtuple.h:188
TileTBAANtuple::m_coincFlag6
int m_coincFlag6
Definition: TileTBAANtuple.h:598
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:233
TileTBAANtuple::MUON_clearBranch
void MUON_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree MUON variable...
Definition: TileTBAANtuple.cxx:2593
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TileTBAANtuple::m_evtNr
int m_evtNr
Definition: TileTBAANtuple.h:349
TileTBAANtuple::m_coincTrig5
std::array< unsigned int, 96 > m_coincTrig5
Definition: TileTBAANtuple.h:588
TileTBAANtuple::m_digitsContainerFlxKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerFlxKey
Definition: TileTBAANtuple.h:117
TileTBAANtuple::m_nSamplesInDrawer
std::vector< int > m_nSamplesInDrawer
Definition: TileTBAANtuple.h:631
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
TileTBAANtuple::m_DMUformatErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUformatErrVec
Definition: TileTBAANtuple.h:516
TileTBAANtuple::m_nDrawers
Gaudi::Property< unsigned int > m_nDrawers
Definition: TileTBAANtuple.h:175
TileBeamElemContainer
Definition: TileBeamElemContainer.h:13
TileTBAANtuple::DIGI_addBranch
void DIGI_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree DIGI variables...
Definition: TileTBAANtuple.cxx:3125
TileTBAANtuple::m_qdc
std::array< uint32_t, 33 > m_qdc
Definition: TileTBAANtuple.h:375
TileTBAANtuple::m_las_D4_Ped
double m_las_D4_Ped
Definition: TileTBAANtuple.h:392
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
CaloCell_ID_FCS::TileGap1
@ TileGap1
Definition: FastCaloSim_CaloCell_ID.h:34
TileTBAANtuple::m_xImp_90
float m_xImp_90
Definition: TileTBAANtuple.h:498
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
AthAlgorithm
Definition: AthAlgorithm.h:47
TileHitContainer
Definition: TileHitContainer.h:13
TileTBAANtuple::m_beamBC1X1
Gaudi::Property< float > m_beamBC1X1
Definition: TileTBAANtuple.h:204
TileTBAANtuple::ADDER_addBranch
void ADDER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree ADDER variable...
Definition: TileTBAANtuple.cxx:2761
TileTBAANtuple::m_hitVectorKey
SG::ReadHandleKey< TileHitVector > m_hitVectorKey
Definition: TileTBAANtuple.h:150
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
fill
void fill(H5::Group &out_file, size_t iterations)
Definition: test-hdf5-writer.cxx:95
TileTBAANtuple::m_thitCnt
std::vector< std::array< float, MAX_CHAN > > m_thitCnt
Definition: TileTBAANtuple.h:617
TileTBAANtuple::m_fitRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitRawChannelContainerKey
Definition: TileTBAANtuple.h:126
TileTBAANtuple::m_las_PMT2_TDC
int m_las_PMT2_TDC
Definition: TileTBAANtuple.h:423
TileTBAANtuple::m_las_BCID
int m_las_BCID
Definition: TileTBAANtuple.h:378
LASE_PTN_FRAG
#define LASE_PTN_FRAG
Definition: TileTBFrag.h:27
TileTBAANtuple::QDC_clearBranch
void QDC_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree QDC variables
Definition: TileTBAANtuple.cxx:2616
TileDigitsCollection
Definition: TileDigitsCollection.h:18
TileLaserObject::getDiodeSigmaPedestal
double getDiodeSigmaPedestal(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:123
TileTBAANtuple::COINCBOARD_addBranch
void COINCBOARD_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree COINCBOARD var...
Definition: TileTBAANtuple.cxx:3064
TileTBAANtuple::m_las_D3_AlphaPed
double m_las_D3_AlphaPed
Definition: TileTBAANtuple.h:411
TileTBAANtuple::m_tfitVec
std::vector< std::array< float, MAX_CHAN > > m_tfitVec
Definition: TileTBAANtuple.h:535
TileTBAANtuple::m_fitcRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitcRawChannelContainerKey
Definition: TileTBAANtuple.h:135
PathResolver.h
TileTBAANtuple::m_s2cou
uint32_t m_s2cou
Definition: TileTBAANtuple.h:453
Trk::index2
@ index2
Definition: BoundarySurfaceFace.h:49
TileTBAANtuple::m_rodCRCVec
std::vector< std::array< int, MAX_DMU > > m_rodCRCVec
Definition: TileTBAANtuple.h:528
TileTBAANtuple::m_ROD_GlobalCRCVec
std::vector< short > m_ROD_GlobalCRCVec
Definition: TileTBAANtuple.h:559
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
TileTBAANtuple::m_cispar
int m_cispar[16]
Definition: TileTBAANtuple.h:449
TileTBAANtuple::m_xImp
float m_xImp
Definition: TileTBAANtuple.h:493
TileTBAANtuple::ECAL_addBranch
void ECAL_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add ECAL variables to t...
Definition: TileTBAANtuple.cxx:2539
TileTBAANtuple::m_las_D2_AlphaPed
double m_las_D2_AlphaPed
Definition: TileTBAANtuple.h:410
TileCablingService::getTestBeam
bool getTestBeam() const
Definition: TileCablingService.h:274
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
TileDigits
Definition: TileDigits.h:30
TileTBAANtuple::m_ROD_DMUHeadformatErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUHeadformatErrVec
Definition: TileTBAANtuple.h:564
CaloCell_ID_FCS::TileExt1
@ TileExt1
Definition: FastCaloSim_CaloCell_ID.h:38
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
TileLaserObject::getBCID
int getBCID() const
Definition: TileLaserObject.h:335
TileTBAANtuple::m_las2
float m_las2
Definition: TileTBAANtuple.h:436
MAX_DRAWERS
#define MAX_DRAWERS
Definition: TileTBAANtuple.cxx:73
TileLaserObject::getDiodeADC
int getDiodeADC(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:95
TileTBAANtuple::m_adder
int ** m_adder
Definition: TileTBAANtuple.h:444
TileTBAANtuple::m_coincFlag2
int m_coincFlag2
Definition: TileTBAANtuple.h:594
TileTBAANtuple::m_beamFragList
Gaudi::Property< std::vector< std::string > > m_beamFragList
Definition: TileTBAANtuple.h:186
TileRawChannelCollection
Definition: TileRawChannelCollection.h:12
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
TileTBAANtuple::m_xCha2
float m_xCha2
Definition: TileTBAANtuple.h:487
TileTBAANtuple::m_coincTrig1
std::array< unsigned int, 96 > m_coincTrig1
Definition: TileTBAANtuple.h:584
TileTBAANtuple::m_las_D2_ADC
int m_las_D2_ADC
Definition: TileTBAANtuple.h:385
TileTBAANtuple::TRIGGER_addBranch
void TRIGGER_addBranch(void)
///////////////////////////////////////////////////////////////////////////
Definition: TileTBAANtuple.cxx:2472
TileTBAANtuple::clear_init_minus1
void clear_init_minus1(std::vector< T > &vec)
Definition: TileTBAANtuple.cxx:3746
TileTBAANtuple::m_btdc1
std::array< int, 16 > m_btdc1
Definition: TileTBAANtuple.h:469
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TileTBAANtuple::LASER_addBranch
void LASER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree LASER variable...
Definition: TileTBAANtuple.cxx:2628
TileTBAANtuple::m_las_D2_Alpha
double m_las_D2_Alpha
Definition: TileTBAANtuple.h:400
TileTBAANtuple::m_lasExtra
std::array< float, 4 > m_lasExtra
Definition: TileTBAANtuple.h:438
TileTBAANtuple::m_mdL1idflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdL1idflxVec
Definition: TileTBAANtuple.h:568
TileTBAANtuple::m_coincFlag1
int m_coincFlag1
Definition: TileTBAANtuple.h:593
TileTBFrag.h
TileHit
Definition: TileSimEvent/TileSimEvent/TileHit.h:30
TileTBAANtuple::m_beamBC1Z_min90
Gaudi::Property< float > m_beamBC1Z_min90
Definition: TileTBAANtuple.h:211
TileTBAANtuple::MUON_addBranch
void MUON_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add MUON variables to t...
Definition: TileTBAANtuple.cxx:2511
TileLaserObject::getPMPedestal
double getPMPedestal(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:223
TileTBAANtuple::BEAM_clearBranch
void BEAM_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree BEAM variable...
Definition: TileTBAANtuple.cxx:2944
TileTBAANtuple::m_yCha1
float m_yCha1
Definition: TileTBAANtuple.h:486
TileTBAANtuple::m_las_D1_Ped_RMS
double m_las_D1_Ped_RMS
Definition: TileTBAANtuple.h:394
TileTBAANtuple::m_etaFileName
Gaudi::Property< std::string > m_etaFileName
Definition: TileTBAANtuple.h:223
TileTBAANtuple::m_run
int m_run
Definition: TileTBAANtuple.h:353
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
TileTBAANtuple::m_eDspVec
std::vector< std::array< float, MAX_CHAN > > m_eDspVec
Definition: TileTBAANtuple.h:546
TileTBAANtuple::m_tOptVec
std::vector< std::array< float, MAX_CHAN > > m_tOptVec
Definition: TileTBAANtuple.h:543
TileLaserObject::getDiodeCurrMeas
double getDiodeCurrMeas() const
Definition: TileLaserObject.h:224
TileTBAANtuple::m_radius
Gaudi::Property< float > m_radius
Definition: TileTBAANtuple.h:222
TileTBAANtuple::m_beamBC1Y1
Gaudi::Property< float > m_beamBC1Y1
Definition: TileTBAANtuple.h:206
EventInfo.h
TileTBAANtuple::m_GapEne
std::array< float, 3 > m_GapEne
Definition: TileTBAANtuple.h:582
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
TileTBAANtuple::m_las_D3_Alpha
double m_las_D3_Alpha
Definition: TileTBAANtuple.h:401
ReadOfcFromCool.nsamples
nsamples
Definition: ReadOfcFromCool.py:115
TileTBAANtuple::m_pedfitcVec
std::vector< std::array< float, MAX_CHAN > > m_pedfitcVec
Definition: TileTBAANtuple.h:540
MUON_ADC_FRAG
#define MUON_ADC_FRAG
Definition: TileTBFrag.h:25
ir
int ir
counter of the current depth
Definition: fastadd.cxx:49
TileTBAANtuple::m_nSamplesFlxInDrawer
std::vector< int > m_nSamplesFlxInDrawer
Definition: TileTBAANtuple.h:632
python.PyAthena.v
v
Definition: PyAthena.py:154
TileTBAANtuple::m_las_D1_AlphaPed_RMS
double m_las_D1_AlphaPed_RMS
Definition: TileTBAANtuple.h:414
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
TileTBAANtuple::MAX_CHAN
@ MAX_CHAN
Definition: TileTBAANtuple.h:106
TileTBAANtuple::m_las_PMT1_TDC
int m_las_PMT1_TDC
Definition: TileTBAANtuple.h:422
TileTBAANtuple::m_tflxoptVec
std::vector< std::array< float, MAX_CHAN > > m_tflxoptVec
Definition: TileTBAANtuple.h:555
TileTBAANtuple::m_timeAdd
std::array< float, 16 > m_timeAdd
Definition: TileTBAANtuple.h:446
COIN_TRIG3_FRAG
#define COIN_TRIG3_FRAG
Definition: TileTBFrag.h:34
TileTBAANtuple::m_beamBC2X2
Gaudi::Property< float > m_beamBC2X2
Definition: TileTBAANtuple.h:214
DeMoScan.index
string index
Definition: DeMoScan.py:364
TileTBAANtuple::m_las_D3_ADC
int m_las_D3_ADC
Definition: TileTBAANtuple.h:386
TileTBAANtuple::m_bcidVec
std::vector< std::array< int, MAX_DMU > > m_bcidVec
Definition: TileTBAANtuple.h:514
TileTBAANtuple::m_sc1
int m_sc1
Definition: TileTBAANtuple.h:465
TileTBAANtuple::m_las_D4_Alpha_RMS
double m_las_D4_Alpha_RMS
Definition: TileTBAANtuple.h:407
TileTBAANtuple::m_DMUHeadparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUHeadparityErrVec
Definition: TileTBAANtuple.h:521
TileTBAANtuple::m_dspUnit
TileRawChannelUnit::UNIT m_dspUnit
Unit for TileRawChannels in DSP.
Definition: TileTBAANtuple.h:622
TileTBAANtuple::TRIGGER_clearBranch
void TRIGGER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER varia...
Definition: TileTBAANtuple.cxx:2571
TileTBAANtuple::m_rchUnit
TileRawChannelUnit::UNIT m_rchUnit
Unit for TileRawChannels (ADC, pCb, MeV)
Definition: TileTBAANtuple.h:621
TileTBAANtuple::m_muCalib
std::array< float, 2 > m_muCalib
Definition: TileTBAANtuple.h:369
TileTBAANtuple::storeLaser
StatusCode storeLaser(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:455
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
TileTBAANtuple::m_las_D2_Ped
double m_las_D2_Ped
Definition: TileTBAANtuple.h:390
COIN_TRIG2_FRAG
#define COIN_TRIG2_FRAG
Definition: TileTBFrag.h:33
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
TileRawDataContainer::get_unit
UNIT get_unit() const
Definition: TileRawDataContainer.h:60
TileHit::pmt_HWID
HWIdentifier pmt_HWID(void) const
Return pmt hardware ID (== channel ID)
Definition: TileHit.cxx:125
TileTBAANtuple::m_ROD_DMUSstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUSstrobeErrVec
Definition: TileTBAANtuple.h:562
TileTBAANtuple::getEta
void getEta(void)
Definition: TileTBAANtuple.cxx:2396
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileTBAANtuple::m_las_PMT2_ADC
int m_las_PMT2_ADC
Definition: TileTBAANtuple.h:420
TileHit::energy
float energy(int ind=0) const
Return energy of ind-th sub-hit
Definition: TileSimEvent/TileSimEvent/TileHit.h:90
TileTBAANtuple::m_cher2
uint32_t m_cher2
Definition: TileTBAANtuple.h:456
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
TileTBAANtuple::m_unpackAdder
Gaudi::Property< bool > m_unpackAdder
Definition: TileTBAANtuple.h:169
TileTBAANtuple::m_mdRunflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdRunflxVec
Definition: TileTBAANtuple.h:574
TileTBAANtuple::m_optRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_optRawChannelContainerKey
Definition: TileTBAANtuple.h:129
TileLaserObject::getPMSigmaPedestal
double getPMSigmaPedestal(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:237
TileBeamElemContByteStreamCnv.h
TileTBAANtuple::m_beamBC0Y2
Gaudi::Property< float > m_beamBC0Y2
Definition: TileTBAANtuple.h:201
DEBUG
#define DEBUG
Definition: page_access.h:11
F
#define F(x, y, z)
Definition: MD5.cxx:112
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TileLaserObject::getDiodePedestal
double getDiodePedestal(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:109
TileTBAANtuple::m_yCha0
float m_yCha0
Definition: TileTBAANtuple.h:483
TileTBAANtuple::m_beamBC2Z_90
Gaudi::Property< float > m_beamBC2Z_90
Definition: TileTBAANtuple.h:219
TileTBAANtuple::m_pmtOrder
Gaudi::Property< bool > m_pmtOrder
Definition: TileTBAANtuple.h:172
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
TileTBAANtuple::m_nSamples
Gaudi::Property< int > m_nSamples
Definition: TileTBAANtuple.h:173
TileTBAANtuple::m_chi2flxoptVec
std::vector< std::array< float, MAX_CHAN > > m_chi2flxoptVec
Definition: TileTBAANtuple.h:556
TileTBAANtuple::m_coincFlag5
int m_coincFlag5
Definition: TileTBAANtuple.h:597
TileTBAANtuple::m_beamBC2Y1
Gaudi::Property< float > m_beamBC2Y1
Definition: TileTBAANtuple.h:215
TileTBAANtuple::m_ROD_DMUmemoryErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUmemoryErrVec
Definition: TileTBAANtuple.h:561
TileTBAANtuple::m_chi2DspVec
std::vector< std::array< float, MAX_CHAN > > m_chi2DspVec
Definition: TileTBAANtuple.h:548
TileTBAANtuple::m_DMUDstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUDstrobeErrVec
Definition: TileTBAANtuple.h:519
TileTBAANtuple::m_thitVec
std::vector< std::array< float, MAX_CHAN > > m_thitVec
Definition: TileTBAANtuple.h:615
TileTBAANtuple::m_evt
int m_evt
Definition: TileTBAANtuple.h:354
TileTBAANtuple::m_xChN1
float m_xChN1
Definition: TileTBAANtuple.h:480
TileTBAANtuple::m_las_D3_Ped_RMS
double m_las_D3_Ped_RMS
Definition: TileTBAANtuple.h:396
TileTBAANtuple::m_sc2
int m_sc2
Definition: TileTBAANtuple.h:466
TileTBAANtuple::m_DMUDataparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUDataparityErrVec
Definition: TileTBAANtuple.h:522
TileTBAANtuple::m_las_D3_Ped
double m_las_D3_Ped
Definition: TileTBAANtuple.h:391
TileTBAANtuple::m_trigType
int m_trigType
Definition: TileTBAANtuple.h:355
TileTBAANtuple::m_scaler
std::array< int, 16 > m_scaler
Definition: TileTBAANtuple.h:471
SIGNAL_FOUND
#define SIGNAL_FOUND(frag, chan, amplitude)
Definition: TileTBAANtuple.cxx:66
COMMON_ADC2_FRAG
#define COMMON_ADC2_FRAG
Definition: TileTBFrag.h:44
TileTBAANtuple::ADDER_clearBranch
void ADDER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ADDER variabl...
Definition: TileTBAANtuple.cxx:2784
TileTBAANtuple::m_las_D2_Ped_RMS
double m_las_D2_Ped_RMS
Definition: TileTBAANtuple.h:395
TileTBAANtuple::m_las_PMT2_Ped_RMS
double m_las_PMT2_Ped_RMS
Definition: TileTBAANtuple.h:429
TileTBAANtuple::m_beamBC1Z_90
Gaudi::Property< float > m_beamBC1Z_90
Definition: TileTBAANtuple.h:210
LArDigits2NtupleDumper.nSamples
nSamples
Definition: LArDigits2NtupleDumper.py:85
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_ROD_DMUDataformatErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUDataformatErrVec
Definition: TileTBAANtuple.h:565
TileTBAANtuple::m_ROD_DMUDstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUDstrobeErrVec
Definition: TileTBAANtuple.h:563
TileTBAANtuple::m_adderFilterAlgTool
ToolHandle< TileRawChannelBuilderFlatFilter > m_adderFilterAlgTool
Definition: TileTBAANtuple.h:159
TileTBAANtuple::m_las_D1_Alpha
double m_las_D1_Alpha
Definition: TileTBAANtuple.h:399
calibdata.copy
bool copy
Definition: calibdata.py:27
TileTBAANtuple::CISPAR_clearBranch
void CISPAR_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variab...
Definition: TileTBAANtuple.cxx:2810
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
TileTBAANtuple::m_flxFitRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flxFitRawChannelContainerKey
Definition: TileTBAANtuple.h:138
TileTBAANtuple::m_las_PMT1_Ped_RMS
double m_las_PMT1_Ped_RMS
Definition: TileTBAANtuple.h:428
jobOptions.fileName
fileName
Definition: jobOptions.SuperChic_ALP2.py:39
TileTBAANtuple::m_las_D4_Alpha
double m_las_D4_Alpha
Definition: TileTBAANtuple.h:402
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
TileHWID::to_string
std::string to_string(const HWIdentifier &id, int level=0) const
extract all fields from HW identifier HWIdentifier get_all_fields ( const HWIdentifier & id,...
Definition: TileHWID.cxx:50
TileTBAANtuple::m_xCha1_0
float m_xCha1_0
Definition: TileTBAANtuple.h:489
TileTBAANtuple::m_timeVec
std::vector< std::array< float, MAX_CHAN > > m_timeVec
Definition: TileTBAANtuple.h:531
TileLaserObject::getSigmaAlpha
double getSigmaAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:152
TileTBAANtuple::m_eflxoptVec
std::vector< std::array< float, MAX_CHAN > > m_eflxoptVec
Definition: TileTBAANtuple.h:554
TileTBAANtuple::m_LarEne
std::array< float, 4 > m_LarEne
Definition: TileTBAANtuple.h:579
TileTBAANtuple::m_gainVec
std::vector< std::array< int, MAX_CHAN > > m_gainVec
Definition: TileTBAANtuple.h:525
TileTBAANtuple::m_nSamplesFlxInDrawerMap
std::map< int, int > m_nSamplesFlxInDrawerMap
Definition: TileTBAANtuple.h:630
TileTBAANtuple::m_eneAdd
std::array< float, 16 > m_eneAdd
Definition: TileTBAANtuple.h:445
TileHit::time
float time(int ind=0) const
Return time of ind-th sub-hit
Definition: TileSimEvent/TileSimEvent/TileHit.h:92
TileTBAANtuple::m_las_D4_AlphaPed_RMS
double m_las_D4_AlphaPed_RMS
Definition: TileTBAANtuple.h:417
TileTBAANtuple::m_chi2flxfitVec
std::vector< std::array< float, MAX_CHAN > > m_chi2flxfitVec
Definition: TileTBAANtuple.h:552
TileTBAANtuple::m_las_D2_Alpha_RMS
double m_las_D2_Alpha_RMS
Definition: TileTBAANtuple.h:405
ECAL_ADC_FRAG
#define ECAL_ADC_FRAG
Definition: TileTBFrag.h:30
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
CaloCell_ID_FCS::EMB3
@ EMB3
Definition: FastCaloSim_CaloCell_ID.h:22
TileTBAANtuple::m_las_D2_AlphaPed_RMS
double m_las_D2_AlphaPed_RMS
Definition: TileTBAANtuple.h:415
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
TileTBAANtuple::m_las_D1_Alpha_RMS
double m_las_D1_Alpha_RMS
Definition: TileTBAANtuple.h:404
TileTBAANtuple::m_las_D4_Ped_RMS
double m_las_D4_Ped_RMS
Definition: TileTBAANtuple.h:397
TileLaserObjByteStreamCnv.h
TileTBAANtuple::initList
StatusCode initList(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:2188
TileTBAANtuple::m_rosName
Gaudi::Property< std::vector< std::string > > m_rosName
Definition: TileTBAANtuple.h:183
CaloCell_ID_FCS::TileBar2
@ TileBar2
Definition: FastCaloSim_CaloCell_ID.h:33
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
COIN_TRIG5_FRAG
#define COIN_TRIG5_FRAG
Definition: TileTBFrag.h:36
TileTBAANtuple::m_l1Type
std::vector< int > m_l1Type
Definition: TileTBAANtuple.h:360
TileTBAANtuple::m_ntupleCreated
bool m_ntupleCreated
Definition: TileTBAANtuple.h:346
TileTBAANtuple::storeBeamElements
StatusCode storeBeamElements(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:525
TileTBAANtuple::DIGI_clearBranch
void DIGI_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variabl...
Definition: TileTBAANtuple.cxx:3407
TileTBAANtuple::m_TBperiod
Gaudi::Property< int > m_TBperiod
Definition: TileTBAANtuple.h:177
TileLaserObject
Definition: TileLaserObject.h:33
TileTBAANtuple::m_ehitCnt
std::vector< std::array< float, MAX_CHAN > > m_ehitCnt
Definition: TileTBAANtuple.h:616
TileTBAANtuple::m_dqStatusKey
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
Definition: TileTBAANtuple.h:162
COIN_TRIG4_FRAG
#define COIN_TRIG4_FRAG
Definition: TileTBFrag.h:35
TileTBAANtuple::m_eOptVec
std::vector< std::array< float, MAX_CHAN > > m_eOptVec
Definition: TileTBAANtuple.h:542
TileTBAANtuple::m_coincTrig8
std::array< unsigned int, 96 > m_coincTrig8
Definition: TileTBAANtuple.h:591
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
TileRawChannelUnit::ADCcounts
@ ADCcounts
Definition: TileRawChannelUnit.h:17
TileTBAANtuple::m_las1
float m_las1
Definition: TileTBAANtuple.h:435
TileTBAANtuple::m_dspFlags
int m_dspFlags
Definition: TileTBAANtuple.h:356
TileTBAANtuple::m_pedfitVec
std::vector< std::array< float, MAX_CHAN > > m_pedfitVec
Definition: TileTBAANtuple.h:536
TileTBAANtuple::m_muVeto
uint32_t m_muVeto
Definition: TileTBAANtuple.h:460
TileTBAANtuple::m_yCha2
float m_yCha2
Definition: TileTBAANtuple.h:488
fitman.k
k
Definition: fitman.py:528
TileRawChannelUnit::OnlineMegaElectronVolts
@ OnlineMegaElectronVolts
Definition: TileRawChannelUnit.h:24
TileTBAANtuple::m_las_D3_Alpha_RMS
double m_las_D3_Alpha_RMS
Definition: TileTBAANtuple.h:406
TileTBAANtuple::m_efitcVec
std::vector< std::array< float, MAX_CHAN > > m_efitcVec
Definition: TileTBAANtuple.h:538
TileLaserObject::getPedestalAlpha
double getPedestalAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:166
TileTBAANtuple::m_xImp_min90
float m_xImp_min90
Definition: TileTBAANtuple.h:500
TileTBAANtuple::m_mdChargeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdChargeflxVec
Definition: TileTBAANtuple.h:575
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_beamBC0X1
Gaudi::Property< float > m_beamBC0X1
Definition: TileTBAANtuple.h:198
Generated on Wed Apr 9 2025 21:20:32 for ATLAS Offline Software by   doxygen 1.8.18