#include <ZDCDataAnalyzer.h>

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
using	JSON = ZDCJSONConfig::JSON

Public Member Functions
	ZDCDataAnalyzer (ZDCMsg::MessageFunctionPtr messageFunc_p, int nSample, float deltaTSample, size_t preSampleIdx, const std::string &fitFunction, const ZDCModuleIntArray &peak2ndDerivMinSamples, const ZDCModuleFloatArray &peak2ndDerivMinThresholdsHG, const ZDCModuleFloatArray &peak2ndDerivMinThresholdsLG, unsigned int LGMode=ZDCPulseAnalyzer::LGModeNormal)
	ZDCDataAnalyzer (ZDCMsg::MessageFunctionPtr messageFunc_p, const JSON &configJSON)
	~ZDCDataAnalyzer ()
template<typename T>
bool	getPulseAnalyzerGlobalPar (const std::string &key, T &value)
template<typename T>
void	invokeAll (T functor)
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
bool	moduleEnabled (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
void	DoNLcalibModuleSum ()
float	GetNLcalibModuleSum (size_t side) const
float	GetNLcalibModuleSumErr (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
ZDCPulseAnalyzer *	GetPulseAnalyzer (size_t side, size_t module)
bool	disableModule (size_t side, size_t module)
void	set2ndDerivStep (size_t step)
void	setMinimumSignificance (float sigMinHG, float sigMinLG)
void	SetGainFactorsHGLG (float gainFactorHG, float gainFactorLG)
void	SetGainFactorsHGLG (const ZDCModuleFloatArray &gainFactorsHG, const ZDCModuleFloatArray &gainFactorsLG)
void	SetPeak2ndDerivMinTolerances (size_t tolerance)
void	SetFitTimeMax (float tmax)
void	SetADCOverUnderflowValues (const ZDCModuleFloatArray &HGOverflowADC, const ZDCModuleFloatArray &HGUnderflowADC, const ZDCModuleFloatArray &LGOverflowADC)
void	SetNoiseSigmas (const ZDCModuleFloatArray &noiseSigmasHG, const ZDCModuleFloatArray &noiseSigmasLG)
void	setPerSampleNoiseSigmas (const std::array< std::array< std::vector< float >, 4 >, 2 > &sampleNoiseVecsHG, const std::array< std::array< std::vector< float >, 4 >, 2 > &sampleNoiseVecsLG)
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	SetTimeCuts (const ZDCModuleFloatArray &deltaT0MinHG, const ZDCModuleFloatArray &deltaT0MaxHG, const ZDCModuleFloatArray &deltaT0MinLG, const ZDCModuleFloatArray &deltaT0MaxLG)
void	SetChisqCuts (const ZDCModuleFloatArray &chisqDivAmpCutHG, const ZDCModuleFloatArray &chisqDivAmpScaleHG, const ZDCModuleFloatArray &chisqDivAmpOffsetHG, const ZDCModuleFloatArray &chisqDivAmpPowerHG, const ZDCModuleFloatArray &chisqDivAmpCutLG, const ZDCModuleFloatArray &chisqDivAmpScaleLG, const ZDCModuleFloatArray &chisqDivAmpOffsetLG, const ZDCModuleFloatArray &chisqDivAmpPowerLG)
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	SetNLcalibParams (std::array< std::array< std::vector< float >, 3 >, 2 > &nlcalibParams)
void	SetModuleAmpFractionLG (const ZDCDataAnalyzer::ZDCModuleFloatArray &moduleAmpFractionLG)
void	enablePostPulseCheck (unsigned int postPulseSampleDelta, float postPulseDerivMinSig, float postPulseAbsDer2ndMinSig, float minMainDer2ndRatio)
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	enableFADCCorrections (bool correctPerSample, std::array< std::array< std::unique_ptr< const TH1 >, 4 >, 2 > &correHistHG, std::array< std::array< std::unique_ptr< const TH1 >, 4 >, 2 > &correHistLG)
void	disableFADCCorrections ()
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 ()
void	saveFitFunc (bool save)
void	setQuietFits (bool quiet)

Static Public Attributes
static const ZDCJSONConfig::JSONParamList	JSONConfigParams

Private Member Functions
void	init ()

Private Attributes
ZDCMsg::MessageFunctionPtr	m_msgFunc_p
std::unique_ptr< ZDCJSONConfig >	m_dataAnalyzerConfig {}
std::unique_ptr< ZDCJSONConfig >	m_pulseAnalyzerConfig {}
bool	m_repassEnabled {false}
std::array< std::array< int, 4 >, 2 >	m_delayedOrder {}
ZDCModuleBoolArray	m_moduleEnabled {}
std::array< std::array< std::unique_ptr< ZDCPulseAnalyzer >, 4 >, 2 >	m_moduleAnalyzers {}
int	m_eventCount {0}
ZDCModuleFloatArray	m_HGGains {}
ZDCModuleFloatArray	m_pedestals {}
bool	m_haveECalib {false}
bool	m_haveT0Calib {false}
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 >	m_LBDepEcalibSplines {}
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 >	m_T0HGOffsetSplines {}
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 >	m_T0LGOffsetSplines {}
bool	m_haveIterCalibCorr {false}
std::array< std::vector< std::tuple< unsigned int, float, std::vector< float > > >, 2 >	m_iterCalibCorr
int	m_currentLB {-1}
ZDCModuleFloatArray	m_currentECalibCoeff {}
ZDCModuleFloatArray	m_currentT0OffsetsHG {}
ZDCModuleFloatArray	m_currentT0OffsetsLG {}
std::array< std::array< bool, 4 >, 2 >	m_dataLoaded {}
unsigned int	m_moduleMask {0}
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 {}
bool	m_haveNLcalib {false}
std::array< std::array< std::vector< float >, 3 >, 2 >	m_NLcalibFactors {}
std::array< float, 2 >	m_NLcalibModuleSum {}
std::array< float, 2 >	m_NLcalibModuleSumErrSq {}
std::array< float, 2 >	m_NLcalibModSumBkgdFrac {}
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 23 of file ZDCDataAnalyzer.h.

Member Typedef Documentation

◆ JSON

using ZDCDataAnalyzer::JSON = ZDCJSONConfig::JSON

Definition at line 30 of file ZDCDataAnalyzer.h.

◆ ZDCModuleBoolArray

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

Definition at line 27 of file ZDCDataAnalyzer.h.

◆ ZDCModuleFloatArray

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

Definition at line 26 of file ZDCDataAnalyzer.h.

◆ ZDCModuleIntArray

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

Definition at line 28 of file ZDCDataAnalyzer.h.

Constructor & Destructor Documentation

◆ ZDCDataAnalyzer() [1/2]

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

Definition at line 21 of file ZDCDataAnalyzer.cxx.

                                                      :
  m_msgFunc_p(std::move(msgFunc_p))
{
  m_moduleEnabled[0] = {{true, true, true, true}};
  m_moduleEnabled[1] = {{true, true, true, true}};
 
  m_moduleAnalyzers[0] = {{0, 0, 0, 0}};
  m_moduleAnalyzers[1] = {{0, 0, 0, 0}};
 
  m_calibAmplitude[0] = {{0, 0, 0, 0}};
  m_calibAmplitude[1] = {{0, 0, 0, 0}};
 
  m_calibTime[0] = {{0, 0, 0, 0}};
  m_calibTime[1] = {{0, 0, 0, 0}};
 
  m_dataLoaded[0] = {{false, false, false, false}};
  m_dataLoaded[1] = {{false, false, false, false}};
 
  m_delayedOrder[0] = {0, 0, 0, 0};
  m_delayedOrder[1] = {0, 0, 0, 0};
 
  // For now we are using hard-coded gain factors and pedestals
  //
  m_HGGains[0] = {{10, 10, 10, 10}};
  m_HGGains[1] = {{10, 10, 10, 10}};
 
  m_pedestals[0] = {{100, 100, 100, 100}};
  m_pedestals[1] = {{100, 100, 100, 100}};
  
  // Construct the per-module pulse analyzers
  //
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      std::string moduleTag= "_s" + std::to_string(side) + "_m" +std::to_string(module);
      m_moduleAnalyzers[side][module] = make_unique<ZDCPulseAnalyzer>(m_msgFunc_p, std::move(moduleTag), nSample, deltaTSample, preSampleIdx,
                                      m_pedestals[side][module], fitFunction,
                                      peak2ndDerivMinSamples[side][module],
                                      peak2ndDerivMinThresholdsHG[side][module],
                                      peak2ndDerivMinThresholdsLG[side][module]);
      m_moduleAnalyzers[side][module]->setLGMode(LGMode);
    }
  }
}

◆ ZDCDataAnalyzer() [2/2]

ZDCDataAnalyzer::ZDCDataAnalyzer	(	ZDCMsg::MessageFunctionPtr	messageFunc_p,
		const JSON &	configJSON )

Definition at line 69 of file ZDCDataAnalyzer.cxx.

                                                                                           :
  m_msgFunc_p(msgFunc_p)
{
  init();
  
  // Construct the object that will extract the data and pulse analyzer
  //   configurations from the input JSON configuration
  //
  //  For the data anlyzer we use 1 channel since the relevant
  //    configurations will all be per-side
  //
  m_dataAnalyzerConfig = std::make_unique<ZDCJSONConfig>(std::vector<std::string>{"C", "A"}, 1);
  m_pulseAnalyzerConfig = std::make_unique<ZDCJSONConfig>(std::vector<std::string>{"C", "A"}, 4);
 
 
  // Extract the JSON object for the pulse analyzer(s)
  //
  JSON DAconfig = configJSON["DataAnalyzer"];
  if (DAconfig.is_null()) {
    (*m_msgFunc_p)(ZDCMsg::Fatal, "JSON configuration object for ZDCDataAnalyzer not found");
    return;
  }
  
  auto [result, resultStr] = m_dataAnalyzerConfig->ParseConfig(DAconfig, ZDCDataAnalyzer::JSONConfigParams);
  if (!result) {
    (*m_msgFunc_p)(ZDCMsg::Fatal, "Error parsing ZDCDataAnalyzer JSON config, error = " + resultStr);
    return;
  }
  
  // The data analyzer configuration is simple enough we handle it inline
  //
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleEnabled[side][module] = true;
    }
 
    // Now extract information from ZDCDataAnalyzer-specific configuration
    //
    JSON sideConfig = m_dataAnalyzerConfig->getChannelConfig(side, 0);
    JSON modEnable = sideConfig["moduleEnabled"];
    JSON delayedOrder = sideConfig["delayedOrder"];
    JSON iterativeCalibCorr = sideConfig["iterativeCalibCorr"];
      
    if (!modEnable.is_null()) {
      if (modEnable.size() != 4) {
    (*m_msgFunc_p)(ZDCMsg::Fatal, "Error parsing ZDCDataAnalyzer JSON config, incorrect size of moduleEnabled");
    return;
      }
      
      for (size_t module : {0, 1, 2, 3}) {
    m_moduleEnabled[side][module] = modEnable[module];
      }
    }
    if (!delayedOrder.is_null()) {
      if (delayedOrder.size() != 4) {
    (*m_msgFunc_p)(ZDCMsg::Fatal, "Error parsing ZDCDataAnalyzer JSON config, incorrect size of delayedOrder");
    return;
      }
      
      for (size_t module : {0, 1, 2, 3}) {
      m_delayedOrder[side][module] = delayedOrder[module];
      }
    }
 
  
    // Check for JSON entries for iterative NL correction
    if (!iterativeCalibCorr.is_null()) {
 
 
  for (const auto & modIterCalibCorr : iterativeCalibCorr) {
    if (modIterCalibCorr.size() != 3) {
      (*m_msgFunc_p)(ZDCMsg::Fatal, "Error parsing ZDCDataAnalyzer JSON config, incorrect size of iterativeCalibCorr entry " +  modIterCalibCorr.dump());
      return;
    }
 
    unsigned int module = modIterCalibCorr[0];
    float refFrac = modIterCalibCorr[1];
  JSON coeffArray = modIterCalibCorr[2];
 
    std::vector<float> polyCoeff;
    for (auto elem : coeffArray) {
      polyCoeff.push_back(elem);
    }
 
    (*m_msgFunc_p)(ZDCMsg::Debug, "Iterative correction using module " + std::to_string(module) + " with reference energy fraction " + std::to_string(refFrac) + " and polynomial with " + std::to_string(polyCoeff.size()) + " terms");
 
    
    m_iterCalibCorr[side].push_back(std::make_tuple(module, refFrac, polyCoeff));
      }
    }   
 
  m_haveIterCalibCorr= true;
  }
 
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
 
      (*m_msgFunc_p)(
          ZDCMsg::Info,
          "Setting up ZDCPulseAnalyzer for side " + std::to_string(side) +
              ", module " + std::to_string(module) +
              ", enabled = " + std::to_string(m_moduleEnabled[side][module]) +
              ", delayedOrder = " +
              std::to_string(m_delayedOrder[side][module]));
    }
  }
 
  
 
  // Extract the JSON object for the pulse analyzer(s)
  //
  JSON PAconfig = configJSON["PulseAnalyzer"];
  if (PAconfig.is_null()) {
    (*m_msgFunc_p)(ZDCMsg::Fatal, "JSON configuration object for ZDCPulseAnalyzer not found");
    return;
  }
 
  // Do the parsing of the pulse analyzer JSON configuration
  //
  auto [result2, resultStr2] = m_pulseAnalyzerConfig->ParseConfig(PAconfig, ZDCPulseAnalyzer::JSONConfigParams);
  if (!result2) {
    (*m_msgFunc_p)(ZDCMsg::Fatal, "Error parsing ZDCPulseAnalyzer JSON config, error = " + resultStr2);
    return;
  }
 
  // Now set up each of the pulse analyzers
  //
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      
      (*m_msgFunc_p)(ZDCMsg::Info, "Setting up ZDCPulseAnalyzer for side " + std::to_string(side) +
             ", module " + std::to_string(module));
 
      //
      // Get the parsed configuration JSON object for this module
      //
      JSON moduleConfig = m_pulseAnalyzerConfig->getChannelConfig(side, module);
      
      std::ostringstream ostr;
      ostr << "JSON configuration for ZDC pulse analyyzer for side " << std::to_string(side)
       << ", module " <<  std::to_string(module) << "\n" <<  moduleConfig.dump(2);
      (*m_msgFunc_p)(ZDCMsg::Verbose, ostr.str());
 
      // Construct the ZDCPulseAnalyzer object
      //
      m_moduleAnalyzers[side][module] = std::make_unique<ZDCPulseAnalyzer>(msgFunc_p, moduleConfig);
 
      (*m_msgFunc_p)(ZDCMsg::Info, "Finished constructing ZDCPulseAnalyzer for side " + std::to_string(side) +
             ", module " + std::to_string(module));
 
    }
  }
 
  // Check for the enabling of re-pass
  //
  getPulseAnalyzerGlobalPar("enableRepass", m_repassEnabled);
  
  (*m_msgFunc_p)(ZDCMsg::Info, "ZDCDataAnalyzer construction complete");
}

◆ ~ZDCDataAnalyzer()

ZDCDataAnalyzer::~ZDCDataAnalyzer ( )

inline

Definition at line 111 of file ZDCDataAnalyzer.h.

111{};

Member Function Documentation

◆ disableFADCCorrections()

void ZDCDataAnalyzer::disableFADCCorrections ( )

Definition at line 594 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->disableFADCCorrections();
    }
  }
}

◆ disableModule()

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

Definition at line 266 of file ZDCDataAnalyzer.cxx.

{
  if (side < 2 && module < 4) {
    //
    // Can't disable in the middle of analysis
    //
    if (m_dataLoaded[side][module]) return false;
    else {
      m_moduleEnabled[side][module] = false;
      return true;
    }
  }
  else {
    return false;
  }
}

◆ DoNLcalibModuleSum()

void ZDCDataAnalyzer::DoNLcalibModuleSum ( )

Definition at line 870 of file ZDCDataAnalyzer.cxx.

{
  if (!m_haveIterCalibCorr) return;
 
  
  //loop over both sides; first index in m_iterCalibcorr
  for (int iside:{0,1}){
 
    // If the module mask is empty for this side, there's nothing to do
    if ((m_moduleMask>>(4*iside)&0xf) == 0) continue;
      
    if (m_calibModuleSum[iside]>0.){ //it's theoretically possible that: one or more modules fired → module mask is nonzero → mask check passes
                                    //but their calibrated amplitudes are so small they sum to essentially zero
 
      //use uncorrected energy first and update in each iteration of the loop over module tuples
      float totalmoduleE= m_calibModuleSum[iside];
 
      //loop over module tuples
      for (auto modtuple : m_iterCalibCorr[iside]){
        //get and unpack tuple
        unsigned int modnum = std::get<0>(modtuple);
        float ftyp = std::get<1>(modtuple);
        std::vector<float>  polyCoeffs = std::get<2>(modtuple);
 
        //calculate energy fraction using current total energy
        float f= m_calibAmplitude[iside][modnum]/totalmoduleE;
 
        //calculate energy correction
        float CorrFact = 0;
        for (size_t i=0;i<polyCoeffs.size(); i++){    
              CorrFact += std::pow(f -ftyp,i)*polyCoeffs[i];
            }
        
        //check that CorrFact !=0 so we don't divide by 0 [[unlikely]
         if (CorrFact == 0.){
           (*m_msgFunc_p)(ZDCMsg::Error,"ZDCDataAnalyzer::DoNLcalibModuleSum:  Denominator is zero");
           return;
         }
 
        //apply energy correction
        totalmoduleE= totalmoduleE/CorrFact;
      }
      
      //m_calibModuleSum[iside] = totalmoduleE;
        m_NLcalibModuleSum[iside] = totalmoduleE;
        m_NLcalibModuleSumErrSq[iside] = 0.; // no error for now
      }
 
    else{
        (*m_msgFunc_p)(ZDCMsg::Info,"SUM = 0!!");
        m_NLcalibModuleSum[iside] = 0.;
        m_NLcalibModuleSumErrSq[iside] = 0.; // no error for now
      }
  }
 
}

◆ enableDelayed() [1/2]

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

Definition at line 304 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      if (delayDeltaTArray[side][module] < 0) m_delayedOrder[side][module] = -1;
      else m_delayedOrder[side][module] = 1;
 
      (*m_msgFunc_p)(ZDCMsg::Verbose, "Enabling use of delayed samples on side, module = " + std::to_string(side) + ", " +
                     std::to_string(module) + ", delta t = " + std::to_string(delayDeltaTArray[side][module]));
 
      m_moduleAnalyzers[side][module]->enableDelayed(std::abs(delayDeltaTArray[side][module]), undelayedDelayedPedestalDiff[side][module]);
    }
  }
}

◆ enableDelayed() [2/2]

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

Definition at line 293 of file ZDCDataAnalyzer.cxx.

{
  int delayedOrder = deltaT < 0 ? -1 : 1;
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_delayedOrder[side][module] = delayedOrder;
      m_moduleAnalyzers[side][module]->enableDelayed(std::abs(deltaT), undelayedDelayedPedestalDiff[side][module]);
    }
  }
}

◆ enableFADCCorrections()

void ZDCDataAnalyzer::enableFADCCorrections	(	bool	correctPerSample,
		std::array< std::array< std::unique_ptr< const TH1 >, 4 >, 2 > &	correHistHG,
		std::array< std::array< std::unique_ptr< const TH1 >, 4 >, 2 > &	correHistLG )

Definition at line 578 of file ZDCDataAnalyzer.cxx.

{
  if (correctPerSample)
    (*m_msgFunc_p)(ZDCMsg::Info, "ZDCDataAnalyzer::enabling FADC Corrections per sample");
  else
    (*m_msgFunc_p)(ZDCMsg::Info, "ZDCDataAnalyzer::enabling FADC Corrections per amplitude");
    
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->enableFADCCorrections(correctPerSample, corrHistHG[side][module], corrHistLG[side][module]);
    }
  }
}

◆ enablePostExclusion() [1/2]

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

Definition at line 337 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->enablePostExclusion(maxSamplesExcl, HGADCThresh[side][module], LGADCThresh[side][module]);
    }
  }
}

◆ enablePostExclusion() [2/2]

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

Definition at line 346 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->enablePostExclusion(maxSamplesExcl, HGADCThresh, LGADCThresh);
    }
  }
}

◆ enablePostPulseCheck()

void ZDCDataAnalyzer::enablePostPulseCheck	(	unsigned int	postPulseSampleDelta,
		float	postPulseDerivMinSig,
		float	postPulseAbsDer2ndMinSig,
		float	minMainDer2ndRatio )

Definition at line 530 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->enablePostPulseCheck(postPulseSampleDelta, postPulseDerivMinSig, postPulseAbsDer2ndMinSig, minMainDer2ndRatio);
    }
  }
}

◆ enablePreExclusion() [1/2]

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

Definition at line 319 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->enablePreExclusion(maxSamplesExcl, HGADCThresh[side][module], LGADCThresh[side][module]);
    }
  }
}

◆ enablePreExclusion() [2/2]

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

Definition at line 328 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->enablePreExclusion(maxSamplesExcl, HGADCThresh, LGADCThresh);
    }
  }
}

◆ enableRepass()

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

Definition at line 356 of file ZDCDataAnalyzer.cxx.

{
  m_repassEnabled = true;
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->enableRepass(peak2ndDerivMinRepassHG[side][module], peak2ndDerivMinRepassLG[side][module]);
    }
  }
}

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

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->enableTimeSigCut(AND, sigCut, TF1String, parsHGArr[side][module], parsLGArr[side][module]);
    }
  }
}

◆ FinishEvent()

bool ZDCDataAnalyzer::FinishEvent ( )

Definition at line 764 of file ZDCDataAnalyzer.cxx.

{
  // First make sure that all data is loaded. while we're at it, count how many modules on each side have a pulse
  //
  unsigned int sideNPulsesMod[2] = {0, 0};
 
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      if (!m_dataLoaded[side][module] && m_moduleEnabled[side][module]) {return false;}
      if (m_moduleAnalyzers[side][module]->armSumInclude()) {sideNPulsesMod[side]++;}
    }
  }
 
  // Are we doing a repass? If so, reanalyze modules for which no pulse was found the first time
  //   as long as we have one module with a pulse on the given side
  //
  if (m_repassEnabled) {
    for (size_t side : {0, 1}) {
      if (sideNPulsesMod[side] == 0) continue;
 
      for (size_t module : {0, 1, 2, 3}) {
    if (!m_moduleEnabled[side][module]) continue;
 
        ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
 
        // If this module had no pulse the first time, reanalyze it (with a lower 2nd derivative threshold)
        //
        if (!pulseAna_p->havePulse()) {
          (*m_msgFunc_p)(ZDCMsg::Debug, ("ZDCPulseAnalyzer:: performing a repass on data for side, module = " + std::to_string(side) + ", " + std::to_string(module)));
          pulseAna_p->ReanalyzeData();
      m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
        }
      }
    }
  }
 
  // Now sum up amplitudes etc
  //
  for (size_t side : {0, 1}) {
    float tempFraction = 1.0;
    double sumAmpTimesBkgdFrac = 0.0;
    double sumCalibAmpTimesBkgdFrac = 0.0;
      
    for (size_t module : {0, 1, 2, 3}) {
      ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
 
      if (pulseAna_p->armSumInclude()) {
        int moduleMaskBit = 4 * side + module;
        m_moduleMask |= 1 << moduleMaskBit;
 
        float amplitude = pulseAna_p->GetAmplitude();
        float ampError = pulseAna_p->GetAmpError();
        float bkgdFraction = pulseAna_p->GetBkgdMaxFraction();
 
        m_calibAmplitude[side][module] = amplitude * m_currentECalibCoeff[side][module];
 
        float calibAmpError = ampError * m_currentECalibCoeff[side][module];
 
        float timeCalib = pulseAna_p->GetT0Corr();
        if (pulseAna_p->useLowGain()) {timeCalib -= m_currentT0OffsetsLG[side][module];}
        else {timeCalib -= m_currentT0OffsetsHG[side][module];}
 
        m_calibTime[side][module] = timeCalib;
 
        m_moduleSum[side] += amplitude;
        m_moduleSumErrSq[side] += ampError * ampError;
    sumAmpTimesBkgdFrac += amplitude*bkgdFraction;
 
        m_moduleSumPreSample[side] += pulseAna_p->GetPreSampleAmp();
 
        m_calibModuleSum[side] += m_calibAmplitude[side][module];
        m_calibModuleSumErrSq[side] += calibAmpError * calibAmpError;
 
        m_averageTime[side] += m_calibTime[side][module] * m_calibAmplitude[side][module];
    sumCalibAmpTimesBkgdFrac += amplitude*bkgdFraction;
      }
 
      // subtract the fraction of LGOverflow events if we have fraction available (<0 means unavailable)
      if (pulseAna_p->LGOverflow() && m_moduleAmpFractionLG[side][module] > 0) {tempFraction -= m_moduleAmpFractionLG[side][module];}
    }
 
    {
      CXXUTILS_TRAPPING_FP;
      if (m_moduleSum[side] > 0) m_moduleSumBkgdFrac[side] = sumAmpTimesBkgdFrac/m_moduleSum[side];
      else m_moduleSumBkgdFrac[side] = 0;
    }
    
    if (m_calibModuleSum[side] > 1e-6) {
      m_averageTime[side] /= m_calibModuleSum[side];
      m_calibModSumBkgdFrac[side] = sumCalibAmpTimesBkgdFrac/m_calibModuleSum[side];
    }
    else {
      m_averageTime[side] = 0;
      m_calibModSumBkgdFrac[side] = 0;
    }
    
    if (tempFraction < 1.0) {m_moduleSum[side] /= tempFraction;}
  }
  
  DoNLcalibModuleSum();
  
  m_eventCount++;
  return true;
}

◆ GetAverageTime()

float ZDCDataAnalyzer::GetAverageTime ( size_t side ) const

inline

Definition at line 158 of file ZDCDataAnalyzer.h.

158{return m_averageTime.at(side);}

◆ GetCalibModuleSum()

float ZDCDataAnalyzer::GetCalibModuleSum ( size_t side ) const

inline

Definition at line 148 of file ZDCDataAnalyzer.h.

148{return m_calibModuleSum.at(side);}

◆ GetCalibModuleSumErr()

float ZDCDataAnalyzer::GetCalibModuleSumErr ( size_t side ) const

inline

Definition at line 149 of file ZDCDataAnalyzer.h.

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

◆ GetdelayedBS()

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

inline

Definition at line 169 of file ZDCDataAnalyzer.h.

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

◆ GetModuleAmplitude()

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

inline

Definition at line 161 of file ZDCDataAnalyzer.h.

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

◆ GetModuleCalibAmplitude()

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

inline

Definition at line 165 of file ZDCDataAnalyzer.h.

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

◆ GetModuleCalibTime()

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

inline

Definition at line 166 of file ZDCDataAnalyzer.h.

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

◆ GetModuleChisq()

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

inline

Definition at line 163 of file ZDCDataAnalyzer.h.

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

◆ GetModuleMask()

unsigned int ZDCDataAnalyzer::GetModuleMask ( ) const

inline

Definition at line 141 of file ZDCDataAnalyzer.h.

141{return m_moduleMask;}

◆ GetModuleStatus()

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

inline

Definition at line 167 of file ZDCDataAnalyzer.h.

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

◆ GetModuleSum()

float ZDCDataAnalyzer::GetModuleSum ( size_t side ) const

inline

Definition at line 143 of file ZDCDataAnalyzer.h.

143{return m_moduleSum.at(side);}

◆ GetModuleSumErr()

float ZDCDataAnalyzer::GetModuleSumErr ( size_t side ) const

inline

Definition at line 144 of file ZDCDataAnalyzer.h.

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

◆ GetModuleSumPreSample()

float ZDCDataAnalyzer::GetModuleSumPreSample ( size_t side ) const

inline

Definition at line 156 of file ZDCDataAnalyzer.h.

156{return m_moduleSumPreSample.at(side);}

◆ GetModuleTime()

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

inline

Definition at line 162 of file ZDCDataAnalyzer.h.

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

◆ GetNLcalibModuleSum()

float ZDCDataAnalyzer::GetNLcalibModuleSum ( size_t side ) const

inline

Definition at line 153 of file ZDCDataAnalyzer.h.

153{return m_NLcalibModuleSum.at(side);}

◆ GetNLcalibModuleSumErr()

float ZDCDataAnalyzer::GetNLcalibModuleSumErr ( size_t side ) const

inline

Definition at line 154 of file ZDCDataAnalyzer.h.

154{return std::sqrt(m_NLcalibModuleSumErrSq.at(side));}

◆ GetPulseAnalyzer() [1/2]

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

inline

Definition at line 172 of file ZDCDataAnalyzer.h.

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

◆ GetPulseAnalyzer() [2/2]

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

inline

Definition at line 171 of file ZDCDataAnalyzer.h.

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

◆ getPulseAnalyzerGlobalPar()

template<typename T>

bool ZDCDataAnalyzer::getPulseAnalyzerGlobalPar	(	const std::string &	key,
		T &	value )

inline

Definition at line 113 of file ZDCDataAnalyzer.h.

                                                                                      {
    if (m_pulseAnalyzerConfig.get()) return m_pulseAnalyzerConfig->getGlobalParam(key, value);
    else return false;
  }

◆ GetSideBkgdFrac()

float ZDCDataAnalyzer::GetSideBkgdFrac ( size_t side ) const

inline

Definition at line 145 of file ZDCDataAnalyzer.h.

145{return m_moduleSumBkgdFrac.at(side);}

◆ GetSideCalibBkgdFrac()

float ZDCDataAnalyzer::GetSideCalibBkgdFrac ( size_t side ) const

inline

Definition at line 150 of file ZDCDataAnalyzer.h.

150{return m_calibModSumBkgdFrac.at(side);}

◆ init()

void ZDCDataAnalyzer::init ( )

private

Definition at line 229 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    m_moduleSum[side] = 0;
    m_moduleSumErrSq[side] = 0;
    m_moduleSumPreSample[side] = 0;
    m_calibModuleSum[side] = 0;
    m_calibModuleSumErrSq[side] = 0;
 
    m_NLcalibModuleSum[side] = 0;
    m_NLcalibModuleSumErrSq[side] = 0;
    m_averageTime[side] = 0;
    m_fail[side] = 0;
 
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleEnabled[side][module] = true;
      m_calibAmplitude[side][module] = 0;
      m_calibTime[side][module] = 0;
 
      m_dataLoaded[side][module] = false;
      m_delayedOrder[side][module] = 0;
 
      // Default "calibrations"
      //
      m_currentECalibCoeff[side][module] = 1;
      m_currentT0OffsetsHG[side][module] = 0;
      m_currentT0OffsetsLG[side][module] = 0;
 
    }
  }
 
  m_NLcalibFactors = {{
      {{ {{0,0,0,0,0,0}},{{0,0,0,0,0,0}},{{0,0,0,0,0,0}} }},
      {{ {{0,0,0,0,0,0}},{{0,0,0,0,0,0}},{{0,0,0,0,0,0}} }}  }};
 
}

◆ invokeAll()

template<typename T>

void ZDCDataAnalyzer::invokeAll ( T functor )

inline

Definition at line 118 of file ZDCDataAnalyzer.h.

  {
    for (size_t side : {0, 1}) {
      for (size_t module : {0, 1, 2, 3}) {
    functor(m_moduleAnalyzers[side][module].get());
      }
    }
  }

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

{
 
  // We immediately return if this module is disabled
  //
  if (!m_moduleEnabled[side][module]) {
    (*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)));
 
    return;
  }
 
  (*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)));
 
  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
  pulseAna_p->LoadAndAnalyzeData(HGSamples, LGSamples);
  m_dataLoaded[side][module] = true;
 
  if (pulseAna_p->failed()) {
    (*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)));
 
    m_fail[side] = true;
  }
 
  m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
}

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

{
  // We immediately return if this module is disabled
  //
  if (!m_moduleEnabled[side][module]) {
    (*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)));
 
    return;
  }
 
  if (m_delayedOrder[side][module] == 0) {
    (*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)));
    return;
  }
 
  (*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)));
 
  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
  if (m_delayedOrder[side][module] > 0) {
    pulseAna_p->LoadAndAnalyzeData(HGSamples, LGSamples, HGSamplesDelayed, LGSamplesDelayed);
  }
  else {
    pulseAna_p->LoadAndAnalyzeData(HGSamplesDelayed, LGSamplesDelayed, HGSamples, LGSamples);
  }
  m_dataLoaded[side][module] = true;
 
  if (pulseAna_p->failed()) {
    (*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)));
 
    m_fail[side] = true;
  }
 
  m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
}

◆ LoadEnergyCalibrations()

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

inline

Definition at line 241 of file ZDCDataAnalyzer.h.

  {
    (*m_msgFunc_p)(ZDCMsg::Verbose, "Loading energy calibrations");
 
    m_LBDepEcalibSplines = std::move (calibSplines);
    m_haveECalib = true;
  }

◆ 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 249 of file ZDCDataAnalyzer.h.

  {
    (*m_msgFunc_p)(ZDCMsg::Verbose, "Loading timing calibrations");
 
    m_T0HGOffsetSplines = std::move (T0HGOffsetSplines);
    m_T0LGOffsetSplines = std::move (T0LGOffsetSplines);
 
    m_haveT0Calib = true;
  }

◆ ModuleDisabled()

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

inline

Definition at line 138 of file ZDCDataAnalyzer.h.

138{return !m_moduleEnabled[side][module];}

◆ moduleEnabled()

bool ZDCDataAnalyzer::moduleEnabled	(	unsigned int	side,
		unsigned int	module ) const

inline

Definition at line 139 of file ZDCDataAnalyzer.h.

139{return m_moduleEnabled[side][module];}

◆ saveFitFunc()

void ZDCDataAnalyzer::saveFitFunc ( bool save )

Definition at line 283 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->saveFitFunc(save);
    }
  }
}

◆ set2ndDerivStep()

void ZDCDataAnalyzer::set2ndDerivStep ( size_t step )

Definition at line 375 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->set2ndDerivStep(step);
    }
  }
}

◆ SetADCOverUnderflowValues()

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

Definition at line 481 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetADCOverUnderflowValues(HGOverflowADC[side][module], HGUnderflowADC[side][module], LGOverflowADC[side][module]);
    }
  }
}

◆ SetChisqCuts()

void ZDCDataAnalyzer::SetChisqCuts	(	const ZDCModuleFloatArray &	chisqDivAmpCutHG,
		const ZDCModuleFloatArray &	chisqDivAmpScaleHG,
		const ZDCModuleFloatArray &	chisqDivAmpOffsetHG,
		const ZDCModuleFloatArray &	chisqDivAmpPowerHG,
		const ZDCModuleFloatArray &	chisqDivAmpCutLG,
		const ZDCModuleFloatArray &	chisqDivAmpScaleLG,
		const ZDCModuleFloatArray &	chisqDivAmpOffsetLG,
		const ZDCModuleFloatArray &	chisqDivAmpPowerLG )

Definition at line 515 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetChisqCuts(chisqDivAmpCutHG[side][module], chisqDivAmpScaleHG[side][module],
                            chisqDivAmpOffsetHG[side][module], chisqDivAmpPowerHG[side][module],
                            chisqDivAmpCutLG[side][module], chisqDivAmpScaleLG[side][module],
                            chisqDivAmpOffsetLG[side][module], chisqDivAmpPowerLG[side][module]);
    }
  }
}

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

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetCutValues(chisqDivAmpCutHG[side][module], chisqDivAmpCutLG[side][module],
          deltaT0MinHG[side][module], deltaT0MaxHG[side][module],
          deltaT0MinLG[side][module], deltaT0MaxLG[side][module]);
    }
  }
}

◆ SetFitMinMaxAmpValues() [1/2]

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

Definition at line 460 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetFitMinMaxAmp(minAmpHG[side][module], minAmpLG[side][module],
          maxAmpHG[side][module], maxAmpLG[side][module]);
 
    }
  }
}

◆ SetFitMinMaxAmpValues() [2/2]

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

Definition at line 472 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetFitMinMaxAmp(minHG, minLG, maxHG, maxLG);
    }
  }
}

◆ SetFitTimeMax()

void ZDCDataAnalyzer::SetFitTimeMax ( float tmax )

Definition at line 411 of file ZDCDataAnalyzer.cxx.

                                              {
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetFitTimeMax(tmax);
    }
  }
}

◆ SetGainFactorsHGLG() [1/2]

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

Definition at line 393 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetGainFactorsHGLG(gainFactorsHG[side][module], gainFactorsLG[side][module]);
    }
  }
}

◆ SetGainFactorsHGLG() [2/2]

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

Definition at line 384 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetGainFactorsHGLG(gainFactorHG, gainFactorLG);
    }
  }
}

◆ setMinimumSignificance()

void ZDCDataAnalyzer::setMinimumSignificance	(	float	sigMinHG,
		float	sigMinLG )

Definition at line 366 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->setMinimumSignificance(sigMinHG, sigMinLG);
    }
  }
}

◆ SetModuleAmpFractionLG()

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

Definition at line 452 of file ZDCDataAnalyzer.cxx.

                                                                                                          {
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAmpFractionLG[side][module] = moduleAmpFractionLG[side][module];
    }
  }
}

◆ SetNLcalibParams()

void ZDCDataAnalyzer::SetNLcalibParams ( std::array< std::array< std::vector< float >, 3 >, 2 > & nlcalibParams )

Definition at line 566 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side: {0,1})
    {
      for (size_t module: {0,1,2})
    {
      m_NLcalibFactors[side][module] = nlcalibParams[side][module];
    }
    }
  m_haveNLcalib = true;
}

◆ SetNoiseSigmas()

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

Definition at line 433 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetNoiseSigmas(noiseSigmasHG[side][module], noiseSigmasLG[side][module]);
    }
  }
}

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

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetNonlinCorrParams(refADC, refScale,
                               HGNonlinCorrParams[side][module],
                               LGNonlinCorrParams[side][module]);
    }
  }
}

◆ SetPeak2ndDerivMinTolerances()

void ZDCDataAnalyzer::SetPeak2ndDerivMinTolerances ( size_t tolerance )

Definition at line 402 of file ZDCDataAnalyzer.cxx.

                                                                   {
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetPeak2ndDerivMinTolerance(tolerance);
    }
  }
}

◆ setPerSampleNoiseSigmas()

void ZDCDataAnalyzer::setPerSampleNoiseSigmas	(	const std::array< std::array< std::vector< float >, 4 >, 2 > &	sampleNoiseVecsHG,
		const std::array< std::array< std::vector< float >, 4 >, 2 > &	sampleNoiseVecsLG )

Definition at line 442 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->setPerSampleNoiseSigmas(sampleNoiseVecsHG[side][module], sampleNoiseVecsLG[side][module]);
    }
  }
}

◆ setQuietFits()

void ZDCDataAnalyzer::setQuietFits ( bool quiet )

inline

Definition at line 271 of file ZDCDataAnalyzer.h.

                                {
    if (quiet) invokeAll([](ZDCPulseAnalyzer* pa){pa->setQuietFits();});
    else invokeAll([](ZDCPulseAnalyzer* pa){pa->setUnquietFits();});
  }

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

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetTauT0Values(fixTau1[side][module], fixTau2[side][module],
          tau1[side][module], tau2[side][module], t0HG[side][module], t0LG[side][module]);
    }
  }
}

◆ SetTimeCuts()

void ZDCDataAnalyzer::SetTimeCuts	(	const ZDCModuleFloatArray &	deltaT0MinHG,
		const ZDCModuleFloatArray &	deltaT0MaxHG,
		const ZDCModuleFloatArray &	deltaT0MinLG,
		const ZDCModuleFloatArray &	deltaT0MaxLG )

Definition at line 504 of file ZDCDataAnalyzer.cxx.

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetTimeCuts(deltaT0MinHG[side][module], deltaT0MaxHG[side][module],
                           deltaT0MinLG[side][module], deltaT0MaxLG[side][module]);
    }
  }
}

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

{
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_moduleAnalyzers[side][module]->SetTimingCorrParams(mode, refADC, refScale,
                               HGParamArr.at(side).at(module), LGParamArr.at(side).at(module));
    }
  }
 
}

◆ SideFailed()

bool ZDCDataAnalyzer::SideFailed ( size_t side ) const

inline

Definition at line 159 of file ZDCDataAnalyzer.h.

159{return m_fail.at(side);}

◆ StartEvent()

void ZDCDataAnalyzer::StartEvent ( int lumiBlock )

Definition at line 614 of file ZDCDataAnalyzer.cxx.

{
  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Starting new event, event index = " + std::to_string(m_eventCount)));
  
  //  See if we have to load up new calibrations
  //
  if (lumiBlock != m_currentLB) {
    (*m_msgFunc_p)(ZDCMsg::Verbose,  ("Starting new luminosity block " + std::to_string(lumiBlock)));
 
    if (m_haveECalib) {
      (*m_msgFunc_p)(ZDCMsg::Verbose, ("Loading energy calibrations for event " + std::to_string(m_eventCount) + ", lumi block " +
                                       std::to_string(lumiBlock)));
 
      for (size_t side : {0, 1}) {
        for (size_t module : {0, 1, 2, 3}) {
          float splineLBMin = m_LBDepEcalibSplines[side][module]->GetXmin();
          float splineLBMax = m_LBDepEcalibSplines[side][module]->GetXmax();
 
          if (lumiBlock >= splineLBMin && lumiBlock <= splineLBMax) {
            m_currentECalibCoeff[side][module] = m_LBDepEcalibSplines[side][module]->Eval(lumiBlock);
          }
          else if (lumiBlock < splineLBMin) {
            m_currentECalibCoeff[side][module] = m_LBDepEcalibSplines[side][module]->Eval(splineLBMin);
          }
          else {
            m_currentECalibCoeff[side][module] = m_LBDepEcalibSplines[side][module]->Eval(splineLBMax);
          }
        }
      }
    } // end of if (_haveEcalib) {
 
    if (m_haveT0Calib) {
      (*m_msgFunc_p)(ZDCMsg::Verbose, ("Loading timing calibrations for event " + std::to_string(m_eventCount) + ", lumi block " + std::to_string(lumiBlock)));
 
      for (size_t side : {0, 1}) {
        for (size_t module : {0, 1, 2, 3}) {
          float splineLBMin = m_T0HGOffsetSplines[side][module]->GetXmin();
          float splineLBMax = m_T0HGOffsetSplines[side][module]->GetXmax();
 
          if (lumiBlock >= splineLBMin && lumiBlock <= splineLBMax) {
            m_currentT0OffsetsHG[side][module] = m_T0HGOffsetSplines[side][module]->Eval(lumiBlock);
            m_currentT0OffsetsLG[side][module] = m_T0LGOffsetSplines[side][module]->Eval(lumiBlock);
          }
          else if (lumiBlock < splineLBMin) {
            m_currentT0OffsetsHG[side][module] = m_T0HGOffsetSplines[side][module]->Eval(splineLBMin);
            m_currentT0OffsetsLG[side][module] = m_T0LGOffsetSplines[side][module]->Eval(splineLBMin);
          }
          else {
            m_currentT0OffsetsHG[side][module] = m_T0HGOffsetSplines[side][module]->Eval(splineLBMax);
            m_currentT0OffsetsLG[side][module] = m_T0LGOffsetSplines[side][module]->Eval(splineLBMax);
          }
        }
      }
    } // end of if (m_haveT0Calib)
  }
 
  // Initialize transient results
  //
  for (size_t side : {0, 1}) {
    for (size_t module : {0, 1, 2, 3}) {
      m_dataLoaded[side][module] = false;
      m_moduleStatus[side][module] = 0;
      m_calibAmplitude[side][module] = 0;
      m_calibTime[side][module] = 0;
      //      _moduleFail[side][module] = false;
    }
 
    m_moduleSum[side] = 0;
    m_moduleSumErrSq[side] = 0;
    m_moduleSumPreSample[side] = 0;
    m_moduleSumBkgdFrac[side] = 0;
 
    m_calibModuleSum[side] = 0;
    m_calibModuleSumErrSq[side] = 0;
    m_calibModSumBkgdFrac[side] = 0;
 
    m_NLcalibModuleSum[side] = 0;
    m_NLcalibModuleSumErrSq[side] = 0;
    m_NLcalibModSumBkgdFrac[side] = 0;
    
    m_averageTime[side] = 0;
    m_fail[side] = false;
  }
 
  m_moduleMask = 0;
  m_currentLB = lumiBlock;
}

Member Data Documentation

◆ JSONConfigParams

const ZDCJSONConfig::JSONParamList ZDCDataAnalyzer::JSONConfigParams

static

Initial value:

                                                                     = {
  {"moduleEnabled", {JSON::value_t::array, 4, true, false}},
  {"iterativeCalibCorr", {JSON::value_t::array, 4, true, false}},
  {"delayedOrder", {JSON::value_t::array, 4, true, false}}
}

Definition at line 14 of file ZDCDataAnalyzer.h.

◆ m_averageTime

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

private

Definition at line 93 of file ZDCDataAnalyzer.h.

93{};

◆ m_calibAmplitude

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

private

Definition at line 74 of file ZDCDataAnalyzer.h.

74{};

◆ m_calibModSumBkgdFrac

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

private

Definition at line 84 of file ZDCDataAnalyzer.h.

84{};

◆ m_calibModuleSum

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

private

Definition at line 82 of file ZDCDataAnalyzer.h.

82{};

◆ m_calibModuleSumErrSq

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

private

Definition at line 83 of file ZDCDataAnalyzer.h.

83{};

◆ m_calibTime

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

private

Definition at line 75 of file ZDCDataAnalyzer.h.

75{};

◆ m_currentECalibCoeff

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentECalibCoeff {}

private

Definition at line 65 of file ZDCDataAnalyzer.h.

65{};

◆ m_currentLB

int ZDCDataAnalyzer::m_currentLB {-1}

private

Definition at line 64 of file ZDCDataAnalyzer.h.

64{-1};

◆ m_currentT0OffsetsHG

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentT0OffsetsHG {}

private

Definition at line 66 of file ZDCDataAnalyzer.h.

66{};

◆ m_currentT0OffsetsLG

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentT0OffsetsLG {}

private

Definition at line 67 of file ZDCDataAnalyzer.h.

67{};

◆ m_dataAnalyzerConfig

std::unique_ptr<ZDCJSONConfig> ZDCDataAnalyzer::m_dataAnalyzerConfig {}

private

Definition at line 35 of file ZDCDataAnalyzer.h.

35{};

◆ m_dataLoaded

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

private

Definition at line 69 of file ZDCDataAnalyzer.h.

69{};

◆ m_delayedOrder

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

private

Definition at line 40 of file ZDCDataAnalyzer.h.

40{};

◆ m_eventCount

int ZDCDataAnalyzer::m_eventCount {0}

private

Definition at line 45 of file ZDCDataAnalyzer.h.

45{0};

◆ m_fail

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

private

Definition at line 94 of file ZDCDataAnalyzer.h.

94{};

◆ m_haveECalib

bool ZDCDataAnalyzer::m_haveECalib {false}

private

Definition at line 50 of file ZDCDataAnalyzer.h.

50{false};

◆ m_haveIterCalibCorr

bool ZDCDataAnalyzer::m_haveIterCalibCorr {false}

private

Definition at line 56 of file ZDCDataAnalyzer.h.

56{false};

◆ m_haveNLcalib

bool ZDCDataAnalyzer::m_haveNLcalib {false}

private

Definition at line 86 of file ZDCDataAnalyzer.h.

86{false};

◆ m_haveT0Calib

bool ZDCDataAnalyzer::m_haveT0Calib {false}

private

Definition at line 51 of file ZDCDataAnalyzer.h.

51{false};

◆ m_HGGains

ZDCModuleFloatArray ZDCDataAnalyzer::m_HGGains {}

private

Definition at line 47 of file ZDCDataAnalyzer.h.

47{};

◆ m_iterCalibCorr

std::array<std::vector<std::tuple<unsigned int, float, std::vector<float> > >, 2> ZDCDataAnalyzer::m_iterCalibCorr

private

Definition at line 60 of file ZDCDataAnalyzer.h.

◆ m_LBDepEcalibSplines

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

private

Definition at line 52 of file ZDCDataAnalyzer.h.

52{};

◆ m_moduleAmpFractionLG

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

private

Definition at line 96 of file ZDCDataAnalyzer.h.

96{};

◆ m_moduleAnalyzers

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

private

Definition at line 43 of file ZDCDataAnalyzer.h.

43{};

◆ m_moduleEnabled

ZDCModuleBoolArray ZDCDataAnalyzer::m_moduleEnabled {}

private

Definition at line 42 of file ZDCDataAnalyzer.h.

42{};

◆ m_moduleMask

unsigned int ZDCDataAnalyzer::m_moduleMask {0}

private

Definition at line 71 of file ZDCDataAnalyzer.h.

71{0};

◆ m_moduleStatus

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

private

Definition at line 73 of file ZDCDataAnalyzer.h.

73{};

◆ m_moduleSum

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

private

Definition at line 77 of file ZDCDataAnalyzer.h.

77{};

◆ m_moduleSumBkgdFrac

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

private

Definition at line 80 of file ZDCDataAnalyzer.h.

80{};

◆ m_moduleSumErrSq

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

private

Definition at line 78 of file ZDCDataAnalyzer.h.

78{};

◆ m_moduleSumPreSample

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

private

Definition at line 79 of file ZDCDataAnalyzer.h.

79{};

◆ m_msgFunc_p

ZDCMsg::MessageFunctionPtr ZDCDataAnalyzer::m_msgFunc_p

private

Definition at line 34 of file ZDCDataAnalyzer.h.

◆ m_NLcalibFactors

std::array< std::array< std::vector<float>, 3>, 2> ZDCDataAnalyzer::m_NLcalibFactors {}

private

Definition at line 87 of file ZDCDataAnalyzer.h.

87{}; // 3 POL5s for each side

◆ m_NLcalibModSumBkgdFrac

std::array<float, 2> ZDCDataAnalyzer::m_NLcalibModSumBkgdFrac {}

private

Definition at line 91 of file ZDCDataAnalyzer.h.

91{};

◆ m_NLcalibModuleSum

std::array<float, 2> ZDCDataAnalyzer::m_NLcalibModuleSum {}

private

Definition at line 89 of file ZDCDataAnalyzer.h.

89{};

◆ m_NLcalibModuleSumErrSq

std::array<float, 2> ZDCDataAnalyzer::m_NLcalibModuleSumErrSq {}

private

Definition at line 90 of file ZDCDataAnalyzer.h.

90{};

◆ m_pedestals

ZDCModuleFloatArray ZDCDataAnalyzer::m_pedestals {}

private

Definition at line 48 of file ZDCDataAnalyzer.h.

48{};

◆ m_pulseAnalyzerConfig

std::unique_ptr<ZDCJSONConfig> ZDCDataAnalyzer::m_pulseAnalyzerConfig {}

private

Definition at line 36 of file ZDCDataAnalyzer.h.

36{};

◆ m_repassEnabled

bool ZDCDataAnalyzer::m_repassEnabled {false}

private

Definition at line 38 of file ZDCDataAnalyzer.h.

38{false};

◆ m_T0HGOffsetSplines

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

private

Definition at line 53 of file ZDCDataAnalyzer.h.

53{};

◆ m_T0LGOffsetSplines

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

private

Definition at line 54 of file ZDCDataAnalyzer.h.

54{};

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ JSON

◆ ZDCModuleBoolArray

◆ ZDCModuleFloatArray

◆ ZDCModuleIntArray

Constructor & Destructor Documentation

◆ ZDCDataAnalyzer() [1/2]

◆ ZDCDataAnalyzer() [2/2]

◆ ~ZDCDataAnalyzer()

Member Function Documentation

◆ disableFADCCorrections()

◆ disableModule()

◆ DoNLcalibModuleSum()

◆ enableDelayed() [1/2]

◆ enableDelayed() [2/2]

◆ enableFADCCorrections()

◆ enablePostExclusion() [1/2]

◆ enablePostExclusion() [2/2]

◆ enablePostPulseCheck()

◆ enablePreExclusion() [1/2]

◆ enablePreExclusion() [2/2]

◆ enableRepass()

◆ enableTimeSigCut()

◆ FinishEvent()

◆ GetAverageTime()

◆ GetCalibModuleSum()

◆ GetCalibModuleSumErr()

◆ GetdelayedBS()

◆ GetModuleAmplitude()

◆ GetModuleCalibAmplitude()

◆ GetModuleCalibTime()

◆ GetModuleChisq()

◆ GetModuleMask()

◆ GetModuleStatus()

◆ GetModuleSum()

◆ GetModuleSumErr()

◆ GetModuleSumPreSample()

◆ GetModuleTime()

◆ GetNLcalibModuleSum()

◆ GetNLcalibModuleSumErr()

◆ GetPulseAnalyzer() [1/2]

◆ GetPulseAnalyzer() [2/2]

◆ getPulseAnalyzerGlobalPar()

◆ GetSideBkgdFrac()

◆ GetSideCalibBkgdFrac()

◆ init()

◆ invokeAll()

◆ LoadAndAnalyzeData() [1/2]

◆ LoadAndAnalyzeData() [2/2]

◆ LoadEnergyCalibrations()

◆ LoadT0Calibrations()

◆ ModuleDisabled()

◆ moduleEnabled()

◆ saveFitFunc()

◆ set2ndDerivStep()

◆ SetADCOverUnderflowValues()

◆ SetChisqCuts()

◆ SetCutValues()

◆ SetFitMinMaxAmpValues() [1/2]

◆ SetFitMinMaxAmpValues() [2/2]

◆ SetFitTimeMax()

◆ SetGainFactorsHGLG() [1/2]

◆ SetGainFactorsHGLG() [2/2]

◆ setMinimumSignificance()

◆ SetModuleAmpFractionLG()

◆ SetNLcalibParams()

◆ SetNoiseSigmas()

◆ SetNonlinCorrParams()

◆ SetPeak2ndDerivMinTolerances()

◆ setPerSampleNoiseSigmas()

◆ setQuietFits()

◆ SetTauT0Values()

◆ SetTimeCuts()

◆ SetTimingCorrParams()