ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Public Attributes | 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)
 
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)
 

Public Attributes

bool m_doTimeCalib
 

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
 
bool m_doCalib
 
bool m_doTrigEff
 
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_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 pedestal"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmpLGRefit {this, "ZdcModuleAmpLGRefit", "", "ZDC module fit amp LG refit"}
 
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  // The following parameters are primarily used for the "default" configuration, but also may be
55  // use to modify/tailor other configurations
56  //
57  declareProperty("NumSampl", m_numSample = 7);
58  declareProperty("DeltaTSample", m_deltaTSample = 25);
59  declareProperty("Presample", m_presample = 0);
60  declareProperty("CombineDelay", m_combineDelay = false);
61  declareProperty("DelayDeltaT", m_delayDeltaT = -12.5);
62 
63  declareProperty("PeakSample", m_peakSample = 11);
64  declareProperty("Peak2ndDerivThresh", m_Peak2ndDerivThresh = 20);
65 
66  declareProperty("T0", m_t0 = 30);
67  declareProperty("Tau1", m_tau1 = 5);
68  declareProperty("Tau2", m_tau2 = 25);
69  declareProperty("FixTau1", m_fixTau1 = false);
70  declareProperty("FixTau2", m_fixTau2 = false);
71 
72  declareProperty("DeltaTCut", m_deltaTCut = 10);
73  declareProperty("ChisqRatioCut", m_ChisqRatioCut = 10);
74 
75  declareProperty("LHCRun", m_LHCRun = 3);
76 
77 }

◆ ~ZdcAnalysisTool()

ZDC::ZdcAnalysisTool::~ZdcAnalysisTool ( )
overridevirtual

Definition at line 79 of file ZdcAnalysisTool.cxx.

80 {
81  ATH_MSG_DEBUG("Deleting ZdcAnalysisTool named " << m_name);
82 }

Member Function Documentation

◆ configureNewRun()

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

Definition at line 2006 of file ZdcAnalysisTool.cxx.

2007 {
2008  ATH_MSG_DEBUG("Setting up new run " << runNumber);
2009 
2010  // We do nothing for the default configuration
2011  //
2012  if (m_configuration != "default") {
2013  if (m_configuration == "PbPb2015") {
2014  //
2015  // Two periods, 40 MHz and 80 MHz readout
2016  //
2017  if (runNumber < 287222) m_zdcDataAnalyzer = m_zdcDataAnalyzer_40MHz;
2018  else m_zdcDataAnalyzer = m_zdcDataAnalyzer_80MHz;
2019  }
2020  }
2021 
2022  return StatusCode::SUCCESS;
2023 }

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

2538 {
2539  if (!m_zdcDataAnalyzer) return 0;
2540  return m_zdcDataAnalyzer->GetAverageTime(side);
2541 }

◆ getCalibModuleSum()

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

Definition at line 2513 of file ZdcAnalysisTool.cxx.

2514 {
2515  if (!m_zdcDataAnalyzer) return 0;
2516  return m_zdcDataAnalyzer->GetCalibModuleSum(side);
2517 }

◆ getCalibModuleSumErr()

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

Definition at line 2519 of file ZdcAnalysisTool.cxx.

2520 {
2521  if (!m_zdcDataAnalyzer) return 0;
2522  return m_zdcDataAnalyzer->GetCalibModuleSumErr(side);
2523 }

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

2550 {
2551  if (!m_zdcDataAnalyzer) return 0;
2552  return m_zdcDataAnalyzer->GetModuleMask();
2553 }

◆ getModuleSum()

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

Definition at line 2507 of file ZdcAnalysisTool.cxx.

2508 {
2509  if (!m_zdcDataAnalyzer) return 0;
2510  return m_zdcDataAnalyzer->GetModuleSum(side);
2511 }

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

2556 {
2557  if (!m_doTrigEff) return -1;
2558 
2559  m_zdcTriggerEfficiency->UpdatelumiBlock(m_lumiBlock);
2560  float adcSum = getModuleSum(side);
2561  double eff = m_zdcTriggerEfficiency->GetEfficiency(side, adcSum);
2562  return eff;
2563 }

◆ getTriggerEfficiencyUncertainty()

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

Definition at line 2565 of file ZdcAnalysisTool.cxx.

2566 {
2567  if (!m_doCalib) return -1;
2568 
2569  m_zdcTriggerEfficiency->UpdatelumiBlock(m_lumiBlock);
2570  float adcSum = getModuleSum(side);
2571  std::pair<double, double> eff_pair = m_zdcTriggerEfficiency->GetEfficiencyAndError(msg(), side, adcSum);
2572  return eff_pair.second;
2573 }

◆ getUncalibModuleSum()

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

Definition at line 2525 of file ZdcAnalysisTool.cxx.

2526 {
2527  if (!m_zdcDataAnalyzer) return 0;
2528  return m_zdcDataAnalyzer->GetModuleSum(side);
2529 }

◆ getUncalibModuleSumErr()

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

Definition at line 2531 of file ZdcAnalysisTool.cxx.

2532 {
2533  if (!m_zdcDataAnalyzer) return 0;
2534  return m_zdcDataAnalyzer->GetModuleSumErr(side);
2535 }

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

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

◆ initialize40MHz()

void ZDC::ZdcAnalysisTool::initialize40MHz ( )

Definition at line 1584 of file ZdcAnalysisTool.cxx.

1585 {
1586  // We have a complete configuration and so we override all of the default parameters
1587  //
1588 
1589  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{{4.2, 3.8, 5.2, 5.0}},
1590  {{5.0, 3.7, 3.5, 3.5}}
1591  }
1592  };
1593 
1594  // identical to 80 MHz -- is this right
1595  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{{20.0, 20.4, 18.9, 20.8}},
1596  {{19.1, 21.9, 22.6, 23.4}}
1597  }
1598  };
1599 
1600  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{{1, 1, 2, 1}},
1601  {{1, 1, 1, 1}}
1602  }
1603  };
1604 
1605  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG = {{{{ -8, -8, -8, -8}},
1606  {{ -8, -8, -8, -8}}
1607  }
1608  };
1609 
1610  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsLG = {{{{ -4, -4, -4, -4}},
1611  {{ -4, -4, -4, -4}}
1612  }
1613  };
1614 
1615  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1616  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1617  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1618 
1619  // Set Tau and nominal timing offsets
1620  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1621 
1622  bool fixTau1 = true;
1623  bool fixTau2 = true;
1624 
1625  for (size_t side : {0, 1}) {
1626  for (size_t module : {0, 1, 2, 3}) {
1627  fixTau1Arr[side][module] = fixTau1;
1628  fixTau2Arr[side][module] = fixTau2;
1629  }
1630  }
1631 
1632  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{{53.942, 49.887, 59.633, 46.497}},
1633  {{46.314, 42.267, 50.327, 41.605}}
1634  }
1635  };
1636  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{{51.771, 47.936, 57.438, 44.191}},
1637  {{44.295, 41.755, 48.081, 40.175}}
1638  }
1639  };
1640 
1641 
1642  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1643  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutLG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1644  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1645  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1646  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1647  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1648 
1649  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1650 
1651  slewingParamsHG[0][0] = {0, -7.904e-02, 4.686e-02, 1.530e-03 };
1652  slewingParamsHG[0][1] = {0, 2.250e-02, 4.732e-02, 6.050e-03 };
1653  slewingParamsHG[0][2] = {0, 4.388e-02, 6.707e-02, -5.526e-05 };
1654  slewingParamsHG[0][3] = {0, 1.205e-01, 2.726e-02, 2.610e-03 };
1655 
1656  slewingParamsHG[1][0] = {0, 6.861e-02, 5.175e-03, -9.018e-04 };
1657  slewingParamsHG[1][1] = {0, 3.855e-01, -4.442e-02, -2.022e-02 };
1658  slewingParamsHG[1][2] = {0, -4.337e-03, 3.841e-02, 4.661e-03 };
1659  slewingParamsHG[1][3] = {0, 3.623e-01, -3.882e-02, -1.805e-02 };
1660 
1661  slewingParamsLG[0][0] = {0, 1.708e-02, 7.929e-02, 5.079e-03 };
1662  slewingParamsLG[0][1] = {0, 1.406e-01, 1.209e-01, -1.922e-04 };
1663  slewingParamsLG[0][2] = {0, 1.762e-01, 1.118e-01, 1.679e-04 };
1664  slewingParamsLG[0][3] = {0, 1.361e-02, -2.685e-02, -4.168e-02 };
1665 
1666  slewingParamsLG[1][0] = {0, 1.962e-01, -5.025e-03, -2.001e-02 };
1667  slewingParamsLG[1][1] = {0, 3.258e-01, 1.229e-02, -2.925e-02 };
1668  slewingParamsLG[1][2] = {0, 1.393e-01, 8.113e-02, -2.594e-03 };
1669  slewingParamsLG[1][3] = {0, 1.939e-01, 2.188e-02, -5.579e-02 };
1670 
1671  m_zdcDataAnalyzer_40MHz.reset (new ZDCDataAnalyzer(MakeMessageFunction(), 7, 25, 0, "FermiExp", peak2ndDerivMinSamples,
1672  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1673 
1674  m_zdcDataAnalyzer_40MHz->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1675  m_zdcDataAnalyzer_40MHz->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1676  m_zdcDataAnalyzer_40MHz->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1677  m_zdcDataAnalyzer_40MHz->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1678  slewingParamsHG, slewingParamsLG);
1679 
1680  std::array<std::array<std::vector<float>, 4>, 2> moduleHGNonLinCorr, moduleLGNonLinCorr;
1681  moduleHGNonLinCorr[0][0] = { -3.76800e-02, 4.63597e-02};
1682  moduleHGNonLinCorr[0][1] = { -1.02185e-01, -1.17548e-01};
1683  moduleHGNonLinCorr[0][2] = { -8.78451e-02, -1.52174e-01};
1684  moduleHGNonLinCorr[0][3] = { -1.04835e-01, -1.96514e-01};
1685  moduleHGNonLinCorr[1][0] = { -6.83115e-02, 3.57802e-02};
1686  moduleHGNonLinCorr[1][1] = { -1.08162e-01, -1.91413e-01};
1687  moduleHGNonLinCorr[1][2] = { -7.82514e-02, -1.21218e-01};
1688  moduleHGNonLinCorr[1][3] = { -2.34354e-02, -2.52033e-01};
1689 
1690  moduleLGNonLinCorr = {{ {{{0},
1691  {0},
1692  {0},
1693  {0}}},
1694  {{{0},
1695  {0},
1696  {0},
1697  {0}}} }};
1698 
1699  m_zdcDataAnalyzer_40MHz->SetNonlinCorrParams(500, 1000, moduleHGNonLinCorr, moduleLGNonLinCorr);
1700  m_zdcDataAnalyzer_40MHz->SetSaveFitFunc(false);
1701 
1702 }

◆ initialize80MHz()

void ZDC::ZdcAnalysisTool::initialize80MHz ( )

Definition at line 1704 of file ZdcAnalysisTool.cxx.

1705 {
1706  // We have a complete configuration and so we override all of the default parameters
1707  //
1708 
1709  m_peak2ndDerivMinSamples = {{{{3, 2, 3, 2}},
1710  {{2, 2, 2, 2}}
1711  }
1712  };
1713 
1714  m_peak2ndDerivMinThresholdsHG = {{{{ -8, -8, -8, -8}},
1715  {{ -8, -8, -8, -8}}
1716  }
1717  };
1718 
1719  m_peak2ndDerivMinThresholdsLG = {{{{ -4, -4, -4, -4}},
1720  {{ -4, -4, -4, -4}}
1721  }
1722  };
1723 
1724  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1725  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1726  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{950, 950, 950, 950}}, {{950, 950, 950, 950}}}};
1727 
1728  // Set Tau and nominal timing offsets
1729  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1730 
1731  bool fixTau1 = true;
1732  bool fixTau2 = true;
1733 
1734  for (size_t side : {0, 1}) {
1735  for (size_t module : {0, 1, 2, 3}) {
1736  fixTau1Arr[side][module] = fixTau1;
1737  fixTau2Arr[side][module] = fixTau2;
1738  }
1739  }
1740 
1741  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{{3.9, 3.4, 4.1, 4.2}},
1742  {{4.2, 3.6, 3.3, 3.4}}
1743  }
1744  };
1745 
1746  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{{20.0, 20.4, 18.9, 20.8}},
1747  {{19.1, 21.9, 22.6, 23.4}}
1748  }
1749  };
1750 
1751  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{{44.24, 40.35, 49.3, 36.0}},
1752  {{36.0, 31.1, 40.75, 30.5}}
1753  }
1754  };
1755 
1756  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{{42.65, 38.5, 47.4, 34}},
1757  {{33.7, 29.9, 39.0, 29.3}}
1758  }
1759  };
1760 
1761  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1762  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutLG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1763  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1764  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1765  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1766  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1767 
1768  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1769 
1770  slewingParamsHG[0][0] = {0, -6.5e-2, 2.85e-2, -2.83e-3};
1771  slewingParamsHG[0][1] = {0, -5.5e-2, 5.13e-2, 5.6e-3};
1772  slewingParamsHG[0][2] = {0, -1.45e-3, 9.3e-2, 3.9e-3};
1773  slewingParamsHG[0][3] = {0, -2.36e-2, 8.3e-2, 1.1e-3};
1774 
1775  slewingParamsHG[1][0] = {0, -6.5e-2, 4.84e-2, -3.7e-3};
1776  slewingParamsHG[1][1] = {0, 1.34e-2, 6.57e-2, 5.37e-3};
1777  slewingParamsHG[1][2] = {0, -5.37e-2, 3.49e-2, 3.8e-3};
1778  slewingParamsHG[1][3] = {0, -3.3e-2, 3.9e-2, 2.2e-3};
1779 
1780  slewingParamsLG[0][0] = {0, -9.6e-2, 4.39e-2, 2.93e-3 };
1781  slewingParamsLG[0][1] = {0, -5.0e-2, 14.9e-2, 20.6e-3 };
1782  slewingParamsLG[0][2] = {0, -4.4e-2, 5.3e-2, 0, };
1783  slewingParamsLG[0][3] = {0, -9.90e-2, 4.08e-2, 0, };
1784 
1785  slewingParamsLG[1][0] = {0, -8.7e-2, 4.2e-2, -3.2e-3 };
1786  slewingParamsLG[1][1] = {0, -3.26e-2, 3.84e-2, -2.32e-3};
1787  slewingParamsLG[1][2] = {0, -26.8e-2, -2.64e-2, -5.3e-3 };
1788  slewingParamsLG[1][3] = {0, -13.2e-2, 0.45e-2, -2.4e-3 };
1789 
1790 
1791  m_zdcDataAnalyzer_80MHz.reset (new ZDCDataAnalyzer(MakeMessageFunction(), 7 , 12.5, 0, "FermiExp", m_peak2ndDerivMinSamples,
1792  m_peak2ndDerivMinThresholdsHG, m_peak2ndDerivMinThresholdsLG, m_lowGainMode));
1793 
1794  m_zdcDataAnalyzer_80MHz->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1795  m_zdcDataAnalyzer_80MHz->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1796  m_zdcDataAnalyzer_80MHz->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1797  m_zdcDataAnalyzer_80MHz->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1798  slewingParamsHG, slewingParamsLG);
1799 
1800  std::array<std::array<std::vector<float>, 4>, 2> moduleHGNonLinCorr, moduleLGNonLinCorr;
1801  moduleHGNonLinCorr[0][0] = { -3.76800e-02, 4.63597e-02};
1802  moduleHGNonLinCorr[0][1] = { -1.02185e-01, -1.17548e-01};
1803  moduleHGNonLinCorr[0][2] = { -8.78451e-02, -1.52174e-01};
1804  moduleHGNonLinCorr[0][3] = { -1.04835e-01, -1.96514e-01};
1805  moduleHGNonLinCorr[1][0] = { -6.83115e-02, 3.57802e-02};
1806  moduleHGNonLinCorr[1][1] = { -1.08162e-01, -1.91413e-01};
1807  moduleHGNonLinCorr[1][2] = { -7.82514e-02, -1.21218e-01};
1808  moduleHGNonLinCorr[1][3] = { -2.34354e-02, -2.52033e-01};
1809 
1810  moduleLGNonLinCorr = {{ {{{0},
1811  {0},
1812  {0},
1813  {0}}},
1814  {{{0},
1815  {0},
1816  {0},
1817  {0}}} }};
1818 
1819  m_zdcDataAnalyzer_80MHz->SetNonlinCorrParams(500, 1000, moduleHGNonLinCorr, moduleLGNonLinCorr);
1820  m_zdcDataAnalyzer_80MHz->SetSaveFitFunc(false);
1821 }

◆ initializeDecorations()

void ZDC::ZdcAnalysisTool::initializeDecorations ( )

Definition at line 2001 of file ZdcAnalysisTool.cxx.

2002 {
2003 
2004 }

◆ initializeDefault()

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

Definition at line 1219 of file ZdcAnalysisTool.cxx.

1220 {
1221  // We rely completely on the default parameters specified in the job properties to control:
1222  // # samples
1223  // frequency (more precisely, time/sample)
1224  // which sample to use as the pre-sample
1225  // where to expact the maxim of the peak (min 2nd derivative)
1226  // thresholds on the 2nd derivative for valid pulses
1227  // whether to fix the tau values in the pulse fitting
1228  // the default tau values
1229  // the nominal T0
1230  // delta T and chisq/amp cuts
1231  //
1232  // For now, we continue to use hard-coded values for the maximum and minimum ADC values
1233  // For now we also use the FermiExp pulse model.
1234  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
1235  ZDCDataAnalyzer::ZDCModuleFloatArray tau1{}, tau2{}, t0{};
1236  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
1237  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
1238  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1239 
1240  for (size_t side : {0, 1}) {
1241  for (size_t module : {0, 1, 2, 3}) {
1242  fixTau1Arr[side][module] = m_fixTau1;
1243  fixTau2Arr[side][module] = m_fixTau2;
1244  tau1[side][module] = m_tau1;
1245  tau2[side][module] = m_tau2;
1246 
1247  peak2ndDerivMinSamples[side][module] = m_peakSample;
1248  peak2ndDerivMinThresholdsHG[side][module] = -m_Peak2ndDerivThresh;
1249  peak2ndDerivMinThresholdsLG[side][module] = -m_Peak2ndDerivThresh / 2;
1250 
1251  t0[side][module] = m_t0;
1252  deltaT0CutLow[side][module] = -m_deltaTCut;
1253  deltaT0CutHigh[side][module] = m_deltaTCut;
1254  chisqDivAmpCut[side][module] = m_ChisqRatioCut;
1255  }
1256  }
1257 
1258  ATH_MSG_DEBUG( "Default: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1259 
1260  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1261  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1262  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1263 
1264  // Construct the data analyzer
1265  //
1266  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), m_numSample, m_deltaTSample, m_presample, "FermiExp", peak2ndDerivMinSamples,
1267  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1268 
1269  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1270  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0, t0);
1271  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1272 
1273  if (m_combineDelay) {
1274  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
1275 
1276  zdcDataAnalyzer->enableDelayed(m_delayDeltaT, defaultPedestalShifts);
1277  }
1278 
1279  return zdcDataAnalyzer;
1280 }

◆ initializeInjectorPbPb2024()

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

Definition at line 928 of file ZdcAnalysisTool.cxx.

929 {
930  // Key configuration parameters needed for the data analyzer construction
931  //
932  m_deltaTSample = 3.125;
933  m_numSample = 24;
934 
935  const int deriv2ndThreshDSHG = -25;
936  const int deriv2ndThreshDSLG = -10;
937  const unsigned int peakSample = 10;
938 
939  const float deltaTcutLow = -10;
940  const float deltaTcutHigh = 10;
941  const float chisqDivAmpCutHGVal = 30;
942  const float chisqDivAmpCutLGVal = 50;
943 
944  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
945  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
946 
947  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
948  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
949  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
950 
951  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.2, 1.4, 1.3, 1.2},
952  {1.35, 1.4, 1.3, 1.1}}};
953 
954  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
955 
956  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
957  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{28, 28, 28, 28}, {28, 28, 28, 28}}};
958 
959  for (size_t side : {0, 1}) {
960  for (size_t module : {0, 1, 2, 3}) {
961  fixTau1Arr[side][module] = false;
962  fixTau2Arr[side][module] = true;
963 
964  peak2ndDerivMinSamples[side][module] = peakSample;
965  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
966  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
967 
968  deltaT0CutLow[side][module] = deltaTcutLow;
969  deltaT0CutHigh[side][module] = deltaTcutHigh;
970  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
971  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
972  }
973  }
974 
975  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
976 
977  // Construct the data analyzer
978  //
979  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
980  m_numSample, m_deltaTSample,
981  m_presample, "FermiExpLHCf",
982  peak2ndDerivMinSamples,
983  peak2ndDerivMinThresholdsHG,
984  peak2ndDerivMinThresholdsLG,
985  ZDCPulseAnalyzer::LGModeRefitLG));
986  zdcDataAnalyzer->set2ndDerivStep(2);
987  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
988 
989  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
990  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{10, 10, 10, 10}, {10, 10, 10, 10}}};
991 
992  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
993 
994  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
995  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
996  //
997  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
998  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{10.0, 10.0, 10.0, 10.0}, {10.0, 10.0, 10.0, 10.0}}};
999 
1000  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
1001 
1002  // Now set cuts and default fit parameters
1003  //
1004  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
1005  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
1006  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
1007 
1008  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1009  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1010  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1011 
1012  // Enable two-pass analysis
1013  //
1014  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-20, -20, -20, -20},
1015  {-20, -20, -20, -20},}};
1016 
1017  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
1018  {-8, -8, -8, -8}}};
1019 
1020  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
1021 
1022  // Turn on exclusion of early and late samples to address OOT pileup
1023  //
1024  zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
1025  zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
1026 
1027 
1028  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
1029  timeCorrCoefficHG[0][0] = {0.07, -0.020672, 0.070206, 0.004961, -0.010821, -0.001835};
1030  timeCorrCoefficHG[0][1] = {0.04, -0.012961, 0.008204, 0.010771, 0.011593, 0.002045};
1031  timeCorrCoefficHG[0][2] = {0.04, 0.017393, 0.017597, 0.003736, -0.001696, -0.000465};
1032  timeCorrCoefficHG[0][3] = {0.04, 0.018463, 0.009862, -0.000277, -0.000268, 0.000192};
1033 
1034  timeCorrCoefficHG[1][0] = {0.13, -0.106068, 0.078153, 0.034479, -0.004964, -0.001688};
1035  timeCorrCoefficHG[1][1] = {0.03, -0.007518, 0.008937, 0.015319, 0.012290, 0.001889};
1036  timeCorrCoefficHG[1][2] = {-0.01, 0.006711, -0.001652, -0.004223, -0.000573, 0.000161};
1037  timeCorrCoefficHG[1][3] = {0.015, 0.017993, 0.006339, 0.003122, 0.002980, 0.000735};
1038 
1039  // +++ BAC 07-26-24
1040  //
1041  // The +3.25 in the constant t0 correction term accounts for a change in the nominal T0 from 31.25 to 28
1042  // made at the same time to match the timing shift of the LG channels
1043  //
1044  // ---
1045  timeCorrCoefficLG[0][0] = {0.035+3.25, -0.126189, 0.022724, 0.039116, -0.098255};
1046  timeCorrCoefficLG[0][1] = {0.022+3.25, -0.165988, -0.014125, 0.057323, -0.205109};
1047  timeCorrCoefficLG[0][2] = {0.01+3.25, -0.136087, -0.007248, -0.014452, -0.060469};
1048  timeCorrCoefficLG[0][3] = {0.0+3.25, -0.131067, 0.025579, 0.059994, -0.065595};
1049 
1050  timeCorrCoefficLG[1][0] = {0.076+3.25, -0.300587, -0.041827, 0.641108, -0.594157};
1051  timeCorrCoefficLG[1][1] = {0.057+3.25, -0.223443, -0.125013, -0.176900, 0.348081};
1052  timeCorrCoefficLG[1][2] = {0.015+3.25, -0.141721, 0.023936, 0.099657, -0.188526};
1053  timeCorrCoefficLG[1][3] = {0.01+3.25, -0.152589, 0.016122, -0.086580, 0.563625};
1054 
1055  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
1056 
1057  // Set the amplitude fit range limits
1058  //
1059  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
1060 
1061  return zdcDataAnalyzer;
1062 }

◆ initializeInjectorpp2024()

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

Definition at line 792 of file ZdcAnalysisTool.cxx.

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

◆ initializeLHCf2022()

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

Definition at line 197 of file ZdcAnalysisTool.cxx.

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

◆ initializeMonteCarloPbPb2023()

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

Definition at line 1064 of file ZdcAnalysisTool.cxx.

1065 {
1066  // Key configuration parameters needed for the data analyzer construction
1067  //
1068  m_deltaTSample = 3.125;
1069  m_numSample = 24;
1070 
1071  const int deriv2ndThreshDSHG = -25;
1072  const int deriv2ndThreshDSLG = -10;
1073  const unsigned int peakSample = 10;
1074 
1075  const float deltaTcutLow = -10;
1076  const float deltaTcutHigh = 10;
1077  const float chisqDivAmpCutHGVal = 30;
1078  const float chisqDivAmpCutLGVal = 50;
1079 
1080  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples;
1081  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG;
1082 
1083  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow, deltaT0CutHigh;
1084  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG, chisqDivAmpCutLG;
1085  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr, fixTau2Arr;
1086 
1087  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.1, 1.1, 1.1, 1.1},
1088  {1.1, 1.1, 1.1, 1.1}}};
1089 
1090  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
1091 
1092  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
1093  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
1094 
1095  for (size_t side : {0, 1}) {
1096  for (size_t module : {0, 1, 2, 3}) {
1097  fixTau1Arr[side][module] = false;
1098  fixTau2Arr[side][module] = false;
1099 
1100  peak2ndDerivMinSamples[side][module] = peakSample;
1101  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
1102  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
1103 
1104  deltaT0CutLow[side][module] = deltaTcutLow;
1105  deltaT0CutHigh[side][module] = deltaTcutHigh;
1106  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
1107  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
1108  }
1109  }
1110 
1111  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
1112 
1113  // Construct the data analyzer
1114  //
1115  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
1116  m_numSample, m_deltaTSample,
1117  m_presample, "FermiExpLHCf",
1118  peak2ndDerivMinSamples,
1119  peak2ndDerivMinThresholdsHG,
1120  peak2ndDerivMinThresholdsLG,
1121  m_lowGainMode));
1122  zdcDataAnalyzer->set2ndDerivStep(2);
1123  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
1124 
1125  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1, 1, 1, 1},{1, 1, 1, 1}}};
1126  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{10.,10.,10.,10.},{10.,10.,10.,10.}}}; // apply constant factor of 10 to high gain data
1127 
1128  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
1129 
1130  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
1131  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
1132  //
1133  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
1134  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{1.5, 1.7, 3, 1.7}, {1.7, 1.6, 2.2, 1.8}}};
1135 
1136  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
1137 
1138  // Now set cuts and default fit parameters
1139  //
1140  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
1141  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
1142  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
1143 
1144  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1145  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1146  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
1147 
1148  // Enable two-pass analysis
1149  //
1150  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-10, -10, -10, -10},
1151  {-10, -10, -10, -10}}};
1152 
1153  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
1154  {-8, -8, -8, -8}}};
1155 
1156  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
1157 
1158  // Turn on exclusion of early and late samples to address OOT pileup
1159  //
1160  //zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
1161  //zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
1162 
1163  // Set up non-linear corrections for the ZDC
1164  //
1165  std::array<std::array<std::vector<float>, 4>, 2> nonLinearCorrCoefficHG, nonLinearCorrCoefficLG;
1166 
1167  nonLinearCorrCoefficHG = {{ {{{0},
1168  {0},
1169  {0},
1170  {0}}},
1171  {{{0},
1172  {0},
1173  {0},
1174  {0}}} }};
1175 
1176  // For now we don't use corrections on the LG as it's much harder to measure them
1177  //
1178  nonLinearCorrCoefficLG = {{ {{{0},
1179  {0},
1180  {0},
1181  {0}}},
1182  {{{0},
1183  {0},
1184  {0},
1185  {0}}} }};
1186 
1187  zdcDataAnalyzer->SetNonlinCorrParams(0, 1000, nonLinearCorrCoefficHG, nonLinearCorrCoefficLG);
1188 
1189  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
1190  timeCorrCoefficHG[0][0] = {};
1191  timeCorrCoefficHG[0][1] = {};
1192  timeCorrCoefficHG[0][2] = {};
1193  timeCorrCoefficHG[0][3] = {};
1194 
1195  timeCorrCoefficHG[1][0] = {};
1196  timeCorrCoefficHG[1][1] = {};
1197  timeCorrCoefficHG[1][2] = {};
1198  timeCorrCoefficHG[1][3] = {};
1199 
1200  timeCorrCoefficLG[0][0] = {};
1201  timeCorrCoefficLG[0][1] = {};
1202  timeCorrCoefficLG[0][2] = {};
1203  timeCorrCoefficLG[0][3] = {};
1204 
1205  timeCorrCoefficLG[1][0] = {};
1206  timeCorrCoefficLG[1][1] = {};
1207  timeCorrCoefficLG[1][2] = {};
1208  timeCorrCoefficLG[1][3] = {};
1209 
1210  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
1211 
1212  // Set the amplitude fit range limits
1213  //
1214  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
1215 
1216  return zdcDataAnalyzer;
1217 }

◆ initializePbPb2015G4()

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

Definition at line 1282 of file ZdcAnalysisTool.cxx.

1283 {
1284  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
1285  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
1286  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
1287  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
1288  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1289 
1290  const int peakSample = 4;
1291  const float peak2ndDerivThreshHG = -12;
1292  const float peak2ndDerivThreshLG = -10;
1293  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{4.000, 4.000, 4.000, 4.000},
1294  {4.000, 4.000, 4.000, 4.000}}};
1295  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{25.36, 25.05, 25.43, 25.60},
1296  {25.11, 25.08, 25.18, 25.48}}};
1297 
1298  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{57.31, 57.28, 57.30, 57.28},
1299  {57.28, 57.29, 57.31, 57.33}}};
1300  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{57.31, 57.28, 57.30, 57.28},
1301  {57.28, 57.29, 57.31, 57.33}}};
1302 
1303  // Delta T0 cut
1304  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{-10, -10, -10, -10}, {-10, -10, -10, -10}}};
1305  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{ 10, 10, 10, 10}, { 10, 10, 10, 10}}};
1306  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{-10, -10, -10, -10}, {-10, -10, -10, -10}}};
1307  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{ 10, 10, 10, 10}, { 10, 10, 10, 10}}};
1308 
1309  for (size_t side : {0, 1}) {
1310  for (size_t module : {0, 1, 2, 3}) {
1311  fixTau1Arr[side][module] = true;
1312  fixTau2Arr[side][module] = true;
1313 
1314  peak2ndDerivMinSamples[side][module] = peakSample;
1315  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
1316  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
1317 
1318  chisqDivAmpCut[side][module] = 15;
1319  }
1320  }
1321 
1322  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{ 800, 800, 800, 800}}, {{ 800, 800, 800, 800}}}};
1323  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{ 10, 10, 10, 10}}, {{ 10, 10, 10, 10}}}};
1324  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1325 
1326  m_deltaTSample = 12.5;
1327 
1328  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), 7, m_deltaTSample, 0, "FermiExp", peak2ndDerivMinSamples,
1329  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1330 
1331  // Open up tolerances on the position of the peak for now
1332  //
1333  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
1334 
1335  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1336  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
1337  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1338 
1339  zdcDataAnalyzer->SetFitTimeMax(85);
1340  zdcDataAnalyzer->SetSaveFitFunc(false);
1341 
1342  return zdcDataAnalyzer;
1343 }

◆ initializePbPb2018()

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

Definition at line 1457 of file ZdcAnalysisTool.cxx.

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

◆ initializePbPb2023()

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

Definition at line 464 of file ZdcAnalysisTool.cxx.

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

◆ initializePbPb2024()

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

Definition at line 628 of file ZdcAnalysisTool.cxx.

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

◆ initializepp2023()

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

Definition at line 286 of file ZdcAnalysisTool.cxx.

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

◆ initializepp2024()

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

Definition at line 375 of file ZdcAnalysisTool.cxx.

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

◆ initializepPb2016()

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

Definition at line 1345 of file ZdcAnalysisTool.cxx.

1346 {
1347  //
1348  // For now, we continue to use hard-coded values for the maximum and minimum ADC values
1349  // For now we also use the FermiExp pulse model.
1350 
1351  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
1352  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
1353  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
1354  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1355 
1356  // For now we allow the tau values to be controlled by the job properties until they are better determined
1357  //
1358  const int peakSample = 5;
1359  const float peak2ndDerivThreshHG = -12;
1360  const float peak2ndDerivThreshLG = -10;
1361  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{4.000, 3.380, 3.661, 3.679},
1362  {4.472, 4.656, 3.871, 4.061}
1363  }};
1364 
1365  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{22, 24.81, 24.48, 24.45},
1366  {24.17, 24.22, 25.46, 24.45}
1367  }};
1368 
1369  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{70.00, 72.74, 73.09, 72.25},
1370  {75.11, 74.94, 73.93, 74.45}
1371  }};
1372  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{70.00, 73.41, 74.27, 73.30},
1373  {76.28, 76.07, 74.98, 76.54}
1374  }};
1375 
1376  // Delta T0 cut
1377  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
1378  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
1379  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
1380  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
1381 
1382 
1383  for (size_t side : {0, 1}) {
1384  for (size_t module : {0, 1, 2, 3}) {
1385  fixTau1Arr[side][module] = true;
1386  fixTau2Arr[side][module] = true;
1387 
1388  peak2ndDerivMinSamples[side][module] = peakSample;
1389  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
1390  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
1391 
1392  chisqDivAmpCut[side][module] = 15;
1393  }
1394  }
1395 
1396  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1397  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1398  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
1399 
1400  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1401  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
1402  slewingParamsHG[0][0] = {0, 0, 0, 0};
1403  slewingParamsHG[0][1] = { -4.780244e-01, -7.150874e-02, 4.614585e-02, 8.015731e-04};
1404  slewingParamsHG[0][2] = { -5.253412e-01, -5.718167e-02, 5.243121e-02, 2.128398e-03};
1405  slewingParamsHG[0][3] = { -5.773952e-01, -5.687478e-02, 4.564267e-02, 1.462294e-03};
1406 
1407  slewingParamsHG[1][0] = { 7.105115e-01, -3.686143e-02, 7.727447e-02, 5.924152e-03};
1408  slewingParamsHG[1][1] = { 4.052120e-02, 4.450686e-03, 8.031615e-02, 4.038097e-03};
1409  slewingParamsHG[1][2] = { 3.389476e-02, -2.056782e-02, 4.805321e-02, -2.627999e-03};
1410  slewingParamsHG[1][3] = { 2.069765e-01, -2.890419e-02, 6.084375e-02, 3.742011e-03};
1411 
1412  slewingParamsLG[0][0] = {0, 0, 0, 0};
1413  slewingParamsLG[0][1] = { -1.632547e+00, -4.827813e-01, -1.379131e-01, -2.522607e-02};
1414  slewingParamsLG[0][2] = { -7.254288e+00, -5.454064e+00, -1.619126e+00, -1.739665e-01};
1415  slewingParamsLG[0][3] = { -1.548400e+01, -1.277708e+01, -3.729333e+00, -3.700458e-01};
1416 
1417  slewingParamsLG[1][0] = { 1.142767e-01, -3.608906e-02, 9.642735e-02, -3.097043e-03};
1418  slewingParamsLG[1][1] = { -5.615388e-01, -1.655047e-02, 8.327350e-02, -4.231348e-03};
1419  slewingParamsLG[1][2] = { -7.370728e-01, -2.887482e-02, 8.293875e-02, -4.482743e-03};
1420  slewingParamsLG[1][3] = { -1.270636e+00, -2.791777e-01, -5.807295e-02, -2.332612e-02};
1421 
1422  // Construct the data analyzer
1423  //
1424  // We adopt hard-coded values for the number of samples and the frequency which we kept fixed for all physics data
1425  //
1426  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), 7, 25, 0, "FermiExpLinear", peak2ndDerivMinSamples,
1427  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainMode));
1428 
1429  // Open up tolerances on the position of the peak for now
1430  //
1431  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
1432 
1433  // We alwyas disable the 12EM (sideC) module which was not present (LHCf)
1434  //
1435  zdcDataAnalyzer->disableModule(0, 0);
1436 
1437  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1438  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
1439  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1440 
1441  // We allow the combineDelay to be controlled by the properties
1442  //
1443  // if (m_combineDelay) {
1444  m_combineDelay = true;
1445  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
1446 
1447  zdcDataAnalyzer->enableDelayed(-12.5, defaultPedestalShifts);
1448  zdcDataAnalyzer->SetFitTimeMax(140); // This restrict the fit range of the pulse fitting
1449  zdcDataAnalyzer->SetSaveFitFunc(false);
1450  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1451  slewingParamsHG, slewingParamsLG); // add time slewing correction Sep 17 2019 Bill
1452  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
1453 
1454  return zdcDataAnalyzer;
1455 }

◆ initializeTriggerEffs()

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

Definition at line 84 of file ZdcAnalysisTool.cxx.

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

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

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

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

2443 {
2444  if (!m_init)
2445  {
2446  ATH_MSG_WARNING("Tool not initialized!");
2447  return StatusCode::FAILURE;
2448  }
2449  m_eventReady = false;
2450  ATH_MSG_DEBUG ("Trying to retrieve " << m_zdcModuleContainerName);
2451 
2452  m_zdcModules = 0;
2453  ATH_CHECK(evtStore()->retrieve(m_zdcModules, m_zdcModuleContainerName));
2454 
2455  m_zdcSums = 0;
2456  ATH_CHECK(evtStore()->retrieve(m_zdcSums, m_zdcSumContainerName));
2457 
2458  m_eventReady = true;
2459 
2460  ATH_CHECK(recoZdcModules(*m_zdcModules, *m_zdcSums));
2461 
2462  return StatusCode::SUCCESS;
2463 }

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

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

◆ setTimeCalibrations()

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

Definition at line 2367 of file ZdcAnalysisTool.cxx.

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

◆ sideFailed()

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

Definition at line 2543 of file ZdcAnalysisTool.cxx.

2544 {
2545  if (!m_zdcDataAnalyzer) return 0;
2546  return m_zdcDataAnalyzer->SideFailed(side);
2547 }

◆ sigprocMaxFinder()

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

Definition at line 2465 of file ZdcAnalysisTool.cxx.

2466 {
2467  size_t nsamp = adc.size();
2468  float presamp = adc.at(0);
2469  unsigned short max_adc = 0;
2470  int max_index = -1;
2471  for (size_t i = 0; i < nsamp; i++)
2472  {
2473  if (adc[i] > max_adc)
2474  {
2475  max_adc = adc[i];
2476  max_index = i;
2477  }
2478  }
2479  amp = max_adc - presamp;
2480  time = max_index * deltaT;
2481  qual = 1.;
2482 
2483  if (max_index == -1)
2484  {
2485  qual = 0.;
2486  return false;
2487  }
2488 
2489  return true;
2490 }

◆ sigprocSincInterp()

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

Definition at line 2492 of file ZdcAnalysisTool.cxx.

2493 {
2494  size_t nsamp = adc.size();
2495  float presamp = adc.at(0);
2496  m_tf1SincInterp->SetParameter(0, deltaT);
2497  for (size_t i = 0; i < nsamp; i++)
2498  {
2499  m_tf1SincInterp->SetParameter(i + 1, adc.at(i) - presamp);
2500  }
2501  amp = m_tf1SincInterp->GetMaximum();
2502  time = m_tf1SincInterp->GetMaximumX();
2503  qual = 1.;
2504  return true;
2505 }

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

◆ m_ChisqRatioCut

float ZDC::ZdcAnalysisTool::m_ChisqRatioCut
private

Definition at line 175 of file ZdcAnalysisTool.h.

◆ m_combineDelay

bool ZDC::ZdcAnalysisTool::m_combineDelay
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 169 of file ZdcAnalysisTool.h.

◆ m_deltaTCut

float ZDC::ZdcAnalysisTool::m_deltaTCut
private

Definition at line 174 of file ZdcAnalysisTool.h.

◆ m_deltaTSample

float ZDC::ZdcAnalysisTool::m_deltaTSample
private

Definition at line 164 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
private

Definition at line 155 of file ZdcAnalysisTool.h.

◆ m_doTimeCalib

bool ZDC::ZdcAnalysisTool::m_doTimeCalib

Definition at line 68 of file ZdcAnalysisTool.h.

◆ m_doTrigEff

bool ZDC::ZdcAnalysisTool::m_doTrigEff
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 172 of file ZdcAnalysisTool.h.

◆ m_fixTau2

bool ZDC::ZdcAnalysisTool::m_fixTau2
private

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

◆ m_forceCalibRun

int ZDC::ZdcAnalysisTool::m_forceCalibRun
private

Definition at line 157 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 177 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 163 of file ZdcAnalysisTool.h.

◆ m_peak2ndDerivMinSamples

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

Definition at line 185 of file ZdcAnalysisTool.h.

◆ m_peak2ndDerivMinThresholdsHG

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

Definition at line 186 of file ZdcAnalysisTool.h.

◆ m_peak2ndDerivMinThresholdsLG

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

Definition at line 187 of file ZdcAnalysisTool.h.

◆ m_Peak2ndDerivThresh

float ZDC::ZdcAnalysisTool::m_Peak2ndDerivThresh
private

Definition at line 167 of file ZdcAnalysisTool.h.

◆ m_peakSample

unsigned int ZDC::ZdcAnalysisTool::m_peakSample
private

Definition at line 166 of file ZdcAnalysisTool.h.

◆ m_presample

unsigned int ZDC::ZdcAnalysisTool::m_presample
private

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

◆ m_tau1

float ZDC::ZdcAnalysisTool::m_tau1
private

Definition at line 170 of file ZdcAnalysisTool.h.

◆ m_tau2

float ZDC::ZdcAnalysisTool::m_tau2
private

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

◆ m_zdcDataAnalyzer_40MHz

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

Definition at line 182 of file ZdcAnalysisTool.h.

◆ m_zdcDataAnalyzer_80MHz

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

Definition at line 183 of file ZdcAnalysisTool.h.

◆ m_zdcEnergyCalibFileName

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

Definition at line 130 of file ZdcAnalysisTool.h.

◆ m_zdcModuleAmpLGRefit

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcModuleAmpLGRefit {this, "ZdcModuleAmpLGRefit", "", "ZDC module fit amp LG refit"}
private

Definition at line 213 of file ZdcAnalysisTool.h.

◆ m_zdcModuleAmplitude

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

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

◆ m_zdcModuleCalibEnergy

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

Definition at line 197 of file ZdcAnalysisTool.h.

◆ m_zdcModuleCalibTime

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

Definition at line 198 of file ZdcAnalysisTool.h.

◆ m_zdcModuleChisq

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

Definition at line 201 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 216 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 202 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 203 of file ZdcAnalysisTool.h.

◆ m_zdcModuleFitT0

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

Definition at line 204 of file ZdcAnalysisTool.h.

◆ m_zdcModuleMaxADC

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

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

◆ m_zdcModulePresample

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

Definition at line 207 of file ZdcAnalysisTool.h.

◆ m_zdcModulePreSampleAmp

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

Definition at line 206 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 199 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 214 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 215 of file ZdcAnalysisTool.h.

◆ m_zdcModuleTime

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

Definition at line 200 of file ZdcAnalysisTool.h.

◆ m_zdcSumAverageTime

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

Definition at line 224 of file ZdcAnalysisTool.h.

◆ m_zdcSumCalibEnergy

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

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

◆ m_zdcSumModuleMask

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

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

◆ m_zdcSumUncalibSum

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

Definition at line 219 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 220 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 190 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 192 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::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:792
ZDCPulseAnalyzer::getRefitLGAmp
float getRefitLGAmp() const
Definition: ZDCPulseAnalyzer.h:582
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinSamples
ZDCDataAnalyzer::ZDCModuleIntArray m_peak2ndDerivMinSamples
Definition: ZdcAnalysisTool.h:185
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:167
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:201
ZDC::ZdcAnalysisTool::m_zdcModules
const xAOD::ZdcModuleContainer * m_zdcModules
Definition: ZdcAnalysisTool.h:149
ZDC::ZdcAnalysisTool::initializePbPb2024
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2024()
Definition: ZdcAnalysisTool.cxx:628
ZDC::ZdcAnalysisTool::m_zdcModuleCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibEnergy
Definition: ZdcAnalysisTool.h:197
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinThresholdsLG
ZDCDataAnalyzer::ZDCModuleFloatArray m_peak2ndDerivMinThresholdsLG
Definition: ZdcAnalysisTool.h:187
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:175
ZDC::ZdcAnalysisTool::m_LHCRun
int m_LHCRun
Definition: ZdcAnalysisTool.h:177
ZDCDataAnalyzer::ZDCModuleFloatArray
std::array< std::array< float, 4 >, 2 > ZDCModuleFloatArray
Definition: ZDCDataAnalyzer.h:22
ZDCPulseAnalyzer::GetAmpError
float GetAmpError() const
Definition: ZDCPulseAnalyzer.h:579
Data
@ Data
Definition: BaseObject.h:11
ZDC::ZdcAnalysisTool::m_fixTau1
bool m_fixTau1
Definition: ZdcAnalysisTool.h:172
ZDCPulseAnalyzer::getRefitLGTime
float getRefitLGTime() const
Definition: ZDCPulseAnalyzer.h:600
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:202
ZDC::ZdcAnalysisTool::getUncalibModuleSumErr
float getUncalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:2531
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:68
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::initializepp2024
std::unique_ptr< ZDCDataAnalyzer > initializepp2024()
Definition: ZdcAnalysisTool.cxx:375
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:165
ZDC::ZdcAnalysisTool::m_zdcSumModuleMask
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumModuleMask
Definition: ZdcAnalysisTool.h:226
ZDCPulseAnalyzer
Definition: ZDCPulseAnalyzer.h:24
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
ZDCPulseAnalyzer::GetPresample
float GetPresample() const
Definition: ZDCPulseAnalyzer.h:612
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ZDC::ZdcAnalysisTool::m_zdcModuleStatus
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleStatus
Definition: ZdcAnalysisTool.h:199
ZDC::ZdcAnalysisTool::m_zdcSumAverageTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumAverageTime
Definition: ZdcAnalysisTool.h:224
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
ZDCPulseAnalyzer::getRefitLGTimeSub
float getRefitLGTimeSub() const
Definition: ZDCPulseAnalyzer.h:606
ZDC::ZdcAnalysisTool::m_tf1SincInterp
std::unique_ptr< TF1 > m_tf1SincInterp
Definition: ZdcAnalysisTool.h:142
ZDC::ZdcAnalysisTool::m_tau1
float m_tau1
Definition: ZdcAnalysisTool.h:170
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
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
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:225
ZDC::ZdcAnalysisTool::m_zdcModuleAmplitude
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmplitude
Definition: ZdcAnalysisTool.h:196
ZDC::ZdcAnalysisTool::sideFailed
bool sideFailed(int side)
Definition: ZdcAnalysisTool.cxx:2543
ZDC::ZdcAnalysisTool::getModuleSum
float getModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:2507
ZDC::ZdcAnalysisTool::initializepp2023
std::unique_ptr< ZDCDataAnalyzer > initializepp2023()
Definition: ZdcAnalysisTool.cxx:286
ZDC::ZdcAnalysisTool::m_zdcSumFinalEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumFinalEnergy
Definition: ZdcAnalysisTool.h:223
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:2302
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:169
ZDC::ZdcAnalysisTool::m_init
bool m_init
Definition: ZdcAnalysisTool.h:127
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
ZDC::ZdcAnalysisTool::getCalibModuleSumErr
float getCalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:2519
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:219
ZDCDataAnalyzer::SetNoiseSigmas
void SetNoiseSigmas(const ZDCModuleFloatArray &noiseSigmasHG, const ZDCModuleFloatArray &noiseSigmasLG)
Definition: ZDCDataAnalyzer.cxx:244
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
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:928
ZDC::ZdcAnalysisTool::m_combineDelay
bool m_combineDelay
Definition: ZdcAnalysisTool.h:154
ZDC::ZdcAnalysisTool::m_numSample
unsigned int m_numSample
Definition: ZdcAnalysisTool.h:163
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ZDC::ZdcAnalysisTool::initializepPb2016
std::unique_ptr< ZDCDataAnalyzer > initializepPb2016()
Definition: ZdcAnalysisTool.cxx:1345
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ZDC::ZdcAnalysisTool::m_forceCalibLB
int m_forceCalibLB
Definition: ZdcAnalysisTool.h:158
ZDC::ZdcAnalysisTool::initializePbPb2023
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2023()
Definition: ZdcAnalysisTool.cxx:464
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:183
ZDC::ZdcAnalysisTool::m_zdcModuleChisqLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleChisqLGRefit
Definition: ZdcAnalysisTool.h:216
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:209
ZDCPulseAnalyzer::LGModeForceLG
@ LGModeForceLG
Definition: ZDCPulseAnalyzer.h:55
ZDC::ZdcAnalysisTool::m_zdcModuleFitT0
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitT0
Definition: ZdcAnalysisTool.h:204
ZDC::ZdcAnalysisTool::recoZdcModules
StatusCode recoZdcModules(const xAOD::ZdcModuleContainer &moduleContainer, const xAOD::ZdcModuleContainer &moduleSumContainer) override
Definition: ZdcAnalysisTool.cxx:2026
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:2549
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:215
ZDC::ZdcAnalysisTool::m_zdcModuleMinDeriv2nd
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMinDeriv2nd
Definition: ZdcAnalysisTool.h:208
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:205
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:181
ZDC::ZdcAnalysisTool::setTimeCalibrations
void setTimeCalibrations(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:2367
xAOD::EventInfo_v1::ForwardDet
@ ForwardDet
The forward detectors.
Definition: EventInfo_v1.h:338
ZDC::ZdcAnalysisTool::m_tau2
float m_tau2
Definition: ZdcAnalysisTool.h:171
ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergyErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergyErr
Definition: ZdcAnalysisTool.h:222
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:159
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:214
ZDC::ZdcAnalysisTool::m_zdcModuleAmpLGRefit
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmpLGRefit
Definition: ZdcAnalysisTool.h:213
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
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
ZDC::ZdcAnalysisTool::m_forceCalibRun
int m_forceCalibRun
Definition: ZdcAnalysisTool.h:157
ZDC::ZdcAnalysisTool::m_deltaTCut
float m_deltaTCut
Definition: ZdcAnalysisTool.h:174
ZDCTriggerEfficiency
Definition: ZDCTriggerEfficiency.h:16
ZDC::ZdcAnalysisTool::m_zdcModuleCalibTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibTime
Definition: ZdcAnalysisTool.h:198
ZDC::ZdcAnalysisTool::s_debugLevel
static std::atomic< int > s_debugLevel
Definition: ZdcAnalysisTool.h:192
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:562
ZDC::ZdcAnalysisTool::initializeLHCf2022
std::unique_ptr< ZDCDataAnalyzer > initializeLHCf2022()
Definition: ZdcAnalysisTool.cxx:197
ZDCPulseAnalyzer::getRefitLGChisq
float getRefitLGChisq() const
Definition: ZDCPulseAnalyzer.h:594
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
ZDCPulseAnalyzer::GetMinDeriv2nd
float GetMinDeriv2nd() const
Definition: ZDCPulseAnalyzer.h:627
ZDC::ZdcAnalysisTool::m_zdcTriggerEfficiency
std::shared_ptr< ZDCTriggerEfficiency > m_zdcTriggerEfficiency
Definition: ZdcAnalysisTool.h:190
ZDCPulseAnalyzer::GetFitT0
float GetFitT0() const
Definition: ZDCPulseAnalyzer.h:563
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
ZDC::ZdcAnalysisTool::m_zdcModuleFitAmpError
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmpError
Definition: ZdcAnalysisTool.h:203
ZDC::ZdcAnalysisTool::getAverageTime
float getAverageTime(int side)
Definition: ZdcAnalysisTool.cxx:2537
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ZDC::ZdcAnalysisTool::m_zdcModulePresample
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePresample
Definition: ZdcAnalysisTool.h:207
ZDCPulseAnalyzer::GetBkgdMaxFraction
float GetBkgdMaxFraction() const
Definition: ZDCPulseAnalyzer.h:633
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ZDC::ZdcAnalysisTool::initializeTriggerEffs
void initializeTriggerEffs(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:84
ZDC::ZdcAnalysisTool::m_zdcModuleTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleTime
Definition: ZdcAnalysisTool.h:200
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
ZDC::ZdcAnalysisTool::configureNewRun
StatusCode configureNewRun(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:2006
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:186
ZDC::ZdcAnalysisTool::initializeDefault
std::unique_ptr< ZDCDataAnalyzer > initializeDefault()
Definition: ZdcAnalysisTool.cxx:1219
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:182
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:164
ZDCPulseAnalyzer::LGModeRefitLG
@ LGModeRefitLG
Definition: ZDCPulseAnalyzer.h:56
ZDCPulseAnalyzer::GetMaxADC
float GetMaxADC() const
Definition: ZDCPulseAnalyzer.h:613
ZDC::ZdcAnalysisTool::initializeMonteCarloPbPb2023
std::unique_ptr< ZDCDataAnalyzer > initializeMonteCarloPbPb2023()
Definition: ZdcAnalysisTool.cxx:1064
ZDC::ZdcAnalysisTool::m_zdcSumUncalibSumErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumUncalibSumErr
Definition: ZdcAnalysisTool.h:220
ZDC::ZdcAnalysisTool::m_zdcTimeCalibFileName
std::string m_zdcTimeCalibFileName
Definition: ZdcAnalysisTool.h:131
ZDC::ZdcAnalysisTool::m_peakSample
unsigned int m_peakSample
Definition: ZdcAnalysisTool.h:166
beamspotman.qual
qual
Definition: beamspotman.py:481
ZDC::ZdcAnalysisTool::getCalibModuleSum
float getCalibModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:2513
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:1704
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:1457
ZDC::ZdcAnalysisTool::m_flipEMDelay
bool m_flipEMDelay
Definition: ZdcAnalysisTool.h:152
ZDC::ZdcAnalysisTool::m_zdcModulePreSampleAmp
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePreSampleAmp
Definition: ZdcAnalysisTool.h:206
ZDCDataAnalyzer::SetPeak2ndDerivMinTolerances
void SetPeak2ndDerivMinTolerances(size_t tolerance)
Definition: ZDCDataAnalyzer.cxx:209
ZDCPulseAnalyzer::GetChisq
float GetChisq() const
Definition: ZDCPulseAnalyzer.h:567
ZDC::ZdcAnalysisTool::initializePbPb2015G4
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2015G4()
Definition: ZdcAnalysisTool.cxx:1282
ZDC::ZdcAnalysisTool::m_zdcEnergyCalibFileName
std::string m_zdcEnergyCalibFileName
Definition: ZdcAnalysisTool.h:130
ZDC::ZdcAnalysisTool::m_t0
float m_t0
Definition: ZdcAnalysisTool.h:168
python.DataFormatRates.env
env
Definition: DataFormatRates.py:32
SG::DataProxy
Definition: DataProxy.h:44
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:1584
ZDC::ZdcAnalysisTool::m_fixTau2
bool m_fixTau2
Definition: ZdcAnalysisTool.h:173
ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergy
Definition: ZdcAnalysisTool.h:221
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
ZDCPulseAnalyzer::GetPreSampleAmp
float GetPreSampleAmp() const
Definition: ZDCPulseAnalyzer.h:632
ZDCDataAnalyzer::SetModuleAmpFractionLG
void SetModuleAmpFractionLG(const ZDCDataAnalyzer::ZDCModuleFloatArray &moduleAmpFractionLG)
Definition: ZDCDataAnalyzer.cxx:253
ZDC::ZdcAnalysisTool::getUncalibModuleSum
float getUncalibModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:2525
Generated on Thu Nov 7 2024 22:33:04 for ATLAS Offline Software by   doxygen 1.8.18