ZDCDataAnalyzer Class Reference

#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, 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	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	SetNLcalibParams (std::array< std::array< std::array< float, 6 >, 3 >, 2 > &nlcalibParams)
void	SetModuleAmpFractionLG (const ZDCDataAnalyzer::ZDCModuleFloatArray &moduleAmpFractionLG)
void	enableTimeSigCut (bool AND, float sigCut, const std::string &TF1String, const std::array< std::array< std::vector< double >, 4 >, 2 > &parsHGArr, const std::array< std::array< std::vector< double >, 4 >, 2 > &parsLGArr)
void	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 ()

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 {}
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::array< float, 6 >, 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 22 of file ZDCDataAnalyzer.h.

Member Typedef Documentation

JSON

using ZDCDataAnalyzer::JSON = ZDCJSONConfig::JSON

Definition at line 29 of file ZDCDataAnalyzer.h.

ZDCModuleBoolArray

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

Definition at line 26 of file ZDCDataAnalyzer.h.

ZDCModuleFloatArray

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

Definition at line 25 of file ZDCDataAnalyzer.h.

ZDCModuleIntArray

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

Definition at line 27 of file ZDCDataAnalyzer.h.

Constructor & Destructor Documentation

ZDCDataAnalyzer() [1/2]

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

Definition at line 20 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 68 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"];
    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];
      }
    }
  }
 
  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().c_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 104 of file ZDCDataAnalyzer.h.

{};

Member Function Documentation

disableFADCCorrections()

void ZDCDataAnalyzer::disableFADCCorrections

(

)

Definition at line 509 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 234 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 795 of file ZDCDataAnalyzer.cxx.

{
  if (!m_haveNLcalib) return;
  
  for (int iside:{0,1})
    {
      if (m_calibModuleSum[iside]>0.)
    {
      float fEM = m_calibAmplitude[iside][0] / m_calibModuleSum[iside];
      float fHad1 = m_calibAmplitude[iside][1] / m_calibModuleSum[iside];
      float fHad2 = m_calibAmplitude[iside][2] / m_calibModuleSum[iside];
      
      float EMCorrFact = 0;
      
      for (size_t i=0;i<m_NLcalibFactors[iside][0].size()-1;i++)
        {     
          EMCorrFact += std::pow(fEM - m_NLcalibFactors[iside][0][0],i)*m_NLcalibFactors[iside][0][i+1];
        }
      
      float Had1CorrFact = 0;
      for (size_t i=0;i<m_NLcalibFactors[iside][1].size()-1;i++)
        {
          Had1CorrFact += std::pow(fHad1 - m_NLcalibFactors[iside][1][0],i)*m_NLcalibFactors[iside][1][i+1];
        }
      
      float Had2CorrFact = 0;
      for (size_t i=0;i<m_NLcalibFactors[iside][2].size()-1;i++)
        {
          Had2CorrFact += std::pow(fHad2 - m_NLcalibFactors[iside][2][0],i)*m_NLcalibFactors[iside][2][i+1];
        }
 
      std::ostringstream ostr;
      ostr << "ZDCDataAnalyzer: " << m_calibModuleSum[iside] << " " << EMCorrFact << " " << Had1CorrFact << " " << Had2CorrFact << std::endl;
      (*m_msgFunc_p)(ZDCMsg::Debug,ostr.str().c_str());
      
      float ECorrEM = m_calibModuleSum[iside]/EMCorrFact;
      float ECorrEMHad1 = ECorrEM/Had1CorrFact;
      float ECorrEMHad1Had2 = ECorrEMHad1/Had2CorrFact;
      
      
      m_NLcalibModuleSum[iside] = ECorrEMHad1Had2;
      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 262 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 251 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 493 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 295 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 304 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);
    }
  }
}

enablePreExclusion() [1/2]

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

Definition at line 277 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 286 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 314 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 518 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 690 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 150 of file ZDCDataAnalyzer.h.

{return m_averageTime.at(side);}

GetCalibModuleSum()

float ZDCDataAnalyzer::GetCalibModuleSum ( size_t side ) const

inline

Definition at line 140 of file ZDCDataAnalyzer.h.

{return m_calibModuleSum.at(side);}

GetCalibModuleSumErr()

float ZDCDataAnalyzer::GetCalibModuleSumErr ( size_t side ) const

inline

Definition at line 141 of file ZDCDataAnalyzer.h.

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

GetdelayedBS()

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

inline

Definition at line 161 of file ZDCDataAnalyzer.h.

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

GetModuleAmplitude()

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

inline

Definition at line 153 of file ZDCDataAnalyzer.h.

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

GetModuleCalibAmplitude()

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

inline

Definition at line 157 of file ZDCDataAnalyzer.h.

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

GetModuleCalibTime()

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

inline

Definition at line 158 of file ZDCDataAnalyzer.h.

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

GetModuleChisq()

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

inline

Definition at line 155 of file ZDCDataAnalyzer.h.

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

GetModuleMask()

unsigned int ZDCDataAnalyzer::GetModuleMask ( ) const

inline

Definition at line 134 of file ZDCDataAnalyzer.h.

{return m_moduleMask;}

GetModuleStatus()

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

inline

Definition at line 159 of file ZDCDataAnalyzer.h.

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

GetModuleSum()

float ZDCDataAnalyzer::GetModuleSum ( size_t side ) const

inline

Definition at line 136 of file ZDCDataAnalyzer.h.

{return m_moduleSum.at(side);}

GetModuleSumErr()

float ZDCDataAnalyzer::GetModuleSumErr ( size_t side ) const

inline

Definition at line 137 of file ZDCDataAnalyzer.h.

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

GetModuleSumPreSample()

float ZDCDataAnalyzer::GetModuleSumPreSample ( size_t side ) const

inline

Definition at line 148 of file ZDCDataAnalyzer.h.

{return m_moduleSumPreSample.at(side);}

GetModuleTime()

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

inline

Definition at line 154 of file ZDCDataAnalyzer.h.

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

GetNLcalibModuleSum()

float ZDCDataAnalyzer::GetNLcalibModuleSum ( size_t side ) const

inline

Definition at line 145 of file ZDCDataAnalyzer.h.

{return m_NLcalibModuleSum.at(side);}

GetNLcalibModuleSumErr()

float ZDCDataAnalyzer::GetNLcalibModuleSumErr ( size_t side ) const

inline

Definition at line 146 of file ZDCDataAnalyzer.h.

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

GetPulseAnalyzer() [1/2]

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

inline

Definition at line 164 of file ZDCDataAnalyzer.h.

{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 163 of file ZDCDataAnalyzer.h.

{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 106 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 138 of file ZDCDataAnalyzer.h.

{return m_moduleSumBkgdFrac.at(side);}

GetSideCalibBkgdFrac()

float ZDCDataAnalyzer::GetSideCalibBkgdFrac ( size_t side ) const

inline

Definition at line 142 of file ZDCDataAnalyzer.h.

{return m_calibModSumBkgdFrac.at(side);}

init()

void ZDCDataAnalyzer::init ( )

private

Definition at line 197 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 111 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 628 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 654 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 224 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 232 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 131 of file ZDCDataAnalyzer.h.

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

moduleEnabled()

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

inline

Definition at line 132 of file ZDCDataAnalyzer.h.

{return m_moduleEnabled[side][module];}

set2ndDerivStep()

void ZDCDataAnalyzer::set2ndDerivStep

(

size_t

step

)

Definition at line 333 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 429 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]);
    }
  }
}

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 439 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 408 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 420 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 369 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 351 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 342 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 324 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 400 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::array< float, 6 >, 3 >, 2 > &

nlcalibParams

)

Definition at line 478 of file ZDCDataAnalyzer.cxx.

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

SetNoiseSigmas()

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

Definition at line 391 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 465 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 360 of file ZDCDataAnalyzer.cxx.

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

SetSaveFitFunc()

void ZDCDataAnalyzer::SetSaveFitFunc

(

bool

save

)

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 379 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]);
    }
  }
}

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 452 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 151 of file ZDCDataAnalyzer.h.

{return m_fail.at(side);}

StartEvent()

void ZDCDataAnalyzer::StartEvent

(

int

lumiBlock

)

Definition at line 529 of file ZDCDataAnalyzer.cxx.

{
  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Starting new event, event index = " + std::to_string(m_eventCount)));
 
  // By default we perform quiet pulse fits
  //
  /*
  if ((*m_msgFunc_p)(ZDCMsg::Verbose, "")) {
    invokeAll([](ZDCPulseAnalyzer* pa){pa->setQuietFits();});
  }
  else {
    invokeAll([](ZDCPulseAnalyzer* pa){pa->setQuietFits();});
  }
  */
  
  //  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 13 of file ZDCDataAnalyzer.h.

m_averageTime

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

private

Definition at line 86 of file ZDCDataAnalyzer.h.

{};

m_calibAmplitude

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

private

Definition at line 67 of file ZDCDataAnalyzer.h.

{};

m_calibModSumBkgdFrac

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

private

Definition at line 77 of file ZDCDataAnalyzer.h.

{};

m_calibModuleSum

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

private

Definition at line 75 of file ZDCDataAnalyzer.h.

{};

m_calibModuleSumErrSq

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

private

Definition at line 76 of file ZDCDataAnalyzer.h.

{};

m_calibTime

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

private

Definition at line 68 of file ZDCDataAnalyzer.h.

{};

m_currentECalibCoeff

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentECalibCoeff {}

private

Definition at line 58 of file ZDCDataAnalyzer.h.

{};

m_currentLB

int ZDCDataAnalyzer::m_currentLB {-1}

private

Definition at line 57 of file ZDCDataAnalyzer.h.

{-1};

m_currentT0OffsetsHG

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentT0OffsetsHG {}

private

Definition at line 59 of file ZDCDataAnalyzer.h.

{};

m_currentT0OffsetsLG

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentT0OffsetsLG {}

private

Definition at line 60 of file ZDCDataAnalyzer.h.

{};

m_dataAnalyzerConfig

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

private

Definition at line 34 of file ZDCDataAnalyzer.h.

{};

m_dataLoaded

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

private

Definition at line 62 of file ZDCDataAnalyzer.h.

{};

m_delayedOrder

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

private

Definition at line 39 of file ZDCDataAnalyzer.h.

{};

m_eventCount

int ZDCDataAnalyzer::m_eventCount {0}

private

Definition at line 44 of file ZDCDataAnalyzer.h.

{0};

m_fail

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

private

Definition at line 87 of file ZDCDataAnalyzer.h.

{};

m_haveECalib

bool ZDCDataAnalyzer::m_haveECalib {false}

private

Definition at line 49 of file ZDCDataAnalyzer.h.

{false};

m_haveNLcalib

bool ZDCDataAnalyzer::m_haveNLcalib {false}

private

Definition at line 79 of file ZDCDataAnalyzer.h.

{false};

m_haveT0Calib

bool ZDCDataAnalyzer::m_haveT0Calib {false}

private

Definition at line 50 of file ZDCDataAnalyzer.h.

{false};

m_HGGains

ZDCModuleFloatArray ZDCDataAnalyzer::m_HGGains {}

private

Definition at line 46 of file ZDCDataAnalyzer.h.

{};

m_LBDepEcalibSplines

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

private

Definition at line 51 of file ZDCDataAnalyzer.h.

{};

m_moduleAmpFractionLG

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

private

Definition at line 89 of file ZDCDataAnalyzer.h.

{};

m_moduleAnalyzers

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

private

Definition at line 42 of file ZDCDataAnalyzer.h.

{};

m_moduleEnabled

ZDCModuleBoolArray ZDCDataAnalyzer::m_moduleEnabled {}

private

Definition at line 41 of file ZDCDataAnalyzer.h.

{};

m_moduleMask

unsigned int ZDCDataAnalyzer::m_moduleMask {0}

private

Definition at line 64 of file ZDCDataAnalyzer.h.

{0};

m_moduleStatus

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

private

Definition at line 66 of file ZDCDataAnalyzer.h.

{};

m_moduleSum

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

private

Definition at line 70 of file ZDCDataAnalyzer.h.

{};

m_moduleSumBkgdFrac

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

private

Definition at line 73 of file ZDCDataAnalyzer.h.

{};

m_moduleSumErrSq

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

private

Definition at line 71 of file ZDCDataAnalyzer.h.

{};

m_moduleSumPreSample

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

private

Definition at line 72 of file ZDCDataAnalyzer.h.

{};

m_msgFunc_p

ZDCMsg::MessageFunctionPtr ZDCDataAnalyzer::m_msgFunc_p

private

Definition at line 33 of file ZDCDataAnalyzer.h.

m_NLcalibFactors

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

private

Definition at line 80 of file ZDCDataAnalyzer.h.

{}; // 3 POL5s for each side

m_NLcalibModSumBkgdFrac

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

private

Definition at line 84 of file ZDCDataAnalyzer.h.

{};

m_NLcalibModuleSum

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

private

Definition at line 82 of file ZDCDataAnalyzer.h.

{};

m_NLcalibModuleSumErrSq

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

private

Definition at line 83 of file ZDCDataAnalyzer.h.

{};

m_pedestals

ZDCModuleFloatArray ZDCDataAnalyzer::m_pedestals {}

private

Definition at line 47 of file ZDCDataAnalyzer.h.

{};

m_pulseAnalyzerConfig

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

private

Definition at line 35 of file ZDCDataAnalyzer.h.

{};

m_repassEnabled

bool ZDCDataAnalyzer::m_repassEnabled {false}

private

Definition at line 37 of file ZDCDataAnalyzer.h.

{false};

m_T0HGOffsetSplines

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

private

Definition at line 52 of file ZDCDataAnalyzer.h.

{};

m_T0LGOffsetSplines

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

private

Definition at line 53 of file ZDCDataAnalyzer.h.

{};

---

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

• ZDCDataAnalyzer.h
• ZDCDataAnalyzer.cxx