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, bool forceLG=false)
 
 ~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, 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
 
bool m_forceLG {}
 
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,
bool  forceLG = false 
)

Definition at line 14 of file ZDCDataAnalyzer.cxx.

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

◆ ~ZDCDataAnalyzer()

ZDCDataAnalyzer::~ZDCDataAnalyzer ( )

Definition at line 87 of file ZDCDataAnalyzer.cxx.

88 {
89 }

Member Function Documentation

◆ disableModule()

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

Definition at line 91 of file ZDCDataAnalyzer.cxx.

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

◆ enableDelayed() [1/2]

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

Definition at line 119 of file ZDCDataAnalyzer.cxx.

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

◆ enableDelayed() [2/2]

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

Definition at line 108 of file ZDCDataAnalyzer.cxx.

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

◆ enablePostExclusion() [1/2]

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

Definition at line 152 of file ZDCDataAnalyzer.cxx.

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

◆ enablePostExclusion() [2/2]

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

Definition at line 161 of file ZDCDataAnalyzer.cxx.

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

◆ enablePreExclusion() [1/2]

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

Definition at line 134 of file ZDCDataAnalyzer.cxx.

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

◆ enablePreExclusion() [2/2]

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

Definition at line 143 of file ZDCDataAnalyzer.cxx.

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

◆ enableRepass()

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

Definition at line 171 of file ZDCDataAnalyzer.cxx.

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

◆ enableTimeSigCut()

void ZDCDataAnalyzer::enableTimeSigCut ( bool  AND,
float  sigCut,
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 330 of file ZDCDataAnalyzer.cxx.

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

◆ FinishEvent()

bool ZDCDataAnalyzer::FinishEvent ( )

Definition at line 491 of file ZDCDataAnalyzer.cxx.

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

◆ 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 429 of file ZDCDataAnalyzer.cxx.

430 {
431 
432  // We immediately return if this module is disabled
433  //
434  if (m_moduleDisabled[side][module]) {
435  (*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)));
436 
437  return;
438  }
439 
440  (*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)));
441 
442  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
443  pulseAna_p->LoadAndAnalyzeData(HGSamples, LGSamples);
444  m_dataLoaded[side][module] = true;
445 
446  if (pulseAna_p->Failed()) {
447  (*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)));
448 
449  m_fail[side] = true;
450  }
451 
452  m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
453 }

◆ 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 455 of file ZDCDataAnalyzer.cxx.

457 {
458  // We immediately return if this module is disabled
459  //
460  if (m_moduleDisabled[side][module]) {
461  (*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)));
462 
463  return;
464  }
465 
466  if (m_delayedOrder[side][module] == 0) {
467  (*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)));
468  return;
469  }
470 
471  (*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)));
472 
473  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
474  if (m_delayedOrder[side][module] > 0) {
475  pulseAna_p->LoadAndAnalyzeData(HGSamples, LGSamples, HGSamplesDelayed, LGSamplesDelayed);
476  }
477  else {
478  pulseAna_p->LoadAndAnalyzeData(HGSamplesDelayed, LGSamplesDelayed, HGSamples, LGSamples);
479  }
480  m_dataLoaded[side][module] = true;
481 
482  if (pulseAna_p->Failed()) {
483  (*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)));
484 
485  m_fail[side] = true;
486  }
487 
488  m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
489 }

◆ 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 181 of file ZDCDataAnalyzer.cxx.

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

◆ SetADCOverUnderflowValues()

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

Definition at line 281 of file ZDCDataAnalyzer.cxx.

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

◆ 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 291 of file ZDCDataAnalyzer.cxx.

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

◆ SetFitMinMaxAmpValues() [1/2]

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

Definition at line 260 of file ZDCDataAnalyzer.cxx.

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

◆ SetFitMinMaxAmpValues() [2/2]

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

Definition at line 272 of file ZDCDataAnalyzer.cxx.

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

◆ SetFitTimeMax()

void ZDCDataAnalyzer::SetFitTimeMax ( float  tmax)

Definition at line 217 of file ZDCDataAnalyzer.cxx.

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

◆ SetGainFactorsHGLG() [1/2]

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

Definition at line 199 of file ZDCDataAnalyzer.cxx.

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

◆ SetGainFactorsHGLG() [2/2]

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

Definition at line 190 of file ZDCDataAnalyzer.cxx.

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

◆ SetModuleAmpFractionLG()

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

Definition at line 252 of file ZDCDataAnalyzer.cxx.

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

◆ SetNoiseSigmas()

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

Definition at line 243 of file ZDCDataAnalyzer.cxx.

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

◆ 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 317 of file ZDCDataAnalyzer.cxx.

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

◆ SetPeak2ndDerivMinTolerances()

void ZDCDataAnalyzer::SetPeak2ndDerivMinTolerances ( size_t  tolerance)

Definition at line 208 of file ZDCDataAnalyzer.cxx.

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

◆ SetSaveFitFunc()

void ZDCDataAnalyzer::SetSaveFitFunc ( bool  save)

Definition at line 226 of file ZDCDataAnalyzer.cxx.

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

◆ 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 231 of file ZDCDataAnalyzer.cxx.

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

◆ 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 304 of file ZDCDataAnalyzer.cxx.

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

◆ 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 341 of file ZDCDataAnalyzer.cxx.

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

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_forceLG

bool ZDCDataAnalyzer::m_forceLG {}
private

Definition at line 32 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_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
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
ZDCPulseAnalyzer::UseLowGain
bool UseLowGain() const
Definition: ZDCPulseAnalyzer.h:490
ZDCDataAnalyzer::m_moduleMask
unsigned int m_moduleMask
Definition: ZDCDataAnalyzer.h:63
ZDCPulseAnalyzer::ArmSumInclude
bool ArmSumInclude() const
Definition: ZDCPulseAnalyzer.h:510
ZDCPulseAnalyzer::ReanalyzeData
bool ReanalyzeData()
Definition: ZDCPulseAnalyzer.cxx:625
ZDCPulseAnalyzer::Failed
bool Failed() const
Definition: ZDCPulseAnalyzer.h:491
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:535
ZDCPulseAnalyzer::LGOverflow
bool LGOverflow() const
Definition: ZDCPulseAnalyzer.h:496
ZDCPulseAnalyzer::GetStatusMask
unsigned int GetStatusMask() const
Definition: ZDCPulseAnalyzer.cxx:1789
ZDCDataAnalyzer::m_repassEnabled
bool m_repassEnabled
Definition: ZDCDataAnalyzer.h:34
ZDCPulseAnalyzer::HavePulse
bool HavePulse() const
Definition: ZDCPulseAnalyzer.h:489
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:534
ZDCDataAnalyzer::m_msgFunc_p
ZDCMsg::MessageFunctionPtr m_msgFunc_p
Definition: ZDCDataAnalyzer.h:27
ZDCPulseAnalyzer::SetQuietFits
static void SetQuietFits(bool quiet)
Definition: ZDCPulseAnalyzer.h:386
ZDCPulseAnalyzer::GetT0Corr
float GetT0Corr() const
Definition: ZDCPulseAnalyzer.h:521
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:548
ZDCDataAnalyzer::m_calibTime
std::array< std::array< float, 4 >, 2 > m_calibTime
Definition: ZDCDataAnalyzer.h:67
python.PyAthena.module
module
Definition: PyAthena.py:134
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_forceLG
bool m_forceLG
Definition: ZDCDataAnalyzer.h:32
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:387
Preparation.mode
mode
Definition: Preparation.py:95
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
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
ZDCPulseAnalyzer::GetBkgdMaxFraction
float GetBkgdMaxFraction() const
Definition: ZDCPulseAnalyzer.h:561
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:560
ZDCDataAnalyzer::m_deltaTSample
float m_deltaTSample
Definition: ZDCDataAnalyzer.h:29
Generated on Sun Jun 30 2024 22:10:21 for ATLAS Offline Software by   doxygen 1.8.18