ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
ZDC::ZdcAnalysisTool Class Referenceabstract

#include <ZdcAnalysisTool.h>

Inheritance diagram for ZDC::ZdcAnalysisTool:
Collaboration diagram for ZDC::ZdcAnalysisTool:

Public Member Functions

 ZdcAnalysisTool (const std::string &name)
 
virtual ~ZdcAnalysisTool () override
 
void initializeDecorations ()
 
StatusCode initialize () override
 Dummy implementation of the initialisation function. More...
 
void initialize80MHz ()
 
void initialize40MHz ()
 
void initializeTriggerEffs (unsigned int runNumber)
 
StatusCode recoZdcModules (const xAOD::ZdcModuleContainer &moduleContainer, const xAOD::ZdcModuleContainer &moduleSumContainer) override
 
StatusCode reprocessZdc () override
 
bool sigprocSincInterp (const std::vector< unsigned short > &adc, float deltaT, float &amp, float &time, float &qual)
 
void setEnergyCalibrations (unsigned int runNumber)
 
void setTimeCalibrations (unsigned int runNumber)
 
void setFADCCorrections (unsigned int runNumber=0)
 
float getModuleSum (int side)
 
float getCalibModuleSum (int side)
 
float getCalibModuleSumErr (int side)
 
float getNLCalibModuleSum (int side)
 
float getNLCalibModuleSumErr (int side)
 
float getUncalibModuleSum (int side)
 
float getUncalibModuleSumErr (int side)
 
float getAverageTime (int side)
 
bool sideFailed (int side)
 
unsigned int getModuleMask ()
 
double getTriggerEfficiency (int side)
 
double getTriggerEfficiencyUncertainty (int side)
 
const ZDCDataAnalyzer * getDataAnalyzer ()
 
ZDCMsg::MessageFunctionPtr MakeMessageFunction ()
 
void Dump_setting ()
 
virtual void print () const =0
 Print the state of the tool. More...
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static bool sigprocMaxFinder (const std::vector< unsigned short > &adc, float deltaT, float &amp, float &time, float &qual)
 
static void SetDebugLevel (int debugLevel=0)
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

std::unique_ptr< ZDCDataAnalyzer > initializeDefault ()
 
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2015G4 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializepPb2016 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2018 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializeLHCf2022 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializepp2023 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2023 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializepp2024 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2024 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializeOONeNe2025 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializepO2025 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializepO2025B ()
 
std::unique_ptr< ZDCDataAnalyzer > initializeInjectorpp2024 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializeInjectorPbPb2024 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializeInjectorpOOONeNe2025 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializeMonteCarloPbPb2023 ()
 
StatusCode configureNewRun (unsigned int runNumber)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::string m_name
 
bool m_init
 
std::string m_configuration
 
std::string m_zdcAnalysisConfigPath
 
std::string m_zdcEnergyCalibFileName
 
std::string m_zdcTimeCalibFileName
 
std::string m_zdcTriggerEffParamsFileName
 
bool m_writeAux
 
std::string m_auxSuffix
 
bool m_eventReady
 
unsigned int m_runNumber
 
unsigned int m_lumiBlock
 
std::unique_ptr< TF1 > m_tf1SincInterp
 
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
 
std::string m_zdcModuleContainerName
 
const xAOD::ZdcModuleContainer * m_zdcModules {nullptr}
 
std::string m_zdcSumContainerName
 
const xAOD::ZdcModuleContainer * m_zdcSums {nullptr}
 
bool m_flipEMDelay
 
unsigned int m_lowGainMode
 
bool m_combineDelay {false}
 
bool m_doCalib {false}
 
bool m_doTrigEff {false}
 
bool m_doTimeCalib {false}
 
bool m_doFADCCorr {false}
 
bool m_doNonLinCorr {false}
 
bool m_doFADCCorrPerSample {false}
 
int m_forceCalibRun
 
int m_forceCalibLB
 
std::string m_calibVersion
 
unsigned int m_numSample
 
float m_deltaTSample
 
unsigned int m_presample
 
unsigned int m_peakSample
 
float m_Peak2ndDerivThresh
 
float m_t0
 
float m_delayDeltaT
 
float m_tau1
 
float m_tau2
 
bool m_fixTau1
 
bool m_fixTau2
 
float m_deltaTCut
 
float m_ChisqRatioCut
 
int m_LHCRun
 
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer
 
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer_40MHz
 
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer_80MHz
 
ZDCDataAnalyzer::ZDCModuleIntArray m_peak2ndDerivMinSamples {}
 
ZDCDataAnalyzer::ZDCModuleFloatArray m_peak2ndDerivMinThresholdsHG {}
 
ZDCDataAnalyzer::ZDCModuleFloatArray m_peak2ndDerivMinThresholdsLG {}
 
std::shared_ptr< ZDCTriggerEfficiency > m_zdcTriggerEfficiency
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmplitude {this, "ZdcModuleAmplitude", "", "ZDC module amplitude"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibEnergy {this, "ZdcModuleCalibEnergy", "", "ZDC module calibrated energy"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleNLCalibEnergy {this, "ZdcModuleNLCalibEnergy", "", "ZDC module NL calibrated energy"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibTime {this, "ZdcModuleCalibTime", "", "ZDC module calibrated time"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleStatus {this, "ZdcModuleStatus", "", "ZDC module fit status"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleTime {this, "ZdcModuleTime", "", "ZDC module time"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleChisq {this, "ZdcModuleChisq", "", "ZDC module fit chisq"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmpNoNonLin {this, "ZdcModuleAmpNoNonLin", "", "ZDC module amplitude with gain factor applied but no nonlinear correction"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmp {this, "ZdcModuleFitAmp", "", "ZDC module fit amp"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmpError {this, "ZdcModuleFitAmpError", "", "ZDC module fit amp error"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitT0 {this, "ZdcModuleFitT0", "", "ZDC module fit t0"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleBkgdMaxFraction {this, "ZdcModuleBkgdMaxFraction", "", "ZDC module background max fraction"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePreSampleAmp {this, "ZdcModulePreSampleAmp", "", "ZDC module presample amplitude"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePresample {this, "ZdcModulePresample", "", "ZDC module presample"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMinDeriv2nd {this, "ZdcModuleMinDeriv2nd", "", "ZDC module min 2nd derivative"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMaxADC {this, "ZdcModuleMaxADC", "", "ZDC module max ADC, minus pre-sample"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMaxADCHG {this, "ZdcModuleMaxADCHG", "", "ZDC module HG max ADC, unsubtracted"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMaxADCLG {this, "ZdcModuleMaxADCLG", "", "ZDC module LG max ADC, unsubtracted"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmpLGRefit {this, "ZdcModuleFitAmpLGRefit", "", "ZDC module fit amp LG refit, with no gain factor or nonlinear correction applied"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmpLGRefit {this, "ZdcModuleAmpLGRefit", "", "ZDC module amp LG refit, with gain factor applied but no nonlinear correction"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmpCorrLGRefit {this, "ZdcModuleAmpCorrLGRefit", "", "ZDC module amp LG refit, with both gain factor and nonlinear correction applied"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleT0LGRefit {this, "ZdcModuleT0LGRefit", "", "ZDC module fit t0 LG refit"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleT0SubLGRefit {this, "ZdcModuleT0SubLGRefit", "", "ZDC module subtracted t0 LG refit"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleChisqLGRefit {this, "ZdcModuleChisqLGRefit", "", "ZDC module LG refit chi square"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumUncalibSum {this, "ZdcSumUncalibSum", "", "ZDC side uncalibrated sum"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumUncalibSumErr {this, "ZdcSumUncalibSumErr", "", "ZDC side uncalibrated sum error"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergy {this, "ZdcSumCalibEnergy", "", "ZDC side calibrated energy"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergyErr {this, "ZdcSumCalibEnergyErr", "", "ZDC side calibrated energy error"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumNLCalibEnergy {this, "ZdcSumNLCalibEnergy", "", "ZDC side NL calibrated energy"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumNLCalibEnergyErr {this, "ZdcSumNLCalibEnergyErr", "", "ZDC side NL calibrated energy error"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumFinalEnergy {this, "ZdcSumFinalEnergy", "", "ZDC side final energy"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumFinalEnergyErr {this, "ZdcSumFinalEnergyErr", "", "ZDC side final energy error"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumAverageTime {this, "ZdcSumAverageTime", "", "ZDC side average time"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumStatus {this, "ZdcSumStatus", "", "ZDC side status"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumModuleMask {this, "ZdcSumModuleMask", "", "ZDC side module mask"}
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Static Private Attributes

static std::atomic< int > s_debugLevel
 

Detailed Description

Definition at line 28 of file ZdcAnalysisTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ZdcAnalysisTool()

ZDC::ZdcAnalysisTool::ZdcAnalysisTool ( const std::string &  name)

Definition at line 24 of file ZdcAnalysisTool.cxx.

25  : asg::AsgTool(name), m_name(name), m_init(false),
26  m_writeAux(false), m_eventReady(false),
27  m_runNumber(0), m_lumiBlock(0),
28  m_zdcTriggerEfficiency(0)
29 {
30 
31 #ifndef XAOD_STANDALONE
32  declareInterface<IZdcAnalysisTool>(this);
33 #endif
34 
35  declareProperty("ZdcModuleContainerName", m_zdcModuleContainerName = "ZdcModules", "Location of ZDC processed data");
36  declareProperty("ZdcSumContainerName", m_zdcSumContainerName = "ZdcSums", "Location of ZDC processed sums");
37  declareProperty("Configuration", m_configuration = "PbPb2015");
38  declareProperty("FlipEMDelay", m_flipEMDelay = false);
39  declareProperty("LowGainMode", m_lowGainMode = 0);
40  declareProperty("WriteAux", m_writeAux = true);
41  declareProperty("AuxSuffix", m_auxSuffix = "");
42 
43  // The following job properties enable/disable and affect the calibration of the ZDC energies
44  //
45  declareProperty("DoCalib", m_doCalib = true);
46  declareProperty("CalibVersion", m_calibVersion = "");
47  declareProperty("DoTrigEff", m_doTrigEff = true);
48  declareProperty("DoTimeCalib", m_doTimeCalib = true);
49  declareProperty("ZdcAnalysisConfigPath", m_zdcAnalysisConfigPath = "$ROOTCOREBIN/data/ZdcAnalysis", "ZDC Analysis config file path");
50  //declareProperty("ForceCalibRun",m_forceCalibRun=287931); // last run of Pb+Pb 2015
51  declareProperty("ForceCalibRun", m_forceCalibRun = -1); // last run of Pb+Pb 2015
52  declareProperty("ForceCalibLB", m_forceCalibLB = 814); // last LB of Pb+Pb 2015
53 
54  declareProperty("DoNonLinCorr", m_doNonLinCorr = true); // how we have run with 2023 and most of 2024
55  declareProperty("DoFADCCorr", m_doFADCCorr = false);
56  declareProperty("DoFADCCorrPerSample", m_doFADCCorrPerSample = false);
57 
58  // The following parameters are primarily used for the "default" configuration, but also may be
59  // use to modify/tailor other configurations
60  //
61  declareProperty("NumSampl", m_numSample = 7);
62  declareProperty("DeltaTSample", m_deltaTSample = 25);
63  declareProperty("Presample", m_presample = 0);
64  declareProperty("CombineDelay", m_combineDelay = false);
65  declareProperty("DelayDeltaT", m_delayDeltaT = -12.5);
66 
67  declareProperty("PeakSample", m_peakSample = 11);
68  declareProperty("Peak2ndDerivThresh", m_Peak2ndDerivThresh = 20);
69 
70  declareProperty("T0", m_t0 = 30);
71  declareProperty("Tau1", m_tau1 = 5);
72  declareProperty("Tau2", m_tau2 = 25);
73  declareProperty("FixTau1", m_fixTau1 = false);
74  declareProperty("FixTau2", m_fixTau2 = false);
75 
76  declareProperty("DeltaTCut", m_deltaTCut = 10);
77  declareProperty("ChisqRatioCut", m_ChisqRatioCut = 10);
78 
79  declareProperty("LHCRun", m_LHCRun = 3);
80 
81 }

◆ ~ZdcAnalysisTool()

ZDC::ZdcAnalysisTool::~ZdcAnalysisTool ( )
overridevirtual

Definition at line 83 of file ZdcAnalysisTool.cxx.

84 {
85  ATH_MSG_DEBUG("Deleting ZdcAnalysisTool named " << m_name);
86 }

Member Function Documentation

◆ configureNewRun()

StatusCode ZDC::ZdcAnalysisTool::configureNewRun ( unsigned int  runNumber)
private

Definition at line 2596 of file ZdcAnalysisTool.cxx.

2597 {
2598  ATH_MSG_DEBUG("Setting up new run " << runNumber);
2599 
2600  // We do nothing for the default configuration
2601  //
2602  if (m_configuration != "default") {
2603  if (m_configuration == "PbPb2015") {
2604  //
2605  // Two periods, 40 MHz and 80 MHz readout
2606  //
2607  if (runNumber < 287222) m_zdcDataAnalyzer = m_zdcDataAnalyzer_40MHz;
2608  else m_zdcDataAnalyzer = m_zdcDataAnalyzer_80MHz;
2609  }
2610  }
2611 
2612  return StatusCode::SUCCESS;
2613 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ Dump_setting()

void ZDC::ZdcAnalysisTool::Dump_setting ( )
inline

Definition at line 95 of file ZdcAnalysisTool.h.

95  {
96  if (s_debugLevel > 2) {
97  ATH_MSG_INFO("========================================================================================================================");
98  for (int i = 0; i < 2; i++) {
99  for (int j = 0; j < 4; j++) {
100  ATH_MSG_INFO("-------------------------------------------------------------------------------------------------------------------");
101  ATH_MSG_INFO("Side: " << i << ", Module: " << j);
102  m_zdcDataAnalyzer->GetPulseAnalyzer(i, j)->dumpSetting();
103  }
104  }
105  ATH_MSG_INFO("========================================================================================================================");
106  }
107  }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ getAverageTime()

float ZDC::ZdcAnalysisTool::getAverageTime ( int  side)

Definition at line 3271 of file ZdcAnalysisTool.cxx.

3272 {
3273  if (!m_zdcDataAnalyzer) return 0;
3274  return m_zdcDataAnalyzer->GetAverageTime(side);
3275 }

◆ getCalibModuleSum()

float ZDC::ZdcAnalysisTool::getCalibModuleSum ( int  side)

Definition at line 3235 of file ZdcAnalysisTool.cxx.

3236 {
3237  if (!m_zdcDataAnalyzer) return 0;
3238  return m_zdcDataAnalyzer->GetCalibModuleSum(side);
3239 }

◆ getCalibModuleSumErr()

float ZDC::ZdcAnalysisTool::getCalibModuleSumErr ( int  side)

Definition at line 3241 of file ZdcAnalysisTool.cxx.

3242 {
3243  if (!m_zdcDataAnalyzer) return 0;
3244  return m_zdcDataAnalyzer->GetCalibModuleSumErr(side);
3245 }

◆ getDataAnalyzer()

const ZDCDataAnalyzer* ZDC::ZdcAnalysisTool::getDataAnalyzer ( )
inline

Definition at line 73 of file ZdcAnalysisTool.h.

73 {return m_zdcDataAnalyzer.get();}

◆ getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void *  ptr) const
inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getName
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

119  {
120 
121 #ifdef XAOD_STANDALONE
122  // In case we use @c xAOD::TEvent, we have a direct function call
123  // for this.
124  return evtStore()->event()->getKey( ptr );
125 #else
126  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
127  return ( proxy == nullptr ? 0 : proxy->sgkey() );
128 #endif // XAOD_STANDALONE
129  }

◆ getModuleMask()

unsigned int ZDC::ZdcAnalysisTool::getModuleMask ( )

Definition at line 3283 of file ZdcAnalysisTool.cxx.

3284 {
3285  if (!m_zdcDataAnalyzer) return 0;
3286  return m_zdcDataAnalyzer->GetModuleMask();
3287 }

◆ getModuleSum()

float ZDC::ZdcAnalysisTool::getModuleSum ( int  side)

Definition at line 3229 of file ZdcAnalysisTool.cxx.

3230 {
3231  if (!m_zdcDataAnalyzer) return 0;
3232  return m_zdcDataAnalyzer->GetModuleSum(side);
3233 }

◆ getName()

const std::string & asg::AsgTool::getName ( const void *  ptr) const
inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getKey
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

106  {
107 
108 #ifdef XAOD_STANDALONE
109  // In case we use @c xAOD::TEvent, we have a direct function call
110  // for this.
111  return evtStore()->event()->getName( ptr );
112 #else
113  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
114  static const std::string dummy = "";
115  return ( proxy == nullptr ? dummy : proxy->name() );
116 #endif // XAOD_STANDALONE
117  }

◆ getNLCalibModuleSum()

float ZDC::ZdcAnalysisTool::getNLCalibModuleSum ( int  side)

Definition at line 3247 of file ZdcAnalysisTool.cxx.

3248 {
3249  if (!m_zdcDataAnalyzer) return 0;
3250  return m_zdcDataAnalyzer->GetNLcalibModuleSum(side);
3251 }

◆ getNLCalibModuleSumErr()

float ZDC::ZdcAnalysisTool::getNLCalibModuleSumErr ( int  side)

Definition at line 3253 of file ZdcAnalysisTool.cxx.

3254 {
3255  if (!m_zdcDataAnalyzer) return 0;
3256  return m_zdcDataAnalyzer->GetNLcalibModuleSumErr(side);
3257 }

◆ getProperty()

template<class T >
const T* asg::AsgTool::getProperty ( const std::string &  name) const
inherited

Get one of the tool's properties.

◆ getTriggerEfficiency()

double ZDC::ZdcAnalysisTool::getTriggerEfficiency ( int  side)

Definition at line 3289 of file ZdcAnalysisTool.cxx.

3290 {
3291  if (!m_doTrigEff) return -1;
3292 
3293  m_zdcTriggerEfficiency->UpdatelumiBlock(m_lumiBlock);
3294  float adcSum = getModuleSum(side);
3295  double eff = m_zdcTriggerEfficiency->GetEfficiency(side, adcSum);
3296  return eff;
3297 }

◆ getTriggerEfficiencyUncertainty()

double ZDC::ZdcAnalysisTool::getTriggerEfficiencyUncertainty ( int  side)

Definition at line 3299 of file ZdcAnalysisTool.cxx.

3300 {
3301  if (!m_doCalib) return -1;
3302 
3303  m_zdcTriggerEfficiency->UpdatelumiBlock(m_lumiBlock);
3304  float adcSum = getModuleSum(side);
3305  std::pair<double, double> eff_pair = m_zdcTriggerEfficiency->GetEfficiencyAndError(msg(), side, adcSum);
3306  return eff_pair.second;
3307 }

◆ getUncalibModuleSum()

float ZDC::ZdcAnalysisTool::getUncalibModuleSum ( int  side)

Definition at line 3259 of file ZdcAnalysisTool.cxx.

3260 {
3261  if (!m_zdcDataAnalyzer) return 0;
3262  return m_zdcDataAnalyzer->GetModuleSum(side);
3263 }

◆ getUncalibModuleSumErr()

float ZDC::ZdcAnalysisTool::getUncalibModuleSumErr ( int  side)

Definition at line 3265 of file ZdcAnalysisTool.cxx.

3266 {
3267  if (!m_zdcDataAnalyzer) return 0;
3268  return m_zdcDataAnalyzer->GetModuleSumErr(side);
3269 }

◆ initialize()

StatusCode ZDC::ZdcAnalysisTool::initialize ( )
overridevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 2386 of file ZdcAnalysisTool.cxx.

2387 {
2388  m_tf1SincInterp.reset (new TF1("SincInterp", ZDC::SincInterp, -5., 160., 8));
2389  m_tf1SincInterp->SetNpx(300);
2390 
2391  // Set up calibrations
2392  //
2393  std::string filename = PathResolverFindCalibFile( "ZdcAnalysis/ZdcAnalysisConfig.conf" );
2394  TEnv env(filename.c_str());
2395 
2396  m_zdcEnergyCalibFileName = std::string(env.GetValue("ZdcEnergyCalibFileName", "ZdcCalibrations_v1.root"));
2397  ATH_MSG_INFO("ZDC energy calibration filename " << m_zdcEnergyCalibFileName);
2398  m_zdcTimeCalibFileName = std::string(env.GetValue("ZdcTimeCalibFileName", "ZdcTimeCalibrations_v1.root"));
2399  ATH_MSG_INFO("ZDC time calibration filename " << m_zdcTimeCalibFileName);
2400  m_zdcTriggerEffParamsFileName = std::string(env.GetValue("ZdcTriggerEffFileName", "ZdcTriggerEffParameters_v6.root"));
2401  ATH_MSG_INFO("ZDC trigger efficiencies filename " << m_zdcTriggerEffParamsFileName);
2402 
2403 
2404  if (m_forceCalibRun > -1) {
2405  ATH_MSG_DEBUG("CAREFUL: forcing calibration run/LB =" << m_forceCalibRun << "/" << m_forceCalibLB);
2406 
2407  if (m_forceCalibLB < 0) {
2408  ATH_MSG_ERROR("Invalid settings: Forced run > 0 but lumi block < 0");
2409  return StatusCode::FAILURE;
2410  }
2411  }
2412 
2413  // Use configuration to direct initialization
2414  //
2415  if (m_configuration == "default") {
2416  m_zdcDataAnalyzer = initializeDefault();
2417  }
2418  else if (m_configuration == "PbPb2015") {
2419  initialize80MHz();
2420  initialize40MHz();
2421 
2422  m_zdcDataAnalyzer = m_zdcDataAnalyzer_80MHz; // default
2423  }
2424  else if (m_configuration == "pPb2016") {
2425  m_zdcDataAnalyzer = initializepPb2016();
2426  }
2427  else if (m_configuration == "PbPb2018") {
2428  m_zdcDataAnalyzer = initializePbPb2018();
2429  }
2430  else if (m_configuration == "PbPb2015G4") {
2431  m_zdcDataAnalyzer = initializePbPb2015G4();
2432  }
2433  else if (m_configuration == "LHCf2022") {
2434  m_zdcDataAnalyzer = initializeLHCf2022();
2435  }
2436  else if (m_configuration == "pp2023") {
2437  m_zdcDataAnalyzer = initializepp2023();
2438  }
2439  else if (m_configuration == "pp2024") {
2440  m_zdcDataAnalyzer = initializepp2024();
2441  }
2442  else if (m_configuration == "PbPb2023") {
2443  m_zdcDataAnalyzer = initializePbPb2023();
2444  }
2445  else if (m_configuration == "PbPb2024") {
2446  m_zdcDataAnalyzer = initializePbPb2024();
2447  }
2448  else if (m_configuration == "OONeNe2025") {
2449  m_zdcDataAnalyzer = initializeOONeNe2025();
2450  }
2451  else if (m_configuration == "pO2025") {
2452  m_zdcDataAnalyzer = initializepO2025();
2453  }
2454  else if (m_configuration == "pO2025B") {
2455  m_zdcDataAnalyzer = initializepO2025B();
2456  }
2457  else if (m_configuration == "Injectorpp2024") {
2458  m_zdcDataAnalyzer = initializeInjectorpp2024();
2459  }
2460  else if (m_configuration == "InjectorPbPb2024") {
2461  m_zdcDataAnalyzer = initializeInjectorPbPb2024();
2462  }
2463  else if (m_configuration == "InjectorpOOONeNe2025") {
2464  m_zdcDataAnalyzer = initializeInjectorpOOONeNe2025();
2465  }
2466  else if (m_configuration == "MonteCarloPbPb2023") {
2467  m_zdcDataAnalyzer = initializeMonteCarloPbPb2023();
2468  }
2469  else {
2470  ATH_MSG_ERROR("Unknown configuration: " << m_configuration);
2471  return StatusCode::FAILURE;
2472  }
2473 
2474  // If an aux suffix is provided, prepend it with "_" so we don't have to do so at each use
2475  //
2476 
2477  ATH_MSG_INFO("Configuration: " << m_configuration);
2478  ATH_MSG_DEBUG("FlipEMDelay: " << m_flipEMDelay);
2479  ATH_MSG_DEBUG("LowGainMode: " << m_lowGainMode);
2480 
2481  ATH_MSG_DEBUG("Using Combined delayed and undelayed samples: " << m_combineDelay);
2482 
2483  ATH_MSG_DEBUG("WriteAux: " << m_writeAux);
2484  ATH_MSG_DEBUG("AuxSuffix: " << m_auxSuffix);
2485  ATH_MSG_DEBUG("DoCalib: " << m_doCalib);
2486  ATH_MSG_DEBUG("ForceCalibRun: " << m_forceCalibRun);
2487  ATH_MSG_DEBUG("ForceCalibLB: " << m_forceCalibLB);
2488  ATH_MSG_DEBUG("NumSampl: " << m_numSample);
2489  ATH_MSG_DEBUG("DeltaTSample: " << m_deltaTSample);
2490  ATH_MSG_DEBUG("Presample: " << m_presample);
2491  ATH_MSG_DEBUG("PeakSample: " << m_peakSample);
2492  ATH_MSG_DEBUG("Peak2ndDerivThresh: " << m_Peak2ndDerivThresh);
2493 
2494  if (m_combineDelay) ATH_MSG_DEBUG("DelayDeltaT: " << m_delayDeltaT);
2495 
2496  ATH_MSG_DEBUG("T0: " << m_t0);
2497  ATH_MSG_DEBUG("Tau1: " << m_tau1);
2498  ATH_MSG_DEBUG("Tau2: " << m_tau2);
2499  ATH_MSG_DEBUG("FixTau1: " << m_fixTau1);
2500  ATH_MSG_DEBUG("FixTau2: " << m_fixTau2);
2501  ATH_MSG_DEBUG("DeltaTCut: " << m_deltaTCut);
2502  ATH_MSG_DEBUG("ChisqRatioCut: " << m_ChisqRatioCut);
2503 
2504  ATH_CHECK( m_eventInfoKey.initialize());
2505 
2506  // Initialize decorations
2507 
2508  m_zdcModuleAmplitude = m_zdcModuleContainerName+".Amplitude"+m_auxSuffix;
2509  ATH_CHECK( m_zdcModuleAmplitude.initialize());
2510  m_zdcModuleCalibEnergy = m_zdcModuleContainerName+".CalibEnergy"+m_auxSuffix;
2511  ATH_CHECK( m_zdcModuleCalibEnergy.initialize());
2512  m_zdcModuleCalibTime = m_zdcModuleContainerName+".CalibTime"+m_auxSuffix;
2513  ATH_CHECK( m_zdcModuleCalibTime.initialize());
2514  m_zdcModuleStatus = m_zdcModuleContainerName+".Status"+m_auxSuffix;
2515  ATH_CHECK( m_zdcModuleStatus.initialize());
2516  m_zdcModuleTime = m_zdcModuleContainerName+".Time"+m_auxSuffix;
2517  ATH_CHECK( m_zdcModuleTime.initialize());
2518  m_zdcModuleChisq = m_zdcModuleContainerName+".Chisq"+m_auxSuffix;
2519  ATH_CHECK( m_zdcModuleChisq.initialize());
2520  m_zdcModuleAmpNoNonLin = m_zdcModuleContainerName+".AmpNoNonLin"+m_auxSuffix;
2521  ATH_CHECK( m_zdcModuleAmpNoNonLin.initialize());
2522  m_zdcModuleFitAmp = m_zdcModuleContainerName+".FitAmp"+m_auxSuffix;
2523  ATH_CHECK( m_zdcModuleFitAmp.initialize());
2524  m_zdcModuleFitAmpError = m_zdcModuleContainerName+".FitAmpError"+m_auxSuffix;
2525  ATH_CHECK( m_zdcModuleFitAmpError.initialize());
2526  m_zdcModuleFitT0 = m_zdcModuleContainerName+".FitT0"+m_auxSuffix;
2527  ATH_CHECK( m_zdcModuleFitT0.initialize());
2528  m_zdcModuleBkgdMaxFraction = m_zdcModuleContainerName+".BkgdMaxFraction"+m_auxSuffix;
2529  ATH_CHECK( m_zdcModuleBkgdMaxFraction.initialize());
2530  m_zdcModulePreSampleAmp = m_zdcModuleContainerName+".PreSampleAmp"+m_auxSuffix;
2531  ATH_CHECK( m_zdcModulePreSampleAmp.initialize());
2532  m_zdcModulePresample = m_zdcModuleContainerName+".Presample"+m_auxSuffix;
2533  ATH_CHECK( m_zdcModulePresample.initialize());
2534  m_zdcModuleMinDeriv2nd = m_zdcModuleContainerName+".MinDeriv2nd"+m_auxSuffix;
2535  ATH_CHECK( m_zdcModuleMinDeriv2nd.initialize());
2536  m_zdcModuleMaxADC = m_zdcModuleContainerName+".MaxADC"+m_auxSuffix;
2537  ATH_CHECK( m_zdcModuleMaxADC.initialize());
2538 
2539  m_zdcModuleMaxADCHG = m_zdcModuleContainerName+".MaxADCHG"+m_auxSuffix;
2540  ATH_CHECK( m_zdcModuleMaxADCHG.initialize());
2541  m_zdcModuleMaxADCLG = m_zdcModuleContainerName+".MaxADCLG"+m_auxSuffix;
2542  ATH_CHECK( m_zdcModuleMaxADCLG.initialize());
2543 
2544  // LG refit data
2545  //
2546  m_zdcModuleFitAmpLGRefit = m_zdcModuleContainerName+".FitAmpLGRefit"+m_auxSuffix;
2547  ATH_CHECK(m_zdcModuleFitAmpLGRefit.initialize());
2548  m_zdcModuleAmpLGRefit = m_zdcModuleContainerName+".AmpLGRefit"+m_auxSuffix;
2549  ATH_CHECK(m_zdcModuleAmpLGRefit.initialize());
2550  m_zdcModuleAmpCorrLGRefit = m_zdcModuleContainerName+".AmpCorrLGRefit"+m_auxSuffix;
2551  ATH_CHECK(m_zdcModuleAmpCorrLGRefit.initialize());
2552  m_zdcModuleT0LGRefit = m_zdcModuleContainerName+".T0LGRefit"+m_auxSuffix;
2553  ATH_CHECK(m_zdcModuleT0LGRefit.initialize());
2554  m_zdcModuleT0SubLGRefit = m_zdcModuleContainerName+".T0SubLGRefit"+m_auxSuffix;
2555  ATH_CHECK(m_zdcModuleT0SubLGRefit.initialize());
2556  m_zdcModuleChisqLGRefit = m_zdcModuleContainerName+".ChisqLGRefit"+m_auxSuffix;
2557  ATH_CHECK( m_zdcModuleChisqLGRefit.initialize());
2558 
2559  // ZDC per-calorimeter data
2560  //
2561  m_zdcSumUncalibSum = m_zdcSumContainerName+".UncalibSum"+m_auxSuffix;
2562  ATH_CHECK( m_zdcSumUncalibSum.initialize());
2563  m_zdcSumUncalibSumErr = m_zdcSumContainerName+".UncalibSumErr"+m_auxSuffix;
2564  ATH_CHECK( m_zdcSumUncalibSumErr.initialize());
2565  m_zdcSumCalibEnergy = m_zdcSumContainerName+".CalibEnergy"+m_auxSuffix;
2566  ATH_CHECK( m_zdcSumCalibEnergy.initialize());
2567  m_zdcSumCalibEnergyErr = m_zdcSumContainerName+".CalibEnergyErr"+m_auxSuffix;
2568  ATH_CHECK( m_zdcSumCalibEnergyErr.initialize());
2569  m_zdcSumNLCalibEnergy = m_zdcSumContainerName+".NLCalibEnergy"+m_auxSuffix;
2570  ATH_CHECK( m_zdcSumNLCalibEnergy.initialize());
2571  m_zdcSumNLCalibEnergyErr = m_zdcSumContainerName+".NLCalibEnergyErr"+m_auxSuffix;
2572  ATH_CHECK( m_zdcSumNLCalibEnergyErr.initialize());
2573  m_zdcSumFinalEnergy = m_zdcSumContainerName+".FinalEnergy"+m_auxSuffix;
2574  ATH_CHECK( m_zdcSumFinalEnergy.initialize());
2575  m_zdcSumAverageTime = m_zdcSumContainerName+".AverageTime"+m_auxSuffix;
2576  ATH_CHECK( m_zdcSumAverageTime.initialize());
2577  m_zdcSumStatus = m_zdcSumContainerName+".Status"+m_auxSuffix;
2578  ATH_CHECK( m_zdcSumStatus.initialize());
2579  m_zdcSumModuleMask = m_zdcSumContainerName+".ModuleMask"+m_auxSuffix;
2580  ATH_CHECK( m_zdcSumModuleMask.initialize());
2581 
2582  if (m_writeAux && m_auxSuffix != "") {
2583  ATH_MSG_DEBUG("suffix string = " << m_auxSuffix);
2584  }
2585 
2586  m_init = true;
2587 
2588  return StatusCode::SUCCESS;
2589 }

◆ initialize40MHz()

void ZDC::ZdcAnalysisTool::initialize40MHz ( )

Definition at line 2147 of file ZdcAnalysisTool.cxx.

2148 {
2149  // We have a complete configuration and so we override all of the default parameters
2150  //
2151 
2152  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{{4.2, 3.8, 5.2, 5.0}},
2153  {{5.0, 3.7, 3.5, 3.5}}
2154  }
2155  };
2156 
2157  // identical to 80 MHz -- is this right
2158  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{{20.0, 20.4, 18.9, 20.8}},
2159  {{19.1, 21.9, 22.6, 23.4}}
2160  }
2161  };
2162 
2163  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{{1, 1, 2, 1}},
2164  {{1, 1, 1, 1}}
2165  }
2166  };
2167 
2168  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG = {{{{ -8, -8, -8, -8}},
2169  {{ -8, -8, -8, -8}}
2170  }
2171  };
2172 
2173  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsLG = {{{{ -4, -4, -4, -4}},
2174  {{ -4, -4, -4, -4}}
2175  }
2176  };
2177 
2178  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
2179  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
2180  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
2181 
2182  // Set Tau and nominal timing offsets
2183  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
2184 
2185  bool fixTau1 = true;
2186  bool fixTau2 = true;
2187 
2188  for (size_t side : {0, 1}) {
2189  for (size_t module : {0, 1, 2, 3}) {
2190  fixTau1Arr[side][module] = fixTau1;
2191  fixTau2Arr[side][module] = fixTau2;
2192  }
2193  }
2194 
2195  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{{53.942, 49.887, 59.633, 46.497}},
2196  {{46.314, 42.267, 50.327, 41.605}}
2197  }
2198  };
2199  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{{51.771, 47.936, 57.438, 44.191}},
2200  {{44.295, 41.755, 48.081, 40.175}}
2201  }
2202  };
2203 
2204 
2205  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
2206  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutLG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
2207  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
2208  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
2209  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
2210  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
2211 
2212  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
2213 
2214  slewingParamsHG[0][0] = {0, -7.904e-02, 4.686e-02, 1.530e-03 };
2215  slewingParamsHG[0][1] = {0, 2.250e-02, 4.732e-02, 6.050e-03 };
2216  slewingParamsHG[0][2] = {0, 4.388e-02, 6.707e-02, -5.526e-05 };
2217  slewingParamsHG[0][3] = {0, 1.205e-01, 2.726e-02, 2.610e-03 };
2218 
2219  slewingParamsHG[1][0] = {0, 6.861e-02, 5.175e-03, -9.018e-04 };
2220  slewingParamsHG[1][1] = {0, 3.855e-01, -4.442e-02, -2.022e-02 };
2221  slewingParamsHG[1][2] = {0, -4.337e-03, 3.841e-02, 4.661e-03 };
2222  slewingParamsHG[1][3] = {0, 3.623e-01, -3.882e-02, -1.805e-02 };
2223 
2224  slewingParamsLG[0][0] = {0, 1.708e-02, 7.929e-02, 5.079e-03 };
2225  slewingParamsLG[0][1] = {0, 1.406e-01, 1.209e-01, -1.922e-04 };
2226  slewingParamsLG[0][2] = {0, 1.762e-01, 1.118e-01, 1.679e-04 };
2227  slewingParamsLG[0][3] = {0, 1.361e-02, -2.685e-02, -4.168e-02 };
2228 
2229  slewingParamsLG[1][0] = {0, 1.962e-01, -5.025e-03, -2.001e-02 };
2230  slewingParamsLG[1][1] = {0, 3.258e-01, 1.229e-02, -2.925e-02 };
2231  slewingParamsLG[1][2] = {0, 1.393e-01, 8.113e-02, -2.594e-03 };
2232  slewingParamsLG[1][3] = {0, 1.939e-01, 2.188e-02, -5.579e-02 };
2233 
2234  m_zdcDataAnalyzer_40MHz.reset (new ZDCDataAnalyzer(MakeMessageFunction(), 7, 25, 0, "FermiExp", peak2ndDerivMinSamples,
2235  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
2236 
2237  m_zdcDataAnalyzer_40MHz->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
2238  m_zdcDataAnalyzer_40MHz->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
2239  m_zdcDataAnalyzer_40MHz->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
2240  m_zdcDataAnalyzer_40MHz->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
2241  slewingParamsHG, slewingParamsLG);
2242 
2243  std::array<std::array<std::vector<float>, 4>, 2> moduleHGNonLinCorr, moduleLGNonLinCorr;
2244  moduleHGNonLinCorr[0][0] = { -3.76800e-02, 4.63597e-02};
2245  moduleHGNonLinCorr[0][1] = { -1.02185e-01, -1.17548e-01};
2246  moduleHGNonLinCorr[0][2] = { -8.78451e-02, -1.52174e-01};
2247  moduleHGNonLinCorr[0][3] = { -1.04835e-01, -1.96514e-01};
2248  moduleHGNonLinCorr[1][0] = { -6.83115e-02, 3.57802e-02};
2249  moduleHGNonLinCorr[1][1] = { -1.08162e-01, -1.91413e-01};
2250  moduleHGNonLinCorr[1][2] = { -7.82514e-02, -1.21218e-01};
2251  moduleHGNonLinCorr[1][3] = { -2.34354e-02, -2.52033e-01};
2252 
2253  moduleLGNonLinCorr = {{ {{{0},
2254  {0},
2255  {0},
2256  {0}}},
2257  {{{0},
2258  {0},
2259  {0},
2260  {0}}} }};
2261 
2262  if (m_doNonLinCorr) m_zdcDataAnalyzer_40MHz->SetNonlinCorrParams(500, 1000, moduleHGNonLinCorr, moduleLGNonLinCorr);
2263  m_zdcDataAnalyzer_40MHz->SetSaveFitFunc(false);
2264 
2265 }

◆ initialize80MHz()

void ZDC::ZdcAnalysisTool::initialize80MHz ( )

Definition at line 2267 of file ZdcAnalysisTool.cxx.

2268 {
2269  // We have a complete configuration and so we override all of the default parameters
2270  //
2271 
2272  m_peak2ndDerivMinSamples = {{{{3, 2, 3, 2}},
2273  {{2, 2, 2, 2}}
2274  }
2275  };
2276 
2277  m_peak2ndDerivMinThresholdsHG = {{{{ -8, -8, -8, -8}},
2278  {{ -8, -8, -8, -8}}
2279  }
2280  };
2281 
2282  m_peak2ndDerivMinThresholdsLG = {{{{ -4, -4, -4, -4}},
2283  {{ -4, -4, -4, -4}}
2284  }
2285  };
2286 
2287  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
2288  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
2289  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{950, 950, 950, 950}}, {{950, 950, 950, 950}}}};
2290 
2291  // Set Tau and nominal timing offsets
2292  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
2293 
2294  bool fixTau1 = true;
2295  bool fixTau2 = true;
2296 
2297  for (size_t side : {0, 1}) {
2298  for (size_t module : {0, 1, 2, 3}) {
2299  fixTau1Arr[side][module] = fixTau1;
2300  fixTau2Arr[side][module] = fixTau2;
2301  }
2302  }
2303 
2304  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{{3.9, 3.4, 4.1, 4.2}},
2305  {{4.2, 3.6, 3.3, 3.4}}
2306  }
2307  };
2308 
2309  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{{20.0, 20.4, 18.9, 20.8}},
2310  {{19.1, 21.9, 22.6, 23.4}}
2311  }
2312  };
2313 
2314  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{{44.24, 40.35, 49.3, 36.0}},
2315  {{36.0, 31.1, 40.75, 30.5}}
2316  }
2317  };
2318 
2319  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{{42.65, 38.5, 47.4, 34}},
2320  {{33.7, 29.9, 39.0, 29.3}}
2321  }
2322  };
2323 
2324  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
2325  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutLG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
2326  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
2327  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
2328  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
2329  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
2330 
2331  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
2332 
2333  slewingParamsHG[0][0] = {0, -6.5e-2, 2.85e-2, -2.83e-3};
2334  slewingParamsHG[0][1] = {0, -5.5e-2, 5.13e-2, 5.6e-3};
2335  slewingParamsHG[0][2] = {0, -1.45e-3, 9.3e-2, 3.9e-3};
2336  slewingParamsHG[0][3] = {0, -2.36e-2, 8.3e-2, 1.1e-3};
2337 
2338  slewingParamsHG[1][0] = {0, -6.5e-2, 4.84e-2, -3.7e-3};
2339  slewingParamsHG[1][1] = {0, 1.34e-2, 6.57e-2, 5.37e-3};
2340  slewingParamsHG[1][2] = {0, -5.37e-2, 3.49e-2, 3.8e-3};
2341  slewingParamsHG[1][3] = {0, -3.3e-2, 3.9e-2, 2.2e-3};
2342 
2343  slewingParamsLG[0][0] = {0, -9.6e-2, 4.39e-2, 2.93e-3 };
2344  slewingParamsLG[0][1] = {0, -5.0e-2, 14.9e-2, 20.6e-3 };
2345  slewingParamsLG[0][2] = {0, -4.4e-2, 5.3e-2, 0, };
2346  slewingParamsLG[0][3] = {0, -9.90e-2, 4.08e-2, 0, };
2347 
2348  slewingParamsLG[1][0] = {0, -8.7e-2, 4.2e-2, -3.2e-3 };
2349  slewingParamsLG[1][1] = {0, -3.26e-2, 3.84e-2, -2.32e-3};
2350  slewingParamsLG[1][2] = {0, -26.8e-2, -2.64e-2, -5.3e-3 };
2351  slewingParamsLG[1][3] = {0, -13.2e-2, 0.45e-2, -2.4e-3 };
2352 
2353 
2354  m_zdcDataAnalyzer_80MHz.reset (new ZDCDataAnalyzer(MakeMessageFunction(), 7 , 12.5, 0, "FermiExp", m_peak2ndDerivMinSamples,
2355  m_peak2ndDerivMinThresholdsHG, m_peak2ndDerivMinThresholdsLG, m_lowGainMode));
2356 
2357  m_zdcDataAnalyzer_80MHz->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
2358  m_zdcDataAnalyzer_80MHz->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
2359  m_zdcDataAnalyzer_80MHz->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
2360  m_zdcDataAnalyzer_80MHz->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
2361  slewingParamsHG, slewingParamsLG);
2362 
2363  std::array<std::array<std::vector<float>, 4>, 2> moduleHGNonLinCorr, moduleLGNonLinCorr;
2364  moduleHGNonLinCorr[0][0] = { -3.76800e-02, 4.63597e-02};
2365  moduleHGNonLinCorr[0][1] = { -1.02185e-01, -1.17548e-01};
2366  moduleHGNonLinCorr[0][2] = { -8.78451e-02, -1.52174e-01};
2367  moduleHGNonLinCorr[0][3] = { -1.04835e-01, -1.96514e-01};
2368  moduleHGNonLinCorr[1][0] = { -6.83115e-02, 3.57802e-02};
2369  moduleHGNonLinCorr[1][1] = { -1.08162e-01, -1.91413e-01};
2370  moduleHGNonLinCorr[1][2] = { -7.82514e-02, -1.21218e-01};
2371  moduleHGNonLinCorr[1][3] = { -2.34354e-02, -2.52033e-01};
2372 
2373  moduleLGNonLinCorr = {{ {{{0},
2374  {0},
2375  {0},
2376  {0}}},
2377  {{{0},
2378  {0},
2379  {0},
2380  {0}}} }};
2381 
2382  if (m_doNonLinCorr) m_zdcDataAnalyzer_80MHz->SetNonlinCorrParams(500, 1000, moduleHGNonLinCorr, moduleLGNonLinCorr);
2383  m_zdcDataAnalyzer_80MHz->SetSaveFitFunc(false);
2384 }

◆ initializeDecorations()

void ZDC::ZdcAnalysisTool::initializeDecorations ( )

Definition at line 2591 of file ZdcAnalysisTool.cxx.

2592 {
2593 
2594 }

◆ initializeDefault()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializeDefault ( )
private

Definition at line 1782 of file ZdcAnalysisTool.cxx.

1783 {
1784  // We rely completely on the default parameters specified in the job properties to control:
1785  // # samples
1786  // frequency (more precisely, time/sample)
1787  // which sample to use as the pre-sample
1788  // where to expact the maxim of the peak (min 2nd derivative)
1789  // thresholds on the 2nd derivative for valid pulses
1790  // whether to fix the tau values in the pulse fitting
1791  // the default tau values
1792  // the nominal T0
1793  // delta T and chisq/amp cuts
1794  //
1795  // For now, we continue to use hard-coded values for the maximum and minimum ADC values
1796  // For now we also use the FermiExp pulse model.
1797  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
1798  ZDCDataAnalyzer::ZDCModuleFloatArray tau1{}, tau2{}, t0{};
1799  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
1800  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
1801  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1802 
1803  for (size_t side : {0, 1}) {
1804  for (size_t module : {0, 1, 2, 3}) {
1805  fixTau1Arr[side][module] = m_fixTau1;
1806  fixTau2Arr[side][module] = m_fixTau2;
1807  tau1[side][module] = m_tau1;
1808  tau2[side][module] = m_tau2;
1809 
1810  peak2ndDerivMinSamples[side][module] = m_peakSample;
1811  peak2ndDerivMinThresholdsHG[side][module] = -m_Peak2ndDerivThresh;
1812  peak2ndDerivMinThresholdsLG[side][module] = -m_Peak2ndDerivThresh / 2;
1813 
1814  t0[side][module] = m_t0;
1815  deltaT0CutLow[side][module] = -m_deltaTCut;
1816  deltaT0CutHigh[side][module] = m_deltaTCut;
1817  chisqDivAmpCut[side][module] = m_ChisqRatioCut;
1818  }
1819  }
1820 
1821  ATH_MSG_DEBUG( "Default: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1822 
1823  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1824  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1825  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1826 
1827  // Construct the data analyzer
1828  //
1829  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), m_numSample, m_deltaTSample, m_presample, "FermiExp", peak2ndDerivMinSamples,
1830  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1831 
1832  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1833  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0, t0);
1834  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1835 
1836  if (m_combineDelay) {
1837  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
1838 
1839  zdcDataAnalyzer->enableDelayed(m_delayDeltaT, defaultPedestalShifts);
1840  }
1841 
1842  return zdcDataAnalyzer;
1843 }

◆ initializeInjectorPbPb2024()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializeInjectorPbPb2024 ( )
private

Definition at line 1444 of file ZdcAnalysisTool.cxx.

1445 {
1446  // Key configuration parameters needed for the data analyzer construction
1447  //
1448  m_deltaTSample = 3.125;
1449  m_numSample = 24;
1450 
1451  const int deriv2ndThreshDSHG = -25;
1452  const int deriv2ndThreshDSLG = -10;
1453  const unsigned int peakSample = 10;
1454 
1455  const float deltaTcutLow = -10;
1456  const float deltaTcutHigh = 10;
1457  const float chisqDivAmpCutHGVal = 30;
1458  const float chisqDivAmpCutLGVal = 50;
1459 
1460  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
1461  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
1462 
1463  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
1464  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
1465  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
1466 
1467  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.8, 1.8, 1.8, 1.8}, {1.8, 1.8, 1.8, 1.8}}};
1468 
1469  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{5.5, 5.5, 5.5, 5.5}, {5.5, 5.5, 5.5, 5.5}}};
1470 
1471  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{33.25, 33, 29.5, 33}, {31.5, 32.5, 32, 32.25}}};
1472  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{30.5, 30, 26.75, 30}, {29.5, 32.5, 29.5, 29}}};
1473 
1474  for (size_t side : {0, 1}) {
1475  for (size_t module : {0, 1, 2, 3}) {
1476  fixTau1Arr[side][module] = false;
1477  fixTau2Arr[side][module] = true;
1478 
1479  peak2ndDerivMinSamples[side][module] = peakSample;
1480  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
1481  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
1482 
1483  deltaT0CutLow[side][module] = deltaTcutLow;
1484  deltaT0CutHigh[side][module] = deltaTcutHigh;
1485  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
1486  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
1487  }
1488  }
1489 
1490  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1491 
1492  // Construct the data analyzer
1493  //
1494  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
1495  m_numSample, m_deltaTSample,
1496  m_presample, "FermiExpLHCf",
1497  peak2ndDerivMinSamples,
1498  peak2ndDerivMinThresholdsHG,
1499  peak2ndDerivMinThresholdsLG,
1500  ZDCPulseAnalyzer::LGModeRefitLG));
1501 
1502  zdcDataAnalyzer->set2ndDerivStep(2);
1503  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
1504 
1505  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
1506  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{10, 10, 10, 10}, {10, 10, 10, 10}}};
1507 
1508  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
1509 
1510  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
1511  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
1512  //
1513  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{2.0, 2.0, 2.0, 2.0}, {2.0, 2.0, 2.0, 2.0}}};
1514  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{15.0, 15.0, 15.0, 15.0}, {15.0, 15.0, 15.0, 15.0}}};
1515 
1516  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
1517 
1518  // Now set cuts and default fit parameters
1519  //
1520  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
1521  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
1522  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
1523 
1524  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1525  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1526  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1527 
1528  // Set the amplitude fit range limits
1529  //
1530  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
1531 
1532  return zdcDataAnalyzer;
1533 }

◆ initializeInjectorpOOONeNe2025()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializeInjectorpOOONeNe2025 ( )
private

Definition at line 1535 of file ZdcAnalysisTool.cxx.

1536 {
1537  // Key configuration parameters needed for the data analyzer construction
1538  //
1539  m_deltaTSample = 3.125;
1540  m_numSample = 24;
1541 
1542  const int deriv2ndThreshDSHG = -25;
1543  const int deriv2ndThreshDSLG = -10;
1544  const unsigned int peakSample = 10;
1545 
1546  const float deltaTcutLow = -10;
1547  const float deltaTcutHigh = 10;
1548  const float chisqDivAmpCutHGVal = 30;
1549  const float chisqDivAmpCutLGVal = 50;
1550 
1551  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
1552  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
1553 
1554  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
1555  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
1556  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
1557 
1558  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.8, 1.8, 1.8, 1.8}, {1.8, 1.8, 1.8, 1.8}}};
1559 
1560  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{5.5, 5.5, 5.5, 5.5}, {5.5, 5.5, 5.5, 5.5}}};
1561 
1562  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{33.25, 33, 29.5, 33}, {31.5, 32.5, 32, 32.25}}};
1563  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{30.5, 30, 26.75, 30}, {29.5, 32.5, 29.5, 29}}};
1564 
1565  for (size_t side : {0, 1}) {
1566  for (size_t module : {0, 1, 2, 3}) {
1567  fixTau1Arr[side][module] = false;
1568  fixTau2Arr[side][module] = true;
1569 
1570  peak2ndDerivMinSamples[side][module] = peakSample;
1571  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
1572  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
1573 
1574  deltaT0CutLow[side][module] = deltaTcutLow;
1575  deltaT0CutHigh[side][module] = deltaTcutHigh;
1576  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
1577  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
1578  }
1579  }
1580 
1581  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1582 
1583  // Construct the data analyzer
1584  //
1585  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
1586  m_numSample, m_deltaTSample,
1587  m_presample, "FermiExpLHCf",
1588  peak2ndDerivMinSamples,
1589  peak2ndDerivMinThresholdsHG,
1590  peak2ndDerivMinThresholdsLG,
1591  ZDCPulseAnalyzer::LGModeRefitLG));
1592 
1593  zdcDataAnalyzer->set2ndDerivStep(2);
1594  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
1595 
1596  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
1597  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{4,4,4,4}, {4,4,4,4}}};
1598 
1599  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 4 applied to LG ADC, 1 to HG ADC values
1600 
1601  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
1602  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
1603  //
1604  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{2.0, 2.0, 2.0, 2.0}, {2.0, 2.0, 2.0, 2.0}}};
1605  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{15.0, 15.0, 15.0, 15.0}, {15.0, 15.0, 15.0, 15.0}}};
1606 
1607  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
1608 
1609  // Now set cuts and default fit parameters
1610  //
1611  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
1612  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
1613  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
1614 
1615  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1616  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1617  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1618 
1619  // Set the amplitude fit range limits
1620  //
1621  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
1622 
1623  return zdcDataAnalyzer;
1624 }

◆ initializeInjectorpp2024()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializeInjectorpp2024 ( )
private

Definition at line 1318 of file ZdcAnalysisTool.cxx.

1319 {
1320  // Key configuration parameters needed for the data analyzer construction
1321  //
1322  m_deltaTSample = 3.125;
1323  m_numSample = 24;
1324 
1325  const int deriv2ndThreshDSHG = -10;
1326  const int deriv2ndThreshDSLG = -10;
1327  const unsigned int peakSample = 10;
1328 
1329  const float deltaTcutLow = -50;
1330  const float deltaTcutHigh = 50;
1331  const float chisqDivAmpCutHGVal = 30;
1332  const float chisqDivAmpCutLGVal = 50;
1333 
1334  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
1335  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
1336 
1337  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
1338  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
1339  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
1340 
1341  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.2, 1.4, 1.3, 1.2},
1342  {1.35, 1.4, 1.3, 1.1}}};
1343 
1344  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
1345 
1346  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
1347  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{28, 28, 28, 28}, {28, 28, 28, 28}}};
1348 
1349  for (size_t side : {0, 1}) {
1350  for (size_t module : {0, 1, 2, 3}) {
1351  fixTau1Arr[side][module] = false;
1352  fixTau2Arr[side][module] = true;
1353 
1354  peak2ndDerivMinSamples[side][module] = peakSample;
1355  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
1356  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
1357 
1358  deltaT0CutLow[side][module] = deltaTcutLow;
1359  deltaT0CutHigh[side][module] = deltaTcutHigh;
1360  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
1361  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
1362  }
1363  }
1364 
1365  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1366 
1367  // Construct the data analyzer
1368  //
1369  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
1370  m_numSample, m_deltaTSample,
1371  m_presample, "FermiExpLHCf",
1372  peak2ndDerivMinSamples,
1373  peak2ndDerivMinThresholdsHG,
1374  peak2ndDerivMinThresholdsLG,
1375  ZDCPulseAnalyzer::LGModeRefitLG));
1376  zdcDataAnalyzer->set2ndDerivStep(2);
1377  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(10);
1378 
1379  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
1380  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
1381 
1382  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
1383 
1384  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
1385  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
1386  //
1387  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
1388  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{10.0, 10.0, 10.0, 10.0}, {10.0, 10.0, 10.0, 10.0}}};
1389 
1390  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
1391 
1392  // Now set cuts and default fit parameters
1393  //
1394  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
1395  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
1396  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
1397 
1398  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1399  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1400  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1401 
1402  // Turn on exclusion of early and late samples to address OOT pileup
1403  //
1404  zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
1405  zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
1406 
1407 
1408  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
1409  timeCorrCoefficHG[0][0] = {0.07, -0.020672, 0.070206, 0.004961, -0.010821, -0.001835};
1410  timeCorrCoefficHG[0][1] = {0.04, -0.012961, 0.008204, 0.010771, 0.011593, 0.002045};
1411  timeCorrCoefficHG[0][2] = {0.04, 0.017393, 0.017597, 0.003736, -0.001696, -0.000465};
1412  timeCorrCoefficHG[0][3] = {0.04, 0.018463, 0.009862, -0.000277, -0.000268, 0.000192};
1413 
1414  timeCorrCoefficHG[1][0] = {0.13, -0.106068, 0.078153, 0.034479, -0.004964, -0.001688};
1415  timeCorrCoefficHG[1][1] = {0.03, -0.007518, 0.008937, 0.015319, 0.012290, 0.001889};
1416  timeCorrCoefficHG[1][2] = {-0.01, 0.006711, -0.001652, -0.004223, -0.000573, 0.000161};
1417  timeCorrCoefficHG[1][3] = {0.015, 0.017993, 0.006339, 0.003122, 0.002980, 0.000735};
1418 
1419  // +++ BAC 07-26-24
1420  //
1421  // The +3.25 in the constant t0 correction term accounts for a change in the nominal T0 from 31.25 to 28
1422  // made at the same time to match the timing shift of the LG channels
1423  //
1424  // ---
1425  timeCorrCoefficLG[0][0] = {0.035f+3.25f, -0.126189, 0.022724, 0.039116, -0.098255};
1426  timeCorrCoefficLG[0][1] = {0.022f+3.25f, -0.165988, -0.014125, 0.057323, -0.205109};
1427  timeCorrCoefficLG[0][2] = {0.01f+3.25f, -0.136087, -0.007248, -0.014452, -0.060469};
1428  timeCorrCoefficLG[0][3] = {0.0f+3.25f, -0.131067, 0.025579, 0.059994, -0.065595};
1429 
1430  timeCorrCoefficLG[1][0] = {0.076f+3.25f, -0.300587, -0.041827, 0.641108, -0.594157};
1431  timeCorrCoefficLG[1][1] = {0.057f+3.25f, -0.223443, -0.125013, -0.176900, 0.348081};
1432  timeCorrCoefficLG[1][2] = {0.015f+3.25f, -0.141721, 0.023936, 0.099657, -0.188526};
1433  timeCorrCoefficLG[1][3] = {0.01f+3.25f, -0.152589, 0.016122, -0.086580, 0.563625};
1434 
1435  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
1436 
1437  // Set the amplitude fit range limits
1438  //
1439  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
1440 
1441  return zdcDataAnalyzer;
1442 }

◆ initializeLHCf2022()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializeLHCf2022 ( )
private

Definition at line 201 of file ZdcAnalysisTool.cxx.

202 {
203 
204  m_deltaTSample = 3.125;
205  m_numSample = 24;
206 
207  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{0, 9, 9, 9}, {0, 9, 10, 8}}};
208 
209  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
210  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
211  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
212 
213  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{0, 1.1, 1.1, 1.1},
214  {0, 1.1, 1.1, 1.1}}};
215 
216  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{6, 5, 5, 5}, {5.5, 5.5, 5.5, 5.5}}};
217 
218  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{0, 26.3, 26.5, 26.8}, {32, 32, 32, 32}}};
219 
220  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{0, 31.1, 28.1, 27.0}, {0, 26.6, 26.3, 25.3}}};
221 
222  for (size_t side : {0, 1}) {
223  for (size_t module : {0, 1, 2, 3}) {
224  fixTau1Arr[side][module] = true;
225  fixTau2Arr[side][module] = false;
226 
227  peak2ndDerivMinThresholdsHG[side][module] = -35;
228  peak2ndDerivMinThresholdsLG[side][module] = -16;
229 
230  deltaT0CutLow[side][module] = -10;
231  deltaT0CutHigh[side][module] = 10;
232  chisqDivAmpCut[side][module] = 20;
233  }
234  }
235 
236  ATH_MSG_DEBUG( "LHCF2022: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
237 
238  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
239  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
240  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
241 
242  // For the LHCf run, use low gain samples
243  //
244  m_lowGainMode = ZDCPulseAnalyzer::LGModeForceLG;
245 
246  // Construct the data analyzer
247  //
248  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
249  m_numSample, m_deltaTSample,
250  m_presample, "FermiExpLHCf",
251  peak2ndDerivMinSamples,
252  peak2ndDerivMinThresholdsHG,
253  peak2ndDerivMinThresholdsLG,
254  m_lowGainMode));
255 
256  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(2);
257  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
258  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
259  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
260 
261  zdcDataAnalyzer->SetGainFactorsHGLG(0.1, 1); // a gain adjustment of unity applied to LG ADC, 0.1 to HG ADC values
262 
263  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{2, 2, 2, 2}, {2, 2, 2, 2}}};
264  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{20, 20, 20, 20}, {20, 20, 20, 20}}};
265 
266  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
267 
268  // Enable two-pass analysis
269  //
270  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-12, -12, -12, -12},
271  {-12, -12, -12, -12}}};
272 
273  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
274  {-8, -8, -8, -8}}};
275 
276  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
277 
278  // Set the amplitude fit range limits
279  //
280  zdcDataAnalyzer->SetFitMinMaxAmpValues(5, 2, 5000, 5000);
281 
282  // disable EM module on each side
283  zdcDataAnalyzer->disableModule(0, 0);
284  zdcDataAnalyzer->disableModule(1, 0);
285 
286  return zdcDataAnalyzer;
287 
288 }

◆ initializeMonteCarloPbPb2023()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializeMonteCarloPbPb2023 ( )
private

Definition at line 1626 of file ZdcAnalysisTool.cxx.

1627 {
1628  // Key configuration parameters needed for the data analyzer construction
1629  //
1630  m_deltaTSample = 3.125;
1631  m_numSample = 24;
1632 
1633  const int deriv2ndThreshDSHG = -25;
1634  const int deriv2ndThreshDSLG = -10;
1635  const unsigned int peakSample = 10;
1636 
1637  const float deltaTcutLow = -10;
1638  const float deltaTcutHigh = 10;
1639  const float chisqDivAmpCutHGVal = 30;
1640  const float chisqDivAmpCutLGVal = 50;
1641 
1642  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
1643  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
1644 
1645  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
1646  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
1647  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
1648 
1649  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.1, 1.1, 1.1, 1.1},
1650  {1.1, 1.1, 1.1, 1.1}}};
1651 
1652  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
1653 
1654  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
1655  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
1656 
1657  for (size_t side : {0, 1}) {
1658  for (size_t module : {0, 1, 2, 3}) {
1659  fixTau1Arr[side][module] = false;
1660  fixTau2Arr[side][module] = false;
1661 
1662  peak2ndDerivMinSamples[side][module] = peakSample;
1663  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
1664  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
1665 
1666  deltaT0CutLow[side][module] = deltaTcutLow;
1667  deltaT0CutHigh[side][module] = deltaTcutHigh;
1668  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
1669  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
1670  }
1671  }
1672 
1673  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1674 
1675  // Construct the data analyzer
1676  //
1677  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
1678  m_numSample, m_deltaTSample,
1679  m_presample, "FermiExpLHCf",
1680  peak2ndDerivMinSamples,
1681  peak2ndDerivMinThresholdsHG,
1682  peak2ndDerivMinThresholdsLG,
1683  m_lowGainMode));
1684  zdcDataAnalyzer->set2ndDerivStep(2);
1685  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
1686 
1687  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1, 1, 1, 1},{1, 1, 1, 1}}};
1688  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{10.,10.,10.,10.},{10.,10.,10.,10.}}}; // apply constant factor of 10 to high gain data
1689 
1690  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
1691 
1692  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
1693  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
1694  //
1695  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
1696  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{1.5, 1.7, 3, 1.7}, {1.7, 1.6, 2.2, 1.8}}};
1697 
1698  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
1699 
1700  // Now set cuts and default fit parameters
1701  //
1702  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
1703  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
1704  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
1705 
1706  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1707  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1708  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1709 
1710  // Enable two-pass analysis
1711  //
1712  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-10, -10, -10, -10},
1713  {-10, -10, -10, -10}}};
1714 
1715  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
1716  {-8, -8, -8, -8}}};
1717 
1718  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
1719 
1720  // Turn on exclusion of early and late samples to address OOT pileup
1721  //
1722  //zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
1723  //zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
1724 
1725  // Set up non-linear corrections for the ZDC
1726  //
1727  std::array<std::array<std::vector<float>, 4>, 2> nonLinearCorrCoefficHG, nonLinearCorrCoefficLG;
1728 
1729  nonLinearCorrCoefficHG = {{ {{{0},
1730  {0},
1731  {0},
1732  {0}}},
1733  {{{0},
1734  {0},
1735  {0},
1736  {0}}} }};
1737 
1738  // For now we don't use corrections on the LG as it's much harder to measure them
1739  //
1740  nonLinearCorrCoefficLG = {{ {{{0},
1741  {0},
1742  {0},
1743  {0}}},
1744  {{{0},
1745  {0},
1746  {0},
1747  {0}}} }};
1748 
1749  if (m_doNonLinCorr)
1750  zdcDataAnalyzer->SetNonlinCorrParams(0, 1000, nonLinearCorrCoefficHG, nonLinearCorrCoefficLG);
1751 
1752  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
1753  timeCorrCoefficHG[0][0] = {};
1754  timeCorrCoefficHG[0][1] = {};
1755  timeCorrCoefficHG[0][2] = {};
1756  timeCorrCoefficHG[0][3] = {};
1757 
1758  timeCorrCoefficHG[1][0] = {};
1759  timeCorrCoefficHG[1][1] = {};
1760  timeCorrCoefficHG[1][2] = {};
1761  timeCorrCoefficHG[1][3] = {};
1762 
1763  timeCorrCoefficLG[0][0] = {};
1764  timeCorrCoefficLG[0][1] = {};
1765  timeCorrCoefficLG[0][2] = {};
1766  timeCorrCoefficLG[0][3] = {};
1767 
1768  timeCorrCoefficLG[1][0] = {};
1769  timeCorrCoefficLG[1][1] = {};
1770  timeCorrCoefficLG[1][2] = {};
1771  timeCorrCoefficLG[1][3] = {};
1772 
1773  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
1774 
1775  // Set the amplitude fit range limits
1776  //
1777  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
1778 
1779  return zdcDataAnalyzer;
1780 }

◆ initializeOONeNe2025()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializeOONeNe2025 ( )
private

Definition at line 804 of file ZdcAnalysisTool.cxx.

805 {
806  // Key configuration parameters needed for the data analyzer construction
807  //
808  m_deltaTSample = 3.125;
809  m_numSample = 24;
810 
811  const int deriv2ndThreshDSHG = -45;
812  const int deriv2ndThreshDSLG = -10;
813  const unsigned int peakSample = 10;
814 
815  const float deltaTcutLow = -10;
816  const float deltaTcutHigh = 10;
817  const float chisqDivAmpCutHGVal = 30;
818  const float chisqDivAmpCutLGVal = 50;
819 
820  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
821  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
822 
823  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
824  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
825  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
826 
827  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.2, 1.4, 1.3, 1.2},
828  {1.35, 1.4, 1.3, 1.1}}};
829 
830  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
831 
832  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.5, 31.5, 29.5, 30.5}, {34.5, 33.0, 33, 34.0}}};
833  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{32.25, 32.0, 30.5, 30.5}, {32.4, 33.5, 30.5, 31.4}}};
834 
835  for (size_t side : {0, 1}) {
836  for (size_t module : {0, 1, 2, 3}) {
837  fixTau1Arr[side][module] = true;
838  fixTau2Arr[side][module] = false;
839 
840  peak2ndDerivMinSamples[side][module] = peakSample;
841  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
842  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
843 
844  deltaT0CutLow[side][module] = deltaTcutLow;
845  deltaT0CutHigh[side][module] = deltaTcutHigh;
846  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
847  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
848  }
849  }
850 
851  ATH_MSG_DEBUG( "PbPb2024: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
852 
853  // Construct the data analyzer
854  //
855  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
856  m_numSample, m_deltaTSample,
857  m_presample, "FermiExpLHCf",
858  peak2ndDerivMinSamples,
859  peak2ndDerivMinThresholdsHG,
860  peak2ndDerivMinThresholdsLG,
861  ZDCPulseAnalyzer::LGModeRefitLG));
862  zdcDataAnalyzer->set2ndDerivStep(1);
863  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
864 
865  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1, 1, 1, 1},{1, 1, 1, 1.0}}};
866  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{4,4,4,4}, {4,4,4,4}}};
867 
868  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 4 applied to LG ADC, 1 to HG ADC values
869 
870  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
871  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
872  //
873  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.5, 1.5, 1.5, 1.5}, {1.5, 1.5, 1.5, 1.5}}};
874  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{10, 10, 10, 10}, {10, 10, 10, 10}}};
875 
876  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
877 
878  // Now set cuts and default fit parameters
879  //
880  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
881  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
882  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
883 
884  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
885  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
886  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
887 
888  // Enable two-pass analysis
889  //
890  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-30, -30, -30, -30},
891  {-30, -30, -30, -30},}};
892 
893  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
894  {-8, -8, -8, -8}}};
895 
896  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
897 
898  // Turn on exclusion of early and late samples to address OOT pileup
899  //
900  zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
901  zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
902 
903  // Set up non-linear corrections for the ZDC
904  //
905  std::array<std::array<std::vector<float>, 4>, 2> nonLinearCorrCoefficHG, nonLinearCorrCoefficLG;
906 
907  nonLinearCorrCoefficHG[0][0] = {-0.0225871, 0.00702802, 0.00201155, -0.00675293, 0.00186212} ;
908  nonLinearCorrCoefficHG[0][1] = {-0.0155562, 0.00594092, 0.00382112, -0.00665466, 0.00143384} ;
909  nonLinearCorrCoefficHG[0][2] = {-0.0313621, 0.0134528, 0.00529013, -0.0111751, 0.0029913} ;
910  nonLinearCorrCoefficHG[0][3] = {-0.025108, 0.00301898, 0.022472, -0.0204288, 0.00453215} ;
911  nonLinearCorrCoefficHG[1][0] = {-0.0266648, 0.0106792, -0.00939959, 0.000833011, 0.000199051} ;
912  nonLinearCorrCoefficHG[1][1] = {-0.0246541, 0.000327376, 0.00754946, -0.00710273, 0.00136899} ;
913  nonLinearCorrCoefficHG[1][2] = {-0.0175283, 0.0127954, 0.000235749, -0.00769698, 0.00221995} ;;
914  nonLinearCorrCoefficHG[1][3] = {-0.0279931, 0.0188122, 0.0126234, -0.0169907, 0.00398826} ;
915 
916 
917  // Remove nonlinear corrections while we study the injector pulse
918  nonLinearCorrCoefficHG = {{ {{{0},
919  {0},
920  {0},
921  {0}}},
922  {{{0},
923  {0},
924  {0},
925  {0}}} }};
926 
927  //
928  // We are disabling the old FADC correction moving forward
929  if (m_doNonLinCorr)
930  zdcDataAnalyzer->SetNonlinCorrParams(1000, 1000, nonLinearCorrCoefficHG, nonLinearCorrCoefficLG);
931 
932  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
933  timeCorrCoefficHG[0][0] = {0.07, -0.020672, 0.070206, 0.004961, -0.010821, -0.001835};
934  timeCorrCoefficHG[0][1] = {0.04, -0.012961, 0.008204, 0.010771, 0.011593, 0.002045};
935  timeCorrCoefficHG[0][2] = {0.04, 0.017393, 0.017597, 0.003736, -0.001696, -0.000465};
936  timeCorrCoefficHG[0][3] = {0.04, 0.018463, 0.009862, -0.000277, -0.000268, 0.000192};
937 
938  timeCorrCoefficHG[1][0] = {0.13, -0.106068, 0.078153, 0.034479, -0.004964, -0.001688};
939  timeCorrCoefficHG[1][1] = {0.03, -0.007518, 0.008937, 0.015319, 0.012290, 0.001889};
940  timeCorrCoefficHG[1][2] = {-0.01, 0.006711, -0.001652, -0.004223, -0.000573, 0.000161};
941  timeCorrCoefficHG[1][3] = {0.015, 0.017993, 0.006339, 0.003122, 0.002980, 0.000735};
942 
943  // +++ BAC 07-26-24
944  //
945  // The +3.25 in the constant t0 correction term accounts for a change in the nominal T0 from 31.25 to 28
946  // made at the same time to match the timing shift of the LG channels
947  //
948  // ---
949  timeCorrCoefficLG[0][0] = {0.035f+3.25f, -0.126189, 0.022724, 0.039116, -0.098255};
950  timeCorrCoefficLG[0][1] = {0.022f+3.25f, -0.165988, -0.014125, 0.057323, -0.205109};
951  timeCorrCoefficLG[0][2] = {0.01f+3.25f, -0.136087, -0.007248, -0.014452, -0.060469};
952  timeCorrCoefficLG[0][3] = {0.0f+3.25f, -0.131067, 0.025579, 0.059994, -0.065595};
953 
954  timeCorrCoefficLG[1][0] = {0.076f+3.25f, -0.300587, -0.041827, 0.641108, -0.594157};
955  timeCorrCoefficLG[1][1] = {0.057f+3.25f, -0.223443, -0.125013, -0.176900, 0.348081};
956  timeCorrCoefficLG[1][2] = {0.015f+3.25f, -0.141721, 0.023936, 0.099657, -0.188526};
957  timeCorrCoefficLG[1][3] = {0.01f+3.25f, -0.152589, 0.016122, -0.086580, 0.563625};
958 
959  // Commenting out the timing correlation for PbPb2024: re-calibraton needed
960  // zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
961 
962  // Set the amplitude fit range limits
963  //
964  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
965 
966 
967  /*
968 {{
969  {{{{0.3, 1, -0.00753349, 0.882218, 0.019739, 1.0803}},{{0.3, 1, 0.0181165, 0.620646, -0.171213, 2.2143}},{{0.25, 1, -0.108547, 0.106, -1.3594, 4.1509}}}},
970  {{{{0.3, 1, -0.00753349, 0.882218, 0.019739, 1.0803}},{{0.3, 1, 0.0181165, 0.620646, -0.171213, 2.2143}},{{0.25, 1, -0.108547, 0.106, -1.3594, 4.1509}}}}
971  }};
972  */
973 
974  std::array< std::array< std::array<float,6>, 3>, 2> nlCalib = {{
975  {{ {{0.3, 1, -0.00753349, 0.882218, 0.019739, 1.0803}},{{0.3, 1, 0.0181165, 0.620646, -0.171213, 2.2143}},{{0.25, 1, -0.108547, 0.106, -1.3594, 4.1509}} }},
976  {{ {{0.3, 1, -0.00753349, 0.882218, 0.019739, 1.0803}},{{0.3, 1, 0.0181165, 0.620646, -0.171213, 2.2143}},{{0.25, 1, -0.108547, 0.106, -1.3594, 4.1509}} }}
977  }};
978 
979  zdcDataAnalyzer->SetNLcalibParams(nlCalib);
980 
981  return zdcDataAnalyzer;
982 }

◆ initializePbPb2015G4()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializePbPb2015G4 ( )
private

Definition at line 1845 of file ZdcAnalysisTool.cxx.

1846 {
1847  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
1848  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
1849  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
1850  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
1851  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1852 
1853  const int peakSample = 4;
1854  const float peak2ndDerivThreshHG = -12;
1855  const float peak2ndDerivThreshLG = -10;
1856  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{4.000, 4.000, 4.000, 4.000},
1857  {4.000, 4.000, 4.000, 4.000}}};
1858  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{25.36, 25.05, 25.43, 25.60},
1859  {25.11, 25.08, 25.18, 25.48}}};
1860 
1861  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{57.31, 57.28, 57.30, 57.28},
1862  {57.28, 57.29, 57.31, 57.33}}};
1863  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{57.31, 57.28, 57.30, 57.28},
1864  {57.28, 57.29, 57.31, 57.33}}};
1865 
1866  // Delta T0 cut
1867  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{-10, -10, -10, -10}, {-10, -10, -10, -10}}};
1868  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{ 10, 10, 10, 10}, { 10, 10, 10, 10}}};
1869  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{-10, -10, -10, -10}, {-10, -10, -10, -10}}};
1870  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{ 10, 10, 10, 10}, { 10, 10, 10, 10}}};
1871 
1872  for (size_t side : {0, 1}) {
1873  for (size_t module : {0, 1, 2, 3}) {
1874  fixTau1Arr[side][module] = true;
1875  fixTau2Arr[side][module] = true;
1876 
1877  peak2ndDerivMinSamples[side][module] = peakSample;
1878  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
1879  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
1880 
1881  chisqDivAmpCut[side][module] = 15;
1882  }
1883  }
1884 
1885  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{ 800, 800, 800, 800}}, {{ 800, 800, 800, 800}}}};
1886  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{ 10, 10, 10, 10}}, {{ 10, 10, 10, 10}}}};
1887  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1888 
1889  m_deltaTSample = 12.5;
1890 
1891  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), 7, m_deltaTSample, 0, "FermiExp", peak2ndDerivMinSamples,
1892  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1893 
1894  // Open up tolerances on the position of the peak for now
1895  //
1896  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
1897 
1898  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1899  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
1900  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1901 
1902  zdcDataAnalyzer->SetFitTimeMax(85);
1903  zdcDataAnalyzer->SetSaveFitFunc(false);
1904 
1905  return zdcDataAnalyzer;
1906 }

◆ initializePbPb2018()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializePbPb2018 ( )
private

Definition at line 2020 of file ZdcAnalysisTool.cxx.

2021 {
2022  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
2023  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{}, peak2ndDerivMinRepassHG{}, peak2ndDerivMinRepassLG{};
2024  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
2025  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
2026 
2027  static constexpr int peakSample = 5;
2028  static constexpr float peak2ndDerivThreshHG = -35;
2029  static constexpr float peak2ndDerivThreshLG = -20;
2030  static constexpr float peak2ndDerivRepassHG = -10;
2031  static constexpr float peak2ndDerivRepassLG = -6;
2032 
2033  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{3.877, 3.998, 3.821, 3.858},
2034  {4.296, 4.064, 3.497, 3.642}
2035  }};
2036 
2037  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{24.40, 25.28, 25.66, 24.12},
2038  {24.42, 24.99, 25.72, 25.29}
2039  }};
2040 
2041  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{70.51, 70.57, 70.13, 69.98},
2042  {74.18, 72.79, 71.77, 72.62}
2043  }};
2044  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{70.70, 70.78, 70.76, 70.91},
2045  {75.16, 73.71, 72.25, 73.61}
2046  }};
2047 
2048  ZDCDataAnalyzer::ZDCModuleFloatArray moduleAmpFractionLG = {{{0.2760, 0.3045, 0.2369, 0.1826},
2049  {0.3216, 0.2593, 0.2511, 0.1680}
2050  }};
2051 
2052  // Delta T0 cut
2053  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
2054  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
2055  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
2056  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
2057 
2058  for (size_t side : {0, 1}) {
2059  for (size_t module : {0, 1, 2, 3}) {
2060  fixTau1Arr[side][module] = true;
2061  fixTau2Arr[side][module] = true;
2062 
2063  peak2ndDerivMinSamples[side][module] = peakSample;
2064  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
2065  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
2066  peak2ndDerivMinRepassHG [side][module] = peak2ndDerivRepassHG;
2067  peak2ndDerivMinRepassLG [side][module] = peak2ndDerivRepassLG;
2068 
2069  chisqDivAmpCut[side][module] = 15;
2070  }
2071  }
2072 
2073  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
2074  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
2075  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
2076 
2077  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1, 1, 1, 1}, {1, 1, 1, 1}}};
2078  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{12, 12, 12, 12}, {12, 12, 12, 12}}};
2079 
2080 
2081  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
2082  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
2083  slewingParamsHG[0][0] = { -1.335560e-01, -6.071869e-03, 5.858193e-02, 2.473300e-03};
2084  slewingParamsHG[0][1] = { -1.223062e-01, -4.379469e-02, 4.452285e-02, 2.130210e-03};
2085  slewingParamsHG[0][2] = { -1.021415e-01, -4.254239e-02, 4.939866e-02, 3.849738e-03};
2086  slewingParamsHG[0][3] = { -8.234056e-02, -3.938803e-02, 4.689029e-02, 2.784816e-03};
2087 
2088  slewingParamsHG[1][0] = { -1.640979e-01, -2.780350e-02, 5.755065e-02, -4.244651e-04};
2089  slewingParamsHG[1][1] = { -1.422324e-01, 2.663803e-02, 7.295366e-02, 3.740496e-03};
2090  slewingParamsHG[1][2] = { -9.858124e-02, -2.426132e-02, 4.895967e-02, 2.291393e-03};
2091  slewingParamsHG[1][3] = { -1.070401e-01, -2.256383e-03, 5.833770e-02, 2.255208e-03};
2092 
2093  slewingParamsLG[0][0] = { -2.588446e-01, -3.241086e-02, 7.828661e-02, 1.945547e-03};
2094  slewingParamsLG[0][1] = { -3.112495e-01, -7.419508e-02, 6.825776e-02, 2.148860e-03};
2095  slewingParamsLG[0][2] = { -3.470650e-01, -5.836748e-02, 6.204396e-02, 1.550421e-03};
2096  slewingParamsLG[0][3] = { -4.485435e-01, -4.603790e-02, 5.944799e-02, -1.174585e-03};
2097 
2098  slewingParamsLG[1][0] = { -3.291676e-01, -4.023732e-02, 8.608755e-02, -3.958167e-03};
2099  slewingParamsLG[1][1] = { -2.608969e-01, -2.129786e-03, 6.930791e-02, -4.141910e-03};
2100  slewingParamsLG[1][2] = { -2.505712e-01, -2.195804e-02, 5.137261e-02, -4.058378e-03};
2101  slewingParamsLG[1][3] = { -5.083206e-01, 3.776601e-02, 1.284275e-01, 1.014067e-02};
2102 
2103  // Construct the data analyzer
2104  //
2105  // We adopt hard-coded values for the number of samples and the frequency which we kept fixed for all physics data
2106  //
2107  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer = std::make_unique<ZDCDataAnalyzer>(MakeMessageFunction(), 7, 25, 0, "FermiExpLinear", peak2ndDerivMinSamples, // presample index changed to zero 4/6/19
2108  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode);
2109 
2110  // Open up tolerances on the position of the peak for now
2111  //
2112  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
2113 
2114  // We alwyas disable the 12EM (sideC) module which was not present (LHCf)
2115  //
2116 
2117  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
2118  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
2119  zdcDataAnalyzer->SetModuleAmpFractionLG(moduleAmpFractionLG); // fraction calculation for LGOverflows added Nov 23, 2020
2120  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
2121 
2122  // We allow the combineDelay to be controlled by the properties
2123  //
2124  m_combineDelay = true;
2125  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
2126 
2127  // We use per-module delays to handle the delayed-undelayed swap on EMC
2128  //
2129  ZDCDataAnalyzer::ZDCModuleFloatArray delayDeltaTs = {{{{12.5, -12.5, -12.5, -12.5}},
2130  {{ -12.5, -12.5, -12.5, -12.5}}
2131  }
2132  };
2133 
2134  zdcDataAnalyzer->enableDelayed(delayDeltaTs, defaultPedestalShifts);
2135  zdcDataAnalyzer->SetFitTimeMax(140); // This restrict the fit range of the pulse fitting, requested by BAC 4/6/19
2136  zdcDataAnalyzer->SetSaveFitFunc(false);
2137  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG); // add repass as default Jul 21 2020 Bill
2138  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
2139  slewingParamsHG, slewingParamsLG); // add time slewing correction Sep 17 2019 Bill
2140  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
2141 
2142  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
2143 
2144  return zdcDataAnalyzer;
2145 }

◆ initializePbPb2023()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializePbPb2023 ( )
private

Definition at line 468 of file ZdcAnalysisTool.cxx.

469 {
470  // Key configuration parameters needed for the data analyzer construction
471  //
472  m_deltaTSample = 3.125;
473  m_numSample = 24;
474 
475  const int deriv2ndThreshDSHG = -25;
476  const int deriv2ndThreshDSLG = -10;
477  const unsigned int peakSample = 10;
478 
479  const float deltaTcutLow = -10;
480  const float deltaTcutHigh = 10;
481  const float chisqDivAmpCutHGVal = 30;
482  const float chisqDivAmpCutLGVal = 50;
483 
484  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
485  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
486 
487  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{};
488  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG{}, chisqDivAmpCutLG{};
489  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
490 
491  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.2, 1.4, 1.3, 1.2},
492  {1.35, 1.4, 1.3, 1.1}}};
493 
494  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
495 
496  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
497  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{28, 28, 28, 28}, {28, 28, 28, 28}}};
498 
499  for (size_t side : {0, 1}) {
500  for (size_t module : {0, 1, 2, 3}) {
501  fixTau1Arr[side][module] = true;
502  fixTau2Arr[side][module] = false;
503 
504  peak2ndDerivMinSamples[side][module] = peakSample;
505  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
506  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
507 
508  deltaT0CutLow[side][module] = deltaTcutLow;
509  deltaT0CutHigh[side][module] = deltaTcutHigh;
510  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
511  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
512  }
513  }
514 
515  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
516 
517  // Construct the data analyzer
518  //
519  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
520  m_numSample, m_deltaTSample,
521  m_presample, "FermiExpLHCf",
522  peak2ndDerivMinSamples,
523  peak2ndDerivMinThresholdsHG,
524  peak2ndDerivMinThresholdsLG,
525  ZDCPulseAnalyzer::LGModeRefitLG));
526  zdcDataAnalyzer->set2ndDerivStep(2);
527  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
528 
529  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1.042, 1.078, 1.008, 1.066},{1.047, 1.060, 1.010, 0.99}}};
530  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{10, 10, 10, 10}, {10, 10, 10, 10}}};
531 
532  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
533 
534  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
535  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
536  //
537  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
538  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{1.5, 1.7, 3, 1.7}, {1.7, 1.6, 2.2, 1.8}}};
539 
540  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
541 
542  // Now set cuts and default fit parameters
543  //
544  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
545  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
546  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
547 
548  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
549  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
550  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
551 
552  // Enable two-pass analysis
553  //
554  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-20, -20, -20, -20},
555  {-20, -20, -20, -20},}};
556 
557  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
558  {-8, -8, -8, -8}}};
559 
560  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
561 
562  // Turn on exclusion of early and late samples to address OOT pileup
563  //
564  zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
565  zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
566 
567  // Set up non-linear corrections for the ZDC
568  //
569  std::array<std::array<std::vector<float>, 4>, 2> nonLinearCorrCoefficHG, nonLinearCorrCoefficLG;
570 
571  nonLinearCorrCoefficHG[0][0] = {-0.0225871, 0.00702802, 0.00201155, -0.00675293, 0.00186212} ;
572  nonLinearCorrCoefficHG[0][1] = {-0.0155562, 0.00594092, 0.00382112, -0.00665466, 0.00143384} ;
573  nonLinearCorrCoefficHG[0][2] = {-0.0313621, 0.0134528, 0.00529013, -0.0111751, 0.0029913} ;
574  nonLinearCorrCoefficHG[0][3] = {-0.025108, 0.00301898, 0.022472, -0.0204288, 0.00453215} ;
575  nonLinearCorrCoefficHG[1][0] = {-0.0266648, 0.0106792, -0.00939959, 0.000833011, 0.000199051} ;
576  nonLinearCorrCoefficHG[1][1] = {-0.0246541, 0.000327376, 0.00754946, -0.00710273, 0.00136899} ;
577  nonLinearCorrCoefficHG[1][2] = {-0.0175283, 0.0127954, 0.000235749, -0.00769698, 0.00221995} ;;
578  nonLinearCorrCoefficHG[1][3] = {-0.0279931, 0.0188122, 0.0126234, -0.0169907, 0.00398826} ;
579 
580  // For now we don't use corrections on the LG as it's much harder to measure them
581  //
582  nonLinearCorrCoefficLG = {{ {{{0},
583  {0},
584  {0},
585  {0}}},
586  {{{0},
587  {0},
588  {0},
589  {0}}} }};
590 
591  // Now use 1000 as the offset for the high gain non-linear correction due to the improved
592  // clarity in the high gain/low gain response change around the 10 bit mark with the new LG refit procedure
593  //
594  if (m_doNonLinCorr)
595  zdcDataAnalyzer->SetNonlinCorrParams(1000, 1000, nonLinearCorrCoefficHG, nonLinearCorrCoefficLG);
596 
597  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
598  timeCorrCoefficHG[0][0] = {0.07, -0.020672, 0.070206, 0.004961, -0.010821, -0.001835};
599  timeCorrCoefficHG[0][1] = {0.04, -0.012961, 0.008204, 0.010771, 0.011593, 0.002045};
600  timeCorrCoefficHG[0][2] = {0.04, 0.017393, 0.017597, 0.003736, -0.001696, -0.000465};
601  timeCorrCoefficHG[0][3] = {0.04, 0.018463, 0.009862, -0.000277, -0.000268, 0.000192};
602 
603  timeCorrCoefficHG[1][0] = {0.13, -0.106068, 0.078153, 0.034479, -0.004964, -0.001688};
604  timeCorrCoefficHG[1][1] = {0.03, -0.007518, 0.008937, 0.015319, 0.012290, 0.001889};
605  timeCorrCoefficHG[1][2] = {-0.01, 0.006711, -0.001652, -0.004223, -0.000573, 0.000161};
606  timeCorrCoefficHG[1][3] = {0.015, 0.017993, 0.006339, 0.003122, 0.002980, 0.000735};
607 
608  // +++ BAC 07-26-24
609  //
610  // The +3.25 in the constant t0 correction term accounts for a change in the nominal T0 from 31.25 to 28
611  // made at the same time to match the timing shift of the LG channels
612  //
613  // ---
614  timeCorrCoefficLG[0][0] = {0.035f+3.25f, -0.126189, 0.022724, 0.039116, -0.098255};
615  timeCorrCoefficLG[0][1] = {0.022f+3.25f, -0.165988, -0.014125, 0.057323, -0.205109};
616  timeCorrCoefficLG[0][2] = {0.01f+3.25f, -0.136087, -0.007248, -0.014452, -0.060469};
617  timeCorrCoefficLG[0][3] = {0.0f+3.25f, -0.131067, 0.025579, 0.059994, -0.065595};
618 
619  timeCorrCoefficLG[1][0] = {0.076f+3.25f, -0.300587, -0.041827, 0.641108, -0.594157};
620  timeCorrCoefficLG[1][1] = {0.057f+3.25f, -0.223443, -0.125013, -0.176900, 0.348081};
621  timeCorrCoefficLG[1][2] = {0.015f+3.25f, -0.141721, 0.023936, 0.099657, -0.188526};
622  timeCorrCoefficLG[1][3] = {0.01f+3.25f, -0.152589, 0.016122, -0.086580, 0.563625};
623 
624  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
625 
626  // Set the amplitude fit range limits
627  //
628  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
629 
630  return zdcDataAnalyzer;
631 }

◆ initializePbPb2024()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializePbPb2024 ( )
private

Definition at line 633 of file ZdcAnalysisTool.cxx.

634 {
635  // Key configuration parameters needed for the data analyzer construction
636  //
637  m_deltaTSample = 3.125;
638  m_numSample = 24;
639 
640  const int deriv2ndThreshDSHG = -45;
641  const int deriv2ndThreshDSLG = -10;
642  const unsigned int peakSample = 10;
643 
644  const float deltaTcutLow = -10;
645  const float deltaTcutHigh = 10;
646  const float chisqDivAmpCutHGVal = 30;
647  const float chisqDivAmpCutLGVal = 50;
648 
649  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
650  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
651 
652  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
653  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
654  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
655 
656  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.2, 1.4, 1.3, 1.2},
657  {1.35, 1.4, 1.3, 1.1}}};
658 
659  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
660 
661  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.5, 31.5, 29.5, 30.5}, {34.5, 33.0, 33, 34.0}}};
662  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{32.25, 32.0, 30.5, 30.5}, {32.4, 33.5, 30.5, 31.4}}};
663 
664  for (size_t side : {0, 1}) {
665  for (size_t module : {0, 1, 2, 3}) {
666  fixTau1Arr[side][module] = true;
667  fixTau2Arr[side][module] = false;
668 
669  peak2ndDerivMinSamples[side][module] = peakSample;
670  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
671  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
672 
673  deltaT0CutLow[side][module] = deltaTcutLow;
674  deltaT0CutHigh[side][module] = deltaTcutHigh;
675  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
676  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
677  }
678  }
679 
680  ATH_MSG_DEBUG( "PbPb2024: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
681 
682  // Construct the data analyzer
683  //
684  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
685  m_numSample, m_deltaTSample,
686  m_presample, "FermiExpLHCf",
687  peak2ndDerivMinSamples,
688  peak2ndDerivMinThresholdsHG,
689  peak2ndDerivMinThresholdsLG,
690  ZDCPulseAnalyzer::LGModeRefitLG));
691  zdcDataAnalyzer->set2ndDerivStep(2);
692  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
693 
694  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1, 1, 1, 1},{1, 1, 1, 1.0}}};
695  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{9.36, 9.7, 10.95, 10.5}, {9.9, 10.5, 11.2, 10.4}}};
696 
697  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
698 
699  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
700  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
701  //
702  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.5, 1.5, 1.5, 1.5}, {1.5, 1.5, 1.5, 1.5}}};
703  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{10, 10, 10, 10}, {10, 10, 10, 10}}};
704 
705  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
706 
707  // Now set cuts and default fit parameters
708  //
709  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
710  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
711  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
712 
713  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
714  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
715  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
716 
717  // Enable two-pass analysis
718  //
719  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-30, -30, -30, -30},
720  {-30, -30, -30, -30},}};
721 
722  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
723  {-8, -8, -8, -8}}};
724 
725  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
726 
727  // Turn on exclusion of early and late samples to address OOT pileup
728  //
729  zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
730  zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
731 
732  // Set up non-linear corrections for the ZDC
733  //
734  std::array<std::array<std::vector<float>, 4>, 2> nonLinearCorrCoefficHG, nonLinearCorrCoefficLG;
735 
736  nonLinearCorrCoefficHG[0][0] = {-0.0225871, 0.00702802, 0.00201155, -0.00675293, 0.00186212} ;
737  nonLinearCorrCoefficHG[0][1] = {-0.0155562, 0.00594092, 0.00382112, -0.00665466, 0.00143384} ;
738  nonLinearCorrCoefficHG[0][2] = {-0.0313621, 0.0134528, 0.00529013, -0.0111751, 0.0029913} ;
739  nonLinearCorrCoefficHG[0][3] = {-0.025108, 0.00301898, 0.022472, -0.0204288, 0.00453215} ;
740  nonLinearCorrCoefficHG[1][0] = {-0.0266648, 0.0106792, -0.00939959, 0.000833011, 0.000199051} ;
741  nonLinearCorrCoefficHG[1][1] = {-0.0246541, 0.000327376, 0.00754946, -0.00710273, 0.00136899} ;
742  nonLinearCorrCoefficHG[1][2] = {-0.0175283, 0.0127954, 0.000235749, -0.00769698, 0.00221995} ;;
743  nonLinearCorrCoefficHG[1][3] = {-0.0279931, 0.0188122, 0.0126234, -0.0169907, 0.00398826} ;
744 
745 
746  // Remove nonlinear corrections while we study the injector pulse
747  nonLinearCorrCoefficHG = {{ {{{0},
748  {0},
749  {0},
750  {0}}},
751  {{{0},
752  {0},
753  {0},
754  {0}}} }};
755 
756  //
757  // We are disabling the old FADC correction moving forward
758  if (m_doNonLinCorr)
759  zdcDataAnalyzer->SetNonlinCorrParams(1000, 1000, nonLinearCorrCoefficHG, nonLinearCorrCoefficLG);
760 
761  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
762  timeCorrCoefficHG[0][0] = {0.07, -0.020672, 0.070206, 0.004961, -0.010821, -0.001835};
763  timeCorrCoefficHG[0][1] = {0.04, -0.012961, 0.008204, 0.010771, 0.011593, 0.002045};
764  timeCorrCoefficHG[0][2] = {0.04, 0.017393, 0.017597, 0.003736, -0.001696, -0.000465};
765  timeCorrCoefficHG[0][3] = {0.04, 0.018463, 0.009862, -0.000277, -0.000268, 0.000192};
766 
767  timeCorrCoefficHG[1][0] = {0.13, -0.106068, 0.078153, 0.034479, -0.004964, -0.001688};
768  timeCorrCoefficHG[1][1] = {0.03, -0.007518, 0.008937, 0.015319, 0.012290, 0.001889};
769  timeCorrCoefficHG[1][2] = {-0.01, 0.006711, -0.001652, -0.004223, -0.000573, 0.000161};
770  timeCorrCoefficHG[1][3] = {0.015, 0.017993, 0.006339, 0.003122, 0.002980, 0.000735};
771 
772  // +++ BAC 07-26-24
773  //
774  // The +3.25 in the constant t0 correction term accounts for a change in the nominal T0 from 31.25 to 28
775  // made at the same time to match the timing shift of the LG channels
776  //
777  // ---
778  timeCorrCoefficLG[0][0] = {0.035f+3.25f, -0.126189, 0.022724, 0.039116, -0.098255};
779  timeCorrCoefficLG[0][1] = {0.022f+3.25f, -0.165988, -0.014125, 0.057323, -0.205109};
780  timeCorrCoefficLG[0][2] = {0.01f+3.25f, -0.136087, -0.007248, -0.014452, -0.060469};
781  timeCorrCoefficLG[0][3] = {0.0f+3.25f, -0.131067, 0.025579, 0.059994, -0.065595};
782 
783  timeCorrCoefficLG[1][0] = {0.076f+3.25f, -0.300587, -0.041827, 0.641108, -0.594157};
784  timeCorrCoefficLG[1][1] = {0.057f+3.25f, -0.223443, -0.125013, -0.176900, 0.348081};
785  timeCorrCoefficLG[1][2] = {0.015f+3.25f, -0.141721, 0.023936, 0.099657, -0.188526};
786  timeCorrCoefficLG[1][3] = {0.01f+3.25f, -0.152589, 0.016122, -0.086580, 0.563625};
787 
788  // Commenting out the timing correlation for PbPb2024: re-calibraton needed
789  // zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
790 
791  std::array< std::array< std::array<float,6>, 3>, 2> nlCalib = {{
792  {{ {{0.3, 1, -0.00753349, 0.882218, 0.019739, 1.0803}},{{0.3, 1, 0.0181165, 0.620646, -0.171213, 2.2143}},{{0.25, 1, -0.108547, 0.106, -1.3594, 4.1509}} }},
793  {{ {{0.3, 1, -0.00753349, 0.882218, 0.019739, 1.0803}},{{0.3, 1, 0.0181165, 0.620646, -0.171213, 2.2143}},{{0.25, 1, -0.108547, 0.106, -1.3594, 4.1509}} }}
794  }};
795 
796  zdcDataAnalyzer->SetNLcalibParams(nlCalib);
797 
798  // Set the amplitude fit range limits
799  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
800 
801  return zdcDataAnalyzer;
802 }

◆ initializepO2025()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializepO2025 ( )
private

Definition at line 984 of file ZdcAnalysisTool.cxx.

985 {
986  // Key configuration parameters needed for the data analyzer construction
987  //
988  m_deltaTSample = 3.125;
989  m_numSample = 24;
990 
991  const int deriv2ndThreshDSHG = -45;
992  const int deriv2ndThreshDSLG = -10;
993  const unsigned int peakSample = 10;
994 
995  const float deltaTcutLow = -10;
996  const float deltaTcutHigh = 10;
997  const float chisqDivAmpCutHGVal = 30;
998  const float chisqDivAmpCutLGVal = 50;
999 
1000  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
1001  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
1002 
1003  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
1004  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
1005  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
1006 
1007  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.2, 1.4, 1.3, 1.2},
1008  {1.35, 1.4, 1.3, 1.1}}};
1009 
1010  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
1011 
1012  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.5, 31.5, 29.5, 30.5}, {34.5, 33.0, 33, 34.0}}};
1013  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{32.25, 32.0, 30.5, 30.5}, {32.4, 33.5, 30.5, 31.4}}};
1014 
1015  for (size_t side : {0, 1}) {
1016  for (size_t module : {0, 1, 2, 3}) {
1017  fixTau1Arr[side][module] = true;
1018  fixTau2Arr[side][module] = false;
1019 
1020  peak2ndDerivMinSamples[side][module] = peakSample;
1021  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
1022  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
1023 
1024  deltaT0CutLow[side][module] = deltaTcutLow;
1025  deltaT0CutHigh[side][module] = deltaTcutHigh;
1026  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
1027  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
1028  }
1029  }
1030 
1031  ATH_MSG_DEBUG( "PbPb2024: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1032 
1033  // Construct the data analyzer
1034  //
1035  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
1036  m_numSample, m_deltaTSample,
1037  m_presample, "FermiExpLHCf",
1038  peak2ndDerivMinSamples,
1039  peak2ndDerivMinThresholdsHG,
1040  peak2ndDerivMinThresholdsLG,
1041  ZDCPulseAnalyzer::LGModeRefitLG));
1042  zdcDataAnalyzer->set2ndDerivStep(1);
1043  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
1044 
1045  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1, 1, 1, 1},{1, 1, 1, 1.0}}};
1046  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{4,4,4,4}, {4,4,4,4}}};
1047 
1048  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
1049 
1050  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
1051  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
1052  //
1053  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.5, 1.5, 1.5, 1.5}, {1.5, 1.5, 1.5, 1.5}}};
1054  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{10, 10, 10, 10}, {10, 10, 10, 10}}};
1055 
1056  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
1057 
1058  // Now set cuts and default fit parameters
1059  //
1060  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
1061  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
1062  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
1063 
1064  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1065  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1066  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1067 
1068  // Enable two-pass analysis
1069  //
1070  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-30, -30, -30, -30},
1071  {-30, -30, -30, -30},}};
1072 
1073  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
1074  {-8, -8, -8, -8}}};
1075 
1076  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
1077 
1078  // Turn on exclusion of early and late samples to address OOT pileup
1079  //
1080  zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
1081  zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
1082 
1083  // Set up non-linear corrections for the ZDC
1084  //
1085  std::array<std::array<std::vector<float>, 4>, 2> nonLinearCorrCoefficHG, nonLinearCorrCoefficLG;
1086 
1087  nonLinearCorrCoefficHG[0][0] = {-0.0225871, 0.00702802, 0.00201155, -0.00675293, 0.00186212} ;
1088  nonLinearCorrCoefficHG[0][1] = {-0.0155562, 0.00594092, 0.00382112, -0.00665466, 0.00143384} ;
1089  nonLinearCorrCoefficHG[0][2] = {-0.0313621, 0.0134528, 0.00529013, -0.0111751, 0.0029913} ;
1090  nonLinearCorrCoefficHG[0][3] = {-0.025108, 0.00301898, 0.022472, -0.0204288, 0.00453215} ;
1091  nonLinearCorrCoefficHG[1][0] = {-0.0266648, 0.0106792, -0.00939959, 0.000833011, 0.000199051} ;
1092  nonLinearCorrCoefficHG[1][1] = {-0.0246541, 0.000327376, 0.00754946, -0.00710273, 0.00136899} ;
1093  nonLinearCorrCoefficHG[1][2] = {-0.0175283, 0.0127954, 0.000235749, -0.00769698, 0.00221995} ;;
1094  nonLinearCorrCoefficHG[1][3] = {-0.0279931, 0.0188122, 0.0126234, -0.0169907, 0.00398826} ;
1095 
1096 
1097  // Remove nonlinear corrections while we study the injector pulse
1098  nonLinearCorrCoefficHG = {{ {{{0},
1099  {0},
1100  {0},
1101  {0}}},
1102  {{{0},
1103  {0},
1104  {0},
1105  {0}}} }};
1106 
1107  //
1108  // We are disabling the old FADC correction moving forward
1109  if (m_doNonLinCorr)
1110  zdcDataAnalyzer->SetNonlinCorrParams(1000, 1000, nonLinearCorrCoefficHG, nonLinearCorrCoefficLG);
1111 
1112  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
1113  timeCorrCoefficHG[0][0] = {0.07, -0.020672, 0.070206, 0.004961, -0.010821, -0.001835};
1114  timeCorrCoefficHG[0][1] = {0.04, -0.012961, 0.008204, 0.010771, 0.011593, 0.002045};
1115  timeCorrCoefficHG[0][2] = {0.04, 0.017393, 0.017597, 0.003736, -0.001696, -0.000465};
1116  timeCorrCoefficHG[0][3] = {0.04, 0.018463, 0.009862, -0.000277, -0.000268, 0.000192};
1117 
1118  timeCorrCoefficHG[1][0] = {0.13, -0.106068, 0.078153, 0.034479, -0.004964, -0.001688};
1119  timeCorrCoefficHG[1][1] = {0.03, -0.007518, 0.008937, 0.015319, 0.012290, 0.001889};
1120  timeCorrCoefficHG[1][2] = {-0.01, 0.006711, -0.001652, -0.004223, -0.000573, 0.000161};
1121  timeCorrCoefficHG[1][3] = {0.015, 0.017993, 0.006339, 0.003122, 0.002980, 0.000735};
1122 
1123  // +++ BAC 07-26-24
1124  //
1125  // The +3.25 in the constant t0 correction term accounts for a change in the nominal T0 from 31.25 to 28
1126  // made at the same time to match the timing shift of the LG channels
1127  //
1128  // ---
1129  timeCorrCoefficLG[0][0] = {0.035f+3.25f, -0.126189, 0.022724, 0.039116, -0.098255};
1130  timeCorrCoefficLG[0][1] = {0.022f+3.25f, -0.165988, -0.014125, 0.057323, -0.205109};
1131  timeCorrCoefficLG[0][2] = {0.01f+3.25f, -0.136087, -0.007248, -0.014452, -0.060469};
1132  timeCorrCoefficLG[0][3] = {0.0f+3.25f, -0.131067, 0.025579, 0.059994, -0.065595};
1133 
1134  timeCorrCoefficLG[1][0] = {0.076f+3.25f, -0.300587, -0.041827, 0.641108, -0.594157};
1135  timeCorrCoefficLG[1][1] = {0.057f+3.25f, -0.223443, -0.125013, -0.176900, 0.348081};
1136  timeCorrCoefficLG[1][2] = {0.015f+3.25f, -0.141721, 0.023936, 0.099657, -0.188526};
1137  timeCorrCoefficLG[1][3] = {0.01f+3.25f, -0.152589, 0.016122, -0.086580, 0.563625};
1138 
1139  // Commenting out the timing correlation for PbPb2024: re-calibraton needed
1140  // zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
1141 
1142  // Set the amplitude fit range limits
1143  //
1144  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
1145 
1146  zdcDataAnalyzer->disableModule(0, 0); // required since EM not installed
1147 
1148  return zdcDataAnalyzer;
1149 }

◆ initializepO2025B()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializepO2025B ( )
private

Definition at line 1151 of file ZdcAnalysisTool.cxx.

1152 {
1153  // Key configuration parameters needed for the data analyzer construction
1154  //
1155  m_deltaTSample = 3.125;
1156  m_numSample = 24;
1157 
1158  const int deriv2ndThreshDSHG = -45;
1159  const int deriv2ndThreshDSLG = -10;
1160  const unsigned int peakSample = 10;
1161 
1162  const float deltaTcutLow = -10;
1163  const float deltaTcutHigh = 10;
1164  const float chisqDivAmpCutHGVal = 30;
1165  const float chisqDivAmpCutLGVal = 50;
1166 
1167  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
1168  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
1169 
1170  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
1171  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
1172  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
1173 
1174  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.2, 1.4, 1.3, 1.2},
1175  {1.35, 1.4, 1.3, 1.1}}};
1176 
1177  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
1178 
1179  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.5, 31.5, 29.5, 30.5}, {34.5, 33.0, 33, 34.0}}};
1180  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{32.25, 32.0, 30.5, 30.5}, {32.4, 33.5, 30.5, 31.4}}};
1181 
1182  for (size_t side : {0, 1}) {
1183  for (size_t module : {0, 1, 2, 3}) {
1184  fixTau1Arr[side][module] = true;
1185  fixTau2Arr[side][module] = false;
1186 
1187  peak2ndDerivMinSamples[side][module] = peakSample;
1188  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
1189  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
1190 
1191  deltaT0CutLow[side][module] = deltaTcutLow;
1192  deltaT0CutHigh[side][module] = deltaTcutHigh;
1193  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
1194  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
1195  }
1196  }
1197 
1198  ATH_MSG_DEBUG( "PbPb2024: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1199 
1200  // Construct the data analyzer
1201  //
1202  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
1203  m_numSample, m_deltaTSample,
1204  m_presample, "FermiExpLHCf",
1205  peak2ndDerivMinSamples,
1206  peak2ndDerivMinThresholdsHG,
1207  peak2ndDerivMinThresholdsLG,
1208  ZDCPulseAnalyzer::LGModeRefitLG));
1209  zdcDataAnalyzer->set2ndDerivStep(1);
1210  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
1211 
1212  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1, 1, 1, 1},{1, 1, 1, 1.0}}}; //
1213  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{4,4,4,4}, {3,4,4,4}}}; // decided to move the change to the HG/LG ratio
1214 
1215  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
1216 
1217  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
1218  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
1219  //
1220  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.5, 1.5, 1.5, 1.5}, {1.5, 1.5, 1.5, 1.5}}};
1221  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{10, 10, 10, 10}, {10, 10, 10, 10}}};
1222 
1223  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
1224 
1225  // Now set cuts and default fit parameters
1226  //
1227  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
1228  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
1229  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
1230 
1231  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1232  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1233  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1234 
1235  // Enable two-pass analysis
1236  //
1237  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-30, -30, -30, -30},
1238  {-30, -30, -30, -30},}};
1239 
1240  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
1241  {-8, -8, -8, -8}}};
1242 
1243  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
1244 
1245  // Turn on exclusion of early and late samples to address OOT pileup
1246  //
1247  zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
1248  zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
1249 
1250  // Set up non-linear corrections for the ZDC
1251  //
1252  std::array<std::array<std::vector<float>, 4>, 2> nonLinearCorrCoefficHG, nonLinearCorrCoefficLG;
1253 
1254  nonLinearCorrCoefficHG[0][0] = {-0.0225871, 0.00702802, 0.00201155, -0.00675293, 0.00186212} ;
1255  nonLinearCorrCoefficHG[0][1] = {-0.0155562, 0.00594092, 0.00382112, -0.00665466, 0.00143384} ;
1256  nonLinearCorrCoefficHG[0][2] = {-0.0313621, 0.0134528, 0.00529013, -0.0111751, 0.0029913} ;
1257  nonLinearCorrCoefficHG[0][3] = {-0.025108, 0.00301898, 0.022472, -0.0204288, 0.00453215} ;
1258  nonLinearCorrCoefficHG[1][0] = {-0.0266648, 0.0106792, -0.00939959, 0.000833011, 0.000199051} ;
1259  nonLinearCorrCoefficHG[1][1] = {-0.0246541, 0.000327376, 0.00754946, -0.00710273, 0.00136899} ;
1260  nonLinearCorrCoefficHG[1][2] = {-0.0175283, 0.0127954, 0.000235749, -0.00769698, 0.00221995} ;;
1261  nonLinearCorrCoefficHG[1][3] = {-0.0279931, 0.0188122, 0.0126234, -0.0169907, 0.00398826} ;
1262 
1263 
1264  // Remove nonlinear corrections while we study the injector pulse
1265  nonLinearCorrCoefficHG = {{ {{{0},
1266  {0},
1267  {0},
1268  {0}}},
1269  {{{0},
1270  {0},
1271  {0},
1272  {0}}} }};
1273 
1274  //
1275  // We are disabling the old FADC correction moving forward
1276  if (m_doNonLinCorr)
1277  zdcDataAnalyzer->SetNonlinCorrParams(1000, 1000, nonLinearCorrCoefficHG, nonLinearCorrCoefficLG);
1278 
1279  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
1280  timeCorrCoefficHG[0][0] = {0.07, -0.020672, 0.070206, 0.004961, -0.010821, -0.001835};
1281  timeCorrCoefficHG[0][1] = {0.04, -0.012961, 0.008204, 0.010771, 0.011593, 0.002045};
1282  timeCorrCoefficHG[0][2] = {0.04, 0.017393, 0.017597, 0.003736, -0.001696, -0.000465};
1283  timeCorrCoefficHG[0][3] = {0.04, 0.018463, 0.009862, -0.000277, -0.000268, 0.000192};
1284 
1285  timeCorrCoefficHG[1][0] = {0.13, -0.106068, 0.078153, 0.034479, -0.004964, -0.001688};
1286  timeCorrCoefficHG[1][1] = {0.03, -0.007518, 0.008937, 0.015319, 0.012290, 0.001889};
1287  timeCorrCoefficHG[1][2] = {-0.01, 0.006711, -0.001652, -0.004223, -0.000573, 0.000161};
1288  timeCorrCoefficHG[1][3] = {0.015, 0.017993, 0.006339, 0.003122, 0.002980, 0.000735};
1289 
1290  // +++ BAC 07-26-24
1291  //
1292  // The +3.25 in the constant t0 correction term accounts for a change in the nominal T0 from 31.25 to 28
1293  // made at the same time to match the timing shift of the LG channels
1294  //
1295  // ---
1296  timeCorrCoefficLG[0][0] = {0.035f+3.25f, -0.126189, 0.022724, 0.039116, -0.098255};
1297  timeCorrCoefficLG[0][1] = {0.022f+3.25f, -0.165988, -0.014125, 0.057323, -0.205109};
1298  timeCorrCoefficLG[0][2] = {0.01f+3.25f, -0.136087, -0.007248, -0.014452, -0.060469};
1299  timeCorrCoefficLG[0][3] = {0.0f+3.25f, -0.131067, 0.025579, 0.059994, -0.065595};
1300 
1301  timeCorrCoefficLG[1][0] = {0.076f+3.25f, -0.300587, -0.041827, 0.641108, -0.594157};
1302  timeCorrCoefficLG[1][1] = {0.057f+3.25f, -0.223443, -0.125013, -0.176900, 0.348081};
1303  timeCorrCoefficLG[1][2] = {0.015f+3.25f, -0.141721, 0.023936, 0.099657, -0.188526};
1304  timeCorrCoefficLG[1][3] = {0.01f+3.25f, -0.152589, 0.016122, -0.086580, 0.563625};
1305 
1306  // Commenting out the timing correlation for PbPb2024: re-calibraton needed
1307  // zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
1308 
1309  // Set the amplitude fit range limits
1310  //
1311  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
1312 
1313  zdcDataAnalyzer->disableModule(0, 0); // required since EM not installed
1314 
1315  return zdcDataAnalyzer;
1316 }

◆ initializepp2023()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializepp2023 ( )
private

Definition at line 290 of file ZdcAnalysisTool.cxx.

291 {
292 
293  m_deltaTSample = 3.125;
294  m_numSample = 24;
295  m_lowGainMode = ZDCPulseAnalyzer::LGModeForceLG;
296 
297  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{12, 12, 12, 12}, {12, 12, 12, 12}}};
298 
299  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
300  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
301  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
302 
303  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.1, 1.1, 1.1, 1.1},
304  {1.1, 1.1, 1.1, 1.1}}};
305 
306  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{5.5, 5.5, 5.5, 5.5}, {5.5, 5.5, 5.5, 5.5}}};
307 
308  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{36, 36, 36, 36}, {36, 36, 36, 36}}};
309 
310  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{36, 36, 36, 36}, {36, 36, 36, 36}}};
311 
312  const int deriv2ndThreshDSHG = -35;
313  const int deriv2ndThreshDSLG = -10;
314 
315  const float deltaTcutLow = -10;
316  const float deltaTcutHigh = 10;
317  const float chisqDivAmpCutVal = 10;
318 
319  for (size_t side : {0, 1}) {
320  for (size_t module : {0, 1, 2, 3}) {
321  fixTau1Arr[side][module] = true;
322  fixTau2Arr[side][module] = false;
323 
324  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
325  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
326 
327  deltaT0CutLow[side][module] = deltaTcutLow;
328  deltaT0CutHigh[side][module] = deltaTcutHigh;
329  chisqDivAmpCut[side][module] = chisqDivAmpCutVal;
330  }
331  }
332 
333  ATH_MSG_DEBUG( "pp2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
334 
335  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
336  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
337  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
338 
339  // Construct the data analyzer
340  //
341  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
342  m_numSample, m_deltaTSample,
343  m_presample, "FermiExpLHCf",
344  peak2ndDerivMinSamples,
345  peak2ndDerivMinThresholdsHG,
346  peak2ndDerivMinThresholdsLG,
347  m_lowGainMode));
348 
349  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
350  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
351  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
352  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
353 
354  zdcDataAnalyzer->SetGainFactorsHGLG(1, 10); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
355 
356  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{0.5, 0.5, 0.5, 0.5}, {0.5, 0.5, 0.5, 0.5}}};
357  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{2, 2, 2, 2}, {2, 2, 2, 2}}};
358 
359  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
360 
361  // Enable two-pass analysis
362  //
363  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-12, -12, -12, -12},
364  {-12, -12, -12, -12}}};
365 
366  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
367  {-8, -8, -8, -8}}};
368 
369  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
370 
371  // Set the amplitude fit range limits
372  //
373  zdcDataAnalyzer->SetFitMinMaxAmpValues(5, 2, 5000, 5000);
374 
375  return zdcDataAnalyzer;
376 
377 }

◆ initializepp2024()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializepp2024 ( )
private

Definition at line 379 of file ZdcAnalysisTool.cxx.

380 {
381 
382  m_deltaTSample = 3.125;
383  m_numSample = 24;
384  m_lowGainMode = ZDCPulseAnalyzer::LGModeForceLG;
385 
386  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{12, 12, 12, 12}, {12, 12, 12, 12}}};
387 
388  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
389  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh, chisqDivAmpCut;
390  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
391 
392  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.1, 1.1, 1.1, 1.1},
393  {1.1, 1.1, 1.1, 1.1}}};
394 
395  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{5.5, 5.5, 5.5, 5.5}, {5.5, 5.5, 5.5, 5.5}}};
396 
397  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{36, 36, 36, 36}, {36, 36, 36, 36}}};
398 
399  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{36, 36, 36, 36}, {36, 36, 36, 36}}};
400 
401  const int deriv2ndThreshDSHG = -35;
402  const int deriv2ndThreshDSLG = -10;
403 
404  const float deltaTcutLow = -10;
405  const float deltaTcutHigh = 10;
406  const float chisqDivAmpCutVal = 100;
407 
408  for (size_t side : {0, 1}) {
409  for (size_t module : {0, 1, 2, 3}) {
410  fixTau1Arr[side][module] = true;
411  fixTau2Arr[side][module] = false;
412 
413  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
414  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
415 
416  deltaT0CutLow[side][module] = deltaTcutLow;
417  deltaT0CutHigh[side][module] = deltaTcutHigh;
418  chisqDivAmpCut[side][module] = chisqDivAmpCutVal;
419  }
420  }
421 
422  ATH_MSG_DEBUG( "pp2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
423 
424  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
425  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
426  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
427 
428  // Construct the data analyzer
429  //
430  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
431  m_numSample, m_deltaTSample,
432  m_presample, "FermiExpLHCf",
433  peak2ndDerivMinSamples,
434  peak2ndDerivMinThresholdsHG,
435  peak2ndDerivMinThresholdsLG,
436  m_lowGainMode));
437 
438  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
439  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
440  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
441  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
442 
443  zdcDataAnalyzer->SetGainFactorsHGLG(1, 1); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
444 
445  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{0.5, 0.5, 0.5, 0.5}, {0.5, 0.5, 0.5, 0.5}}};
446  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{2, 2, 2, 2}, {2, 2, 2, 2}}};
447 
448  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
449 
450  // Enable two-pass analysis
451  //
452  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-12, -12, -12, -12},
453  {-12, -12, -12, -12}}};
454 
455  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
456  {-8, -8, -8, -8}}};
457 
458  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
459 
460  // Set the amplitude fit range limits
461  //
462  zdcDataAnalyzer->SetFitMinMaxAmpValues(5, 2, 5000, 5000);
463 
464  return zdcDataAnalyzer;
465 
466 }

◆ initializepPb2016()

std::unique_ptr< ZDCDataAnalyzer > ZDC::ZdcAnalysisTool::initializepPb2016 ( )
private

Definition at line 1908 of file ZdcAnalysisTool.cxx.

1909 {
1910  //
1911  // For now, we continue to use hard-coded values for the maximum and minimum ADC values
1912  // For now we also use the FermiExp pulse model.
1913 
1914  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
1915  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
1916  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
1917  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1918 
1919  // For now we allow the tau values to be controlled by the job properties until they are better determined
1920  //
1921  const int peakSample = 5;
1922  const float peak2ndDerivThreshHG = -12;
1923  const float peak2ndDerivThreshLG = -10;
1924  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{4.000, 3.380, 3.661, 3.679},
1925  {4.472, 4.656, 3.871, 4.061}
1926  }};
1927 
1928  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{22, 24.81, 24.48, 24.45},
1929  {24.17, 24.22, 25.46, 24.45}
1930  }};
1931 
1932  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{70.00, 72.74, 73.09, 72.25},
1933  {75.11, 74.94, 73.93, 74.45}
1934  }};
1935  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{70.00, 73.41, 74.27, 73.30},
1936  {76.28, 76.07, 74.98, 76.54}
1937  }};
1938 
1939  // Delta T0 cut
1940  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
1941  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
1942  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
1943  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
1944 
1945 
1946  for (size_t side : {0, 1}) {
1947  for (size_t module : {0, 1, 2, 3}) {
1948  fixTau1Arr[side][module] = true;
1949  fixTau2Arr[side][module] = true;
1950 
1951  peak2ndDerivMinSamples[side][module] = peakSample;
1952  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
1953  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
1954 
1955  chisqDivAmpCut[side][module] = 15;
1956  }
1957  }
1958 
1959  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1960  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1961  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1962 
1963  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1964  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
1965  slewingParamsHG[0][0] = {0, 0, 0, 0};
1966  slewingParamsHG[0][1] = { -4.780244e-01, -7.150874e-02, 4.614585e-02, 8.015731e-04};
1967  slewingParamsHG[0][2] = { -5.253412e-01, -5.718167e-02, 5.243121e-02, 2.128398e-03};
1968  slewingParamsHG[0][3] = { -5.773952e-01, -5.687478e-02, 4.564267e-02, 1.462294e-03};
1969 
1970  slewingParamsHG[1][0] = { 7.105115e-01, -3.686143e-02, 7.727447e-02, 5.924152e-03};
1971  slewingParamsHG[1][1] = { 4.052120e-02, 4.450686e-03, 8.031615e-02, 4.038097e-03};
1972  slewingParamsHG[1][2] = { 3.389476e-02, -2.056782e-02, 4.805321e-02, -2.627999e-03};
1973  slewingParamsHG[1][3] = { 2.069765e-01, -2.890419e-02, 6.084375e-02, 3.742011e-03};
1974 
1975  slewingParamsLG[0][0] = {0, 0, 0, 0};
1976  slewingParamsLG[0][1] = { -1.632547e+00, -4.827813e-01, -1.379131e-01, -2.522607e-02};
1977  slewingParamsLG[0][2] = { -7.254288e+00, -5.454064e+00, -1.619126e+00, -1.739665e-01};
1978  slewingParamsLG[0][3] = { -1.548400e+01, -1.277708e+01, -3.729333e+00, -3.700458e-01};
1979 
1980  slewingParamsLG[1][0] = { 1.142767e-01, -3.608906e-02, 9.642735e-02, -3.097043e-03};
1981  slewingParamsLG[1][1] = { -5.615388e-01, -1.655047e-02, 8.327350e-02, -4.231348e-03};
1982  slewingParamsLG[1][2] = { -7.370728e-01, -2.887482e-02, 8.293875e-02, -4.482743e-03};
1983  slewingParamsLG[1][3] = { -1.270636e+00, -2.791777e-01, -5.807295e-02, -2.332612e-02};
1984 
1985  // Construct the data analyzer
1986  //
1987  // We adopt hard-coded values for the number of samples and the frequency which we kept fixed for all physics data
1988  //
1989  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), 7, 25, 0, "FermiExpLinear", peak2ndDerivMinSamples,
1990  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1991 
1992  // Open up tolerances on the position of the peak for now
1993  //
1994  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
1995 
1996  // We alwyas disable the 12EM (sideC) module which was not present (LHCf)
1997  //
1998  zdcDataAnalyzer->disableModule(0, 0);
1999 
2000  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
2001  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
2002  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
2003 
2004  // We allow the combineDelay to be controlled by the properties
2005  //
2006  // if (m_combineDelay) {
2007  m_combineDelay = true;
2008  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
2009 
2010  zdcDataAnalyzer->enableDelayed(-12.5, defaultPedestalShifts);
2011  zdcDataAnalyzer->SetFitTimeMax(140); // This restrict the fit range of the pulse fitting
2012  zdcDataAnalyzer->SetSaveFitFunc(false);
2013  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
2014  slewingParamsHG, slewingParamsLG); // add time slewing correction Sep 17 2019 Bill
2015  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
2016 
2017  return zdcDataAnalyzer;
2018 }

◆ initializeTriggerEffs()

void ZDC::ZdcAnalysisTool::initializeTriggerEffs ( unsigned int  runNumber)

Definition at line 88 of file ZdcAnalysisTool.cxx.

89 {
90  if (!m_doTrigEff) return;
91 
92  if (!m_zdcTriggerEfficiency)
93  {
94  ATH_MSG_DEBUG("Creating new ZDCTriggerEfficiency");
95  m_zdcTriggerEfficiency.reset (new ZDCTriggerEfficiency());
96  }
97 
98  std::string filename = PathResolverFindCalibFile( ("ZdcAnalysis/" + m_zdcTriggerEffParamsFileName) );
99  ATH_MSG_DEBUG ("Found trigger config file " << filename);
100  ATH_MSG_DEBUG("Opening trigger efficiency file " << filename);
101 
102  std::unique_ptr<TFile> file (TFile::Open(filename.c_str(), "READ"));
103  if (file == nullptr || file->IsZombie())
104  {
105  ATH_MSG_WARNING("No trigger efficiencies at " << filename);
106  return;
107  }
108 
109  //file->Print();
110 
111  ATH_MSG_DEBUG("Reading in trigger efficiencies");
112 
113  std::stringstream Aalpha_name;
114  Aalpha_name << "A_alpha_" << runNumber;
115  TSpline3* par_A_alpha = (TSpline3*)file->GetObjectChecked(Aalpha_name.str().c_str(), "TSpline3");
116 
117  if (!par_A_alpha)
118  {
119  ATH_MSG_WARNING("No trigger efficiencies for run number " << runNumber);
120  m_doCalib = false;
121  }
122 
123  std::stringstream Abeta_name;
124  Abeta_name << "A_beta_" << runNumber;
125  TSpline3* par_A_beta = (TSpline3*)file->GetObjectChecked(Abeta_name.str().c_str(), "TSpline3");
126  std::stringstream Atheta_name;
127  Atheta_name << "A_theta_" << runNumber;
128  TSpline3* par_A_theta = (TSpline3*)file->GetObjectChecked(Atheta_name.str().c_str(), "TSpline3");
129 
130  std::stringstream Calpha_name;
131  Calpha_name << "C_alpha_" << runNumber;
132  TSpline3* par_C_alpha = (TSpline3*)file->GetObjectChecked(Calpha_name.str().c_str(), "TSpline3");
133  std::stringstream Cbeta_name;
134  Cbeta_name << "C_beta_" << runNumber;
135  TSpline3* par_C_beta = (TSpline3*)file->GetObjectChecked(Cbeta_name.str().c_str(), "TSpline3");
136  std::stringstream Ctheta_name;
137  Ctheta_name << "C_theta_" << runNumber;
138  TSpline3* par_C_theta = (TSpline3*)file->GetObjectChecked(Ctheta_name.str().c_str(), "TSpline3");
139 
140  std::stringstream Err_Aalpha_name;
141  Err_Aalpha_name << "A_alpha_error_" << runNumber;
142  TSpline3* parErr_A_alpha = (TSpline3*)file->GetObjectChecked(Err_Aalpha_name.str().c_str(), "TSpline3");
143  std::stringstream Err_Abeta_name;
144  Err_Abeta_name << "A_beta_error_" << runNumber;
145  TSpline3* parErr_A_beta = (TSpline3*)file->GetObjectChecked(Err_Abeta_name.str().c_str(), "TSpline3");
146  std::stringstream Err_Atheta_name;
147  Err_Atheta_name << "A_theta_error_" << runNumber;
148  TSpline3* parErr_A_theta = (TSpline3*)file->GetObjectChecked(Err_Atheta_name.str().c_str(), "TSpline3");
149 
150  std::stringstream Err_Calpha_name;
151  Err_Calpha_name << "C_alpha_error_" << runNumber;
152  TSpline3* parErr_C_alpha = (TSpline3*)file->GetObjectChecked(Err_Calpha_name.str().c_str(), "TSpline3");
153  std::stringstream Err_Cbeta_name;
154  Err_Cbeta_name << "C_beta_error_" << runNumber;
155  TSpline3* parErr_C_beta = (TSpline3*)file->GetObjectChecked(Err_Cbeta_name.str().c_str(), "TSpline3");
156  std::stringstream Err_Ctheta_name;
157  Err_Ctheta_name << "C_theta_error_" << runNumber;
158  TSpline3* parErr_C_theta = (TSpline3*)file->GetObjectChecked(Err_Ctheta_name.str().c_str(), "TSpline3");
159 
160 
161  std::stringstream Cov_A_alpha_beta_name;
162  Cov_A_alpha_beta_name << "cov_A_alpha_beta_" << runNumber;
163  TSpline3* cov_A_alpha_beta = (TSpline3*)file->GetObjectChecked(Cov_A_alpha_beta_name.str().c_str(), "TSpline3");
164  std::stringstream Cov_A_alpha_theta_name;
165  Cov_A_alpha_theta_name << "cov_A_alpha_theta_" << runNumber;
166  TSpline3* cov_A_alpha_theta = (TSpline3*)file->GetObjectChecked(Cov_A_alpha_theta_name.str().c_str(), "TSpline3");
167  std::stringstream Cov_A_beta_theta_name;
168  Cov_A_beta_theta_name << "cov_A_beta_theta_" << runNumber;
169  TSpline3* cov_A_beta_theta = (TSpline3*)file->GetObjectChecked(Cov_A_beta_theta_name.str().c_str(), "TSpline3");
170 
171  std::stringstream Cov_C_alpha_beta_name;
172  Cov_C_alpha_beta_name << "cov_C_alpha_beta_" << runNumber;
173  TSpline3* cov_C_alpha_beta = (TSpline3*)file->GetObjectChecked(Cov_C_alpha_beta_name.str().c_str(), "TSpline3");
174  std::stringstream Cov_C_alpha_theta_name;
175  Cov_C_alpha_theta_name << "cov_C_alpha_theta_" << runNumber;
176  TSpline3* cov_C_alpha_theta = (TSpline3*)file->GetObjectChecked(Cov_C_alpha_theta_name.str().c_str(), "TSpline3");
177  std::stringstream Cov_C_beta_theta_name;
178  Cov_C_beta_theta_name << "cov_C_beta_theta_" << runNumber;
179  TSpline3* cov_C_beta_theta = (TSpline3*)file->GetObjectChecked(Cov_C_beta_theta_name.str().c_str(), "TSpline3");
180 
181  std::array<std::vector<TSpline3*>, 2> effparams;
182  std::array<std::vector<TSpline3*>, 2> effparamErrors;
183  std::array<std::vector<TSpline3*>, 2> effparamsCorrCoeffs;
184  //side0: C; side1: A
185  effparams[0] = {par_C_alpha, par_C_beta, par_C_theta};
186  effparams[1] = {par_A_alpha, par_A_beta, par_A_theta};
187  effparamErrors[0] = {parErr_C_alpha, parErr_C_beta, parErr_C_theta};
188  effparamErrors[1] = {parErr_A_alpha, parErr_A_beta, parErr_A_theta};
189  effparamsCorrCoeffs[0] = {cov_C_alpha_beta, cov_C_alpha_theta, cov_C_beta_theta};
190  effparamsCorrCoeffs[1] = {cov_A_alpha_beta, cov_A_alpha_theta, cov_A_beta_theta};
191 
192  ATH_MSG_DEBUG("Trying to set parameters and errors at " << m_zdcTriggerEfficiency);
193 
194  m_zdcTriggerEfficiency->SetEffParamsAndErrors(effparams, effparamErrors);
195  m_zdcTriggerEfficiency->SetEffParamCorrCoeffs(effparamsCorrCoeffs);
196 
197  return;
198 
199 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ MakeMessageFunction()

ZDCMsg::MessageFunctionPtr ZDC::ZdcAnalysisTool::MakeMessageFunction ( )
inline

Definition at line 80 of file ZdcAnalysisTool.h.

81  {
82  std::function<bool(int, std::string)> msgFunction = [this](int messageZdcLevel, const std::string& message)-> bool
83  {
84  MSG::Level messageAthenaLevel = static_cast<MSG::Level>(messageZdcLevel);
85  bool passesStreamOutputLevel = messageAthenaLevel >= this->msg().level();
86  if (passesStreamOutputLevel) {
87  this->msg(messageAthenaLevel) << message << endmsg;
88  }
89  return passesStreamOutputLevel;
90  };
91 
92  return ZDCMsg::MessageFunctionPtr(new ZDCMsg::MessageFunction(msgFunction));
93  }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const
inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns
The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

101  {
102 
103  return MSG::name( msg().level() );
104  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ print() [1/2]

void asg::AsgTool::print ( ) const
virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, LundVariablesTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

131  {
132 
133  ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134  return;
135  }

◆ print() [2/2]

virtual void asg::IAsgTool::print ( ) const
pure virtualinherited

Print the state of the tool.

Implemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, LundVariablesTool, asg::AsgTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

◆ recoZdcModules()

StatusCode ZDC::ZdcAnalysisTool::recoZdcModules ( const xAOD::ZdcModuleContainer &  moduleContainer,
const xAOD::ZdcModuleContainer &  moduleSumContainer 
)
overridevirtual

Implements ZDC::IZdcAnalysisTool.

Definition at line 2616 of file ZdcAnalysisTool.cxx.

2617 {
2618 
2619  if (moduleContainer.size()==0) return StatusCode::SUCCESS; // if no modules, do nothing
2620 
2621  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
2622  if (!eventInfo.isValid()) return StatusCode::FAILURE;
2623 
2624  // Check for decoding errors and bail out if ZDC error found
2625  bool zdcErr = eventInfo->isEventFlagBitSet(xAOD::EventInfo::ForwardDet, ZdcEventInfo::ZDCDECODINGERROR );
2626  if (zdcErr)
2627  {
2628  ATH_MSG_WARNING("ZDC decoding error found - abandoning ZDC reco!");
2629  return StatusCode::SUCCESS;
2630  }
2631 
2632  // check for new run number, if new, possibly update configuration and/or calibrations
2633  //
2634  unsigned int thisRunNumber = eventInfo->runNumber();
2635  if (thisRunNumber != m_runNumber) {
2636  ATH_MSG_DEBUG("ZDC analysis tool will be configured for run " << thisRunNumber);
2637 
2638  ATH_CHECK(configureNewRun(thisRunNumber)); // ALWAYS check methods that return StatusCode
2639 
2640  ATH_MSG_DEBUG("Setting up calibrations");
2641 
2642  if (m_doFADCCorr)
2643  {
2644  unsigned int calibRunNumber = thisRunNumber;
2645  if (m_forceCalibRun > -1) calibRunNumber = m_forceCalibRun;
2646  try
2647  {
2648  setFADCCorrections(calibRunNumber);
2649  }
2650  catch(std::runtime_error&)
2651  {
2652  m_doFADCCorr = false;
2653  }
2654  }
2655 
2656  if (m_doCalib) {
2657  //
2658  // Check for calibration override
2659  //
2660  unsigned int calibRunNumber = thisRunNumber;
2661  if (m_forceCalibRun > -1) calibRunNumber = m_forceCalibRun;
2662  try
2663  {
2664  setEnergyCalibrations(calibRunNumber);
2665  }
2666  catch(std::runtime_error&)
2667  {
2668  m_doCalib = false;
2669  }
2670 
2671  if (m_doTrigEff) initializeTriggerEffs(calibRunNumber); // if energy calibrations fail to load, then so will trigger efficiencies
2672  if (m_doTimeCalib) setTimeCalibrations(calibRunNumber);
2673  }
2674 
2675  m_runNumber = thisRunNumber;
2676  }
2677 
2678  m_lumiBlock = eventInfo->lumiBlock();
2679 
2680  unsigned int calibLumiBlock = m_lumiBlock;
2681  if (m_doCalib) {
2682  if (m_forceCalibRun > 0) calibLumiBlock = m_forceCalibLB;
2683  }
2684 
2685  ATH_MSG_DEBUG("Starting event processing");
2686  ATH_MSG_DEBUG("LB=" << calibLumiBlock);
2687 
2688  m_zdcDataAnalyzer->StartEvent(calibLumiBlock);
2689 
2690  static const SG::ConstAccessor<std::vector<uint16_t> > g0dataAcc ("g0data");
2691  static const SG::ConstAccessor<std::vector<uint16_t> > g1dataAcc ("g1data");
2692 
2693  const std::vector<unsigned short>* adcUndelayLG = 0;
2694  const std::vector<unsigned short>* adcUndelayHG = 0;
2695 
2696  const std::vector<unsigned short>* adcDelayLG = 0;
2697  const std::vector<unsigned short>* adcDelayHG = 0;
2698 
2699  ATH_MSG_DEBUG("Processing modules");
2700  for (const auto zdcModule : moduleContainer)
2701  {
2702  int side = -1;
2703  if (zdcModule->zdcSide() == -1) side = 0;
2704  else if (zdcModule->zdcSide() == 1) side = 1;
2705  else {
2706  // Invalid side
2707  //
2708  ATH_MSG_WARNING("Invalid side value found for module number: " << zdcModule->zdcModule() << ", side value = " << side);
2709  continue;
2710  }
2711  // Ignore MC only modules
2712  if(zdcModule->zdcModule() > 4) continue;
2713 
2714  if (zdcModule->zdcType() == 0) {
2715  //
2716  // This is ZDC data
2717  //
2718  if (m_LHCRun==3) // no delay channels, so we drop the index
2719  {
2720  adcUndelayLG = &g0dataAcc(*zdcModule); // g0
2721  adcUndelayHG = &g1dataAcc(*zdcModule); // g1
2722  }
2723  else if (m_LHCRun==2)
2724  {
2725 
2726 
2727  static const SG::ConstAccessor<std::vector<uint16_t> > g0d1dataAcc ("g0d1data");
2728  static const SG::ConstAccessor<std::vector<uint16_t> > g1d1dataAcc ("g1d1data");
2729  static const SG::ConstAccessor<std::vector<uint16_t> > g0d0dataAcc ("g0d0data");
2730  static const SG::ConstAccessor<std::vector<uint16_t> > g1d0dataAcc ("g1d0data");
2731 
2732  if (zdcModule->zdcModule() == 0 && m_flipEMDelay) // flip delay/non-delay for 2015 ONLY
2733  {
2734  adcUndelayLG = &g0d1dataAcc(*zdcModule); // g0d1
2735  adcUndelayHG = &g1d1dataAcc(*zdcModule); // g1d1
2736  adcDelayLG = &g0d0dataAcc(*zdcModule); // g0d0
2737  adcDelayHG = &g1d0dataAcc(*zdcModule); // g1d0
2738  }
2739  else // nominal configuation
2740  {
2741  adcUndelayLG = &g0d0dataAcc(*zdcModule); // g0d0
2742  adcUndelayHG = &g1d0dataAcc(*zdcModule); // g1d0
2743  adcDelayLG = &g0d1dataAcc(*zdcModule); // g0d1
2744  adcDelayHG = &g1d1dataAcc(*zdcModule); // g1d1
2745  }
2746  }
2747  else
2748  {
2749  ATH_MSG_WARNING("Unknown LHC Run " << m_LHCRun);
2750  return StatusCode::FAILURE;
2751  }
2752 
2753  // Why were these static? to optimize processing time
2754  std::vector<float> HGUndelADCSamples(m_numSample);
2755  std::vector<float> LGUndelADCSamples(m_numSample);
2756 
2757  if (LGUndelADCSamples.size() < adcUndelayLG->size()) {
2758  LGUndelADCSamples.resize(adcUndelayLG->size());
2759  }
2760 
2761  if (HGUndelADCSamples.size() < adcUndelayHG->size()) {
2762  HGUndelADCSamples.resize(adcUndelayHG->size());
2763  }
2764 
2765  std::copy(adcUndelayLG->begin(), adcUndelayLG->end(), LGUndelADCSamples.begin());
2766  std::copy(adcUndelayHG->begin(), adcUndelayHG->end(), HGUndelADCSamples.begin());
2767 
2768  int side = (zdcModule->zdcSide() == -1) ? 0 : 1 ;
2769 
2770  if (!m_combineDelay) {
2771  m_zdcDataAnalyzer->LoadAndAnalyzeData(side, zdcModule->zdcModule(), HGUndelADCSamples, LGUndelADCSamples);
2772  }
2773  else {
2774  std::vector<float> HGDelayADCSamples(m_numSample);
2775  std::vector<float> LGDelayADCSamples(m_numSample);
2776  if (adcDelayLG and adcDelayHG){
2777  std::copy(adcDelayLG->begin(), adcDelayLG->end(), LGDelayADCSamples.begin());
2778  std::copy(adcDelayHG->begin(), adcDelayHG->end(), HGDelayADCSamples.begin());
2779  }else{
2780  ATH_MSG_ERROR("adcDelayLG or adcDelayHG pointers are null");
2781  return StatusCode::FAILURE;
2782  }
2783  // If the delayed channels actually come earlier (as in the pPb in 2016), we invert the meaning of delayed and undelayed
2784  // see the initialization sections for similar inversion on the sign of the pedestal difference
2785  //
2786 
2787  m_zdcDataAnalyzer->LoadAndAnalyzeData(side, zdcModule->zdcModule(),
2788  HGUndelADCSamples, LGUndelADCSamples,
2789  HGDelayADCSamples, LGDelayADCSamples);
2790  }
2791  }
2792  }
2793 
2794  ATH_MSG_DEBUG("Finishing event processing");
2795 
2796  m_zdcDataAnalyzer->FinishEvent();
2797 
2798  ATH_MSG_DEBUG("Adding variables with suffix=" + m_auxSuffix);
2799 
2800  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleAmplitude(m_zdcModuleAmplitude);
2801  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleCalibEnergy(m_zdcModuleCalibEnergy);
2802  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleCalibTime(m_zdcModuleCalibTime);
2803  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcModuleStatus(m_zdcModuleStatus);
2804  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleTime(m_zdcModuleTime);
2805  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleChisq(m_zdcModuleChisq);
2806  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleAmpNoNonLin(m_zdcModuleAmpNoNonLin);
2807  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitAmp(m_zdcModuleFitAmp);
2808  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitAmpError(m_zdcModuleFitAmpError);
2809  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitT0(m_zdcModuleFitT0);
2810  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleBkgdMaxFraction(m_zdcModuleBkgdMaxFraction);
2811  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModulePreSampleAmp(m_zdcModulePreSampleAmp);
2812  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModulePresample(m_zdcModulePresample);
2813  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMinDeriv2nd(m_zdcModuleMinDeriv2nd);
2814  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMaxADC(m_zdcModuleMaxADC);
2815  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMaxADCHG(m_zdcModuleMaxADCHG);
2816  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMaxADCLG(m_zdcModuleMaxADCLG);
2817 
2818  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleAmpLGRefit(m_zdcModuleAmpLGRefit);
2819  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitAmpLGRefit(m_zdcModuleFitAmpLGRefit);
2820  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleAmpCorrLGRefit(m_zdcModuleAmpCorrLGRefit);
2821  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleT0LGRefit(m_zdcModuleT0LGRefit);
2822  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleT0SubLGRefit(m_zdcModuleT0SubLGRefit);
2823  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleChisqLGRefit(m_zdcModuleChisqLGRefit);
2824 
2825  // CalibTime
2826  // Status
2827  // Time
2828  // Chisq
2829  // AmpNoNonLin
2830  // FitAmp
2831  // FitAmpError
2832  // FitT0
2833  // BkgdMaxFraction
2834  // PreSampleAmp
2835  // Presample
2836  // MinDeriv2nd
2837  // MaxADC
2838 
2839  for (const auto zdcModule : moduleContainer)
2840  {
2841  int side = (zdcModule->zdcSide() == -1) ? 0 : 1 ;
2842  int mod = zdcModule->zdcModule();
2843  // Ignore MC only modules
2844  if(mod > 4) continue;
2845 
2846  if (zdcModule->zdcType() == 0) {
2847  // this is the main ZDC
2848  if (m_writeAux) {
2849  float calibEnergy = m_zdcDataAnalyzer->GetModuleCalibAmplitude(side, mod);
2850  zdcModuleCalibEnergy(*zdcModule) = calibEnergy;
2851  zdcModuleCalibTime(*zdcModule) = m_zdcDataAnalyzer->GetModuleCalibTime(side, mod);
2852 
2853  zdcModuleAmplitude(*zdcModule) = m_zdcDataAnalyzer->GetModuleAmplitude(side, mod);
2854  zdcModuleStatus(*zdcModule) = m_zdcDataAnalyzer->GetModuleStatus(side, mod);
2855  zdcModuleTime(*zdcModule) = m_zdcDataAnalyzer->GetModuleTime(side, mod);
2856 
2857  const ZDCPulseAnalyzer* pulseAna_p = m_zdcDataAnalyzer->GetPulseAnalyzer(side, mod);
2858  zdcModuleChisq(*zdcModule) = pulseAna_p->GetChisq();
2859  zdcModuleAmpNoNonLin(*zdcModule) = pulseAna_p->GetAmpNoNonLin();
2860  zdcModuleFitAmp(*zdcModule) = pulseAna_p->GetFitAmplitude();
2861  zdcModuleFitAmpError(*zdcModule) = pulseAna_p->GetAmpError();
2862  zdcModuleFitT0(*zdcModule) = pulseAna_p->GetFitT0();
2863  zdcModuleBkgdMaxFraction(*zdcModule) = pulseAna_p->GetBkgdMaxFraction();
2864  zdcModulePreSampleAmp(*zdcModule) = pulseAna_p->GetPreSampleAmp();
2865  zdcModulePresample(*zdcModule) = pulseAna_p->getPresample();
2866  zdcModuleMinDeriv2nd(*zdcModule) = pulseAna_p->GetMinDeriv2nd();
2867  zdcModuleMaxADC(*zdcModule) = pulseAna_p->getMaxADCSub();
2868  zdcModuleMaxADCHG(*zdcModule) = pulseAna_p->getMaxADCHG();
2869  zdcModuleMaxADCLG(*zdcModule) = pulseAna_p->getMaxADCLG();
2870 
2871  zdcModuleAmpLGRefit(*zdcModule) = pulseAna_p->getRefitLGAmp();
2872  zdcModuleFitAmpLGRefit(*zdcModule) = pulseAna_p->getRefitLGFitAmp();
2873  zdcModuleAmpCorrLGRefit(*zdcModule) = pulseAna_p->getRefitLGAmpCorr();
2874  zdcModuleT0LGRefit(*zdcModule) = pulseAna_p->getRefitLGTime();
2875  zdcModuleT0SubLGRefit(*zdcModule) = pulseAna_p->getRefitLGTimeSub();
2876  zdcModuleChisqLGRefit(*zdcModule) = pulseAna_p->getRefitLGChisq();
2877  }
2878  //ATH_MSG_DEBUG ("side = " << side << " module=" << zdcModule->zdcModule() << " CalibEnergy=" << zdcModule->auxdecor<float>("CalibEnergy")
2879  // << " should be " << m_zdcDataAnalyzer->GetModuleCalibAmplitude(side, mod));
2880  }
2881  }
2882 
2883  // Output sum information
2884  // In Run 3 - we have to assume the container already exists (since it is needed to store the per-side trigger info)
2885  // reprocessing will add new variables with the suffix
2886 
2887  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumUncalibSum(m_zdcSumUncalibSum);
2888  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumUncalibSumErr(m_zdcSumUncalibSumErr);
2889  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumCalibEnergy(m_zdcSumCalibEnergy);
2890  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumCalibEnergyErr(m_zdcSumCalibEnergyErr);
2891  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumNLCalibEnergy(m_zdcSumNLCalibEnergy);
2892  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumNLCalibEnergyErr(m_zdcSumNLCalibEnergyErr);
2893  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumFinalEnergy(m_zdcSumFinalEnergy);
2894  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumAverageTime(m_zdcSumAverageTime);
2895  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcSumStatus(m_zdcSumStatus);
2896  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcSumModuleMask(m_zdcSumModuleMask);
2897 
2898  for (const auto zdc_sum: moduleSumContainer)
2899  {
2900  ATH_MSG_DEBUG("Extracting ZDC side " << zdc_sum->zdcSide());
2901 
2902  if (zdc_sum->zdcSide()==0) continue; // skip new global sum
2903 
2904  int iside = (zdc_sum->zdcSide()==-1) ? 0 : 1;
2905 
2906  float uncalibSum = getUncalibModuleSum(iside);
2907  zdcSumUncalibSum(*zdc_sum) = uncalibSum;
2908  float uncalibSumErr = getUncalibModuleSumErr(iside);
2909  zdcSumUncalibSumErr(*zdc_sum) = uncalibSumErr;
2910 
2911  float calibEnergy = getCalibModuleSum(iside);
2912  zdcSumCalibEnergy(*zdc_sum) = calibEnergy;
2913  float calibEnergyErr = getCalibModuleSumErr(iside);
2914  zdcSumCalibEnergyErr(*zdc_sum) = calibEnergyErr;
2915 
2916  float nlcalibEnergy = getNLCalibModuleSum(iside);
2917  zdcSumNLCalibEnergy(*zdc_sum) = nlcalibEnergy;
2918  float nlcalibEnergyErr = getNLCalibModuleSumErr(iside);
2919  zdcSumNLCalibEnergyErr(*zdc_sum) = nlcalibEnergyErr;
2920 
2921  float finalEnergy = calibEnergy;
2922  zdcSumFinalEnergy(*zdc_sum) = finalEnergy;
2923  zdcSumAverageTime(*zdc_sum) = getAverageTime(iside);
2924  zdcSumStatus(*zdc_sum) = !sideFailed(iside);
2925  zdcSumModuleMask(*zdc_sum) = (getModuleMask() >> (4 * iside)) & 0xF;
2926  }
2927 
2928  return StatusCode::SUCCESS;
2929 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ reprocessZdc()

StatusCode ZDC::ZdcAnalysisTool::reprocessZdc ( )
overridevirtual

Implements ZDC::IZdcAnalysisTool.

Definition at line 3164 of file ZdcAnalysisTool.cxx.

3165 {
3166  if (!m_init)
3167  {
3168  ATH_MSG_WARNING("Tool not initialized!");
3169  return StatusCode::FAILURE;
3170  }
3171  m_eventReady = false;
3172  ATH_MSG_DEBUG ("Trying to retrieve " << m_zdcModuleContainerName);
3173 
3174  m_zdcModules = 0;
3175  ATH_CHECK(evtStore()->retrieve(m_zdcModules, m_zdcModuleContainerName));
3176 
3177  m_zdcSums = 0;
3178  ATH_CHECK(evtStore()->retrieve(m_zdcSums, m_zdcSumContainerName));
3179 
3180  m_eventReady = true;
3181 
3182  ATH_CHECK(recoZdcModules(*m_zdcModules, *m_zdcSums));
3183 
3184  return StatusCode::SUCCESS;
3185 }

◆ SetDebugLevel()

static void ZDC::ZdcAnalysisTool::SetDebugLevel ( int  debugLevel = 0)
inlinestatic

Definition at line 75 of file ZdcAnalysisTool.h.

76  {
77  s_debugLevel = debugLevel;
78  }

◆ setEnergyCalibrations()

void ZDC::ZdcAnalysisTool::setEnergyCalibrations ( unsigned int  runNumber)

Definition at line 2931 of file ZdcAnalysisTool.cxx.

2932 {
2933 
2934  char name[128];
2935 
2936  std::string filename;
2937  if (m_LHCRun==3)
2938  {
2939  filename = PathResolverFindCalibFile( ("ZdcAnalysis/ZdcCalib_Run"+TString::Itoa(runNumber,10)+".root").Data() );
2940  }
2941  else if (m_LHCRun==2)
2942  {
2943  filename = PathResolverFindCalibFile( ("ZdcAnalysis/" + m_zdcEnergyCalibFileName).c_str() );
2944  }
2945  else
2946  {
2947  ATH_MSG_WARNING("No LHC Run defined, so no calibration allowed");
2948  return;
2949  }
2950 
2951  ATH_MSG_INFO("Opening energy calibration file " << filename);
2952  std::unique_ptr<TFile> fCalib (TFile::Open(filename.c_str(), "READ"));
2953 
2954  if (fCalib == nullptr || fCalib->IsZombie())
2955  {
2956  ATH_MSG_INFO ("failed to open file: " << filename);
2957  throw std::runtime_error ("failed to open file " + filename);
2958  }
2959 
2960  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> splines;
2961 
2962  // "m_calibVersion", called CalibVersion when settings parameters in python, is a directory within the run-based calibration file
2963  TString calibVersion;
2964  if (m_calibVersion != "") calibVersion = m_calibVersion + "/";
2965 
2966  for (int iside = 0; iside < 2; iside++)
2967  {
2968  for (int imod = 0; imod < 4; imod++)
2969  {
2970  sprintf(name, "ZDC_Ecalib_run%u_s%d_m%d", runNumber, iside, imod);
2971  ATH_MSG_DEBUG("Searching for spline " << name);
2972  TSpline3* s = (TSpline3*) fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3");
2973  if (!s && m_doCalib)
2974  {
2975  ATH_MSG_WARNING("No calibrations for run " << runNumber);
2976  m_doCalib = false;
2977  }
2978 
2979  if (s)
2980  {
2981  splines[iside][imod].reset (s);
2982  }
2983  else
2984  {
2985  ATH_MSG_WARNING("No spline " << name);
2986  }
2987  }
2988  }
2989  fCalib->Close();
2990 
2991  if (m_doCalib) m_zdcDataAnalyzer->LoadEnergyCalibrations(splines);
2992 
2993  return;
2994 }

◆ setFADCCorrections()

void ZDC::ZdcAnalysisTool::setFADCCorrections ( unsigned int  runNumber = 0)

Definition at line 3071 of file ZdcAnalysisTool.cxx.

3072 {
3073  std::string filename;
3074 
3075  if (m_LHCRun==3) {
3076  std::string runString;
3077 
3078  if (runNumber == 0) runString = "ZdcFADCCorr_" + m_configuration + "_default.root";
3079  else runString = ("ZdcFADCCorr_Run"+TString::Itoa(runNumber,10)+".root").Data();
3080 
3081  filename = PathResolverFindCalibFile("ZdcAnalysis/" + runString );
3082  }
3083  else {
3084  ATH_MSG_WARNING("setFADCCorrections: FADC corrections not implemented for Run 2");
3085  return;
3086  }
3087 
3088  if (filename.empty())
3089  {
3090  ATH_MSG_INFO("FADC correction requested but no calibration file found");
3091  m_doFADCCorr = false;
3092  return;
3093  }
3094 
3095  ATH_MSG_INFO("Opening FADC corrections file " << filename);
3096  std::unique_ptr<TFile> fFADCCorr(TFile::Open(filename.c_str(), "READ"));
3097 
3098  if (!fFADCCorr->IsOpen()) {
3099  ATH_MSG_INFO ("setFADCCorrections: failed to open file: " << filename);
3100  throw std::runtime_error ("ZdcAnalysisTool failed to open FADCCorrections file " + filename);
3101  }
3102 
3103  // Attempt to read histograms with corrections from file
3104  //
3105  bool readSuccess = true;
3106  std::array<std::array<std::unique_ptr<const TH1>, 4>, 2> histogramsHG;
3107  std::array<std::array<std::unique_ptr<const TH1>, 4>, 2> histogramsLG;
3108 
3109  for (size_t side : {0, 1}) {
3110  for (int module : {0, 1, 2, 3}) {
3111  std::string histNameHG = "ZDC_FADCCorr_s" + std::to_string(side) + "_m" + std::to_string(module)+"_HG";
3112  std::string histNameLG = "ZDC_FADCCorr_s" + std::to_string(side) + "_m" + std::to_string(module)+"_LG";
3113 
3114  ATH_MSG_DEBUG("setFADCCorrections: Searching for histograms HG and LG: " << histNameHG << ", " << histNameLG);
3115 
3116  TH1* histHG_ptr = static_cast<TH1*>(fFADCCorr->GetObjectChecked(histNameHG.c_str(), "TH1"));
3117  TH1* histLG_ptr = static_cast<TH1*>(fFADCCorr->GetObjectChecked(histNameLG.c_str(), "TH1"));
3118 
3119  if (!histHG_ptr || !histLG_ptr) {
3120  std::string errMsg = "setFADCCorrections: unable to read FADC correction histogram(s) ";
3121  if (!histHG_ptr) errMsg += histNameHG + " ";
3122  if (!histLG_ptr) errMsg += histNameLG;
3123 
3124  ATH_MSG_ERROR(errMsg);
3125  readSuccess = false;
3126  break;
3127  }
3128  else {
3129  //
3130  // Check for valid range (Lion uses -0.5 to 4095.5)
3131  //
3132 
3133  if ( std::abs(histHG_ptr->GetXaxis()->GetXmin()+0.5) > 1e-3 || std::abs(histHG_ptr->GetXaxis()->GetXmax() - 4095.5) > 1e-3) {
3134  ATH_MSG_ERROR("setFADCCorrections: invalid axis range for HG FADC corrections in histogram with name " << histNameHG);
3135  readSuccess = false;
3136  break;
3137  }
3138  if (std::abs(histLG_ptr->GetXaxis()->GetXmin()+0.5) > 1e-3 || std::abs(histLG_ptr->GetXaxis()->GetXmax() - 4095.5) > 1e-3) {
3139  ATH_MSG_ERROR("setFADCCorrections: invalid axis range for HG FADC corrections in histogram with name " << histNameLG);
3140  readSuccess = false;
3141  break;
3142  }
3143 
3144  histogramsHG[side][module].reset(histHG_ptr);
3145  histogramsLG[side][module].reset(histLG_ptr);
3146  }
3147  }
3148  }
3149 
3150  fFADCCorr->Close();
3151 
3152  if (readSuccess) {
3153  m_zdcDataAnalyzer->enableFADCCorrections(m_doFADCCorrPerSample, histogramsHG, histogramsLG);
3154  }
3155  else {
3156  ATH_MSG_ERROR("setFADCCorrections: due to at least one error, FADC corrections are not implemented");
3157  m_doFADCCorr = false;
3158  }
3159 
3160  return;
3161 }

◆ setTimeCalibrations()

void ZDC::ZdcAnalysisTool::setTimeCalibrations ( unsigned int  runNumber)

Definition at line 2996 of file ZdcAnalysisTool.cxx.

2997 {
2998  std::string filename;
2999 
3000  if (m_LHCRun==3)
3001  {
3002  filename = PathResolverFindCalibFile( ("ZdcAnalysis/ZdcCalib_Run"+TString::Itoa(runNumber,10)+".root").Data() );
3003  }
3004  else if (m_LHCRun==2)
3005  {
3006  filename = PathResolverFindCalibFile( "ZdcAnalysis/" + m_zdcTimeCalibFileName );
3007  }
3008  else
3009  {
3010  ATH_MSG_WARNING("No LHC Run defined, so no time calibration allowed");
3011  return;
3012  }
3013 
3014  char name[128] = {0};
3015  ATH_MSG_INFO("Opening time calibration file " << filename);
3016  std::unique_ptr<TFile> fCalib (TFile::Open(filename.c_str(), "READ"));
3017 
3018  // "m_calibVersion", called CalibVersion when settings parameters in python, is a directory within the run-based calibration file
3019  TString calibVersion = "";
3020  if (m_calibVersion != "") calibVersion = m_calibVersion + "/";
3021 
3022  if (fCalib && !fCalib->IsZombie())
3023  {
3024  bool success = true;
3025  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> T0HGOffsetSplines;
3026  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> T0LGOffsetSplines;
3027  std::unique_ptr<TSpline3> spline;
3028  for (int iside = 0; iside < 2; iside++)
3029  {
3030  for (int imod = 0; imod < 4; imod++)
3031  {
3032  sprintf(name, "ZDC_T0calib_run%u_HG_s%d_m%d", runNumber, iside, imod);
3033  spline.reset (static_cast<TSpline3*>(fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3")));
3034  if (spline)
3035  {
3036  T0HGOffsetSplines[iside][imod] = std::move (spline);
3037  }
3038  else
3039  {
3040  ATH_MSG_WARNING("No time calib. spline " << calibVersion+name);
3041  success = false;
3042  }
3043 
3044  sprintf(name, "ZDC_T0calib_run%u_LG_s%d_m%d", runNumber, iside, imod);
3045  spline.reset (static_cast<TSpline3*>(fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3")));
3046  if (spline)
3047  {
3048  T0LGOffsetSplines[iside][imod] = std::move (spline);
3049  }
3050  else
3051  {
3052  ATH_MSG_WARNING("No time calib. spline " << calibVersion+name);
3053  success = false;
3054  }
3055  }
3056  }
3057 
3058  if (success)
3059  m_zdcDataAnalyzer->LoadT0Calibrations(T0HGOffsetSplines, T0LGOffsetSplines);
3060  else
3061  ATH_MSG_WARNING("Time calibration failed - no T0 offsets loaded " << calibVersion+name);
3062 
3063  fCalib->Close();
3064  }
3065  else
3066  {
3067  ATH_MSG_WARNING("No time calibration file " << filename);
3068  }
3069 }

◆ sideFailed()

bool ZDC::ZdcAnalysisTool::sideFailed ( int  side)

Definition at line 3277 of file ZdcAnalysisTool.cxx.

3278 {
3279  if (!m_zdcDataAnalyzer) return 0;
3280  return m_zdcDataAnalyzer->SideFailed(side);
3281 }

◆ sigprocMaxFinder()

bool ZDC::ZdcAnalysisTool::sigprocMaxFinder ( const std::vector< unsigned short > &  adc,
float  deltaT,
float &  amp,
float &  time,
float &  qual 
)
static

Definition at line 3187 of file ZdcAnalysisTool.cxx.

3188 {
3189  size_t nsamp = adc.size();
3190  float presamp = adc.at(0);
3191  unsigned short max_adc = 0;
3192  int max_index = -1;
3193  for (size_t i = 0; i < nsamp; i++)
3194  {
3195  if (adc[i] > max_adc)
3196  {
3197  max_adc = adc[i];
3198  max_index = i;
3199  }
3200  }
3201  amp = max_adc - presamp;
3202  time = max_index * deltaT;
3203  qual = 1.;
3204 
3205  if (max_index == -1)
3206  {
3207  qual = 0.;
3208  return false;
3209  }
3210 
3211  return true;
3212 }

◆ sigprocSincInterp()

bool ZDC::ZdcAnalysisTool::sigprocSincInterp ( const std::vector< unsigned short > &  adc,
float  deltaT,
float &  amp,
float &  time,
float &  qual 
)

Definition at line 3214 of file ZdcAnalysisTool.cxx.

3215 {
3216  size_t nsamp = adc.size();
3217  float presamp = adc.at(0);
3218  m_tf1SincInterp->SetParameter(0, deltaT);
3219  for (size_t i = 0; i < nsamp; i++)
3220  {
3221  m_tf1SincInterp->SetParameter(i + 1, adc.at(i) - presamp);
3222  }
3223  amp = m_tf1SincInterp->GetMaximum();
3224  time = m_tf1SincInterp->GetMaximumX();
3225  qual = 1.;
3226  return true;
3227 }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_auxSuffix

std::string ZDC::ZdcAnalysisTool::m_auxSuffix
private

Definition at line 142 of file ZdcAnalysisTool.h.

◆ m_calibVersion

std::string ZDC::ZdcAnalysisTool::m_calibVersion
private

Definition at line 170 of file ZdcAnalysisTool.h.

◆ m_ChisqRatioCut

float ZDC::ZdcAnalysisTool::m_ChisqRatioCut
private

Definition at line 186 of file ZdcAnalysisTool.h.

◆ m_combineDelay

bool ZDC::ZdcAnalysisTool::m_combineDelay {false}
private

Definition at line 161 of file ZdcAnalysisTool.h.

◆ m_configuration

std::string ZDC::ZdcAnalysisTool::m_configuration
private

Definition at line 135 of file ZdcAnalysisTool.h.

◆ m_delayDeltaT

float ZDC::ZdcAnalysisTool::m_delayDeltaT
private

Definition at line 180 of file ZdcAnalysisTool.h.

◆ m_deltaTCut

float ZDC::ZdcAnalysisTool::m_deltaTCut
private

Definition at line 185 of file ZdcAnalysisTool.h.

◆ m_deltaTSample

float ZDC::ZdcAnalysisTool::m_deltaTSample
private

Definition at line 175 of file ZdcAnalysisTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doCalib

bool ZDC::ZdcAnalysisTool::m_doCalib {false}
private

Definition at line 162 of file ZdcAnalysisTool.h.

◆ m_doFADCCorr

bool ZDC::ZdcAnalysisTool::m_doFADCCorr {false}
private

Definition at line 165 of file ZdcAnalysisTool.h.

◆ m_doFADCCorrPerSample

bool ZDC::ZdcAnalysisTool::m_doFADCCorrPerSample {false}
private

Definition at line 167 of file ZdcAnalysisTool.h.

◆ m_doNonLinCorr

bool ZDC::ZdcAnalysisTool::m_doNonLinCorr {false}
private

Definition at line 166 of file ZdcAnalysisTool.h.

◆ m_doTimeCalib

bool ZDC::ZdcAnalysisTool::m_doTimeCalib {false}
private

Definition at line 164 of file ZdcAnalysisTool.h.

◆ m_doTrigEff

bool ZDC::ZdcAnalysisTool::m_doTrigEff {false}
private

Definition at line 163 of file ZdcAnalysisTool.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> ZDC::ZdcAnalysisTool::m_eventInfoKey
private
Initial value:
{
this, "EventInfoKey", "EventInfo",
"Location of the event info."}

Definition at line 151 of file ZdcAnalysisTool.h.

◆ m_eventReady

bool ZDC::ZdcAnalysisTool::m_eventReady
private

Definition at line 144 of file ZdcAnalysisTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_fixTau1

bool ZDC::ZdcAnalysisTool::m_fixTau1
private

Definition at line 183 of file ZdcAnalysisTool.h.

◆ m_fixTau2

bool ZDC::ZdcAnalysisTool::m_fixTau2
private

Definition at line 184 of file ZdcAnalysisTool.h.

◆ m_flipEMDelay

bool ZDC::ZdcAnalysisTool::m_flipEMDelay
private

Definition at line 159 of file ZdcAnalysisTool.h.

◆ m_forceCalibLB

int ZDC::ZdcAnalysisTool::m_forceCalibLB
private

Definition at line 169 of file ZdcAnalysisTool.h.

◆ m_forceCalibRun

int ZDC::ZdcAnalysisTool::m_forceCalibRun
private

Definition at line 168 of file ZdcAnalysisTool.h.

◆ m_init

bool ZDC::ZdcAnalysisTool::m_init
private

Definition at line 134 of file ZdcAnalysisTool.h.

◆ m_LHCRun

int ZDC::ZdcAnalysisTool::m_LHCRun
private

Definition at line 188 of file ZdcAnalysisTool.h.

◆ m_lowGainMode

unsigned int ZDC::ZdcAnalysisTool::m_lowGainMode
private

Definition at line 160 of file ZdcAnalysisTool.h.

◆ m_lumiBlock

unsigned int ZDC::ZdcAnalysisTool::m_lumiBlock
private

Definition at line 146 of file ZdcAnalysisTool.h.

◆ m_name

std::string ZDC::ZdcAnalysisTool::m_name
private

Definition at line 133 of file ZdcAnalysisTool.h.

◆ m_numSample

unsigned int ZDC::ZdcAnalysisTool::m_numSample
private

Definition at line 174 of file ZdcAnalysisTool.h.

◆ m_peak2ndDerivMinSamples

ZDCDataAnalyzer::ZDCModuleIntArray ZDC::ZdcAnalysisTool::m_peak2ndDerivMinSamples {}
private

Definition at line 196 of file ZdcAnalysisTool.h.

◆ m_peak2ndDerivMinThresholdsHG

ZDCDataAnalyzer::ZDCModuleFloatArray ZDC::ZdcAnalysisTool::m_peak2ndDerivMinThresholdsHG {}
private

Definition at line 197 of file ZdcAnalysisTool.h.

◆ m_peak2ndDerivMinThresholdsLG

ZDCDataAnalyzer::ZDCModuleFloatArray ZDC::ZdcAnalysisTool::m_peak2ndDerivMinThresholdsLG {}
private

Definition at line 198 of file ZdcAnalysisTool.h.

◆ m_Peak2ndDerivThresh

float ZDC::ZdcAnalysisTool::m_Peak2ndDerivThresh
private

Definition at line 178 of file ZdcAnalysisTool.h.

◆ m_peakSample

unsigned int ZDC::ZdcAnalysisTool::m_peakSample
private

Definition at line 177 of file ZdcAnalysisTool.h.

◆ m_presample

unsigned int ZDC::ZdcAnalysisTool::m_presample
private

Definition at line 176 of file ZdcAnalysisTool.h.

◆ m_runNumber

unsigned int ZDC::ZdcAnalysisTool::m_runNumber
private

Definition at line 145 of file ZdcAnalysisTool.h.

◆ m_t0

float ZDC::ZdcAnalysisTool::m_t0
private

Definition at line 179 of file ZdcAnalysisTool.h.

◆ m_tau1

float ZDC::ZdcAnalysisTool::m_tau1
private

Definition at line 181 of file ZdcAnalysisTool.h.

◆ m_tau2

float ZDC::ZdcAnalysisTool::m_tau2
private

Definition at line 182 of file ZdcAnalysisTool.h.

◆ m_tf1SincInterp

std::unique_ptr<TF1> ZDC::ZdcAnalysisTool::m_tf1SincInterp
private

Definition at line 149 of file ZdcAnalysisTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_writeAux

bool ZDC::ZdcAnalysisTool::m_writeAux
private

Definition at line 141 of file ZdcAnalysisTool.h.

◆ m_zdcAnalysisConfigPath

std::string ZDC::ZdcAnalysisTool::m_zdcAnalysisConfigPath
private

Definition at line 136 of file ZdcAnalysisTool.h.

◆ m_zdcDataAnalyzer

std::shared_ptr<ZDCDataAnalyzer> ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer
private

Definition at line 192 of file ZdcAnalysisTool.h.

◆ m_zdcDataAnalyzer_40MHz

std::shared_ptr<ZDCDataAnalyzer> ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer_40MHz
private

Definition at line 193 of file ZdcAnalysisTool.h.

◆ m_zdcDataAnalyzer_80MHz

std::shared_ptr<ZDCDataAnalyzer> ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer_80MHz
private

Definition at line 194 of file ZdcAnalysisTool.h.

◆ m_zdcEnergyCalibFileName

std::string ZDC::ZdcAnalysisTool::m_zdcEnergyCalibFileName
private

Definition at line 137 of file ZdcAnalysisTool.h.

◆ m_zdcModuleAmpCorrLGRefit

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleAmpCorrLGRefit {this, "ZdcModuleAmpCorrLGRefit", "", "ZDC module amp LG refit, with both gain factor and nonlinear correction applied"}
private

Definition at line 230 of file ZdcAnalysisTool.h.

◆ m_zdcModuleAmpLGRefit

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleAmpLGRefit {this, "ZdcModuleAmpLGRefit", "", "ZDC module amp LG refit, with gain factor applied but no nonlinear correction"}
private

Definition at line 229 of file ZdcAnalysisTool.h.

◆ m_zdcModuleAmplitude

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleAmplitude {this, "ZdcModuleAmplitude", "", "ZDC module amplitude"}
private

Definition at line 207 of file ZdcAnalysisTool.h.

◆ m_zdcModuleAmpNoNonLin

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleAmpNoNonLin {this, "ZdcModuleAmpNoNonLin", "", "ZDC module amplitude with gain factor applied but no nonlinear correction"}
private

Definition at line 214 of file ZdcAnalysisTool.h.

◆ m_zdcModuleBkgdMaxFraction

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleBkgdMaxFraction {this, "ZdcModuleBkgdMaxFraction", "", "ZDC module background max fraction"}
private

Definition at line 218 of file ZdcAnalysisTool.h.

◆ m_zdcModuleCalibEnergy

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleCalibEnergy {this, "ZdcModuleCalibEnergy", "", "ZDC module calibrated energy"}
private

Definition at line 208 of file ZdcAnalysisTool.h.

◆ m_zdcModuleCalibTime

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleCalibTime {this, "ZdcModuleCalibTime", "", "ZDC module calibrated time"}
private

Definition at line 210 of file ZdcAnalysisTool.h.

◆ m_zdcModuleChisq

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleChisq {this, "ZdcModuleChisq", "", "ZDC module fit chisq"}
private

Definition at line 213 of file ZdcAnalysisTool.h.

◆ m_zdcModuleChisqLGRefit

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleChisqLGRefit {this, "ZdcModuleChisqLGRefit", "", "ZDC module LG refit chi square"}
private

Definition at line 233 of file ZdcAnalysisTool.h.

◆ m_zdcModuleContainerName

std::string ZDC::ZdcAnalysisTool::m_zdcModuleContainerName
private

Definition at line 155 of file ZdcAnalysisTool.h.

◆ m_zdcModuleFitAmp

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleFitAmp {this, "ZdcModuleFitAmp", "", "ZDC module fit amp"}
private

Definition at line 215 of file ZdcAnalysisTool.h.

◆ m_zdcModuleFitAmpError

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleFitAmpError {this, "ZdcModuleFitAmpError", "", "ZDC module fit amp error"}
private

Definition at line 216 of file ZdcAnalysisTool.h.

◆ m_zdcModuleFitAmpLGRefit

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleFitAmpLGRefit {this, "ZdcModuleFitAmpLGRefit", "", "ZDC module fit amp LG refit, with no gain factor or nonlinear correction applied"}
private

Definition at line 228 of file ZdcAnalysisTool.h.

◆ m_zdcModuleFitT0

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleFitT0 {this, "ZdcModuleFitT0", "", "ZDC module fit t0"}
private

Definition at line 217 of file ZdcAnalysisTool.h.

◆ m_zdcModuleMaxADC

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleMaxADC {this, "ZdcModuleMaxADC", "", "ZDC module max ADC, minus pre-sample"}
private

Definition at line 222 of file ZdcAnalysisTool.h.

◆ m_zdcModuleMaxADCHG

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleMaxADCHG {this, "ZdcModuleMaxADCHG", "", "ZDC module HG max ADC, unsubtracted"}
private

Definition at line 223 of file ZdcAnalysisTool.h.

◆ m_zdcModuleMaxADCLG

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleMaxADCLG {this, "ZdcModuleMaxADCLG", "", "ZDC module LG max ADC, unsubtracted"}
private

Definition at line 224 of file ZdcAnalysisTool.h.

◆ m_zdcModuleMinDeriv2nd

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleMinDeriv2nd {this, "ZdcModuleMinDeriv2nd", "", "ZDC module min 2nd derivative"}
private

Definition at line 221 of file ZdcAnalysisTool.h.

◆ m_zdcModuleNLCalibEnergy

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleNLCalibEnergy {this, "ZdcModuleNLCalibEnergy", "", "ZDC module NL calibrated energy"}
private

Definition at line 209 of file ZdcAnalysisTool.h.

◆ m_zdcModulePresample

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModulePresample {this, "ZdcModulePresample", "", "ZDC module presample"}
private

Definition at line 220 of file ZdcAnalysisTool.h.

◆ m_zdcModulePreSampleAmp

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModulePreSampleAmp {this, "ZdcModulePreSampleAmp", "", "ZDC module presample amplitude"}
private

Definition at line 219 of file ZdcAnalysisTool.h.

◆ m_zdcModules

const xAOD::ZdcModuleContainer* ZDC::ZdcAnalysisTool::m_zdcModules {nullptr}
private

Definition at line 156 of file ZdcAnalysisTool.h.

◆ m_zdcModuleStatus

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleStatus {this, "ZdcModuleStatus", "", "ZDC module fit status"}
private

Definition at line 211 of file ZdcAnalysisTool.h.

◆ m_zdcModuleT0LGRefit

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleT0LGRefit {this, "ZdcModuleT0LGRefit", "", "ZDC module fit t0 LG refit"}
private

Definition at line 231 of file ZdcAnalysisTool.h.

◆ m_zdcModuleT0SubLGRefit

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleT0SubLGRefit {this, "ZdcModuleT0SubLGRefit", "", "ZDC module subtracted t0 LG refit"}
private

Definition at line 232 of file ZdcAnalysisTool.h.

◆ m_zdcModuleTime

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleTime {this, "ZdcModuleTime", "", "ZDC module time"}
private

Definition at line 212 of file ZdcAnalysisTool.h.

◆ m_zdcSumAverageTime

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumAverageTime {this, "ZdcSumAverageTime", "", "ZDC side average time"}
private

Definition at line 244 of file ZdcAnalysisTool.h.

◆ m_zdcSumCalibEnergy

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergy {this, "ZdcSumCalibEnergy", "", "ZDC side calibrated energy"}
private

Definition at line 238 of file ZdcAnalysisTool.h.

◆ m_zdcSumCalibEnergyErr

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergyErr {this, "ZdcSumCalibEnergyErr", "", "ZDC side calibrated energy error"}
private

Definition at line 239 of file ZdcAnalysisTool.h.

◆ m_zdcSumContainerName

std::string ZDC::ZdcAnalysisTool::m_zdcSumContainerName
private

Definition at line 157 of file ZdcAnalysisTool.h.

◆ m_zdcSumFinalEnergy

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumFinalEnergy {this, "ZdcSumFinalEnergy", "", "ZDC side final energy"}
private

Definition at line 242 of file ZdcAnalysisTool.h.

◆ m_zdcSumFinalEnergyErr

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumFinalEnergyErr {this, "ZdcSumFinalEnergyErr", "", "ZDC side final energy error"}
private

Definition at line 243 of file ZdcAnalysisTool.h.

◆ m_zdcSumModuleMask

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumModuleMask {this, "ZdcSumModuleMask", "", "ZDC side module mask"}
private

Definition at line 246 of file ZdcAnalysisTool.h.

◆ m_zdcSumNLCalibEnergy

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumNLCalibEnergy {this, "ZdcSumNLCalibEnergy", "", "ZDC side NL calibrated energy"}
private

Definition at line 240 of file ZdcAnalysisTool.h.

◆ m_zdcSumNLCalibEnergyErr

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumNLCalibEnergyErr {this, "ZdcSumNLCalibEnergyErr", "", "ZDC side NL calibrated energy error"}
private

Definition at line 241 of file ZdcAnalysisTool.h.

◆ m_zdcSums

const xAOD::ZdcModuleContainer* ZDC::ZdcAnalysisTool::m_zdcSums {nullptr}
private

Definition at line 158 of file ZdcAnalysisTool.h.

◆ m_zdcSumStatus

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumStatus {this, "ZdcSumStatus", "", "ZDC side status"}
private

Definition at line 245 of file ZdcAnalysisTool.h.

◆ m_zdcSumUncalibSum

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumUncalibSum {this, "ZdcSumUncalibSum", "", "ZDC side uncalibrated sum"}
private

Definition at line 236 of file ZdcAnalysisTool.h.

◆ m_zdcSumUncalibSumErr

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumUncalibSumErr {this, "ZdcSumUncalibSumErr", "", "ZDC side uncalibrated sum error"}
private

Definition at line 237 of file ZdcAnalysisTool.h.

◆ m_zdcTimeCalibFileName

std::string ZDC::ZdcAnalysisTool::m_zdcTimeCalibFileName
private

Definition at line 138 of file ZdcAnalysisTool.h.

◆ m_zdcTriggerEfficiency

std::shared_ptr<ZDCTriggerEfficiency> ZDC::ZdcAnalysisTool::m_zdcTriggerEfficiency
private

Definition at line 201 of file ZdcAnalysisTool.h.

◆ m_zdcTriggerEffParamsFileName

std::string ZDC::ZdcAnalysisTool::m_zdcTriggerEffParamsFileName
private

Definition at line 139 of file ZdcAnalysisTool.h.

◆ s_debugLevel

std::atomic<int> ZDC::ZdcAnalysisTool::s_debugLevel
staticprivate

Definition at line 203 of file ZdcAnalysisTool.h.

The documentation for this class was generated from the following files:
ZDC::ZdcAnalysisTool::m_zdcTriggerEffParamsFileName
std::string m_zdcTriggerEffParamsFileName
Definition: ZdcAnalysisTool.h:139
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ZDC::ZdcAnalysisTool::m_zdcModuleMaxADCHG
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMaxADCHG
Definition: ZdcAnalysisTool.h:223
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ZDC::ZdcAnalysisTool::MakeMessageFunction
ZDCMsg::MessageFunctionPtr MakeMessageFunction()
Definition: ZdcAnalysisTool.h:80
ZDC::ZdcAnalysisTool::m_zdcModuleContainerName
std::string m_zdcModuleContainerName
Definition: ZdcAnalysisTool.h:155
ZDC::ZdcAnalysisTool::initializeInjectorpp2024
std::unique_ptr< ZDCDataAnalyzer > initializeInjectorpp2024()
Definition: ZdcAnalysisTool.cxx:1318
ZDCPulseAnalyzer::getRefitLGAmp
float getRefitLGAmp() const
Definition: ZDCPulseAnalyzer.h:601
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
ZDC::ZdcAnalysisTool::m_zdcSumNLCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumNLCalibEnergy
Definition: ZdcAnalysisTool.h:240
ZDC::ZdcAnalysisTool::m_doFADCCorr
bool m_doFADCCorr
Definition: ZdcAnalysisTool.h:165
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinSamples
ZDCDataAnalyzer::ZDCModuleIntArray m_peak2ndDerivMinSamples
Definition: ZdcAnalysisTool.h:196
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:407
ZDC::ZdcAnalysisTool::m_runNumber
unsigned int m_runNumber
Definition: ZdcAnalysisTool.h:145
ZDC::ZdcAnalysisTool::m_Peak2ndDerivThresh
float m_Peak2ndDerivThresh
Definition: ZdcAnalysisTool.h:178
ZDC::ZdcAnalysisTool::initializeInjectorpOOONeNe2025
std::unique_ptr< ZDCDataAnalyzer > initializeInjectorpOOONeNe2025()
Definition: ZdcAnalysisTool.cxx:1535
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ZDC::ZdcAnalysisTool::m_zdcModuleChisq
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleChisq
Definition: ZdcAnalysisTool.h:213
ZDC::ZdcAnalysisTool::m_zdcModules
const xAOD::ZdcModuleContainer * m_zdcModules
Definition: ZdcAnalysisTool.h:156
ZDC::ZdcAnalysisTool::initializePbPb2024
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2024()
Definition: ZdcAnalysisTool.cxx:633
ParticleDataType::Data
@ Data
Definition: Event/EventKernel/EventKernel/IParticle.h:36
ZDC::ZdcAnalysisTool::m_zdcModuleCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibEnergy
Definition: ZdcAnalysisTool.h:208
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinThresholdsLG
ZDCDataAnalyzer::ZDCModuleFloatArray m_peak2ndDerivMinThresholdsLG
Definition: ZdcAnalysisTool.h:198
ZDCPulseAnalyzer::getMaxADCLG
float getMaxADCLG() const
Definition: ZDCPulseAnalyzer.h:639
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
ZDC::ZdcAnalysisTool::m_doTrigEff
bool m_doTrigEff
Definition: ZdcAnalysisTool.h:163
ZDC::ZdcAnalysisTool::m_ChisqRatioCut
float m_ChisqRatioCut
Definition: ZdcAnalysisTool.h:186
ZDC::ZdcAnalysisTool::m_LHCRun
int m_LHCRun
Definition: ZdcAnalysisTool.h:188
ZDCDataAnalyzer::ZDCModuleFloatArray
std::array< std::array< float, 4 >, 2 > ZDCModuleFloatArray
Definition: ZDCDataAnalyzer.h:22
ZDCPulseAnalyzer::GetAmpError
float GetAmpError() const
Definition: ZDCPulseAnalyzer.h:598
ZDC::ZdcAnalysisTool::m_fixTau1
bool m_fixTau1
Definition: ZdcAnalysisTool.h:183
ZDCPulseAnalyzer::getRefitLGTime
float getRefitLGTime() const
Definition: ZDCPulseAnalyzer.h:625
ALFA_EventTPCnv_Dict::t0
std::vector< ALFA_RawData_p1 > t0
Definition: ALFA_EventTPCnvDict.h:42
ZDC::ZdcAnalysisTool::m_zdcModuleFitAmp
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmp
Definition: ZdcAnalysisTool.h:215
ZDCPulseAnalyzer::GetAmpNoNonLin
float GetAmpNoNonLin() const
Definition: ZDCPulseAnalyzer.h:596
ZDC::ZdcAnalysisTool::getUncalibModuleSumErr
float getUncalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:3265
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
ZDC::ZdcAnalysisTool::m_doTimeCalib
bool m_doTimeCalib
Definition: ZdcAnalysisTool.h:164
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
ZDCDataAnalyzer::ZDCModuleIntArray
std::array< std::array< int, 4 >, 2 > ZDCModuleIntArray
Definition: ZDCDataAnalyzer.h:24
ZDC::ZdcAnalysisTool::m_zdcModuleAmpNoNonLin
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmpNoNonLin
Definition: ZdcAnalysisTool.h:214
ZDC::ZdcAnalysisTool::initializepO2025B
std::unique_ptr< ZDCDataAnalyzer > initializepO2025B()
Definition: ZdcAnalysisTool.cxx:1151
ZDC::ZdcAnalysisTool::initializepp2024
std::unique_ptr< ZDCDataAnalyzer > initializepp2024()
Definition: ZdcAnalysisTool.cxx:379
ZDC::ZdcAnalysisTool::m_zdcAnalysisConfigPath
std::string m_zdcAnalysisConfigPath
Definition: ZdcAnalysisTool.h:136
ZDC::SincInterp
double SincInterp(const double *xvec, const double *pvec)
Definition: ZdcSincInterp.cxx:11
ZDC::ZdcAnalysisTool::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: ZdcAnalysisTool.h:151
ZDC::ZdcAnalysisTool::m_presample
unsigned int m_presample
Definition: ZdcAnalysisTool.h:176
ZDC::ZdcAnalysisTool::m_zdcSumModuleMask
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumModuleMask
Definition: ZdcAnalysisTool.h:246
ZDCPulseAnalyzer
Definition: ZDCPulseAnalyzer.h:22
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ZDC::ZdcAnalysisTool::m_zdcModuleStatus
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleStatus
Definition: ZdcAnalysisTool.h:211
ZDC::ZdcAnalysisTool::m_zdcSumAverageTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumAverageTime
Definition: ZdcAnalysisTool.h:244
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
ZDCPulseAnalyzer::getRefitLGTimeSub
float getRefitLGTimeSub() const
Definition: ZDCPulseAnalyzer.h:631
ZDC::ZdcAnalysisTool::m_tf1SincInterp
std::unique_ptr< TF1 > m_tf1SincInterp
Definition: ZdcAnalysisTool.h:149
ZDC::ZdcAnalysisTool::m_tau1
float m_tau1
Definition: ZdcAnalysisTool.h:181
ReweightUtils.message
message
Definition: ReweightUtils.py:15
ZDC::ZdcAnalysisTool::m_lowGainMode
unsigned int m_lowGainMode
Definition: ZdcAnalysisTool.h:160
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
ZDCDataAnalyzer::SetCutValues
void SetCutValues(const ZDCModuleFloatArray &chisqDivAmpCutHG, const ZDCModuleFloatArray &chisqDivAmpCutLG, const ZDCModuleFloatArray &deltaT0MinHG, const ZDCModuleFloatArray &deltaT0MaxHG, const ZDCModuleFloatArray &deltaT0MinLG, const ZDCModuleFloatArray &deltaT0MaxLG)
Definition: ZDCDataAnalyzer.cxx:296
ZDC::ZdcAnalysisTool::setFADCCorrections
void setFADCCorrections(unsigned int runNumber=0)
Definition: ZdcAnalysisTool.cxx:3071
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TRT::Hit::side
@ side
Definition: HitInfo.h:83
ZDCDataAnalyzer
Definition: ZDCDataAnalyzer.h:20
ZDC::ZdcAnalysisTool::m_zdcSumStatus
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumStatus
Definition: ZdcAnalysisTool.h:245
ZDC::ZdcAnalysisTool::m_zdcModuleAmplitude
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmplitude
Definition: ZdcAnalysisTool.h:207
ZDC::ZdcAnalysisTool::sideFailed
bool sideFailed(int side)
Definition: ZdcAnalysisTool.cxx:3277
ZDC::ZdcAnalysisTool::getModuleSum
float getModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:3229
ZDC::ZdcAnalysisTool::initializepp2023
std::unique_ptr< ZDCDataAnalyzer > initializepp2023()
Definition: ZdcAnalysisTool.cxx:290
ZDC::ZdcAnalysisTool::m_zdcSumFinalEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumFinalEnergy
Definition: ZdcAnalysisTool.h:242
python.PyAthena.module
module
Definition: PyAthena.py:131
ZDC::ZdcAnalysisTool::m_lumiBlock
unsigned int m_lumiBlock
Definition: ZdcAnalysisTool.h:146
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
ZDCPulseAnalyzer::TimingCorrLog
@ TimingCorrLog
Definition: ZDCPulseAnalyzer.h:57
ZDC::ZdcAnalysisTool::setEnergyCalibrations
void setEnergyCalibrations(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:2931
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ZDC::ZdcAnalysisTool::m_delayDeltaT
float m_delayDeltaT
Definition: ZdcAnalysisTool.h:180
ZDC::ZdcAnalysisTool::m_doNonLinCorr
bool m_doNonLinCorr
Definition: ZdcAnalysisTool.h:166
ZDC::ZdcAnalysisTool::m_init
bool m_init
Definition: ZdcAnalysisTool.h:134
ZDCPulseAnalyzer::getPresample
float getPresample() const
Definition: ZDCPulseAnalyzer.h:637
ZDCPulseAnalyzer::getMaxADCHG
float getMaxADCHG() const
Definition: ZDCPulseAnalyzer.h:638
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
ZDC::ZdcAnalysisTool::getCalibModuleSumErr
float getCalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:3241
AthCommonDataStore
Definition: AthCommonDataStore.h:52
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ZDC::ZdcAnalysisTool::m_zdcSumUncalibSum
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumUncalibSum
Definition: ZdcAnalysisTool.h:236
ZDCDataAnalyzer::SetNoiseSigmas
void SetNoiseSigmas(const ZDCModuleFloatArray &noiseSigmasHG, const ZDCModuleFloatArray &noiseSigmasLG)
Definition: ZDCDataAnalyzer.cxx:248
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
ZDCPulseAnalyzer::getRefitLGFitAmp
float getRefitLGFitAmp() const
Definition: ZDCPulseAnalyzer.h:607
ZdcEventInfo::ZDCDECODINGERROR
@ ZDCDECODINGERROR
Definition: ZdcEventInfo.h:19
lumiFormat.i
int i
Definition: lumiFormat.py:85
ZDC::ZdcAnalysisTool::initializeInjectorPbPb2024
std::unique_ptr< ZDCDataAnalyzer > initializeInjectorPbPb2024()
Definition: ZdcAnalysisTool.cxx:1444
ZDC::ZdcAnalysisTool::m_combineDelay
bool m_combineDelay
Definition: ZdcAnalysisTool.h:161
ZDC::ZdcAnalysisTool::m_numSample
unsigned int m_numSample
Definition: ZdcAnalysisTool.h:174
ZDC::ZdcAnalysisTool::m_zdcSumNLCalibEnergyErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumNLCalibEnergyErr
Definition: ZdcAnalysisTool.h:241
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ZDC::ZdcAnalysisTool::initializepPb2016
std::unique_ptr< ZDCDataAnalyzer > initializepPb2016()
Definition: ZdcAnalysisTool.cxx:1908
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
ZDC::ZdcAnalysisTool::m_forceCalibLB
int m_forceCalibLB
Definition: ZdcAnalysisTool.h:169
ZDC::ZdcAnalysisTool::initializePbPb2023
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2023()
Definition: ZdcAnalysisTool.cxx:468
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
ZDC::ZdcAnalysisTool::getNLCalibModuleSum
float getNLCalibModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:3247
ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer_80MHz
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer_80MHz
Definition: ZdcAnalysisTool.h:194
ZDC::ZdcAnalysisTool::m_zdcModuleChisqLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleChisqLGRefit
Definition: ZdcAnalysisTool.h:233
ZDC::ZdcAnalysisTool::getNLCalibModuleSumErr
float getNLCalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:3253
ZDCDataAnalyzer::SetADCOverUnderflowValues
void SetADCOverUnderflowValues(const ZDCModuleFloatArray &HGOverflowADC, const ZDCModuleFloatArray &HGUnderflowADC, const ZDCModuleFloatArray &LGOverflowADC)
Definition: ZDCDataAnalyzer.cxx:286
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
file
TFile * file
Definition: tile_monitor.h:29
ZDC::ZdcAnalysisTool::m_zdcModuleMaxADC
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMaxADC
Definition: ZdcAnalysisTool.h:222
ZDCPulseAnalyzer::LGModeForceLG
@ LGModeForceLG
Definition: ZDCPulseAnalyzer.h:53
ZDC::ZdcAnalysisTool::m_zdcModuleFitT0
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitT0
Definition: ZdcAnalysisTool.h:217
ZDC::ZdcAnalysisTool::recoZdcModules
StatusCode recoZdcModules(const xAOD::ZdcModuleContainer &moduleContainer, const xAOD::ZdcModuleContainer &moduleSumContainer) override
Definition: ZdcAnalysisTool.cxx:2616
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
ZDC::ZdcAnalysisTool::getModuleMask
unsigned int getModuleMask()
Definition: ZdcAnalysisTool.cxx:3283
ZDCPulseAnalyzer::getMaxADCSub
float getMaxADCSub() const
Definition: ZDCPulseAnalyzer.h:643
DQHistogramMerge.debugLevel
debugLevel
Definition: DQHistogramMerge.py:40
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
ZDCPulseAnalyzer::TimingCorrLin
@ TimingCorrLin
Definition: ZDCPulseAnalyzer.h:57
ZDC::ZdcAnalysisTool::m_zdcModuleT0SubLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleT0SubLGRefit
Definition: ZdcAnalysisTool.h:232
ZDC::ZdcAnalysisTool::m_zdcModuleMinDeriv2nd
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMinDeriv2nd
Definition: ZdcAnalysisTool.h:221
ZDCDataAnalyzer::SetTauT0Values
void SetTauT0Values(const ZDCModuleBoolArray &fxiTau1, const ZDCModuleBoolArray &fxiTau2, const ZDCModuleFloatArray &tau1, const ZDCModuleFloatArray &tau2, const ZDCModuleFloatArray &t0HG, const ZDCModuleFloatArray &t0LG)
Definition: ZDCDataAnalyzer.cxx:236
ZDC::ZdcAnalysisTool::m_zdcModuleBkgdMaxFraction
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleBkgdMaxFraction
Definition: ZdcAnalysisTool.h:218
ZDC::ZdcAnalysisTool::m_zdcSumContainerName
std::string m_zdcSumContainerName
Definition: ZdcAnalysisTool.h:157
ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer
Definition: ZdcAnalysisTool.h:192
ZDC::ZdcAnalysisTool::setTimeCalibrations
void setTimeCalibrations(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:2996
xAOD::EventInfo_v1::ForwardDet
@ ForwardDet
The forward detectors.
Definition: EventInfo_v1.h:338
ZDC::ZdcAnalysisTool::m_tau2
float m_tau2
Definition: ZdcAnalysisTool.h:182
ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergyErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergyErr
Definition: ZdcAnalysisTool.h:239
ZDCDataAnalyzer::enableDelayed
void enableDelayed(float deltaT, const ZDCModuleFloatArray &undelayedDelayedPedestalDiff)
Definition: ZDCDataAnalyzer.cxx:113
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
ZDC::ZdcAnalysisTool::m_calibVersion
std::string m_calibVersion
Definition: ZdcAnalysisTool.h:170
ZDCMsg::MessageFunction
std::function< bool(int, std::string)> MessageFunction
Definition: ZDCMsg.h:12
ZDC::ZdcAnalysisTool::m_zdcModuleT0LGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleT0LGRefit
Definition: ZdcAnalysisTool.h:231
ZDC::ZdcAnalysisTool::m_zdcModuleAmpLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmpLGRefit
Definition: ZdcAnalysisTool.h:229
ZDC::ZdcAnalysisTool::m_writeAux
bool m_writeAux
Definition: ZdcAnalysisTool.h:141
ZDC::ZdcAnalysisTool::m_configuration
std::string m_configuration
Definition: ZdcAnalysisTool.h:135
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
ZDC::ZdcAnalysisTool::m_doFADCCorrPerSample
bool m_doFADCCorrPerSample
Definition: ZdcAnalysisTool.h:167
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
ZDC::ZdcAnalysisTool::m_forceCalibRun
int m_forceCalibRun
Definition: ZdcAnalysisTool.h:168
ZDC::ZdcAnalysisTool::m_deltaTCut
float m_deltaTCut
Definition: ZdcAnalysisTool.h:185
ZDCTriggerEfficiency
Definition: ZDCTriggerEfficiency.h:17
ZDC::ZdcAnalysisTool::m_zdcModuleCalibTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibTime
Definition: ZdcAnalysisTool.h:210
ZDC::ZdcAnalysisTool::s_debugLevel
static std::atomic< int > s_debugLevel
Definition: ZdcAnalysisTool.h:203
ZDC::ZdcAnalysisTool::m_zdcSums
const xAOD::ZdcModuleContainer * m_zdcSums
Definition: ZdcAnalysisTool.h:158
ZDCMsg::MessageFunctionPtr
std::shared_ptr< MessageFunction > MessageFunctionPtr
Definition: ZDCMsg.h:14
ZDCPulseAnalyzer::GetFitAmplitude
float GetFitAmplitude() const
Definition: ZDCPulseAnalyzer.h:581
ZDC::ZdcAnalysisTool::initializeLHCf2022
std::unique_ptr< ZDCDataAnalyzer > initializeLHCf2022()
Definition: ZdcAnalysisTool.cxx:201
ZDCPulseAnalyzer::getRefitLGChisq
float getRefitLGChisq() const
Definition: ZDCPulseAnalyzer.h:619
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:283
ZDCPulseAnalyzer::GetMinDeriv2nd
float GetMinDeriv2nd() const
Definition: ZDCPulseAnalyzer.h:670
ZDC::ZdcAnalysisTool::m_zdcTriggerEfficiency
std::shared_ptr< ZDCTriggerEfficiency > m_zdcTriggerEfficiency
Definition: ZdcAnalysisTool.h:201
ZDC::ZdcAnalysisTool::initializepO2025
std::unique_ptr< ZDCDataAnalyzer > initializepO2025()
Definition: ZdcAnalysisTool.cxx:984
ZDCPulseAnalyzer::GetFitT0
float GetFitT0() const
Definition: ZDCPulseAnalyzer.h:582
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
ZDC::ZdcAnalysisTool::m_zdcModuleFitAmpError
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmpError
Definition: ZdcAnalysisTool.h:216
ZDC::ZdcAnalysisTool::getAverageTime
float getAverageTime(int side)
Definition: ZdcAnalysisTool.cxx:3271
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ZDC::ZdcAnalysisTool::m_zdcModulePresample
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePresample
Definition: ZdcAnalysisTool.h:220
ZDCPulseAnalyzer::GetBkgdMaxFraction
float GetBkgdMaxFraction() const
Definition: ZDCPulseAnalyzer.h:676
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ZDC::ZdcAnalysisTool::initializeTriggerEffs
void initializeTriggerEffs(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:88
ZDC::ZdcAnalysisTool::m_zdcModuleTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleTime
Definition: ZdcAnalysisTool.h:212
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
ZDC::ZdcAnalysisTool::configureNewRun
StatusCode configureNewRun(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:2596
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ZDCDataAnalyzer::ZDCModuleBoolArray
std::array< std::array< bool, 4 >, 2 > ZDCModuleBoolArray
Definition: ZDCDataAnalyzer.h:23
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinThresholdsHG
ZDCDataAnalyzer::ZDCModuleFloatArray m_peak2ndDerivMinThresholdsHG
Definition: ZdcAnalysisTool.h:197
ZDC::ZdcAnalysisTool::initializeDefault
std::unique_ptr< ZDCDataAnalyzer > initializeDefault()
Definition: ZdcAnalysisTool.cxx:1782
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer_40MHz
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer_40MHz
Definition: ZdcAnalysisTool.h:193
ZDCPulseAnalyzer::getRefitLGAmpCorr
float getRefitLGAmpCorr() const
Definition: ZDCPulseAnalyzer.h:613
ZDCDataAnalyzer::SetFitTimeMax
void SetFitTimeMax(float tmax)
Definition: ZDCDataAnalyzer.cxx:222
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:23
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
ZDC::ZdcAnalysisTool::m_deltaTSample
float m_deltaTSample
Definition: ZdcAnalysisTool.h:175
ZDCPulseAnalyzer::LGModeRefitLG
@ LGModeRefitLG
Definition: ZDCPulseAnalyzer.h:54
ZDC::ZdcAnalysisTool::initializeMonteCarloPbPb2023
std::unique_ptr< ZDCDataAnalyzer > initializeMonteCarloPbPb2023()
Definition: ZdcAnalysisTool.cxx:1626
ZDC::ZdcAnalysisTool::m_zdcSumUncalibSumErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumUncalibSumErr
Definition: ZdcAnalysisTool.h:237
ZDC::ZdcAnalysisTool::m_zdcTimeCalibFileName
std::string m_zdcTimeCalibFileName
Definition: ZdcAnalysisTool.h:138
ZDC::ZdcAnalysisTool::m_peakSample
unsigned int m_peakSample
Definition: ZdcAnalysisTool.h:177
ZDC::ZdcAnalysisTool::m_zdcModuleFitAmpLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmpLGRefit
Definition: ZdcAnalysisTool.h:228
beamspotman.qual
qual
Definition: beamspotman.py:479
ZDC::ZdcAnalysisTool::getCalibModuleSum
float getCalibModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:3235
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
ZDC::ZdcAnalysisTool::initialize80MHz
void initialize80MHz()
Definition: ZdcAnalysisTool.cxx:2267
ZDCDataAnalyzer::enableRepass
void enableRepass(const ZDCModuleFloatArray &peak2ndDerivMinRepassHG, const ZDCModuleFloatArray &peak2ndDerivMinRepassLG)
Definition: ZDCDataAnalyzer.cxx:176
calibdata.copy
bool copy
Definition: calibdata.py:26
ZDC::ZdcAnalysisTool::initializePbPb2018
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2018()
Definition: ZdcAnalysisTool.cxx:2020
ZDC::ZdcAnalysisTool::m_flipEMDelay
bool m_flipEMDelay
Definition: ZdcAnalysisTool.h:159
ZDC::ZdcAnalysisTool::m_zdcModulePreSampleAmp
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePreSampleAmp
Definition: ZdcAnalysisTool.h:219
ZDCDataAnalyzer::SetPeak2ndDerivMinTolerances
void SetPeak2ndDerivMinTolerances(size_t tolerance)
Definition: ZDCDataAnalyzer.cxx:213
ZDCPulseAnalyzer::GetChisq
float GetChisq() const
Definition: ZDCPulseAnalyzer.h:586
ZDC::ZdcAnalysisTool::initializePbPb2015G4
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2015G4()
Definition: ZdcAnalysisTool.cxx:1845
ZDC::ZdcAnalysisTool::m_zdcEnergyCalibFileName
std::string m_zdcEnergyCalibFileName
Definition: ZdcAnalysisTool.h:137
ZDC::ZdcAnalysisTool::m_t0
float m_t0
Definition: ZdcAnalysisTool.h:179
ZDC::ZdcAnalysisTool::m_zdcModuleAmpCorrLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmpCorrLGRefit
Definition: ZdcAnalysisTool.h:230
python.DataFormatRates.env
env
Definition: DataFormatRates.py:32
SG::DataProxy
Definition: DataProxy.h:45
ZDC::ZdcAnalysisTool::initializeOONeNe2025
std::unique_ptr< ZDCDataAnalyzer > initializeOONeNe2025()
Definition: ZdcAnalysisTool.cxx:804
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
ZDCDataAnalyzer::SetSaveFitFunc
void SetSaveFitFunc(bool save)
Definition: ZDCDataAnalyzer.cxx:231
ZDC::ZdcAnalysisTool::m_doCalib
bool m_doCalib
Definition: ZdcAnalysisTool.h:162
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
ZDCDataAnalyzer::SetTimingCorrParams
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)
Definition: ZDCDataAnalyzer.cxx:309
ZDC::ZdcAnalysisTool::m_auxSuffix
std::string m_auxSuffix
Definition: ZdcAnalysisTool.h:142
ZDC::ZdcAnalysisTool::initialize40MHz
void initialize40MHz()
Definition: ZdcAnalysisTool.cxx:2147
ZDC::ZdcAnalysisTool::m_fixTau2
bool m_fixTau2
Definition: ZdcAnalysisTool.h:184
ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergy
Definition: ZdcAnalysisTool.h:238
fitman.k
k
Definition: fitman.py:528
ZDC::ZdcAnalysisTool::m_name
std::string m_name
Definition: ZdcAnalysisTool.h:133
ZDC::ZdcAnalysisTool::m_eventReady
bool m_eventReady
Definition: ZdcAnalysisTool.h:144
ZDC::ZdcAnalysisTool::m_zdcModuleMaxADCLG
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMaxADCLG
Definition: ZdcAnalysisTool.h:224
ZDCPulseAnalyzer::GetPreSampleAmp
float GetPreSampleAmp() const
Definition: ZDCPulseAnalyzer.h:675
ZDCDataAnalyzer::SetModuleAmpFractionLG
void SetModuleAmpFractionLG(const ZDCDataAnalyzer::ZDCModuleFloatArray &moduleAmpFractionLG)
Definition: ZDCDataAnalyzer.cxx:257
ZDC::ZdcAnalysisTool::getUncalibModuleSum
float getUncalibModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:3259
Generated on Sun Aug 31 2025 22:14:13 for ATLAS Offline Software by   doxygen 1.8.18