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 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 > &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 > initializeInjectorpp2024 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializeInjectorPbPb2024 ()
 
std::unique_ptr< ZDCDataAnalyzer > initializeMonteCarloPbPb2023 ()
 
StatusCode configureNewRun (unsigned int runNumber)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &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_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_zdcSumFinalEnergy {this, "ZdcSumFinalEnergy", "", "ZDC side final energy"}
 
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 1969 of file ZdcAnalysisTool.cxx.

1970 {
1971  ATH_MSG_DEBUG("Setting up new run " << runNumber);
1972 
1973  // We do nothing for the default configuration
1974  //
1975  if (m_configuration != "default") {
1976  if (m_configuration == "PbPb2015") {
1977  //
1978  // Two periods, 40 MHz and 80 MHz readout
1979  //
1980  if (runNumber < 287222) m_zdcDataAnalyzer = m_zdcDataAnalyzer_40MHz;
1981  else m_zdcDataAnalyzer = m_zdcDataAnalyzer_80MHz;
1982  }
1983  }
1984 
1985  return StatusCode::SUCCESS;
1986 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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 > &  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 > &  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 > &  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 > &  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 92 of file ZdcAnalysisTool.h.

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

◆ 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 2625 of file ZdcAnalysisTool.cxx.

2626 {
2627  if (!m_zdcDataAnalyzer) return 0;
2628  return m_zdcDataAnalyzer->GetAverageTime(side);
2629 }

◆ getCalibModuleSum()

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

Definition at line 2601 of file ZdcAnalysisTool.cxx.

2602 {
2603  if (!m_zdcDataAnalyzer) return 0;
2604  return m_zdcDataAnalyzer->GetCalibModuleSum(side);
2605 }

◆ getCalibModuleSumErr()

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

Definition at line 2607 of file ZdcAnalysisTool.cxx.

2608 {
2609  if (!m_zdcDataAnalyzer) return 0;
2610  return m_zdcDataAnalyzer->GetCalibModuleSumErr(side);
2611 }

◆ getDataAnalyzer()

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

Definition at line 70 of file ZdcAnalysisTool.h.

70 {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 2637 of file ZdcAnalysisTool.cxx.

2638 {
2639  if (!m_zdcDataAnalyzer) return 0;
2640  return m_zdcDataAnalyzer->GetModuleMask();
2641 }

◆ getModuleSum()

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

Definition at line 2595 of file ZdcAnalysisTool.cxx.

2596 {
2597  if (!m_zdcDataAnalyzer) return 0;
2598  return m_zdcDataAnalyzer->GetModuleSum(side);
2599 }

◆ 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  }

◆ 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 2643 of file ZdcAnalysisTool.cxx.

2644 {
2645  if (!m_doTrigEff) return -1;
2646 
2647  m_zdcTriggerEfficiency->UpdatelumiBlock(m_lumiBlock);
2648  float adcSum = getModuleSum(side);
2649  double eff = m_zdcTriggerEfficiency->GetEfficiency(side, adcSum);
2650  return eff;
2651 }

◆ getTriggerEfficiencyUncertainty()

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

Definition at line 2653 of file ZdcAnalysisTool.cxx.

2654 {
2655  if (!m_doCalib) return -1;
2656 
2657  m_zdcTriggerEfficiency->UpdatelumiBlock(m_lumiBlock);
2658  float adcSum = getModuleSum(side);
2659  std::pair<double, double> eff_pair = m_zdcTriggerEfficiency->GetEfficiencyAndError(msg(), side, adcSum);
2660  return eff_pair.second;
2661 }

◆ getUncalibModuleSum()

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

Definition at line 2613 of file ZdcAnalysisTool.cxx.

2614 {
2615  if (!m_zdcDataAnalyzer) return 0;
2616  return m_zdcDataAnalyzer->GetModuleSum(side);
2617 }

◆ getUncalibModuleSumErr()

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

Definition at line 2619 of file ZdcAnalysisTool.cxx.

2620 {
2621  if (!m_zdcDataAnalyzer) return 0;
2622  return m_zdcDataAnalyzer->GetModuleSumErr(side);
2623 }

◆ 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 1775 of file ZdcAnalysisTool.cxx.

1776 {
1777  m_tf1SincInterp.reset (new TF1("SincInterp", ZDC::SincInterp, -5., 160., 8));
1778  m_tf1SincInterp->SetNpx(300);
1779 
1780  // Set up calibrations
1781  //
1782  std::string filename = PathResolverFindCalibFile( "ZdcAnalysis/ZdcAnalysisConfig.conf" );
1783  TEnv env(filename.c_str());
1784 
1785  m_zdcEnergyCalibFileName = std::string(env.GetValue("ZdcEnergyCalibFileName", "ZdcCalibrations_v1.root"));
1786  ATH_MSG_INFO("ZDC energy calibration filename " << m_zdcEnergyCalibFileName);
1787  m_zdcTimeCalibFileName = std::string(env.GetValue("ZdcTimeCalibFileName", "ZdcTimeCalibrations_v1.root"));
1788  ATH_MSG_INFO("ZDC time calibration filename " << m_zdcTimeCalibFileName);
1789  m_zdcTriggerEffParamsFileName = std::string(env.GetValue("ZdcTriggerEffFileName", "ZdcTriggerEffParameters_v6.root"));
1790  ATH_MSG_INFO("ZDC trigger efficiencies filename " << m_zdcTriggerEffParamsFileName);
1791 
1792 
1793  if (m_forceCalibRun > -1) {
1794  ATH_MSG_DEBUG("CAREFUL: forcing calibration run/LB =" << m_forceCalibRun << "/" << m_forceCalibLB);
1795 
1796  if (m_forceCalibLB < 0) {
1797  ATH_MSG_ERROR("Invalid settings: Forced run > 0 but lumi block < 0");
1798  return StatusCode::FAILURE;
1799  }
1800  }
1801 
1802  // Use configuration to direct initialization
1803  //
1804  if (m_configuration == "default") {
1805  m_zdcDataAnalyzer = initializeDefault();
1806  }
1807  else if (m_configuration == "PbPb2015") {
1808  initialize80MHz();
1809  initialize40MHz();
1810 
1811  m_zdcDataAnalyzer = m_zdcDataAnalyzer_80MHz; // default
1812  }
1813  else if (m_configuration == "pPb2016") {
1814  m_zdcDataAnalyzer = initializepPb2016();
1815  }
1816  else if (m_configuration == "PbPb2018") {
1817  m_zdcDataAnalyzer = initializePbPb2018();
1818  }
1819  else if (m_configuration == "PbPb2015G4") {
1820  m_zdcDataAnalyzer = initializePbPb2015G4();
1821  }
1822  else if (m_configuration == "LHCf2022") {
1823  m_zdcDataAnalyzer = initializeLHCf2022();
1824  }
1825  else if (m_configuration == "pp2023") {
1826  m_zdcDataAnalyzer = initializepp2023();
1827  }
1828  else if (m_configuration == "pp2024") {
1829  m_zdcDataAnalyzer = initializepp2024();
1830  }
1831  else if (m_configuration == "PbPb2023") {
1832  m_zdcDataAnalyzer = initializePbPb2023();
1833  }
1834  else if (m_configuration == "PbPb2024") {
1835  m_zdcDataAnalyzer = initializePbPb2024();
1836  }
1837  else if (m_configuration == "Injectorpp2024") {
1838  m_zdcDataAnalyzer = initializeInjectorpp2024();
1839  }
1840  else if (m_configuration == "InjectorPbPb2024") {
1841  m_zdcDataAnalyzer = initializeInjectorPbPb2024();
1842  }
1843  else if (m_configuration == "MonteCarloPbPb2023") {
1844  m_zdcDataAnalyzer = initializeMonteCarloPbPb2023();
1845  }
1846  else {
1847  ATH_MSG_ERROR("Unknown configuration: " << m_configuration);
1848  return StatusCode::FAILURE;
1849  }
1850 
1851  // If an aux suffix is provided, prepend it with "_" so we don't have to do so at each use
1852  //
1853 
1854  ATH_MSG_INFO("Configuration: " << m_configuration);
1855  ATH_MSG_DEBUG("FlipEMDelay: " << m_flipEMDelay);
1856  ATH_MSG_DEBUG("LowGainMode: " << m_lowGainMode);
1857 
1858  ATH_MSG_DEBUG("Using Combined delayed and undelayed samples: " << m_combineDelay);
1859 
1860  ATH_MSG_DEBUG("WriteAux: " << m_writeAux);
1861  ATH_MSG_DEBUG("AuxSuffix: " << m_auxSuffix);
1862  ATH_MSG_DEBUG("DoCalib: " << m_doCalib);
1863  ATH_MSG_DEBUG("ForceCalibRun: " << m_forceCalibRun);
1864  ATH_MSG_DEBUG("ForceCalibLB: " << m_forceCalibLB);
1865  ATH_MSG_DEBUG("NumSampl: " << m_numSample);
1866  ATH_MSG_DEBUG("DeltaTSample: " << m_deltaTSample);
1867  ATH_MSG_DEBUG("Presample: " << m_presample);
1868  ATH_MSG_DEBUG("PeakSample: " << m_peakSample);
1869  ATH_MSG_DEBUG("Peak2ndDerivThresh: " << m_Peak2ndDerivThresh);
1870 
1871  if (m_combineDelay) ATH_MSG_DEBUG("DelayDeltaT: " << m_delayDeltaT);
1872 
1873  ATH_MSG_DEBUG("T0: " << m_t0);
1874  ATH_MSG_DEBUG("Tau1: " << m_tau1);
1875  ATH_MSG_DEBUG("Tau2: " << m_tau2);
1876  ATH_MSG_DEBUG("FixTau1: " << m_fixTau1);
1877  ATH_MSG_DEBUG("FixTau2: " << m_fixTau2);
1878  ATH_MSG_DEBUG("DeltaTCut: " << m_deltaTCut);
1879  ATH_MSG_DEBUG("ChisqRatioCut: " << m_ChisqRatioCut);
1880 
1881  ATH_CHECK( m_eventInfoKey.initialize());
1882 
1883  // Initialize decorations
1884 
1885  m_zdcModuleAmplitude = m_zdcModuleContainerName+".Amplitude"+m_auxSuffix;
1886  ATH_CHECK( m_zdcModuleAmplitude.initialize());
1887  m_zdcModuleCalibEnergy = m_zdcModuleContainerName+".CalibEnergy"+m_auxSuffix;
1888  ATH_CHECK( m_zdcModuleCalibEnergy.initialize());
1889  m_zdcModuleCalibTime = m_zdcModuleContainerName+".CalibTime"+m_auxSuffix;
1890  ATH_CHECK( m_zdcModuleCalibTime.initialize());
1891  m_zdcModuleStatus = m_zdcModuleContainerName+".Status"+m_auxSuffix;
1892  ATH_CHECK( m_zdcModuleStatus.initialize());
1893  m_zdcModuleTime = m_zdcModuleContainerName+".Time"+m_auxSuffix;
1894  ATH_CHECK( m_zdcModuleTime.initialize());
1895  m_zdcModuleChisq = m_zdcModuleContainerName+".Chisq"+m_auxSuffix;
1896  ATH_CHECK( m_zdcModuleChisq.initialize());
1897  m_zdcModuleAmpNoNonLin = m_zdcModuleContainerName+".AmpNoNonLin"+m_auxSuffix;
1898  ATH_CHECK( m_zdcModuleAmpNoNonLin.initialize());
1899  m_zdcModuleFitAmp = m_zdcModuleContainerName+".FitAmp"+m_auxSuffix;
1900  ATH_CHECK( m_zdcModuleFitAmp.initialize());
1901  m_zdcModuleFitAmpError = m_zdcModuleContainerName+".FitAmpError"+m_auxSuffix;
1902  ATH_CHECK( m_zdcModuleFitAmpError.initialize());
1903  m_zdcModuleFitT0 = m_zdcModuleContainerName+".FitT0"+m_auxSuffix;
1904  ATH_CHECK( m_zdcModuleFitT0.initialize());
1905  m_zdcModuleBkgdMaxFraction = m_zdcModuleContainerName+".BkgdMaxFraction"+m_auxSuffix;
1906  ATH_CHECK( m_zdcModuleBkgdMaxFraction.initialize());
1907  m_zdcModulePreSampleAmp = m_zdcModuleContainerName+".PreSampleAmp"+m_auxSuffix;
1908  ATH_CHECK( m_zdcModulePreSampleAmp.initialize());
1909  m_zdcModulePresample = m_zdcModuleContainerName+".Presample"+m_auxSuffix;
1910  ATH_CHECK( m_zdcModulePresample.initialize());
1911  m_zdcModuleMinDeriv2nd = m_zdcModuleContainerName+".MinDeriv2nd"+m_auxSuffix;
1912  ATH_CHECK( m_zdcModuleMinDeriv2nd.initialize());
1913  m_zdcModuleMaxADC = m_zdcModuleContainerName+".MaxADC"+m_auxSuffix;
1914  ATH_CHECK( m_zdcModuleMaxADC.initialize());
1915 
1916  m_zdcModuleMaxADCHG = m_zdcModuleContainerName+".MaxADCHG"+m_auxSuffix;
1917  ATH_CHECK( m_zdcModuleMaxADCHG.initialize());
1918  m_zdcModuleMaxADCLG = m_zdcModuleContainerName+".MaxADCLG"+m_auxSuffix;
1919  ATH_CHECK( m_zdcModuleMaxADCLG.initialize());
1920 
1921  // LG refit data
1922  //
1923  m_zdcModuleFitAmpLGRefit = m_zdcModuleContainerName+".FitAmpLGRefit"+m_auxSuffix;
1924  ATH_CHECK(m_zdcModuleFitAmpLGRefit.initialize());
1925  m_zdcModuleAmpLGRefit = m_zdcModuleContainerName+".AmpLGRefit"+m_auxSuffix;
1926  ATH_CHECK(m_zdcModuleAmpLGRefit.initialize());
1927  m_zdcModuleAmpCorrLGRefit = m_zdcModuleContainerName+".AmpCorrLGRefit"+m_auxSuffix;
1928  ATH_CHECK(m_zdcModuleAmpCorrLGRefit.initialize());
1929  m_zdcModuleT0LGRefit = m_zdcModuleContainerName+".T0LGRefit"+m_auxSuffix;
1930  ATH_CHECK(m_zdcModuleT0LGRefit.initialize());
1931  m_zdcModuleT0SubLGRefit = m_zdcModuleContainerName+".T0SubLGRefit"+m_auxSuffix;
1932  ATH_CHECK(m_zdcModuleT0SubLGRefit.initialize());
1933  m_zdcModuleChisqLGRefit = m_zdcModuleContainerName+".ChisqLGRefit"+m_auxSuffix;
1934  ATH_CHECK( m_zdcModuleChisqLGRefit.initialize());
1935 
1936  // ZDC per-calorimeter data
1937  //
1938  m_zdcSumUncalibSum = m_zdcSumContainerName+".UncalibSum"+m_auxSuffix;
1939  ATH_CHECK( m_zdcSumUncalibSum.initialize());
1940  m_zdcSumCalibEnergy = m_zdcSumContainerName+".CalibEnergy"+m_auxSuffix;
1941  ATH_CHECK( m_zdcSumCalibEnergy.initialize());
1942  m_zdcSumCalibEnergyErr = m_zdcSumContainerName+".CalibEnergyErr"+m_auxSuffix;
1943  ATH_CHECK( m_zdcSumCalibEnergyErr.initialize());
1944  m_zdcSumUncalibSumErr = m_zdcSumContainerName+".UncalibSumErr"+m_auxSuffix;
1945  ATH_CHECK( m_zdcSumUncalibSumErr.initialize());
1946  m_zdcSumFinalEnergy = m_zdcSumContainerName+".FinalEnergy"+m_auxSuffix;
1947  ATH_CHECK( m_zdcSumFinalEnergy.initialize());
1948  m_zdcSumAverageTime = m_zdcSumContainerName+".AverageTime"+m_auxSuffix;
1949  ATH_CHECK( m_zdcSumAverageTime.initialize());
1950  m_zdcSumStatus = m_zdcSumContainerName+".Status"+m_auxSuffix;
1951  ATH_CHECK( m_zdcSumStatus.initialize());
1952  m_zdcSumModuleMask = m_zdcSumContainerName+".ModuleMask"+m_auxSuffix;
1953  ATH_CHECK( m_zdcSumModuleMask.initialize());
1954 
1955  if (m_writeAux && m_auxSuffix != "") {
1956  ATH_MSG_DEBUG("suffix string = " << m_auxSuffix);
1957  }
1958 
1959  m_init = true;
1960 
1961  return StatusCode::SUCCESS;
1962 }

◆ initialize40MHz()

void ZDC::ZdcAnalysisTool::initialize40MHz ( )

Definition at line 1536 of file ZdcAnalysisTool.cxx.

1537 {
1538  // We have a complete configuration and so we override all of the default parameters
1539  //
1540 
1541  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{{4.2, 3.8, 5.2, 5.0}},
1542  {{5.0, 3.7, 3.5, 3.5}}
1543  }
1544  };
1545 
1546  // identical to 80 MHz -- is this right
1547  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{{20.0, 20.4, 18.9, 20.8}},
1548  {{19.1, 21.9, 22.6, 23.4}}
1549  }
1550  };
1551 
1552  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{{1, 1, 2, 1}},
1553  {{1, 1, 1, 1}}
1554  }
1555  };
1556 
1557  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG = {{{{ -8, -8, -8, -8}},
1558  {{ -8, -8, -8, -8}}
1559  }
1560  };
1561 
1562  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsLG = {{{{ -4, -4, -4, -4}},
1563  {{ -4, -4, -4, -4}}
1564  }
1565  };
1566 
1567  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1568  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1569  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1570 
1571  // Set Tau and nominal timing offsets
1572  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1573 
1574  bool fixTau1 = true;
1575  bool fixTau2 = true;
1576 
1577  for (size_t side : {0, 1}) {
1578  for (size_t module : {0, 1, 2, 3}) {
1579  fixTau1Arr[side][module] = fixTau1;
1580  fixTau2Arr[side][module] = fixTau2;
1581  }
1582  }
1583 
1584  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{{53.942, 49.887, 59.633, 46.497}},
1585  {{46.314, 42.267, 50.327, 41.605}}
1586  }
1587  };
1588  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{{51.771, 47.936, 57.438, 44.191}},
1589  {{44.295, 41.755, 48.081, 40.175}}
1590  }
1591  };
1592 
1593 
1594  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1595  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutLG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1596  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1597  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1598  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1599  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1600 
1601  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1602 
1603  slewingParamsHG[0][0] = {0, -7.904e-02, 4.686e-02, 1.530e-03 };
1604  slewingParamsHG[0][1] = {0, 2.250e-02, 4.732e-02, 6.050e-03 };
1605  slewingParamsHG[0][2] = {0, 4.388e-02, 6.707e-02, -5.526e-05 };
1606  slewingParamsHG[0][3] = {0, 1.205e-01, 2.726e-02, 2.610e-03 };
1607 
1608  slewingParamsHG[1][0] = {0, 6.861e-02, 5.175e-03, -9.018e-04 };
1609  slewingParamsHG[1][1] = {0, 3.855e-01, -4.442e-02, -2.022e-02 };
1610  slewingParamsHG[1][2] = {0, -4.337e-03, 3.841e-02, 4.661e-03 };
1611  slewingParamsHG[1][3] = {0, 3.623e-01, -3.882e-02, -1.805e-02 };
1612 
1613  slewingParamsLG[0][0] = {0, 1.708e-02, 7.929e-02, 5.079e-03 };
1614  slewingParamsLG[0][1] = {0, 1.406e-01, 1.209e-01, -1.922e-04 };
1615  slewingParamsLG[0][2] = {0, 1.762e-01, 1.118e-01, 1.679e-04 };
1616  slewingParamsLG[0][3] = {0, 1.361e-02, -2.685e-02, -4.168e-02 };
1617 
1618  slewingParamsLG[1][0] = {0, 1.962e-01, -5.025e-03, -2.001e-02 };
1619  slewingParamsLG[1][1] = {0, 3.258e-01, 1.229e-02, -2.925e-02 };
1620  slewingParamsLG[1][2] = {0, 1.393e-01, 8.113e-02, -2.594e-03 };
1621  slewingParamsLG[1][3] = {0, 1.939e-01, 2.188e-02, -5.579e-02 };
1622 
1623  m_zdcDataAnalyzer_40MHz.reset (new ZDCDataAnalyzer(MakeMessageFunction(), 7, 25, 0, "FermiExp", peak2ndDerivMinSamples,
1624  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1625 
1626  m_zdcDataAnalyzer_40MHz->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1627  m_zdcDataAnalyzer_40MHz->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1628  m_zdcDataAnalyzer_40MHz->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1629  m_zdcDataAnalyzer_40MHz->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1630  slewingParamsHG, slewingParamsLG);
1631 
1632  std::array<std::array<std::vector<float>, 4>, 2> moduleHGNonLinCorr, moduleLGNonLinCorr;
1633  moduleHGNonLinCorr[0][0] = { -3.76800e-02, 4.63597e-02};
1634  moduleHGNonLinCorr[0][1] = { -1.02185e-01, -1.17548e-01};
1635  moduleHGNonLinCorr[0][2] = { -8.78451e-02, -1.52174e-01};
1636  moduleHGNonLinCorr[0][3] = { -1.04835e-01, -1.96514e-01};
1637  moduleHGNonLinCorr[1][0] = { -6.83115e-02, 3.57802e-02};
1638  moduleHGNonLinCorr[1][1] = { -1.08162e-01, -1.91413e-01};
1639  moduleHGNonLinCorr[1][2] = { -7.82514e-02, -1.21218e-01};
1640  moduleHGNonLinCorr[1][3] = { -2.34354e-02, -2.52033e-01};
1641 
1642  moduleLGNonLinCorr = {{ {{{0},
1643  {0},
1644  {0},
1645  {0}}},
1646  {{{0},
1647  {0},
1648  {0},
1649  {0}}} }};
1650 
1651  if (m_doNonLinCorr) m_zdcDataAnalyzer_40MHz->SetNonlinCorrParams(500, 1000, moduleHGNonLinCorr, moduleLGNonLinCorr);
1652  m_zdcDataAnalyzer_40MHz->SetSaveFitFunc(false);
1653 
1654 }

◆ initialize80MHz()

void ZDC::ZdcAnalysisTool::initialize80MHz ( )

Definition at line 1656 of file ZdcAnalysisTool.cxx.

1657 {
1658  // We have a complete configuration and so we override all of the default parameters
1659  //
1660 
1661  m_peak2ndDerivMinSamples = {{{{3, 2, 3, 2}},
1662  {{2, 2, 2, 2}}
1663  }
1664  };
1665 
1666  m_peak2ndDerivMinThresholdsHG = {{{{ -8, -8, -8, -8}},
1667  {{ -8, -8, -8, -8}}
1668  }
1669  };
1670 
1671  m_peak2ndDerivMinThresholdsLG = {{{{ -4, -4, -4, -4}},
1672  {{ -4, -4, -4, -4}}
1673  }
1674  };
1675 
1676  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1677  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1678  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{950, 950, 950, 950}}, {{950, 950, 950, 950}}}};
1679 
1680  // Set Tau and nominal timing offsets
1681  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1682 
1683  bool fixTau1 = true;
1684  bool fixTau2 = true;
1685 
1686  for (size_t side : {0, 1}) {
1687  for (size_t module : {0, 1, 2, 3}) {
1688  fixTau1Arr[side][module] = fixTau1;
1689  fixTau2Arr[side][module] = fixTau2;
1690  }
1691  }
1692 
1693  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{{3.9, 3.4, 4.1, 4.2}},
1694  {{4.2, 3.6, 3.3, 3.4}}
1695  }
1696  };
1697 
1698  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{{20.0, 20.4, 18.9, 20.8}},
1699  {{19.1, 21.9, 22.6, 23.4}}
1700  }
1701  };
1702 
1703  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{{44.24, 40.35, 49.3, 36.0}},
1704  {{36.0, 31.1, 40.75, 30.5}}
1705  }
1706  };
1707 
1708  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{{42.65, 38.5, 47.4, 34}},
1709  {{33.7, 29.9, 39.0, 29.3}}
1710  }
1711  };
1712 
1713  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1714  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutLG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1715  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1716  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1717  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1718  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1719 
1720  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1721 
1722  slewingParamsHG[0][0] = {0, -6.5e-2, 2.85e-2, -2.83e-3};
1723  slewingParamsHG[0][1] = {0, -5.5e-2, 5.13e-2, 5.6e-3};
1724  slewingParamsHG[0][2] = {0, -1.45e-3, 9.3e-2, 3.9e-3};
1725  slewingParamsHG[0][3] = {0, -2.36e-2, 8.3e-2, 1.1e-3};
1726 
1727  slewingParamsHG[1][0] = {0, -6.5e-2, 4.84e-2, -3.7e-3};
1728  slewingParamsHG[1][1] = {0, 1.34e-2, 6.57e-2, 5.37e-3};
1729  slewingParamsHG[1][2] = {0, -5.37e-2, 3.49e-2, 3.8e-3};
1730  slewingParamsHG[1][3] = {0, -3.3e-2, 3.9e-2, 2.2e-3};
1731 
1732  slewingParamsLG[0][0] = {0, -9.6e-2, 4.39e-2, 2.93e-3 };
1733  slewingParamsLG[0][1] = {0, -5.0e-2, 14.9e-2, 20.6e-3 };
1734  slewingParamsLG[0][2] = {0, -4.4e-2, 5.3e-2, 0, };
1735  slewingParamsLG[0][3] = {0, -9.90e-2, 4.08e-2, 0, };
1736 
1737  slewingParamsLG[1][0] = {0, -8.7e-2, 4.2e-2, -3.2e-3 };
1738  slewingParamsLG[1][1] = {0, -3.26e-2, 3.84e-2, -2.32e-3};
1739  slewingParamsLG[1][2] = {0, -26.8e-2, -2.64e-2, -5.3e-3 };
1740  slewingParamsLG[1][3] = {0, -13.2e-2, 0.45e-2, -2.4e-3 };
1741 
1742 
1743  m_zdcDataAnalyzer_80MHz.reset (new ZDCDataAnalyzer(MakeMessageFunction(), 7 , 12.5, 0, "FermiExp", m_peak2ndDerivMinSamples,
1744  m_peak2ndDerivMinThresholdsHG, m_peak2ndDerivMinThresholdsLG, m_lowGainMode));
1745 
1746  m_zdcDataAnalyzer_80MHz->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1747  m_zdcDataAnalyzer_80MHz->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1748  m_zdcDataAnalyzer_80MHz->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1749  m_zdcDataAnalyzer_80MHz->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1750  slewingParamsHG, slewingParamsLG);
1751 
1752  std::array<std::array<std::vector<float>, 4>, 2> moduleHGNonLinCorr, moduleLGNonLinCorr;
1753  moduleHGNonLinCorr[0][0] = { -3.76800e-02, 4.63597e-02};
1754  moduleHGNonLinCorr[0][1] = { -1.02185e-01, -1.17548e-01};
1755  moduleHGNonLinCorr[0][2] = { -8.78451e-02, -1.52174e-01};
1756  moduleHGNonLinCorr[0][3] = { -1.04835e-01, -1.96514e-01};
1757  moduleHGNonLinCorr[1][0] = { -6.83115e-02, 3.57802e-02};
1758  moduleHGNonLinCorr[1][1] = { -1.08162e-01, -1.91413e-01};
1759  moduleHGNonLinCorr[1][2] = { -7.82514e-02, -1.21218e-01};
1760  moduleHGNonLinCorr[1][3] = { -2.34354e-02, -2.52033e-01};
1761 
1762  moduleLGNonLinCorr = {{ {{{0},
1763  {0},
1764  {0},
1765  {0}}},
1766  {{{0},
1767  {0},
1768  {0},
1769  {0}}} }};
1770 
1771  if (m_doNonLinCorr) m_zdcDataAnalyzer_80MHz->SetNonlinCorrParams(500, 1000, moduleHGNonLinCorr, moduleLGNonLinCorr);
1772  m_zdcDataAnalyzer_80MHz->SetSaveFitFunc(false);
1773 }

◆ initializeDecorations()

void ZDC::ZdcAnalysisTool::initializeDecorations ( )

Definition at line 1964 of file ZdcAnalysisTool.cxx.

1965 {
1966 
1967 }

◆ initializeDefault()

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

Definition at line 1171 of file ZdcAnalysisTool.cxx.

1172 {
1173  // We rely completely on the default parameters specified in the job properties to control:
1174  // # samples
1175  // frequency (more precisely, time/sample)
1176  // which sample to use as the pre-sample
1177  // where to expact the maxim of the peak (min 2nd derivative)
1178  // thresholds on the 2nd derivative for valid pulses
1179  // whether to fix the tau values in the pulse fitting
1180  // the default tau values
1181  // the nominal T0
1182  // delta T and chisq/amp cuts
1183  //
1184  // For now, we continue to use hard-coded values for the maximum and minimum ADC values
1185  // For now we also use the FermiExp pulse model.
1186  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
1187  ZDCDataAnalyzer::ZDCModuleFloatArray tau1{}, tau2{}, t0{};
1188  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
1189  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
1190  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1191 
1192  for (size_t side : {0, 1}) {
1193  for (size_t module : {0, 1, 2, 3}) {
1194  fixTau1Arr[side][module] = m_fixTau1;
1195  fixTau2Arr[side][module] = m_fixTau2;
1196  tau1[side][module] = m_tau1;
1197  tau2[side][module] = m_tau2;
1198 
1199  peak2ndDerivMinSamples[side][module] = m_peakSample;
1200  peak2ndDerivMinThresholdsHG[side][module] = -m_Peak2ndDerivThresh;
1201  peak2ndDerivMinThresholdsLG[side][module] = -m_Peak2ndDerivThresh / 2;
1202 
1203  t0[side][module] = m_t0;
1204  deltaT0CutLow[side][module] = -m_deltaTCut;
1205  deltaT0CutHigh[side][module] = m_deltaTCut;
1206  chisqDivAmpCut[side][module] = m_ChisqRatioCut;
1207  }
1208  }
1209 
1210  ATH_MSG_DEBUG( "Default: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1211 
1212  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1213  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1214  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1215 
1216  // Construct the data analyzer
1217  //
1218  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), m_numSample, m_deltaTSample, m_presample, "FermiExp", peak2ndDerivMinSamples,
1219  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1220 
1221  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1222  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0, t0);
1223  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1224 
1225  if (m_combineDelay) {
1226  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
1227 
1228  zdcDataAnalyzer->enableDelayed(m_delayDeltaT, defaultPedestalShifts);
1229  }
1230 
1231  return zdcDataAnalyzer;
1232 }

◆ initializeInjectorPbPb2024()

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

Definition at line 924 of file ZdcAnalysisTool.cxx.

925 {
926  // Key configuration parameters needed for the data analyzer construction
927  //
928  m_deltaTSample = 3.125;
929  m_numSample = 24;
930 
931  const int deriv2ndThreshDSHG = -25;
932  const int deriv2ndThreshDSLG = -10;
933  const unsigned int peakSample = 10;
934 
935  const float deltaTcutLow = -10;
936  const float deltaTcutHigh = 10;
937  const float chisqDivAmpCutHGVal = 30;
938  const float chisqDivAmpCutLGVal = 50;
939 
940  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
941  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
942 
943  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
944  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
945  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
946 
947  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.8, 1.8, 1.8, 1.8}, {1.8, 1.8, 1.8, 1.8}}};
948 
949  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{5.5, 5.5, 5.5, 5.5}, {5.5, 5.5, 5.5, 5.5}}};
950 
951  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{33.25, 33, 29.5, 33}, {31.5, 32.5, 32, 32.25}}};
952  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{30.5, 30, 26.75, 30}, {29.5, 32.5, 29.5, 29}}};
953 
954  for (size_t side : {0, 1}) {
955  for (size_t module : {0, 1, 2, 3}) {
956  fixTau1Arr[side][module] = false;
957  fixTau2Arr[side][module] = true;
958 
959  peak2ndDerivMinSamples[side][module] = peakSample;
960  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
961  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
962 
963  deltaT0CutLow[side][module] = deltaTcutLow;
964  deltaT0CutHigh[side][module] = deltaTcutHigh;
965  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
966  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
967  }
968  }
969 
970  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
971 
972  // Construct the data analyzer
973  //
974  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
975  m_numSample, m_deltaTSample,
976  m_presample, "FermiExpLHCf",
977  peak2ndDerivMinSamples,
978  peak2ndDerivMinThresholdsHG,
979  peak2ndDerivMinThresholdsLG,
980  ZDCPulseAnalyzer::LGModeRefitLG));
981 
982  zdcDataAnalyzer->set2ndDerivStep(2);
983  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
984 
985  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
986  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{10, 10, 10, 10}, {10, 10, 10, 10}}};
987 
988  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
989 
990  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
991  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
992  //
993  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{2.0, 2.0, 2.0, 2.0}, {2.0, 2.0, 2.0, 2.0}}};
994  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{15.0, 15.0, 15.0, 15.0}, {15.0, 15.0, 15.0, 15.0}}};
995 
996  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
997 
998  // Now set cuts and default fit parameters
999  //
1000  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
1001  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
1002  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
1003 
1004  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1005  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1006  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1007 
1008  // Set the amplitude fit range limits
1009  //
1010  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
1011 
1012  return zdcDataAnalyzer;
1013 }

◆ initializeInjectorpp2024()

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

Definition at line 798 of file ZdcAnalysisTool.cxx.

799 {
800  // Key configuration parameters needed for the data analyzer construction
801  //
802  m_deltaTSample = 3.125;
803  m_numSample = 24;
804 
805  const int deriv2ndThreshDSHG = -10;
806  const int deriv2ndThreshDSLG = -10;
807  const unsigned int peakSample = 10;
808 
809  const float deltaTcutLow = -50;
810  const float deltaTcutHigh = 50;
811  const float chisqDivAmpCutHGVal = 30;
812  const float chisqDivAmpCutLGVal = 50;
813 
814  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
815  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
816 
817  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
818  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
819  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
820 
821  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.2, 1.4, 1.3, 1.2},
822  {1.35, 1.4, 1.3, 1.1}}};
823 
824  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
825 
826  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
827  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{28, 28, 28, 28}, {28, 28, 28, 28}}};
828 
829  for (size_t side : {0, 1}) {
830  for (size_t module : {0, 1, 2, 3}) {
831  fixTau1Arr[side][module] = false;
832  fixTau2Arr[side][module] = true;
833 
834  peak2ndDerivMinSamples[side][module] = peakSample;
835  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
836  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
837 
838  deltaT0CutLow[side][module] = deltaTcutLow;
839  deltaT0CutHigh[side][module] = deltaTcutHigh;
840  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
841  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
842  }
843  }
844 
845  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
846 
847  // Construct the data analyzer
848  //
849  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
850  m_numSample, m_deltaTSample,
851  m_presample, "FermiExpLHCf",
852  peak2ndDerivMinSamples,
853  peak2ndDerivMinThresholdsHG,
854  peak2ndDerivMinThresholdsLG,
855  ZDCPulseAnalyzer::LGModeRefitLG));
856  zdcDataAnalyzer->set2ndDerivStep(2);
857  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(10);
858 
859  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
860  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
861 
862  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
863 
864  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
865  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
866  //
867  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
868  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{10.0, 10.0, 10.0, 10.0}, {10.0, 10.0, 10.0, 10.0}}};
869 
870  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
871 
872  // Now set cuts and default fit parameters
873  //
874  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
875  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
876  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
877 
878  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
879  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
880  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
881 
882  // Turn on exclusion of early and late samples to address OOT pileup
883  //
884  zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
885  zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
886 
887 
888  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
889  timeCorrCoefficHG[0][0] = {0.07, -0.020672, 0.070206, 0.004961, -0.010821, -0.001835};
890  timeCorrCoefficHG[0][1] = {0.04, -0.012961, 0.008204, 0.010771, 0.011593, 0.002045};
891  timeCorrCoefficHG[0][2] = {0.04, 0.017393, 0.017597, 0.003736, -0.001696, -0.000465};
892  timeCorrCoefficHG[0][3] = {0.04, 0.018463, 0.009862, -0.000277, -0.000268, 0.000192};
893 
894  timeCorrCoefficHG[1][0] = {0.13, -0.106068, 0.078153, 0.034479, -0.004964, -0.001688};
895  timeCorrCoefficHG[1][1] = {0.03, -0.007518, 0.008937, 0.015319, 0.012290, 0.001889};
896  timeCorrCoefficHG[1][2] = {-0.01, 0.006711, -0.001652, -0.004223, -0.000573, 0.000161};
897  timeCorrCoefficHG[1][3] = {0.015, 0.017993, 0.006339, 0.003122, 0.002980, 0.000735};
898 
899  // +++ BAC 07-26-24
900  //
901  // The +3.25 in the constant t0 correction term accounts for a change in the nominal T0 from 31.25 to 28
902  // made at the same time to match the timing shift of the LG channels
903  //
904  // ---
905  timeCorrCoefficLG[0][0] = {0.035f+3.25f, -0.126189, 0.022724, 0.039116, -0.098255};
906  timeCorrCoefficLG[0][1] = {0.022f+3.25f, -0.165988, -0.014125, 0.057323, -0.205109};
907  timeCorrCoefficLG[0][2] = {0.01f+3.25f, -0.136087, -0.007248, -0.014452, -0.060469};
908  timeCorrCoefficLG[0][3] = {0.0f+3.25f, -0.131067, 0.025579, 0.059994, -0.065595};
909 
910  timeCorrCoefficLG[1][0] = {0.076f+3.25f, -0.300587, -0.041827, 0.641108, -0.594157};
911  timeCorrCoefficLG[1][1] = {0.057f+3.25f, -0.223443, -0.125013, -0.176900, 0.348081};
912  timeCorrCoefficLG[1][2] = {0.015f+3.25f, -0.141721, 0.023936, 0.099657, -0.188526};
913  timeCorrCoefficLG[1][3] = {0.01f+3.25f, -0.152589, 0.016122, -0.086580, 0.563625};
914 
915  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
916 
917  // Set the amplitude fit range limits
918  //
919  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
920 
921  return zdcDataAnalyzer;
922 }

◆ 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 1015 of file ZdcAnalysisTool.cxx.

1016 {
1017  // Key configuration parameters needed for the data analyzer construction
1018  //
1019  m_deltaTSample = 3.125;
1020  m_numSample = 24;
1021 
1022  const int deriv2ndThreshDSHG = -25;
1023  const int deriv2ndThreshDSLG = -10;
1024  const unsigned int peakSample = 10;
1025 
1026  const float deltaTcutLow = -10;
1027  const float deltaTcutHigh = 10;
1028  const float chisqDivAmpCutHGVal = 30;
1029  const float chisqDivAmpCutLGVal = 50;
1030 
1031  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
1032  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
1033 
1034  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
1035  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
1036  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
1037 
1038  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.1, 1.1, 1.1, 1.1},
1039  {1.1, 1.1, 1.1, 1.1}}};
1040 
1041  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
1042 
1043  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
1044  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
1045 
1046  for (size_t side : {0, 1}) {
1047  for (size_t module : {0, 1, 2, 3}) {
1048  fixTau1Arr[side][module] = false;
1049  fixTau2Arr[side][module] = false;
1050 
1051  peak2ndDerivMinSamples[side][module] = peakSample;
1052  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
1053  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
1054 
1055  deltaT0CutLow[side][module] = deltaTcutLow;
1056  deltaT0CutHigh[side][module] = deltaTcutHigh;
1057  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
1058  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
1059  }
1060  }
1061 
1062  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1063 
1064  // Construct the data analyzer
1065  //
1066  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
1067  m_numSample, m_deltaTSample,
1068  m_presample, "FermiExpLHCf",
1069  peak2ndDerivMinSamples,
1070  peak2ndDerivMinThresholdsHG,
1071  peak2ndDerivMinThresholdsLG,
1072  m_lowGainMode));
1073  zdcDataAnalyzer->set2ndDerivStep(2);
1074  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
1075 
1076  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1, 1, 1, 1},{1, 1, 1, 1}}};
1077  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{10.,10.,10.,10.},{10.,10.,10.,10.}}}; // apply constant factor of 10 to high gain data
1078 
1079  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
1080 
1081  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
1082  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
1083  //
1084  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
1085  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{1.5, 1.7, 3, 1.7}, {1.7, 1.6, 2.2, 1.8}}};
1086 
1087  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
1088 
1089  // Now set cuts and default fit parameters
1090  //
1091  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
1092  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
1093  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
1094 
1095  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1096  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1097  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1098 
1099  // Enable two-pass analysis
1100  //
1101  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-10, -10, -10, -10},
1102  {-10, -10, -10, -10}}};
1103 
1104  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
1105  {-8, -8, -8, -8}}};
1106 
1107  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
1108 
1109  // Turn on exclusion of early and late samples to address OOT pileup
1110  //
1111  //zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
1112  //zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
1113 
1114  // Set up non-linear corrections for the ZDC
1115  //
1116  std::array<std::array<std::vector<float>, 4>, 2> nonLinearCorrCoefficHG, nonLinearCorrCoefficLG;
1117 
1118  nonLinearCorrCoefficHG = {{ {{{0},
1119  {0},
1120  {0},
1121  {0}}},
1122  {{{0},
1123  {0},
1124  {0},
1125  {0}}} }};
1126 
1127  // For now we don't use corrections on the LG as it's much harder to measure them
1128  //
1129  nonLinearCorrCoefficLG = {{ {{{0},
1130  {0},
1131  {0},
1132  {0}}},
1133  {{{0},
1134  {0},
1135  {0},
1136  {0}}} }};
1137 
1138  if (m_doNonLinCorr)
1139  zdcDataAnalyzer->SetNonlinCorrParams(0, 1000, nonLinearCorrCoefficHG, nonLinearCorrCoefficLG);
1140 
1141  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
1142  timeCorrCoefficHG[0][0] = {};
1143  timeCorrCoefficHG[0][1] = {};
1144  timeCorrCoefficHG[0][2] = {};
1145  timeCorrCoefficHG[0][3] = {};
1146 
1147  timeCorrCoefficHG[1][0] = {};
1148  timeCorrCoefficHG[1][1] = {};
1149  timeCorrCoefficHG[1][2] = {};
1150  timeCorrCoefficHG[1][3] = {};
1151 
1152  timeCorrCoefficLG[0][0] = {};
1153  timeCorrCoefficLG[0][1] = {};
1154  timeCorrCoefficLG[0][2] = {};
1155  timeCorrCoefficLG[0][3] = {};
1156 
1157  timeCorrCoefficLG[1][0] = {};
1158  timeCorrCoefficLG[1][1] = {};
1159  timeCorrCoefficLG[1][2] = {};
1160  timeCorrCoefficLG[1][3] = {};
1161 
1162  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
1163 
1164  // Set the amplitude fit range limits
1165  //
1166  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
1167 
1168  return zdcDataAnalyzer;
1169 }

◆ initializePbPb2015G4()

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

Definition at line 1234 of file ZdcAnalysisTool.cxx.

1235 {
1236  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
1237  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
1238  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
1239  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
1240  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1241 
1242  const int peakSample = 4;
1243  const float peak2ndDerivThreshHG = -12;
1244  const float peak2ndDerivThreshLG = -10;
1245  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{4.000, 4.000, 4.000, 4.000},
1246  {4.000, 4.000, 4.000, 4.000}}};
1247  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{25.36, 25.05, 25.43, 25.60},
1248  {25.11, 25.08, 25.18, 25.48}}};
1249 
1250  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{57.31, 57.28, 57.30, 57.28},
1251  {57.28, 57.29, 57.31, 57.33}}};
1252  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{57.31, 57.28, 57.30, 57.28},
1253  {57.28, 57.29, 57.31, 57.33}}};
1254 
1255  // Delta T0 cut
1256  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{-10, -10, -10, -10}, {-10, -10, -10, -10}}};
1257  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{ 10, 10, 10, 10}, { 10, 10, 10, 10}}};
1258  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{-10, -10, -10, -10}, {-10, -10, -10, -10}}};
1259  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{ 10, 10, 10, 10}, { 10, 10, 10, 10}}};
1260 
1261  for (size_t side : {0, 1}) {
1262  for (size_t module : {0, 1, 2, 3}) {
1263  fixTau1Arr[side][module] = true;
1264  fixTau2Arr[side][module] = true;
1265 
1266  peak2ndDerivMinSamples[side][module] = peakSample;
1267  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
1268  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
1269 
1270  chisqDivAmpCut[side][module] = 15;
1271  }
1272  }
1273 
1274  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{ 800, 800, 800, 800}}, {{ 800, 800, 800, 800}}}};
1275  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{ 10, 10, 10, 10}}, {{ 10, 10, 10, 10}}}};
1276  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1277 
1278  m_deltaTSample = 12.5;
1279 
1280  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), 7, m_deltaTSample, 0, "FermiExp", peak2ndDerivMinSamples,
1281  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1282 
1283  // Open up tolerances on the position of the peak for now
1284  //
1285  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
1286 
1287  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1288  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
1289  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1290 
1291  zdcDataAnalyzer->SetFitTimeMax(85);
1292  zdcDataAnalyzer->SetSaveFitFunc(false);
1293 
1294  return zdcDataAnalyzer;
1295 }

◆ initializePbPb2018()

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

Definition at line 1409 of file ZdcAnalysisTool.cxx.

1410 {
1411  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
1412  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{}, peak2ndDerivMinRepassHG{}, peak2ndDerivMinRepassLG{};
1413  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
1414  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1415 
1416  static constexpr int peakSample = 5;
1417  static constexpr float peak2ndDerivThreshHG = -35;
1418  static constexpr float peak2ndDerivThreshLG = -20;
1419  static constexpr float peak2ndDerivRepassHG = -10;
1420  static constexpr float peak2ndDerivRepassLG = -6;
1421 
1422  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{3.877, 3.998, 3.821, 3.858},
1423  {4.296, 4.064, 3.497, 3.642}
1424  }};
1425 
1426  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{24.40, 25.28, 25.66, 24.12},
1427  {24.42, 24.99, 25.72, 25.29}
1428  }};
1429 
1430  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{70.51, 70.57, 70.13, 69.98},
1431  {74.18, 72.79, 71.77, 72.62}
1432  }};
1433  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{70.70, 70.78, 70.76, 70.91},
1434  {75.16, 73.71, 72.25, 73.61}
1435  }};
1436 
1437  ZDCDataAnalyzer::ZDCModuleFloatArray moduleAmpFractionLG = {{{0.2760, 0.3045, 0.2369, 0.1826},
1438  {0.3216, 0.2593, 0.2511, 0.1680}
1439  }};
1440 
1441  // Delta T0 cut
1442  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
1443  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
1444  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
1445  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
1446 
1447  for (size_t side : {0, 1}) {
1448  for (size_t module : {0, 1, 2, 3}) {
1449  fixTau1Arr[side][module] = true;
1450  fixTau2Arr[side][module] = true;
1451 
1452  peak2ndDerivMinSamples[side][module] = peakSample;
1453  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
1454  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
1455  peak2ndDerivMinRepassHG [side][module] = peak2ndDerivRepassHG;
1456  peak2ndDerivMinRepassLG [side][module] = peak2ndDerivRepassLG;
1457 
1458  chisqDivAmpCut[side][module] = 15;
1459  }
1460  }
1461 
1462  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1463  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1464  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1465 
1466  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1, 1, 1, 1}, {1, 1, 1, 1}}};
1467  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{12, 12, 12, 12}, {12, 12, 12, 12}}};
1468 
1469 
1470  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1471  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
1472  slewingParamsHG[0][0] = { -1.335560e-01, -6.071869e-03, 5.858193e-02, 2.473300e-03};
1473  slewingParamsHG[0][1] = { -1.223062e-01, -4.379469e-02, 4.452285e-02, 2.130210e-03};
1474  slewingParamsHG[0][2] = { -1.021415e-01, -4.254239e-02, 4.939866e-02, 3.849738e-03};
1475  slewingParamsHG[0][3] = { -8.234056e-02, -3.938803e-02, 4.689029e-02, 2.784816e-03};
1476 
1477  slewingParamsHG[1][0] = { -1.640979e-01, -2.780350e-02, 5.755065e-02, -4.244651e-04};
1478  slewingParamsHG[1][1] = { -1.422324e-01, 2.663803e-02, 7.295366e-02, 3.740496e-03};
1479  slewingParamsHG[1][2] = { -9.858124e-02, -2.426132e-02, 4.895967e-02, 2.291393e-03};
1480  slewingParamsHG[1][3] = { -1.070401e-01, -2.256383e-03, 5.833770e-02, 2.255208e-03};
1481 
1482  slewingParamsLG[0][0] = { -2.588446e-01, -3.241086e-02, 7.828661e-02, 1.945547e-03};
1483  slewingParamsLG[0][1] = { -3.112495e-01, -7.419508e-02, 6.825776e-02, 2.148860e-03};
1484  slewingParamsLG[0][2] = { -3.470650e-01, -5.836748e-02, 6.204396e-02, 1.550421e-03};
1485  slewingParamsLG[0][3] = { -4.485435e-01, -4.603790e-02, 5.944799e-02, -1.174585e-03};
1486 
1487  slewingParamsLG[1][0] = { -3.291676e-01, -4.023732e-02, 8.608755e-02, -3.958167e-03};
1488  slewingParamsLG[1][1] = { -2.608969e-01, -2.129786e-03, 6.930791e-02, -4.141910e-03};
1489  slewingParamsLG[1][2] = { -2.505712e-01, -2.195804e-02, 5.137261e-02, -4.058378e-03};
1490  slewingParamsLG[1][3] = { -5.083206e-01, 3.776601e-02, 1.284275e-01, 1.014067e-02};
1491 
1492  // Construct the data analyzer
1493  //
1494  // We adopt hard-coded values for the number of samples and the frequency which we kept fixed for all physics data
1495  //
1496  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer = std::make_unique<ZDCDataAnalyzer>(MakeMessageFunction(), 7, 25, 0, "FermiExpLinear", peak2ndDerivMinSamples, // presample index changed to zero 4/6/19
1497  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode);
1498 
1499  // Open up tolerances on the position of the peak for now
1500  //
1501  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
1502 
1503  // We alwyas disable the 12EM (sideC) module which was not present (LHCf)
1504  //
1505 
1506  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1507  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
1508  zdcDataAnalyzer->SetModuleAmpFractionLG(moduleAmpFractionLG); // fraction calculation for LGOverflows added Nov 23, 2020
1509  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1510 
1511  // We allow the combineDelay to be controlled by the properties
1512  //
1513  m_combineDelay = true;
1514  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
1515 
1516  // We use per-module delays to handle the delayed-undelayed swap on EMC
1517  //
1518  ZDCDataAnalyzer::ZDCModuleFloatArray delayDeltaTs = {{{{12.5, -12.5, -12.5, -12.5}},
1519  {{ -12.5, -12.5, -12.5, -12.5}}
1520  }
1521  };
1522 
1523  zdcDataAnalyzer->enableDelayed(delayDeltaTs, defaultPedestalShifts);
1524  zdcDataAnalyzer->SetFitTimeMax(140); // This restrict the fit range of the pulse fitting, requested by BAC 4/6/19
1525  zdcDataAnalyzer->SetSaveFitFunc(false);
1526  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG); // add repass as default Jul 21 2020 Bill
1527  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1528  slewingParamsHG, slewingParamsLG); // add time slewing correction Sep 17 2019 Bill
1529  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
1530 
1531  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
1532 
1533  return zdcDataAnalyzer;
1534 }

◆ 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.035+3.25, -0.126189, 0.022724, 0.039116, -0.098255};
615  timeCorrCoefficLG[0][1] = {0.022+3.25, -0.165988, -0.014125, 0.057323, -0.205109};
616  timeCorrCoefficLG[0][2] = {0.01+3.25, -0.136087, -0.007248, -0.014452, -0.060469};
617  timeCorrCoefficLG[0][3] = {0.0+3.25, -0.131067, 0.025579, 0.059994, -0.065595};
618 
619  timeCorrCoefficLG[1][0] = {0.076+3.25, -0.300587, -0.041827, 0.641108, -0.594157};
620  timeCorrCoefficLG[1][1] = {0.057+3.25, -0.223443, -0.125013, -0.176900, 0.348081};
621  timeCorrCoefficLG[1][2] = {0.015+3.25, -0.141721, 0.023936, 0.099657, -0.188526};
622  timeCorrCoefficLG[1][3] = {0.01+3.25, -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.035+3.25, -0.126189, 0.022724, 0.039116, -0.098255};
779  timeCorrCoefficLG[0][1] = {0.022+3.25, -0.165988, -0.014125, 0.057323, -0.205109};
780  timeCorrCoefficLG[0][2] = {0.01+3.25, -0.136087, -0.007248, -0.014452, -0.060469};
781  timeCorrCoefficLG[0][3] = {0.0+3.25, -0.131067, 0.025579, 0.059994, -0.065595};
782 
783  timeCorrCoefficLG[1][0] = {0.076+3.25, -0.300587, -0.041827, 0.641108, -0.594157};
784  timeCorrCoefficLG[1][1] = {0.057+3.25, -0.223443, -0.125013, -0.176900, 0.348081};
785  timeCorrCoefficLG[1][2] = {0.015+3.25, -0.141721, 0.023936, 0.099657, -0.188526};
786  timeCorrCoefficLG[1][3] = {0.01+3.25, -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  // Set the amplitude fit range limits
792  //
793  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
794 
795  return zdcDataAnalyzer;
796 }

◆ 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::LGModeRefitLG;
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, 10); // 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 1297 of file ZdcAnalysisTool.cxx.

1298 {
1299  //
1300  // For now, we continue to use hard-coded values for the maximum and minimum ADC values
1301  // For now we also use the FermiExp pulse model.
1302 
1303  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
1304  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
1305  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
1306  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1307 
1308  // For now we allow the tau values to be controlled by the job properties until they are better determined
1309  //
1310  const int peakSample = 5;
1311  const float peak2ndDerivThreshHG = -12;
1312  const float peak2ndDerivThreshLG = -10;
1313  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{4.000, 3.380, 3.661, 3.679},
1314  {4.472, 4.656, 3.871, 4.061}
1315  }};
1316 
1317  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{22, 24.81, 24.48, 24.45},
1318  {24.17, 24.22, 25.46, 24.45}
1319  }};
1320 
1321  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{70.00, 72.74, 73.09, 72.25},
1322  {75.11, 74.94, 73.93, 74.45}
1323  }};
1324  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{70.00, 73.41, 74.27, 73.30},
1325  {76.28, 76.07, 74.98, 76.54}
1326  }};
1327 
1328  // Delta T0 cut
1329  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
1330  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
1331  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
1332  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
1333 
1334 
1335  for (size_t side : {0, 1}) {
1336  for (size_t module : {0, 1, 2, 3}) {
1337  fixTau1Arr[side][module] = true;
1338  fixTau2Arr[side][module] = true;
1339 
1340  peak2ndDerivMinSamples[side][module] = peakSample;
1341  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
1342  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
1343 
1344  chisqDivAmpCut[side][module] = 15;
1345  }
1346  }
1347 
1348  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1349  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1350  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1351 
1352  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1353  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
1354  slewingParamsHG[0][0] = {0, 0, 0, 0};
1355  slewingParamsHG[0][1] = { -4.780244e-01, -7.150874e-02, 4.614585e-02, 8.015731e-04};
1356  slewingParamsHG[0][2] = { -5.253412e-01, -5.718167e-02, 5.243121e-02, 2.128398e-03};
1357  slewingParamsHG[0][3] = { -5.773952e-01, -5.687478e-02, 4.564267e-02, 1.462294e-03};
1358 
1359  slewingParamsHG[1][0] = { 7.105115e-01, -3.686143e-02, 7.727447e-02, 5.924152e-03};
1360  slewingParamsHG[1][1] = { 4.052120e-02, 4.450686e-03, 8.031615e-02, 4.038097e-03};
1361  slewingParamsHG[1][2] = { 3.389476e-02, -2.056782e-02, 4.805321e-02, -2.627999e-03};
1362  slewingParamsHG[1][3] = { 2.069765e-01, -2.890419e-02, 6.084375e-02, 3.742011e-03};
1363 
1364  slewingParamsLG[0][0] = {0, 0, 0, 0};
1365  slewingParamsLG[0][1] = { -1.632547e+00, -4.827813e-01, -1.379131e-01, -2.522607e-02};
1366  slewingParamsLG[0][2] = { -7.254288e+00, -5.454064e+00, -1.619126e+00, -1.739665e-01};
1367  slewingParamsLG[0][3] = { -1.548400e+01, -1.277708e+01, -3.729333e+00, -3.700458e-01};
1368 
1369  slewingParamsLG[1][0] = { 1.142767e-01, -3.608906e-02, 9.642735e-02, -3.097043e-03};
1370  slewingParamsLG[1][1] = { -5.615388e-01, -1.655047e-02, 8.327350e-02, -4.231348e-03};
1371  slewingParamsLG[1][2] = { -7.370728e-01, -2.887482e-02, 8.293875e-02, -4.482743e-03};
1372  slewingParamsLG[1][3] = { -1.270636e+00, -2.791777e-01, -5.807295e-02, -2.332612e-02};
1373 
1374  // Construct the data analyzer
1375  //
1376  // We adopt hard-coded values for the number of samples and the frequency which we kept fixed for all physics data
1377  //
1378  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), 7, 25, 0, "FermiExpLinear", peak2ndDerivMinSamples,
1379  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1380 
1381  // Open up tolerances on the position of the peak for now
1382  //
1383  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
1384 
1385  // We alwyas disable the 12EM (sideC) module which was not present (LHCf)
1386  //
1387  zdcDataAnalyzer->disableModule(0, 0);
1388 
1389  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1390  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
1391  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1392 
1393  // We allow the combineDelay to be controlled by the properties
1394  //
1395  // if (m_combineDelay) {
1396  m_combineDelay = true;
1397  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
1398 
1399  zdcDataAnalyzer->enableDelayed(-12.5, defaultPedestalShifts);
1400  zdcDataAnalyzer->SetFitTimeMax(140); // This restrict the fit range of the pulse fitting
1401  zdcDataAnalyzer->SetSaveFitFunc(false);
1402  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1403  slewingParamsHG, slewingParamsLG); // add time slewing correction Sep 17 2019 Bill
1404  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
1405 
1406  return zdcDataAnalyzer;
1407 }

◆ 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 77 of file ZdcAnalysisTool.h.

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

◆ 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, 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, 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 1989 of file ZdcAnalysisTool.cxx.

1990 {
1991 
1992  if (moduleContainer.size()==0) return StatusCode::SUCCESS; // if no modules, do nothing
1993 
1994  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
1995  if (!eventInfo.isValid()) return StatusCode::FAILURE;
1996 
1997  // Check for decoding errors and bail out if ZDC error found
1998  bool zdcErr = eventInfo->isEventFlagBitSet(xAOD::EventInfo::ForwardDet, ZdcEventInfo::ZDCDECODINGERROR );
1999  if (zdcErr)
2000  {
2001  ATH_MSG_WARNING("ZDC decoding error found - abandoning ZDC reco!");
2002  return StatusCode::SUCCESS;
2003  }
2004 
2005  // check for new run number, if new, possibly update configuration and/or calibrations
2006  //
2007  unsigned int thisRunNumber = eventInfo->runNumber();
2008  if (thisRunNumber != m_runNumber) {
2009  ATH_MSG_DEBUG("ZDC analysis tool will be configured for run " << thisRunNumber);
2010 
2011  ATH_CHECK(configureNewRun(thisRunNumber)); // ALWAYS check methods that return StatusCode
2012 
2013  ATH_MSG_DEBUG("Setting up calibrations");
2014 
2015  if (m_doFADCCorr)
2016  {
2017  unsigned int calibRunNumber = thisRunNumber;
2018  if (m_forceCalibRun > -1) calibRunNumber = m_forceCalibRun;
2019  try
2020  {
2021  setFADCCorrections(calibRunNumber);
2022  }
2023  catch(std::runtime_error&)
2024  {
2025  m_doFADCCorr = false;
2026  }
2027  }
2028 
2029  if (m_doCalib) {
2030  //
2031  // Check for calibration override
2032  //
2033  unsigned int calibRunNumber = thisRunNumber;
2034  if (m_forceCalibRun > -1) calibRunNumber = m_forceCalibRun;
2035  try
2036  {
2037  setEnergyCalibrations(calibRunNumber);
2038  }
2039  catch(std::runtime_error&)
2040  {
2041  m_doCalib = false;
2042  }
2043 
2044  if (m_doTrigEff) initializeTriggerEffs(calibRunNumber); // if energy calibrations fail to load, then so will trigger efficiencies
2045  if (m_doTimeCalib) setTimeCalibrations(calibRunNumber);
2046  }
2047 
2048  m_runNumber = thisRunNumber;
2049  }
2050 
2051  m_lumiBlock = eventInfo->lumiBlock();
2052 
2053  unsigned int calibLumiBlock = m_lumiBlock;
2054  if (m_doCalib) {
2055  if (m_forceCalibRun > 0) calibLumiBlock = m_forceCalibLB;
2056  }
2057 
2058  ATH_MSG_DEBUG("Starting event processing");
2059  ATH_MSG_DEBUG("LB=" << calibLumiBlock);
2060 
2061  m_zdcDataAnalyzer->StartEvent(calibLumiBlock);
2062 
2063  static const SG::ConstAccessor<std::vector<uint16_t> > g0dataAcc ("g0data");
2064  static const SG::ConstAccessor<std::vector<uint16_t> > g1dataAcc ("g1data");
2065 
2066  const std::vector<unsigned short>* adcUndelayLG = 0;
2067  const std::vector<unsigned short>* adcUndelayHG = 0;
2068 
2069  const std::vector<unsigned short>* adcDelayLG = 0;
2070  const std::vector<unsigned short>* adcDelayHG = 0;
2071 
2072  ATH_MSG_DEBUG("Processing modules");
2073  for (const auto zdcModule : moduleContainer)
2074  {
2075  int side = -1;
2076  if (zdcModule->zdcSide() == -1) side = 0;
2077  else if (zdcModule->zdcSide() == 1) side = 1;
2078  else {
2079  // Invalid side
2080  //
2081  ATH_MSG_WARNING("Invalid side value found for module number: " << zdcModule->zdcModule() << ", side value = " << side);
2082  continue;
2083  }
2084  // Ignore MC only modules
2085  if(zdcModule->zdcModule() > 4) continue;
2086 
2087  if (zdcModule->zdcType() == 0) {
2088  //
2089  // This is ZDC data
2090  //
2091  if (m_LHCRun==3) // no delay channels, so we drop the index
2092  {
2093  adcUndelayLG = &g0dataAcc(*zdcModule); // g0
2094  adcUndelayHG = &g1dataAcc(*zdcModule); // g1
2095  }
2096  else if (m_LHCRun==2)
2097  {
2098 
2099 
2100  static const SG::ConstAccessor<std::vector<uint16_t> > g0d1dataAcc ("g0d1data");
2101  static const SG::ConstAccessor<std::vector<uint16_t> > g1d1dataAcc ("g1d1data");
2102  static const SG::ConstAccessor<std::vector<uint16_t> > g0d0dataAcc ("g0d0data");
2103  static const SG::ConstAccessor<std::vector<uint16_t> > g1d0dataAcc ("g1d0data");
2104 
2105  if (zdcModule->zdcModule() == 0 && m_flipEMDelay) // flip delay/non-delay for 2015 ONLY
2106  {
2107  adcUndelayLG = &g0d1dataAcc(*zdcModule); // g0d1
2108  adcUndelayHG = &g1d1dataAcc(*zdcModule); // g1d1
2109  adcDelayLG = &g0d0dataAcc(*zdcModule); // g0d0
2110  adcDelayHG = &g1d0dataAcc(*zdcModule); // g1d0
2111  }
2112  else // nominal configuation
2113  {
2114  adcUndelayLG = &g0d0dataAcc(*zdcModule); // g0d0
2115  adcUndelayHG = &g1d0dataAcc(*zdcModule); // g1d0
2116  adcDelayLG = &g0d1dataAcc(*zdcModule); // g0d1
2117  adcDelayHG = &g1d1dataAcc(*zdcModule); // g1d1
2118  }
2119  }
2120  else
2121  {
2122  ATH_MSG_WARNING("Unknown LHC Run " << m_LHCRun);
2123  return StatusCode::FAILURE;
2124  }
2125 
2126  // Why were these static? to optimize processing time
2127  std::vector<float> HGUndelADCSamples(m_numSample);
2128  std::vector<float> LGUndelADCSamples(m_numSample);
2129 
2130  if (LGUndelADCSamples.size() < adcUndelayLG->size()) {
2131  LGUndelADCSamples.resize(adcUndelayLG->size());
2132  }
2133 
2134  if (HGUndelADCSamples.size() < adcUndelayHG->size()) {
2135  HGUndelADCSamples.resize(adcUndelayHG->size());
2136  }
2137 
2138  std::copy(adcUndelayLG->begin(), adcUndelayLG->end(), LGUndelADCSamples.begin());
2139  std::copy(adcUndelayHG->begin(), adcUndelayHG->end(), HGUndelADCSamples.begin());
2140 
2141  int side = (zdcModule->zdcSide() == -1) ? 0 : 1 ;
2142 
2143  if (!m_combineDelay) {
2144  m_zdcDataAnalyzer->LoadAndAnalyzeData(side, zdcModule->zdcModule(), HGUndelADCSamples, LGUndelADCSamples);
2145  }
2146  else {
2147  std::vector<float> HGDelayADCSamples(m_numSample);
2148  std::vector<float> LGDelayADCSamples(m_numSample);
2149  if (adcDelayLG and adcDelayHG){
2150  std::copy(adcDelayLG->begin(), adcDelayLG->end(), LGDelayADCSamples.begin());
2151  std::copy(adcDelayHG->begin(), adcDelayHG->end(), HGDelayADCSamples.begin());
2152  }else{
2153  ATH_MSG_ERROR("adcDelayLG or adcDelayHG pointers are null");
2154  return StatusCode::FAILURE;
2155  }
2156  // If the delayed channels actually come earlier (as in the pPb in 2016), we invert the meaning of delayed and undelayed
2157  // see the initialization sections for similar inversion on the sign of the pedestal difference
2158  //
2159 
2160  m_zdcDataAnalyzer->LoadAndAnalyzeData(side, zdcModule->zdcModule(),
2161  HGUndelADCSamples, LGUndelADCSamples,
2162  HGDelayADCSamples, LGDelayADCSamples);
2163  }
2164  }
2165  }
2166 
2167  ATH_MSG_DEBUG("Finishing event processing");
2168 
2169  m_zdcDataAnalyzer->FinishEvent();
2170 
2171  ATH_MSG_DEBUG("Adding variables with suffix=" + m_auxSuffix);
2172 
2173  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleAmplitude(m_zdcModuleAmplitude);
2174  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleCalibEnergy(m_zdcModuleCalibEnergy);
2175  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleCalibTime(m_zdcModuleCalibTime);
2176  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcModuleStatus(m_zdcModuleStatus);
2177  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleTime(m_zdcModuleTime);
2178  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleChisq(m_zdcModuleChisq);
2179  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleAmpNoNonLin(m_zdcModuleAmpNoNonLin);
2180  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitAmp(m_zdcModuleFitAmp);
2181  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitAmpError(m_zdcModuleFitAmpError);
2182  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitT0(m_zdcModuleFitT0);
2183  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleBkgdMaxFraction(m_zdcModuleBkgdMaxFraction);
2184  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModulePreSampleAmp(m_zdcModulePreSampleAmp);
2185  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModulePresample(m_zdcModulePresample);
2186  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMinDeriv2nd(m_zdcModuleMinDeriv2nd);
2187  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMaxADC(m_zdcModuleMaxADC);
2188  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMaxADCHG(m_zdcModuleMaxADCHG);
2189  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMaxADCLG(m_zdcModuleMaxADCLG);
2190 
2191  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleAmpLGRefit(m_zdcModuleAmpLGRefit);
2192  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitAmpLGRefit(m_zdcModuleFitAmpLGRefit);
2193  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleAmpCorrLGRefit(m_zdcModuleAmpCorrLGRefit);
2194  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleT0LGRefit(m_zdcModuleT0LGRefit);
2195  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleT0SubLGRefit(m_zdcModuleT0SubLGRefit);
2196  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleChisqLGRefit(m_zdcModuleChisqLGRefit);
2197 
2198  // CalibTime
2199  // Status
2200  // Time
2201  // Chisq
2202  // AmpNoNonLin
2203  // FitAmp
2204  // FitAmpError
2205  // FitT0
2206  // BkgdMaxFraction
2207  // PreSampleAmp
2208  // Presample
2209  // MinDeriv2nd
2210  // MaxADC
2211 
2212  for (const auto zdcModule : moduleContainer)
2213  {
2214  int side = (zdcModule->zdcSide() == -1) ? 0 : 1 ;
2215  int mod = zdcModule->zdcModule();
2216  // Ignore MC only modules
2217  if(mod > 4) continue;
2218 
2219  if (zdcModule->zdcType() == 0) {
2220  // this is the main ZDC
2221  if (m_writeAux) {
2222  float calibEnergy = m_zdcDataAnalyzer->GetModuleCalibAmplitude(side, mod);
2223  zdcModuleCalibEnergy(*zdcModule) = calibEnergy;
2224  zdcModuleCalibTime(*zdcModule) = m_zdcDataAnalyzer->GetModuleCalibTime(side, mod);
2225 
2226  zdcModuleAmplitude(*zdcModule) = m_zdcDataAnalyzer->GetModuleAmplitude(side, mod);
2227  zdcModuleStatus(*zdcModule) = m_zdcDataAnalyzer->GetModuleStatus(side, mod);
2228  zdcModuleTime(*zdcModule) = m_zdcDataAnalyzer->GetModuleTime(side, mod);
2229 
2230  const ZDCPulseAnalyzer* pulseAna_p = m_zdcDataAnalyzer->GetPulseAnalyzer(side, mod);
2231  zdcModuleChisq(*zdcModule) = pulseAna_p->GetChisq();
2232  zdcModuleAmpNoNonLin(*zdcModule) = pulseAna_p->GetAmpNoNonLin();
2233  zdcModuleFitAmp(*zdcModule) = pulseAna_p->GetFitAmplitude();
2234  zdcModuleFitAmpError(*zdcModule) = pulseAna_p->GetAmpError();
2235  zdcModuleFitT0(*zdcModule) = pulseAna_p->GetFitT0();
2236  zdcModuleBkgdMaxFraction(*zdcModule) = pulseAna_p->GetBkgdMaxFraction();
2237  zdcModulePreSampleAmp(*zdcModule) = pulseAna_p->GetPreSampleAmp();
2238  zdcModulePresample(*zdcModule) = pulseAna_p->getPresample();
2239  zdcModuleMinDeriv2nd(*zdcModule) = pulseAna_p->GetMinDeriv2nd();
2240  zdcModuleMaxADC(*zdcModule) = pulseAna_p->getMaxADCSub();
2241  zdcModuleMaxADCHG(*zdcModule) = pulseAna_p->getMaxADCHG();
2242  zdcModuleMaxADCLG(*zdcModule) = pulseAna_p->getMaxADCLG();
2243 
2244  zdcModuleAmpLGRefit(*zdcModule) = pulseAna_p->getRefitLGAmp();
2245  zdcModuleFitAmpLGRefit(*zdcModule) = pulseAna_p->getRefitLGFitAmp();
2246  zdcModuleAmpCorrLGRefit(*zdcModule) = pulseAna_p->getRefitLGAmpCorr();
2247  zdcModuleT0LGRefit(*zdcModule) = pulseAna_p->getRefitLGTime();
2248  zdcModuleT0SubLGRefit(*zdcModule) = pulseAna_p->getRefitLGTimeSub();
2249  zdcModuleChisqLGRefit(*zdcModule) = pulseAna_p->getRefitLGChisq();
2250  }
2251  //ATH_MSG_DEBUG ("side = " << side << " module=" << zdcModule->zdcModule() << " CalibEnergy=" << zdcModule->auxdecor<float>("CalibEnergy")
2252  // << " should be " << m_zdcDataAnalyzer->GetModuleCalibAmplitude(side, mod));
2253  }
2254  }
2255 
2256  // Output sum information
2257  // In Run 3 - we have to assume the container already exists (since it is needed to store the per-side trigger info)
2258  // reprocessing will add new variables with the suffix
2259 
2260  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumUncalibSum(m_zdcSumUncalibSum);
2261  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumUncalibSumErr(m_zdcSumUncalibSumErr);
2262  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumCalibEnergy(m_zdcSumCalibEnergy);
2263  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumCalibEnergyErr(m_zdcSumCalibEnergyErr);
2264  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumFinalEnergy(m_zdcSumFinalEnergy);
2265  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumAverageTime(m_zdcSumAverageTime);
2266  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcSumStatus(m_zdcSumStatus);
2267  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcSumModuleMask(m_zdcSumModuleMask);
2268 
2269  for (const auto zdc_sum: moduleSumContainer)
2270  {
2271  ATH_MSG_DEBUG("Extracting ZDC side " << zdc_sum->zdcSide());
2272 
2273  if (zdc_sum->zdcSide()==0) continue; // skip new global sum
2274 
2275  int iside = (zdc_sum->zdcSide()==-1) ? 0 : 1;
2276 
2277  float uncalibSum = getUncalibModuleSum(iside);
2278  zdcSumUncalibSum(*zdc_sum) = uncalibSum;
2279  float uncalibSumErr = getUncalibModuleSumErr(iside);
2280  zdcSumUncalibSumErr(*zdc_sum) = uncalibSumErr;
2281 
2282  float calibEnergy = getCalibModuleSum(iside);
2283  zdcSumCalibEnergy(*zdc_sum) = calibEnergy;
2284  float calibEnergyErr = getCalibModuleSumErr(iside);
2285  zdcSumCalibEnergyErr(*zdc_sum) = calibEnergyErr;
2286 
2287  float finalEnergy = calibEnergy;
2288  zdcSumFinalEnergy(*zdc_sum) = finalEnergy;
2289  zdcSumAverageTime(*zdc_sum) = getAverageTime(iside);
2290  zdcSumStatus(*zdc_sum) = !sideFailed(iside);
2291  zdcSumModuleMask(*zdc_sum) = (getModuleMask() >> (4 * iside)) & 0xF;
2292  }
2293 
2294  return StatusCode::SUCCESS;
2295 }

◆ 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 2530 of file ZdcAnalysisTool.cxx.

2531 {
2532  if (!m_init)
2533  {
2534  ATH_MSG_WARNING("Tool not initialized!");
2535  return StatusCode::FAILURE;
2536  }
2537  m_eventReady = false;
2538  ATH_MSG_DEBUG ("Trying to retrieve " << m_zdcModuleContainerName);
2539 
2540  m_zdcModules = 0;
2541  ATH_CHECK(evtStore()->retrieve(m_zdcModules, m_zdcModuleContainerName));
2542 
2543  m_zdcSums = 0;
2544  ATH_CHECK(evtStore()->retrieve(m_zdcSums, m_zdcSumContainerName));
2545 
2546  m_eventReady = true;
2547 
2548  ATH_CHECK(recoZdcModules(*m_zdcModules, *m_zdcSums));
2549 
2550  return StatusCode::SUCCESS;
2551 }

◆ SetDebugLevel()

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

Definition at line 72 of file ZdcAnalysisTool.h.

73  {
74  s_debugLevel = debugLevel;
75  }

◆ setEnergyCalibrations()

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

Definition at line 2297 of file ZdcAnalysisTool.cxx.

2298 {
2299 
2300  char name[128];
2301 
2302  std::string filename;
2303  if (m_LHCRun==3)
2304  {
2305  filename = PathResolverFindCalibFile( ("ZdcAnalysis/ZdcCalib_Run"+TString::Itoa(runNumber,10)+".root").Data() );
2306  }
2307  else if (m_LHCRun==2)
2308  {
2309  filename = PathResolverFindCalibFile( ("ZdcAnalysis/" + m_zdcEnergyCalibFileName).c_str() );
2310  }
2311  else
2312  {
2313  ATH_MSG_WARNING("No LHC Run defined, so no calibration allowed");
2314  return;
2315  }
2316 
2317  ATH_MSG_INFO("Opening energy calibration file " << filename);
2318  std::unique_ptr<TFile> fCalib (TFile::Open(filename.c_str(), "READ"));
2319 
2320  if (fCalib == nullptr || fCalib->IsZombie())
2321  {
2322  ATH_MSG_INFO ("failed to open file: " << filename);
2323  throw std::runtime_error ("failed to open file " + filename);
2324  }
2325 
2326  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> splines;
2327 
2328  // "m_calibVersion", called CalibVersion when settings parameters in python, is a directory within the run-based calibration file
2329  TString calibVersion;
2330  if (m_calibVersion != "") calibVersion = m_calibVersion + "/";
2331 
2332  for (int iside = 0; iside < 2; iside++)
2333  {
2334  for (int imod = 0; imod < 4; imod++)
2335  {
2336  sprintf(name, "ZDC_Ecalib_run%u_s%d_m%d", runNumber, iside, imod);
2337  ATH_MSG_DEBUG("Searching for spline " << name);
2338  TSpline3* s = (TSpline3*) fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3");
2339  if (!s && m_doCalib)
2340  {
2341  ATH_MSG_WARNING("No calibrations for run " << runNumber);
2342  m_doCalib = false;
2343  }
2344 
2345  if (s)
2346  {
2347  splines[iside][imod].reset (s);
2348  }
2349  else
2350  {
2351  ATH_MSG_WARNING("No spline " << name);
2352  }
2353  }
2354  }
2355  fCalib->Close();
2356 
2357  if (m_doCalib) m_zdcDataAnalyzer->LoadEnergyCalibrations(splines);
2358 
2359  return;
2360 }

◆ setFADCCorrections()

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

Definition at line 2437 of file ZdcAnalysisTool.cxx.

2438 {
2439  std::string filename;
2440 
2441  if (m_LHCRun==3) {
2442  std::string runString;
2443 
2444  if (runNumber == 0) runString = "ZdcFADCCorr_" + m_configuration + "_default.root";
2445  else runString = ("ZdcFADCCorr_Run"+TString::Itoa(runNumber,10)+".root").Data();
2446 
2447  filename = PathResolverFindCalibFile("ZdcAnalysis/" + runString );
2448  }
2449  else {
2450  ATH_MSG_WARNING("setFADCCorrections: FADC corrections not implemented for Run 2");
2451  return;
2452  }
2453 
2454  if (filename.empty())
2455  {
2456  ATH_MSG_INFO("FADC correction requested but no calibration file found");
2457  m_doFADCCorr = false;
2458  return;
2459  }
2460 
2461  ATH_MSG_INFO("Opening FADC corrections file " << filename);
2462  std::unique_ptr<TFile> fFADCCorr(TFile::Open(filename.c_str(), "READ"));
2463 
2464  if (!fFADCCorr->IsOpen()) {
2465  ATH_MSG_INFO ("setFADCCorrections: failed to open file: " << filename);
2466  throw std::runtime_error ("ZdcAnalysisTool failed to open FADCCorrections file " + filename);
2467  }
2468 
2469  // Attempt to read histograms with corrections from file
2470  //
2471  bool readSuccess = true;
2472  std::array<std::array<std::unique_ptr<const TH1>, 4>, 2> histogramsHG;
2473  std::array<std::array<std::unique_ptr<const TH1>, 4>, 2> histogramsLG;
2474 
2475  for (size_t side : {0, 1}) {
2476  for (int module : {0, 1, 2, 3}) {
2477  std::string histNameHG = "ZDC_FADCCorr_s" + std::to_string(side) + "_m" + std::to_string(module)+"_HG";
2478  std::string histNameLG = "ZDC_FADCCorr_s" + std::to_string(side) + "_m" + std::to_string(module)+"_LG";
2479 
2480  ATH_MSG_DEBUG("setFADCCorrections: Searching for histograms HG and LG: " << histNameHG << ", " << histNameLG);
2481 
2482  TH1* histHG_ptr = static_cast<TH1*>(fFADCCorr->GetObjectChecked(histNameHG.c_str(), "TH1"));
2483  TH1* histLG_ptr = static_cast<TH1*>(fFADCCorr->GetObjectChecked(histNameLG.c_str(), "TH1"));
2484 
2485  if (!histHG_ptr || !histLG_ptr) {
2486  std::string errMsg = "setFADCCorrections: unable to read FADC correction histogram(s) ";
2487  if (!histHG_ptr) errMsg += histNameHG + " ";
2488  if (!histLG_ptr) errMsg += histNameLG;
2489 
2490  ATH_MSG_ERROR(errMsg);
2491  readSuccess = false;
2492  break;
2493  }
2494  else {
2495  //
2496  // Check for valid range (Lion uses -0.5 to 4095.5)
2497  //
2498 
2499  if ( std::abs(histHG_ptr->GetXaxis()->GetXmin()+0.5) > 1e-3 || std::abs(histHG_ptr->GetXaxis()->GetXmax() - 4095.5) > 1e-3) {
2500  ATH_MSG_ERROR("setFADCCorrections: invalid axis range for HG FADC corrections in histogram with name " << histNameHG);
2501  readSuccess = false;
2502  break;
2503  }
2504  if (std::abs(histLG_ptr->GetXaxis()->GetXmin()+0.5) > 1e-3 || std::abs(histLG_ptr->GetXaxis()->GetXmax() - 4095.5) > 1e-3) {
2505  ATH_MSG_ERROR("setFADCCorrections: invalid axis range for HG FADC corrections in histogram with name " << histNameLG);
2506  readSuccess = false;
2507  break;
2508  }
2509 
2510  histogramsHG[side][module].reset(histHG_ptr);
2511  histogramsLG[side][module].reset(histLG_ptr);
2512  }
2513  }
2514  }
2515 
2516  fFADCCorr->Close();
2517 
2518  if (readSuccess) {
2519  m_zdcDataAnalyzer->enableFADCCorrections(m_doFADCCorrPerSample, histogramsHG, histogramsLG);
2520  }
2521  else {
2522  ATH_MSG_ERROR("setFADCCorrections: due to at least one error, FADC corrections are not implemented");
2523  m_doFADCCorr = false;
2524  }
2525 
2526  return;
2527 }

◆ setTimeCalibrations()

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

Definition at line 2362 of file ZdcAnalysisTool.cxx.

2363 {
2364  std::string filename;
2365 
2366  if (m_LHCRun==3)
2367  {
2368  filename = PathResolverFindCalibFile( ("ZdcAnalysis/ZdcCalib_Run"+TString::Itoa(runNumber,10)+".root").Data() );
2369  }
2370  else if (m_LHCRun==2)
2371  {
2372  filename = PathResolverFindCalibFile( "ZdcAnalysis/" + m_zdcTimeCalibFileName );
2373  }
2374  else
2375  {
2376  ATH_MSG_WARNING("No LHC Run defined, so no time calibration allowed");
2377  return;
2378  }
2379 
2380  char name[128] = {0};
2381  ATH_MSG_INFO("Opening time calibration file " << filename);
2382  std::unique_ptr<TFile> fCalib (TFile::Open(filename.c_str(), "READ"));
2383 
2384  // "m_calibVersion", called CalibVersion when settings parameters in python, is a directory within the run-based calibration file
2385  TString calibVersion = "";
2386  if (m_calibVersion != "") calibVersion = m_calibVersion + "/";
2387 
2388  if (fCalib && !fCalib->IsZombie())
2389  {
2390  bool success = true;
2391  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> T0HGOffsetSplines;
2392  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> T0LGOffsetSplines;
2393  std::unique_ptr<TSpline3> spline;
2394  for (int iside = 0; iside < 2; iside++)
2395  {
2396  for (int imod = 0; imod < 4; imod++)
2397  {
2398  sprintf(name, "ZDC_T0calib_run%u_HG_s%d_m%d", runNumber, iside, imod);
2399  spline.reset (static_cast<TSpline3*>(fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3")));
2400  if (spline)
2401  {
2402  T0HGOffsetSplines[iside][imod] = std::move (spline);
2403  }
2404  else
2405  {
2406  ATH_MSG_WARNING("No time calib. spline " << calibVersion+name);
2407  success = false;
2408  }
2409 
2410  sprintf(name, "ZDC_T0calib_run%u_LG_s%d_m%d", runNumber, iside, imod);
2411  spline.reset (static_cast<TSpline3*>(fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3")));
2412  if (spline)
2413  {
2414  T0LGOffsetSplines[iside][imod] = std::move (spline);
2415  }
2416  else
2417  {
2418  ATH_MSG_WARNING("No time calib. spline " << calibVersion+name);
2419  success = false;
2420  }
2421  }
2422  }
2423 
2424  if (success)
2425  m_zdcDataAnalyzer->LoadT0Calibrations(T0HGOffsetSplines, T0LGOffsetSplines);
2426  else
2427  ATH_MSG_WARNING("Time calibration failed - no T0 offsets loaded " << calibVersion+name);
2428 
2429  fCalib->Close();
2430  }
2431  else
2432  {
2433  ATH_MSG_WARNING("No time calibration file " << filename);
2434  }
2435 }

◆ sideFailed()

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

Definition at line 2631 of file ZdcAnalysisTool.cxx.

2632 {
2633  if (!m_zdcDataAnalyzer) return 0;
2634  return m_zdcDataAnalyzer->SideFailed(side);
2635 }

◆ sigprocMaxFinder()

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

Definition at line 2553 of file ZdcAnalysisTool.cxx.

2554 {
2555  size_t nsamp = adc.size();
2556  float presamp = adc.at(0);
2557  unsigned short max_adc = 0;
2558  int max_index = -1;
2559  for (size_t i = 0; i < nsamp; i++)
2560  {
2561  if (adc[i] > max_adc)
2562  {
2563  max_adc = adc[i];
2564  max_index = i;
2565  }
2566  }
2567  amp = max_adc - presamp;
2568  time = max_index * deltaT;
2569  qual = 1.;
2570 
2571  if (max_index == -1)
2572  {
2573  qual = 0.;
2574  return false;
2575  }
2576 
2577  return true;
2578 }

◆ sigprocSincInterp()

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

Definition at line 2580 of file ZdcAnalysisTool.cxx.

2581 {
2582  size_t nsamp = adc.size();
2583  float presamp = adc.at(0);
2584  m_tf1SincInterp->SetParameter(0, deltaT);
2585  for (size_t i = 0; i < nsamp; i++)
2586  {
2587  m_tf1SincInterp->SetParameter(i + 1, adc.at(i) - presamp);
2588  }
2589  amp = m_tf1SincInterp->GetMaximum();
2590  time = m_tf1SincInterp->GetMaximumX();
2591  qual = 1.;
2592  return true;
2593 }

◆ 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 135 of file ZdcAnalysisTool.h.

◆ m_calibVersion

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

Definition at line 163 of file ZdcAnalysisTool.h.

◆ m_ChisqRatioCut

float ZDC::ZdcAnalysisTool::m_ChisqRatioCut
private

Definition at line 179 of file ZdcAnalysisTool.h.

◆ m_combineDelay

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

Definition at line 154 of file ZdcAnalysisTool.h.

◆ m_configuration

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

Definition at line 128 of file ZdcAnalysisTool.h.

◆ m_delayDeltaT

float ZDC::ZdcAnalysisTool::m_delayDeltaT
private

Definition at line 173 of file ZdcAnalysisTool.h.

◆ m_deltaTCut

float ZDC::ZdcAnalysisTool::m_deltaTCut
private

Definition at line 178 of file ZdcAnalysisTool.h.

◆ m_deltaTSample

float ZDC::ZdcAnalysisTool::m_deltaTSample
private

Definition at line 168 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 155 of file ZdcAnalysisTool.h.

◆ m_doFADCCorr

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

Definition at line 158 of file ZdcAnalysisTool.h.

◆ m_doFADCCorrPerSample

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

Definition at line 160 of file ZdcAnalysisTool.h.

◆ m_doNonLinCorr

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

Definition at line 159 of file ZdcAnalysisTool.h.

◆ m_doTimeCalib

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

Definition at line 157 of file ZdcAnalysisTool.h.

◆ m_doTrigEff

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

Definition at line 156 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 144 of file ZdcAnalysisTool.h.

◆ m_eventReady

bool ZDC::ZdcAnalysisTool::m_eventReady
private

Definition at line 137 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 176 of file ZdcAnalysisTool.h.

◆ m_fixTau2

bool ZDC::ZdcAnalysisTool::m_fixTau2
private

Definition at line 177 of file ZdcAnalysisTool.h.

◆ m_flipEMDelay

bool ZDC::ZdcAnalysisTool::m_flipEMDelay
private

Definition at line 152 of file ZdcAnalysisTool.h.

◆ m_forceCalibLB

int ZDC::ZdcAnalysisTool::m_forceCalibLB
private

Definition at line 162 of file ZdcAnalysisTool.h.

◆ m_forceCalibRun

int ZDC::ZdcAnalysisTool::m_forceCalibRun
private

Definition at line 161 of file ZdcAnalysisTool.h.

◆ m_init

bool ZDC::ZdcAnalysisTool::m_init
private

Definition at line 127 of file ZdcAnalysisTool.h.

◆ m_LHCRun

int ZDC::ZdcAnalysisTool::m_LHCRun
private

Definition at line 181 of file ZdcAnalysisTool.h.

◆ m_lowGainMode

unsigned int ZDC::ZdcAnalysisTool::m_lowGainMode
private

Definition at line 153 of file ZdcAnalysisTool.h.

◆ m_lumiBlock

unsigned int ZDC::ZdcAnalysisTool::m_lumiBlock
private

Definition at line 139 of file ZdcAnalysisTool.h.

◆ m_name

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

Definition at line 126 of file ZdcAnalysisTool.h.

◆ m_numSample

unsigned int ZDC::ZdcAnalysisTool::m_numSample
private

Definition at line 167 of file ZdcAnalysisTool.h.

◆ m_peak2ndDerivMinSamples

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

Definition at line 189 of file ZdcAnalysisTool.h.

◆ m_peak2ndDerivMinThresholdsHG

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

Definition at line 190 of file ZdcAnalysisTool.h.

◆ m_peak2ndDerivMinThresholdsLG

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

Definition at line 191 of file ZdcAnalysisTool.h.

◆ m_Peak2ndDerivThresh

float ZDC::ZdcAnalysisTool::m_Peak2ndDerivThresh
private

Definition at line 171 of file ZdcAnalysisTool.h.

◆ m_peakSample

unsigned int ZDC::ZdcAnalysisTool::m_peakSample
private

Definition at line 170 of file ZdcAnalysisTool.h.

◆ m_presample

unsigned int ZDC::ZdcAnalysisTool::m_presample
private

Definition at line 169 of file ZdcAnalysisTool.h.

◆ m_runNumber

unsigned int ZDC::ZdcAnalysisTool::m_runNumber
private

Definition at line 138 of file ZdcAnalysisTool.h.

◆ m_t0

float ZDC::ZdcAnalysisTool::m_t0
private

Definition at line 172 of file ZdcAnalysisTool.h.

◆ m_tau1

float ZDC::ZdcAnalysisTool::m_tau1
private

Definition at line 174 of file ZdcAnalysisTool.h.

◆ m_tau2

float ZDC::ZdcAnalysisTool::m_tau2
private

Definition at line 175 of file ZdcAnalysisTool.h.

◆ m_tf1SincInterp

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

Definition at line 142 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 134 of file ZdcAnalysisTool.h.

◆ m_zdcAnalysisConfigPath

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

Definition at line 129 of file ZdcAnalysisTool.h.

◆ m_zdcDataAnalyzer

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

Definition at line 185 of file ZdcAnalysisTool.h.

◆ m_zdcDataAnalyzer_40MHz

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

Definition at line 186 of file ZdcAnalysisTool.h.

◆ m_zdcDataAnalyzer_80MHz

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

Definition at line 187 of file ZdcAnalysisTool.h.

◆ m_zdcEnergyCalibFileName

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

Definition at line 130 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 222 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 221 of file ZdcAnalysisTool.h.

◆ m_zdcModuleAmplitude

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

Definition at line 200 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 206 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 210 of file ZdcAnalysisTool.h.

◆ m_zdcModuleCalibEnergy

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

Definition at line 201 of file ZdcAnalysisTool.h.

◆ m_zdcModuleCalibTime

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

Definition at line 202 of file ZdcAnalysisTool.h.

◆ m_zdcModuleChisq

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

Definition at line 205 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 225 of file ZdcAnalysisTool.h.

◆ m_zdcModuleContainerName

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

Definition at line 148 of file ZdcAnalysisTool.h.

◆ m_zdcModuleFitAmp

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

Definition at line 207 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 208 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 220 of file ZdcAnalysisTool.h.

◆ m_zdcModuleFitT0

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

Definition at line 209 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 214 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 215 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 216 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 213 of file ZdcAnalysisTool.h.

◆ m_zdcModulePresample

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

Definition at line 212 of file ZdcAnalysisTool.h.

◆ m_zdcModulePreSampleAmp

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

Definition at line 211 of file ZdcAnalysisTool.h.

◆ m_zdcModules

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

Definition at line 149 of file ZdcAnalysisTool.h.

◆ m_zdcModuleStatus

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

Definition at line 203 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 223 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 224 of file ZdcAnalysisTool.h.

◆ m_zdcModuleTime

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

Definition at line 204 of file ZdcAnalysisTool.h.

◆ m_zdcSumAverageTime

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

Definition at line 233 of file ZdcAnalysisTool.h.

◆ m_zdcSumCalibEnergy

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

Definition at line 230 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 231 of file ZdcAnalysisTool.h.

◆ m_zdcSumContainerName

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

Definition at line 150 of file ZdcAnalysisTool.h.

◆ m_zdcSumFinalEnergy

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

Definition at line 232 of file ZdcAnalysisTool.h.

◆ m_zdcSumModuleMask

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

Definition at line 235 of file ZdcAnalysisTool.h.

◆ m_zdcSums

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

Definition at line 151 of file ZdcAnalysisTool.h.

◆ m_zdcSumStatus

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

Definition at line 234 of file ZdcAnalysisTool.h.

◆ m_zdcSumUncalibSum

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

Definition at line 228 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 229 of file ZdcAnalysisTool.h.

◆ m_zdcTimeCalibFileName

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

Definition at line 131 of file ZdcAnalysisTool.h.

◆ m_zdcTriggerEfficiency

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

Definition at line 194 of file ZdcAnalysisTool.h.

◆ m_zdcTriggerEffParamsFileName

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

Definition at line 132 of file ZdcAnalysisTool.h.

◆ s_debugLevel

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

Definition at line 196 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:132
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:215
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ZDC::ZdcAnalysisTool::MakeMessageFunction
ZDCMsg::MessageFunctionPtr MakeMessageFunction()
Definition: ZdcAnalysisTool.h:77
ZDC::ZdcAnalysisTool::m_zdcModuleContainerName
std::string m_zdcModuleContainerName
Definition: ZdcAnalysisTool.h:148
ZDC::ZdcAnalysisTool::initializeInjectorpp2024
std::unique_ptr< ZDCDataAnalyzer > initializeInjectorpp2024()
Definition: ZdcAnalysisTool.cxx:798
ZDCPulseAnalyzer::getRefitLGAmp
float getRefitLGAmp() const
Definition: ZDCPulseAnalyzer.h:603
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
ZDC::ZdcAnalysisTool::m_doFADCCorr
bool m_doFADCCorr
Definition: ZdcAnalysisTool.h:158
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinSamples
ZDCDataAnalyzer::ZDCModuleIntArray m_peak2ndDerivMinSamples
Definition: ZdcAnalysisTool.h:189
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
ZDC::ZdcAnalysisTool::m_runNumber
unsigned int m_runNumber
Definition: ZdcAnalysisTool.h:138
ZDC::ZdcAnalysisTool::m_Peak2ndDerivThresh
float m_Peak2ndDerivThresh
Definition: ZdcAnalysisTool.h:171
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:205
ZDC::ZdcAnalysisTool::m_zdcModules
const xAOD::ZdcModuleContainer * m_zdcModules
Definition: ZdcAnalysisTool.h:149
ZDC::ZdcAnalysisTool::initializePbPb2024
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2024()
Definition: ZdcAnalysisTool.cxx:633
ZDC::ZdcAnalysisTool::m_zdcModuleCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibEnergy
Definition: ZdcAnalysisTool.h:201
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinThresholdsLG
ZDCDataAnalyzer::ZDCModuleFloatArray m_peak2ndDerivMinThresholdsLG
Definition: ZdcAnalysisTool.h:191
ZDCPulseAnalyzer::getMaxADCLG
float getMaxADCLG() const
Definition: ZDCPulseAnalyzer.h:641
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
ZDC::ZdcAnalysisTool::m_doTrigEff
bool m_doTrigEff
Definition: ZdcAnalysisTool.h:156
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
ZDC::ZdcAnalysisTool::m_ChisqRatioCut
float m_ChisqRatioCut
Definition: ZdcAnalysisTool.h:179
ZDC::ZdcAnalysisTool::m_LHCRun
int m_LHCRun
Definition: ZdcAnalysisTool.h:181
ZDCDataAnalyzer::ZDCModuleFloatArray
std::array< std::array< float, 4 >, 2 > ZDCModuleFloatArray
Definition: ZDCDataAnalyzer.h:22
ZDCPulseAnalyzer::GetAmpError
float GetAmpError() const
Definition: ZDCPulseAnalyzer.h:600
Data
@ Data
Definition: BaseObject.h:11
ZDC::ZdcAnalysisTool::m_fixTau1
bool m_fixTau1
Definition: ZdcAnalysisTool.h:176
ZDCPulseAnalyzer::getRefitLGTime
float getRefitLGTime() const
Definition: ZDCPulseAnalyzer.h:627
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:207
ZDCPulseAnalyzer::GetAmpNoNonLin
float GetAmpNoNonLin() const
Definition: ZDCPulseAnalyzer.h:598
ZDC::ZdcAnalysisTool::getUncalibModuleSumErr
float getUncalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:2619
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:157
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:206
ZDC::ZdcAnalysisTool::initializepp2024
std::unique_ptr< ZDCDataAnalyzer > initializepp2024()
Definition: ZdcAnalysisTool.cxx:379
ZDC::ZdcAnalysisTool::m_zdcAnalysisConfigPath
std::string m_zdcAnalysisConfigPath
Definition: ZdcAnalysisTool.h:129
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:144
ZDC::ZdcAnalysisTool::m_presample
unsigned int m_presample
Definition: ZdcAnalysisTool.h:169
ZDC::ZdcAnalysisTool::m_zdcSumModuleMask
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumModuleMask
Definition: ZdcAnalysisTool.h:235
ZDCPulseAnalyzer
Definition: ZDCPulseAnalyzer.h:24
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:203
ZDC::ZdcAnalysisTool::m_zdcSumAverageTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumAverageTime
Definition: ZdcAnalysisTool.h:233
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
ZDCPulseAnalyzer::getRefitLGTimeSub
float getRefitLGTimeSub() const
Definition: ZDCPulseAnalyzer.h:633
ZDC::ZdcAnalysisTool::m_tf1SincInterp
std::unique_ptr< TF1 > m_tf1SincInterp
Definition: ZdcAnalysisTool.h:142
ZDC::ZdcAnalysisTool::m_tau1
float m_tau1
Definition: ZdcAnalysisTool.h:174
ReweightUtils.message
message
Definition: ReweightUtils.py:15
ZDC::ZdcAnalysisTool::m_lowGainMode
unsigned int m_lowGainMode
Definition: ZdcAnalysisTool.h:153
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:292
ZDC::ZdcAnalysisTool::setFADCCorrections
void setFADCCorrections(unsigned int runNumber=0)
Definition: ZdcAnalysisTool.cxx:2437
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:234
ZDC::ZdcAnalysisTool::m_zdcModuleAmplitude
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmplitude
Definition: ZdcAnalysisTool.h:200
ZDC::ZdcAnalysisTool::sideFailed
bool sideFailed(int side)
Definition: ZdcAnalysisTool.cxx:2631
ZDC::ZdcAnalysisTool::getModuleSum
float getModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:2595
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:232
python.PyAthena.module
module
Definition: PyAthena.py:131
ZDC::ZdcAnalysisTool::m_lumiBlock
unsigned int m_lumiBlock
Definition: ZdcAnalysisTool.h:139
ZDCPulseAnalyzer::TimingCorrLog
@ TimingCorrLog
Definition: ZDCPulseAnalyzer.h:59
ZDC::ZdcAnalysisTool::setEnergyCalibrations
void setEnergyCalibrations(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:2297
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:173
ZDC::ZdcAnalysisTool::m_doNonLinCorr
bool m_doNonLinCorr
Definition: ZdcAnalysisTool.h:159
ZDC::ZdcAnalysisTool::m_init
bool m_init
Definition: ZdcAnalysisTool.h:127
ZDCPulseAnalyzer::getPresample
float getPresample() const
Definition: ZDCPulseAnalyzer.h:639
ZDCPulseAnalyzer::getMaxADCHG
float getMaxADCHG() const
Definition: ZDCPulseAnalyzer.h:640
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
ZDC::ZdcAnalysisTool::getCalibModuleSumErr
float getCalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:2607
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:228
ZDCDataAnalyzer::SetNoiseSigmas
void SetNoiseSigmas(const ZDCModuleFloatArray &noiseSigmasHG, const ZDCModuleFloatArray &noiseSigmasLG)
Definition: ZDCDataAnalyzer.cxx:244
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
ZDCPulseAnalyzer::getRefitLGFitAmp
float getRefitLGFitAmp() const
Definition: ZDCPulseAnalyzer.h:609
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:924
ZDC::ZdcAnalysisTool::m_combineDelay
bool m_combineDelay
Definition: ZdcAnalysisTool.h:154
ZDC::ZdcAnalysisTool::m_numSample
unsigned int m_numSample
Definition: ZdcAnalysisTool.h:167
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ZDC::ZdcAnalysisTool::initializepPb2016
std::unique_ptr< ZDCDataAnalyzer > initializepPb2016()
Definition: ZdcAnalysisTool.cxx:1297
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ZDC::ZdcAnalysisTool::m_forceCalibLB
int m_forceCalibLB
Definition: ZdcAnalysisTool.h:162
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::m_zdcDataAnalyzer_80MHz
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer_80MHz
Definition: ZdcAnalysisTool.h:187
ZDC::ZdcAnalysisTool::m_zdcModuleChisqLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleChisqLGRefit
Definition: ZdcAnalysisTool.h:225
ZDCDataAnalyzer::SetADCOverUnderflowValues
void SetADCOverUnderflowValues(const ZDCModuleFloatArray &HGOverflowADC, const ZDCModuleFloatArray &HGUnderflowADC, const ZDCModuleFloatArray &LGOverflowADC)
Definition: ZDCDataAnalyzer.cxx:282
file
TFile * file
Definition: tile_monitor.h:29
ZDC::ZdcAnalysisTool::m_zdcModuleMaxADC
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMaxADC
Definition: ZdcAnalysisTool.h:214
ZDCPulseAnalyzer::LGModeForceLG
@ LGModeForceLG
Definition: ZDCPulseAnalyzer.h:55
ZDC::ZdcAnalysisTool::m_zdcModuleFitT0
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitT0
Definition: ZdcAnalysisTool.h:209
ZDC::ZdcAnalysisTool::recoZdcModules
StatusCode recoZdcModules(const xAOD::ZdcModuleContainer &moduleContainer, const xAOD::ZdcModuleContainer &moduleSumContainer) override
Definition: ZdcAnalysisTool.cxx:1989
python.xAODType.dummy
dummy
Definition: xAODType.py:4
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:2637
ZDCPulseAnalyzer::getMaxADCSub
float getMaxADCSub() const
Definition: ZDCPulseAnalyzer.h:645
DQHistogramMerge.debugLevel
debugLevel
Definition: DQHistogramMerge.py:41
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:59
ZDC::ZdcAnalysisTool::m_zdcModuleT0SubLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleT0SubLGRefit
Definition: ZdcAnalysisTool.h:224
ZDC::ZdcAnalysisTool::m_zdcModuleMinDeriv2nd
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMinDeriv2nd
Definition: ZdcAnalysisTool.h:213
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:232
ZDC::ZdcAnalysisTool::m_zdcModuleBkgdMaxFraction
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleBkgdMaxFraction
Definition: ZdcAnalysisTool.h:210
ZDC::ZdcAnalysisTool::m_zdcSumContainerName
std::string m_zdcSumContainerName
Definition: ZdcAnalysisTool.h:150
ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer
Definition: ZdcAnalysisTool.h:185
ZDC::ZdcAnalysisTool::setTimeCalibrations
void setTimeCalibrations(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:2362
xAOD::EventInfo_v1::ForwardDet
@ ForwardDet
The forward detectors.
Definition: EventInfo_v1.h:338
ZDC::ZdcAnalysisTool::m_tau2
float m_tau2
Definition: ZdcAnalysisTool.h:175
ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergyErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergyErr
Definition: ZdcAnalysisTool.h:231
ZDCDataAnalyzer::enableDelayed
void enableDelayed(float deltaT, const ZDCModuleFloatArray &undelayedDelayedPedestalDiff)
Definition: ZDCDataAnalyzer.cxx:109
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:163
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:223
ZDC::ZdcAnalysisTool::m_zdcModuleAmpLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmpLGRefit
Definition: ZdcAnalysisTool.h:221
ZDC::ZdcAnalysisTool::m_writeAux
bool m_writeAux
Definition: ZdcAnalysisTool.h:134
ZDC::ZdcAnalysisTool::m_configuration
std::string m_configuration
Definition: ZdcAnalysisTool.h:128
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
ZDC::ZdcAnalysisTool::m_doFADCCorrPerSample
bool m_doFADCCorrPerSample
Definition: ZdcAnalysisTool.h:160
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
ZDC::ZdcAnalysisTool::m_forceCalibRun
int m_forceCalibRun
Definition: ZdcAnalysisTool.h:161
ZDC::ZdcAnalysisTool::m_deltaTCut
float m_deltaTCut
Definition: ZdcAnalysisTool.h:178
ZDCTriggerEfficiency
Definition: ZDCTriggerEfficiency.h:16
ZDC::ZdcAnalysisTool::m_zdcModuleCalibTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibTime
Definition: ZdcAnalysisTool.h:202
ZDC::ZdcAnalysisTool::s_debugLevel
static std::atomic< int > s_debugLevel
Definition: ZdcAnalysisTool.h:196
ZDC::ZdcAnalysisTool::m_zdcSums
const xAOD::ZdcModuleContainer * m_zdcSums
Definition: ZdcAnalysisTool.h:151
ZDCMsg::MessageFunctionPtr
std::shared_ptr< MessageFunction > MessageFunctionPtr
Definition: ZDCMsg.h:14
ZDCPulseAnalyzer::GetFitAmplitude
float GetFitAmplitude() const
Definition: ZDCPulseAnalyzer.h:583
ZDC::ZdcAnalysisTool::initializeLHCf2022
std::unique_ptr< ZDCDataAnalyzer > initializeLHCf2022()
Definition: ZdcAnalysisTool.cxx:201
ZDCPulseAnalyzer::getRefitLGChisq
float getRefitLGChisq() const
Definition: ZDCPulseAnalyzer.h:621
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
ZDCPulseAnalyzer::GetMinDeriv2nd
float GetMinDeriv2nd() const
Definition: ZDCPulseAnalyzer.h:672
ZDC::ZdcAnalysisTool::m_zdcTriggerEfficiency
std::shared_ptr< ZDCTriggerEfficiency > m_zdcTriggerEfficiency
Definition: ZdcAnalysisTool.h:194
ZDCPulseAnalyzer::GetFitT0
float GetFitT0() const
Definition: ZDCPulseAnalyzer.h:584
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
ZDC::ZdcAnalysisTool::m_zdcModuleFitAmpError
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmpError
Definition: ZdcAnalysisTool.h:208
ZDC::ZdcAnalysisTool::getAverageTime
float getAverageTime(int side)
Definition: ZdcAnalysisTool.cxx:2625
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ZDC::ZdcAnalysisTool::m_zdcModulePresample
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePresample
Definition: ZdcAnalysisTool.h:212
ZDCPulseAnalyzer::GetBkgdMaxFraction
float GetBkgdMaxFraction() const
Definition: ZDCPulseAnalyzer.h:678
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:204
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
ZDC::ZdcAnalysisTool::configureNewRun
StatusCode configureNewRun(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:1969
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:190
ZDC::ZdcAnalysisTool::initializeDefault
std::unique_ptr< ZDCDataAnalyzer > initializeDefault()
Definition: ZdcAnalysisTool.cxx:1171
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:186
ZDCPulseAnalyzer::getRefitLGAmpCorr
float getRefitLGAmpCorr() const
Definition: ZDCPulseAnalyzer.h:615
ZDCDataAnalyzer::SetFitTimeMax
void SetFitTimeMax(float tmax)
Definition: ZDCDataAnalyzer.cxx:218
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
ZDC::ZdcAnalysisTool::m_deltaTSample
float m_deltaTSample
Definition: ZdcAnalysisTool.h:168
ZDCPulseAnalyzer::LGModeRefitLG
@ LGModeRefitLG
Definition: ZDCPulseAnalyzer.h:56
ZDC::ZdcAnalysisTool::initializeMonteCarloPbPb2023
std::unique_ptr< ZDCDataAnalyzer > initializeMonteCarloPbPb2023()
Definition: ZdcAnalysisTool.cxx:1015
ZDC::ZdcAnalysisTool::m_zdcSumUncalibSumErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumUncalibSumErr
Definition: ZdcAnalysisTool.h:229
ZDC::ZdcAnalysisTool::m_zdcTimeCalibFileName
std::string m_zdcTimeCalibFileName
Definition: ZdcAnalysisTool.h:131
ZDC::ZdcAnalysisTool::m_peakSample
unsigned int m_peakSample
Definition: ZdcAnalysisTool.h:170
ZDC::ZdcAnalysisTool::m_zdcModuleFitAmpLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmpLGRefit
Definition: ZdcAnalysisTool.h:220
beamspotman.qual
qual
Definition: beamspotman.py:481
ZDC::ZdcAnalysisTool::getCalibModuleSum
float getCalibModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:2601
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
ZDC::ZdcAnalysisTool::initialize80MHz
void initialize80MHz()
Definition: ZdcAnalysisTool.cxx:1656
ZDCDataAnalyzer::enableRepass
void enableRepass(const ZDCModuleFloatArray &peak2ndDerivMinRepassHG, const ZDCModuleFloatArray &peak2ndDerivMinRepassLG)
Definition: ZDCDataAnalyzer.cxx:172
calibdata.copy
bool copy
Definition: calibdata.py:27
ZDC::ZdcAnalysisTool::initializePbPb2018
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2018()
Definition: ZdcAnalysisTool.cxx:1409
ZDC::ZdcAnalysisTool::m_flipEMDelay
bool m_flipEMDelay
Definition: ZdcAnalysisTool.h:152
ZDC::ZdcAnalysisTool::m_zdcModulePreSampleAmp
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePreSampleAmp
Definition: ZdcAnalysisTool.h:211
ZDCDataAnalyzer::SetPeak2ndDerivMinTolerances
void SetPeak2ndDerivMinTolerances(size_t tolerance)
Definition: ZDCDataAnalyzer.cxx:209
ZDCPulseAnalyzer::GetChisq
float GetChisq() const
Definition: ZDCPulseAnalyzer.h:588
ZDC::ZdcAnalysisTool::initializePbPb2015G4
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2015G4()
Definition: ZdcAnalysisTool.cxx:1234
ZDC::ZdcAnalysisTool::m_zdcEnergyCalibFileName
std::string m_zdcEnergyCalibFileName
Definition: ZdcAnalysisTool.h:130
ZDC::ZdcAnalysisTool::m_t0
float m_t0
Definition: ZdcAnalysisTool.h:172
ZDC::ZdcAnalysisTool::m_zdcModuleAmpCorrLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmpCorrLGRefit
Definition: ZdcAnalysisTool.h:222
python.DataFormatRates.env
env
Definition: DataFormatRates.py:32
SG::DataProxy
Definition: DataProxy.h:45
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
ZDCDataAnalyzer::SetSaveFitFunc
void SetSaveFitFunc(bool save)
Definition: ZDCDataAnalyzer.cxx:227
ZDC::ZdcAnalysisTool::m_doCalib
bool m_doCalib
Definition: ZdcAnalysisTool.h:155
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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:305
ZDC::ZdcAnalysisTool::m_auxSuffix
std::string m_auxSuffix
Definition: ZdcAnalysisTool.h:135
ZDC::ZdcAnalysisTool::initialize40MHz
void initialize40MHz()
Definition: ZdcAnalysisTool.cxx:1536
ZDC::ZdcAnalysisTool::m_fixTau2
bool m_fixTau2
Definition: ZdcAnalysisTool.h:177
ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergy
Definition: ZdcAnalysisTool.h:230
fitman.k
k
Definition: fitman.py:528
ZDC::ZdcAnalysisTool::m_name
std::string m_name
Definition: ZdcAnalysisTool.h:126
ZDC::ZdcAnalysisTool::m_eventReady
bool m_eventReady
Definition: ZdcAnalysisTool.h:137
ZDC::ZdcAnalysisTool::m_zdcModuleMaxADCLG
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMaxADCLG
Definition: ZdcAnalysisTool.h:216
ZDCPulseAnalyzer::GetPreSampleAmp
float GetPreSampleAmp() const
Definition: ZDCPulseAnalyzer.h:677
ZDCDataAnalyzer::SetModuleAmpFractionLG
void SetModuleAmpFractionLG(const ZDCDataAnalyzer::ZDCModuleFloatArray &moduleAmpFractionLG)
Definition: ZDCDataAnalyzer.cxx:253
ZDC::ZdcAnalysisTool::getUncalibModuleSum
float getUncalibModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:2613
Generated on Sun Dec 22 2024 22:13:29 for ATLAS Offline Software by   doxygen 1.8.18