ATLAS Offline Software
Public Types | Public Member Functions | Private Attributes | List of all members
ZDCDataAnalyzer Class Reference

#include <ZDCDataAnalyzer.h>

Collaboration diagram for ZDCDataAnalyzer:

Public Types

typedef std::array< std::array< float, 4 >, 2 > ZDCModuleFloatArray
 
typedef std::array< std::array< bool, 4 >, 2 > ZDCModuleBoolArray
 
typedef std::array< std::array< int, 4 >, 2 > ZDCModuleIntArray
 

Public Member Functions

 ZDCDataAnalyzer (ZDCMsg::MessageFunctionPtr messageFunc_p, int nSample, float deltaTSample, size_t preSampleIdx, std::string fitFunction, const ZDCModuleIntArray &peak2ndDerivMinSamples, const ZDCModuleFloatArray &peak2ndDerivMinThresholdsHG, const ZDCModuleFloatArray &peak2ndDerivMinThresholdsLG, unsigned int LGMode=ZDCPulseAnalyzer::LGModeNormal)
 
 ~ZDCDataAnalyzer ()
 
void enableDelayed (float deltaT, const ZDCModuleFloatArray &undelayedDelayedPedestalDiff)
 
void enableDelayed (const ZDCModuleFloatArray &delayDeltaT, const ZDCModuleFloatArray &undelayedDelayedPedestalDiff)
 
void enableRepass (const ZDCModuleFloatArray &peak2ndDerivMinRepassHG, const ZDCModuleFloatArray &peak2ndDerivMinRepassLG)
 
void enablePreExclusion (unsigned int maxSamplesExcl, const ZDCModuleIntArray &HGADCThresh, const ZDCModuleIntArray &LGADCThresh)
 
void enablePreExclusion (unsigned int maxSamplesExcl, unsigned int HGADCThresh, unsigned int LGADCThresh)
 
void enablePostExclusion (unsigned int maxSamplesExcl, const ZDCModuleIntArray &HGADCThresh, const ZDCModuleIntArray &LGADCThresh)
 
void enablePostExclusion (unsigned int maxSamplesExcl, unsigned int HGADCThresh, unsigned int LGADCThresh)
 
bool ModuleDisabled (unsigned int side, unsigned int module) const
 
unsigned int GetModuleMask () const
 
float GetModuleSum (size_t side) const
 
float GetModuleSumErr (size_t side) const
 
float GetSideBkgdFrac (size_t side) const
 
float GetCalibModuleSum (size_t side) const
 
float GetCalibModuleSumErr (size_t side) const
 
float GetSideCalibBkgdFrac (size_t side) const
 
float GetModuleSumPreSample (size_t side) const
 
float GetAverageTime (size_t side) const
 
bool SideFailed (size_t side) const
 
float GetModuleAmplitude (size_t side, size_t module) const
 
float GetModuleTime (size_t side, size_t module) const
 
float GetModuleChisq (size_t side, size_t module) const
 
float GetModuleCalibAmplitude (size_t side, size_t module) const
 
float GetModuleCalibTime (size_t side, size_t module) const
 
float GetModuleStatus (size_t side, size_t module) const
 
float GetdelayedBS (size_t side, size_t module) const
 
const ZDCPulseAnalyzer * GetPulseAnalyzer (size_t side, size_t module) const
 
bool disableModule (size_t side, size_t module)
 
void set2ndDerivStep (size_t step)
 
void SetGainFactorsHGLG (float gainFactorHG, float gainFactorLG)
 
void SetGainFactorsHGLG (const ZDCModuleFloatArray &gainFactorsHG, const ZDCModuleFloatArray &gainFactorsLG)
 
void SetPeak2ndDerivMinTolerances (size_t tolerance)
 
void SetFitTimeMax (float tmax)
 
void SetSaveFitFunc (bool save)
 
void SetADCOverUnderflowValues (const ZDCModuleFloatArray &HGOverflowADC, const ZDCModuleFloatArray &HGUnderflowADC, const ZDCModuleFloatArray &LGOverflowADC)
 
void SetNoiseSigmas (const ZDCModuleFloatArray &noiseSigmasHG, const ZDCModuleFloatArray &noiseSigmasLG)
 
void SetTauT0Values (const ZDCModuleBoolArray &fxiTau1, const ZDCModuleBoolArray &fxiTau2, const ZDCModuleFloatArray &tau1, const ZDCModuleFloatArray &tau2, const ZDCModuleFloatArray &t0HG, const ZDCModuleFloatArray &t0LG)
 
void SetFitMinMaxAmpValues (const ZDCModuleFloatArray &minAmpHG, const ZDCModuleFloatArray &minAmpLG, const ZDCModuleFloatArray &maxAmpHG, const ZDCModuleFloatArray &maxAmpLG)
 
void SetFitMinMaxAmpValues (float minHG, float minLG, float maxHG, float maxLG)
 
void SetCutValues (const ZDCModuleFloatArray &chisqDivAmpCutHG, const ZDCModuleFloatArray &chisqDivAmpCutLG, const ZDCModuleFloatArray &deltaT0MinHG, const ZDCModuleFloatArray &deltaT0MaxHG, const ZDCModuleFloatArray &deltaT0MinLG, const ZDCModuleFloatArray &deltaT0MaxLG)
 
void SetTimingCorrParams (ZDCPulseAnalyzer::TimingCorrMode mode, float refADC, float refScale, const std::array< std::array< std::vector< float >, 4 >, 2 > &HGParamArr, const std::array< std::array< std::vector< float >, 4 >, 2 > &LGParamArr)
 
void SetNonlinCorrParams (float refADC, float refScale, const std::array< std::array< std::vector< float >, 4 >, 2 > &HGNonlinCorrParams, const std::array< std::array< std::vector< float >, 4 >, 2 > &LHGNonlinCorrParams)
 
void SetModuleAmpFractionLG (const ZDCDataAnalyzer::ZDCModuleFloatArray &moduleAmpFractionLG)
 
void enableTimeSigCut (bool AND, float sigCut, const std::string &TF1String, const std::array< std::array< std::vector< double >, 4 >, 2 > &parsHGArr, const std::array< std::array< std::vector< double >, 4 >, 2 > &parsLGArr)
 
void LoadEnergyCalibrations (std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &calibSplines)
 
void LoadT0Calibrations (std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &T0HGOffsetSplines, std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &T0LGOffsetSplines)
 
void StartEvent (int lumiBlock)
 
void LoadAndAnalyzeData (size_t side, size_t module, const std::vector< float > &HGSamples, const std::vector< float > &LGSamples)
 
void LoadAndAnalyzeData (size_t side, size_t module, const std::vector< float > &HGSamples, const std::vector< float > &LGSamples, const std::vector< float > &HGSamplesDelayed, const std::vector< float > &LGSamplesDelayed)
 
bool FinishEvent ()
 

Private Attributes

ZDCMsg::MessageFunctionPtr m_msgFunc_p
 
size_t m_nSample {}
 
float m_deltaTSample {}
 
size_t m_preSampleIdx {}
 
std::string m_fitFunction
 
unsigned int m_LGMode {}
 
bool m_repassEnabled {}
 
std::array< std::array< int, 4 >, 2 > m_delayedOrder {}
 
ZDCModuleBoolArray m_moduleDisabled {}
 
std::array< std::array< std::unique_ptr< ZDCPulseAnalyzer >, 4 >, 2 > m_moduleAnalyzers {}
 
int m_eventCount {}
 
ZDCModuleFloatArray m_HGGains {}
 
ZDCModuleFloatArray m_pedestals {}
 
bool m_haveECalib {}
 
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_LBDepEcalibSplines {}
 
bool m_haveT0Calib {}
 
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_T0HGOffsetSplines {}
 
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_T0LGOffsetSplines {}
 
int m_currentLB {}
 
ZDCModuleFloatArray m_currentECalibCoeff {}
 
ZDCModuleFloatArray m_currentT0OffsetsHG {}
 
ZDCModuleFloatArray m_currentT0OffsetsLG {}
 
std::array< std::array< bool, 4 >, 2 > m_dataLoaded {}
 
unsigned int m_moduleMask
 
std::array< std::array< unsigned int, 4 >, 2 > m_moduleStatus {}
 
std::array< std::array< float, 4 >, 2 > m_calibAmplitude {}
 
std::array< std::array< float, 4 >, 2 > m_calibTime {}
 
std::array< float, 2 > m_moduleSum {}
 
std::array< float, 2 > m_moduleSumErrSq {}
 
std::array< float, 2 > m_moduleSumPreSample {}
 
std::array< float, 2 > m_moduleSumBkgdFrac {}
 
std::array< float, 2 > m_calibModuleSum {}
 
std::array< float, 2 > m_calibModuleSumErrSq {}
 
std::array< float, 2 > m_calibModSumBkgdFrac {}
 
std::array< float, 2 > m_averageTime {}
 
std::array< bool, 2 > m_fail {}
 
std::array< std::array< float, 4 >, 2 > m_moduleAmpFractionLG {}
 

Detailed Description

Definition at line 19 of file ZDCDataAnalyzer.h.

Member Typedef Documentation

◆ ZDCModuleBoolArray

typedef std::array<std::array<bool, 4>, 2> ZDCDataAnalyzer::ZDCModuleBoolArray

Definition at line 23 of file ZDCDataAnalyzer.h.

◆ ZDCModuleFloatArray

typedef std::array<std::array<float, 4>, 2> ZDCDataAnalyzer::ZDCModuleFloatArray

Definition at line 22 of file ZDCDataAnalyzer.h.

◆ ZDCModuleIntArray

typedef std::array<std::array<int, 4>, 2> ZDCDataAnalyzer::ZDCModuleIntArray

Definition at line 24 of file ZDCDataAnalyzer.h.

Constructor & Destructor Documentation

◆ ZDCDataAnalyzer()

ZDCDataAnalyzer::ZDCDataAnalyzer ( ZDCMsg::MessageFunctionPtr  messageFunc_p,
int  nSample,
float  deltaTSample,
size_t  preSampleIdx,
std::string  fitFunction,
const ZDCModuleIntArray &  peak2ndDerivMinSamples,
const ZDCModuleFloatArray &  peak2ndDerivMinThresholdsHG,
const ZDCModuleFloatArray &  peak2ndDerivMinThresholdsLG,
unsigned int  LGMode = ZDCPulseAnalyzer::LGModeNormal 
)

Definition at line 15 of file ZDCDataAnalyzer.cxx.

19  :
20  m_msgFunc_p(msgFunc_p),
21  m_nSample(nSample), m_deltaTSample(deltaTSample), m_preSampleIdx(preSampleIdx),
22  m_fitFunction(std::move(fitFunction)),
23  m_LGMode(LGMode),
24  m_repassEnabled(false),
25  m_eventCount(0),
26  m_haveECalib(false),
27  m_haveT0Calib(false),
28  m_currentLB(-1),
29 
30  // Default "calibrations"
31  m_currentECalibCoeff ({{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}}),
32  m_currentT0OffsetsHG ({{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}}),
33  m_currentT0OffsetsLG ({{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}}),
34 
35  m_moduleMask(0),
36  m_moduleSum({{0, 0}}),
37  m_moduleSumErrSq({{0, 0}}),
38  m_moduleSumPreSample({{0, 0}}),
39  m_calibModuleSum({{0, 0}}),
40  m_calibModuleSumErrSq({{0, 0}}),
41  m_averageTime({{0, 0}}),
42  m_fail({{false, false}})
43 {
44  m_moduleDisabled[0] = {{false, false, false, false}};
45  m_moduleDisabled[1] = {{false, false, false, false}};
46 
47  m_moduleAnalyzers[0] = {{0, 0, 0, 0}};
48  m_moduleAnalyzers[1] = {{0, 0, 0, 0}};
49 
50  m_calibAmplitude[0] = {{0, 0, 0, 0}};
51  m_calibAmplitude[1] = {{0, 0, 0, 0}};
52 
53  m_calibTime[0] = {{0, 0, 0, 0}};
54  m_calibTime[1] = {{0, 0, 0, 0}};
55 
56  m_dataLoaded[0] = {{false, false, false, false}};
57  m_dataLoaded[1] = {{false, false, false, false}};
58 
59  m_delayedOrder[0] = {0, 0, 0, 0};
60  m_delayedOrder[1] = {0, 0, 0, 0};
61 
62  // For now we are using hard-coded gain factors and pedestals
63  //
64  m_HGGains[0] = {{10, 10, 10, 10}};
65  m_HGGains[1] = {{10, 10, 10, 10}};
66 
67  m_pedestals[0] = {{100, 100, 100, 100}};
68  m_pedestals[1] = {{100, 100, 100, 100}};
69 
70 
71  // Construct the per-module pulse analyzers
72  //
73  for (size_t side : {0, 1}) {
74  for (size_t module : {0, 1, 2, 3}) {
75  std::ostringstream moduleTag;
76  moduleTag << "_s" << side << "_m" << module;
77 
78  m_moduleAnalyzers[side][module].reset (new ZDCPulseAnalyzer(m_msgFunc_p, moduleTag.str(), m_nSample, m_deltaTSample, m_preSampleIdx,
79  m_pedestals[side][module], m_HGGains[side][module], m_fitFunction,
80  peak2ndDerivMinSamples[side][module],
81  peak2ndDerivMinThresholdsHG[side][module],
82  peak2ndDerivMinThresholdsLG[side][module]));
83  m_moduleAnalyzers[side][module]->setLGMode(m_LGMode);
84  }
85  }
86 }

◆ ~ZDCDataAnalyzer()

ZDCDataAnalyzer::~ZDCDataAnalyzer ( )

Definition at line 88 of file ZDCDataAnalyzer.cxx.

89 {
90 }

Member Function Documentation

◆ disableModule()

bool ZDCDataAnalyzer::disableModule ( size_t  side,
size_t  module 
)

Definition at line 92 of file ZDCDataAnalyzer.cxx.

93 {
94  if (side < 2 && module < 4) {
95  //
96  // Can't disable in the middle of analysis
97  //
98  if (m_dataLoaded[side][module]) return false;
99  else {
100  m_moduleDisabled[side][module] = true;
101  return true;
102  }
103  }
104  else {
105  return false;
106  }
107 }

◆ enableDelayed() [1/2]

void ZDCDataAnalyzer::enableDelayed ( const ZDCModuleFloatArray &  delayDeltaT,
const ZDCModuleFloatArray &  undelayedDelayedPedestalDiff 
)

Definition at line 120 of file ZDCDataAnalyzer.cxx.

121 {
122  for (size_t side : {0, 1}) {
123  for (size_t module : {0, 1, 2, 3}) {
124  if (delayDeltaTArray[side][module] < 0) m_delayedOrder[side][module] = -1;
125  else m_delayedOrder[side][module] = 1;
126 
127  (*m_msgFunc_p)(ZDCMsg::Verbose, "Enabling use of delayed samples on side, module = " + std::to_string(side) + ", " +
128  std::to_string(module) + ", delta t = " + std::to_string(delayDeltaTArray[side][module]));
129 
130  m_moduleAnalyzers[side][module]->enableDelayed(std::abs(delayDeltaTArray[side][module]), undelayedDelayedPedestalDiff[side][module]);
131  }
132  }
133 }

◆ enableDelayed() [2/2]

void ZDCDataAnalyzer::enableDelayed ( float  deltaT,
const ZDCModuleFloatArray &  undelayedDelayedPedestalDiff 
)

Definition at line 109 of file ZDCDataAnalyzer.cxx.

110 {
111  int delayedOrder = deltaT < 0 ? -1 : 1;
112  for (size_t side : {0, 1}) {
113  for (size_t module : {0, 1, 2, 3}) {
114  m_delayedOrder[side][module] = delayedOrder;
115  m_moduleAnalyzers[side][module]->enableDelayed(std::abs(deltaT), undelayedDelayedPedestalDiff[side][module]);
116  }
117  }
118 }

◆ enablePostExclusion() [1/2]

void ZDCDataAnalyzer::enablePostExclusion ( unsigned int  maxSamplesExcl,
const ZDCModuleIntArray &  HGADCThresh,
const ZDCModuleIntArray &  LGADCThresh 
)

Definition at line 153 of file ZDCDataAnalyzer.cxx.

154 {
155  for (size_t side : {0, 1}) {
156  for (size_t module : {0, 1, 2, 3}) {
157  m_moduleAnalyzers[side][module]->enablePostExclusion(maxSamplesExcl, HGADCThresh[side][module], LGADCThresh[side][module]);
158  }
159  }
160 }

◆ enablePostExclusion() [2/2]

void ZDCDataAnalyzer::enablePostExclusion ( unsigned int  maxSamplesExcl,
unsigned int  HGADCThresh,
unsigned int  LGADCThresh 
)

Definition at line 162 of file ZDCDataAnalyzer.cxx.

163 {
164  for (size_t side : {0, 1}) {
165  for (size_t module : {0, 1, 2, 3}) {
166  m_moduleAnalyzers[side][module]->enablePostExclusion(maxSamplesExcl, HGADCThresh, LGADCThresh);
167  }
168  }
169 }

◆ enablePreExclusion() [1/2]

void ZDCDataAnalyzer::enablePreExclusion ( unsigned int  maxSamplesExcl,
const ZDCModuleIntArray &  HGADCThresh,
const ZDCModuleIntArray &  LGADCThresh 
)

Definition at line 135 of file ZDCDataAnalyzer.cxx.

136 {
137  for (size_t side : {0, 1}) {
138  for (size_t module : {0, 1, 2, 3}) {
139  m_moduleAnalyzers[side][module]->enablePreExclusion(maxSamplesExcl, HGADCThresh[side][module], LGADCThresh[side][module]);
140  }
141  }
142 }

◆ enablePreExclusion() [2/2]

void ZDCDataAnalyzer::enablePreExclusion ( unsigned int  maxSamplesExcl,
unsigned int  HGADCThresh,
unsigned int  LGADCThresh 
)

Definition at line 144 of file ZDCDataAnalyzer.cxx.

145 {
146  for (size_t side : {0, 1}) {
147  for (size_t module : {0, 1, 2, 3}) {
148  m_moduleAnalyzers[side][module]->enablePreExclusion(maxSamplesExcl, HGADCThresh, LGADCThresh);
149  }
150  }
151 }

◆ enableRepass()

void ZDCDataAnalyzer::enableRepass ( const ZDCModuleFloatArray &  peak2ndDerivMinRepassHG,
const ZDCModuleFloatArray &  peak2ndDerivMinRepassLG 
)

Definition at line 172 of file ZDCDataAnalyzer.cxx.

173 {
174  m_repassEnabled = true;
175  for (size_t side : {0, 1}) {
176  for (size_t module : {0, 1, 2, 3}) {
177  m_moduleAnalyzers[side][module]->enableRepass(peak2ndDerivMinRepassHG[side][module], peak2ndDerivMinRepassLG[side][module]);
178  }
179  }
180 }

◆ enableTimeSigCut()

void ZDCDataAnalyzer::enableTimeSigCut ( bool  AND,
float  sigCut,
const std::string &  TF1String,
const std::array< std::array< std::vector< double >, 4 >, 2 > &  parsHGArr,
const std::array< std::array< std::vector< double >, 4 >, 2 > &  parsLGArr 
)

Definition at line 331 of file ZDCDataAnalyzer.cxx.

334 {
335  for (size_t side : {0, 1}) {
336  for (size_t module : {0, 1, 2, 3}) {
337  m_moduleAnalyzers[side][module]->enableTimeSigCut(AND, sigCut, TF1String, parsHGArr[side][module], parsLGArr[side][module]);
338  }
339  }
340 }

◆ FinishEvent()

bool ZDCDataAnalyzer::FinishEvent ( )

Definition at line 492 of file ZDCDataAnalyzer.cxx.

493 {
494  // First make sure that all data is loaded. while we're at it, count how many modules on each side have a pulse
495  //
496  unsigned int sideNPulsesMod[2] = {0, 0};
497 
498  for (size_t side : {0, 1}) {
499  for (size_t module : {0, 1, 2, 3}) {
500  if (!m_dataLoaded[side][module] && !m_moduleDisabled[side][module]) {return false;}
501  if (m_moduleAnalyzers[side][module]->ArmSumInclude()) {sideNPulsesMod[side]++;}
502  }
503  }
504 
505  // Are we doing a repass? If so, reanalyze modules for which no pulse was found the first time
506  // as long as we have one module with a pulse on the given side
507  //
508  if (m_repassEnabled) {
509  for (size_t side : {0, 1}) {
510  if (sideNPulsesMod[side] == 0) continue;
511 
512  for (size_t module : {0, 1, 2, 3}) {
513  if (m_moduleDisabled[side][module]) continue;
514 
515  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
516 
517  // If this module had no pulse the first time, reanalyze it (with a lower 2nd derivative threshold)
518  //
519  if (!pulseAna_p->HavePulse()) {
520  (*m_msgFunc_p)(ZDCMsg::Debug, ("ZDCPulseAnalyzer:: performing a repass on data for side, module = " + std::to_string(side) + ", " + std::to_string(module)));
521  pulseAna_p->ReanalyzeData();
522  m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
523  }
524  }
525  }
526  }
527 
528  // Now sum up amplitudes etc
529  //
530  for (size_t side : {0, 1}) {
531  float tempFraction = 1.0;
532  double sumAmpTimesBkgdFrac = 0.0;
533  double sumCalibAmpTimesBkgdFrac = 0.0;
534 
535  for (size_t module : {0, 1, 2, 3}) {
536  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
537 
538  if (pulseAna_p->ArmSumInclude()) {
539  int moduleMaskBit = 4 * side + module;
540  m_moduleMask |= 1 << moduleMaskBit;
541 
542  float amplitude = pulseAna_p->GetAmplitude();
543  float ampError = pulseAna_p->GetAmpError();
544  float bkgdFraction = pulseAna_p->GetBkgdMaxFraction();
545 
546  m_calibAmplitude[side][module] = amplitude * m_currentECalibCoeff[side][module];
547 
548  float calibAmpError = ampError * m_currentECalibCoeff[side][module];
549 
550  float timeCalib = pulseAna_p->GetT0Corr();
551  if (pulseAna_p->UseLowGain()) {timeCalib -= m_currentT0OffsetsLG[side][module];}
552  else {timeCalib -= m_currentT0OffsetsHG[side][module];}
553 
554  m_calibTime[side][module] = timeCalib;
555 
556  m_moduleSum[side] += amplitude;
557  m_moduleSumErrSq[side] += ampError * ampError;
558  sumAmpTimesBkgdFrac += amplitude*bkgdFraction;
559 
560  m_moduleSumPreSample[side] += pulseAna_p->GetPreSampleAmp();
561 
562  m_calibModuleSum[side] += m_calibAmplitude[side][module];
563  m_calibModuleSumErrSq[side] += calibAmpError * calibAmpError;
564 
565  m_averageTime[side] += m_calibTime[side][module] * m_calibAmplitude[side][module];
566  sumCalibAmpTimesBkgdFrac += amplitude*bkgdFraction;
567  }
568 
569  // subtract the fraction of LGOverflow events if we have fraction available (<0 means unavailable)
570  if (pulseAna_p->LGOverflow() && m_moduleAmpFractionLG[side][module] > 0) {tempFraction -= m_moduleAmpFractionLG[side][module];}
571  }
572 
573  {
574  CXXUTILS_TRAPPING_FP;
575  if (m_moduleSum[side] > 0) m_moduleSumBkgdFrac[side] = sumAmpTimesBkgdFrac/m_moduleSum[side];
576  else m_moduleSumBkgdFrac[side] = 0;
577  }
578 
579  if (m_calibModuleSum[side] > 1e-6) {
580  m_averageTime[side] /= m_calibModuleSum[side];
581  m_calibModSumBkgdFrac[side] = sumCalibAmpTimesBkgdFrac/m_calibModuleSum[side];
582  }
583  else {
584  m_averageTime[side] = 0;
585  m_calibModSumBkgdFrac[side] = 0;
586  }
587 
588  if (tempFraction < 1.0) {m_moduleSum[side] /= tempFraction;}
589  }
590 
591  m_eventCount++;
592  return true;
593 }

◆ GetAverageTime()

float ZDCDataAnalyzer::GetAverageTime ( size_t  side) const
inline

Definition at line 119 of file ZDCDataAnalyzer.h.

119 {return m_averageTime.at(side);}

◆ GetCalibModuleSum()

float ZDCDataAnalyzer::GetCalibModuleSum ( size_t  side) const
inline

Definition at line 113 of file ZDCDataAnalyzer.h.

113 {return m_calibModuleSum.at(side);}

◆ GetCalibModuleSumErr()

float ZDCDataAnalyzer::GetCalibModuleSumErr ( size_t  side) const
inline

Definition at line 114 of file ZDCDataAnalyzer.h.

114 {return std::sqrt(m_calibModuleSumErrSq.at(side));}

◆ GetdelayedBS()

float ZDCDataAnalyzer::GetdelayedBS ( size_t  side,
size_t  module 
) const
inline

Definition at line 130 of file ZDCDataAnalyzer.h.

130 {return m_moduleAnalyzers.at(side).at(module)->GetdelayBS();}

◆ GetModuleAmplitude()

float ZDCDataAnalyzer::GetModuleAmplitude ( size_t  side,
size_t  module 
) const
inline

Definition at line 122 of file ZDCDataAnalyzer.h.

122 {return m_moduleAnalyzers.at(side).at(module)->GetAmplitude();}

◆ GetModuleCalibAmplitude()

float ZDCDataAnalyzer::GetModuleCalibAmplitude ( size_t  side,
size_t  module 
) const
inline

Definition at line 126 of file ZDCDataAnalyzer.h.

126 {return m_calibAmplitude.at(side).at(module);}

◆ GetModuleCalibTime()

float ZDCDataAnalyzer::GetModuleCalibTime ( size_t  side,
size_t  module 
) const
inline

Definition at line 127 of file ZDCDataAnalyzer.h.

127 {return m_calibTime.at(side).at(module);}

◆ GetModuleChisq()

float ZDCDataAnalyzer::GetModuleChisq ( size_t  side,
size_t  module 
) const
inline

Definition at line 124 of file ZDCDataAnalyzer.h.

124 {return m_moduleAnalyzers.at(side).at(module)->GetChisq();}

◆ GetModuleMask()

unsigned int ZDCDataAnalyzer::GetModuleMask ( ) const
inline

Definition at line 107 of file ZDCDataAnalyzer.h.

107 {return m_moduleMask;}

◆ GetModuleStatus()

float ZDCDataAnalyzer::GetModuleStatus ( size_t  side,
size_t  module 
) const
inline

Definition at line 128 of file ZDCDataAnalyzer.h.

128 {return m_moduleStatus.at(side).at(module);}

◆ GetModuleSum()

float ZDCDataAnalyzer::GetModuleSum ( size_t  side) const
inline

Definition at line 109 of file ZDCDataAnalyzer.h.

109 {return m_moduleSum.at(side);}

◆ GetModuleSumErr()

float ZDCDataAnalyzer::GetModuleSumErr ( size_t  side) const
inline

Definition at line 110 of file ZDCDataAnalyzer.h.

110 {return std::sqrt(m_moduleSumErrSq.at(side));}

◆ GetModuleSumPreSample()

float ZDCDataAnalyzer::GetModuleSumPreSample ( size_t  side) const
inline

Definition at line 117 of file ZDCDataAnalyzer.h.

117 {return m_moduleSumPreSample.at(side);}

◆ GetModuleTime()

float ZDCDataAnalyzer::GetModuleTime ( size_t  side,
size_t  module 
) const
inline

Definition at line 123 of file ZDCDataAnalyzer.h.

123 {return m_moduleAnalyzers.at(side).at(module)->GetT0Corr();}

◆ GetPulseAnalyzer()

const ZDCPulseAnalyzer* ZDCDataAnalyzer::GetPulseAnalyzer ( size_t  side,
size_t  module 
) const
inline

Definition at line 132 of file ZDCDataAnalyzer.h.

132 {return m_moduleAnalyzers.at(side).at(module).get();}

◆ GetSideBkgdFrac()

float ZDCDataAnalyzer::GetSideBkgdFrac ( size_t  side) const
inline

Definition at line 111 of file ZDCDataAnalyzer.h.

111 {return m_moduleSumBkgdFrac.at(side);}

◆ GetSideCalibBkgdFrac()

float ZDCDataAnalyzer::GetSideCalibBkgdFrac ( size_t  side) const
inline

Definition at line 115 of file ZDCDataAnalyzer.h.

115 {return m_calibModSumBkgdFrac.at(side);}

◆ LoadAndAnalyzeData() [1/2]

void ZDCDataAnalyzer::LoadAndAnalyzeData ( size_t  side,
size_t  module,
const std::vector< float > &  HGSamples,
const std::vector< float > &  LGSamples 
)

Definition at line 430 of file ZDCDataAnalyzer.cxx.

431 {
432 
433  // We immediately return if this module is disabled
434  //
435  if (m_moduleDisabled[side][module]) {
436  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Skipping analysis of disabled module for event index " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
437 
438  return;
439  }
440 
441  (*m_msgFunc_p)(ZDCMsg::Verbose, ("/n Loading data for event index " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
442 
443  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
444  pulseAna_p->LoadAndAnalyzeData(HGSamples, LGSamples);
445  m_dataLoaded[side][module] = true;
446 
447  if (pulseAna_p->Failed()) {
448  (*m_msgFunc_p)(ZDCMsg::Debug, ("ZDCPulseAnalyzer::LoadData() returned fail for event " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
449 
450  m_fail[side] = true;
451  }
452 
453  m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
454 }

◆ LoadAndAnalyzeData() [2/2]

void ZDCDataAnalyzer::LoadAndAnalyzeData ( size_t  side,
size_t  module,
const std::vector< float > &  HGSamples,
const std::vector< float > &  LGSamples,
const std::vector< float > &  HGSamplesDelayed,
const std::vector< float > &  LGSamplesDelayed 
)

Definition at line 456 of file ZDCDataAnalyzer.cxx.

458 {
459  // We immediately return if this module is disabled
460  //
461  if (m_moduleDisabled[side][module]) {
462  (*m_msgFunc_p)(ZDCMsg::Debug, ("Skipping analysis of disabled mofule for event index " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
463 
464  return;
465  }
466 
467  if (m_delayedOrder[side][module] == 0) {
468  (*m_msgFunc_p)(ZDCMsg::Error, ("Handling of delayed pulses not enabled, on side, module = " + std::to_string(side) + ", " + std::to_string(module) + ", skipping processing for event index " + std::to_string(m_eventCount)));
469  return;
470  }
471 
472  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Loading undelayed and delayed data for event index " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
473 
474  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
475  if (m_delayedOrder[side][module] > 0) {
476  pulseAna_p->LoadAndAnalyzeData(HGSamples, LGSamples, HGSamplesDelayed, LGSamplesDelayed);
477  }
478  else {
479  pulseAna_p->LoadAndAnalyzeData(HGSamplesDelayed, LGSamplesDelayed, HGSamples, LGSamples);
480  }
481  m_dataLoaded[side][module] = true;
482 
483  if (pulseAna_p->Failed()) {
484  (*m_msgFunc_p)(ZDCMsg::Debug, ("ZDCPulseAnalyzer::LoadData() returned fail for event " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
485 
486  m_fail[side] = true;
487  }
488 
489  m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
490 }

◆ LoadEnergyCalibrations()

void ZDCDataAnalyzer::LoadEnergyCalibrations ( std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &  calibSplines)
inline

Definition at line 182 of file ZDCDataAnalyzer.h.

183  {
184  (*m_msgFunc_p)(ZDCMsg::Verbose, "Loading energy calibrations");
185 
186  m_LBDepEcalibSplines = std::move (calibSplines);
187  m_haveECalib = true;
188  }

◆ LoadT0Calibrations()

void ZDCDataAnalyzer::LoadT0Calibrations ( std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &  T0HGOffsetSplines,
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &  T0LGOffsetSplines 
)
inline

Definition at line 190 of file ZDCDataAnalyzer.h.

192  {
193  (*m_msgFunc_p)(ZDCMsg::Verbose, "Loading timing calibrations");
194 
195  m_T0HGOffsetSplines = std::move (T0HGOffsetSplines);
196  m_T0LGOffsetSplines = std::move (T0LGOffsetSplines);
197 
198  m_haveT0Calib = true;
199  }

◆ ModuleDisabled()

bool ZDCDataAnalyzer::ModuleDisabled ( unsigned int  side,
unsigned int  module 
) const
inline

Definition at line 105 of file ZDCDataAnalyzer.h.

105 {return m_moduleDisabled[side][module];}

◆ set2ndDerivStep()

void ZDCDataAnalyzer::set2ndDerivStep ( size_t  step)

Definition at line 182 of file ZDCDataAnalyzer.cxx.

183 {
184  for (size_t side : {0, 1}) {
185  for (size_t module : {0, 1, 2, 3}) {
186  m_moduleAnalyzers[side][module]->set2ndDerivStep(step);
187  }
188  }
189 }

◆ SetADCOverUnderflowValues()

void ZDCDataAnalyzer::SetADCOverUnderflowValues ( const ZDCModuleFloatArray &  HGOverflowADC,
const ZDCModuleFloatArray &  HGUnderflowADC,
const ZDCModuleFloatArray &  LGOverflowADC 
)

Definition at line 282 of file ZDCDataAnalyzer.cxx.

284 {
285  for (size_t side : {0, 1}) {
286  for (size_t module : {0, 1, 2, 3}) {
287  m_moduleAnalyzers[side][module]->SetADCOverUnderflowValues(HGOverflowADC[side][module], HGUnderflowADC[side][module], LGOverflowADC[side][module]);
288  }
289  }
290 }

◆ SetCutValues()

void ZDCDataAnalyzer::SetCutValues ( const ZDCModuleFloatArray &  chisqDivAmpCutHG,
const ZDCModuleFloatArray &  chisqDivAmpCutLG,
const ZDCModuleFloatArray &  deltaT0MinHG,
const ZDCModuleFloatArray &  deltaT0MaxHG,
const ZDCModuleFloatArray &  deltaT0MinLG,
const ZDCModuleFloatArray &  deltaT0MaxLG 
)

Definition at line 292 of file ZDCDataAnalyzer.cxx.

295 {
296  for (size_t side : {0, 1}) {
297  for (size_t module : {0, 1, 2, 3}) {
298  m_moduleAnalyzers[side][module]->SetCutValues(chisqDivAmpCutHG[side][module], chisqDivAmpCutLG[side][module],
299  deltaT0MinHG[side][module], deltaT0MaxHG[side][module],
300  deltaT0MinLG[side][module], deltaT0MaxLG[side][module]);
301  }
302  }
303 }

◆ SetFitMinMaxAmpValues() [1/2]

void ZDCDataAnalyzer::SetFitMinMaxAmpValues ( const ZDCModuleFloatArray &  minAmpHG,
const ZDCModuleFloatArray &  minAmpLG,
const ZDCModuleFloatArray &  maxAmpHG,
const ZDCModuleFloatArray &  maxAmpLG 
)

Definition at line 261 of file ZDCDataAnalyzer.cxx.

263 {
264  for (size_t side : {0, 1}) {
265  for (size_t module : {0, 1, 2, 3}) {
266  m_moduleAnalyzers[side][module]->SetFitMinMaxAmp(minAmpHG[side][module], minAmpLG[side][module],
267  maxAmpHG[side][module], maxAmpLG[side][module]);
268 
269  }
270  }
271 }

◆ SetFitMinMaxAmpValues() [2/2]

void ZDCDataAnalyzer::SetFitMinMaxAmpValues ( float  minHG,
float  minLG,
float  maxHG,
float  maxLG 
)

Definition at line 273 of file ZDCDataAnalyzer.cxx.

274 {
275  for (size_t side : {0, 1}) {
276  for (size_t module : {0, 1, 2, 3}) {
277  m_moduleAnalyzers[side][module]->SetFitMinMaxAmp(minHG, minLG, maxHG, maxLG);
278  }
279  }
280 }

◆ SetFitTimeMax()

void ZDCDataAnalyzer::SetFitTimeMax ( float  tmax)

Definition at line 218 of file ZDCDataAnalyzer.cxx.

218  {
219  for (size_t side : {0, 1}) {
220  for (size_t module : {0, 1, 2, 3}) {
221  m_moduleAnalyzers[side][module]->SetFitTimeMax(tmax);
222  }
223  }
224 }

◆ SetGainFactorsHGLG() [1/2]

void ZDCDataAnalyzer::SetGainFactorsHGLG ( const ZDCModuleFloatArray &  gainFactorsHG,
const ZDCModuleFloatArray &  gainFactorsLG 
)

Definition at line 200 of file ZDCDataAnalyzer.cxx.

201 {
202  for (size_t side : {0, 1}) {
203  for (size_t module : {0, 1, 2, 3}) {
204  m_moduleAnalyzers[side][module]->SetGainFactorsHGLG(gainFactorsHG[side][module], gainFactorsLG[side][module]);
205  }
206  }
207 }

◆ SetGainFactorsHGLG() [2/2]

void ZDCDataAnalyzer::SetGainFactorsHGLG ( float  gainFactorHG,
float  gainFactorLG 
)

Definition at line 191 of file ZDCDataAnalyzer.cxx.

192 {
193  for (size_t side : {0, 1}) {
194  for (size_t module : {0, 1, 2, 3}) {
195  m_moduleAnalyzers[side][module]->SetGainFactorsHGLG(gainFactorHG, gainFactorLG);
196  }
197  }
198 }

◆ SetModuleAmpFractionLG()

void ZDCDataAnalyzer::SetModuleAmpFractionLG ( const ZDCDataAnalyzer::ZDCModuleFloatArray &  moduleAmpFractionLG)

Definition at line 253 of file ZDCDataAnalyzer.cxx.

253  {
254  for (size_t side : {0, 1}) {
255  for (size_t module : {0, 1, 2, 3}) {
256  m_moduleAmpFractionLG[side][module] = moduleAmpFractionLG[side][module];
257  }
258  }
259 }

◆ SetNoiseSigmas()

void ZDCDataAnalyzer::SetNoiseSigmas ( const ZDCModuleFloatArray &  noiseSigmasHG,
const ZDCModuleFloatArray &  noiseSigmasLG 
)

Definition at line 244 of file ZDCDataAnalyzer.cxx.

245 {
246  for (size_t side : {0, 1}) {
247  for (size_t module : {0, 1, 2, 3}) {
248  m_moduleAnalyzers[side][module]->SetNoiseSigmas(noiseSigmasHG[side][module], noiseSigmasLG[side][module]);
249  }
250  }
251 }

◆ SetNonlinCorrParams()

void ZDCDataAnalyzer::SetNonlinCorrParams ( float  refADC,
float  refScale,
const std::array< std::array< std::vector< float >, 4 >, 2 > &  HGNonlinCorrParams,
const std::array< std::array< std::vector< float >, 4 >, 2 > &  LHGNonlinCorrParams 
)

Definition at line 318 of file ZDCDataAnalyzer.cxx.

321 {
322  for (size_t side : {0, 1}) {
323  for (size_t module : {0, 1, 2, 3}) {
324  m_moduleAnalyzers[side][module]->SetNonlinCorrParams(refADC, refScale,
325  HGNonlinCorrParams[side][module],
326  LGNonlinCorrParams[side][module]);
327  }
328  }
329 }

◆ SetPeak2ndDerivMinTolerances()

void ZDCDataAnalyzer::SetPeak2ndDerivMinTolerances ( size_t  tolerance)

Definition at line 209 of file ZDCDataAnalyzer.cxx.

209  {
210  for (size_t side : {0, 1}) {
211  for (size_t module : {0, 1, 2, 3}) {
212  m_moduleAnalyzers[side][module]->SetPeak2ndDerivMinTolerance(tolerance);
213  }
214  }
215 }

◆ SetSaveFitFunc()

void ZDCDataAnalyzer::SetSaveFitFunc ( bool  save)

Definition at line 227 of file ZDCDataAnalyzer.cxx.

227  {
228  ZDCPulseAnalyzer::SetSaveFitFunc(save);
229 }

◆ SetTauT0Values()

void ZDCDataAnalyzer::SetTauT0Values ( const ZDCModuleBoolArray &  fxiTau1,
const ZDCModuleBoolArray &  fxiTau2,
const ZDCModuleFloatArray &  tau1,
const ZDCModuleFloatArray &  tau2,
const ZDCModuleFloatArray &  t0HG,
const ZDCModuleFloatArray &  t0LG 
)

Definition at line 232 of file ZDCDataAnalyzer.cxx.

235 {
236  for (size_t side : {0, 1}) {
237  for (size_t module : {0, 1, 2, 3}) {
238  m_moduleAnalyzers[side][module]->SetTauT0Values(fixTau1[side][module], fixTau2[side][module],
239  tau1[side][module], tau2[side][module], t0HG[side][module], t0LG[side][module]);
240  }
241  }
242 }

◆ SetTimingCorrParams()

void ZDCDataAnalyzer::SetTimingCorrParams ( ZDCPulseAnalyzer::TimingCorrMode  mode,
float  refADC,
float  refScale,
const std::array< std::array< std::vector< float >, 4 >, 2 > &  HGParamArr,
const std::array< std::array< std::vector< float >, 4 >, 2 > &  LGParamArr 
)

Definition at line 305 of file ZDCDataAnalyzer.cxx.

308 {
309  for (size_t side : {0, 1}) {
310  for (size_t module : {0, 1, 2, 3}) {
311  m_moduleAnalyzers[side][module]->SetTimingCorrParams(mode, refADC, refScale,
312  HGParamArr.at(side).at(module), LGParamArr.at(side).at(module));
313  }
314  }
315 
316 }

◆ SideFailed()

bool ZDCDataAnalyzer::SideFailed ( size_t  side) const
inline

Definition at line 120 of file ZDCDataAnalyzer.h.

120 {return m_fail.at(side);}

◆ StartEvent()

void ZDCDataAnalyzer::StartEvent ( int  lumiBlock)

Definition at line 342 of file ZDCDataAnalyzer.cxx.

343 {
344  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Starting new event, event index = " + std::to_string(m_eventCount)));
345 
346  // By default we perform quiet pulse fits
347  //
348  if ((*m_msgFunc_p)(ZDCMsg::Verbose, "")) {ZDCPulseAnalyzer::SetQuietFits(false);}
349  else {ZDCPulseAnalyzer::SetQuietFits(true);}
350 
351  // See if we have to load up new calibrations
352  //
353  if (lumiBlock != m_currentLB) {
354  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Starting new luminosity block " + std::to_string(lumiBlock)));
355 
356  if (m_haveECalib) {
357  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Loading energy calibrations for event " + std::to_string(m_eventCount) + ", lumi block " +
358  std::to_string(lumiBlock)));
359 
360  for (size_t side : {0, 1}) {
361  for (size_t module : {0, 1, 2, 3}) {
362  float splineLBMin = m_LBDepEcalibSplines[side][module]->GetXmin();
363  float splineLBMax = m_LBDepEcalibSplines[side][module]->GetXmax();
364 
365  if (lumiBlock >= splineLBMin && lumiBlock <= splineLBMax) {
366  m_currentECalibCoeff[side][module] = m_LBDepEcalibSplines[side][module]->Eval(lumiBlock);
367  }
368  else if (lumiBlock < splineLBMin) {
369  m_currentECalibCoeff[side][module] = m_LBDepEcalibSplines[side][module]->Eval(splineLBMin);
370  }
371  else {
372  m_currentECalibCoeff[side][module] = m_LBDepEcalibSplines[side][module]->Eval(splineLBMax);
373  }
374  }
375  }
376  } // end of if (_haveEcalib) {
377 
378  if (m_haveT0Calib) {
379  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Loading timing calibrations for event " + std::to_string(m_eventCount) + ", lumi block " + std::to_string(lumiBlock)));
380 
381  for (size_t side : {0, 1}) {
382  for (size_t module : {0, 1, 2, 3}) {
383  float splineLBMin = m_T0HGOffsetSplines[side][module]->GetXmin();
384  float splineLBMax = m_T0HGOffsetSplines[side][module]->GetXmax();
385 
386  if (lumiBlock >= splineLBMin && lumiBlock <= splineLBMax) {
387  m_currentT0OffsetsHG[side][module] = m_T0HGOffsetSplines[side][module]->Eval(lumiBlock);
388  m_currentT0OffsetsLG[side][module] = m_T0LGOffsetSplines[side][module]->Eval(lumiBlock);
389  }
390  else if (lumiBlock < splineLBMin) {
391  m_currentT0OffsetsHG[side][module] = m_T0HGOffsetSplines[side][module]->Eval(splineLBMin);
392  m_currentT0OffsetsLG[side][module] = m_T0LGOffsetSplines[side][module]->Eval(splineLBMin);
393  }
394  else {
395  m_currentT0OffsetsHG[side][module] = m_T0HGOffsetSplines[side][module]->Eval(splineLBMax);
396  m_currentT0OffsetsLG[side][module] = m_T0LGOffsetSplines[side][module]->Eval(splineLBMax);
397  }
398  }
399  }
400  } // end of if (m_haveT0Calib)
401  }
402 
403  // Initialize transient results
404  //
405  for (size_t side : {0, 1}) {
406  for (size_t module : {0, 1, 2, 3}) {
407  m_dataLoaded[side][module] = false;
408  m_moduleStatus[side][module] = 0;
409  m_calibAmplitude[side][module] = 0;
410  m_calibTime[side][module] = 0;
411  // _moduleFail[side][module] = false;
412  }
413 
414  m_moduleSum[side] = 0;
415  m_moduleSumErrSq[side] = 0;
416  m_moduleSumPreSample[side] = 0;
417  m_moduleSumBkgdFrac[side] = 0;
418 
419  m_calibModuleSum[side] = 0;
420  m_calibModuleSumErrSq[side] = 0;
421  m_calibModSumBkgdFrac[side] = 0;
422  m_averageTime[side] = 0;
423  m_fail[side] = false;
424  }
425 
426  m_moduleMask = 0;
427  m_currentLB = lumiBlock;
428 }

Member Data Documentation

◆ m_averageTime

std::array<float, 2> ZDCDataAnalyzer::m_averageTime {}
private

Definition at line 78 of file ZDCDataAnalyzer.h.

◆ m_calibAmplitude

std::array<std::array<float, 4>, 2> ZDCDataAnalyzer::m_calibAmplitude {}
private

Definition at line 66 of file ZDCDataAnalyzer.h.

◆ m_calibModSumBkgdFrac

std::array<float, 2> ZDCDataAnalyzer::m_calibModSumBkgdFrac {}
private

Definition at line 76 of file ZDCDataAnalyzer.h.

◆ m_calibModuleSum

std::array<float, 2> ZDCDataAnalyzer::m_calibModuleSum {}
private

Definition at line 74 of file ZDCDataAnalyzer.h.

◆ m_calibModuleSumErrSq

std::array<float, 2> ZDCDataAnalyzer::m_calibModuleSumErrSq {}
private

Definition at line 75 of file ZDCDataAnalyzer.h.

◆ m_calibTime

std::array<std::array<float, 4>, 2> ZDCDataAnalyzer::m_calibTime {}
private

Definition at line 67 of file ZDCDataAnalyzer.h.

◆ m_currentECalibCoeff

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentECalibCoeff {}
private

Definition at line 56 of file ZDCDataAnalyzer.h.

◆ m_currentLB

int ZDCDataAnalyzer::m_currentLB {}
private

Definition at line 55 of file ZDCDataAnalyzer.h.

◆ m_currentT0OffsetsHG

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentT0OffsetsHG {}
private

Definition at line 57 of file ZDCDataAnalyzer.h.

◆ m_currentT0OffsetsLG

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentT0OffsetsLG {}
private

Definition at line 58 of file ZDCDataAnalyzer.h.

◆ m_dataLoaded

std::array<std::array<bool, 4>, 2> ZDCDataAnalyzer::m_dataLoaded {}
private

Definition at line 60 of file ZDCDataAnalyzer.h.

◆ m_delayedOrder

std::array<std::array<int, 4>, 2> ZDCDataAnalyzer::m_delayedOrder {}
private

Definition at line 36 of file ZDCDataAnalyzer.h.

◆ m_deltaTSample

float ZDCDataAnalyzer::m_deltaTSample {}
private

Definition at line 29 of file ZDCDataAnalyzer.h.

◆ m_eventCount

int ZDCDataAnalyzer::m_eventCount {}
private

Definition at line 41 of file ZDCDataAnalyzer.h.

◆ m_fail

std::array<bool, 2> ZDCDataAnalyzer::m_fail {}
private

Definition at line 79 of file ZDCDataAnalyzer.h.

◆ m_fitFunction

std::string ZDCDataAnalyzer::m_fitFunction
private

Definition at line 31 of file ZDCDataAnalyzer.h.

◆ m_haveECalib

bool ZDCDataAnalyzer::m_haveECalib {}
private

Definition at line 46 of file ZDCDataAnalyzer.h.

◆ m_haveT0Calib

bool ZDCDataAnalyzer::m_haveT0Calib {}
private

Definition at line 49 of file ZDCDataAnalyzer.h.

◆ m_HGGains

ZDCModuleFloatArray ZDCDataAnalyzer::m_HGGains {}
private

Definition at line 43 of file ZDCDataAnalyzer.h.

◆ m_LBDepEcalibSplines

std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> ZDCDataAnalyzer::m_LBDepEcalibSplines {}
private

Definition at line 47 of file ZDCDataAnalyzer.h.

◆ m_LGMode

unsigned int ZDCDataAnalyzer::m_LGMode {}
private

Definition at line 32 of file ZDCDataAnalyzer.h.

◆ m_moduleAmpFractionLG

std::array<std::array<float, 4>, 2> ZDCDataAnalyzer::m_moduleAmpFractionLG {}
private

Definition at line 81 of file ZDCDataAnalyzer.h.

◆ m_moduleAnalyzers

std::array<std::array<std::unique_ptr<ZDCPulseAnalyzer>, 4>, 2> ZDCDataAnalyzer::m_moduleAnalyzers {}
private

Definition at line 39 of file ZDCDataAnalyzer.h.

◆ m_moduleDisabled

ZDCModuleBoolArray ZDCDataAnalyzer::m_moduleDisabled {}
private

Definition at line 38 of file ZDCDataAnalyzer.h.

◆ m_moduleMask

unsigned int ZDCDataAnalyzer::m_moduleMask
private

Definition at line 63 of file ZDCDataAnalyzer.h.

◆ m_moduleStatus

std::array<std::array<unsigned int, 4>, 2> ZDCDataAnalyzer::m_moduleStatus {}
private

Definition at line 65 of file ZDCDataAnalyzer.h.

◆ m_moduleSum

std::array<float, 2> ZDCDataAnalyzer::m_moduleSum {}
private

Definition at line 69 of file ZDCDataAnalyzer.h.

◆ m_moduleSumBkgdFrac

std::array<float, 2> ZDCDataAnalyzer::m_moduleSumBkgdFrac {}
private

Definition at line 72 of file ZDCDataAnalyzer.h.

◆ m_moduleSumErrSq

std::array<float, 2> ZDCDataAnalyzer::m_moduleSumErrSq {}
private

Definition at line 70 of file ZDCDataAnalyzer.h.

◆ m_moduleSumPreSample

std::array<float, 2> ZDCDataAnalyzer::m_moduleSumPreSample {}
private

Definition at line 71 of file ZDCDataAnalyzer.h.

◆ m_msgFunc_p

ZDCMsg::MessageFunctionPtr ZDCDataAnalyzer::m_msgFunc_p
private

Definition at line 27 of file ZDCDataAnalyzer.h.

◆ m_nSample

size_t ZDCDataAnalyzer::m_nSample {}
private

Definition at line 28 of file ZDCDataAnalyzer.h.

◆ m_pedestals

ZDCModuleFloatArray ZDCDataAnalyzer::m_pedestals {}
private

Definition at line 44 of file ZDCDataAnalyzer.h.

◆ m_preSampleIdx

size_t ZDCDataAnalyzer::m_preSampleIdx {}
private

Definition at line 30 of file ZDCDataAnalyzer.h.

◆ m_repassEnabled

bool ZDCDataAnalyzer::m_repassEnabled {}
private

Definition at line 34 of file ZDCDataAnalyzer.h.

◆ m_T0HGOffsetSplines

std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> ZDCDataAnalyzer::m_T0HGOffsetSplines {}
private

Definition at line 50 of file ZDCDataAnalyzer.h.

◆ m_T0LGOffsetSplines

std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> ZDCDataAnalyzer::m_T0LGOffsetSplines {}
private

Definition at line 51 of file ZDCDataAnalyzer.h.

The documentation for this class was generated from the following files:
ZDCDataAnalyzer::m_T0LGOffsetSplines
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_T0LGOffsetSplines
Definition: ZDCDataAnalyzer.h:51
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ZDCDataAnalyzer::m_calibAmplitude
std::array< std::array< float, 4 >, 2 > m_calibAmplitude
Definition: ZDCDataAnalyzer.h:66
ZDCDataAnalyzer::m_dataLoaded
std::array< std::array< bool, 4 >, 2 > m_dataLoaded
Definition: ZDCDataAnalyzer.h:60
CXXUTILS_TRAPPING_FP
#define CXXUTILS_TRAPPING_FP
Definition: trapping_fp.h:24
ZDCPulseAnalyzer::UseLowGain
bool UseLowGain() const
Definition: ZDCPulseAnalyzer.h:534
ZDCDataAnalyzer::m_moduleMask
unsigned int m_moduleMask
Definition: ZDCDataAnalyzer.h:63
ZDCPulseAnalyzer::ArmSumInclude
bool ArmSumInclude() const
Definition: ZDCPulseAnalyzer.h:554
ZDCPulseAnalyzer::ReanalyzeData
bool ReanalyzeData()
Definition: ZDCPulseAnalyzer.cxx:647
ZDCPulseAnalyzer::Failed
bool Failed() const
Definition: ZDCPulseAnalyzer.h:535
ZDCDataAnalyzer::m_moduleAnalyzers
std::array< std::array< std::unique_ptr< ZDCPulseAnalyzer >, 4 >, 2 > m_moduleAnalyzers
Definition: ZDCDataAnalyzer.h:39
ZDCPulseAnalyzer::GetAmpError
float GetAmpError() const
Definition: ZDCPulseAnalyzer.h:579
ZDCPulseAnalyzer::LGOverflow
bool LGOverflow() const
Definition: ZDCPulseAnalyzer.h:540
ZDCPulseAnalyzer::GetStatusMask
unsigned int GetStatusMask() const
Definition: ZDCPulseAnalyzer.cxx:1920
ZDCDataAnalyzer::m_repassEnabled
bool m_repassEnabled
Definition: ZDCDataAnalyzer.h:34
ZDCPulseAnalyzer::HavePulse
bool HavePulse() const
Definition: ZDCPulseAnalyzer.h:533
ZDCDataAnalyzer::m_moduleSum
std::array< float, 2 > m_moduleSum
Definition: ZDCDataAnalyzer.h:69
ZDCDataAnalyzer::m_T0HGOffsetSplines
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_T0HGOffsetSplines
Definition: ZDCDataAnalyzer.h:50
Root::AND
@ AND
Definition: TGRLCollection.h:32
ZDCPulseAnalyzer
Definition: ZDCPulseAnalyzer.h:24
ZDCPulseAnalyzer::GetAmplitude
float GetAmplitude() const
Definition: ZDCPulseAnalyzer.h:578
ZDCDataAnalyzer::m_msgFunc_p
ZDCMsg::MessageFunctionPtr m_msgFunc_p
Definition: ZDCDataAnalyzer.h:27
ZDCPulseAnalyzer::SetQuietFits
static void SetQuietFits(bool quiet)
Definition: ZDCPulseAnalyzer.h:430
ZDCPulseAnalyzer::GetT0Corr
float GetT0Corr() const
Definition: ZDCPulseAnalyzer.h:565
TRT::Hit::side
@ side
Definition: HitInfo.h:83
ZDCPulseAnalyzer::LoadAndAnalyzeData
bool LoadAndAnalyzeData(const std::vector< float > &ADCSamplesHG, const std::vector< float > &ADCSamplesLG)
Definition: ZDCPulseAnalyzer.cxx:570
ZDCDataAnalyzer::m_calibTime
std::array< std::array< float, 4 >, 2 > m_calibTime
Definition: ZDCDataAnalyzer.h:67
python.PyAthena.module
module
Definition: PyAthena.py:131
ZDCDataAnalyzer::m_haveECalib
bool m_haveECalib
Definition: ZDCDataAnalyzer.h:46
ZDCMsg::Verbose
@ Verbose
Definition: ZDCMsg.h:18
ZDCDataAnalyzer::m_eventCount
int m_eventCount
Definition: ZDCDataAnalyzer.h:41
checkTP.save
def save(self, fileName="./columbo.out")
Definition: checkTP.py:178
ZDCDataAnalyzer::m_moduleSumBkgdFrac
std::array< float, 2 > m_moduleSumBkgdFrac
Definition: ZDCDataAnalyzer.h:72
ZDCDataAnalyzer::m_haveT0Calib
bool m_haveT0Calib
Definition: ZDCDataAnalyzer.h:49
ZDCDataAnalyzer::m_fail
std::array< bool, 2 > m_fail
Definition: ZDCDataAnalyzer.h:79
ZDCDataAnalyzer::m_calibModuleSumErrSq
std::array< float, 2 > m_calibModuleSumErrSq
Definition: ZDCDataAnalyzer.h:75
ZDCDataAnalyzer::m_averageTime
std::array< float, 2 > m_averageTime
Definition: ZDCDataAnalyzer.h:78
ZDCDataAnalyzer::m_pedestals
ZDCModuleFloatArray m_pedestals
Definition: ZDCDataAnalyzer.h:44
ZDCDataAnalyzer::m_nSample
size_t m_nSample
Definition: ZDCDataAnalyzer.h:28
ZDCDataAnalyzer::m_fitFunction
std::string m_fitFunction
Definition: ZDCDataAnalyzer.h:31
ZDCDataAnalyzer::m_currentLB
int m_currentLB
Definition: ZDCDataAnalyzer.h:55
ZDCDataAnalyzer::m_moduleSumPreSample
std::array< float, 2 > m_moduleSumPreSample
Definition: ZDCDataAnalyzer.h:71
ZDCPulseAnalyzer::SetSaveFitFunc
static void SetSaveFitFunc(bool save)
Definition: ZDCPulseAnalyzer.h:431
Preparation.mode
mode
Definition: Preparation.py:94
ZDCDataAnalyzer::m_LGMode
unsigned int m_LGMode
Definition: ZDCDataAnalyzer.h:32
ZDCDataAnalyzer::m_calibModuleSum
std::array< float, 2 > m_calibModuleSum
Definition: ZDCDataAnalyzer.h:74
ZDCDataAnalyzer::m_calibModSumBkgdFrac
std::array< float, 2 > m_calibModSumBkgdFrac
Definition: ZDCDataAnalyzer.h:76
ZDCMsg::Error
@ Error
Definition: ZDCMsg.h:22
tolerance
Definition: suep_shower.h:17
ZDCDataAnalyzer::m_preSampleIdx
size_t m_preSampleIdx
Definition: ZDCDataAnalyzer.h:30
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
ZDCDataAnalyzer::m_moduleSumErrSq
std::array< float, 2 > m_moduleSumErrSq
Definition: ZDCDataAnalyzer.h:70
ZDCDataAnalyzer::m_currentT0OffsetsHG
ZDCModuleFloatArray m_currentT0OffsetsHG
Definition: ZDCDataAnalyzer.h:57
ZDCDataAnalyzer::m_moduleStatus
std::array< std::array< unsigned int, 4 >, 2 > m_moduleStatus
Definition: ZDCDataAnalyzer.h:65
ZDCPulseAnalyzer::GetBkgdMaxFraction
float GetBkgdMaxFraction() const
Definition: ZDCPulseAnalyzer.h:633
ZDCDataAnalyzer::m_currentECalibCoeff
ZDCModuleFloatArray m_currentECalibCoeff
Definition: ZDCDataAnalyzer.h:56
ZDCDataAnalyzer::m_currentT0OffsetsLG
ZDCModuleFloatArray m_currentT0OffsetsLG
Definition: ZDCDataAnalyzer.h:58
ZDCDataAnalyzer::m_LBDepEcalibSplines
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_LBDepEcalibSplines
Definition: ZDCDataAnalyzer.h:47
LArCellBinning.step
step
Definition: LArCellBinning.py:158
ZDCMsg::Debug
@ Debug
Definition: ZDCMsg.h:19
ZDCDataAnalyzer::m_moduleDisabled
ZDCModuleBoolArray m_moduleDisabled
Definition: ZDCDataAnalyzer.h:38
ZDCDataAnalyzer::m_HGGains
ZDCModuleFloatArray m_HGGains
Definition: ZDCDataAnalyzer.h:43
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:327
ZDCDataAnalyzer::m_moduleAmpFractionLG
std::array< std::array< float, 4 >, 2 > m_moduleAmpFractionLG
Definition: ZDCDataAnalyzer.h:81
ZDCDataAnalyzer::m_delayedOrder
std::array< std::array< int, 4 >, 2 > m_delayedOrder
Definition: ZDCDataAnalyzer.h:36
ZDCPulseAnalyzer::GetPreSampleAmp
float GetPreSampleAmp() const
Definition: ZDCPulseAnalyzer.h:632
ZDCDataAnalyzer::m_deltaTSample
float m_deltaTSample
Definition: ZDCDataAnalyzer.h:29
Generated on Thu Nov 7 2024 22:08:35 for ATLAS Offline Software by   doxygen 1.8.18