ATLAS Offline Software
LArRodBlockAccumulatedV3.cxx
Go to the documentation of this file.
1 //Dear emacs, this is -*- c++ -*-
2 
3 /*
4  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
5 */
6 
7 // Implementation of a LArRODBlockStructure class
8 // This version contains LArDigits in fixed gain.
9 // See .h file for more details.
10 
11 #include "GaudiKernel/MsgStream.h"
12 #include "AthenaKernel/getMessageSvc.h"
13 #include "LArByteStream/LArRodBlockAccumulatedV3.h"
14 //#include <cstdio>
15 #include <iostream>
16 
17 //#define LARBSDBGOUTPUT
18 #ifdef LARBSDBGOUTPUT
19 #define LARBSDBG(text) logstr<<MSG::DEBUG<<text<<endmsg
20 #else
21 #define LARBSDBG(text)
22 #endif
23 
24 
25 LArRodBlockAccumulatedV3::LArRodBlockAccumulatedV3() : LArRodBlockStructure()
26 {
27  m_iHeadBlockSize=endtag/2; // The implicit cast rounds down to the right size
28  m_fixedGain=CaloGain::LARNGAIN;
29  LArRodBlockAccumulatedV3::resetPointers();
30 }
31 
32 void LArRodBlockAccumulatedV3::resetPointers()
33 {
34  m_Result1Counter=0;
35  m_Result1Index=0;
36  m_Result2Counter=0;
37  m_Result2Index=0;
38  m_RawDataCounter=0;
39  m_RawDataIndex=0;
40 }
41 
42 uint8_t LArRodBlockAccumulatedV3::getTDCPhase() const
43 {
44  return (getHeader16(NSamples)>>8);
45 }
46 
47 int LArRodBlockAccumulatedV3::getNextRawData(int& channelNumber, std::vector<short>& samples, uint32_t& gain)
48 {
49 #ifdef LARBSDBGOUTPUT
50  MsgStream logstr(Athena::getMessageSvc(), BlockType());
51 #endif
52  //Debug output
53  /*
54  LARBSDBG("GetNextRawData for FEB 0x" << MSG::hex << (uint32_t)getHeader32(FEBID) << MSG::dec);
55  LARBSDBG("m_RawDataCounter=" << m_RawDataCounter << " m_RawDataIndex="<< m_RawDataIndex
56  << " m_channelsPerFEB=" << m_channelsPerFEB);
57  LARBSDBG("requested gain= " << m_fixedGain);
58  */
59  //std::cout << "RAWDATA " << m_RawDataCounter << std::endl;
60  if (m_RawDataCounter>=m_channelsPerFEB) { //Already beyond maximal number of channels
61  LARBSDBG("Maximum number of channels reached");
62  return 0;
63  }
64  //const uint16_t block = getHeader16(m_RawDataOff);//Position of the raw FEB data block
65  const uint16_t block = getHeader16(RawDataBlkOff);
66  if (!block) { //Block does not exist
67  LARBSDBG("No Raw Data Block in this FEB");
68  return 0;
69  }
70  //The m_RawDataChannel keeps track of the last read channel
71  //std::cout << "endtag=" << endtag << " m_iHeadBlockSize=" << m_iHeadBlockSize << std::endl;
72 
73  // Get next channel
74  channelNumber=m_RawDataCounter;
75  uint32_t febgain=0;
76  const unsigned int nsamples = getHeader16(NSamples) & 0xff;
77  const unsigned int ngains = getHeader16(NGains);
78  /*
79  LARBSDBG("This FEB has " << nsamples << " samples");
80  LARBSDBG("This FEB has " << ngains << " gains");
81  */
82  if(ngains==0 || nsamples==0) return 0;
83  // Loop over gains to look for m_fixedGain
84  unsigned int this_gain=0;
85  int offset;
86  LARBSDBG(" ===> fixedGain= " << m_fixedGain << " CaloGain = " << CaloGain::LARNGAIN);
87  if (m_fixedGain!=CaloGain::LARNGAIN) { //Fixed gain: Search for gain
88  offset=block + 8 + ((channelNumber&0x3F)>>3) + ((channelNumber & 0x7)<<3);
89  for(this_gain=0;this_gain<ngains;this_gain++) {
90  int index = offset + 64*this_gain;
91  uint32_t x = m_FebBlock[index];
92  if(channelNumber>=64)
93  x = (x & 0x3000) >> 12;
94  else
95  x = (x & 0x30000000) >> 28;
96  unsigned data_gain = RawToOfflineGain(x);
97  if(data_gain==m_fixedGain) break;
98  }
99  }
100  if (this_gain<ngains) { //Gain found in this fragment
101  int s_size = 8 + 64 * ngains; // Size of one sample block 16 RADD of 16 bit + 128 channels (16 bit data)
102  offset = block + 8 + ((channelNumber&0x3F)>>3) + ((channelNumber & 0x7)<<3) + 64*this_gain;
103  int index = offset;
104  uint32_t x = m_FebBlock[index];
105  if(channelNumber>=64) { //low channels on lower bits
106  // First decode gain
107  febgain = (x & 0x3000) >> 12; // gain on bits 12 and 13
108  // Than samples
109  for(unsigned int s=0;s<nsamples;s++) {
110  index = offset + s*s_size;
111  x = m_FebBlock[index];
112  // if((s==0) && (channelNumber==64)) std::cout << "===> " << std::dec << channelNumber << " " << (x&0xfff) << " " << std::endl;
113  samples.push_back((short) (x & 0x0fff)); // sample on bits 0 to 11
114  }
115  } else { //high channels on higher bits
116  // First decode gain
117  febgain = (x & 0x30000000) >> 28; // gain on bits 12 and 13
118  // Than samples
119  for(unsigned int s=0;s<nsamples;s++) {
120  index = offset + s*s_size;
121  x = (m_FebBlock[index]) >> 16;
122  samples.push_back((short) (x & 0x0fff)); // sample on bits 0 to 11
123  }
124  }
125  gain=RawToOfflineGain(febgain);
126  }
127  //std::cout << "Gain= " << gain << " Febgain=" << febgain << std::endl;
128  ++m_RawDataCounter;
129  unsigned rearrangeFirstSample=0;
130  if (m_rearrangeFirstSample)
131  rearrangeFirstSample=m_rearrangeFirstSample; //Overwrite by jobOptions
132  else
133  rearrangeFirstSample=getFirstSampleIndex();
134  //std::cout << "FebConfig: "<< getFebConfig() << " FirstSampleIndex " << getFirstSampleIndex() <<std::endl;
135  if (rearrangeFirstSample && rearrangeFirstSample<samples.size()) //FIXME: Very ugly hack! See explanation in LArRodDecoder.h file
136  {//Change e.g. 3 0 1 2 4 to 0 1 2 3 4
137  short movedSample=samples[0];
138  for (unsigned i=1;i<=rearrangeFirstSample;i++)
139  samples[i-1]=samples[i];
140  samples[rearrangeFirstSample]=movedSample;
141  }
142  LARBSDBG("GetNextRawData for FEB finished 0x" << MSG::hex << (uint32_t)getHeader32(FEBID) << MSG::dec);
143  return 1;
144 }
145 
146 int LArRodBlockAccumulatedV3::getNextAccumulatedDigit(int& channelNumber, std::vector<uint64_t>& samplesSum,
147  std::vector < uint64_t >& corr2Sum, uint32_t& gain )
148 {
149 #ifdef LARBSDBGOUTPUT
150  MsgStream logstr(Athena::getMessageSvc(), BlockType());
151 #endif
152  //Debug output
153  LARBSDBG("m_Result1Counter" << m_Result1Counter << " m_Result1Index="<< m_Result1Index
154  << " m_channelsPerFEB=" << m_channelsPerFEB);
155  LARBSDBG("requested gain= " << m_fixedGain);
156  if (m_Result1Counter>=m_channelsPerFEB) { //Already beyond maximal number of channels
157  LARBSDBG("Maximum number of channels reached");
158  return 0;
159  }
160  uint16_t block = getHeader16(ResultsOff1);//Position of the AccumulatedCalibDigits FEB data block
161  uint16_t bsize = getHeader16(ResultsDim1);//Position of the AccumulatedCalibDigits FEB data block
162  uint32_t size = getNumberOfWords();
163  if (!block) { //Block does not exist
164  LARBSDBG("No Accumulated Digit Block in this FEB");
165  // std::cout << "index= " << ResultsOff1 << "word= " << getHeader16(ResultsOff1) << std::endl;
166  return 0;
167  }
168  //The m_Result1Channel keeps track of the last read channel
169  //std::cout << "endtag=" << endtag << " m_iHeadBlockSize=" << m_iHeadBlockSize << std::endl;
170 
171  // Get next channel
172  channelNumber=m_Result1Counter;
173 
174  // This is just for fun; these data are not stored here but in RodBlockDecoder.cxx
175  // IWS 08.08.2005 This part is useless in fact - just for debugging
176  const unsigned int nsamples = getHeader16(NSamples);
177  const unsigned int ngains = getHeader16(NGains);
178 
179  //if(channelNumber==0) {
180  // for(uint3_t i=0;i<size;i++) {
181  // if(i==0)
182  // std::cout << std::hex << i << " : NWTot " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
183  // else if(i==1)
184  // std::cout << std::hex << i << " : FEBid " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
185  // else if(i==2)
186  // std::cout << std::hex << i << " : FEBsn " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
187  // else if(i==3)
188  // std::cout << std::hex << i << " : Block1 " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
189  // else if(i==4)
190  // std::cout << std::hex << i << " : Block2 " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
191  // else if(i==5)
192  // std::cout << std::hex << i << " : Block3 " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
193  // else if(i==6)
194  // std::cout << std::hex << i << " : Status " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
195  // else if(i==7)
196  // std::cout << std::hex << i << " : Gain/Sample " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
197  // else if(i==8)
198  // std::cout << std::hex << i << " : 1st/FebConf " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
199  // else if(i==9)
200  // std::cout << std::hex << i << " : InFPGA " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
201  // else if (i<block)
202  // std::cout << std::hex << i << " : raw data " << i-12 << " " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
203  // else if(i-block<bsize) {
204  // if (i<block+1)
205  // std::cout << std::hex << i << " : ntrigger " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
206  // else if (i<block+2)
207  // std::cout << std::hex << i << " : step i&n " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
208  // else if (((i-block-2)%(2*nsamples))<nsamples)
209  // std::cout << std::hex << i << " " << (i-block-2)/(2*nsamples) << " : sum channel " << (i-block-2)/(nsamples+1) << " " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
210  // else
211  // std::cout << std::hex << i << " " << (i-block-2)/(2*nsamples) << " : sum*sum " << (i-block-2)%(nsamples+1) << " " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::endl;
212  // }
213  // else if(i<size-3)
214  // std::cout << std::hex << i << " : raw data " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::dec << std::endl;
215  // else
216  // std::cout << std::hex << i << " : trailer " << std::hex << m_FebBlock+i << " : " << std::hex << m_FebBlock[i] << std::dec << std::endl;
217  // }
218  //}
219 
220  const unsigned int FebConfig = (int) getFebConfig();
221  if(ngains==0 || nsamples==0) return 0;
222  // Loop over gains to look for m_fixedGain
223  //unsigned int this_gain=0;
224  int offset;
225  uint32_t x;
226 
227  if (FebConfig==0 || FebConfig>3) {
228  //Converter can currently not deal with this situation
229  LARBSDBG("Suspicious FebConfig valud" << FebConfig << ", don't know what to do for Accumulated Calib Digit - return 0");
230  return 0;
231  }
232 
233  const uint32_t febgain=FebConfig&0x3; // to be done better when this is better understood
234  gain=RawToOfflineGain(febgain);
235 
236  if (m_fixedGain!=CaloGain::LARNGAIN &&
237  gain!=m_fixedGain) {
238  LARBSDBG("Requested gain: " << m_fixedGain << " got " << gain << " data ingored.");
239  return 0;
240  }
241 
242 
243  // 2 is the size of the accumulated header
244  offset=block + 2 + (channelNumber&0x7F)*(nsamples*2); // needs to be updated for loop on gains
245  if(offset+2*nsamples>size-3) return 0;
246  if((channelNumber&0x7F)*nsamples*2>bsize) return 0;
247 
248 
249  samplesSum.resize(nsamples);
250  corr2Sum.resize(nsamples);
251 
252  for (unsigned int i=0;i<nsamples;i++)
253  {
254  x=m_FebBlock[offset+i];
255  samplesSum[i]=x;
256  //std::cout << "SUM[" << i-1 << "] = " << std::hex << x << std::endl;
257  }
258  offset+=nsamples;
259  for (unsigned int i=0;i<nsamples;i++)
260  {
261  x=m_FebBlock[offset+i];
262  corr2Sum[i]=x;
263  //std::cout << "SUMSQ[" << i-1 << "] = " << std::hex << x << std::endl;
264  }
265 
266  gain=RawToOfflineGain(febgain);
267 
268  ++m_Result1Counter;
269  return 1;
270 }
271 
272 
273 uint32_t LArRodBlockAccumulatedV3::getNumberOfSamples() const
274 {
275  return getHeader16(NSamples);
276 }
277 
278 uint32_t LArRodBlockAccumulatedV3::getNumberOfGains() const
279 {
280  return getHeader16(NGains);
281 }
282 
283 uint16_t LArRodBlockAccumulatedV3::getNTrigger() const
284 {
285 
286  int index=getHeader16(ResultsOff1);
287  uint32_t x=m_FebBlock[index+NTrigger/2];
288  return (uint16_t) x;
289 }
290 
291 uint16_t LArRodBlockAccumulatedV3::getStepIndex() const
292 {
293  int index=getHeader16(ResultsOff1);
294  uint32_t x = m_FebBlock[index+StepIndex/2]&0xffff;
295  return (uint16_t) x;
296 }
297 
298 uint16_t LArRodBlockAccumulatedV3::getResults1Size() const
299 {
300  return getHeader16(ResultsDim1);
301 }
302 
303 uint16_t LArRodBlockAccumulatedV3::getResults2Size() const
304 {
305  return getHeader16(ResultsDim2);
306 }
307 
308 uint16_t LArRodBlockAccumulatedV3::getRawDataSize() const
309 {
310  return getHeader16(RawDataBlkDim);
311 }
312 
313 uint16_t LArRodBlockAccumulatedV3::getNStep() const
314 {
315  int index=getHeader16(ResultsOff1);
316  uint32_t x = m_FebBlock[index+StepIndex/2]>>16;
317  return (uint16_t) x;
318 }
319 
320 uint32_t LArRodBlockAccumulatedV3::getRadd(uint32_t adc, uint32_t sample) const
321 {
322  int ngain=getHeader16(NGains);
323  int index=getHeader16(RawDataBlkOff);
324  if(index<=0) return 0;
325  index+=(8+64*ngain)*sample+adc/2;
326  uint32_t x=m_FebBlock[index];
327  if(adc&0x1) return x>>16;
328  return x&0xffff;
329 }
330 
331 uint16_t LArRodBlockAccumulatedV3::getCtrl1(uint32_t adc) const
332 {
333  int index=getHeader16(RawDataBlkOff)-16+adc/2;
334  uint32_t x=m_FebBlock[index];
335  if(adc&0x1) x=x>>16;
336  else x=x&0xffff;
337  uint16_t ctrl=x;
338  return ctrl;
339  /*
340  int index=getHeader16(RawDataBlkOff)-16;
341  uint32_t x=m_FebBlock[index];
342  if(adc&0x1) return x>>16;
343  return x&0xffff;
344  */
345 }
346 
347 uint16_t LArRodBlockAccumulatedV3::getCtrl2(uint32_t adc) const
348 {
349  int index=getHeader16(RawDataBlkOff)-8+adc/2;
350  uint32_t x=m_FebBlock[index];
351  if(adc&0x1) x=x>>16;
352  else x=x&0xffff;
353  uint16_t ctrl=x;
354  return ctrl;
355  /*
356  int index=getHeader16(RawDataBlkOff)-8 ;
357  uint32_t x=m_FebBlock[index];
358  if(adc&0x1) return x>>16;
359  return x&0xffff;
360  */
361 }
362 
363 uint16_t LArRodBlockAccumulatedV3::getCtrl3(uint32_t adc) const
364 {
365  int nsamples=getHeader16(NSamples);
366  int ngains=getHeader16(NGains);
367  int offset=nsamples*(8+64*ngains)+adc/2;
368  int index=getHeader16(RawDataBlkOff)+offset;
369  uint32_t x=m_FebBlock[index];
370  if(adc&0x1) x=x>>16;
371  else x=x&0xffff;
372  uint16_t ctrl=x;
373  return ctrl;
374  /*
375  int index=getHeader16(RawDataBlkOff)-3;
376  uint32_t x=m_FebBlock[index];
377  x=x>>16;
378  uint16_t ctrl=x;
379  return ctrl;
380  */
381 }
382 
383 uint32_t LArRodBlockAccumulatedV3::getStatus() const
384 {
385  // Old version: get Dsp status word
386  if(getNumberOfWords()<EventStatus/2) return 0;
387  uint32_t x=getHeader32(EventStatus);
388  return x;
389 
390  // New verion: get Rod status word
391  //int nsamples = getHeader16(NSamples);
392  //int ngains = getHeader16(NGains);
393  //int offset = nsamples*(8+64*ngains)+8;
394  //int index = getHeader16(RawDataBlkOff)+offset;
395  //uint32_t x = m_FebBlock[index];
396  //return x;
397 }
398 
399 
400 #ifdef LARBSDBGOUTPUT
401 #undef LARBSDBGOUTPUT
402 #endif
403 #undef LARBSDBG
LArRodBlockStructure
Definition: LArRodBlockStructure.h:48
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
LArRodBlockAccumulatedV3::StepIndex
@ StepIndex
Definition: LArRodBlockAccumulatedV3.h:53
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
LArRodBlockAccumulatedV3::getStepIndex
uint16_t getStepIndex() const
Definition: LArRodBlockAccumulatedV3.cxx:291
getMessageSvc.h
singleton-like access to IMessageSvc via open function and helper
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
LArRodBlockAccumulatedV3::FEBID
@ FEBID
Definition: LArRodBlockAccumulatedV3.h:30
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
LArRodBlockStructure::getNumberOfWords
uint32_t getNumberOfWords() const
Definition: LArRodBlockStructure.h:428
index
Definition: index.py:1
LArRodBlockAccumulatedV3::getNumberOfGains
virtual uint32_t getNumberOfGains() const
Definition: LArRodBlockAccumulatedV3.cxx:278
LArRodBlockAccumulatedV3::getResults2Size
virtual uint16_t getResults2Size() const
Definition: LArRodBlockAccumulatedV3.cxx:303
LArRodBlockAccumulatedV3::endtag
@ endtag
Definition: LArRodBlockAccumulatedV3.h:48
LArRodBlockAccumulatedV3::m_Result2Counter
int m_Result2Counter
Definition: LArRodBlockAccumulatedV3.h:98
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
LArRodBlockAccumulatedV3::getNumberOfSamples
virtual uint32_t getNumberOfSamples() const
Definition: LArRodBlockAccumulatedV3.cxx:273
LArRodBlockAccumulatedV3::ResultsOff1
@ ResultsOff1
Definition: LArRodBlockAccumulatedV3.h:34
LArRodBlockAccumulatedV3::RawDataBlkDim
@ RawDataBlkDim
Definition: LArRodBlockAccumulatedV3.h:39
LArRodBlockStructure::m_FebBlock
const uint32_t * m_FebBlock
Definition: LArRodBlockStructure.h:227
LArRodBlockAccumulatedV3::FebConfig
@ FebConfig
Definition: LArRodBlockAccumulatedV3.h:45
LArRodBlockAccumulatedV3::getResults1Size
virtual uint16_t getResults1Size() const
Definition: LArRodBlockAccumulatedV3.cxx:298
LArRodBlockAccumulatedV3::getCtrl1
virtual uint16_t getCtrl1(uint32_t adc) const
Definition: LArRodBlockAccumulatedV3.cxx:331
CaloGain::LARNGAIN
@ LARNGAIN
Definition: CaloGain.h:19
x
#define x
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
LArRodBlockAccumulatedV3::ResultsDim2
@ ResultsDim2
Definition: LArRodBlockAccumulatedV3.h:37
LArRodBlockAccumulatedV3::NSamples
@ NSamples
Definition: LArRodBlockAccumulatedV3.h:43
LArRodBlockStructure::m_iHeadBlockSize
unsigned short m_iHeadBlockSize
Definition: LArRodBlockStructure.h:221
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
LArRodBlockStructure::m_rearrangeFirstSample
unsigned int m_rearrangeFirstSample
Definition: LArRodBlockStructure.h:241
LArRodBlockStructure::getHeader32
uint32_t getHeader32(const unsigned n) const
Definition: LArRodBlockStructure.h:365
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
LArRodBlockStructure::RawToOfflineGain
uint32_t RawToOfflineGain(const uint32_t gain) const
Definition: LArRodBlockStructure.h:349
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:113
LArRodBlockAccumulatedV3.h
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArRodBlockAccumulatedV3::getStatus
virtual uint32_t getStatus() const
Definition: LArRodBlockAccumulatedV3.cxx:383
LArRodBlockAccumulatedV3::getFirstSampleIndex
uint16_t getFirstSampleIndex() const
Definition: LArRodBlockAccumulatedV3.h:136
LArRodBlockAccumulatedV3::resetPointers
virtual void resetPointers()
Definition: LArRodBlockAccumulatedV3.cxx:32
LArRodBlockAccumulatedV3::m_Result1Index
int m_Result1Index
Definition: LArRodBlockAccumulatedV3.h:97
LArRodBlockAccumulatedV3::getRadd
virtual uint32_t getRadd(uint32_t adc, uint32_t sample) const
Definition: LArRodBlockAccumulatedV3.cxx:320
LArRodBlockAccumulatedV3::getCtrl3
virtual uint16_t getCtrl3(uint32_t adc) const
Definition: LArRodBlockAccumulatedV3.cxx:363
LArRodBlockAccumulatedV3::EventStatus
@ EventStatus
Definition: LArRodBlockAccumulatedV3.h:40
LArRodBlockAccumulatedV3::BlockType
std::string BlockType()
Definition: LArRodBlockAccumulatedV3.h:60
LArRodBlockAccumulatedV3::m_Result2Index
int m_Result2Index
Definition: LArRodBlockAccumulatedV3.h:99
LArRodBlockAccumulatedV3::getRawDataSize
virtual uint16_t getRawDataSize() const
Definition: LArRodBlockAccumulatedV3.cxx:308
LArRodBlockAccumulatedV3::m_RawDataCounter
int m_RawDataCounter
Definition: LArRodBlockAccumulatedV3.h:100
LArRodBlockAccumulatedV3::getNTrigger
uint16_t getNTrigger() const
Definition: LArRodBlockAccumulatedV3.cxx:283
LArRodBlockAccumulatedV3::getCtrl2
virtual uint16_t getCtrl2(uint32_t adc) const
Definition: LArRodBlockAccumulatedV3.cxx:347
LArRodBlockAccumulatedV3::m_fixedGain
unsigned m_fixedGain
Definition: LArRodBlockAccumulatedV3.h:103
LArRodBlockAccumulatedV3::getFebConfig
uint16_t getFebConfig() const
Definition: LArRodBlockAccumulatedV3.h:131
LArRodBlockAccumulatedV3::NGains
@ NGains
Definition: LArRodBlockAccumulatedV3.h:42
LArRodBlockAccumulatedV3::m_Result1Counter
int m_Result1Counter
Definition: LArRodBlockAccumulatedV3.h:96
LArRodBlockAccumulatedV3::getNextRawData
virtual int getNextRawData(int &channelNumber, std::vector< short > &samples, uint32_t &gain)
Definition: LArRodBlockAccumulatedV3.cxx:47
ReadOfcFromCool.nsamples
nsamples
Definition: ReadOfcFromCool.py:115
DeMoScan.index
string index
Definition: DeMoScan.py:364
LARBSDBG
#define LARBSDBG(text)
Definition: LArRodBlockAccumulatedV3.cxx:21
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
LArRodBlockAccumulatedV3::LArRodBlockAccumulatedV3
LArRodBlockAccumulatedV3()
Definition: LArRodBlockAccumulatedV3.cxx:25
LArRodBlockAccumulatedV3::getTDCPhase
virtual uint8_t getTDCPhase() const
Definition: LArRodBlockAccumulatedV3.cxx:42
LArRodBlockAccumulatedV3::NTrigger
@ NTrigger
Definition: LArRodBlockAccumulatedV3.h:51
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
LArRodBlockAccumulatedV3::RawDataBlkOff
@ RawDataBlkOff
Definition: LArRodBlockAccumulatedV3.h:38
LArRodBlockAccumulatedV3::getNStep
uint16_t getNStep() const
Definition: LArRodBlockAccumulatedV3.cxx:313
PlotCalibFromCool.ngain
ngain
Definition: PlotCalibFromCool.py:565
LArRodBlockAccumulatedV3::ResultsDim1
@ ResultsDim1
Definition: LArRodBlockAccumulatedV3.h:35
LArRodBlockStructure::m_channelsPerFEB
int m_channelsPerFEB
Definition: LArRodBlockStructure.h:225
LArRodBlockAccumulatedV3::m_RawDataIndex
int m_RawDataIndex
Definition: LArRodBlockAccumulatedV3.h:101
LArRodBlockStructure::getHeader16
uint16_t getHeader16(const unsigned n) const
Definition: LArRodBlockStructure.h:355
LArRodBlockAccumulatedV3::getNextAccumulatedDigit
virtual int getNextAccumulatedDigit(int &channelNumber, std::vector< uint64_t > &SamplesSum, std::vector< uint64_t > &corr2Sum, uint32_t &gain)
Definition: LArRodBlockAccumulatedV3.cxx:146
Generated on Sun Dec 22 2024 21:13:42 for ATLAS Offline Software by   doxygen 1.8.18