ATLAS Offline Software
TileAANtuple.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 //*****************************************************************************
6 // Filename : TileAANtuple.cxx
7 // Author : Alexander Solodkov
8 // Created : April, 2010
9 //
10 // DESCRIPTION:
11 // Algorithm which puts in ntuple all raw data (digits) and results of Opt filter
12 //
13 // HISTORY:
14 // 29-Apr-2010 First version - simplified version of TileTBAANtuple
15 //
16 // BUGS:
17 //
18 //*****************************************************************************
19 
20 //Tile includes
21 #include "TileRec/TileAANtuple.h"
22 #include "TileIdentifier/TileHWID.h"
23 #include "TileCalibBlobObjs/TileCalibUtils.h"
24 #include "TileConditions/TileCablingService.h"
25 #include "TileConditions/ITileBadChanTool.h"
26 #include "TileConditions/TileInfo.h"
27 #include "TileDetDescr/TileDetDescrManager.h"
28 #include "TileConditions/TileCondToolEmscale.h"
29 #include "TileEvent/TileDigitsContainer.h"
30 #include "TileEvent/TileBeamElemContainer.h"
31 #include "TileEvent/TileRawChannelContainer.h"
32 #include "TileEvent/TileContainer.h"
33 #include "TileEvent/TileLaserObject.h"
34 #include "TileEvent/TileMuonReceiverContainer.h"
35 #include "TileByteStream/TileHid2RESrcID.h"
36 #include "TileIdentifier/TileTBFrag.h"
37 #include "TileL2Algs/TileL2Builder.h"
38 
39 // Calo includes
40 #include "CaloDetDescr/CaloDetDescrElement.h"
41 #include "CaloDetDescr/MbtsDetDescrManager.h"
42 #include "Identifier/IdentifierHash.h"
43 #include "CaloIdentifier/TileID.h"
44 
45 //Atlas include
46 #include "AthenaKernel/errorcheck.h"
47 #include "xAODEventInfo/EventInfo.h"
48 #include "StoreGate/ReadHandleKey.h"
49 #include "ByteStreamCnvSvcBase/ROBDataProviderSvc.h"
50 
51 #include "eformat/ROBFragment.h"
52 #include "eformat/FullEventFragment.h"
53 
54 // Gaudi includes
55 #include "GaudiKernel/ITHistSvc.h"
56 #include "GaudiKernel/ThreadLocalContext.h"
57 
58 #include "TTree.h"
59 #include "TFile.h"
60 #include <iomanip>
61 #include "boost/date_time/local_time/local_time.hpp"
62 #include "boost/date_time/posix_time/posix_time.hpp"
63 #include <iostream>
64 #include <sstream>
65 
66 #define CLEAR(array) \
67 memset(array,0,sizeof(array))
68 
69 #define CLEAR1(array) \
70 memset(array,-1,sizeof(array))
71 
72 #define CLEAR2(array,size) \
73  memset(array,0,sizeof(array)/size)
74 
75 #define CLEAR3(array,size) \
76  memset(array,-1,sizeof(array)/size)
77 
78 // clear for MF arrays with two gains
79 #define CLEAR4(array,size) \
80 memset(array,0,sizeof(*array)*N_ROS2*N_MODULES*N_CHANS*m_nSamples/size)
81 
82 // clear for sample arrays with two gains
83 #define CLEAR5(array,size) \
84 memset(array,-1,sizeof(*array)*N_ROS2*N_MODULES*N_CHANS*m_nSamples/size)
85 
86 // clear for TMDB sample arrays with one gain
87 #define CLEAR6(array) \
88 memset(array,0,sizeof(*array)*N_ROS*N_MODULES*N_TMDBCHANS*m_nSamples)
89 
90 #define NAME1(s1) \
91 s1.c_str()
92 
93 #define NAME2(s1,s2) \
94 (s1+s2).c_str()
95 
96 #define NAME3(s1,s2,s3) \
97 (s1+s2+s3).c_str()
98 
99 #define NAME5(s1,s2,s3,s4,s5) \
100 (s1+s2+s3+s4+s5).c_str()
101 
102 #define sample_ind(r,m,c,i) (((r*N_MODULES + m)*N_CHANS + c)*m_nSamples) + i
103 
104 #define sample_ind_TMDB(r,m,c,i) (((r*N_MODULES + m)*N_TMDBCHANS + c)*m_nSamples) + i
105 
106 // Constructor & deconstructor
112 TileAANtuple::TileAANtuple(const std::string& name, ISvcLocator* pSvcLocator)
113 : AthAlgorithm(name, pSvcLocator)
114 , m_evTime(0)
115 , m_run(0)
116 , m_evt(0)
117 , m_lumiBlock(0)
118 , m_HHMMSS(0)
119 , m_dateTime()
120 , m_trigType(0)
121 , m_dspFlags(0)
122 , m_l1ID()
123 , m_l1Type()
124 , m_evBCID()
125 , m_evType()
126 , m_cispar()
127 , m_las_version(0)
128 , m_las_BCID(0)
129 , m_las_Filt(0)
130 , m_las_ReqAmp(0)
131 , m_las_MeasAmp(0)
132 , m_las_Temperature(0)
133 , m_arrays (std::make_unique<Arrays>())
134 , m_qdctimeout(0)
135 , m_tdctimeout(0)
136 , m_daqtype(0)
137 , m_nBadDr(0)
138 , m_nBadHV(0)
139 , m_nBadDCS(0)
140 , m_nBadDB(0)
141 , m_nBadTotal(0)
142 , m_rchUnit(TileRawChannelUnit::MegaElectronVolts)
143 , m_dspUnit(TileRawChannelUnit::ADCcounts)
144 , m_ntuplePtr(0)
145 , m_DCSntuplePtr(0)
146 , m_thistSvc("THistSvc", name)
147 , m_tileID(0)
148 , m_tileHWID(0)
149 , m_cabling(0)
150 , m_tileMgr(0)
151 , m_tileBadChanTool("TileBadChanTool")
152 , m_tileToolEmscale("TileCondToolEmscale")
153 , m_l2Builder()
154 , m_sumEt_xx()
155 , m_sumEz_xx()
156 , m_sumE_xx()
157 , m_sumEt_yy()
158 , m_sumEz_yy()
159 , m_sumE_yy()
160 , m_sumEt_zz()
161 , m_sumEz_zz()
162 , m_sumE_zz()
163 , m_bad()
164 {
165  declareProperty("TileCondToolEmscale", m_tileToolEmscale);
166  declareProperty("TileDigitsContainer", m_digitsContainerKey = "TileDigitsCnt");
167  declareProperty("TileDigitsContainerFlt", m_fltDigitsContainerKey = "" /* "TileDigitsFlt" */);
168  declareProperty("TileBeamElemContainer", m_beamElemContainerKey = "TileBeamElemCnt");
169  declareProperty("TileRawChannelContainer", m_rawChannelContainerKey = "TileRawChannelCnt");
170  declareProperty("TileRawChannelContainerFit", m_fitRawChannelContainerKey = ""); //
171  declareProperty("TileRawChannelContainerFitCool", m_fitcRawChannelContainerKey = ""); // don't create
172  declareProperty("TileRawChannelContainerOpt", m_optRawChannelContainerKey = ""); // by default
173  declareProperty("TileRawChannelContainerQIE", m_qieRawChannelContainerKey = ""); // processed QIE data
174  declareProperty("TileRawChannelContainerOF1", m_of1RawChannelContainerKey = ""); //
175  declareProperty("TileRawChannelContainerDsp", m_dspRawChannelContainerKey = ""); //
176  declareProperty("TileRawChannelContainerMF", m_mfRawChannelContainerKey = ""); //
177  declareProperty("TileRawChannelContainerWiener", m_wienerRawChannelContainerKey = "");//
178  declareProperty("TileMuRcvRawChannelContainer", m_tileMuRcvRawChannelContainerKey = "MuRcvRawChCnt");// TMDB
179  declareProperty("TileMuRcvDigitsContainer", m_tileMuRcvDigitsContainerKey = "MuRcvDigitsCnt");// TMDB
180  declareProperty("TileMuRcvContainer", m_tileMuRcvContainerKey = "TileMuRcvCnt");// TMDB
181  declareProperty("TileLaserObject", m_laserObjectKey = "" /* "TileLaserObj" */); //
182  declareProperty("TileL2Cnt", m_l2CntKey = "TileL2Cnt");
183  declareProperty("CalibrateEnergy", m_calibrateEnergy = true);
184  declareProperty("UseDspUnits", m_useDspUnits = false);
185  declareProperty("OfflineUnits", m_finalUnit = TileRawChannelUnit::MegaElectronVolts);
186  declareProperty("CalibMode", m_calibMode = false);
187  declareProperty("CompareMode", m_compareMode = false);
188  declareProperty("BSInput", m_bsInput = true);
189  declareProperty("PMTOrder", m_pmtOrder = false);
190 
191  declareProperty("StreamName", m_streamName = "AANT");
192  declareProperty("NTupleID", m_ntupleID = "h2000");
193  declareProperty("TreeSize", m_treeSize = 16000000000LL);
194 
195  declareProperty("CheckDCS",m_checkDCS = false);
196  declareProperty("DCSBranches",m_DCSBranches = 111111111);
197 
198  declareProperty("SkipEvents", m_skipEvents = 0);
199  declareProperty("NSamples", m_nSamples=7);
200  declareProperty("Reduced", m_reduced=false);
201  declareProperty("CompressionSettings", m_compressSettings = -1);
202 
203  m_evtNr = -1;
204 }
205 
206 TileAANtuple::~TileAANtuple() {
207 }
208 
210 StatusCode TileAANtuple::initialize() {
211  ATH_MSG_INFO( "Initialization started");
212 
213  //=== get TileCablingSvc
214  ATH_CHECK( m_cablingSvc.retrieve() );
215 
216  // find TileCablingService
217  m_cabling = TileCablingService::getInstance();
218 
219  // retrieve TileDetDescr Manager det store
220  ATH_CHECK( detStore()->retrieve(m_tileMgr) );
221 
222  // retrieve TileID helper from det store
223  ATH_CHECK( detStore()->retrieve(m_tileID) );
224  ATH_CHECK( detStore()->retrieve(m_tileHWID) );
225 
226  //=== get TileDCSTool
227  if (m_checkDCS) {
228  ATH_CHECK( m_tileDCS.retrieve() );
229  } else {
230  m_tileDCS.disable();
231  }
232 
233  //=== get TileBadChanTool
234  ATH_CHECK( m_tileBadChanTool.retrieve() );
235 
236  //=== get TileCondToolEmscale
237  ATH_CHECK( m_tileToolEmscale.retrieve() );
238 
239  //=== get TileL2Builder
240  if (m_compareMode) {
241  ATH_CHECK( m_l2Builder.retrieve() );
242  }
243 
244  ATH_CHECK( m_DQstatusKey.initialize() );
245 
246  int sample_size = N_ROS2*N_MODULES*N_CHANS*m_nSamples;
247  int sample_TMDB_size = N_ROS*N_MODULES*N_TMDBCHANS*m_nSamples;
248  m_arrays->m_sample = (short *) malloc(sample_size*sizeof(short));
249  m_arrays->m_sampleFlt = (short *) malloc(sample_size*sizeof(short));
250  m_arrays->m_sampleTMDB = (unsigned char *) malloc(sample_TMDB_size*sizeof(unsigned char));
251 
252  ATH_CHECK( m_beamElemContainerKey.initialize(m_bsInput) );
253  ATH_CHECK( m_digitsContainerKey.initialize(SG::AllowEmpty) );
254  ATH_CHECK( m_fltDigitsContainerKey.initialize(SG::AllowEmpty) );
255  ATH_CHECK( m_laserObjectKey.initialize(SG::AllowEmpty) );
256  ATH_CHECK( m_tileMuRcvContainerKey.initialize(SG::AllowEmpty) );
257  ATH_CHECK( m_tileMuRcvDigitsContainerKey.initialize(SG::AllowEmpty) );
258  ATH_CHECK( m_tileMuRcvRawChannelContainerKey.initialize(SG::AllowEmpty) );
259  ATH_CHECK( m_mfRawChannelContainerKey.initialize(SG::AllowEmpty) );
260  ATH_CHECK( m_rawChannelContainerKey.initialize(SG::AllowEmpty) );
261  ATH_CHECK( m_fitRawChannelContainerKey.initialize(SG::AllowEmpty) );
262  ATH_CHECK( m_fitcRawChannelContainerKey.initialize(SG::AllowEmpty) );
263  ATH_CHECK( m_optRawChannelContainerKey.initialize(SG::AllowEmpty) );
264  ATH_CHECK( m_qieRawChannelContainerKey.initialize(SG::AllowEmpty) );
265  ATH_CHECK( m_dspRawChannelContainerKey.initialize(SG::AllowEmpty) );
266  ATH_CHECK( m_of1RawChannelContainerKey.initialize(SG::AllowEmpty) );
267  ATH_CHECK( m_wienerRawChannelContainerKey.initialize(SG::AllowEmpty) );
268  ATH_CHECK( m_l2CntKey.initialize(m_compareMode) );
269 
270  ATH_MSG_INFO( "initialization completed" ) ;
271  return StatusCode::SUCCESS;
272 }
273 
274 
275 StatusCode TileAANtuple::ntuple_initialize(const EventContext& ctx,
276  const TileDQstatus& DQstatus)
277 {
278  if (m_bsInput) {
279  ATH_CHECK( m_robSvc.retrieve() );
280  ATH_CHECK( m_decoder.retrieve() );
281  const TileHid2RESrcID* hid2re = m_decoder->getHid2re();
282  m_ROBID.push_back( hid2re->getRobFromFragID(DIGI_PAR_FRAG) );
283  m_ROBID.push_back( hid2re->getRobFromFragID(LASER_OBJ_FRAG) );
284  }
285 
286  uint32_t calib = DQstatus.calibMode();
287  bool calibMode = (calib == 1);
288  if ( calibMode != m_calibMode && calib!=0xFFFFFFFF ) {
289  ATH_MSG_INFO( "Calib mode from data is " << calibMode );
290  ATH_MSG_INFO( " Overwriting calib mode " );
291  m_calibMode = calibMode;
292  }
293 
294  if (m_finalUnit < TileRawChannelUnit::ADCcounts
295  || m_finalUnit > TileRawChannelUnit::OnlineMegaElectronVolts) {
296 
297  m_finalUnit = -1;
298  if ( !m_useDspUnits && m_calibrateEnergy ) {
299  m_useDspUnits = true;
300  ATH_MSG_INFO( "Final offline units are not set, will use DSP units" );
301  }
302  }
303 
304  if ( !m_calibrateEnergy && m_useDspUnits) {
305  ATH_MSG_INFO( "calibrateEnergy is disabled, don't want to use DSP units" );
306  m_useDspUnits = false;
307  }
308 
309  ATH_MSG_INFO( "calibMode " << m_calibMode );
310  ATH_MSG_INFO( "calibrateEnergy " << m_calibrateEnergy );
311  ATH_MSG_INFO( "offlineUnits " << m_finalUnit );
312  ATH_MSG_INFO( "useDspUnits " << m_useDspUnits );
313 
314  // set event number to 0 before first event
315  m_evtNr = 0;
316 
317  ATH_CHECK( m_thistSvc.retrieve() );
318 
319  if (m_compressSettings >= 0) {
320  ATH_CHECK( m_fileMgr.retrieve() );
321  }
322 
323  if(initNTuple(ctx).isFailure()) {
324  ATH_MSG_ERROR( " Error during ntuple initialization" );
325  }
326 
327  ATH_MSG_INFO( "ntuple initialization completed" );
328  return StatusCode::SUCCESS;
329 }
330 
331 
332 StatusCode TileAANtuple::execute() {
333  const EventContext& ctx = Gaudi::Hive::currentContext();
334  const TileDQstatus* DQstatus = SG::makeHandle (m_DQstatusKey, ctx).get();
335 
336  if (m_evtNr < 0) {
337  if (ntuple_initialize(ctx, *DQstatus).isFailure()) {
338  ATH_MSG_ERROR( "ntuple_initialize failed" );
339  }
340  }
341 
342  if (m_evtNr%1000 == 0) {
343  ATH_MSG_INFO( m_evtNr << " events processed so far" );
344  }
345 
346  if (ntuple_clear().isFailure()) {
347  ATH_MSG_ERROR( "ntuple_clear failed" );
348  }
349 
350  bool empty = true;
351 
352  // store BeamElements
353  if (!m_beamElemContainerKey.key().empty()) {
354  empty &= storeBeamElements(*DQstatus).isFailure();
355  }
356 
357  //store Laser Object
358  if (!m_laserObjectKey.empty()) {
359  empty &= storeLaser(ctx).isFailure();
360  }
361 
362  // store TileDigits
363  empty &= storeDigits(ctx, m_fltDigitsContainerKey,m_arrays->m_sampleFlt,m_arrays->m_gainFlt,false).isFailure();
364  empty &= storeDigits(ctx, m_digitsContainerKey, m_arrays->m_sample, m_arrays->m_gain, true ).isFailure();
365 
366  // store TileRawChannels
367  // start from DSP channels - so we can find out what is the DSP units
368  empty &= storeRawChannels(ctx, m_dspRawChannelContainerKey, m_arrays->m_eDsp, m_arrays->m_tDsp, m_arrays->m_chi2Dsp, m_arrays->m_pedDsp, true ).isFailure();
369  empty &= storeRawChannels(ctx, m_rawChannelContainerKey, m_arrays->m_ene, m_arrays->m_time, m_arrays->m_chi2, m_arrays->m_ped, false).isFailure();
370  empty &= storeMFRawChannels(ctx, m_mfRawChannelContainerKey, m_arrays->m_eMF, m_arrays->m_tMF, m_arrays->m_chi2MF, m_arrays->m_pedMF, false).isFailure();
371  empty &= storeRawChannels(ctx, m_fitRawChannelContainerKey, m_arrays->m_eFit, m_arrays->m_tFit, m_arrays->m_chi2Fit, m_arrays->m_pedFit, false).isFailure();
372  empty &= storeRawChannels(ctx, m_fitcRawChannelContainerKey, m_arrays->m_eFitc, m_arrays->m_tFitc, m_arrays->m_chi2Fitc, m_arrays->m_pedFitc, false).isFailure();
373  empty &= storeRawChannels(ctx, m_optRawChannelContainerKey, m_arrays->m_eOpt, m_arrays->m_tOpt, m_arrays->m_chi2Opt, m_arrays->m_pedOpt, false).isFailure();
374  empty &= storeRawChannels(ctx, m_qieRawChannelContainerKey, m_arrays->m_eQIE, m_arrays->m_tQIE, m_arrays->m_chi2QIE, m_arrays->m_pedQIE, false).isFailure();
375  empty &= storeRawChannels(ctx, m_of1RawChannelContainerKey, m_arrays->m_eOF1, m_arrays->m_tOF1, m_arrays->m_chi2OF1, m_arrays->m_pedOF1, false).isFailure();
376  empty &= storeRawChannels(ctx, m_wienerRawChannelContainerKey, m_arrays->m_eWiener, m_arrays->m_tWiener, m_arrays->m_chi2Wiener, m_arrays->m_pedWiener, false).isFailure();
377 
378  // store TMDB data
379  //
380  empty &= storeTMDBDecision(ctx).isFailure();
381  empty &= storeTMDBDigits(ctx).isFailure();
382  empty &= storeTMDBRawChannel(ctx).isFailure();
383 
384  m_evTime = 0;
385 
386  if (m_bsInput) {
387  const eformat::FullEventFragment<const uint32_t*>* event = nullptr;
388  const eformat::ROBFragment<const uint32_t*>* robFrag = nullptr;
389  event = m_robSvc->getEvent();
390  std::vector<const ROBDataProviderSvc::ROBF*> robf;
391  // keep pointer to whole event and to CIS PAR frag internally
392  m_robSvc->getROBData(m_ROBID, robf);
393  robFrag = (robf.size() > 0 ) ? robf[0] : nullptr;
394  if (event) {
395  m_evTime = event->bc_time_seconds();
396  if ( robFrag ) {
397  // Store ROD header info from collection
398  int rod = N_RODS-1;
399  m_l1ID[rod] = robFrag->rod_lvl1_id();
400  m_l1Type[rod] = robFrag->rod_lvl1_trigger_type();
401  m_evType[rod] = robFrag->rod_detev_type();
402  m_evBCID[rod] = robFrag->rod_bc_id();
403  if (m_trigType == 0) m_trigType = -m_l1Type[rod]; // make negative to distinguish from TileCal internal trig types
404  }
405  }
406  }
407 
408  m_lumiBlock = -1; // placeholder
409 
410  //Get run and event numbers
411  m_run = ctx.eventID().run_number();
412  m_evt = ctx.eventID().event_number();
413 
414  if ( ctx.eventID().lumi_block() ){
415  m_lumiBlock = ctx.eventID().lumi_block();
416  }
417 
418  //Get timestamp of the event
419  if (ctx.eventID().time_stamp() > 0) {
420  m_evTime = ctx.eventID().time_stamp();
421  }
422 
423  if (m_evTime>0) {
424  using namespace boost::local_time;
425  using namespace boost::posix_time;
426 
427  /*
428  // just an example how to read file with time zones
429  tz_database tz_db;
430  try {
431  tz_db.load_from_file("../data/date_time_zonespec.csv");
432  time_zone_ptr gva_tz = tz_db.time_zone_from_region("Europe/Zurich");
433  }catch(data_not_accessible dna) {
434  std::cerr << "Error with time zone data file: " << dna.what() << std::endl;
435  //exit(EXIT_FAILURE);
436  }catch(bad_field_count bfc) {
437  std::cerr << "Error with time zone data file: " << bfc.what() << std::endl;
438  //exit(EXIT_FAILURE);
439  }
440  */
441  //"Europe/Zurich","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
442  static const time_zone_ptr gva_tz(new posix_time_zone((std::string)"CET+01CEST01:00:00,M3.5.0/02:00:00,M10.5.0/03:00:00"));
443  local_date_time gva_time(from_time_t(m_evTime),gva_tz);
444 
445  //std::ostringstream otime;
446  //otime << gva_time; // time in the format YYYY-MMM-DD HH:MM:SS TZ
447  //strncpy(m_dateTime,otime.str().c_str(),31);
448 
449  //time_duration hms(gva_time.time_of_day()); - will give time of the day in GMT
450  //m_HHMMSS = hms.hours()*10000+hms.minutes()*100+hms.seconds();
451 
452  struct tm gva_tm(to_tm(gva_time));
453  strftime(m_dateTime, 32, "%Y-%b-%d %H:%M:%S %Z", &gva_tm);
454  m_HHMMSS = gva_tm.tm_hour*10000+gva_tm.tm_min*100+gva_tm.tm_sec;
455 
456  // the code below is only valid when running at CERN (in Geneva time zone)
457  //struct tm *time = localtime((time_t*)(&m_evTime));
458  //m_HHMMSS = time->tm_hour*10000+time->tm_min*100+time->tm_sec;
459  //strftime(m_dateTime, 32, "%Y-%m-%d %H:%M:%S %Z", time);
460 
461  } else {
462  m_HHMMSS = -1;
463  m_dateTime[0] = '\0'; // empty string
464  }
465 
466  // store DCS data
467  if (m_checkDCS) {
468  empty &= storeDCS().isFailure();
469  }
470 
471  if (empty) {
472  ATH_MSG_WARNING( "Some problems in execute - ntuple was not filled at all" );
473  }
474 
475  // FIRST 4 EVENTS ARE SKIPPED TO RETRIEVE LASER PEDESTALS
476  if (m_ntuplePtr && m_evtNr >= m_skipEvents){
477  m_ntuplePtr->Fill();
478  } // IF
479 
480  ++m_evtNr;
481 
482  // Execution completed.
483 
484  ATH_MSG_DEBUG( "execute() completed successfully" );
485  return StatusCode::SUCCESS;
486 }
487 
488 
489 //
490 // Here the LASER object is opened and corresponding variable are stored
491 //
492 StatusCode TileAANtuple::storeLaser (const EventContext& ctx) {
493 
494  ATH_MSG_DEBUG("TileAANtuple::storeLaser()");
495  const char* gainnames[2] = {"LG","HG"};
496 
497  const TileLaserObject* laserObj = SG::makeHandle(m_laserObjectKey, ctx).get();
498 
499  m_las_BCID = laserObj->getBCID();
500 
501  m_las_Filt = laserObj->getFiltNumber();
502  m_las_ReqAmp = laserObj->getDiodeCurrOrd();
503  m_las_MeasAmp = laserObj->getDiodeCurrMeas();
504  m_las_Temperature = laserObj->getPumpDiodeTemp();
505  ATH_MSG_VERBOSE( "Laser BCID " << m_las_BCID
506  << " Filt " << m_las_Filt
507  << " ReqAmp " << m_las_ReqAmp
508  << " MeasAmp " << m_las_MeasAmp
509  << " Temp " << m_las_Temperature );
510 
511  ATH_MSG_DEBUG("LASER"<<(laserObj->isLASERII()?"II":"I")<<" VERSION IS " << laserObj->getVersion());
512 
513  if(laserObj->isLASERII()){
514  m_qdctimeout = laserObj->getQDCTimeout();
515  m_tdctimeout = laserObj->getTDCTimeout();
516  m_daqtype = laserObj->getDaqType();
517  if (msgLvl(MSG::DEBUG)) {
518  msg(MSG::DEBUG) << "DAQ Type " << m_daqtype << endmsg;
519  msg(MSG::DEBUG) << "QDC TimeOut " << m_qdctimeout << endmsg;
520  msg(MSG::DEBUG) << "TDC TimeOut " << m_tdctimeout << endmsg;
521  }
522 
523  // RETRIEVE SIGNAL IN ADC COUNTS
524  for(int chan=0;chan<28;++chan){
525  int ch=chan>>1;
526  int gn=chan&1;
527  // MONITORING DIODES
528  m_arrays->m_chan[chan] = laserObj->getDiodeADC(ch,gn);
529  ATH_MSG_DEBUG("LASERII CHANNEL " << ch << " ("<<gainnames[gn]<<") " << m_arrays->m_chan[chan]);
530  } // FOR
531 
532  for(int chan=28;chan<32;++chan){
533  int ch=(chan-28)>>1;
534  int gn=chan&1;
535  // MONITORING PMTS
536  m_arrays->m_chan[chan] = laserObj->getPMADC(ch,gn);
537  ATH_MSG_DEBUG("LASERII PMT " << ch << " ("<<gainnames[gn]<<") " << m_arrays->m_chan[chan]);
538  } // FOR
539 
540  // RETRIEVE PEDESTALS IF NOT ALREADY SET
541  for(int chan=0;chan<32;++chan){
542  int ch=chan>>1;
543  int gn=chan&1;
544  if(laserObj->isSet(ch, gn, 0) && laserObj->getMean (ch,gn,0)>0) m_arrays->m_chan_Ped[chan] = laserObj->getMean (ch,gn,0);
545  if(laserObj->isSet(ch, gn, 2) && laserObj->getMean (ch,gn,2)>0) m_arrays->m_chan_Led[chan] = laserObj->getMean (ch,gn,2);
546  if(laserObj->isSet(ch, gn, 3) && laserObj->getMean (ch,gn,3)>0) m_arrays->m_chan_Alpha[chan] = laserObj->getMean (ch,gn,3);
547  if(laserObj->isSet(ch, gn, 1) && laserObj->getMean (ch,gn,1)>0) m_arrays->m_chan_Lin[chan] = laserObj->getMean (ch,gn,1);
548  if(laserObj->isSet(ch, gn, 0) && laserObj->getSigma(ch,gn,0)>0) m_arrays->m_chan_SPed[chan] = laserObj->getSigma(ch,gn,0);
549  if(laserObj->isSet(ch, gn, 2) && laserObj->getSigma(ch,gn,2)>0) m_arrays->m_chan_SLed[chan] = laserObj->getSigma(ch,gn,2);
550  if(laserObj->isSet(ch, gn, 3) && laserObj->getSigma(ch,gn,3)>0) m_arrays->m_chan_SAlpha[chan] = laserObj->getSigma(ch,gn,3);
551  if(laserObj->isSet(ch, gn, 1) && laserObj->getSigma(ch,gn,1)>0) m_arrays->m_chan_SLin[chan] = laserObj->getSigma(ch,gn,1);
552 
553  // DEBUG OUTPUT
554  if (msgLvl(MSG::DEBUG)) {
555  msg(MSG::DEBUG) << gainnames[gn] << " CHAN " << ch << " SIG= " << m_arrays->m_chan[chan] << endmsg;
556  msg(MSG::DEBUG) << gainnames[gn] << " CHAN " << ch << " PED= " << m_arrays->m_chan_Ped[chan] << "+/-" << m_arrays->m_chan_SPed[chan] << " ( " << laserObj->isSet(ch, gn, 0) << " ) " << endmsg;
557  msg(MSG::DEBUG) << gainnames[gn] << " CHAN " << ch << " PED= " << m_arrays->m_chan_Lin[chan] << "+/-" << m_arrays->m_chan_SLin[chan] << " ( " << laserObj->isSet(ch, gn, 1) << " ) " << endmsg;
558  msg(MSG::DEBUG) << gainnames[gn] << " CHAN " << ch << " LED= " << m_arrays->m_chan_Led[chan] << "+/-" << m_arrays->m_chan_SLed[chan] << " ( " << laserObj->isSet(ch, gn, 2) << " ) " << endmsg;
559  msg(MSG::DEBUG) << gainnames[gn] << " CHAN " << ch << " ALP= " << m_arrays->m_chan_Alpha[chan] << "+/-" << m_arrays->m_chan_SAlpha[chan] << " ( " << laserObj->isSet(ch, gn, 3) << " ) " << endmsg;
560  } // IF
561  } // FOR
562  } // IF
563  else{
564  for (unsigned int gn=0; gn<TileLaserObject::nbGains; ++gn) {
565  for (unsigned int i=0; i<TileLaserObject::nbPmts; ++i) {
566  m_arrays->m_las_PMT_ADC[gn][i] = laserObj->getPMADC(i,gn);
567  m_arrays->m_las_PMT_TDC[gn][i] = laserObj->getTDC(i,gn);
568  m_arrays->m_las_PMT_Ped[gn][i] = laserObj->getPMPedestal(i,gn);
569  m_arrays->m_las_PMT_Ped_RMS[gn][i] = laserObj->getPMSigmaPedestal(i,gn);
570  ATH_MSG_VERBOSE( "LasPMT" << i << " g " << gn
571  << " adc " << m_arrays->m_las_PMT_ADC[gn][i]
572  << " ped " << m_arrays->m_las_PMT_Ped[gn][i]
573  << " rms " << m_arrays->m_las_PMT_Ped_RMS[gn][i]
574  << " tdc " << m_arrays->m_las_PMT_TDC[gn][i] );
575  } // FOR
576 
577  for (unsigned int i=0; i<14; ++i) {
578  m_arrays->m_las_D_ADC[gn][i] = laserObj->getDiodeADC(i,gn);
579  m_arrays->m_las_D_Ped[gn][i] = laserObj->getDiodePedestal(i,gn);
580  m_arrays->m_las_D_Ped_RMS[gn][i] = laserObj->getDiodeSigmaPedestal(i,gn);
581  m_arrays->m_las_D_Alpha[gn][i] = laserObj->getAlpha(i,gn);
582  m_arrays->m_las_D_Alpha_RMS[gn][i] = laserObj->getSigmaAlpha(i,gn);
583  m_arrays->m_las_D_AlphaPed[gn][i] = laserObj->getPedestalAlpha(i,gn);
584  m_arrays->m_las_D_AlphaPed_RMS[gn][i] = laserObj->getSigmaPedAlpha(i,gn);
585 
586  ATH_MSG_VERBOSE( "LasD" << i << " g " << gn
587  << " adc " << m_arrays->m_las_D_ADC[gn][i]
588  << " ped " << m_arrays->m_las_D_Ped[gn][i]
589  << " rms " << m_arrays->m_las_D_Ped_RMS[gn][i]
590  << " alp " << m_arrays->m_las_D_Alpha[gn][i]
591  << " rms " << m_arrays->m_las_D_Alpha_RMS[gn][i]
592  << " ape " << m_arrays->m_las_D_AlphaPed[gn][i]
593  << " rms " << m_arrays->m_las_D_AlphaPed_RMS[gn][i] );
594  } // FOR
595  } // FOR
596  } // ELSE
597 
598  return StatusCode::SUCCESS;
599 }
600 
601 StatusCode TileAANtuple::storeBeamElements(const TileDQstatus& DQstatus) {
602 
603  const uint32_t* cispar = DQstatus.cispar();
604 
605  uint32_t oldval = 0;
606  int last = 0;
607  for(int i = 0; i< N_CISPAR; ++i) {
608  m_cispar[i] = cispar[i];
609  if (msgLvl(MSG::VERBOSE)) {
610  if (oldval != cispar[i]) {
611  if (last < i-1) {
612  ATH_MSG_VERBOSE( "cispar[" << last << ".." << i-1 << "] = "
613  << oldval );
614  } else if (last == i-1) {
615  ATH_MSG_VERBOSE( "cispar[" << last << "] = " << oldval );
616  }
617  last = i;
618  oldval = cispar[i];
619  }
620  }
621  }
622 
623  if (msgLvl(MSG::VERBOSE)) {
624  if (last < N_CISPAR-1) {
625  ATH_MSG_VERBOSE( "cispar[" << last << ".." << N_CISPAR-1 << "] = "
626  << oldval );
627  } else {
628  ATH_MSG_VERBOSE( "cispar[" << last << "] = "<< oldval );
629  }
630  }
631 
632  m_trigType = cispar[12];
633 
634  return StatusCode::SUCCESS;
635 }
636 
637 
640 
641 StatusCode
642 TileAANtuple::storeRawChannels(const EventContext& ctx
643  , const SG::ReadHandleKey<TileRawChannelContainer>& containerKey
644  , float ene[N_ROS2][N_MODULES][N_CHANS]
645  , float time[N_ROS2][N_MODULES][N_CHANS]
646  , float chi2[N_ROS2][N_MODULES][N_CHANS]
647  , float ped[N_ROS2][N_MODULES][N_CHANS]
648  , bool fillAll)
649 {
650  if (containerKey.empty()) {// empty name, nothing to do
651  return StatusCode::FAILURE;
652  }
653 
654  // get named container
655  const TileRawChannelContainer* rcCnt =
656  SG::makeHandle (containerKey, ctx).get();
657  ATH_MSG_VERBOSE( "Container ID " << containerKey.key() );
658 
659  TileRawChannelUnit::UNIT rChUnit = rcCnt->get_unit();
660  ATH_MSG_VERBOSE( "RawChannel unit is " << rChUnit );
661 
662  bool dspCont = ( rChUnit >= TileRawChannelUnit::OnlineADCcounts );
663  if (dspCont) { // this is container with DSP results
664  m_dspUnit = rChUnit;
665  m_dspFlags = rcCnt->get_bsflags() >> 16;
666  ATH_MSG_VERBOSE( "DSP flag is 0x" << MSG::hex << m_dspFlags << MSG::dec
667  << " DSP unit is " << m_dspUnit);
668 
669  } else if ((m_useDspUnits || m_finalUnit >= TileRawChannelUnit::OnlineADCcounts)
670  && rChUnit != TileRawChannelUnit::ADCcounts) {
671  ATH_MSG_ERROR( "RawChannel units are not ADC counts, can't apply DSP-like calibration" );
672  return StatusCode::FAILURE;
673  }
674 
675  if (m_calibrateEnergy) {
676  if (m_useDspUnits) { // calibrate a-la online
677  m_rchUnit = m_dspUnit;
678  } else { // convert to final units
679  m_rchUnit = (TileRawChannelUnit::UNIT)m_finalUnit;
680  }
681  } else {
682  m_rchUnit = rChUnit;
683  }
684  ATH_MSG_VERBOSE( "Final RawChannel unit is " << m_rchUnit );
685 
686  std::vector<float> sumE(3);
687  float E[48];
688  int gain[48];
689  if (m_compareMode && dspCont) memset(m_bad,0,sizeof(m_bad));
690 
691  // Get iterator for all TRCColl in TRCCont
692  TileRawChannelContainer::const_iterator itColl = (*rcCnt).begin();
693  TileRawChannelContainer::const_iterator itCollEnd = (*rcCnt).end();
694 
695  TileRawChannelCollection::const_iterator it, itEnd;
696 
697  // Go through all TileRawChannelCollections
698  for(; itColl != itCollEnd; ++itColl) {
699  int fragId = (*itColl)->identify();
700  int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
701  int drawer = fragId & 0x3F;
702  int ROS = (fragId>>8);
703  int rosI = ROS-1;
704  int rosL = rosI;
705  int rosH = rosI + N_ROS;
706 
707  ATH_MSG_VERBOSE( "TRC ("<< containerKey.key()
708  <<") Event# "<< m_evtNr
709  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
710  << " ROS " << ROS
711  << " drawer " << drawer );
712 
713  // go through all TileRawChannels in collection
714  it = (*itColl)->begin();
715  itEnd = (*itColl)->end();
716 
717  int cmpCounter = 0;
718  if (m_compareMode) {
719  memset(E, 0, sizeof(E));
720  memset(gain, 0, sizeof(gain));
721  }
722 
723  for(; it != itEnd; ++it) {
724  const TileRawChannel* rch = (*it);
725 
726  HWIdentifier hwid = rch->adc_HWID();
727 
728  // determine channel
729  int channel = m_tileHWID->channel(hwid);
730  // convert channel number to PMT number if needed
731  if (m_pmtOrder) channel = digiChannel2PMT(ROS,channel);
732 
733  // determine gain and set ros index accordingly
734  int adc = m_tileHWID->adc(hwid);
735  if (m_calibMode) {
736  if (m_compareMode) {
737  ++cmpCounter;
738  if(cmpCounter>48) rosI = rosH;
739  else rosI = rosL;
740  } else {
741  if(adc == 1) rosI = rosH;
742  else rosI = rosL;
743  }
744  }
745 
747  float energy = rch->amplitude();
748  if (m_rchUnit != rChUnit) {
749  if (m_rchUnit < TileRawChannelUnit::OnlineOffset)
750  energy = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, energy, rChUnit, m_rchUnit);
751  else
752  energy = m_tileToolEmscale->channelCalibOnl(drawerIdx, channel, adc, energy, m_rchUnit);
753  }
754 
755  ene[rosI][drawer][channel] = energy;
756  time[rosI][drawer][channel] = rch->time();
757  chi2[rosI][drawer][channel] = rch->quality();
758  ped[rosI][drawer][channel] = rch->pedestal();
759  if (m_arrays->m_gain[rosI][drawer][channel] < 0)
760  m_arrays->m_gain[rosI][drawer][channel] = adc;
761 
762  if (m_compareMode) { // filling array for SumEt calculations
763  E[channel] = energy;
764  gain[channel] = adc;
765  if (dspCont) { // use bad flag from DSP container only
766  m_bad[rosL][drawer][channel] = (rch->quality()>15.99);
767  //} else {
768  //m_bad[rosL][drawer][channel] = m_tileBadChanTool->getAdcStatus(drawerIdx, channel, adc).isBad();
769  }
770  }
771 
772  if (msgLvl(MSG::VERBOSE)) {
773  int index,pmt;
774  rch->cell_ID_index(index,pmt);
775  ATH_MSG_VERBOSE( "TRC ch " << channel
776  << " gain " << adc
777  << " type " << std::min(index,0)
778  << " ene=" << energy
779  << " time=" << rch->time()
780  << " chi2=" << rch->quality()
781  << " ped=" << rch->pedestal() );
782  }
783  }
784 
785  if (fillAll) {
786 
787  m_arrays->m_ROD_GlobalCRC[rosL][drawer] = (*itColl)->getFragGlobalCRC() & 1;
788  m_arrays->m_ROD_BCID[rosL][drawer] = (*itColl)->getFragDSPBCID();
789  m_arrays->m_ROD_DMUMask[rosL][drawer][0] = (*itColl)->getFragRODChipMask();
790  m_arrays->m_ROD_DMUMask[rosL][drawer][1] = (*itColl)->getFragFEChipMask();
791 
792  for(unsigned int dmu=0;dmu<N_DMUS;dmu++) {
793 
794  m_arrays->m_ROD_DMUBCIDErr[rosL][drawer][dmu] = ((*itColl)->getFragBCID() >> dmu) & 1;
795  m_arrays->m_ROD_DMUmemoryErr[rosL][drawer][dmu] = ((*itColl)->getFragMemoryPar() >> dmu) & 1;
796  m_arrays->m_ROD_DMUSstrobeErr[rosL][drawer][dmu] = ((*itColl)->getFragSstrobe() >> dmu) & 1;
797  m_arrays->m_ROD_DMUDstrobeErr[rosL][drawer][dmu] = ((*itColl)->getFragDstrobe() >> dmu) & 1;
798  m_arrays->m_ROD_DMUHeadformatErr[rosL][drawer][dmu] = ((*itColl)->getFragHeaderBit() >> dmu) & 1;
799  m_arrays->m_ROD_DMUHeadparityErr[rosL][drawer][dmu] = ((*itColl)->getFragHeaderPar() >> dmu) & 1;
800  m_arrays->m_ROD_DMUDataformatErr[rosL][drawer][dmu] = ((*itColl)->getFragSampleBit() >> dmu) & 1;
801  m_arrays->m_ROD_DMUDataparityErr[rosL][drawer][dmu] = ((*itColl)->getFragSamplePar() >> dmu) & 1;
802  m_arrays->m_ROD_DMUfeCRC[rosL][drawer][dmu] = ((*itColl)->getFragFEChipMask() >> dmu) & 1;
803  m_arrays->m_ROD_DMUrodCRC[rosL][drawer][dmu] = ((*itColl)->getFragRODChipMask() >> dmu) & 1;
804  }
805  }
806 
807  if (m_compareMode) {
808  m_l2Builder->SumE(ROS,drawer,m_rchUnit,E,gain,m_bad[rosL][drawer],sumE);
809  if (dspCont) {
810  m_sumEt_xx[m_l2Builder->idToIndex(fragId)] = sumE[0];
811  m_sumEz_xx[m_l2Builder->idToIndex(fragId)] = sumE[1];
812  m_sumE_xx[m_l2Builder->idToIndex(fragId)] = sumE[2];
813  }
814  else {
815  m_sumEt_zz[m_l2Builder->idToIndex(fragId)] = sumE[0];
816  m_sumEz_zz[m_l2Builder->idToIndex(fragId)] = sumE[1];
817  m_sumE_zz[m_l2Builder->idToIndex(fragId)] = sumE[2];
818  }
819  }
820  }
821 
822  if (m_compareMode && dspCont) {
823 
824  const TileL2Container* l2Cnt = SG::makeHandle(m_l2CntKey, ctx).get();
825 
826  TileL2Container::const_iterator it = l2Cnt->begin();
827  TileL2Container::const_iterator end= l2Cnt->end();
828  int i=0;
829  for(; it != end; ++it) {
830  m_sumEt_yy[i++] = (*it)->sumEt();
831  m_sumEz_yy[i++] = (*it)->sumEz();
832  m_sumE_yy[i++] = (*it)->sumE();
833  }
834  }
835 
836  return StatusCode::SUCCESS;
837 }
838 
839 StatusCode
840 TileAANtuple::storeMFRawChannels(const EventContext& ctx
841  , const SG::ReadHandleKey<TileRawChannelContainer>& containerKey
842  , float * ene
843  , float * time
844  , float chi2[N_ROS2][N_MODULES][N_CHANS]
845  , float ped[N_ROS2][N_MODULES][N_CHANS]
846  , bool fillAll)
847 {
848  if (containerKey.empty()) {// empty name, nothing to do
849  return StatusCode::FAILURE;
850  }
851 
852  // get named container
853  const TileRawChannelContainer* rcCnt = \
854  SG::makeHandle (containerKey, ctx).get();
855 
856  TileRawChannelUnit::UNIT rChUnit = rcCnt->get_unit();
857  ATH_MSG_VERBOSE( "RawChannel unit is " << rChUnit );
858 
859  bool dspCont = ( rChUnit >= TileRawChannelUnit::OnlineADCcounts );
860  if (dspCont) { // this is container with DSP results
861  m_dspUnit = rChUnit;
862  m_dspFlags = rcCnt->get_bsflags() >> 16;
863  ATH_MSG_VERBOSE( "DSP flag is 0x" << MSG::hex << m_dspFlags << MSG::dec
864  << " DSP unit is " << m_dspUnit);
865 
866  } else if ((m_useDspUnits || m_finalUnit >= TileRawChannelUnit::OnlineADCcounts)
867  && rChUnit != TileRawChannelUnit::ADCcounts) {
868  ATH_MSG_ERROR( "RawChannel units are not ADC counts, can't apply DSP-like calibration" );
869  return StatusCode::FAILURE;
870  }
871 
872  if (m_calibrateEnergy) {
873  if (m_useDspUnits) { // calibrate a-la online
874  m_rchUnit = m_dspUnit;
875  } else { // convert to final units
876  m_rchUnit = (TileRawChannelUnit::UNIT)m_finalUnit;
877  }
878  } else {
879  m_rchUnit = rChUnit;
880  }
881  ATH_MSG_VERBOSE( "Final RawChannel unit is " << m_rchUnit );
882 
883  std::vector<float> sumE(3);
884  float E[48];
885  int gain[48];
886  if (m_compareMode && dspCont) memset(m_bad, 0, sizeof(m_bad));
887 
888  // Get iterator for all TRCColl in TRCCont
889  TileRawChannelContainer::const_iterator itColl = (*rcCnt).begin();
890  TileRawChannelContainer::const_iterator itCollEnd = (*rcCnt).end();
891 
892  TileRawChannelCollection::const_iterator it, itEnd;
893 
894  // Go through all TileRawChannelCollections
895  for (; itColl != itCollEnd; ++itColl) {
896  int fragId = (*itColl)->identify();
897  int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
898  int drawer = fragId & 0x3F;
899  int ROS = (fragId >> 8);
900  int rosI = ROS - 1;
901  int rosL = rosI;
902  int rosH = rosI + N_ROS;
903 
904  ATH_MSG_VERBOSE( "TRC ("<< containerKey.key()
905  <<") Event# "<< m_evtNr
906  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
907  << " ROS " << ROS
908  << " drawer " << drawer );
909 
910  // go through all TileRawChannels in collection
911  it = (*itColl)->begin();
912  itEnd = (*itColl)->end();
913 
914  int cmpCounter = 0;
915  if (m_compareMode) {
916  memset(E, 0, sizeof(E));
917  memset(gain, 0, sizeof(gain));
918  }
919  for(; it != itEnd; ++it) {
920  const TileRawChannel* rch = (*it);
921 
922  HWIdentifier hwid=rch->adc_HWID();
923 
924  // determine channel
925  int channel = m_tileHWID->channel(hwid);
926  // convert channel number to PMT number if needed
927  if (m_pmtOrder) channel = digiChannel2PMT(ROS,channel);
928 
929  // determine gain and set ros index accordingly
930  int adc = m_tileHWID->adc(hwid);
931  if (m_calibMode) {
932  if (m_compareMode) {
933  ++cmpCounter;
934  if(cmpCounter>48) rosI = rosH;
935  else rosI = rosL;
936  } else {
937  if(adc == 1) rosI = rosH;
938  else rosI = rosL;
939  }
940  }
941 
943  float energy = 0.;
944  for (int i = 0; i < 7; ++i) {
945  energy = rch->amplitude(i);
946  if (m_rchUnit != rChUnit) {
947  if (m_rchUnit < TileRawChannelUnit::OnlineOffset)
948  energy = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, energy, rChUnit, m_rchUnit);
949  else
950  energy = m_tileToolEmscale->channelCalibOnl(drawerIdx, channel, adc, energy, m_rchUnit);
951  }
952 
953  ene[sample_ind(rosI,drawer,channel,i)] = energy;
954  time[sample_ind(rosI,drawer,channel,i)] = rch->time(i);
955  }
956  chi2[rosI][drawer][channel] = rch->quality();
957  ped[rosI][drawer][channel] = rch->pedestal();
958 
959  if (m_arrays->m_gain[rosI][drawer][channel] < 0)
960  m_arrays->m_gain[rosI][drawer][channel] = adc;
961 
962  if (m_compareMode) { // filling array for SumEt calculations
963  E[channel] = ene[sample_ind(rosI,drawer,channel,0)];
964  gain[channel] = adc;
965  if (dspCont) { // use bad flag from DSP container only
966  m_bad[rosL][drawer][channel] = (rch->quality() > 15.99);
967  //} else {
968  //m_bad[rosL][drawer][channel] = m_tileBadChanTool->getAdcStatus(drawerIdx, channel, adc).isBad();
969  }
970  }
971 
972  if (msgLvl(MSG::VERBOSE)) {
973  int index,pmt;
974  rch->cell_ID_index(index,pmt);
975  ATH_MSG_VERBOSE( "TRC ch " << channel
976  << " gain " << adc
977  << " type " << std::min(index,0)
978  << " ene=" << ene[sample_ind(rosI,drawer,channel,0)]
979  << " time=" << rch->time()
980  << " chi2=" << rch->quality()
981  << " ped=" << rch->pedestal() );
982  }
983  }
984 
985  if (fillAll) {
986 
987  m_arrays->m_ROD_GlobalCRC[rosL][drawer] = (*itColl)->getFragGlobalCRC() & 1;
988  m_arrays->m_ROD_BCID[rosL][drawer] = (*itColl)->getFragDSPBCID();
989  m_arrays->m_ROD_DMUMask[rosL][drawer][0] = (*itColl)->getFragRODChipMask();
990  m_arrays->m_ROD_DMUMask[rosL][drawer][1] = (*itColl)->getFragFEChipMask();
991 
992  for(unsigned int dmu=0;dmu<N_DMUS;dmu++) {
993 
994  m_arrays->m_ROD_DMUBCIDErr[rosL][drawer][dmu] = ((*itColl)->getFragBCID() >> dmu) & 1;
995  m_arrays->m_ROD_DMUmemoryErr[rosL][drawer][dmu] = ((*itColl)->getFragMemoryPar() >> dmu) & 1;
996  m_arrays->m_ROD_DMUSstrobeErr[rosL][drawer][dmu] = ((*itColl)->getFragSstrobe() >> dmu) & 1;
997  m_arrays->m_ROD_DMUDstrobeErr[rosL][drawer][dmu] = ((*itColl)->getFragDstrobe() >> dmu) & 1;
998  m_arrays->m_ROD_DMUHeadformatErr[rosL][drawer][dmu] = ((*itColl)->getFragHeaderBit() >> dmu) & 1;
999  m_arrays->m_ROD_DMUHeadparityErr[rosL][drawer][dmu] = ((*itColl)->getFragHeaderPar() >> dmu) & 1;
1000  m_arrays->m_ROD_DMUDataformatErr[rosL][drawer][dmu] = ((*itColl)->getFragSampleBit() >> dmu) & 1;
1001  m_arrays->m_ROD_DMUDataparityErr[rosL][drawer][dmu] = ((*itColl)->getFragSamplePar() >> dmu) & 1;
1002  m_arrays->m_ROD_DMUfeCRC[rosL][drawer][dmu] = ((*itColl)->getFragFEChipMask() >> dmu) & 1;
1003  m_arrays->m_ROD_DMUrodCRC[rosL][drawer][dmu] = ((*itColl)->getFragRODChipMask() >> dmu) & 1;
1004  }
1005  }
1006 
1007  if (m_compareMode) {
1008  m_l2Builder->SumE(ROS, drawer, m_rchUnit, E, gain, m_bad[rosL][drawer], sumE);
1009  if (dspCont) {
1010  m_sumEt_xx[m_l2Builder->idToIndex(fragId)] = sumE[0];
1011  m_sumEz_xx[m_l2Builder->idToIndex(fragId)] = sumE[1];
1012  m_sumE_xx[m_l2Builder->idToIndex(fragId)] = sumE[2];
1013  }
1014  else {
1015  m_sumEt_zz[m_l2Builder->idToIndex(fragId)] = sumE[0];
1016  m_sumEz_zz[m_l2Builder->idToIndex(fragId)] = sumE[1];
1017  m_sumE_zz[m_l2Builder->idToIndex(fragId)] = sumE[2];
1018  }
1019  }
1020  }
1021 
1022  if (m_compareMode && dspCont) {
1023 
1024  const TileL2Container* l2Cnt = SG::makeHandle(m_l2CntKey, ctx).get();
1025 
1026  TileL2Container::const_iterator it = l2Cnt->begin();
1027  TileL2Container::const_iterator end= l2Cnt->end();
1028  int i=0;
1029  for(; it != end; ++it) {
1030  m_sumEt_yy[i++] = (*it)->sumEt();
1031  m_sumEz_yy[i++] = (*it)->sumEz();
1032  m_sumE_yy[i++] = (*it)->sumE();
1033  }
1034  }
1035 
1036  return StatusCode::SUCCESS;
1037 }
1038 
1042 
1043 StatusCode
1044 TileAANtuple::storeDigits(const EventContext& ctx
1045  , const SG::ReadHandleKey<TileDigitsContainer>& containerKey
1046  , short *a_sample
1047  , short a_gain[N_ROS2][N_MODULES][N_CHANS]
1048  , bool fillAll)
1049 {
1050  if (containerKey.empty()) // empty name, nothing to do
1051  return StatusCode::FAILURE;
1052 
1053  // Read Digits from TES
1054  const TileDigitsContainer* digitsCnt =
1055  SG::makeHandle (containerKey, ctx).get();
1056 
1057  bool emptyColl = true;
1058 
1059  // Get iterator for all TDColl in TDCont
1060  TileDigitsContainer::const_iterator itColl = (*digitsCnt).begin();
1061  TileDigitsContainer::const_iterator itCollEnd = (*digitsCnt).end();
1062 
1063  // Go through all TileDigitsCollections
1064  for(; itColl != itCollEnd; ++itColl) {
1065  int fragId = (*itColl)->identify();
1066  int drawer = fragId & 0x3F;
1067  int ROS = (fragId>>8);
1068  int rosI = ROS-1;
1069  int rosL = rosI;
1070  int rosH = rosI + N_ROS;
1071 
1072  if (msgLvl(MSG::VERBOSE)) {
1073  ATH_MSG_VERBOSE( "Event# " << m_evtNr
1074  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1075  << " ROS " << ROS
1076  << " drawer " << drawer );
1077 
1078  if (fillAll) {
1079  ATH_MSG_VERBOSE( " Size=" << (*itColl)->getFragSize()
1080  << " BCID=" << (*itColl)->getFragBCID() << MSG::hex
1081  << " CRC=0x" << ((*itColl)->getFragCRC()&0xffff)
1082  << " DMUMask=0x" << ((*itColl)->getFragDMUMask()&0xffff) << MSG::dec );
1083 
1084  ATH_MSG_VERBOSE( " Lvl1ID=" << (*itColl)->getLvl1Id()
1085  << " Lvl1Type=" << (*itColl)->getLvl1Type()
1086  << " EvBCID=" << (*itColl)->getRODBCID()
1087  << " EvType=" << (*itColl)->getDetEvType() );
1088 
1089  ATH_MSG_VERBOSE(" Header=" << (*itColl)->getFragChipHeaderWords() );
1090  }
1091  }
1092 
1095  int rod = (rosL*N_MODULES + drawer);
1096  if (N_RODS<128) {
1097  rod >>= 2;
1098  } else if (N_RODS<256) {
1099  rod = (((rod>>2)<<1) | (rod&1));
1100  }
1101 
1102  m_l1ID[rod] = (*itColl)->getLvl1Id();
1103  m_l1Type[rod] = (*itColl)->getLvl1Type();
1104  m_evType[rod] = (*itColl)->getDetEvType();
1105  m_evBCID[rod] = (*itColl)->getRODBCID();
1106  if (m_trigType == 0) m_trigType = -m_l1Type[rod]; // make negative to distinguish from TileCal internal trig types
1107 
1108  TileDigitsCollection::const_iterator it = (*itColl)->begin();
1109  TileDigitsCollection::const_iterator itEnd = (*itColl)->end();
1110 
1111  // non empty collection
1112  if(it != itEnd) {
1113  emptyColl = false;
1114 
1115  if (fillAll) {
1116 
1117  // store evtnr, bcid,crc, size
1118  // Same for lo and hi, because they come from the same fragment
1119 
1120  m_arrays->m_rodBCID[rosL][drawer] = (*itColl)->getRODBCID();
1121  m_arrays->m_fragSize[rosL][drawer]=(*itColl)->getFragSize();
1122 
1123  m_arrays->m_slinkCRC[rosL][drawer][0] = ((*itColl)->getFragCRC()>>16) & 0xffff;
1124  m_arrays->m_dmuMask[rosL][drawer][0] = ((*itColl)->getFragDMUMask()>>16) & 0xffff;
1125  m_arrays->m_slinkCRC[rosL][drawer][1] = (*itColl)->getFragCRC() & 0xffff;
1126  m_arrays->m_dmuMask[rosL][drawer][1] = (*itColl)->getFragDMUMask() & 0xffff;
1127 
1128  uint32_t CRCmask = (*itColl)->getFragDMUMask(); //mask of FE+ROD DMU crc check (16bit+16bit) 0xffffffff == All ok
1129  uint32_t fe_crc = CRCmask & 0xFFFF;
1130  uint32_t rod_crc = CRCmask >> 16;
1131 
1132  const std::vector<uint32_t> & headerVec = (*itColl)->getFragChipHeaderWords();
1133  unsigned int headsize = std::min(16U, static_cast<unsigned int>(headerVec.size()));
1134 
1135  for (unsigned int ih = 0; ih < headsize; ++ih) {
1136 
1137  m_arrays->m_DMUheader[rosL][drawer][ih] = headerVec[ih];
1138  m_arrays->m_DMUbcid[rosL][drawer][ih] = (headerVec[ih] & 0xFFF);
1139  m_arrays->m_DMUformatErr[rosL][drawer][ih] = CheckDMUFormat(headerVec[ih]);
1140  m_arrays->m_DMUparityErr[rosL][drawer][ih] = CheckDMUParity(headerVec[ih]);
1141  m_arrays->m_DMUmemoryErr[rosL][drawer][ih] = (headerVec[ih] >> 25 & 0x1);
1142  m_arrays->m_DMUSstrobeErr[rosL][drawer][ih] = (headerVec[ih] >> 24 & 0x1);
1143  m_arrays->m_DMUDstrobeErr[rosL][drawer][ih] = (headerVec[ih] >> 23 & 0x1);
1144 
1145  m_arrays->m_feCRC[rosL][drawer][ih] = (fe_crc >> ih & 0x1);
1146  m_arrays->m_rodCRC[rosL][drawer][ih] = (rod_crc >> ih & 0x1);
1147  }
1148 
1149  if (m_calibMode) {
1150  const std::vector<uint32_t> & headerVecHi = (*itColl)->getFragChipHeaderWordsHigh();
1151  unsigned int headsizehi = std::min(16U, static_cast<unsigned int>(headerVecHi.size()));
1152 
1153  for (unsigned int ih = 0; ih < headsizehi; ++ih) {
1154 
1155  m_arrays->m_DMUheader[rosH][drawer][ih] = headerVecHi[ih];
1156  m_arrays->m_DMUbcid[rosH][drawer][ih] = (headerVecHi[ih] & 0xFFF);
1157  m_arrays->m_DMUformatErr[rosH][drawer][ih] = CheckDMUFormat(headerVecHi[ih]);
1158  m_arrays->m_DMUparityErr[rosH][drawer][ih] = CheckDMUParity(headerVecHi[ih]);
1159  m_arrays->m_DMUmemoryErr[rosH][drawer][ih] = (headerVecHi[ih] >> 25 & 0x1);
1160  m_arrays->m_DMUSstrobeErr[rosH][drawer][ih] = (headerVecHi[ih] >> 24 & 0x1);
1161  m_arrays->m_DMUDstrobeErr[rosH][drawer][ih] = (headerVecHi[ih] >> 23 & 0x1);
1162 
1163  m_arrays->m_feCRC[rosH][drawer][ih] = -1 ; //Variables must be filled anyway, empty variables are not allowed
1164  m_arrays->m_rodCRC[rosH][drawer][ih] = -1; //Variables must be filled anyway, empty variables are not allowed
1165  }
1166  }
1167  }
1168 
1169 
1170  int cmpCounter = 0;
1171  // go through all TileDigits in collection
1172  for (; it != itEnd; ++it) {
1173  const TileDigits* digit = (*it);
1174 
1175  HWIdentifier hwid = digit->adc_HWID();
1176 
1177  // determine channel
1178  int channel = m_tileHWID->channel(hwid);
1179  // convert channel number to PMT number if needed
1180  if (m_pmtOrder) channel = digiChannel2PMT(ROS,channel);
1181 
1182  // determine gain and set ros index accordingly
1183  int gain = m_tileHWID->adc(hwid);
1184  if (m_calibMode) {
1185  if (m_compareMode) {
1186  ++cmpCounter;
1187  if (cmpCounter > 48) rosI = rosH;
1188  else rosI = rosL;
1189  } else {
1190  if (gain == 1) rosI = rosH;
1191  else rosI = rosL;
1192  }
1193  }
1194 
1195  a_gain[rosI][drawer][channel] = gain;
1196 
1197  // get digits
1198  const std::vector<float> & sampleVec = digit->samples();
1199  int siz = sampleVec.size();
1200  if (msgLvl(MSG::VERBOSE)) {
1201  int index,pmt;
1202  digit->cell_ID_index(index,pmt);
1203  msg(MSG::VERBOSE) << "TD ch " << channel
1204  << " gain "<< gain
1205  << " type " << std::min(index,0) << " {";
1206  for(int i=0;i<siz;i++) {
1207  msg(MSG::VERBOSE) <<(int)sampleVec[i] << " ";
1208  }
1209  }
1210  // changed N_SAMPLES to number of samples from tile configurator
1211  if (siz > m_nSamples) {
1212  siz = m_nSamples;
1213  if (msgLvl(MSG::VERBOSE))
1214  ATH_MSG_VERBOSE( "} ONLY " << siz << " digits saved to ntuple" );
1215  } else {
1216  if (msgLvl(MSG::VERBOSE))
1217  ATH_MSG_VERBOSE( "}" );
1218  }
1219  for (int n = 0; n < siz; ++n) {
1220  a_sample[sample_ind(rosI,drawer,channel,n)] = (short) sampleVec[n];
1221  }
1222  }
1223  }
1224  }
1225 
1226  if (emptyColl) return StatusCode::FAILURE;
1227  else return StatusCode::SUCCESS;
1228 }
1229 
1230 StatusCode TileAANtuple::storeTMDBDecision(const EventContext& ctx) {
1231 
1232  const char * part[4] = {"LBA","LBC","EBA","EBC"};
1233 
1234  // Read Decision from TES
1235  //
1236  if (!m_tileMuRcvContainerKey.empty()){
1237 
1238  ATH_MSG_VERBOSE( "reading TMDB decision from " << m_tileMuRcvContainerKey.key() );
1239 
1240  const TileMuonReceiverContainer *decisionCnt =
1241  SG::makeHandle (m_tileMuRcvContainerKey, ctx).get();
1242 
1243  TileMuonReceiverContainer::const_iterator it = decisionCnt->begin();
1244  TileMuonReceiverContainer::const_iterator itLast = decisionCnt->end();
1245 
1246  // Go through all decisions
1247  //
1248  int bcid[3]={0};
1249 
1250  for(; it != itLast; ++it) {
1251 
1252  const TileMuonReceiverObj * obj = (*it);
1253 
1254  const std::vector<bool> & decision = obj->GetDecision();
1255  int siz = decision.size();
1256 
1257  if (siz>0) {
1258 
1259  int fragId = (*it)->identify();
1260  int drawer = fragId & 0x3F;
1261  int ros = ((fragId>>8) & 0xF) - 1;
1262  bcid[2] = ((fragId>>24) & 0xF);
1263  bcid[1] = ((fragId>>20) & 0xF);
1264  bcid[0] = ((fragId>>16) & 0XF);
1265 
1266  if (siz > N_TMDBDECISIONS) {
1267  ATH_MSG_VERBOSE( "TMDB ONLY " << N_TMDBDECISIONS << " decisions saved to ntuple instead of " << siz);
1268  siz = N_TMDBDECISIONS;
1269  }
1270 
1271  for (int n = 0; n < siz; ++n) {
1272  m_arrays->m_decisionTMDB[ros][drawer][n] = (unsigned char) decision[n];
1273  }
1274 
1275  for (int n = 0; n < 3; ++n) {
1276  m_arrays->m_bcidTMDB[ros][drawer][n] = (unsigned char) bcid[n];
1277  }
1278 
1279  if (msgLvl(MSG::VERBOSE)) {
1280  std::stringstream ss;
1281  for (int n = 0; n < siz; ++n) {
1282  ss<<std::setw(5)<<(int)m_arrays->m_decisionTMDB[ros][drawer][n];
1283  }
1284  ATH_MSG_VERBOSE( "TMDB 0x" <<MSG::hex<< fragId <<MSG::dec<<" "<< part[ros]
1285  << std::setfill('0') << std::setw(2)
1286  << drawer+1 << std::setfill(' ')
1287  << " BCID check " << bcid[0] <<"/"<< bcid[1] <<"/"<< bcid[2] << " decision: " << ss.str() );
1288  }
1289  }
1290  }
1291  }
1292 
1293  return StatusCode::SUCCESS;
1294 }
1295 
1296 StatusCode TileAANtuple::storeTMDBDigits(const EventContext& ctx) {
1297 
1298  const char * part[4] = {"LBA","LBC","EBA","EBC"};
1299 
1300  // Read Digits from TES
1301  //
1302  if (!m_tileMuRcvDigitsContainerKey.empty()){
1303 
1304  ATH_MSG_VERBOSE( "reading TMDB digits from " << m_tileMuRcvDigitsContainerKey.key() );
1305 
1306  const TileDigitsContainer* digitsCnt =
1307  SG::makeHandle (m_tileMuRcvDigitsContainerKey, ctx).get();
1308 
1309  TileDigitsContainer::const_iterator itColl1 = (*digitsCnt).begin();
1310  TileDigitsContainer::const_iterator itCollEnd1 = (*digitsCnt).end();
1311 
1312  // Go through all TileDigitsCollections
1313  for(; itColl1 != itCollEnd1; ++itColl1) {
1314 
1315  TileDigitsCollection::const_iterator it1 = (*itColl1)->begin();
1316  TileDigitsCollection::const_iterator itEnd1 = (*itColl1)->end();
1317 
1318  if (it1!=itEnd1) {
1319 
1320  int fragId = (*itColl1)->identify();
1321  int drawer = fragId & 0x3F;
1322  int ros = (fragId>>8) - 1;
1323  int ichannel = 0;
1324 
1325  ATH_MSG_VERBOSE( "TMDB 0x" <<MSG::hex<< fragId <<MSG::dec<<" "<< part[ros]
1326  << std::setfill('0') << std::setw(2)
1327  << drawer+1 << std::setfill(' ') );
1328 
1329  for (; it1 != itEnd1; ++it1) {
1330 
1331  if (ichannel>=N_TMDBCHANS) {
1332  ATH_MSG_WARNING("Too many channels in TMDB Digi container for frag 0x" <<MSG::hex<< fragId <<MSG::dec <<" keeping only first " << N_TMDBCHANS << " channels in ntuple ");
1333  break;
1334  }
1335 
1336  const TileDigits* digit = (*it1);
1337 
1338  // get digits
1339  const std::vector<float> & sampleVec = digit->samples();
1340  int siz = sampleVec.size();
1341 
1342  if (siz > m_nSamples) {
1343  ATH_MSG_VERBOSE( "TMDB ONLY " << m_nSamples << " digits saved to ntuple instead of " << siz);
1344  siz = m_nSamples;
1345  }
1346 
1347  for (int n = 0; n < siz; ++n) {
1348  m_arrays->m_sampleTMDB[sample_ind_TMDB(ros,drawer,ichannel,n)] = (unsigned char) sampleVec[n];
1349  }
1350 
1351  if (msgLvl(MSG::VERBOSE)) {
1352  std::stringstream ss;
1353  for (int n = 0; n < siz; ++n) {
1354  ss<<std::setw(5)<<(int)m_arrays->m_sampleTMDB[sample_ind_TMDB(ros,drawer,ichannel,n)];
1355  }
1356  ATH_MSG_VERBOSE( "TMDB dig: " <<ros+1<<"/"<<drawer<<"/"<<m_tileHWID->channel(digit->adc_HWID())<<": "<<ss.str() );
1357  }
1358 
1359  ++ichannel;
1360  }
1361  }
1362  }
1363  }
1364 
1365  return StatusCode::SUCCESS;
1366 }
1367 
1368 StatusCode TileAANtuple::storeTMDBRawChannel(const EventContext& ctx) {
1369 
1370  const char * part[4] = {"LBA","LBC","EBA","EBC"};
1371 
1372  // Read Raw Channels from TDS
1373  //
1374  if (!m_tileMuRcvRawChannelContainerKey.empty()){
1375 
1376  ATH_MSG_VERBOSE( "reading TMDB energies from " << m_tileMuRcvRawChannelContainerKey.key() );
1377 
1378  const TileRawChannelContainer* rcCnt =
1379  SG::makeHandle (m_tileMuRcvRawChannelContainerKey, ctx).get();
1380 
1381  TileRawChannelContainer::const_iterator itColl2 = (*rcCnt).begin();
1382  TileRawChannelContainer::const_iterator itCollEnd2 = (*rcCnt).end();
1383 
1384  // Go through all TileDigitsCollections
1385  for(; itColl2 != itCollEnd2; ++itColl2) {
1386 
1387  TileRawChannelCollection::const_iterator it2 = (*itColl2)->begin();
1388  TileRawChannelCollection::const_iterator itEnd2 = (*itColl2)->end();
1389 
1390  if (it2!=itEnd2) {
1391 
1392  int fragId = (*itColl2)->identify();
1393  int drawer = fragId & 0x3F;
1394  int ros = (fragId>>8) - 1;
1395  int ichannel = 0;
1396 
1397  ATH_MSG_VERBOSE( "TMDB 0x" <<MSG::hex<< fragId <<MSG::dec<<" "<< part[ros]
1398  << std::setfill('0') << std::setw(2)
1399  << drawer+1 << std::setfill(' ') );
1400 
1401  for (; it2 != itEnd2; ++it2) {
1402 
1403  if (ichannel>=N_TMDBCHANS) {
1404  ATH_MSG_WARNING("Too many channels in TMDB RCh container for frag 0x" <<MSG::hex<< fragId <<MSG::dec <<" keeping only first " << N_TMDBCHANS << " channels in ntuple ");
1405  break;
1406  }
1407 
1408  const TileRawChannel* rc = (*it2);
1409 
1410  m_arrays->m_eTMDB[ros][drawer][ichannel] = rc -> amplitude();
1411 
1412  ATH_MSG_VERBOSE( "TMDB rc: " <<ros+1<<"/"<<drawer<<"/"<<m_tileHWID->channel(rc->adc_HWID())<< ": " << m_arrays->m_eTMDB[ros][drawer][ichannel] );
1413 
1414  ++ichannel;
1415  }
1416  }
1417  }
1418  }
1419 
1420  return StatusCode::SUCCESS;
1421 }
1422 
1423 StatusCode
1424 TileAANtuple::finalize() {
1425 
1426  if (m_arrays->m_sample) free(m_arrays->m_sample);
1427  if (m_arrays->m_sampleFlt) free(m_arrays->m_sampleFlt);
1428  if (m_arrays->m_sampleTMDB) free(m_arrays->m_sampleTMDB);
1429  if (m_arrays->m_eMF) free(m_arrays->m_eMF);
1430  if (m_arrays->m_tMF) free(m_arrays->m_tMF);
1431 
1432  ATH_MSG_INFO( "finalize() successfully" );
1433  return StatusCode::SUCCESS;
1434 }
1435 
1436 StatusCode
1437 TileAANtuple::ntuple_clear() {
1438 
1439  TRIGGER_clearBranch();
1440  CISPAR_clearBranch();
1441  LASER_clearBranch();
1442  DIGI_clearBranch();
1443  TMDB_clearBranch();
1444 
1445  return StatusCode::SUCCESS;
1446 }
1447 
1448 StatusCode
1449 TileAANtuple::initNTuple(const EventContext& ctx) {
1450  //Aux Ntuple creation
1451 
1452  if (m_compressSettings >= 0) {
1453  std::vector<std::string> files;
1454  m_fileMgr->getFiles(Io::ROOT, ( Io::WRITE | Io::CREATE ), files);
1455  for (std::string& file : files) {
1456  TFile* outFile = (TFile*) m_fileMgr->fptr(file);
1457  if (outFile) {
1458  ATH_MSG_INFO("Changing compressing settings to " << m_compressSettings << " for file: " << file);
1459  outFile->SetCompressionSettings(m_compressSettings);
1460  }
1461  }
1462  }
1463 
1464  if (m_ntupleID.size() > 0) {
1465 
1466  std::string ntupleID = m_ntupleID + "_map";
1467 
1468  TTree* ntuplePtr = new TTree(ntupleID.c_str(), "TileCal-CellMap");
1469  if(m_thistSvc->regTree("/" + m_streamName + "/" + ntupleID, ntuplePtr).isFailure()) {
1470  ATH_MSG_ERROR( "Problem registering TileRec CellMap Tree" );
1471  }
1472 
1473  fillCellMap(ntuplePtr);
1474 
1475  //Ntuple creation
1476  m_ntuplePtr = new TTree(m_ntupleID.c_str(), "TileCal-Ntuple");
1477  m_ntuplePtr->SetMaxTreeSize(m_treeSize);
1478  if (m_thistSvc->regTree("/" + m_streamName + "/" + m_ntupleID, m_ntuplePtr).isFailure()) {
1479  ATH_MSG_ERROR( "Problem registering TileRec Tree");
1480  }
1481 
1482  TRIGGER_addBranch();
1483  CISPAR_addBranch();
1484  if (!m_laserObjectKey.empty()) {
1485  const TileLaserObject* laserObj =
1486  SG::makeHandle(m_laserObjectKey, ctx).get();
1487  m_las_version = laserObj->getVersion();
1488  LASER_addBranch();
1489  }
1490  DIGI_addBranch();
1491  TMDB_addBranch();
1492  }
1493 
1494  //DCS Ntuple creation
1495  if (m_checkDCS) {
1496  std::string ntupleDCS = "Tile_DCS";
1497  m_DCSntuplePtr = new TTree(ntupleDCS.c_str(), "TileCal-DCS data");
1498  if (m_thistSvc->regTree("/" + m_streamName + "/" + ntupleDCS, m_DCSntuplePtr).isFailure()) {
1499  ATH_MSG_ERROR( "Problem registering TileRec DCS Tree");
1500  }
1501  DCS_addBranch();
1502  }
1503 
1504  return StatusCode::SUCCESS;
1505 }
1506 
1507 
1510 
1525 
1531 
1533 
1534 void TileAANtuple::fillCellMap(TTree* ntuplePtr) {
1535 
1536  float eta[4][64][48];
1537  float phi[4][64][48];
1538  short tower[4][64][48];
1539  short sample[4][64][48];
1540  short ind[4][64][48];
1541  short pmt[4][64][48];
1542  short bad[4][64][48][2];
1543 
1544  CLEAR(eta);
1545  CLEAR(phi);
1546  CLEAR1(tower);
1547  CLEAR1(sample);
1548  CLEAR1(ind);
1549  CLEAR(pmt);
1550  CLEAR1(bad);
1551 
1552  ntuplePtr->Branch("eta", eta, "eta[4][64][48]/F");
1553  ntuplePtr->Branch("phi", phi, "phi[4][64][48]/F");
1554  ntuplePtr->Branch("tower", tower, "tower[4][64][48]/S");
1555  ntuplePtr->Branch("sample", sample, "sample[4][64][48]/S");
1556  ntuplePtr->Branch("ind", ind, "ind[4][64][48]/S");
1557  ntuplePtr->Branch("pmt", pmt, "pmt[4][64][48]/S");
1558  ntuplePtr->Branch("bad", bad, "bad[4][64][48][2]/S");
1559 
1560  TileDetDescrManager::calo_element_const_iterator itr = m_tileMgr->tile_cell_begin();
1561  TileDetDescrManager::calo_element_const_iterator end = m_tileMgr->tile_cell_end();
1562 
1563  for (; itr != end; ++itr) {
1564  const CaloDetDescrElement * caloDDE = (*itr);
1565  Identifier cell_id = caloDDE->identify();
1566  IdentifierHash hash[2] = { caloDDE->onl1(), caloDDE->onl2() };
1567  for (int i = 0; i < 2; ++i) {
1568  if (hash[i] != TileHWID::NOT_VALID_HASH) {
1569  HWIdentifier adc_id = m_tileHWID->adc_id(hash[i], 0);
1570  int ROS = m_tileHWID->ros(adc_id);
1571  int drawer = m_tileHWID->drawer(adc_id);
1572  int chan = m_tileHWID->channel(adc_id);
1573  int index, pm;
1574  m_cabling->h2s_cell_id_index(adc_id, index, pm); // index=-2 for MBTS or -1 for all disconnected channels
1575  if (index > -1) index = i; // just put back 0 or 1 for all connected channels
1576  pm = m_cabling->channel2hole(ROS, chan); // convert channel to PMT number, ignoring difference between drawers
1577  if ((ROS == 3 && drawer == 14) || (ROS == 4 && drawer == 17)) {
1578  if (pm < 0) pm = -pm; // crack scin in EBA15 EBC18 in non-standard place - recover positive pmt number
1579  if (chan == 2 || chan == 3) pm = -pm; // no D4 in special EBA15 EBC18 - put negative sign
1580  }
1581  if (m_pmtOrder) chan = digiChannel2PMT(ROS,chan); // convert channel to PMT-1
1582  int rosI = ROS-1; // make ros index from 0 to 3
1583  eta[rosI][drawer][chan] = caloDDE->eta();
1584  phi[rosI][drawer][chan] = caloDDE->phi();
1585  tower[rosI][drawer][chan] = m_tileID->tower(cell_id);
1586  sample[rosI][drawer][chan] = m_tileID->sample(cell_id);
1587  ind[rosI][drawer][chan] = index;
1588  pmt[rosI][drawer][chan] = pm;
1589  }
1590  }
1591  }
1592 
1593  const MbtsDetDescrManager* mbtsMgr;
1594  if ( detStore()->retrieve(mbtsMgr).isFailure() ) {
1595  ATH_MSG_WARNING( "Unable to retrieve MbtsDetDescrManager from DetectorStore" );
1596  mbtsMgr = 0;
1597  }
1598  for (int ROS = 1; ROS < 5; ++ROS) {
1599  int rosI = ROS - 1;
1600  for (int drawer = 0; drawer < 64; ++drawer) {
1601  for (int chan = 0; chan < 48; ++chan) {
1602  for (int adc = 0; adc < 2; ++adc) {
1603  HWIdentifier adc_id = m_tileHWID->adc_id(ROS, drawer, chan, adc);
1604  bad[rosI][drawer][chan][adc] = (short) m_tileBadChanTool->encodeStatus(m_tileBadChanTool->getAdcStatus(adc_id));
1605  int index, pm;
1606  Identifier cell_id = m_cabling->h2s_cell_id_index(adc_id, index, pm);
1607  if (index == -2) { // MBTS
1608  ind[rosI][drawer][chan] = index;
1609  pmt[rosI][drawer][chan] = 1; // we know that all MBTS are in PMT 1
1610  if (mbtsMgr) {
1611  const CaloDetDescrElement * caloDDE = mbtsMgr->get_element(cell_id);
1612  if (caloDDE) {
1613  if (caloDDE->z() > 0.0)
1614  eta[rosI][drawer][chan] = fabs(caloDDE->eta());
1615  else
1616  eta[rosI][drawer][chan] = -fabs(caloDDE->eta());
1617  phi[rosI][drawer][chan] = caloDDE->phi();
1618  }
1619  }
1620  }
1621  }
1622  }
1623  }
1624  }
1625 
1626  ntuplePtr->Fill();
1627 }
1628 
1629 
1633 
1635 
1636 void TileAANtuple::TRIGGER_addBranch(void) {
1637  m_ntuplePtr->Branch("EvTime",&m_evTime,"EvTime/I");
1638  m_ntuplePtr->Branch("Run",&m_run,"Run/I");
1639  m_ntuplePtr->Branch("LumiBlock",&m_lumiBlock,"LumiBlock/I");
1640  m_ntuplePtr->Branch("Evt",&m_evt,"Evt/I");
1641  m_ntuplePtr->Branch("EvtNr",&m_evtNr,"EvtNr/I");
1642  m_ntuplePtr->Branch("Trig",&m_trigType,"Trig/I");
1643  m_ntuplePtr->Branch("DSPflags",&m_dspFlags,"DSPflags/i");
1644  m_ntuplePtr->Branch("DSPunits",&m_dspUnit,"DSPunits/S");
1645  m_ntuplePtr->Branch("OFLunits",&m_rchUnit,"OFLunits/S");
1646 
1647  if (m_bsInput) {
1648  std::string dim = "[" + std::to_string(N_RODS) + "]/I";
1649  m_ntuplePtr->Branch("L1ID", m_l1ID, NAME2("L1ID", dim));
1650  m_ntuplePtr->Branch("L1Type", m_l1Type, NAME2("L1Type",dim));
1651  m_ntuplePtr->Branch("EvType", m_evType, NAME2("EvType",dim));
1652  m_ntuplePtr->Branch("EvBCID", m_evBCID, NAME2("EvBCID",dim));
1653  }
1654 }
1655 
1656 
1659 
1662 
1663 void TileAANtuple::TRIGGER_clearBranch(void) {
1664  m_evTime=0;
1665  m_run=0;
1666  m_evt=0;
1667  m_trigType=0;
1668  m_dspFlags=0;
1669 
1670  CLEAR1(m_l1ID);
1671  CLEAR1(m_l1Type);
1672  CLEAR1(m_evType);
1673  CLEAR1(m_evBCID);
1674 }
1675 
1676 
1680 
1682 
1683 void TileAANtuple::CISPAR_addBranch(void) {
1684  if (!m_beamElemContainerKey.key().empty()) {
1685  m_ntuplePtr->Branch("cispar",m_cispar,"cispar[110]/i");
1686  }
1687 }
1688 
1689 
1692 
1695 
1696 void TileAANtuple::CISPAR_clearBranch(void) {
1697  if (!m_beamElemContainerKey.key().empty()) {
1698  CLEAR(m_cispar);
1699  }
1700 }
1701 
1702 
1706 
1708 
1709 void TileAANtuple::LASER_addBranch(void) {
1710 
1711  if (!m_laserObjectKey.empty()) {
1712 
1713  const char* gainnames[2] = {"LG","HG"};
1714  const char* channames[16] = {"Diode0","Diode1","Diode2","Diode3","Diode4","Diode5","Diode6","Diode7",
1715  "Diode8","Diode9","ExtCIS0","IntCIS","DiodePhocal","ExtCIS1","PMT1","PMT2"};
1716 
1717  m_ntuplePtr->Branch("LASER_BCID", &m_las_BCID, "LASER_BCID/I");
1718 
1719  m_ntuplePtr->Branch("LASER_FILTER", &m_las_Filt, "LASER_FILTER/I");
1720  m_ntuplePtr->Branch("LASER_REQAMP", &m_las_ReqAmp, "LASER_REQAMP/F");
1721  m_ntuplePtr->Branch("LASER_MEASAMP", &m_las_MeasAmp, "LASER_MEASAMP/F");
1722 
1723  if(m_las_version==2) {
1724 
1725  ATH_MSG_DEBUG("LASERII BRANCHING..");
1726 
1727  m_ntuplePtr->Branch(Form("LASER_QDCTIMEOUT"),&(m_qdctimeout),Form("LASER_QDCTIMEOUT/O"));
1728  m_ntuplePtr->Branch(Form("LASER_TDCTIMEOUT"),&(m_tdctimeout),Form("LASER_TDCTIMEOUT/O"));
1729  m_ntuplePtr->Branch(Form("LASER_DAQTYPE"),&(m_daqtype),Form("LASER_DAQTYPE/I"));
1730  for(int chan=0;chan<32;++chan){
1731  int ch=chan>>1;
1732  int gn=chan&1;
1733  m_ntuplePtr->Branch(Form("LASER_%s_%s_ADC",gainnames[gn],channames[ch]),&(m_arrays->m_chan[chan]),Form("LASER_%s_%s_ADC/I",gainnames[gn],channames[ch]));
1734  m_ntuplePtr->Branch(Form("LASER_%s_%s_Ped",gainnames[gn],channames[ch]),&(m_arrays->m_chan_Ped[chan]),Form("LASER_%s_%s_Ped/F",gainnames[gn],channames[ch]));
1735  m_ntuplePtr->Branch(Form("LASER_%s_%s_Led",gainnames[gn],channames[ch]),&(m_arrays->m_chan_Led[chan]),Form("LASER_%s_%s_Led/F",gainnames[gn],channames[ch]));
1736  m_ntuplePtr->Branch(Form("LASER_%s_%s_Ped1",gainnames[gn],channames[ch]),&(m_arrays->m_chan_Lin[chan]),Form("LASER_%s_%s_Ped1/F",gainnames[gn],channames[ch]));
1737  m_ntuplePtr->Branch(Form("LASER_%s_%s_Alpha",gainnames[gn],channames[ch]),&(m_arrays->m_chan_Alpha[chan]),Form("LASER_%s_%s_Alpha/F",gainnames[gn],channames[ch]));
1738  m_ntuplePtr->Branch(Form("LASER_%s_%s_Sigma_Ped",gainnames[gn],channames[ch]),&(m_arrays->m_chan_SPed[chan]),Form("LASER_%s_%s_Sigma_Ped/F",gainnames[gn],channames[ch]));
1739  m_ntuplePtr->Branch(Form("LASER_%s_%s_Sigma_Led",gainnames[gn],channames[ch]),&(m_arrays->m_chan_SLed[chan]),Form("LASER_%s_%s_Sigma_Led/F",gainnames[gn],channames[ch]));
1740  m_ntuplePtr->Branch(Form("LASER_%s_%s_Sigma_Ped1",gainnames[gn],channames[ch]),&(m_arrays->m_chan_SLin[chan]),Form("LASER_%s_%s_Sigma_Ped1/F",gainnames[gn],channames[ch]));
1741  m_ntuplePtr->Branch(Form("LASER_%s_%s_Sigma_Alpha",gainnames[gn],channames[ch]),&(m_arrays->m_chan_SAlpha[chan]),Form("LASER_%s_%s_Sigma_Alpha/F",gainnames[gn],channames[ch]));
1742  } // FOR
1743 
1744  } else {
1745 
1746  ATH_MSG_DEBUG("LASERI BRANCHING..");
1747 
1748  m_ntuplePtr->Branch("LASER_Diode_1_ADC", &(m_arrays->m_las_D_ADC[0][0]), "LASER_Diode_1_ADC/I");
1749  m_ntuplePtr->Branch("LASER_Diode_2_ADC", &(m_arrays->m_las_D_ADC[0][1]), "LASER_Diode_2_ADC/I");
1750  m_ntuplePtr->Branch("LASER_Diode_3_ADC", &(m_arrays->m_las_D_ADC[0][2]), "LASER_Diode_3_ADC/I");
1751  m_ntuplePtr->Branch("LASER_Diode_4_ADC", &(m_arrays->m_las_D_ADC[0][3]), "LASER_Diode_4_ADC/I");
1752 
1753  m_ntuplePtr->Branch("LASER_Diode_1_Ped", &(m_arrays->m_las_D_Ped[0][0]), "LASER_Diode_1_Ped/F");
1754  m_ntuplePtr->Branch("LASER_Diode_2_Ped", &(m_arrays->m_las_D_Ped[0][1]), "LASER_Diode_2_Ped/F");
1755  m_ntuplePtr->Branch("LASER_Diode_3_Ped", &(m_arrays->m_las_D_Ped[0][2]), "LASER_Diode_3_Ped/F");
1756  m_ntuplePtr->Branch("LASER_Diode_4_Ped", &(m_arrays->m_las_D_Ped[0][3]), "LASER_Diode_4_Ped/F");
1757 
1758  m_ntuplePtr->Branch("LASER_Diode_1_Ped_RMS", &(m_arrays->m_las_D_Ped_RMS[0][0]), "LASER_Diode_1_Ped_RMS/F");
1759  m_ntuplePtr->Branch("LASER_Diode_2_Ped_RMS", &(m_arrays->m_las_D_Ped_RMS[0][1]), "LASER_Diode_2_Ped_RMS/F");
1760  m_ntuplePtr->Branch("LASER_Diode_3_Ped_RMS", &(m_arrays->m_las_D_Ped_RMS[0][2]), "LASER_Diode_3_Ped_RMS/F");
1761  m_ntuplePtr->Branch("LASER_Diode_4_Ped_RMS", &(m_arrays->m_las_D_Ped_RMS[0][3]), "LASER_Diode_4_Ped_RMS/F");
1762 
1763  m_ntuplePtr->Branch("LASER_Diode_1_Alpha", &(m_arrays->m_las_D_Alpha[0][0]), "LASER_Diode_1_Alpha/F");
1764  m_ntuplePtr->Branch("LASER_Diode_2_Alpha", &(m_arrays->m_las_D_Alpha[0][1]), "LASER_Diode_2_Alpha/F");
1765  m_ntuplePtr->Branch("LASER_Diode_3_Alpha", &(m_arrays->m_las_D_Alpha[0][2]), "LASER_Diode_3_Alpha/F");
1766  m_ntuplePtr->Branch("LASER_Diode_4_Alpha", &(m_arrays->m_las_D_Alpha[0][3]), "LASER_Diode_4_Alpha/F");
1767 
1768  m_ntuplePtr->Branch("LASER_Diode_1_Alpha_RMS", &(m_arrays->m_las_D_Alpha_RMS[0][0]), "LASER_Diode_1_Alpha_RMS/F");
1769  m_ntuplePtr->Branch("LASER_Diode_2_Alpha_RMS", &(m_arrays->m_las_D_Alpha_RMS[0][1]), "LASER_Diode_2_Alpha_RMS/F");
1770  m_ntuplePtr->Branch("LASER_Diode_3_Alpha_RMS", &(m_arrays->m_las_D_Alpha_RMS[0][2]), "LASER_Diode_3_Alpha_RMS/F");
1771  m_ntuplePtr->Branch("LASER_Diode_4_Alpha_RMS", &(m_arrays->m_las_D_Alpha_RMS[0][3]), "LASER_Diode_4_Alpha_RMS/F");
1772 
1773  m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed", &(m_arrays->m_las_D_AlphaPed[0][0]), "LASER_Diode_1_AlphaPed/F");
1774  m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed", &(m_arrays->m_las_D_AlphaPed[0][1]), "LASER_Diode_2_AlphaPed/F");
1775  m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed", &(m_arrays->m_las_D_AlphaPed[0][2]), "LASER_Diode_3_AlphaPed/F");
1776  m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed", &(m_arrays->m_las_D_AlphaPed[0][3]), "LASER_Diode_4_AlphaPed/F");
1777 
1778  m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed_RMS", &(m_arrays->m_las_D_AlphaPed_RMS[0][0]), "LASER_Diode_1_AlphaPed_RMS/F");
1779  m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed_RMS", &(m_arrays->m_las_D_AlphaPed_RMS[0][1]), "LASER_Diode_2_AlphaPed_RMS/F");
1780  m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed_RMS", &(m_arrays->m_las_D_AlphaPed_RMS[0][2]), "LASER_Diode_3_AlphaPed_RMS/F");
1781  m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed_RMS", &(m_arrays->m_las_D_AlphaPed_RMS[0][3]), "LASER_Diode_4_AlphaPed_RMS/F");
1782 
1783  m_ntuplePtr->Branch("LASER_PMT_1_ADC", &(m_arrays->m_las_PMT_ADC[0][0]), "LASER_PMT_1_ADC/I");
1784  m_ntuplePtr->Branch("LASER_PMT_2_ADC", &(m_arrays->m_las_PMT_ADC[0][1]), "LASER_PMT_2_ADC/I");
1785 
1786  m_ntuplePtr->Branch("LASER_PMT_1_TDC", &(m_arrays->m_las_PMT_TDC[0][0]), "LASER_PMT_1_TDC/I");
1787  m_ntuplePtr->Branch("LASER_PMT_2_TDC", &(m_arrays->m_las_PMT_TDC[0][1]), "LASER_PMT_2_TDC/I");
1788 
1789  m_ntuplePtr->Branch("LASER_PMT_1_Ped", &(m_arrays->m_las_PMT_Ped[0][0]), "LASER_PMT_1_Ped/F");
1790  m_ntuplePtr->Branch("LASER_PMT_2_Ped", &(m_arrays->m_las_PMT_Ped[0][1]), "LASER_PMT_2_Ped/F");
1791 
1792  m_ntuplePtr->Branch("LASER_PMT_1_Ped_RMS", &(m_arrays->m_las_PMT_Ped_RMS[0][0]), "LASER_PMT_1_Ped_RMS/F");
1793  m_ntuplePtr->Branch("LASER_PMT_2_Ped_RMS", &(m_arrays->m_las_PMT_Ped_RMS[0][1]), "LASER_PMT_2_Ped_RMS/F");
1794 
1795  }
1796 
1797  m_ntuplePtr->Branch("LASER_HEAD_Temp", &m_las_Temperature, "LASER_HEAD_Temp/F");
1798  }
1799 }
1800 
1801 
1804 
1807 
1808 void TileAANtuple::LASER_clearBranch(void) {
1809 
1810  if (!m_laserObjectKey.empty()) {
1811 
1812  m_las_BCID = 0;
1813 
1814  m_las_Filt = 0;
1815  m_las_ReqAmp = 0.0;
1816  m_las_MeasAmp = 0.0;
1817  m_las_Temperature = 0.0;
1818 
1819  // LASERII
1820  // memset(m_arrays->m_chan, 0, sizeof(m_arrays->m_chan));
1821  // memset(m_arrays->m_chan_Ped, 0, sizeof(m_arrays->m_chan_Ped));
1822  // memset(m_arrays->m_chan_Led, 0, sizeof(m_arrays->m_chan_Led));
1823  // memset(m_arrays->m_chan_Lin, 0, sizeof(m_arrays->m_chan_Lin));
1824  // memset(m_arrays->m_chan_Alpha, 0, sizeof(m_arrays->m_chan_Alpha));
1825  // memset(m_arrays->m_chan_SPed, 0, sizeof(m_arrays->m_chan_SPed));
1826  // memset(m_arrays->m_chan_SLed, 0, sizeof(m_arrays->m_chan_SLed));
1827  // memset(m_arrays->m_chan_SLin, 0, sizeof(m_arrays->m_chan_SLin));
1828  // memset(m_arrays->m_chan_SAlpha, 0, sizeof(m_arrays->m_chan_SAlpha));
1829 
1830  // LASERI
1831  memset(m_arrays->m_las_D_ADC, 0, sizeof(m_arrays->m_las_D_ADC));
1832  memset(m_arrays->m_las_D_Ped, 0, sizeof(m_arrays->m_las_D_Ped));
1833  memset(m_arrays->m_las_D_Ped_RMS, 0, sizeof(m_arrays->m_las_D_Ped_RMS));
1834  memset(m_arrays->m_las_D_Alpha, 0, sizeof(m_arrays->m_las_D_Alpha));
1835  memset(m_arrays->m_las_D_Alpha_RMS, 0, sizeof(m_arrays->m_las_D_Alpha_RMS));
1836  memset(m_arrays->m_las_D_AlphaPed, 0, sizeof(m_arrays->m_las_D_AlphaPed));
1837  memset(m_arrays->m_las_D_AlphaPed_RMS, 0, sizeof(m_arrays->m_las_D_AlphaPed_RMS));
1838 
1839  memset(m_arrays->m_las_PMT_ADC, 0, sizeof(m_arrays->m_las_PMT_ADC));
1840  memset(m_arrays->m_las_PMT_TDC, 0, sizeof(m_arrays->m_las_PMT_TDC));
1841  memset(m_arrays->m_las_PMT_Ped, 0, sizeof(m_arrays->m_las_PMT_Ped));
1842  memset(m_arrays->m_las_PMT_Ped_RMS, 0, sizeof(m_arrays->m_las_PMT_Ped_RMS));
1843 
1844  }
1845 }
1846 
1847 
1851 
1853 
1854 void TileAANtuple::DIGI_addBranch(void)
1855 {
1856  std::string suf[3] = {"_lo","_hi",""};
1857  if (m_compareMode) {
1858  suf[0] = "_xx";
1859  suf[1] = "_yy";
1860  suf[2] = "_zz";
1861  m_ntuplePtr->Branch(NAME2("sumEt",suf[0]), m_sumEt_xx, NAME3("sumEt", suf[0],"[4][64]/F")); // float
1862  m_ntuplePtr->Branch(NAME2("sumEz",suf[0]), m_sumEz_xx, NAME3("sumEz", suf[0],"[4][64]/F")); // float
1863  m_ntuplePtr->Branch(NAME2("sumE", suf[0]), m_sumE_xx, NAME3("sumE", suf[0],"[4][64]/F")); // float
1864  m_ntuplePtr->Branch(NAME2("sumEt",suf[1]), m_sumEt_yy, NAME3("sumEt", suf[1],"[4][64]/F")); // float
1865  m_ntuplePtr->Branch(NAME2("sumEz",suf[1]), m_sumEz_yy, NAME3("sumEz", suf[1],"[4][64]/F")); // float
1866  m_ntuplePtr->Branch(NAME2("sumE", suf[1]), m_sumE_yy, NAME3("sumE", suf[1],"[4][64]/F")); // float
1867  m_ntuplePtr->Branch(NAME2("sumEt",suf[2]), m_sumEt_zz, NAME3("sumEt", suf[2],"[4][64]/F")); // float
1868  m_ntuplePtr->Branch(NAME2("sumEz",suf[2]), m_sumEz_zz, NAME3("sumEz", suf[2],"[4][64]/F")); // float
1869  m_ntuplePtr->Branch(NAME2("sumE", suf[2]), m_sumE_zz, NAME3("sumE", suf[2],"[4][64]/F")); // float
1870  }
1871 
1872  int sample_size = N_ROS*N_MODULES*N_CHANS*m_nSamples;
1873 
1874  int imin = 2, imax = 3, ir = 0, is = 0;
1875 
1876  if (m_calibMode) {
1877  imin = 0;
1878  imax = 2;
1879  }
1880 
1881  if (!m_mfRawChannelContainerKey.empty()) {
1882  int size = sample_size * (imax-imin);
1883  m_arrays->m_eMF = (float *) malloc(size*sizeof(float));
1884  m_arrays->m_tMF = (float *) malloc(size*sizeof(float));
1885  }
1886 
1887  for (int i = imin; i < imax; ++i) {
1888 
1889  std::string f_suf(suf[i]);
1890 
1891  if (m_fltDigitsContainerKey.empty() && m_digitsContainerKey.empty()
1892  && (!m_rawChannelContainerKey.empty()
1893  || !m_fitRawChannelContainerKey.empty()
1894  || !m_fitcRawChannelContainerKey.empty()
1895  || !m_optRawChannelContainerKey.empty()
1896  || !m_qieRawChannelContainerKey.empty()
1897  || !m_dspRawChannelContainerKey.empty()
1898  || !m_mfRawChannelContainerKey.empty()
1899  || !m_of1RawChannelContainerKey.empty()
1900  || !m_wienerRawChannelContainerKey.empty()
1901  || !m_bsInput) ) {
1902 
1903  m_ntuplePtr->Branch(NAME2("gain",f_suf), m_arrays->m_gain[ir], NAME3("gain", f_suf,"[4][64][48]/S")); // short
1904 
1905  } else {
1906 
1907  std::string samples = "[4][64][48][" + std::to_string(m_nSamples) + "]/S";
1908 
1909  if (!m_fltDigitsContainerKey.empty()) {
1910  if (!m_digitsContainerKey.empty()) { // should use different names for two containers
1911 
1912  m_ntuplePtr->Branch(NAME2("sampleFlt",f_suf), &(m_arrays->m_sample[is]), NAME3("sampleFlt", f_suf, samples)); // short
1913  m_ntuplePtr->Branch(NAME2("gainFlt",f_suf), m_arrays->m_gainFlt[ir], NAME3("gainFlt", f_suf,"[4][64][48]/S")); // short
1914  } else {
1915  m_ntuplePtr->Branch(NAME2("sample",f_suf), &(m_arrays->m_sampleFlt[is]), NAME3("sampleFlt", f_suf, samples)); // short
1916  if (!m_rawChannelContainerKey.empty()
1917  || !m_fitRawChannelContainerKey.empty()
1918  || !m_fitcRawChannelContainerKey.empty()
1919  || !m_optRawChannelContainerKey.empty()
1920  || !m_qieRawChannelContainerKey.empty()
1921  || !m_of1RawChannelContainerKey.empty()
1922  || !m_dspRawChannelContainerKey.empty()
1923  || !m_wienerRawChannelContainerKey.empty()
1924  || m_bsInput) {
1925 
1926  m_ntuplePtr->Branch(NAME2("gain",f_suf), m_arrays->m_gain[ir], NAME3("gain", f_suf,"[4][64][48]/S")); // short
1927  } else {
1928  m_ntuplePtr->Branch(NAME2("gain",f_suf), m_arrays->m_gainFlt[ir], NAME3("gainFlt", f_suf,"[4][64][48]/S")); // short
1929  }
1930  }
1931  }
1932 
1933  if (!m_digitsContainerKey.empty()) {
1934  m_ntuplePtr->Branch(NAME2("sample",f_suf), &(m_arrays->m_sample[is]), NAME3("sample", f_suf, samples)); // short
1935  m_ntuplePtr->Branch(NAME2("gain",f_suf), m_arrays->m_gain[ir], NAME3("gain", f_suf,"[4][64][48]/S")); // short
1936 
1937  if (m_bsInput) {
1938  m_ntuplePtr->Branch(NAME2("DMUheader",f_suf), m_arrays->m_DMUheader[ir], NAME3("DMUheader", f_suf,"[4][64][16]/i")); // uint32
1939  m_ntuplePtr->Branch(NAME2("DMUBCID",f_suf), m_arrays->m_DMUbcid[ir], NAME3("DMUBCID", f_suf,"[4][64][16]/S")); // short
1940  m_ntuplePtr->Branch(NAME2("DMUmemoryErr",f_suf), m_arrays->m_DMUmemoryErr[ir], NAME3("DMUmemoryErr", f_suf,"[4][64][16]/S")); // short
1941  m_ntuplePtr->Branch(NAME2("DMUSstrobeErr",f_suf), m_arrays->m_DMUSstrobeErr[ir], NAME3("DMUSstrobeErr", f_suf,"[4][64][16]/S")); // short
1942  m_ntuplePtr->Branch(NAME2("DMUDstrobeErr",f_suf), m_arrays->m_DMUDstrobeErr[ir], NAME3("DMUDstrobeErr", f_suf,"[4][64][16]/S")); // short
1943  m_ntuplePtr->Branch(NAME2("DMUheadformatErr",f_suf),m_arrays->m_DMUformatErr[ir], NAME3("DMUheadformatErr", f_suf,"[4][64][16]/S")); // short
1944  m_ntuplePtr->Branch(NAME2("DMUheadparityErr",f_suf),m_arrays->m_DMUparityErr[ir], NAME3("DMUheadparityErr", f_suf,"[4][64][16]/S")); // short
1945 
1946  m_ntuplePtr->Branch(NAME2("feCRC",f_suf), m_arrays->m_feCRC[ir], NAME3("feCRC", f_suf,"[4][64][16]/S")); // short
1947  m_ntuplePtr->Branch(NAME2("rodCRC",f_suf), m_arrays->m_rodCRC[ir], NAME3("rodCRC", f_suf,"[4][64][16]/S")); // short
1948 
1949  if (i == imin) { // common for low and high gain
1950  m_ntuplePtr->Branch("rodBCID", m_arrays->m_rodBCID, "rodBCID[4][64]/S"); // short
1951  m_ntuplePtr->Branch("fragSize", m_arrays->m_fragSize,"fragSize[4][64]/S"); // short
1952  m_ntuplePtr->Branch("DMUmask", m_arrays->m_dmuMask, "DMUmask[4][64][2]/s"); // unsigned short
1953  m_ntuplePtr->Branch("slinkCRC", m_arrays->m_slinkCRC,"slinkCRC[4][64][2]/s"); // unsigned short
1954  }
1955  }
1956  }
1957  }
1958 
1959  if (!m_rawChannelContainerKey.empty()) {
1960  m_ntuplePtr->Branch(NAME2("ene",f_suf), m_arrays->m_ene[ir], NAME3("ene",f_suf,"[4][64][48]/F")); // float
1961  m_ntuplePtr->Branch(NAME2("time",f_suf), m_arrays->m_time[ir], NAME3("time",f_suf,"[4][64][48]/F")); // float
1962  m_ntuplePtr->Branch(NAME2("ped",f_suf), m_arrays->m_ped[ir], NAME3("ped",f_suf,"[4][64][48]/F")); // float
1963  m_ntuplePtr->Branch(NAME2("chi2",f_suf), m_arrays->m_chi2[ir], NAME3("chi2",f_suf,"[4][64][48]/F")); // float
1964  }
1965 
1966  if (!m_fitRawChannelContainerKey.empty()) {
1967  m_ntuplePtr->Branch(NAME2("eFit",f_suf), m_arrays->m_eFit[ir], NAME3("eFit",f_suf,"[4][64][48]/F")); // float
1968  m_ntuplePtr->Branch(NAME2("tFit",f_suf), m_arrays->m_tFit[ir], NAME3("tFit",f_suf,"[4][64][48]/F")); // float
1969  m_ntuplePtr->Branch(NAME2("pedFit",f_suf), m_arrays->m_pedFit[ir], NAME3("pedFit",f_suf,"[4][64][48]/F")); // float
1970  m_ntuplePtr->Branch(NAME2("chi2Fit",f_suf), m_arrays->m_chi2Fit[ir], NAME3("chi2Fit",f_suf,"[4][64][48]/F")); // float
1971  }
1972 
1973  if (!m_fitcRawChannelContainerKey.empty()) {
1974  m_ntuplePtr->Branch(NAME2("eFitc",f_suf), m_arrays->m_eFitc[ir], NAME3("eFitc",f_suf,"[4][64][48]/F")); // float
1975  m_ntuplePtr->Branch(NAME2("tFitc",f_suf), m_arrays->m_tFitc[ir], NAME3("tFitc",f_suf,"[4][64][48]/F")); // float
1976  m_ntuplePtr->Branch(NAME2("pedFitc",f_suf), m_arrays->m_pedFitc[ir], NAME3("pedFitc",f_suf,"[4][64][48]/F")); // float
1977  m_ntuplePtr->Branch(NAME2("chi2Fitc",f_suf),m_arrays->m_chi2Fitc[ir],NAME3("chi2Fitc",f_suf,"[4][64][48]/F")); // float
1978  }
1979 
1980  if (!m_optRawChannelContainerKey.empty()) {
1981  m_ntuplePtr->Branch(NAME2("eOpt",f_suf), m_arrays->m_eOpt[ir], NAME3("eOpt",f_suf,"[4][64][48]/F")); // float
1982  m_ntuplePtr->Branch(NAME2("tOpt",f_suf), m_arrays->m_tOpt[ir], NAME3("tOpt",f_suf,"[4][64][48]/F")); // float
1983  m_ntuplePtr->Branch(NAME2("pedOpt",f_suf), m_arrays->m_pedOpt[ir], NAME3("pedOpt",f_suf,"[4][64][48]/F")); // float
1984  m_ntuplePtr->Branch(NAME2("chi2Opt",f_suf), m_arrays->m_chi2Opt[ir], NAME3("chi2Opt",f_suf,"[4][64][48]/F")); // float
1985  }
1986 
1987  if (!m_qieRawChannelContainerKey.empty()) {
1988  m_ntuplePtr->Branch(NAME2("eQIE",f_suf), m_arrays->m_eQIE[ir], NAME3("eQIE",f_suf,"[4][64][48]/F")); // float
1989  m_ntuplePtr->Branch(NAME2("tQIE",f_suf), m_arrays->m_tQIE[ir], NAME3("tQIE",f_suf,"[4][64][48]/F")); // float
1990  m_ntuplePtr->Branch(NAME2("pedQIE",f_suf), m_arrays->m_pedQIE[ir], NAME3("pedQIE",f_suf,"[4][64][48]/F")); // float
1991  m_ntuplePtr->Branch(NAME2("chi2QIE",f_suf), m_arrays->m_chi2QIE[ir], NAME3("chi2QIE",f_suf,"[4][64][48]/F")); // float
1992  }
1993 
1994  if (!m_of1RawChannelContainerKey.empty()) {
1995  m_ntuplePtr->Branch(NAME2("eOF1",f_suf), m_arrays->m_eOF1[ir], NAME3("eOF1",f_suf,"[4][64][48]/F")); // float
1996  m_ntuplePtr->Branch(NAME2("tOF1",f_suf), m_arrays->m_tOF1[ir], NAME3("tOF1",f_suf,"[4][64][48]/F")); // float
1997  m_ntuplePtr->Branch(NAME2("pedOF1",f_suf), m_arrays->m_pedOF1[ir], NAME3("pedOF1",f_suf,"[4][64][48]/F")); // float
1998  m_ntuplePtr->Branch(NAME2("chi2OF1",f_suf), m_arrays->m_chi2OF1[ir], NAME3("chi2OF1",f_suf,"[4][64][48]/F")); // float
1999  }
2000 
2001  if (!m_dspRawChannelContainerKey.empty() && !m_reduced) {
2002  m_ntuplePtr->Branch(NAME2("eDsp",f_suf), m_arrays->m_eDsp[ir], NAME3("eDsp",f_suf,"[4][64][48]/F")); // float
2003  m_ntuplePtr->Branch(NAME2("tDsp",f_suf), m_arrays->m_tDsp[ir], NAME3("tDsp",f_suf,"[4][64][48]/F")); // float
2004  m_ntuplePtr->Branch(NAME2("pedDsp",f_suf), m_arrays->m_pedDsp[ir], NAME3("pedDsp",f_suf,"[4][64][48]/F")); // float
2005  m_ntuplePtr->Branch(NAME2("chi2Dsp",f_suf), m_arrays->m_chi2Dsp[ir], NAME3("chi2Dsp",f_suf,"[4][64][48]/F")); // float
2006  }
2007 
2008  if (!m_wienerRawChannelContainerKey.empty()) {
2009  m_ntuplePtr->Branch(NAME2("eWiener",f_suf), m_arrays->m_eWiener[ir], NAME3("eWiener",f_suf,"[4][64][48]/F")); // float
2010  m_ntuplePtr->Branch(NAME2("tWiener",f_suf), m_arrays->m_tWiener[ir], NAME3("tWiener",f_suf,"[4][64][48]/F")); // float
2011  m_ntuplePtr->Branch(NAME2("pedWiener",f_suf), m_arrays->m_pedWiener[ir], NAME3("pedWiener",f_suf,"[4][64][48]/F")); // float
2012  m_ntuplePtr->Branch(NAME2("chi2Wiener",f_suf), m_arrays->m_chi2Wiener[ir], NAME3("chi2Wiener",f_suf,"[4][64][48]/F")); // float
2013  }
2014 
2015  if (!m_mfRawChannelContainerKey.empty()) {
2016  std::string f_samples = "[4][64][48][" + std::to_string(m_nSamples) + "]/F";
2017  m_ntuplePtr->Branch(NAME2("eMF",f_suf), &(m_arrays->m_eMF[is]), NAME3("eMF",f_suf,f_samples)); // float
2018  m_ntuplePtr->Branch(NAME2("tMF",f_suf), &(m_arrays->m_tMF[is]), NAME3("tMF",f_suf,f_samples)); // float
2019  m_ntuplePtr->Branch(NAME2("chi2MF",f_suf), m_arrays->m_chi2MF[ir], NAME3("chi2MF",f_suf,"[4][64][48]/F")); // float
2020  m_ntuplePtr->Branch(NAME2("pedMF",f_suf), m_arrays->m_pedMF[ir], NAME3("pedMF",f_suf,"[4][64][48]/F")); // float
2021  }
2022 
2023  if (m_bsInput) {
2024  if (i == imin) { // common for low and high gain
2025  m_ntuplePtr->Branch("ROD_GlobalCRC", m_arrays->m_ROD_GlobalCRC, "ROD_GlobalCRC[4][64]/S"); // short
2026  m_ntuplePtr->Branch("ROD_BCID", m_arrays->m_ROD_BCID, "ROD_BCID[4][64]/S"); // short
2027  m_ntuplePtr->Branch("ROD_DMUBCIDErr", m_arrays->m_ROD_DMUBCIDErr, "ROD_DMUBCIDErr[4][64][16]/S"); // short
2028  m_ntuplePtr->Branch("ROD_DMUmemoryErr", m_arrays->m_ROD_DMUmemoryErr, "ROD_DMUmemoryErr[4][64][16]/S"); // short
2029  m_ntuplePtr->Branch("ROD_DMUSstrobeErr", m_arrays->m_ROD_DMUSstrobeErr, "ROD_DMUSstrobeErr[4][64][16]/S"); // short
2030  m_ntuplePtr->Branch("ROD_DMUDstrobeErr", m_arrays->m_ROD_DMUDstrobeErr, "ROD_DMUDstrobeErr[4][64][16]/S"); // short
2031  m_ntuplePtr->Branch("ROD_DMUheadformatErr",m_arrays->m_ROD_DMUHeadformatErr, "ROD_DMUheadformatErr[4][64][16]/S"); // short
2032  m_ntuplePtr->Branch("ROD_DMUheadparityErr",m_arrays->m_ROD_DMUHeadparityErr, "ROD_DMUheadparityErr[4][64][16]/S"); // short
2033  m_ntuplePtr->Branch("ROD_DMUdataformatErr",m_arrays->m_ROD_DMUDataformatErr, "ROD_DMUdataformatErr[4][64][16]/S"); // short
2034  m_ntuplePtr->Branch("ROD_DMUdataparityErr",m_arrays->m_ROD_DMUDataparityErr, "ROD_DMUdataparityErr[4][64][16]/S"); // short
2035 
2036  m_ntuplePtr->Branch("ROD_feCRC", m_arrays->m_ROD_DMUfeCRC, "ROD_feCRC[4][64][16]/S"); // short
2037  m_ntuplePtr->Branch("ROD_rodCRC", m_arrays->m_ROD_DMUrodCRC, "ROD_rodCRC[4][64][16]/S"); // short
2038  m_ntuplePtr->Branch("ROD_DMUmask", m_arrays->m_ROD_DMUMask, "ROD_DMUmask[4][64][2]/s"); // unsigned short
2039  }
2040  }
2041  ir += N_ROS;
2042  is += sample_size;
2043  }
2044 }
2045 
2050 
2051 void TileAANtuple::DIGI_clearBranch(void) {
2052  unsigned int size = (m_calibMode) ? 1 : 2;
2053 
2054  if (m_compareMode) {
2055  CLEAR(m_sumEt_xx);
2056  CLEAR(m_sumEt_yy);
2057  CLEAR(m_sumEt_zz);
2058  CLEAR(m_sumEz_xx);
2059  CLEAR(m_sumEz_yy);
2060  CLEAR(m_sumEz_zz);
2061  CLEAR(m_sumE_xx);
2062  CLEAR(m_sumE_yy);
2063  CLEAR(m_sumE_zz);
2064  }
2065 
2066  CLEAR3(m_arrays->m_gain, size);
2067 
2068  if (!m_fltDigitsContainerKey.empty()) {
2069  CLEAR5(m_arrays->m_sampleFlt, size);
2070  CLEAR3(m_arrays->m_gainFlt, size);
2071  }
2072 
2073  if (!m_digitsContainerKey.empty()) {
2074 
2075  CLEAR5(m_arrays->m_sample,size);
2076 
2077  if (m_bsInput) {
2078  CLEAR2(m_arrays->m_DMUheader, size);
2079  CLEAR3(m_arrays->m_DMUbcid, size);
2080  CLEAR3(m_arrays->m_DMUformatErr, size);
2081  CLEAR3(m_arrays->m_DMUparityErr, size);
2082  CLEAR3(m_arrays->m_DMUmemoryErr, size);
2083  CLEAR3(m_arrays->m_DMUSstrobeErr, size);
2084  CLEAR3(m_arrays->m_DMUDstrobeErr, size);
2085 
2086  CLEAR3(m_arrays->m_feCRC, size);
2087  CLEAR3(m_arrays->m_rodCRC, size);
2088 
2089  CLEAR1(m_arrays->m_rodBCID);
2090  CLEAR1(m_arrays->m_fragSize);
2091  CLEAR(m_arrays->m_dmuMask);
2092  CLEAR(m_arrays->m_slinkCRC);
2093  }
2094 
2095  }
2096 
2097  if (!m_rawChannelContainerKey.empty()) {
2098  CLEAR2(m_arrays->m_ene, size);
2099  CLEAR2(m_arrays->m_time, size);
2100  CLEAR2(m_arrays->m_ped, size);
2101  CLEAR2(m_arrays->m_chi2, size);
2102  }
2103 
2104  if (!m_fitRawChannelContainerKey.empty()) {
2105  CLEAR2(m_arrays->m_eFit, size);
2106  CLEAR2(m_arrays->m_tFit, size);
2107  CLEAR2(m_arrays->m_pedFit, size);
2108  CLEAR2(m_arrays->m_chi2Fit, size);
2109  }
2110 
2111  if (!m_fitcRawChannelContainerKey.empty()) {
2112  CLEAR2(m_arrays->m_eFitc, size);
2113  CLEAR2(m_arrays->m_tFitc, size);
2114  CLEAR2(m_arrays->m_pedFitc, size);
2115  CLEAR2(m_arrays->m_chi2Fitc, size);
2116  }
2117 
2118  if (!m_optRawChannelContainerKey.empty()) {
2119  CLEAR2(m_arrays->m_eOpt, size);
2120  CLEAR2(m_arrays->m_tOpt, size);
2121  CLEAR2(m_arrays->m_pedOpt, size);
2122  CLEAR2(m_arrays->m_chi2Opt, size);
2123  }
2124 
2125 
2126  if (!m_qieRawChannelContainerKey.empty()) {
2127  CLEAR2(m_arrays->m_eQIE, size);
2128  CLEAR2(m_arrays->m_tQIE, size);
2129  CLEAR2(m_arrays->m_pedQIE, size);
2130  CLEAR2(m_arrays->m_chi2QIE, size);
2131  }
2132 
2133  if (!m_of1RawChannelContainerKey.empty()) {
2134  CLEAR2(m_arrays->m_eOF1, size);
2135  CLEAR2(m_arrays->m_tOF1, size);
2136  CLEAR2(m_arrays->m_pedOF1, size);
2137  CLEAR2(m_arrays->m_chi2OF1, size);
2138  }
2139 
2140  if (!m_dspRawChannelContainerKey.empty()) {
2141  CLEAR2(m_arrays->m_eDsp, size);
2142  CLEAR2(m_arrays->m_tDsp, size);
2143  CLEAR2(m_arrays->m_pedDsp, size);
2144  CLEAR2(m_arrays->m_chi2Dsp, size);
2145  }
2146 
2147  if (!m_mfRawChannelContainerKey.empty()) {
2148  CLEAR4(m_arrays->m_eMF, size);
2149  CLEAR4(m_arrays->m_tMF, size);
2150  CLEAR2(m_arrays->m_chi2MF, size);
2151  CLEAR2(m_arrays->m_pedMF, size);
2152  }
2153 
2154  if (!m_wienerRawChannelContainerKey.empty()) {
2155  CLEAR2(m_arrays->m_eWiener, size);
2156  CLEAR2(m_arrays->m_tWiener, size);
2157  CLEAR2(m_arrays->m_pedWiener, size);
2158  CLEAR2(m_arrays->m_chi2Wiener, size);
2159  }
2160 
2161  if (m_bsInput) {
2162  CLEAR1(m_arrays->m_ROD_GlobalCRC);
2163  CLEAR1(m_arrays->m_ROD_BCID);
2164  CLEAR1(m_arrays->m_ROD_DMUBCIDErr);
2165  CLEAR1(m_arrays->m_ROD_DMUmemoryErr);
2166  CLEAR1(m_arrays->m_ROD_DMUSstrobeErr);
2167  CLEAR1(m_arrays->m_ROD_DMUDstrobeErr);
2168  CLEAR1(m_arrays->m_ROD_DMUHeadformatErr);
2169  CLEAR1(m_arrays->m_ROD_DMUHeadparityErr);
2170  CLEAR1(m_arrays->m_ROD_DMUDataformatErr);
2171  CLEAR1(m_arrays->m_ROD_DMUDataparityErr);
2172  CLEAR1(m_arrays->m_ROD_DMUfeCRC);
2173  CLEAR1(m_arrays->m_ROD_DMUrodCRC);
2174  CLEAR(m_arrays->m_ROD_DMUMask);
2175  }
2176 
2177 }
2178 
2179 /*//////////////////////////////////////////////////////////////////////////////
2180  // TMDB variables
2182  */
2183 
2184 void TileAANtuple::TMDB_addBranch(void)
2185 {
2186 
2187  if (!m_tileMuRcvRawChannelContainerKey.empty()) {
2188  m_ntuplePtr->Branch("eTMDB", m_arrays->m_eTMDB, "eTMDB[4][64][8]/F"); // float m_arrays->m_eTMDB[N_ROS][N_MODULES][N_TMDBCHANS]
2189  }
2190 
2191  if (!m_tileMuRcvDigitsContainerKey.empty()) {
2192  m_ntuplePtr->Branch("sampleTMDB", &(m_arrays->m_sampleTMDB[0]), NAME3("sampleTMDB[4][64][8][",std::to_string(m_nSamples),"]/b")); // unsigned char m_arrays->m_sampleTMDB[N_ROS][N_MODULES][N_TMDBCHANS][N_SAMPLES]
2193  }
2194 
2195  if (!m_tileMuRcvContainerKey.empty()) {
2196  m_ntuplePtr->Branch("decisionTMDB", m_arrays->m_decisionTMDB, "decisionTMDB[4][64][4]/b"); // unsigned char m_arrays->m_decisionTMDB[N_ROS][N_MODULES][N_TMDBDECISIONS]
2197  }
2198 
2199  if (!m_tileMuRcvContainerKey.empty()) {
2200  m_ntuplePtr->Branch("bcidTMDB", m_arrays->m_bcidTMDB, "bcidTMDB[4][64][3]/b"); // unsigned char m_arrays->m_bcidTMDB[N_ROS][N_MODULES][N_TMDBBCIDWORDS]
2201  }
2202 
2203 }
2204 
2205 void TileAANtuple::TMDB_clearBranch(void)
2206 {
2207  if (!m_tileMuRcvRawChannelContainerKey.empty()) CLEAR(m_arrays->m_eTMDB);
2208  if (!m_tileMuRcvDigitsContainerKey.empty()) CLEAR6(m_arrays->m_sampleTMDB);
2209  if (!m_tileMuRcvContainerKey.empty()) CLEAR(m_arrays->m_decisionTMDB);
2210  if (!m_tileMuRcvContainerKey.empty()) CLEAR(m_arrays->m_bcidTMDB);
2211 }
2212 
2213 /*/////////////////////////////////////////////////////////////////////////////
2214  // DCS variables
2216  */
2217 
2218 void TileAANtuple::DCS_addBranch() {
2219  bool br[9];
2220  int mask = m_DCSBranches;
2221 
2222  for (int i = 0; i < 9; ++i) {
2223  br[i] = (mask % 10);
2224  mask /= 10;
2225  }
2226 
2227  if (br[0]) {
2228  m_DCSntuplePtr->Branch("EvTime", &m_evTime, "EvTime/I");
2229  m_DCSntuplePtr->Branch("Run", &m_run, "Run/I");
2230  m_DCSntuplePtr->Branch("LumiBlock",&m_lumiBlock,"LumiBlock/I");
2231  m_DCSntuplePtr->Branch("HHMMSS", &m_HHMMSS, "HHMMSS/I");
2232  m_DCSntuplePtr->Branch("Evt", &m_evt, "Evt/I");
2233  m_DCSntuplePtr->Branch("EvtNr", &m_evtNr, "EvtNr/I");
2234  }
2235 
2236  if (br[1]) m_DCSntuplePtr->Branch("TEMP", m_arrays->m_TEMP, "TEMP[4][64][7]/F");
2237  if (br[2]) m_DCSntuplePtr->Branch("HV", m_arrays->m_HV, "HV[4][64][48]/F");
2238  if (br[3]) m_DCSntuplePtr->Branch("HVSET", m_arrays->m_HVSET, "HVSET[4][64][48]/F");
2239  if (br[4]) m_DCSntuplePtr->Branch("DRSTATES",m_arrays->m_DRSTATES,"DRSTATES[4][64]/I");
2240  if (br[5]) m_DCSntuplePtr->Branch("HVSTATUS",m_arrays->m_HVSTATUS,"HVSTATUS[4][64][48]/S");
2241  if (br[6]) m_DCSntuplePtr->Branch("DRSTATUS",m_arrays->m_DRSTATUS,"DRSTATUS[4][64]/S");
2242  if (br[7]) m_DCSntuplePtr->Branch("CHSTATUS",m_arrays->m_CHSTATUS,"CHSTATUS[4][64][48]/S");
2243  if (br[8]) {
2244  m_DCSntuplePtr->Branch("nBadDr", &m_nBadDr, "nBadDr/I");
2245  m_DCSntuplePtr->Branch("nBadHV", &m_nBadHV, "nBadHV/I");
2246  m_DCSntuplePtr->Branch("nBadDCS", &m_nBadDCS, "nBadDCS/I");
2247  m_DCSntuplePtr->Branch("nBadDB", &m_nBadDB, "nBadDB/I");
2248  m_DCSntuplePtr->Branch("nBadTotal", &m_nBadTotal, "nBadTotal/I");
2249  }
2250 }
2251 
2252 StatusCode TileAANtuple::storeDCS() {
2253 
2254  ATH_MSG_DEBUG( "Filling DCS ntuple:"
2255  <<" evtCnt=" << m_evtNr
2256  << " evt=" << m_evt
2257  << " lumi=" << m_lumiBlock << " " << m_dateTime );
2258 
2259  CLEAR(m_arrays->m_TEMP);
2260  CLEAR(m_arrays->m_HV);
2261  CLEAR(m_arrays->m_HVSET);
2262  CLEAR(m_arrays->m_DRSTATES);
2263  CLEAR(m_arrays->m_HVSTATUS);
2264  CLEAR(m_arrays->m_DRSTATUS);
2265  CLEAR(m_arrays->m_CHSTATUS);
2266 
2267  m_nBadDr = 0;
2268  m_nBadHV = 0;
2269  m_nBadDCS = 0;
2270  m_nBadDB = 0;
2271  m_nBadTotal = 0;
2272  for (int ROS = 1; ROS < 5; ++ROS) {
2273  int rosI = ROS - 1;
2274 
2275  for (int drawer = 0; drawer < 64; ++drawer) {
2276  m_arrays->m_DRSTATES[rosI][drawer] = m_tileDCS->getDrawerStates(ROS, drawer);
2277  m_arrays->m_DRSTATUS[rosI][drawer] = m_tileDCS->getDCSStatus(ROS, drawer);
2278  bool drbad = m_tileDCS->isStatusBad(ROS, drawer);
2279 
2280  if (drbad) {
2281  ++m_nBadDr;
2282  }
2283 
2284  if (msgLvl(MSG::VERBOSE) || m_arrays->m_DRSTATUS[rosI][drawer] != TileDCSState::OK_DRAWER) {
2285  ATH_MSG_VERBOSE( "Module=" << TileCalibUtils::getDrawerString(ROS, drawer)
2286  << " DRSTATES=" << m_arrays->m_DRSTATES[rosI][drawer]
2287  << " DRSTATUS=" << m_arrays->m_DRSTATUS[rosI][drawer]
2288  << " => " << ((drbad) ? "bad" : "good") );
2289  }
2290 
2291  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ROS,drawer);
2292  for (int channel=0; channel<48; ++channel){
2293  TileBchStatus chStat = m_tileBadChanTool->getChannelStatus(drawerIdx,channel);
2294  m_arrays->m_HV[rosI][drawer][channel] = m_tileDCS->getChannelHV(ROS, drawer, channel);
2295  m_arrays->m_HVSET[rosI][drawer][channel] = m_tileDCS->getChannelHVSet(ROS, drawer, channel);
2296  m_arrays->m_HVSTATUS[rosI][drawer][channel] = m_tileDCS->getDCSHVStatus(ROS, drawer, channel);
2297  m_arrays->m_CHSTATUS[rosI][drawer][channel] = m_tileDCS->getDCSStatus(ROS, drawer, channel)
2298  + 100 * m_tileBadChanTool->encodeStatus(chStat);
2299  bool chbad = m_tileDCS->isStatusBad(ROS, drawer, channel);
2300 
2301  if (chbad || chStat.isBad()) {
2302  ++m_nBadTotal;
2303  if (chbad) ++m_nBadDCS;
2304  if (chStat.isBad()) ++m_nBadDB;
2305  }
2306 
2307  if (m_tileDCS->isStatusHVBad(ROS, drawer, channel)) {
2308  ++m_nBadHV;
2309  }
2310 
2311  if (msgLvl(MSG::VERBOSE) || (chbad && !drbad)) {
2312  int pmt=abs(m_cabling->channel2hole(ROS,channel));
2313  ATH_MSG_VERBOSE( "Module=" << TileCalibUtils::getDrawerString(ROS, drawer)
2314  << " channel=" << channel << " pmt=" << pmt
2315  << " HV=" << m_arrays->m_HV[rosI][drawer][channel]
2316  << " HVSET=" << m_arrays->m_HVSET[rosI][drawer][channel]
2317  << " HVSTATUS=" << m_arrays->m_HVSTATUS[rosI][drawer][channel]
2318  << " CHSTATUS=" << m_arrays->m_CHSTATUS[rosI][drawer][channel]
2319  << " => " << ((chbad) ? "bad" : "good") );
2320  }
2321  }
2322 
2323  for (int ind=0; ind<7; ++ind){
2324  m_arrays->m_TEMP[rosI][drawer][ind] = m_tileDCS->getChannelHV(ROS, drawer, ind+48);
2325  ATH_MSG_VERBOSE( "Module=" << TileCalibUtils::getDrawerString(ROS, drawer)
2326  << " TEMP" << ind+1 << "=" << m_arrays->m_TEMP[rosI][drawer][ind] );
2327 
2328  }
2329  }
2330  }
2331 
2332  ATH_MSG_DEBUG( "BAD status in DCS: nBadDr=" << m_nBadDr
2333  << " nBadHV=" << m_nBadHV
2334  << " nBadDCS=" << m_nBadDCS
2335  << " nBadDB=" << m_nBadDB
2336  << " nBadTotal=" << m_nBadTotal );
2337 
2338  m_DCSntuplePtr->Fill();
2339 
2340 
2341  return StatusCode::SUCCESS;
2342 }
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ReadHandleKey.h
Property holding a SG store/key/clid from which a ReadHandle is made.
TileAANtuple::TMDB_clearBranch
void TMDB_clearBranch(void)
Definition: TileAANtuple.cxx:2205
bad
@ bad
Definition: SUSYToolsTester.cxx:95
TileRawChannelContainer
Definition: TileRawChannelContainer.h:13
TileAANtuple::m_dateTime
char m_dateTime[32]
event date and time
Definition: TileAANtuple.h:196
CaloDetDescrElement::onl2
IdentifierHash onl2() const
cell online identifier 2
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:408
TileAANtuple::m_checkDCS
bool m_checkDCS
if false, do not use TileDCS at all
Definition: TileAANtuple.h:380
TileRawChannelUnit
Definition: TileRawChannelUnit.h:13
TileLaserObject::getTDC
int getTDC(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:209
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
TileAANtuple::m_sumE_yy
float m_sumE_yy[N_DRAWERS]
Sum E calcualted inside DSP.
Definition: TileAANtuple.h:422
xAOD::short
short
Definition: Vertex_v1.cxx:165
yodamerge_tmp.dim
dim
Definition: yodamerge_tmp.py:239
TileAANtuple::m_ntupleID
std::string m_ntupleID
Definition: TileAANtuple.h:389
CLEAR2
#define CLEAR2(array, size)
Definition: TileAANtuple.cxx:72
TileAANtuple::m_dspUnit
TileRawChannelUnit::UNIT m_dspUnit
Unit for TileRawChannels in DSP.
Definition: TileAANtuple.h:385
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
TileAANtuple::storeTMDBDigits
StatusCode storeTMDBDigits(const EventContext &ctx)
Definition: TileAANtuple.cxx:1296
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
N_ROS
#define N_ROS
Filename : TileAANtuple.h Author : Alexander Solodkov (based on TileTBAANtuple) Created : April,...
Definition: TileAANtuple.h:72
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
CLEAR6
#define CLEAR6(array)
Definition: TileAANtuple.cxx:87
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileAANtuple::m_DCSntuplePtr
TTree * m_DCSntuplePtr
Definition: TileAANtuple.h:394
make_unique
std::unique_ptr< T > make_unique(Args &&... args)
Definition: SkimmingToolEXOT5.cxx:23
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
index
Definition: index.py:1
N_DMUS
#define N_DMUS
Definition: TileAANtuple.h:76
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TileLaserObject::nbGains
@ nbGains
Definition: TileLaserObject.h:44
TileAANtuple::m_lumiBlock
int m_lumiBlock
lumiblock number in a run
Definition: TileAANtuple.h:194
TileLaserObject::isLASERII
bool isLASERII() const
Definition: TileLaserObject.h:214
TileLaserObject::getPumpDiodeTemp
double getPumpDiodeTemp() const
Definition: TileLaserObject.h:234
TileAANtuple::m_reduced
bool m_reduced
Definition: TileAANtuple.h:350
TileRawChannel::pedestal
float pedestal(void) const
Definition: TileRawChannel.h:106
ReadBchFromCool.pmt
pmt
Definition: ReadBchFromCool.py:62
TileHid2RESrcID::getRobFromFragID
uint32_t getRobFromFragID(int frag_id) const
make a ROB SrcID for a fragment ID
Definition: TileHid2RESrcID.cxx:457
TileAANtuple::m_decoder
ToolHandle< TileROD_Decoder > m_decoder
Definition: TileAANtuple.h:441
TileAANtuple::fillCellMap
void fillCellMap(TTree *ntuplePtr)
///////////////////////////////////////////////////////////////////////////
Definition: TileAANtuple.cxx:1534
TileDQstatus::calibMode
uint32_t calibMode() const
Calibration mode.
Definition: TileDQstatus.h:148
TileAANtuple::m_l2Builder
ToolHandle< TileL2Builder > m_l2Builder
Definition: TileAANtuple.h:416
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
xAOD::char
char
Definition: TrigDecision_v1.cxx:38
ViewHelper::makeHandle
SG::ReadHandle< T > makeHandle(const SG::View *view, const SG::ReadHandleKey< T > &rhKey, const EventContext &context)
navigate from the TrigComposite to nearest view and fetch object from it
Definition: ViewHelper.h:258
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
TileAANtuple::m_finalUnit
int m_finalUnit
calibrate everything to this level
Definition: TileAANtuple.h:377
TileBchStatus
Class holding bad channel problems.
Definition: TileBchStatus.h:20
sample_ind_TMDB
#define sample_ind_TMDB(r, m, c, i)
Definition: TileAANtuple.cxx:104
TileAANtuple::m_HHMMSS
int m_HHMMSS
event time in HH:MM:SS
Definition: TileAANtuple.h:195
TileAANtuple::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition: TileAANtuple.h:397
skel.it
it
Definition: skel.GENtoEVGEN.py:423
TileLaserObject::getAlpha
double getAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:138
N_RODS
#define N_RODS
Definition: TileAANtuple.h:79
TileAANtuple::m_evBCID
int m_evBCID[N_RODS]
Event BCID from ROD header.
Definition: TileAANtuple.h:202
Tile_Base_ID::sample
int sample(const Identifier &id) const
Definition: Tile_Base_ID.cxx:171
pool::WRITE
@ WRITE
Definition: Database/APR/StorageSvc/StorageSvc/pool.h:72
TileAANtuple::m_compareMode
bool m_compareMode
If two sets of data should be compared (e.g.
Definition: TileAANtuple.h:379
TileAANtuple::m_tileBadChanTool
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Tile Bad Channel tool.
Definition: TileAANtuple.h:409
TileAANtuple::initNTuple
StatusCode initNTuple(const EventContext &ctx)
Definition: TileAANtuple.cxx:1449
TileAANtuple::m_nBadDCS
int m_nBadDCS
Definition: TileAANtuple.h:345
TileLaserObject::getDiodeCurrOrd
double getDiodeCurrOrd() const
Definition: TileLaserObject.h:219
CLEAR4
#define CLEAR4(array, size)
Definition: TileAANtuple.cxx:79
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TileAANtuple::m_cablingSvc
ServiceHandle< TileCablingSvc > m_cablingSvc
Name of Tile cabling service.
Definition: TileAANtuple.h:435
TileInfo.h
N_ROS2
#define N_ROS2
Definition: TileAANtuple.h:73
DIGI_PAR_FRAG
#define DIGI_PAR_FRAG
Definition: TileTBFrag.h:41
TileMuonReceiverContainer.h
TileAANtuple::m_sumEz_xx
float m_sumEz_xx[N_DRAWERS]
Sum Ez recalculated offline using DSP raw channels.
Definition: TileAANtuple.h:418
ROBDataProviderSvc.h
TileAANtuple::m_pmtOrder
bool m_pmtOrder
change channel ordering to pmt ordering in ntuple
Definition: TileAANtuple.h:376
TileCablingService::h2s_cell_id_index
Identifier h2s_cell_id_index(const HWIdentifier &id, int &index, int &pmt) const
Definition: TileCablingService.cxx:2418
TileCalibUtils.h
TileAANtuple::m_laserObjectKey
SG::ReadHandleKey< TileLaserObject > m_laserObjectKey
Definition: TileAANtuple.h:366
TileRawChannelUnit::OnlineADCcounts
@ OnlineADCcounts
Definition: TileRawChannelUnit.h:21
Tile_Base_ID::tower
int tower(const Identifier &id) const
Definition: Tile_Base_ID.cxx:165
TileAANtuple::m_ROBID
std::vector< uint32_t > m_ROBID
Definition: TileAANtuple.h:430
TileAANtuple::m_las_BCID
int m_las_BCID
Definition: TileAANtuple.h:210
TileAANtuple::m_calibrateEnergy
bool m_calibrateEnergy
convert energy to new units or use amplitude from RawChannel directly
Definition: TileAANtuple.h:373
TileAANtuple::m_sumE_xx
float m_sumE_xx[N_DRAWERS]
Sum E recalculated offline using DSP raw channels.
Definition: TileAANtuple.h:419
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TileAANtuple::m_skipEvents
int m_skipEvents
Definition: TileAANtuple.h:428
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
TileLaserObject.h
TileAANtuple::m_sumEt_xx
float m_sumEt_xx[N_DRAWERS]
Sum Et recalculated offline using DSP raw channels.
Definition: TileAANtuple.h:417
SG::ReadHandleKey< TileRawChannelContainer >
TileLaserObject::getVersion
int getVersion() const
Definition: TileLaserObject.h:209
TileDigitsContainer
Definition: TileDigitsContainer.h:13
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
CLEAR5
#define CLEAR5(array, size)
Definition: TileAANtuple.cxx:83
TileRawData::adc_HWID
HWIdentifier adc_HWID(void) const
Definition: TileRawData.h:53
HWIdentifier
Definition: HWIdentifier.h:13
TileAANtuple::m_sumEz_zz
float m_sumEz_zz[N_DRAWERS]
Sum Ez recalculated offline using offline OF.
Definition: TileAANtuple.h:424
TileAANtuple::m_treeSize
int64_t m_treeSize
Definition: TileAANtuple.h:390
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
TileAANtuple::LASER_clearBranch
void LASER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree LASER variabl...
Definition: TileAANtuple.cxx:1808
TileRawChannel::time
float time(int ind=0) const
Definition: TileRawChannel.h:103
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileLaserObject::isSet
bool isSet(int chan, int gain, int type) const
Definition: TileLaserObject.cxx:71
TileAANtuple::storeTMDBDecision
StatusCode storeTMDBDecision(const EventContext &ctx)
Definition: TileAANtuple.cxx:1230
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
TileAANtuple::m_evType
int m_evType[N_RODS]
Event Type from ROD header.
Definition: TileAANtuple.h:203
MbtsDetDescrManager
Definition: MbtsDetDescrManager.h:16
python.PyRootLib.ROOT
def ROOT
Definition: PyRootLib.py:72
TileID.h
TileDetDescrManager.h
MbtsDetDescrManager.h
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
TileHid2RESrcID
This class provides conversion between fragment ID and RESrcID.
Definition: TileHid2RESrcID.h:28
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
TileAANtuple::m_wienerRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_wienerRawChannelContainerKey
Definition: TileAANtuple.h:365
TileAANtuple::m_DCSBranches
int m_DCSBranches
mask like 110101 - which DCS branches to fill
Definition: TileAANtuple.h:381
TileAANtuple::m_evtNr
int m_evtNr
event counter
Definition: TileAANtuple.h:188
TileLaserObject::getPMADC
int getPMADC(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:195
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
TileAANtuple::storeBeamElements
StatusCode storeBeamElements(const TileDQstatus &DQstatus)
Definition: TileAANtuple.cxx:601
TileLaserObject::getFiltNumber
int getFiltNumber() const
Definition: TileLaserObject.h:229
TileL2Builder.h
TileAANtuple::storeTMDBRawChannel
StatusCode storeTMDBRawChannel(const EventContext &ctxx)
Definition: TileAANtuple.cxx:1368
TileLaserObject::getSigmaPedAlpha
double getSigmaPedAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:180
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
CaloDetDescrElement::onl1
IdentifierHash onl1() const
cell online identifier 1
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:404
TileRawChannelContainer.h
TileAANtuple::storeMFRawChannels
StatusCode storeMFRawChannels(const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, float *ene, float *time, float chi2[N_ROS2][N_MODULES][N_CHANS], float ped[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
Definition: TileAANtuple.cxx:840
TileRawChannel::quality
float quality(int ind=0) const
Definition: TileRawChannel.h:105
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TileAANtuple::LASER_addBranch
void LASER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree LASER variable...
Definition: TileAANtuple.cxx:1709
WriteCellNoiseToCool.gn
gn
Definition: WriteCellNoiseToCool.py:531
TileAANtuple::m_evTime
int m_evTime
event time
Definition: TileAANtuple.h:191
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition: CaloDetDescrElement.cxx:64
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
TileAANtuple::m_cabling
const TileCablingService * m_cabling
cabling tool
Definition: TileAANtuple.h:406
NAME3
#define NAME3(s1, s2, s3)
Definition: TileAANtuple.cxx:96
TileAANtuple::m_sumEt_zz
float m_sumEt_zz[N_DRAWERS]
Sum Et recalculated offline using offline OF.
Definition: TileAANtuple.h:423
TileLaserObject::getMean
double getMean(int chan, int gain, int type) const
Definition: TileLaserObject.cxx:41
TileDetDescrManager::tile_cell_begin
calo_element_const_iterator tile_cell_begin() const
Definition: TileDetDescrManager.h:147
TileAANtuple::m_fitRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitRawChannelContainerKey
Definition: TileAANtuple.h:358
TileLaserObject::getTDCTimeout
bool getTDCTimeout() const
Definition: TileLaserObject.h:319
TileRawChannel::amplitude
float amplitude(int ind=0) const
Definition: TileRawChannel.h:101
TileHWID.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileAANtuple::m_of1RawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_of1RawChannelContainerKey
Definition: TileAANtuple.h:364
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
TileAANtuple::storeDCS
StatusCode storeDCS()
Definition: TileAANtuple.cxx:2252
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:100
TileCablingService.h
TileAANtuple::m_compressSettings
int m_compressSettings
Definition: TileAANtuple.h:351
eformat::ROBFragment< const uint32_t * >
lumiFormat.i
int i
Definition: lumiFormat.py:92
TileAANtuple::ntuple_initialize
StatusCode ntuple_initialize(const EventContext &ctx, const TileDQstatus &DQstatus)
Definition: TileAANtuple.cxx:275
TileCondToolEmscale.h
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
python.LArBadChannelDBAlg.xFFFFFFFF
xFFFFFFFF
Definition: LArBadChannelDBAlg.py:73
TileAANtuple::TileAANtuple
TileAANtuple(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TileAANtuple.cxx:112
TileDigitsContainer.h
TileAANtuple::m_calibMode
bool m_calibMode
If data should be put in calib mode.
Definition: TileAANtuple.h:378
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
DetDescrDictionaryDict::it1
std::vector< HWIdentifier >::iterator it1
Definition: DetDescrDictionaryDict.h:17
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
01SubmitToGrid.samples
samples
Definition: 01SubmitToGrid.py:58
TileRawDataContainer::get_bsflags
uint32_t get_bsflags() const
Definition: TileRawDataContainer.h:64
TileRawChannelUnit::OnlineOffset
@ OnlineOffset
Definition: TileRawChannelUnit.h:25
N_CHANS
#define N_CHANS
Definition: TileAANtuple.h:77
TileAANtuple::m_dspRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_dspRawChannelContainerKey
Definition: TileAANtuple.h:362
TileAANtuple::TRIGGER_clearBranch
void TRIGGER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER varia...
Definition: TileAANtuple.cxx:1663
TileAANtuple::m_cispar
uint32_t m_cispar[N_CISPAR]
Definition: TileAANtuple.h:206
generateReferenceFile.files
files
Definition: generateReferenceFile.py:12
CLEAR3
#define CLEAR3(array, size)
Definition: TileAANtuple.cxx:75
TileRawChannelUnit::MegaElectronVolts
@ MegaElectronVolts
Definition: TileRawChannelUnit.h:20
CLEAR1
#define CLEAR1(array)
Definition: TileAANtuple.cxx:69
TileDCSState::OK_DRAWER
@ OK_DRAWER
Definition: TileDCSState.h:33
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:522
TileAANtuple::m_rawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerKey
Definition: TileAANtuple.h:357
TileRawChannel
Definition: TileRawChannel.h:35
TileAANtuple::m_bsInput
bool m_bsInput
true if bytestream file is used
Definition: TileAANtuple.h:375
file
TFile * file
Definition: tile_monitor.h:29
TileAANtuple::m_nBadDB
int m_nBadDB
Definition: TileAANtuple.h:346
TileAANtuple::initialize
StatusCode initialize()
Alg standard interface function.
Definition: TileAANtuple.cxx:210
TileDetDescrManager::tile_cell_end
calo_element_const_iterator tile_cell_end() const
Definition: TileDetDescrManager.h:150
TileAANtuple::CISPAR_clearBranch
void CISPAR_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variab...
Definition: TileAANtuple.cxx:1696
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TileAANtuple::m_sumE_zz
float m_sumE_zz[N_DRAWERS]
Sum E recalculated offline using offline OF.
Definition: TileAANtuple.h:425
TileAANtuple::m_optRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_optRawChannelContainerKey
Definition: TileAANtuple.h:360
MbtsDetDescrManager::get_element
CaloDetDescrElement * get_element(const Identifier &elementId) const
Definition: MbtsDetDescrManager.cxx:29
TrigInDetValidation_Base.malloc
malloc
Definition: TrigInDetValidation_Base.py:129
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
TileAANtuple::storeRawChannels
StatusCode storeRawChannels(const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, float ene[N_ROS2][N_MODULES][N_CHANS], float time[N_ROS2][N_MODULES][N_CHANS], float chi2[N_ROS2][N_MODULES][N_CHANS], float ped[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
/ Fill ntuple with data from TRC.
Definition: TileAANtuple.cxx:642
TileAANtuple::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
main Tile Calibration tool
Definition: TileAANtuple.h:411
TileAANtuple::m_ntuplePtr
TTree * m_ntuplePtr
Definition: TileAANtuple.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
RunTileMonitoring.rod
rod
Definition: RunTileMonitoring.py:134
imax
int imax(int i, int j)
Definition: TileLaserTimingTool.cxx:33
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
AthAlgorithm
Definition: AthAlgorithm.h:47
TileAANtuple::m_las_MeasAmp
float m_las_MeasAmp
Definition: TileAANtuple.h:214
TileAANtuple::m_l2CntKey
SG::ReadHandleKey< TileL2Container > m_l2CntKey
Definition: TileAANtuple.h:370
TileAANtuple::m_tileID
const TileID * m_tileID
Definition: TileAANtuple.h:402
min
#define min(a, b)
Definition: cfImp.cxx:40
TileAANtuple::m_las_version
int m_las_version
Definition: TileAANtuple.h:209
DQPostProcessTest.outFile
outFile
Comment Out Those You do not wish to run.
Definition: DQPostProcessTest.py:37
TileAANtuple::m_mfRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_mfRawChannelContainerKey
Definition: TileAANtuple.h:363
TileAANtuple::m_fileMgr
ServiceHandle< IFileMgr > m_fileMgr
Definition: TileAANtuple.h:398
TileLaserObject::getQDCTimeout
bool getQDCTimeout() const
Definition: TileLaserObject.h:314
TileAANtuple::m_sumEt_yy
float m_sumEt_yy[N_DRAWERS]
Sum Et calcualted inside DSP.
Definition: TileAANtuple.h:420
TileAANtuple::m_daqtype
int m_daqtype
Definition: TileAANtuple.h:342
TileHid2RESrcID.h
TileLaserObject::getDiodeSigmaPedestal
double getDiodeSigmaPedestal(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:123
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
TileAANtuple::m_dspFlags
uint32_t m_dspFlags
DSP flags from BS.
Definition: TileAANtuple.h:198
LASER_OBJ_FRAG
#define LASER_OBJ_FRAG
Definition: TileTBFrag.h:49
TileDigits
Definition: TileDigits.h:30
N_CISPAR
#define N_CISPAR
Definition: TileAANtuple.h:80
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
TileLaserObject::getBCID
int getBCID() const
Definition: TileLaserObject.h:335
IdentifierHash.h
TileLaserObject::getDiodeADC
int getDiodeADC(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:95
TileAANtuple::~TileAANtuple
virtual ~TileAANtuple()
Definition: TileAANtuple.cxx:206
TileAANtuple::DIGI_addBranch
void DIGI_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree DIGI variables...
Definition: TileAANtuple.cxx:1854
TileAANtuple::m_streamName
std::string m_streamName
Definition: TileAANtuple.h:388
TileAANtuple::m_las_Filt
int m_las_Filt
Definition: TileAANtuple.h:212
TileAANtuple::m_bad
bool m_bad[N_ROS][N_MODULES][N_CHANS]
Definition: TileAANtuple.h:426
errorcheck.h
Helpers for checking error return status codes and reporting errors.
TileAANtuple::m_nBadHV
int m_nBadHV
Definition: TileAANtuple.h:344
TileAANtuple::m_tileMuRcvContainerKey
SG::ReadHandleKey< TileMuonReceiverContainer > m_tileMuRcvContainerKey
Definition: TileAANtuple.h:369
xAOD::bcid
setEventNumber setTimeStamp bcid
Definition: EventInfo_v1.cxx:133
TileTBFrag.h
TileAANtuple::m_beamElemContainerKey
SG::ReadHandleKey< TileBeamElemContainer > m_beamElemContainerKey
Definition: TileAANtuple.h:356
TileLaserObject::getPMPedestal
double getPMPedestal(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:223
TileAANtuple::m_digitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
Definition: TileAANtuple.h:354
TileAANtuple::m_fitcRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitcRawChannelContainerKey
Definition: TileAANtuple.h:359
TileDQstatus::cispar
const uint32_t * cispar() const
CIS parameters.
Definition: TileDQstatus.h:152
N_MODULES
#define N_MODULES
Definition: TileAANtuple.h:74
TileLaserObject::getDiodeCurrMeas
double getDiodeCurrMeas() const
Definition: TileLaserObject.h:224
EventInfo.h
Example_ReadSampleNoise.ped
ped
Definition: Example_ReadSampleNoise.py:45
PlotSFuncertainty.calib
calib
Definition: PlotSFuncertainty.py:110
TileAANtuple::m_run
int m_run
run number
Definition: TileAANtuple.h:192
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TileHWID::adc_id
HWIdentifier adc_id(int ros, int drawer, int channel, int adc) const
adc HWIdentifer
Definition: TileHWID.cxx:228
ir
int ir
counter of the current depth
Definition: fastadd.cxx:49
TileMuonReceiverObj
Definition: TileMuonReceiverObj.h:28
TileAANtuple.h
TileCalibUtils::getDrawerString
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
Definition: TileCalibUtils.cxx:145
N_TMDBDECISIONS
#define N_TMDBDECISIONS
Definition: TileAANtuple.h:82
DeMoScan.index
string index
Definition: DeMoScan.py:362
TileAANtuple::DIGI_clearBranch
void DIGI_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variabl...
Definition: TileAANtuple.cxx:2051
TileHWID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: TileHWID.h:314
TileAANtuple::m_tileMgr
const TileDetDescrManager * m_tileMgr
Pointer to TileDetDescrManager.
Definition: TileAANtuple.h:407
TileRawData::cell_ID_index
Identifier cell_ID_index(int &index, int &pmt) const
Definition: TileRawData.cxx:65
TileAANtuple::ntuple_clear
StatusCode ntuple_clear()
Definition: TileAANtuple.cxx:1437
TileLaserObject::nbPmts
@ nbPmts
Definition: TileLaserObject.h:45
TileAANtuple::m_tileMuRcvRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_tileMuRcvRawChannelContainerKey
Definition: TileAANtuple.h:367
TileAANtuple::m_tileMuRcvDigitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_tileMuRcvDigitsContainerKey
Definition: TileAANtuple.h:368
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
TileAANtuple::m_tdctimeout
bool m_tdctimeout
Definition: TileAANtuple.h:341
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
TileRawDataContainer::get_unit
UNIT get_unit() const
Definition: TileRawDataContainer.h:60
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileAANtuple::m_trigType
int m_trigType
trigger type (1=Phys, 2=Laser, 4=Ped, 8=CIS)
Definition: TileAANtuple.h:197
CLEAR
#define CLEAR(array)
Definition: TileAANtuple.cxx:66
CaloDetDescrElement::z
float z() const
cell z
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:367
TileLaserObject::getPMSigmaPedestal
double getPMSigmaPedestal(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:237
TileCablingService::channel2hole
static int channel2hole(int ros, int channel)
Definition: TileCablingService.cxx:1946
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
NAME2
#define NAME2(s1, s2)
Definition: TileAANtuple.cxx:93
TileLaserObject::getDiodePedestal
double getDiodePedestal(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:109
TileBeamElemContainer.h
TileAANtuple::storeLaser
StatusCode storeLaser(const EventContext &ctx)
Definition: TileAANtuple.cxx:492
TileAANtuple::m_sumEz_yy
float m_sumEz_yy[N_DRAWERS]
Sum Ez calcualted inside DSP.
Definition: TileAANtuple.h:421
TileDetDescrManager::calo_element_const_iterator
calo_element_vec::const_iterator calo_element_const_iterator
Definition: TileDetDescrManager.h:56
CaloDetDescrElement::eta
float eta() const
cell eta
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:344
TileAANtuple::m_nBadDr
int m_nBadDr
Definition: TileAANtuple.h:343
CaloDetDescrElement::phi
float phi() const
cell phi
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:346
TileAANtuple::m_las_Temperature
float m_las_Temperature
Definition: TileAANtuple.h:215
TileAANtuple::m_las_ReqAmp
float m_las_ReqAmp
Definition: TileAANtuple.h:213
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
TileAANtuple::digiChannel2PMT
int digiChannel2PMT(int fragType, int chan)
Definition: TileAANtuple.h:161
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
TileAANtuple::execute
StatusCode execute()
Definition: TileAANtuple.cxx:332
TileAANtuple::m_l1Type
int m_l1Type[N_RODS]
Level1 Type from ROD header.
Definition: TileAANtuple.h:201
N_TMDBCHANS
#define N_TMDBCHANS
Definition: TileAANtuple.h:81
TileAANtuple::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: TileAANtuple.h:167
TileAANtuple::TRIGGER_addBranch
void TRIGGER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add TRIGGER variables t...
Definition: TileAANtuple.cxx:1636
TileAANtuple::m_l1ID
int m_l1ID[N_RODS]
Level1 ID from ROD header.
Definition: TileAANtuple.h:200
TileLaserObject::getSigmaAlpha
double getSigmaAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:152
TileContainer.h
IdentifierHash
Definition: IdentifierHash.h:38
ITileBadChanTool.h
TileAANtuple::m_qieRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_qieRawChannelContainerKey
Definition: TileAANtuple.h:361
TileLaserObject::getDaqType
int getDaqType() const
Definition: TileLaserObject.h:325
TileAANtuple::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileAANtuple.h:403
TileAANtuple::m_DQstatusKey
SG::ReadHandleKey< TileDQstatus > m_DQstatusKey
Definition: TileAANtuple.h:444
TileAANtuple::CheckDMUParity
short CheckDMUParity(uint32_t header)
Parity of the DMU header should be odd.
Definition: TileAANtuple.h:177
TileAANtuple::m_rchUnit
TileRawChannelUnit::UNIT m_rchUnit
Unit for TileRawChannels (ADC, pCb, MeV)
Definition: TileAANtuple.h:384
TileAANtuple::m_useDspUnits
bool m_useDspUnits
true if energy should be converted to units used in DSP
Definition: TileAANtuple.h:374
python.PyAthena.obj
obj
Definition: PyAthena.py:135
sample_ind
#define sample_ind(r, m, c, i)
Definition: TileAANtuple.cxx:102
CREATE
#define CREATE(__TYPE)
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
TileContainer
Definition: TileContainer.h:38
TileAANtuple::TMDB_addBranch
void TMDB_addBranch(void)
Definition: TileAANtuple.cxx:2184
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
TileAANtuple::CISPAR_addBranch
void CISPAR_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variabl...
Definition: TileAANtuple.cxx:1683
TileAANtuple::m_tileDCS
ToolHandle< ITileDCSTool > m_tileDCS
Definition: TileAANtuple.h:413
TileAANtuple::m_nBadTotal
int m_nBadTotal
Definition: TileAANtuple.h:347
TileLaserObject
Definition: TileLaserObject.h:33
TileAANtuple::DCS_addBranch
void DCS_addBranch(void)
Definition: TileAANtuple.cxx:2218
TileAANtuple::finalize
StatusCode finalize()
Definition: TileAANtuple.cxx:1424
TileAANtuple::m_nSamples
int m_nSamples
number of samples
Definition: TileAANtuple.h:349
TileAANtuple::m_fltDigitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_fltDigitsContainerKey
Definition: TileAANtuple.h:355
TileAANtuple::m_robSvc
ServiceHandle< IROBDataProviderSvc > m_robSvc
Definition: TileAANtuple.h:438
TileAANtuple::Arrays
Definition: TileAANtuple.h:217
TileBchStatus::isBad
bool isBad() const
Definition: TileBchStatus.h:145
TileAANtuple::m_qdctimeout
bool m_qdctimeout
Definition: TileAANtuple.h:340
checkFileSG.ind
list ind
Definition: checkFileSG.py:118
TileRawChannelUnit::ADCcounts
@ ADCcounts
Definition: TileRawChannelUnit.h:17
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
TileAANtuple::m_evt
int m_evt
event number in a run
Definition: TileAANtuple.h:193
TileLaserObject::getSigma
double getSigma(int chan, int gain, int type) const
Definition: TileLaserObject.cxx:49
TileRawChannelUnit::OnlineMegaElectronVolts
@ OnlineMegaElectronVolts
Definition: TileRawChannelUnit.h:24
TileLaserObject::getPedestalAlpha
double getPedestalAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:166
TileAANtuple::storeDigits
StatusCode storeDigits(const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey, short *sample, short gain[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
/ Fill Ntuple with info from TileDigits / Return true if the collection is empty
Definition: TileAANtuple.cxx:1044
TileAANtuple::m_arrays
std::unique_ptr< Arrays > m_arrays
Definition: TileAANtuple.h:338
PlotCalibFromCool.br
br
Definition: PlotCalibFromCool.py:355
Generated on Thu Jul 4 2024 21:28:47 for ATLAS Offline Software by   doxygen 1.8.18