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 ()
 
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
 
bool m_lowGainOnly
 
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
 
unsigned int m_rpdNbaselineSamples
 
unsigned int m_rpdEndSignalSample
 
float m_rpdPulse2ndDerivThresh
 
float m_rpdPostPulseFracThresh
 
unsigned int m_rpdGoodPulseSampleStart
 
unsigned int m_rpdGoodPulseSampleStop
 
unsigned int m_rpdNominalBaseline
 
float m_rpdPileupBaselineSumThresh
 
float m_rpdPileupBaselineStdDevThresh
 
unsigned int m_rpdNNegativesAllowed
 
unsigned int m_rpdAdcOverflow
 
std::vector< float > m_rpdSideCOutputCalibFactors
 
std::vector< float > m_rpdSideAOutputCalibFactors
 
int m_LHCRun
 
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer
 
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer_40MHz
 
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer_80MHz
 
std::vector< std::unique_ptr< RPDDataAnalyzer > > m_rpdDataAnalyzer
 
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_rpdChannelBaseline {this, "RPDChannelBaseline", "", "RPD channel baseline"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupExpFitParams {this, "RPDChannelPileupExpFitParams", "", "RPD channel pileup exponential fit parameters: exp( [0] + [1]*sample )"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupStretchedExpFitParams {this, "RPDChannelPileupStretchedExpFitParams", "", "RPD channel pileup stretched exponential fit parameters: exp( [0] + [1]*(sample + 4)**0.5 + [2]*(sample + 4)**-0.5 )"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupExpFitParamErrs {this, "RPDChannelPileupExpFitParamErrs", "", "RPD channel pileup exponential fit parameter errors"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupStretchedExpFitParamErrs {this, "RPDChannelPileupStretchedExpFitParamErrs", "", "RPD channel pileup stretched exponential fit parameter errors"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupExpFitMSE {this, "RPDChannelPileupExpFitMSE", "", "RPD Channel pileup exponential fit mean squared error in baseline samples"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupStretchedExpFitMSE {this, "RPDChannelPileupStretchedExpFitMSE", "", "RPD channel pileup stretched exponential fit mean squared error in baseline samples"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelAmplitude {this, "RPDChannelAmplitude", "", "RPD channel sum ADC (baseline and pileup subtracted)"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelAmplitudeCalib {this, "RPDChannelAmplitudeCalib", "", "RPD channel sum ADC (baseline and pileup subtracted) with output calibration factors applied"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelMaxADC {this, "RPDChannelMaxADC", "", "RPD channel max ADC (baseline and pileup subtracted)"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelMaxADCCalib {this, "RPDChannelMaxADCCalib", "", "RPD channel max ADC (baseline and pileup subtracted) with output calibration factors applied"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelMaxSample {this, "RPDChannelMaxSample", "", "RPD channel max sample"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelStatus {this, "RPDChannelStatus", "", "RPD channel status"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupFrac {this, "RPDChannelPileupFrac", "", "RPD channel pileup as fraction of total (nominal baseline-subtracted) sum ADC"}
 
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"}
 
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumRPDStatus {this, "ZdcSumRPDStatus", "", "RPD side level status"}
 
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 33 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 23 of file ZdcAnalysisTool.cxx.

24  : asg::AsgTool(name), m_name(name), m_init(false),
25  m_writeAux(false), m_eventReady(false),
26  m_runNumber(0), m_lumiBlock(0),
27  m_zdcTriggerEfficiency(0)
28 {
29 
30 #ifndef XAOD_STANDALONE
31  declareInterface<IZdcAnalysisTool>(this);
32 #endif
33 
34  declareProperty("ZdcModuleContainerName", m_zdcModuleContainerName = "ZdcModules", "Location of ZDC processed data");
35  declareProperty("ZdcSumContainerName", m_zdcSumContainerName = "ZdcSums", "Location of ZDC processed sums");
36  declareProperty("Configuration", m_configuration = "PbPb2015");
37  declareProperty("FlipEMDelay", m_flipEMDelay = false);
38  declareProperty("LowGainOnly", m_lowGainOnly = false);
39  declareProperty("WriteAux", m_writeAux = true);
40  declareProperty("AuxSuffix", m_auxSuffix = "");
41 
42  // The following job properties enable/disable and affect the calibration of the ZDC energies
43  //
44  declareProperty("DoCalib", m_doCalib = true);
45  declareProperty("CalibVersion", m_calibVersion = "");
46  declareProperty("DoTrigEff", m_doTrigEff = true);
47  declareProperty("DoTimeCalib", m_doTimeCalib = true);
48  declareProperty("ZdcAnalysisConfigPath", m_zdcAnalysisConfigPath = "$ROOTCOREBIN/data/ZdcAnalysis", "ZDC Analysis config file path");
49  //declareProperty("ForceCalibRun",m_forceCalibRun=287931); // last run of Pb+Pb 2015
50  declareProperty("ForceCalibRun", m_forceCalibRun = -1); // last run of Pb+Pb 2015
51  declareProperty("ForceCalibLB", m_forceCalibLB = 814); // last LB of Pb+Pb 2015
52 
53  // The following parameters are primarily used for the "default" configuration, but also may be
54  // use to modify/tailor other configurations
55  //
56  declareProperty("NumSampl", m_numSample = 7);
57  declareProperty("DeltaTSample", m_deltaTSample = 25);
58  declareProperty("Presample", m_presample = 0);
59  declareProperty("CombineDelay", m_combineDelay = false);
60  declareProperty("DelayDeltaT", m_delayDeltaT = -12.5);
61 
62  declareProperty("PeakSample", m_peakSample = 11);
63  declareProperty("Peak2ndDerivThresh", m_Peak2ndDerivThresh = 20);
64 
65  declareProperty("T0", m_t0 = 30);
66  declareProperty("Tau1", m_tau1 = 5);
67  declareProperty("Tau2", m_tau2 = 25);
68  declareProperty("FixTau1", m_fixTau1 = false);
69  declareProperty("FixTau2", m_fixTau2 = false);
70 
71  declareProperty("DeltaTCut", m_deltaTCut = 10);
72  declareProperty("ChisqRatioCut", m_ChisqRatioCut = 10);
73 
74  declareProperty("RpdNbaselineSamples", m_rpdNbaselineSamples = 7, "Number of baseline samples; the sample equal to this number is the start of signal region");
75  declareProperty("RpdEndSignalSample", m_rpdEndSignalSample = 23, "Samples before (not including) this sample are the signal region; 0 or Nsamples goes to end of window");
76  declareProperty("RpdPulse2ndDerivThresh", m_rpdPulse2ndDerivThresh = -18, "Second differences less than or equal to this number indicate a pulse");
77  declareProperty("RpdPostPulseFracThresh", m_rpdPostPulseFracThresh = 0.15, "If there is a good pulse and post-pulse and size of post-pulse as a fraction of good pulse is less than or equal to this number, ignore post-pulse");
78  declareProperty("RpdGoodPulseSampleStart", m_rpdGoodPulseSampleStart = 8, "Pulses before this sample are considered pre-pulses");
79  declareProperty("RpdGoodPulseSampleStop", m_rpdGoodPulseSampleStop = 10, "Pulses after this sample are considered post-pulses");
80  declareProperty("RpdNominalBaseline", m_rpdNominalBaseline = 100, "The global nominal baseline; used when pileup is detected");
81  declareProperty("RpdPileupBaselineSumThresh", m_rpdPileupBaselineSumThresh = 53, "Baseline sum (after subtracting nominal baseline) less than this number indicates there is NO pileup");
82  declareProperty("RpdPileupBaselineStdDevThresh", m_rpdPileupBaselineStdDevThresh = 2, "Baseline standard deviations less than this number indicate there is NO pileup");
83  declareProperty("RpdNNegativesAllowed", m_rpdNNegativesAllowed = 2, "Maximum number of negative ADC values after baseline and pileup subtraction allowed in signal range");
84  declareProperty("RpdAdcOverflow", m_rpdAdcOverflow = 4095, "ADC values greater than or equal to this number are considered overflow");
85  declareProperty("RpdSideCCalibFactors", m_rpdSideCOutputCalibFactors = std::vector<float>(16, 1.0), "Multiplicative calibration factors to apply to RPD output, e.g., sum/max ADC, per channel on side C");
86  declareProperty("RpdSideACalibFactors", m_rpdSideAOutputCalibFactors = std::vector<float>(16, 1.0), "Multiplicative calibration factors to apply to RPD output, e.g., sum/max ADC, per channel on side A");
87 
88  declareProperty("LHCRun", m_LHCRun = 3);
89 
90 }

◆ ~ZdcAnalysisTool()

ZDC::ZdcAnalysisTool::~ZdcAnalysisTool ( )
overridevirtual

Definition at line 92 of file ZdcAnalysisTool.cxx.

93 {
94  ATH_MSG_DEBUG("Deleting ZdcAnalysisTool named " << m_name);
95 }

Member Function Documentation

◆ configureNewRun()

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

Definition at line 1387 of file ZdcAnalysisTool.cxx.

1388 {
1389  ATH_MSG_DEBUG("Setting up new run " << runNumber);
1390 
1391  // We do nothing for the default configuration
1392  //
1393  if (m_configuration != "default") {
1394  if (m_configuration == "PbPb2015") {
1395  //
1396  // Two periods, 40 MHz and 80 MHz readout
1397  //
1398  if (runNumber < 287222) m_zdcDataAnalyzer = m_zdcDataAnalyzer_40MHz;
1399  else m_zdcDataAnalyzer = m_zdcDataAnalyzer_80MHz;
1400  }
1401  }
1402 
1403  return StatusCode::SUCCESS;
1404 }

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

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

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

1973 {
1974  if (!m_zdcDataAnalyzer) return 0;
1975  return m_zdcDataAnalyzer->GetAverageTime(side);
1976 }

◆ getCalibModuleSum()

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

Definition at line 1948 of file ZdcAnalysisTool.cxx.

1949 {
1950  if (!m_zdcDataAnalyzer) return 0;
1951  return m_zdcDataAnalyzer->GetCalibModuleSum(side);
1952 }

◆ getCalibModuleSumErr()

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

Definition at line 1954 of file ZdcAnalysisTool.cxx.

1955 {
1956  if (!m_zdcDataAnalyzer) return 0;
1957  return m_zdcDataAnalyzer->GetCalibModuleSumErr(side);
1958 }

◆ getDataAnalyzer()

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

Definition at line 75 of file ZdcAnalysisTool.h.

75 {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 1984 of file ZdcAnalysisTool.cxx.

1985 {
1986  if (!m_zdcDataAnalyzer) return 0;
1987  return m_zdcDataAnalyzer->GetModuleMask();
1988 }

◆ getModuleSum()

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

Definition at line 1942 of file ZdcAnalysisTool.cxx.

1943 {
1944  if (!m_zdcDataAnalyzer) return 0;
1945  return m_zdcDataAnalyzer->GetModuleSum(side);
1946 }

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

1991 {
1992  if (!m_doTrigEff) return -1;
1993 
1994  m_zdcTriggerEfficiency->UpdatelumiBlock(m_lumiBlock);
1995  float adcSum = getModuleSum(side);
1996  double eff = m_zdcTriggerEfficiency->GetEfficiency(side, adcSum);
1997  return eff;
1998 }

◆ getTriggerEfficiencyUncertainty()

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

Definition at line 2000 of file ZdcAnalysisTool.cxx.

2001 {
2002  if (!m_doCalib) return -1;
2003 
2004  m_zdcTriggerEfficiency->UpdatelumiBlock(m_lumiBlock);
2005  float adcSum = getModuleSum(side);
2006  std::pair<double, double> eff_pair = m_zdcTriggerEfficiency->GetEfficiencyAndError(msg(), side, adcSum);
2007  return eff_pair.second;
2008 }

◆ getUncalibModuleSum()

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

Definition at line 1960 of file ZdcAnalysisTool.cxx.

1961 {
1962  if (!m_zdcDataAnalyzer) return 0;
1963  return m_zdcDataAnalyzer->GetModuleSum(side);
1964 }

◆ getUncalibModuleSumErr()

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

Definition at line 1966 of file ZdcAnalysisTool.cxx.

1967 {
1968  if (!m_zdcDataAnalyzer) return 0;
1969  return m_zdcDataAnalyzer->GetModuleSumErr(side);
1970 }

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

1203 {
1204  m_tf1SincInterp.reset (new TF1("SincInterp", ZDC::SincInterp, -5., 160., 8));
1205  m_tf1SincInterp->SetNpx(300);
1206 
1207  // Set up calibrations
1208  //
1209  std::string filename = PathResolverFindCalibFile( "ZdcAnalysis/ZdcAnalysisConfig.conf" );
1210  TEnv env(filename.c_str());
1211 
1212  m_zdcEnergyCalibFileName = std::string(env.GetValue("ZdcEnergyCalibFileName", "ZdcCalibrations_v1.root"));
1213  ATH_MSG_INFO("ZDC energy calibration filename " << m_zdcEnergyCalibFileName);
1214  m_zdcTimeCalibFileName = std::string(env.GetValue("ZdcTimeCalibFileName", "ZdcTimeCalibrations_v1.root"));
1215  ATH_MSG_INFO("ZDC time calibration filename " << m_zdcTimeCalibFileName);
1216  m_zdcTriggerEffParamsFileName = std::string(env.GetValue("ZdcTriggerEffFileName", "ZdcTriggerEffParameters_v6.root"));
1217  ATH_MSG_INFO("ZDC trigger efficiencies filename " << m_zdcTriggerEffParamsFileName);
1218 
1219 
1220  if (m_forceCalibRun > -1) {
1221  ATH_MSG_DEBUG("CAREFUL: forcing calibration run/LB =" << m_forceCalibRun << "/" << m_forceCalibLB);
1222 
1223  if (m_forceCalibLB < 0) {
1224  ATH_MSG_ERROR("Invalid settings: Forced run > 0 but lumi block < 0");
1225  return StatusCode::FAILURE;
1226  }
1227  }
1228 
1229  // Use configuration to direct initialization
1230  //
1231  if (m_configuration == "default") {
1232  m_zdcDataAnalyzer = initializeDefault();
1233  }
1234  else if (m_configuration == "PbPb2015") {
1235  initialize80MHz();
1236  initialize40MHz();
1237 
1238  m_zdcDataAnalyzer = m_zdcDataAnalyzer_80MHz; // default
1239  }
1240  else if (m_configuration == "pPb2016") {
1241  m_zdcDataAnalyzer = initializepPb2016();
1242  }
1243  else if (m_configuration == "PbPb2018") {
1244  m_zdcDataAnalyzer = initializePbPb2018();
1245  }
1246  else if (m_configuration == "PbPb2015G4") {
1247  m_zdcDataAnalyzer = initializePbPb2015G4();
1248  }
1249  else if (m_configuration == "LHCf2022") {
1250  m_zdcDataAnalyzer = initializeLHCf2022();
1251  }
1252  else if (m_configuration == "pp2023") {
1253  m_zdcDataAnalyzer = initializepp2023();
1254  }
1255  else if (m_configuration == "PbPb2023") {
1256  m_zdcDataAnalyzer = initializePbPb2023();
1257  }
1258  else {
1259  ATH_MSG_ERROR("Unknown configuration: " << m_configuration);
1260  return StatusCode::FAILURE;
1261  }
1262 
1263  // If an aux suffix is provided, prepend it with "_" so we don't have to do so at each use
1264  //
1265 
1266  ATH_MSG_INFO("Configuration: " << m_configuration);
1267  ATH_MSG_DEBUG("FlipEMDelay: " << m_flipEMDelay);
1268  ATH_MSG_DEBUG("LowGainOnly: " << m_lowGainOnly);
1269 
1270  ATH_MSG_DEBUG("Using Combined delayed and undelayed samples: " << m_combineDelay);
1271 
1272  ATH_MSG_DEBUG("WriteAux: " << m_writeAux);
1273  ATH_MSG_DEBUG("AuxSuffix: " << m_auxSuffix);
1274  ATH_MSG_DEBUG("DoCalib: " << m_doCalib);
1275  ATH_MSG_DEBUG("ForceCalibRun: " << m_forceCalibRun);
1276  ATH_MSG_DEBUG("ForceCalibLB: " << m_forceCalibLB);
1277  ATH_MSG_DEBUG("NumSampl: " << m_numSample);
1278  ATH_MSG_DEBUG("DeltaTSample: " << m_deltaTSample);
1279  ATH_MSG_DEBUG("Presample: " << m_presample);
1280  ATH_MSG_DEBUG("PeakSample: " << m_peakSample);
1281  ATH_MSG_DEBUG("Peak2ndDerivThresh: " << m_Peak2ndDerivThresh);
1282 
1283  if (m_combineDelay) ATH_MSG_DEBUG("DelayDeltaT: " << m_delayDeltaT);
1284 
1285  ATH_MSG_DEBUG("T0: " << m_t0);
1286  ATH_MSG_DEBUG("Tau1: " << m_tau1);
1287  ATH_MSG_DEBUG("Tau2: " << m_tau2);
1288  ATH_MSG_DEBUG("FixTau1: " << m_fixTau1);
1289  ATH_MSG_DEBUG("FixTau2: " << m_fixTau2);
1290  ATH_MSG_DEBUG("DeltaTCut: " << m_deltaTCut);
1291  ATH_MSG_DEBUG("ChisqRatioCut: " << m_ChisqRatioCut);
1292 
1293  ATH_CHECK( m_eventInfoKey.initialize());
1294 
1295  // Initialize decorations
1296 
1297  m_zdcModuleAmplitude = m_zdcModuleContainerName+".Amplitude"+m_auxSuffix;
1298  ATH_CHECK( m_zdcModuleAmplitude.initialize());
1299  m_zdcModuleCalibEnergy = m_zdcModuleContainerName+".CalibEnergy"+m_auxSuffix;
1300  ATH_CHECK( m_zdcModuleCalibEnergy.initialize());
1301  m_zdcModuleCalibTime = m_zdcModuleContainerName+".CalibTime"+m_auxSuffix;
1302  ATH_CHECK( m_zdcModuleCalibTime.initialize());
1303  m_zdcModuleStatus = m_zdcModuleContainerName+".Status"+m_auxSuffix;
1304  ATH_CHECK( m_zdcModuleStatus.initialize());
1305  m_zdcModuleTime = m_zdcModuleContainerName+".Time"+m_auxSuffix;
1306  ATH_CHECK( m_zdcModuleTime.initialize());
1307  m_zdcModuleChisq = m_zdcModuleContainerName+".Chisq"+m_auxSuffix;
1308  ATH_CHECK( m_zdcModuleChisq.initialize());
1309  m_zdcModuleFitAmp = m_zdcModuleContainerName+".FitAmp"+m_auxSuffix;
1310  ATH_CHECK( m_zdcModuleFitAmp.initialize());
1311  m_zdcModuleFitAmpError = m_zdcModuleContainerName+".FitAmpError"+m_auxSuffix;
1312  ATH_CHECK( m_zdcModuleFitAmpError.initialize());
1313  m_zdcModuleFitT0 = m_zdcModuleContainerName+".FitT0"+m_auxSuffix;
1314  ATH_CHECK( m_zdcModuleFitT0.initialize());
1315  m_zdcModuleBkgdMaxFraction = m_zdcModuleContainerName+".BkgdMaxFraction"+m_auxSuffix;
1316  ATH_CHECK( m_zdcModuleBkgdMaxFraction.initialize());
1317  m_zdcModulePreSampleAmp = m_zdcModuleContainerName+".PreSampleAmp"+m_auxSuffix;
1318  ATH_CHECK( m_zdcModulePreSampleAmp.initialize());
1319  m_zdcModulePresample = m_zdcModuleContainerName+".Presample"+m_auxSuffix;
1320  ATH_CHECK( m_zdcModulePresample.initialize());
1321  m_zdcModuleMinDeriv2nd = m_zdcModuleContainerName+".MinDeriv2nd"+m_auxSuffix;
1322  ATH_CHECK( m_zdcModuleMinDeriv2nd.initialize());
1323  m_zdcModuleMaxADC = m_zdcModuleContainerName+".MaxADC"+m_auxSuffix;
1324  ATH_CHECK( m_zdcModuleMaxADC.initialize());
1325  m_rpdChannelBaseline = m_zdcModuleContainerName+".RPDChannelBaseline"+m_auxSuffix;
1326  ATH_CHECK( m_rpdChannelBaseline.initialize());
1327  m_rpdChannelPileupExpFitParams = m_zdcModuleContainerName+".RPDChannelPileupExpFitParams"+m_auxSuffix;
1328  ATH_CHECK( m_rpdChannelPileupExpFitParams.initialize());
1329  m_rpdChannelPileupStretchedExpFitParams = m_zdcModuleContainerName+".RPDChannelPileupStretchedExpFitParams"+m_auxSuffix;
1330  ATH_CHECK( m_rpdChannelPileupStretchedExpFitParams.initialize());
1331  m_rpdChannelPileupExpFitParamErrs = m_zdcModuleContainerName+".RPDChannelPileupExpFitParamErrs"+m_auxSuffix;
1332  ATH_CHECK( m_rpdChannelPileupExpFitParamErrs.initialize());
1333  m_rpdChannelPileupStretchedExpFitParamErrs = m_zdcModuleContainerName+".RPDChannelPileupStretchedExpFitParamErrs"+m_auxSuffix;
1334  ATH_CHECK( m_rpdChannelPileupStretchedExpFitParamErrs.initialize());
1335  m_rpdChannelPileupExpFitMSE = m_zdcModuleContainerName+".RPDChannelPileupExpFitMSE"+m_auxSuffix;
1336  ATH_CHECK( m_rpdChannelPileupExpFitMSE.initialize());
1337  m_rpdChannelPileupStretchedExpFitMSE = m_zdcModuleContainerName+".RPDChannelPileupStretchedExpFitMSE"+m_auxSuffix;
1338  ATH_CHECK( m_rpdChannelPileupStretchedExpFitMSE.initialize());
1339  m_rpdChannelAmplitude = m_zdcModuleContainerName+".RPDChannelAmplitude"+m_auxSuffix;
1340  ATH_CHECK( m_rpdChannelAmplitude.initialize());
1341  m_rpdChannelAmplitudeCalib = m_zdcModuleContainerName+".RPDChannelAmplitudeCalib"+m_auxSuffix;
1342  ATH_CHECK( m_rpdChannelAmplitudeCalib.initialize());
1343  m_rpdChannelMaxADC = m_zdcModuleContainerName+".RPDChannelMaxADC"+m_auxSuffix;
1344  ATH_CHECK( m_rpdChannelMaxADC.initialize());
1345  m_rpdChannelMaxADCCalib = m_zdcModuleContainerName+".RPDChannelMaxADCCalib"+m_auxSuffix;
1346  ATH_CHECK( m_rpdChannelMaxADCCalib.initialize());
1347  m_rpdChannelMaxSample = m_zdcModuleContainerName+".RPDChannelMaxSample"+m_auxSuffix;
1348  ATH_CHECK( m_rpdChannelMaxSample.initialize());
1349  m_rpdChannelStatus = m_zdcModuleContainerName+".RPDChannelStatus"+m_auxSuffix;
1350  ATH_CHECK( m_rpdChannelStatus.initialize());
1351  m_rpdChannelPileupFrac = m_zdcModuleContainerName+".RPDChannelPileupFrac"+m_auxSuffix;
1352  ATH_CHECK( m_rpdChannelPileupFrac.initialize());
1353 
1354  m_zdcSumUncalibSum = m_zdcSumContainerName+".UncalibSum"+m_auxSuffix;
1355  ATH_CHECK( m_zdcSumUncalibSum.initialize());
1356  m_zdcSumCalibEnergy = m_zdcSumContainerName+".CalibEnergy"+m_auxSuffix;
1357  ATH_CHECK( m_zdcSumCalibEnergy.initialize());
1358  m_zdcSumCalibEnergyErr = m_zdcSumContainerName+".CalibEnergyErr"+m_auxSuffix;
1359  ATH_CHECK( m_zdcSumCalibEnergyErr.initialize());
1360  m_zdcSumUncalibSumErr = m_zdcSumContainerName+".UncalibSumErr"+m_auxSuffix;
1361  ATH_CHECK( m_zdcSumUncalibSumErr.initialize());
1362  m_zdcSumFinalEnergy = m_zdcSumContainerName+".FinalEnergy"+m_auxSuffix;
1363  ATH_CHECK( m_zdcSumFinalEnergy.initialize());
1364  m_zdcSumAverageTime = m_zdcSumContainerName+".AverageTime"+m_auxSuffix;
1365  ATH_CHECK( m_zdcSumAverageTime.initialize());
1366  m_zdcSumStatus = m_zdcSumContainerName+".Status"+m_auxSuffix;
1367  ATH_CHECK( m_zdcSumStatus.initialize());
1368  m_zdcSumModuleMask = m_zdcSumContainerName+".ModuleMask"+m_auxSuffix;
1369  ATH_CHECK( m_zdcSumModuleMask.initialize());
1370  m_zdcSumRPDStatus = m_zdcSumContainerName+".RPDStatus"+m_auxSuffix;
1371  ATH_CHECK( m_zdcSumRPDStatus.initialize());
1372 
1373  if (m_writeAux && m_auxSuffix != "") {
1374  ATH_MSG_DEBUG("suffix string = " << m_auxSuffix);
1375  }
1376 
1377  m_init = true;
1378 
1379  return StatusCode::SUCCESS;
1380 }

◆ initialize40MHz()

void ZDC::ZdcAnalysisTool::initialize40MHz ( )

Definition at line 963 of file ZdcAnalysisTool.cxx.

964 {
965  // We have a complete configuration and so we override all of the default parameters
966  //
967 
968  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{{4.2, 3.8, 5.2, 5.0}},
969  {{5.0, 3.7, 3.5, 3.5}}
970  }
971  };
972 
973  // identical to 80 MHz -- is this right
974  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{{20.0, 20.4, 18.9, 20.8}},
975  {{19.1, 21.9, 22.6, 23.4}}
976  }
977  };
978 
979  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{{1, 1, 2, 1}},
980  {{1, 1, 1, 1}}
981  }
982  };
983 
984  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG = {{{{ -8, -8, -8, -8}},
985  {{ -8, -8, -8, -8}}
986  }
987  };
988 
989  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsLG = {{{{ -4, -4, -4, -4}},
990  {{ -4, -4, -4, -4}}
991  }
992  };
993 
994  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
995  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
996  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
997 
998  // Set Tau and nominal timing offsets
999  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1000 
1001  bool fixTau1 = true;
1002  bool fixTau2 = true;
1003 
1004  for (size_t side : {0, 1}) {
1005  for (size_t module : {0, 1, 2, 3}) {
1006  fixTau1Arr[side][module] = fixTau1;
1007  fixTau2Arr[side][module] = fixTau2;
1008  }
1009  }
1010 
1011  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{{53.942, 49.887, 59.633, 46.497}},
1012  {{46.314, 42.267, 50.327, 41.605}}
1013  }
1014  };
1015  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{{51.771, 47.936, 57.438, 44.191}},
1016  {{44.295, 41.755, 48.081, 40.175}}
1017  }
1018  };
1019 
1020 
1021  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1022  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutLG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1023  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1024  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1025  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1026  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1027 
1028  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1029 
1030  slewingParamsHG[0][0] = {0, -7.904e-02, 4.686e-02, 1.530e-03 };
1031  slewingParamsHG[0][1] = {0, 2.250e-02, 4.732e-02, 6.050e-03 };
1032  slewingParamsHG[0][2] = {0, 4.388e-02, 6.707e-02, -5.526e-05 };
1033  slewingParamsHG[0][3] = {0, 1.205e-01, 2.726e-02, 2.610e-03 };
1034 
1035  slewingParamsHG[1][0] = {0, 6.861e-02, 5.175e-03, -9.018e-04 };
1036  slewingParamsHG[1][1] = {0, 3.855e-01, -4.442e-02, -2.022e-02 };
1037  slewingParamsHG[1][2] = {0, -4.337e-03, 3.841e-02, 4.661e-03 };
1038  slewingParamsHG[1][3] = {0, 3.623e-01, -3.882e-02, -1.805e-02 };
1039 
1040  slewingParamsLG[0][0] = {0, 1.708e-02, 7.929e-02, 5.079e-03 };
1041  slewingParamsLG[0][1] = {0, 1.406e-01, 1.209e-01, -1.922e-04 };
1042  slewingParamsLG[0][2] = {0, 1.762e-01, 1.118e-01, 1.679e-04 };
1043  slewingParamsLG[0][3] = {0, 1.361e-02, -2.685e-02, -4.168e-02 };
1044 
1045  slewingParamsLG[1][0] = {0, 1.962e-01, -5.025e-03, -2.001e-02 };
1046  slewingParamsLG[1][1] = {0, 3.258e-01, 1.229e-02, -2.925e-02 };
1047  slewingParamsLG[1][2] = {0, 1.393e-01, 8.113e-02, -2.594e-03 };
1048  slewingParamsLG[1][3] = {0, 1.939e-01, 2.188e-02, -5.579e-02 };
1049 
1050  m_zdcDataAnalyzer_40MHz.reset (new ZDCDataAnalyzer(MakeMessageFunction(), 7, 25, 0, "FermiExp", peak2ndDerivMinSamples,
1051  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainOnly));
1052 
1053  m_zdcDataAnalyzer_40MHz->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1054  m_zdcDataAnalyzer_40MHz->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1055  m_zdcDataAnalyzer_40MHz->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1056  m_zdcDataAnalyzer_40MHz->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1057  slewingParamsHG, slewingParamsLG);
1058 
1059  std::array<std::array<std::vector<float>, 4>, 2> moduleHGNonLinCorr, moduleLGNonLinCorr;
1060  moduleHGNonLinCorr[0][0] = { -3.76800e-02, 4.63597e-02};
1061  moduleHGNonLinCorr[0][1] = { -1.02185e-01, -1.17548e-01};
1062  moduleHGNonLinCorr[0][2] = { -8.78451e-02, -1.52174e-01};
1063  moduleHGNonLinCorr[0][3] = { -1.04835e-01, -1.96514e-01};
1064  moduleHGNonLinCorr[1][0] = { -6.83115e-02, 3.57802e-02};
1065  moduleHGNonLinCorr[1][1] = { -1.08162e-01, -1.91413e-01};
1066  moduleHGNonLinCorr[1][2] = { -7.82514e-02, -1.21218e-01};
1067  moduleHGNonLinCorr[1][3] = { -2.34354e-02, -2.52033e-01};
1068 
1069  moduleLGNonLinCorr = {{ {{{0},
1070  {0},
1071  {0},
1072  {0}}},
1073  {{{0},
1074  {0},
1075  {0},
1076  {0}}} }};
1077 
1078  m_zdcDataAnalyzer_40MHz->SetNonlinCorrParams(500, 1000, moduleHGNonLinCorr, moduleLGNonLinCorr);
1079  m_zdcDataAnalyzer_40MHz->SetSaveFitFunc(false);
1080 
1081 }

◆ initialize80MHz()

void ZDC::ZdcAnalysisTool::initialize80MHz ( )

Definition at line 1083 of file ZdcAnalysisTool.cxx.

1084 {
1085  // We have a complete configuration and so we override all of the default parameters
1086  //
1087 
1088  m_peak2ndDerivMinSamples = {{{{3, 2, 3, 2}},
1089  {{2, 2, 2, 2}}
1090  }
1091  };
1092 
1093  m_peak2ndDerivMinThresholdsHG = {{{{ -8, -8, -8, -8}},
1094  {{ -8, -8, -8, -8}}
1095  }
1096  };
1097 
1098  m_peak2ndDerivMinThresholdsLG = {{{{ -4, -4, -4, -4}},
1099  {{ -4, -4, -4, -4}}
1100  }
1101  };
1102 
1103  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1104  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1105  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{950, 950, 950, 950}}, {{950, 950, 950, 950}}}};
1106 
1107  // Set Tau and nominal timing offsets
1108  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1109 
1110  bool fixTau1 = true;
1111  bool fixTau2 = true;
1112 
1113  for (size_t side : {0, 1}) {
1114  for (size_t module : {0, 1, 2, 3}) {
1115  fixTau1Arr[side][module] = fixTau1;
1116  fixTau2Arr[side][module] = fixTau2;
1117  }
1118  }
1119 
1120  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{{3.9, 3.4, 4.1, 4.2}},
1121  {{4.2, 3.6, 3.3, 3.4}}
1122  }
1123  };
1124 
1125  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{{20.0, 20.4, 18.9, 20.8}},
1126  {{19.1, 21.9, 22.6, 23.4}}
1127  }
1128  };
1129 
1130  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{{44.24, 40.35, 49.3, 36.0}},
1131  {{36.0, 31.1, 40.75, 30.5}}
1132  }
1133  };
1134 
1135  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{{42.65, 38.5, 47.4, 34}},
1136  {{33.7, 29.9, 39.0, 29.3}}
1137  }
1138  };
1139 
1140  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1141  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutLG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1142  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1143  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1144  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1145  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1146 
1147  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1148 
1149  slewingParamsHG[0][0] = {0, -6.5e-2, 2.85e-2, -2.83e-3};
1150  slewingParamsHG[0][1] = {0, -5.5e-2, 5.13e-2, 5.6e-3};
1151  slewingParamsHG[0][2] = {0, -1.45e-3, 9.3e-2, 3.9e-3};
1152  slewingParamsHG[0][3] = {0, -2.36e-2, 8.3e-2, 1.1e-3};
1153 
1154  slewingParamsHG[1][0] = {0, -6.5e-2, 4.84e-2, -3.7e-3};
1155  slewingParamsHG[1][1] = {0, 1.34e-2, 6.57e-2, 5.37e-3};
1156  slewingParamsHG[1][2] = {0, -5.37e-2, 3.49e-2, 3.8e-3};
1157  slewingParamsHG[1][3] = {0, -3.3e-2, 3.9e-2, 2.2e-3};
1158 
1159  slewingParamsLG[0][0] = {0, -9.6e-2, 4.39e-2, 2.93e-3 };
1160  slewingParamsLG[0][1] = {0, -5.0e-2, 14.9e-2, 20.6e-3 };
1161  slewingParamsLG[0][2] = {0, -4.4e-2, 5.3e-2, 0, };
1162  slewingParamsLG[0][3] = {0, -9.90e-2, 4.08e-2, 0, };
1163 
1164  slewingParamsLG[1][0] = {0, -8.7e-2, 4.2e-2, -3.2e-3 };
1165  slewingParamsLG[1][1] = {0, -3.26e-2, 3.84e-2, -2.32e-3};
1166  slewingParamsLG[1][2] = {0, -26.8e-2, -2.64e-2, -5.3e-3 };
1167  slewingParamsLG[1][3] = {0, -13.2e-2, 0.45e-2, -2.4e-3 };
1168 
1169 
1170  m_zdcDataAnalyzer_80MHz.reset (new ZDCDataAnalyzer(MakeMessageFunction(), 7 , 12.5, 0, "FermiExp", m_peak2ndDerivMinSamples,
1171  m_peak2ndDerivMinThresholdsHG, m_peak2ndDerivMinThresholdsLG, m_lowGainOnly));
1172 
1173  m_zdcDataAnalyzer_80MHz->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1174  m_zdcDataAnalyzer_80MHz->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1175  m_zdcDataAnalyzer_80MHz->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1176  m_zdcDataAnalyzer_80MHz->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1177  slewingParamsHG, slewingParamsLG);
1178 
1179  std::array<std::array<std::vector<float>, 4>, 2> moduleHGNonLinCorr, moduleLGNonLinCorr;
1180  moduleHGNonLinCorr[0][0] = { -3.76800e-02, 4.63597e-02};
1181  moduleHGNonLinCorr[0][1] = { -1.02185e-01, -1.17548e-01};
1182  moduleHGNonLinCorr[0][2] = { -8.78451e-02, -1.52174e-01};
1183  moduleHGNonLinCorr[0][3] = { -1.04835e-01, -1.96514e-01};
1184  moduleHGNonLinCorr[1][0] = { -6.83115e-02, 3.57802e-02};
1185  moduleHGNonLinCorr[1][1] = { -1.08162e-01, -1.91413e-01};
1186  moduleHGNonLinCorr[1][2] = { -7.82514e-02, -1.21218e-01};
1187  moduleHGNonLinCorr[1][3] = { -2.34354e-02, -2.52033e-01};
1188 
1189  moduleLGNonLinCorr = {{ {{{0},
1190  {0},
1191  {0},
1192  {0}}},
1193  {{{0},
1194  {0},
1195  {0},
1196  {0}}} }};
1197 
1198  m_zdcDataAnalyzer_80MHz->SetNonlinCorrParams(500, 1000, moduleHGNonLinCorr, moduleLGNonLinCorr);
1199  m_zdcDataAnalyzer_80MHz->SetSaveFitFunc(false);
1200 }

◆ initializeDecorations()

void ZDC::ZdcAnalysisTool::initializeDecorations ( )

Definition at line 1382 of file ZdcAnalysisTool.cxx.

1383 {
1384 
1385 }

◆ initializeDefault()

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

Definition at line 598 of file ZdcAnalysisTool.cxx.

599 {
600  // We rely completely on the default parameters specified in the job properties to control:
601  // # samples
602  // frequency (more precisely, time/sample)
603  // which sample to use as the pre-sample
604  // where to expact the maxim of the peak (min 2nd derivative)
605  // thresholds on the 2nd derivative for valid pulses
606  // whether to fix the tau values in the pulse fitting
607  // the default tau values
608  // the nominal T0
609  // delta T and chisq/amp cuts
610  //
611  // For now, we continue to use hard-coded values for the maximum and minimum ADC values
612  // For now we also use the FermiExp pulse model.
613  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
614  ZDCDataAnalyzer::ZDCModuleFloatArray tau1{}, tau2{}, t0{};
615  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
616  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
617  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
618 
619  for (size_t side : {0, 1}) {
620  for (size_t module : {0, 1, 2, 3}) {
621  fixTau1Arr[side][module] = m_fixTau1;
622  fixTau2Arr[side][module] = m_fixTau2;
623  tau1[side][module] = m_tau1;
624  tau2[side][module] = m_tau2;
625 
626  peak2ndDerivMinSamples[side][module] = m_peakSample;
627  peak2ndDerivMinThresholdsHG[side][module] = -m_Peak2ndDerivThresh;
628  peak2ndDerivMinThresholdsLG[side][module] = -m_Peak2ndDerivThresh / 2;
629 
630  t0[side][module] = m_t0;
631  deltaT0CutLow[side][module] = -m_deltaTCut;
632  deltaT0CutHigh[side][module] = m_deltaTCut;
633  chisqDivAmpCut[side][module] = m_ChisqRatioCut;
634  }
635  }
636 
637  ATH_MSG_DEBUG( "Default: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
638 
639  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
640  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
641  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
642 
643  // Construct the data analyzer
644  //
645  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), m_numSample, m_deltaTSample, m_presample, "FermiExp", peak2ndDerivMinSamples,
646  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainOnly));
647 
648  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
649  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0, t0);
650  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
651 
652  if (m_combineDelay) {
653  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
654 
655  zdcDataAnalyzer->enableDelayed(m_delayDeltaT, defaultPedestalShifts);
656  }
657 
658  return zdcDataAnalyzer;
659 }

◆ initializeLHCf2022()

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

Definition at line 210 of file ZdcAnalysisTool.cxx.

211 {
212 
213  m_deltaTSample = 3.125;
214  m_numSample = 24;
215 
216  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{0, 9, 9, 9}, {0, 9, 10, 8}}};
217 
218  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
219  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
220  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
221 
222  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{0, 1.1, 1.1, 1.1},
223  {0, 1.1, 1.1, 1.1}}};
224 
225  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{6, 5, 5, 5}, {5.5, 5.5, 5.5, 5.5}}};
226 
227  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{0, 26.3, 26.5, 26.8}, {32, 32, 32, 32}}};
228 
229  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{0, 31.1, 28.1, 27.0}, {0, 26.6, 26.3, 25.3}}};
230 
231  for (size_t side : {0, 1}) {
232  for (size_t module : {0, 1, 2, 3}) {
233  fixTau1Arr[side][module] = true;
234  fixTau2Arr[side][module] = false;
235 
236  peak2ndDerivMinThresholdsHG[side][module] = -35;
237  peak2ndDerivMinThresholdsLG[side][module] = -16;
238 
239  deltaT0CutLow[side][module] = -10;
240  deltaT0CutHigh[side][module] = 10;
241  chisqDivAmpCut[side][module] = 20;
242  }
243  }
244 
245  ATH_MSG_DEBUG( "LHCF2022: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
246 
247  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
248  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
249  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
250 
251  // For the LHCf run, use low gain samples
252  //
253  m_lowGainOnly = true;
254 
255  // Construct the data analyzer
256  //
257  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
258  m_numSample, m_deltaTSample,
259  m_presample, "FermiExpLHCf",
260  peak2ndDerivMinSamples,
261  peak2ndDerivMinThresholdsHG,
262  peak2ndDerivMinThresholdsLG,
263  m_lowGainOnly));
264 
265  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(2);
266  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
267  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
268  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
269 
270  zdcDataAnalyzer->SetGainFactorsHGLG(0.1, 1); // a gain adjustment of unity applied to LG ADC, 0.1 to HG ADC values
271 
272  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{2, 2, 2, 2}, {2, 2, 2, 2}}};
273  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{20, 20, 20, 20}, {20, 20, 20, 20}}};
274 
275  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
276 
277  // Enable two-pass analysis
278  //
279  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-12, -12, -12, -12},
280  {-12, -12, -12, -12}}};
281 
282  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
283  {-8, -8, -8, -8}}};
284 
285  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
286 
287  // Set the amplitude fit range limits
288  //
289  zdcDataAnalyzer->SetFitMinMaxAmpValues(5, 2, 5000, 5000);
290 
291  // disable EM module on each side
292  zdcDataAnalyzer->disableModule(0, 0);
293  zdcDataAnalyzer->disableModule(1, 0);
294 
295 
296  RPDConfig rpdConfig{};
297  rpdConfig.nRows = 4;
298  rpdConfig.nColumns = 4;
299  rpdConfig.nSamples = m_numSample;
300  rpdConfig.nBaselineSamples = m_rpdNbaselineSamples;
301  rpdConfig.endSignalSample = m_rpdEndSignalSample;
302  rpdConfig.pulse2ndDerivThresh = m_rpdPulse2ndDerivThresh;
303  rpdConfig.postPulseFracThresh = m_rpdPostPulseFracThresh;
304  rpdConfig.goodPulseSampleStart = m_rpdGoodPulseSampleStart;
305  rpdConfig.goodPulseSampleStop = m_rpdGoodPulseSampleStop;
306  rpdConfig.nominalBaseline = m_rpdNominalBaseline;
307  rpdConfig.pileupBaselineSumThresh = m_rpdPileupBaselineSumThresh;
308  rpdConfig.pileupBaselineStdDevThresh = m_rpdPileupBaselineStdDevThresh;
309  rpdConfig.nNegativesAllowed = m_rpdNNegativesAllowed;
310  rpdConfig.AdcOverflow = m_rpdAdcOverflow;
311  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdC", rpdConfig, m_rpdSideCOutputCalibFactors));
312  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdA", rpdConfig, m_rpdSideAOutputCalibFactors));
313 
314  return zdcDataAnalyzer;
315 
316 }

◆ initializePbPb2015G4()

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

Definition at line 661 of file ZdcAnalysisTool.cxx.

662 {
663  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
664  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
665  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
666  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
667  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
668 
669  const int peakSample = 4;
670  const float peak2ndDerivThreshHG = -12;
671  const float peak2ndDerivThreshLG = -10;
672  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{4.000, 4.000, 4.000, 4.000},
673  {4.000, 4.000, 4.000, 4.000}}};
674  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{25.36, 25.05, 25.43, 25.60},
675  {25.11, 25.08, 25.18, 25.48}}};
676 
677  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{57.31, 57.28, 57.30, 57.28},
678  {57.28, 57.29, 57.31, 57.33}}};
679  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{57.31, 57.28, 57.30, 57.28},
680  {57.28, 57.29, 57.31, 57.33}}};
681 
682  // Delta T0 cut
683  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{-10, -10, -10, -10}, {-10, -10, -10, -10}}};
684  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{ 10, 10, 10, 10}, { 10, 10, 10, 10}}};
685  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{-10, -10, -10, -10}, {-10, -10, -10, -10}}};
686  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{ 10, 10, 10, 10}, { 10, 10, 10, 10}}};
687 
688  for (size_t side : {0, 1}) {
689  for (size_t module : {0, 1, 2, 3}) {
690  fixTau1Arr[side][module] = true;
691  fixTau2Arr[side][module] = true;
692 
693  peak2ndDerivMinSamples[side][module] = peakSample;
694  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
695  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
696 
697  chisqDivAmpCut[side][module] = 15;
698  }
699  }
700 
701  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{ 800, 800, 800, 800}}, {{ 800, 800, 800, 800}}}};
702  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{ 10, 10, 10, 10}}, {{ 10, 10, 10, 10}}}};
703  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
704 
705  m_deltaTSample = 12.5;
706 
707  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), 7, m_deltaTSample, 0, "FermiExp", peak2ndDerivMinSamples,
708  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainOnly));
709 
710  // Open up tolerances on the position of the peak for now
711  //
712  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
713 
714  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
715  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
716  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
717 
718  zdcDataAnalyzer->SetFitTimeMax(85);
719  zdcDataAnalyzer->SetSaveFitFunc(false);
720 
721  return zdcDataAnalyzer;
722 }

◆ initializePbPb2018()

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

Definition at line 836 of file ZdcAnalysisTool.cxx.

837 {
838  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
839  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{}, peak2ndDerivMinRepassHG{}, peak2ndDerivMinRepassLG{};
840  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
841  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
842 
843  static constexpr int peakSample = 5;
844  static constexpr float peak2ndDerivThreshHG = -35;
845  static constexpr float peak2ndDerivThreshLG = -20;
846  static constexpr float peak2ndDerivRepassHG = -10;
847  static constexpr float peak2ndDerivRepassLG = -6;
848 
849  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{3.877, 3.998, 3.821, 3.858},
850  {4.296, 4.064, 3.497, 3.642}
851  }};
852 
853  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{24.40, 25.28, 25.66, 24.12},
854  {24.42, 24.99, 25.72, 25.29}
855  }};
856 
857  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{70.51, 70.57, 70.13, 69.98},
858  {74.18, 72.79, 71.77, 72.62}
859  }};
860  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{70.70, 70.78, 70.76, 70.91},
861  {75.16, 73.71, 72.25, 73.61}
862  }};
863 
864  ZDCDataAnalyzer::ZDCModuleFloatArray moduleAmpFractionLG = {{{0.2760, 0.3045, 0.2369, 0.1826},
865  {0.3216, 0.2593, 0.2511, 0.1680}
866  }};
867 
868  // Delta T0 cut
869  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
870  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
871  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
872  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
873 
874  for (size_t side : {0, 1}) {
875  for (size_t module : {0, 1, 2, 3}) {
876  fixTau1Arr[side][module] = true;
877  fixTau2Arr[side][module] = true;
878 
879  peak2ndDerivMinSamples[side][module] = peakSample;
880  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
881  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
882  peak2ndDerivMinRepassHG [side][module] = peak2ndDerivRepassHG;
883  peak2ndDerivMinRepassLG [side][module] = peak2ndDerivRepassLG;
884 
885  chisqDivAmpCut[side][module] = 15;
886  }
887  }
888 
889  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
890  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
891  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
892 
893  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1, 1, 1, 1}, {1, 1, 1, 1}}};
894  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{12, 12, 12, 12}, {12, 12, 12, 12}}};
895 
896 
897  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
898  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
899  slewingParamsHG[0][0] = { -1.335560e-01, -6.071869e-03, 5.858193e-02, 2.473300e-03};
900  slewingParamsHG[0][1] = { -1.223062e-01, -4.379469e-02, 4.452285e-02, 2.130210e-03};
901  slewingParamsHG[0][2] = { -1.021415e-01, -4.254239e-02, 4.939866e-02, 3.849738e-03};
902  slewingParamsHG[0][3] = { -8.234056e-02, -3.938803e-02, 4.689029e-02, 2.784816e-03};
903 
904  slewingParamsHG[1][0] = { -1.640979e-01, -2.780350e-02, 5.755065e-02, -4.244651e-04};
905  slewingParamsHG[1][1] = { -1.422324e-01, 2.663803e-02, 7.295366e-02, 3.740496e-03};
906  slewingParamsHG[1][2] = { -9.858124e-02, -2.426132e-02, 4.895967e-02, 2.291393e-03};
907  slewingParamsHG[1][3] = { -1.070401e-01, -2.256383e-03, 5.833770e-02, 2.255208e-03};
908 
909  slewingParamsLG[0][0] = { -2.588446e-01, -3.241086e-02, 7.828661e-02, 1.945547e-03};
910  slewingParamsLG[0][1] = { -3.112495e-01, -7.419508e-02, 6.825776e-02, 2.148860e-03};
911  slewingParamsLG[0][2] = { -3.470650e-01, -5.836748e-02, 6.204396e-02, 1.550421e-03};
912  slewingParamsLG[0][3] = { -4.485435e-01, -4.603790e-02, 5.944799e-02, -1.174585e-03};
913 
914  slewingParamsLG[1][0] = { -3.291676e-01, -4.023732e-02, 8.608755e-02, -3.958167e-03};
915  slewingParamsLG[1][1] = { -2.608969e-01, -2.129786e-03, 6.930791e-02, -4.141910e-03};
916  slewingParamsLG[1][2] = { -2.505712e-01, -2.195804e-02, 5.137261e-02, -4.058378e-03};
917  slewingParamsLG[1][3] = { -5.083206e-01, 3.776601e-02, 1.284275e-01, 1.014067e-02};
918 
919  // Construct the data analyzer
920  //
921  // We adopt hard-coded values for the number of samples and the frequency which we kept fixed for all physics data
922  //
923  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer = std::make_unique<ZDCDataAnalyzer>(MakeMessageFunction(), 7, 25, 0, "FermiExpLinear", peak2ndDerivMinSamples, // presample index changed to zero 4/6/19
924  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainOnly);
925 
926  // Open up tolerances on the position of the peak for now
927  //
928  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
929 
930  // We alwyas disable the 12EM (sideC) module which was not present (LHCf)
931  //
932 
933  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
934  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
935  zdcDataAnalyzer->SetModuleAmpFractionLG(moduleAmpFractionLG); // fraction calculation for LGOverflows added Nov 23, 2020
936  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
937 
938  // We allow the combineDelay to be controlled by the properties
939  //
940  m_combineDelay = true;
941  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
942 
943  // We use per-module delays to handle the delayed-undelayed swap on EMC
944  //
945  ZDCDataAnalyzer::ZDCModuleFloatArray delayDeltaTs = {{{{12.5, -12.5, -12.5, -12.5}},
946  {{ -12.5, -12.5, -12.5, -12.5}}
947  }
948  };
949 
950  zdcDataAnalyzer->enableDelayed(delayDeltaTs, defaultPedestalShifts);
951  zdcDataAnalyzer->SetFitTimeMax(140); // This restrict the fit range of the pulse fitting, requested by BAC 4/6/19
952  zdcDataAnalyzer->SetSaveFitFunc(false);
953  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG); // add repass as default Jul 21 2020 Bill
954  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
955  slewingParamsHG, slewingParamsLG); // add time slewing correction Sep 17 2019 Bill
956  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
957 
958  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
959 
960  return zdcDataAnalyzer;
961 }

◆ initializePbPb2023()

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

Definition at line 425 of file ZdcAnalysisTool.cxx.

426 {
427  // Key configuration parameters needed for the data analyzer construction
428  //
429  m_deltaTSample = 3.125;
430  m_numSample = 24;
431 
432  const int deriv2ndThreshDSHG = -25;
433  const int deriv2ndThreshDSLG = -10;
434  const unsigned int peakSample = 10;
435 
436  const float deltaTcutLow = -10;
437  const float deltaTcutHigh = 10;
438  const float chisqDivAmpCutHGVal = 30;
439  const float chisqDivAmpCutLGVal = 50;
440 
441  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
442  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
443 
444  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{};
445  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG{}, chisqDivAmpCutLG{};
446  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
447 
448  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.1, 1.1, 1.1, 1.1},
449  {1.1, 1.1, 1.1, 1.1}}};
450 
451  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
452 
453  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
454  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
455 
456  for (size_t side : {0, 1}) {
457  for (size_t module : {0, 1, 2, 3}) {
458  fixTau1Arr[side][module] = true;
459  fixTau2Arr[side][module] = false;
460 
461  peak2ndDerivMinSamples[side][module] = peakSample;
462  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
463  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
464 
465  deltaT0CutLow[side][module] = deltaTcutLow;
466  deltaT0CutHigh[side][module] = deltaTcutHigh;
467  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
468  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
469  }
470  }
471 
472  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
473 
474  // Construct the data analyzer
475  //
476  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
477  m_numSample, m_deltaTSample,
478  m_presample, "FermiExpLHCf",
479  peak2ndDerivMinSamples,
480  peak2ndDerivMinThresholdsHG,
481  peak2ndDerivMinThresholdsLG,
482  m_lowGainOnly));
483  zdcDataAnalyzer->set2ndDerivStep(2);
484  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
485 
486  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1, 1, 1, 1},{1, 1, 1, 1}}};
487  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{9.63, 9.29, 10.08, 9.34},{9.79, 9.45, 9.94, 10.36}}};
488 
489  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
490 
491  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
492  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
493  //
494  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
495  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{1.5, 1.7, 3, 1.7}, {1.7, 1.6, 2.2, 1.8}}};
496 
497  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
498 
499  // Now set cuts and default fit parameters
500  //
501  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
502  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
503  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
504 
505  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
506  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
507  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
508 
509  // Enable two-pass analysis
510  //
511  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-10, -10, -10, -10},
512  {-10, -10, -10, -10}}};
513 
514  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
515  {-8, -8, -8, -8}}};
516 
517  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
518 
519  // Turn on exclusion of early and late samples to address OOT pileup
520  //
521  zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
522  zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
523 
524  // Set up non-linear corrections for the ZDC
525  //
526  std::array<std::array<std::vector<float>, 4>, 2> nonLinearCorrCoefficHG, nonLinearCorrCoefficLG;
527 
528  nonLinearCorrCoefficHG = {{ {{{-0.039464, 0.013250, -0.003676},
529  {-0.050573, 0.019664, -0.004340},
530  {-0.052816, 0.016221, -0.003364},
531  {-0.014327, 0.000226, -0.000943}}},
532  {{{-0.059663, 0.019482, -0.004615},
533  {-0.036908, 0.008920, -0.002805},
534  {-0.046814, 0.019434, -0.004207},
535  {-0.060879, 0.026635, -0.004833}}} }};
536 
537  // For now we don't use corrections on the LG as it's much harder to measure them
538  //
539  nonLinearCorrCoefficLG = {{ {{{0},
540  {0},
541  {0},
542  {0}}},
543  {{{0},
544  {0},
545  {0},
546  {0}}} }};
547 
548  zdcDataAnalyzer->SetNonlinCorrParams(0, 1000, nonLinearCorrCoefficHG, nonLinearCorrCoefficLG);
549 
550  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
551  timeCorrCoefficHG[0][0] = {0.07, -0.020672, 0.070206, 0.004961, -0.010821, -0.001835};
552  timeCorrCoefficHG[0][1] = {0.04, -0.012961, 0.008204, 0.010771, 0.011593, 0.002045};
553  timeCorrCoefficHG[0][2] = {0.04, 0.017393, 0.017597, 0.003736, -0.001696, -0.000465};
554  timeCorrCoefficHG[0][3] = {0.04, 0.018463, 0.009862, -0.000277, -0.000268, 0.000192};
555 
556  timeCorrCoefficHG[1][0] = {0.13, -0.106068, 0.078153, 0.034479, -0.004964, -0.001688};
557  timeCorrCoefficHG[1][1] = {0.03, -0.007518, 0.008937, 0.015319, 0.012290, 0.001889};
558  timeCorrCoefficHG[1][2] = {-0.01, 0.006711, -0.001652, -0.004223, -0.000573, 0.000161};
559  timeCorrCoefficHG[1][3] = {0.015, 0.017993, 0.006339, 0.003122, 0.002980, 0.000735};
560 
561  timeCorrCoefficLG[0][0] = {0.035, -0.126189, 0.022724, 0.039116, -0.098255};
562  timeCorrCoefficLG[0][1] = {0.022, -0.165988, -0.014125, 0.057323, -0.205109};
563  timeCorrCoefficLG[0][2] = {0.01, -0.136087, -0.007248, -0.014452, -0.060469};
564  timeCorrCoefficLG[0][3] = {0.0, -0.131067, 0.025579, 0.059994, -0.065595};
565 
566  timeCorrCoefficLG[1][0] = {0.076, -0.300587, -0.041827, 0.641108, -0.594157};
567  timeCorrCoefficLG[1][1] = {0.057, -0.223443, -0.125013, -0.176900, 0.348081};
568  timeCorrCoefficLG[1][2] = {0.015, -0.141721, 0.023936, 0.099657, -0.188526};
569  timeCorrCoefficLG[1][3] = {0.01, -0.152589, 0.016122, -0.086580, 0.563625};
570 
571  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
572 
573  // Set the amplitude fit range limits
574  //
575  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
576 
577  RPDConfig rpdConfig{};
578  rpdConfig.nRows = 4;
579  rpdConfig.nColumns = 4;
580  rpdConfig.nSamples = m_numSample;
581  rpdConfig.nBaselineSamples = m_rpdNbaselineSamples;
582  rpdConfig.endSignalSample = m_rpdEndSignalSample;
583  rpdConfig.pulse2ndDerivThresh = m_rpdPulse2ndDerivThresh;
584  rpdConfig.postPulseFracThresh = m_rpdPostPulseFracThresh;
585  rpdConfig.goodPulseSampleStart = m_rpdGoodPulseSampleStart;
586  rpdConfig.goodPulseSampleStop = m_rpdGoodPulseSampleStop;
587  rpdConfig.nominalBaseline = m_rpdNominalBaseline;
588  rpdConfig.pileupBaselineSumThresh = m_rpdPileupBaselineSumThresh;
589  rpdConfig.pileupBaselineStdDevThresh = m_rpdPileupBaselineStdDevThresh;
590  rpdConfig.nNegativesAllowed = m_rpdNNegativesAllowed;
591  rpdConfig.AdcOverflow = m_rpdAdcOverflow;
592  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdC", rpdConfig, m_rpdSideCOutputCalibFactors));
593  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdA", rpdConfig, m_rpdSideAOutputCalibFactors));
594 
595  return zdcDataAnalyzer;
596 }

◆ initializepp2023()

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

Definition at line 318 of file ZdcAnalysisTool.cxx.

319 {
320 
321  m_deltaTSample = 3.125;
322  m_numSample = 24;
323 
324  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{12, 12, 12, 12}, {12, 12, 12, 12}}};
325 
326  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
327  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
328  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
329 
330  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.1, 1.1, 1.1, 1.1},
331  {1.1, 1.1, 1.1, 1.1}}};
332 
333  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{5.5, 5.5, 5.5, 5.5}, {5.5, 5.5, 5.5, 5.5}}};
334 
335  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{36, 36, 36, 36}, {36, 36, 36, 36}}};
336 
337  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{36, 36, 36, 36}, {36, 36, 36, 36}}};
338 
339  const int deriv2ndThreshDSHG = -35;
340  const int deriv2ndThreshDSLG = -10;
341 
342  const float deltaTcutLow = -10;
343  const float deltaTcutHigh = 10;
344  const float chisqDivAmpCutVal = 10;
345 
346  for (size_t side : {0, 1}) {
347  for (size_t module : {0, 1, 2, 3}) {
348  fixTau1Arr[side][module] = true;
349  fixTau2Arr[side][module] = false;
350 
351  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
352  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
353 
354  deltaT0CutLow[side][module] = deltaTcutLow;
355  deltaT0CutHigh[side][module] = deltaTcutHigh;
356  chisqDivAmpCut[side][module] = chisqDivAmpCutVal;
357  }
358  }
359 
360  ATH_MSG_DEBUG( "pp2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
361 
362  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
363  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
364  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
365 
366  // Construct the data analyzer
367  //
368  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
369  m_numSample, m_deltaTSample,
370  m_presample, "FermiExpLHCf",
371  peak2ndDerivMinSamples,
372  peak2ndDerivMinThresholdsHG,
373  peak2ndDerivMinThresholdsLG,
374  m_lowGainOnly));
375 
376  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
377  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
378  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
379  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
380 
381  zdcDataAnalyzer->SetGainFactorsHGLG(1, 10); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
382 
383  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{0.5, 0.5, 0.5, 0.5}, {0.5, 0.5, 0.5, 0.5}}};
384  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{2, 2, 2, 2}, {2, 2, 2, 2}}};
385 
386  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
387 
388  // Enable two-pass analysis
389  //
390  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-12, -12, -12, -12},
391  {-12, -12, -12, -12}}};
392 
393  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
394  {-8, -8, -8, -8}}};
395 
396  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
397 
398  // Set the amplitude fit range limits
399  //
400  zdcDataAnalyzer->SetFitMinMaxAmpValues(5, 2, 5000, 5000);
401 
402 
403  RPDConfig rpdConfig{};
404  rpdConfig.nRows = 4;
405  rpdConfig.nColumns = 4;
406  rpdConfig.nSamples = m_numSample;
407  rpdConfig.nBaselineSamples = m_rpdNbaselineSamples;
408  rpdConfig.endSignalSample = m_rpdEndSignalSample;
409  rpdConfig.pulse2ndDerivThresh = m_rpdPulse2ndDerivThresh;
410  rpdConfig.postPulseFracThresh = m_rpdPostPulseFracThresh;
411  rpdConfig.goodPulseSampleStart = m_rpdGoodPulseSampleStart;
412  rpdConfig.goodPulseSampleStop = m_rpdGoodPulseSampleStop;
413  rpdConfig.nominalBaseline = m_rpdNominalBaseline;
414  rpdConfig.pileupBaselineSumThresh = m_rpdPileupBaselineSumThresh;
415  rpdConfig.pileupBaselineStdDevThresh = m_rpdPileupBaselineStdDevThresh;
416  rpdConfig.nNegativesAllowed = m_rpdNNegativesAllowed;
417  rpdConfig.AdcOverflow = m_rpdAdcOverflow;
418  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdC", rpdConfig, m_rpdSideCOutputCalibFactors));
419  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdA", rpdConfig, m_rpdSideAOutputCalibFactors));
420 
421  return zdcDataAnalyzer;
422 
423 }

◆ initializepPb2016()

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

Definition at line 724 of file ZdcAnalysisTool.cxx.

725 {
726  //
727  // For now, we continue to use hard-coded values for the maximum and minimum ADC values
728  // For now we also use the FermiExp pulse model.
729 
730  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
731  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
732  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
733  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
734 
735  // For now we allow the tau values to be controlled by the job properties until they are better determined
736  //
737  const int peakSample = 5;
738  const float peak2ndDerivThreshHG = -12;
739  const float peak2ndDerivThreshLG = -10;
740  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{4.000, 3.380, 3.661, 3.679},
741  {4.472, 4.656, 3.871, 4.061}
742  }};
743 
744  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{22, 24.81, 24.48, 24.45},
745  {24.17, 24.22, 25.46, 24.45}
746  }};
747 
748  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{70.00, 72.74, 73.09, 72.25},
749  {75.11, 74.94, 73.93, 74.45}
750  }};
751  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{70.00, 73.41, 74.27, 73.30},
752  {76.28, 76.07, 74.98, 76.54}
753  }};
754 
755  // Delta T0 cut
756  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
757  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
758  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
759  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
760 
761 
762  for (size_t side : {0, 1}) {
763  for (size_t module : {0, 1, 2, 3}) {
764  fixTau1Arr[side][module] = true;
765  fixTau2Arr[side][module] = true;
766 
767  peak2ndDerivMinSamples[side][module] = peakSample;
768  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
769  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
770 
771  chisqDivAmpCut[side][module] = 15;
772  }
773  }
774 
775  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
776  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
777  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
778 
779  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
780  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
781  slewingParamsHG[0][0] = {0, 0, 0, 0};
782  slewingParamsHG[0][1] = { -4.780244e-01, -7.150874e-02, 4.614585e-02, 8.015731e-04};
783  slewingParamsHG[0][2] = { -5.253412e-01, -5.718167e-02, 5.243121e-02, 2.128398e-03};
784  slewingParamsHG[0][3] = { -5.773952e-01, -5.687478e-02, 4.564267e-02, 1.462294e-03};
785 
786  slewingParamsHG[1][0] = { 7.105115e-01, -3.686143e-02, 7.727447e-02, 5.924152e-03};
787  slewingParamsHG[1][1] = { 4.052120e-02, 4.450686e-03, 8.031615e-02, 4.038097e-03};
788  slewingParamsHG[1][2] = { 3.389476e-02, -2.056782e-02, 4.805321e-02, -2.627999e-03};
789  slewingParamsHG[1][3] = { 2.069765e-01, -2.890419e-02, 6.084375e-02, 3.742011e-03};
790 
791  slewingParamsLG[0][0] = {0, 0, 0, 0};
792  slewingParamsLG[0][1] = { -1.632547e+00, -4.827813e-01, -1.379131e-01, -2.522607e-02};
793  slewingParamsLG[0][2] = { -7.254288e+00, -5.454064e+00, -1.619126e+00, -1.739665e-01};
794  slewingParamsLG[0][3] = { -1.548400e+01, -1.277708e+01, -3.729333e+00, -3.700458e-01};
795 
796  slewingParamsLG[1][0] = { 1.142767e-01, -3.608906e-02, 9.642735e-02, -3.097043e-03};
797  slewingParamsLG[1][1] = { -5.615388e-01, -1.655047e-02, 8.327350e-02, -4.231348e-03};
798  slewingParamsLG[1][2] = { -7.370728e-01, -2.887482e-02, 8.293875e-02, -4.482743e-03};
799  slewingParamsLG[1][3] = { -1.270636e+00, -2.791777e-01, -5.807295e-02, -2.332612e-02};
800 
801  // Construct the data analyzer
802  //
803  // We adopt hard-coded values for the number of samples and the frequency which we kept fixed for all physics data
804  //
805  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), 7, 25, 0, "FermiExpLinear", peak2ndDerivMinSamples,
806  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainOnly));
807 
808  // Open up tolerances on the position of the peak for now
809  //
810  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
811 
812  // We alwyas disable the 12EM (sideC) module which was not present (LHCf)
813  //
814  zdcDataAnalyzer->disableModule(0, 0);
815 
816  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
817  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
818  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
819 
820  // We allow the combineDelay to be controlled by the properties
821  //
822  // if (m_combineDelay) {
823  m_combineDelay = true;
824  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
825 
826  zdcDataAnalyzer->enableDelayed(-12.5, defaultPedestalShifts);
827  zdcDataAnalyzer->SetFitTimeMax(140); // This restrict the fit range of the pulse fitting
828  zdcDataAnalyzer->SetSaveFitFunc(false);
829  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
830  slewingParamsHG, slewingParamsLG); // add time slewing correction Sep 17 2019 Bill
831  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
832 
833  return zdcDataAnalyzer;
834 }

◆ initializeTriggerEffs()

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

Definition at line 97 of file ZdcAnalysisTool.cxx.

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

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

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

◆ 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, top::TopObjectSelection, 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, top::TopObjectSelection, 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 1407 of file ZdcAnalysisTool.cxx.

1408 {
1409 
1410  if (moduleContainer.size()==0) return StatusCode::SUCCESS; // if no modules, do nothing
1411 
1412  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
1413  if (!eventInfo.isValid()) return StatusCode::FAILURE;
1414 
1415  // check for new run number, if new, possibly update configuration and/or calibrations
1416  //
1417  unsigned int thisRunNumber = eventInfo->runNumber();
1418  if (thisRunNumber != m_runNumber) {
1419  ATH_MSG_DEBUG("ZDC analysis tool will be configured for run " << thisRunNumber);
1420 
1421  ATH_CHECK(configureNewRun(thisRunNumber)); // ALWAYS check methods that return StatusCode
1422 
1423  ATH_MSG_DEBUG("Setting up calibrations");
1424 
1425  if (m_doCalib) {
1426  //
1427  // Check for calibration override
1428  //
1429  unsigned int calibRunNumber = thisRunNumber;
1430  if (m_forceCalibRun > -1) calibRunNumber = m_forceCalibRun;
1431 
1432  setEnergyCalibrations(calibRunNumber);
1433  if (m_doTrigEff) initializeTriggerEffs(calibRunNumber); // if energy calibrations fail to load, then so will trigger efficiencies
1434  if (m_doTimeCalib) setTimeCalibrations(calibRunNumber);
1435  }
1436 
1437  m_runNumber = thisRunNumber;
1438  }
1439 
1440  m_lumiBlock = eventInfo->lumiBlock();
1441 
1442  unsigned int calibLumiBlock = m_lumiBlock;
1443  if (m_doCalib) {
1444  if (m_forceCalibRun > 0) calibLumiBlock = m_forceCalibLB;
1445  }
1446 
1447  ATH_MSG_DEBUG("Starting event processing");
1448  ATH_MSG_DEBUG("LB=" << calibLumiBlock);
1449 
1450  m_zdcDataAnalyzer->StartEvent(calibLumiBlock);
1451 
1452  if (m_LHCRun==3)
1453  {
1454  m_rpdDataAnalyzer.at(0)->reset();
1455  m_rpdDataAnalyzer.at(1)->reset();
1456  }
1457 
1458  static const SG::ConstAccessor<std::vector<uint16_t> > g0dataAcc ("g0data");
1459  static const SG::ConstAccessor<std::vector<uint16_t> > g1dataAcc ("g1data");
1460 
1461  const std::vector<unsigned short>* adcUndelayLG = 0;
1462  const std::vector<unsigned short>* adcUndelayHG = 0;
1463 
1464  const std::vector<unsigned short>* adcDelayLG = 0;
1465  const std::vector<unsigned short>* adcDelayHG = 0;
1466 
1467  ATH_MSG_DEBUG("Processing modules");
1468  for (const auto zdcModule : moduleContainer)
1469  {
1470  int side = -1;
1471  if (zdcModule->zdcSide() == -1) side = 0;
1472  else if (zdcModule->zdcSide() == 1) side = 1;
1473  else {
1474  // Invalid side
1475  //
1476  ATH_MSG_WARNING("Invalid side value found for module number: " << zdcModule->zdcModule() << ", side value = " << side);
1477  continue;
1478  }
1479  // Ignore MC only modules
1480  if(zdcModule->zdcModule() > 4) continue;
1481 
1482  if (zdcModule->zdcType() == 1) {
1483  // This is RPD data in Run 3
1484  //
1485  if (m_LHCRun < 3) continue; // type == 1 -> pixel data in runs 2 and 3, skip
1486  ATH_MSG_DEBUG("RPD side " << side << " chan " << zdcModule->zdcChannel() );
1487 
1488  unsigned int rpdChannel = zdcModule->zdcChannel(); // channel numbers are fixed in mapping, numbered 0-15
1489  if (rpdChannel > 15) {
1490  //
1491  // The data is somehow corrupt, spit out an error
1492  //
1493  ATH_MSG_WARNING("Invalid RPD channel found on side " << side << ", channel number = " << rpdChannel << ", skipping this module");
1494  continue;
1495  }
1496  else {
1497  //
1498  // Pass the data to the RPD analysis tool
1499  //
1500  m_rpdDataAnalyzer.at(side)->loadChannelData(rpdChannel,
1501  g0dataAcc (*zdcModule));
1502  }
1503  }
1504  else {
1505  //
1506  // This is ZDC data
1507  //
1508  if (m_LHCRun==3) // no delay channels, so we drop the index
1509  {
1510  adcUndelayLG = &g0dataAcc(*zdcModule); // g0
1511  adcUndelayHG = &g1dataAcc(*zdcModule); // g1
1512  }
1513  else if (m_LHCRun==2)
1514  {
1515  if (zdcModule->zdcType() == 1) continue; // skip position sensitive modules
1516 
1517  static const SG::ConstAccessor<std::vector<uint16_t> > g0d1dataAcc ("g0d1data");
1518  static const SG::ConstAccessor<std::vector<uint16_t> > g1d1dataAcc ("g1d1data");
1519  static const SG::ConstAccessor<std::vector<uint16_t> > g0d0dataAcc ("g0d0data");
1520  static const SG::ConstAccessor<std::vector<uint16_t> > g1d0dataAcc ("g1d0data");
1521 
1522  if (zdcModule->zdcModule() == 0 && m_flipEMDelay) // flip delay/non-delay for 2015 ONLY
1523  {
1524  adcUndelayLG = &g0d1dataAcc(*zdcModule); // g0d1
1525  adcUndelayHG = &g1d1dataAcc(*zdcModule); // g1d1
1526  adcDelayLG = &g0d0dataAcc(*zdcModule); // g0d0
1527  adcDelayHG = &g1d0dataAcc(*zdcModule); // g1d0
1528  }
1529  else // nominal configuation
1530  {
1531  adcUndelayLG = &g0d0dataAcc(*zdcModule); // g0d0
1532  adcUndelayHG = &g1d0dataAcc(*zdcModule); // g1d0
1533  adcDelayLG = &g0d1dataAcc(*zdcModule); // g0d1
1534  adcDelayHG = &g1d1dataAcc(*zdcModule); // g1d1
1535  }
1536  }
1537  else
1538  {
1539  ATH_MSG_WARNING("Unknown LHC Run " << m_LHCRun);
1540  return StatusCode::FAILURE;
1541  }
1542 
1543  // Why were these static? to optimize processing time
1544  std::vector<float> HGUndelADCSamples(m_numSample);
1545  std::vector<float> LGUndelADCSamples(m_numSample);
1546 
1547  std::copy(adcUndelayLG->begin(), adcUndelayLG->end(), LGUndelADCSamples.begin());
1548  std::copy(adcUndelayHG->begin(), adcUndelayHG->end(), HGUndelADCSamples.begin());
1549 
1550  int side = (zdcModule->zdcSide() == -1) ? 0 : 1 ;
1551 
1552  if (!m_combineDelay) {
1553  m_zdcDataAnalyzer->LoadAndAnalyzeData(side, zdcModule->zdcModule(), HGUndelADCSamples, LGUndelADCSamples);
1554  }
1555  else {
1556  std::vector<float> HGDelayADCSamples(m_numSample);
1557  std::vector<float> LGDelayADCSamples(m_numSample);
1558  if (adcDelayLG and adcDelayHG){
1559  std::copy(adcDelayLG->begin(), adcDelayLG->end(), LGDelayADCSamples.begin());
1560  std::copy(adcDelayHG->begin(), adcDelayHG->end(), HGDelayADCSamples.begin());
1561  }else{
1562  ATH_MSG_ERROR("adcDelayLG or adcDelayHG pointers are null");
1563  return StatusCode::FAILURE;
1564  }
1565  // If the delayed channels actually come earlier (as in the pPb in 2016), we invert the meaning of delayed and undelayed
1566  // see the initialization sections for similar inversion on the sign of the pedestal difference
1567  //
1568 
1569  m_zdcDataAnalyzer->LoadAndAnalyzeData(side, zdcModule->zdcModule(),
1570  HGUndelADCSamples, LGUndelADCSamples,
1571  HGDelayADCSamples, LGDelayADCSamples);
1572  }
1573  }
1574  }
1575 
1576  // analyze RPD data only once all channels have been loaded
1577  if (m_LHCRun==3)
1578  {
1579  m_rpdDataAnalyzer.at(0)->analyzeData();
1580  m_rpdDataAnalyzer.at(1)->analyzeData();
1581  }
1582 
1583  ATH_MSG_DEBUG("Finishing event processing");
1584 
1585  m_zdcDataAnalyzer->FinishEvent();
1586 
1587  ATH_MSG_DEBUG("Adding variables with suffix=" + m_auxSuffix);
1588 
1589  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleAmplitude(m_zdcModuleAmplitude);
1590  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleCalibEnergy(m_zdcModuleCalibEnergy);
1591  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleCalibTime(m_zdcModuleCalibTime);
1592  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcModuleStatus(m_zdcModuleStatus);
1593  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleTime(m_zdcModuleTime);
1594  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleChisq(m_zdcModuleChisq);
1595  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitAmp(m_zdcModuleFitAmp);
1596  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitAmpError(m_zdcModuleFitAmpError);
1597  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitT0(m_zdcModuleFitT0);
1598  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleBkgdMaxFraction(m_zdcModuleBkgdMaxFraction);
1599  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModulePreSampleAmp(m_zdcModulePreSampleAmp);
1600  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModulePresample(m_zdcModulePresample);
1601  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMinDeriv2nd(m_zdcModuleMinDeriv2nd);
1602  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMaxADC(m_zdcModuleMaxADC);
1603  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelBaseline(m_rpdChannelBaseline);
1604  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,std::vector<float>> rpdChannelPileupExpFitParams(m_rpdChannelPileupExpFitParams);
1605  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,std::vector<float>> rpdChannelPileupStretchedExpFitParams(m_rpdChannelPileupStretchedExpFitParams);
1606  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,std::vector<float>> rpdChannelPileupExpFitParamErrs(m_rpdChannelPileupExpFitParamErrs);
1607  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,std::vector<float>> rpdChannelPileupStretchedExpFitParamErrs(m_rpdChannelPileupStretchedExpFitParamErrs);
1608  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelPileupExpFitMSE(m_rpdChannelPileupExpFitMSE);
1609  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelPileupStretchedExpFitMSE(m_rpdChannelPileupStretchedExpFitMSE);
1610  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelAmplitude(m_rpdChannelAmplitude);
1611  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelAmplitudeCalib(m_rpdChannelAmplitudeCalib);
1612  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelMaxADC(m_rpdChannelMaxADC);
1613  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelMaxADCCalib(m_rpdChannelMaxADCCalib);
1614  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> rpdChannelMaxSample(m_rpdChannelMaxSample);
1615  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> rpdChannelStatus(m_rpdChannelStatus);
1616  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelPileupFrac(m_rpdChannelPileupFrac);
1617 
1618  // CalibTime
1619  // Status
1620  // Time
1621  // Chisq
1622  // FitAmp
1623  // FitAmpError
1624  // FitT0
1625  // BkgdMaxFraction
1626  // PreSampleAmp
1627  // Presample
1628  // MinDeriv2nd
1629  // MaxADC
1630 
1631  for (const auto zdcModule : moduleContainer)
1632  {
1633  int side = (zdcModule->zdcSide() == -1) ? 0 : 1 ;
1634  int mod = zdcModule->zdcModule();
1635  // Ignore MC only modules
1636  if(mod > 4) continue;
1637 
1638  if (zdcModule->zdcType() == 1 && m_LHCRun==3) {
1639  // this is the RPD
1640  if (m_writeAux) {
1641  int rpdChannel = zdcModule->zdcChannel(); // channel numbers are fixed in mapping, numbered 0-15
1642  rpdChannelBaseline(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChBaseline(rpdChannel);
1643  rpdChannelPileupExpFitParams(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupExpFitParams(rpdChannel);
1644  rpdChannelPileupStretchedExpFitParams(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupStretchedExpFitParams(rpdChannel);
1645  rpdChannelPileupExpFitParamErrs(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupExpFitParamErrs(rpdChannel);
1646  rpdChannelPileupStretchedExpFitParamErrs(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupStretchedExpFitParamErrs(rpdChannel);
1647  rpdChannelPileupExpFitMSE(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupExpFitMSE(rpdChannel);
1648  rpdChannelPileupStretchedExpFitMSE(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupStretchedExpFitMSE(rpdChannel);
1649  rpdChannelAmplitude(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChSumAdc(rpdChannel);
1650  rpdChannelAmplitudeCalib(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChSumAdcCalib(rpdChannel);
1651  rpdChannelMaxADC(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChMaxAdc(rpdChannel);
1652  rpdChannelMaxADCCalib(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChMaxAdcCalib(rpdChannel);
1653  rpdChannelMaxSample(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChMaxSample(rpdChannel);
1654  rpdChannelStatus(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChStatus(rpdChannel);
1655  rpdChannelPileupFrac(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupFrac(rpdChannel);
1656  }
1657  } else if (zdcModule->zdcType() == 0) {
1658  // this is the main ZDC
1659  if (m_writeAux) {
1660  if (m_doCalib) {
1661  float calibEnergy = m_zdcDataAnalyzer->GetModuleCalibAmplitude(side, mod);
1662  zdcModuleCalibEnergy(*zdcModule) = calibEnergy;
1663  zdcModuleCalibTime(*zdcModule) = m_zdcDataAnalyzer->GetModuleCalibTime(side, mod);
1664  }
1665  else
1666  {
1667  zdcModuleCalibEnergy(*zdcModule) = -1000;
1668  zdcModuleCalibTime(*zdcModule) = -1000;
1669  }
1670 
1671  zdcModuleAmplitude(*zdcModule) = m_zdcDataAnalyzer->GetModuleAmplitude(side, mod);
1672  zdcModuleStatus(*zdcModule) = m_zdcDataAnalyzer->GetModuleStatus(side, mod);
1673  zdcModuleTime(*zdcModule) = m_zdcDataAnalyzer->GetModuleTime(side, mod);
1674 
1675  const ZDCPulseAnalyzer* pulseAna_p = m_zdcDataAnalyzer->GetPulseAnalyzer(side, mod);
1676  zdcModuleChisq(*zdcModule) = pulseAna_p->GetChisq();
1677  zdcModuleFitAmp(*zdcModule) = pulseAna_p->GetFitAmplitude();
1678  zdcModuleFitAmpError(*zdcModule) = pulseAna_p->GetAmpError();
1679  zdcModuleFitT0(*zdcModule) = pulseAna_p->GetFitT0();
1680  zdcModuleBkgdMaxFraction(*zdcModule) = pulseAna_p->GetBkgdMaxFraction();
1681  zdcModulePreSampleAmp(*zdcModule) = pulseAna_p->GetPreSampleAmp();
1682  zdcModulePresample(*zdcModule) = pulseAna_p->GetPresample();
1683  zdcModuleMinDeriv2nd(*zdcModule) = pulseAna_p->GetMinDeriv2nd();
1684  zdcModuleMaxADC(*zdcModule) = pulseAna_p->GetMaxADC();
1685  }
1686  //ATH_MSG_DEBUG ("side = " << side << " module=" << zdcModule->zdcModule() << " CalibEnergy=" << zdcModule->auxdecor<float>("CalibEnergy")
1687  // << " should be " << m_zdcDataAnalyzer->GetModuleCalibAmplitude(side, mod));
1688  }
1689  }
1690 
1691  // Output sum information
1692  // In Run 3 - we have to assume the container already exists (since it is needed to store the per-side trigger info)
1693  // reprocessing will add new variables with the suffix
1694 
1695  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumUncalibSum(m_zdcSumUncalibSum);
1696  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumUncalibSumErr(m_zdcSumUncalibSumErr);
1697  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumCalibEnergy(m_zdcSumCalibEnergy);
1698  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumCalibEnergyErr(m_zdcSumCalibEnergyErr);
1699  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumFinalEnergy(m_zdcSumFinalEnergy);
1700  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumAverageTime(m_zdcSumAverageTime);
1701  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcSumStatus(m_zdcSumStatus);
1702  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcSumModuleMask(m_zdcSumModuleMask);
1703  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcSumRPDStatus(m_zdcSumRPDStatus);
1704 
1705  for (const auto zdc_sum: moduleSumContainer)
1706  {
1707  ATH_MSG_DEBUG("Extracting ZDC side " << zdc_sum->zdcSide());
1708 
1709  if (zdc_sum->zdcSide()==0) continue; // skip new global sum
1710 
1711  int iside = (zdc_sum->zdcSide()==-1) ? 0 : 1;
1712 
1713  float uncalibSum = getUncalibModuleSum(iside);
1714  zdcSumUncalibSum(*zdc_sum) = uncalibSum;
1715  float uncalibSumErr = getUncalibModuleSumErr(iside);
1716  zdcSumUncalibSumErr(*zdc_sum) = uncalibSumErr;
1717 
1718  float calibEnergy = getCalibModuleSum(iside);
1719  zdcSumCalibEnergy(*zdc_sum) = calibEnergy;
1720  float calibEnergyErr = getCalibModuleSumErr(iside);
1721  zdcSumCalibEnergyErr(*zdc_sum) = calibEnergyErr;
1722 
1723  float finalEnergy = calibEnergy;
1724  zdcSumFinalEnergy(*zdc_sum) = finalEnergy;
1725  zdcSumAverageTime(*zdc_sum) = getAverageTime(iside);
1726  zdcSumStatus(*zdc_sum) = !sideFailed(iside);
1727  zdcSumModuleMask(*zdc_sum) = (getModuleMask() >> (4 * iside)) & 0xF;
1728  if (m_LHCRun==3)
1729  {
1730  zdcSumRPDStatus(*zdc_sum) = m_rpdDataAnalyzer.at(iside)->getSideStatus();
1731  }
1732  }
1733 
1734  return StatusCode::SUCCESS;
1735 }

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

1878 {
1879  if (!m_init)
1880  {
1881  ATH_MSG_WARNING("Tool not initialized!");
1882  return StatusCode::FAILURE;
1883  }
1884  m_eventReady = false;
1885  ATH_MSG_DEBUG ("Trying to retrieve " << m_zdcModuleContainerName);
1886 
1887  m_zdcModules = 0;
1888  ATH_CHECK(evtStore()->retrieve(m_zdcModules, m_zdcModuleContainerName));
1889 
1890  m_zdcSums = 0;
1891  ATH_CHECK(evtStore()->retrieve(m_zdcSums, m_zdcSumContainerName));
1892 
1893  m_eventReady = true;
1894 
1895  ATH_CHECK(recoZdcModules(*m_zdcModules, *m_zdcSums));
1896 
1897  return StatusCode::SUCCESS;
1898 }

◆ SetDebugLevel()

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

Definition at line 77 of file ZdcAnalysisTool.h.

78  {
79  s_debugLevel = debugLevel;
80  }

◆ setEnergyCalibrations()

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

Definition at line 1737 of file ZdcAnalysisTool.cxx.

1738 {
1739 
1740  char name[128];
1741 
1742  std::string filename;
1743  if (m_LHCRun==3)
1744  {
1745  filename = PathResolverFindCalibFile( ("ZdcAnalysis/ZdcCalib_Run"+TString::Itoa(runNumber,10)+".root").Data() );
1746  }
1747  else if (m_LHCRun==2)
1748  {
1749  filename = PathResolverFindCalibFile( ("ZdcAnalysis/" + m_zdcEnergyCalibFileName).c_str() );
1750  }
1751  else
1752  {
1753  ATH_MSG_WARNING("No LHC Run defined, so no calibration allowed");
1754  return;
1755  }
1756 
1757  ATH_MSG_INFO("Opening energy calibration file " << filename);
1758  std::unique_ptr<TFile> fCalib (TFile::Open(filename.c_str(), "READ"));
1759 
1760  if (fCalib == nullptr || fCalib->IsZombie())
1761  {
1762  ATH_MSG_INFO ("failed to open file: " << filename);
1763  throw std::runtime_error ("failed to open file " + filename);
1764  }
1765 
1766  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> splines;
1767 
1768  // "m_calibVersion", called CalibVersion when settings parameters in python, is a directory within the run-based calibration file
1769  TString calibVersion;
1770  if (m_calibVersion != "") calibVersion = m_calibVersion + "/";
1771 
1772  for (int iside = 0; iside < 2; iside++)
1773  {
1774  for (int imod = 0; imod < 4; imod++)
1775  {
1776  sprintf(name, "ZDC_Ecalib_run%u_s%d_m%d", runNumber, iside, imod);
1777  ATH_MSG_DEBUG("Searching for spline " << name);
1778  TSpline3* s = (TSpline3*) fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3");
1779  if (!s && m_doCalib)
1780  {
1781  ATH_MSG_WARNING("No calibrations for run " << runNumber);
1782  m_doCalib = false;
1783  }
1784 
1785  if (s)
1786  {
1787  splines[iside][imod].reset (s);
1788  }
1789  else
1790  {
1791  ATH_MSG_WARNING("No spline " << name);
1792  }
1793  }
1794  }
1795  fCalib->Close();
1796 
1797  if (m_doCalib) m_zdcDataAnalyzer->LoadEnergyCalibrations(splines);
1798 
1799  return;
1800 }

◆ setTimeCalibrations()

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

Definition at line 1802 of file ZdcAnalysisTool.cxx.

1803 {
1804  std::string filename;
1805 
1806  if (m_LHCRun==3)
1807  {
1808  filename = PathResolverFindCalibFile( ("ZdcAnalysis/ZdcCalib_Run"+TString::Itoa(runNumber,10)+".root").Data() );
1809  }
1810  else if (m_LHCRun==2)
1811  {
1812  filename = PathResolverFindCalibFile( "ZdcAnalysis/" + m_zdcTimeCalibFileName );
1813  }
1814  else
1815  {
1816  ATH_MSG_WARNING("No LHC Run defined, so no time calibration allowed");
1817  return;
1818  }
1819 
1820  char name[128] = {0};
1821  ATH_MSG_INFO("Opening time calibration file " << filename);
1822  std::unique_ptr<TFile> fCalib (TFile::Open(filename.c_str(), "READ"));
1823 
1824  // "m_calibVersion", called CalibVersion when settings parameters in python, is a directory within the run-based calibration file
1825  TString calibVersion = "";
1826  if (m_calibVersion != "") calibVersion = m_calibVersion + "/";
1827 
1828  if (fCalib && !fCalib->IsZombie())
1829  {
1830  bool success = true;
1831  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> T0HGOffsetSplines;
1832  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> T0LGOffsetSplines;
1833  std::unique_ptr<TSpline3> spline;
1834  for (int iside = 0; iside < 2; iside++)
1835  {
1836  for (int imod = 0; imod < 4; imod++)
1837  {
1838  sprintf(name, "ZDC_T0calib_run%u_HG_s%d_m%d", runNumber, iside, imod);
1839  spline.reset (static_cast<TSpline3*>(fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3")));
1840  if (spline)
1841  {
1842  T0HGOffsetSplines[iside][imod] = std::move (spline);
1843  }
1844  else
1845  {
1846  ATH_MSG_WARNING("No time calib. spline " << calibVersion+name);
1847  success = false;
1848  }
1849 
1850  sprintf(name, "ZDC_T0calib_run%u_LG_s%d_m%d", runNumber, iside, imod);
1851  spline.reset (static_cast<TSpline3*>(fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3")));
1852  if (spline)
1853  {
1854  T0LGOffsetSplines[iside][imod] = std::move (spline);
1855  }
1856  else
1857  {
1858  ATH_MSG_WARNING("No time calib. spline " << calibVersion+name);
1859  success = false;
1860  }
1861  }
1862  }
1863 
1864  if (success)
1865  m_zdcDataAnalyzer->LoadT0Calibrations(T0HGOffsetSplines, T0LGOffsetSplines);
1866  else
1867  ATH_MSG_WARNING("Time calibration failed - no T0 offsets loaded " << calibVersion+name);
1868 
1869  fCalib->Close();
1870  }
1871  else
1872  {
1873  ATH_MSG_WARNING("No time calibration file " << filename);
1874  }
1875 }

◆ sideFailed()

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

Definition at line 1978 of file ZdcAnalysisTool.cxx.

1979 {
1980  if (!m_zdcDataAnalyzer) return 0;
1981  return m_zdcDataAnalyzer->SideFailed(side);
1982 }

◆ sigprocMaxFinder()

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

Definition at line 1900 of file ZdcAnalysisTool.cxx.

1901 {
1902  size_t nsamp = adc.size();
1903  float presamp = adc.at(0);
1904  unsigned short max_adc = 0;
1905  int max_index = -1;
1906  for (size_t i = 0; i < nsamp; i++)
1907  {
1908  if (adc[i] > max_adc)
1909  {
1910  max_adc = adc[i];
1911  max_index = i;
1912  }
1913  }
1914  amp = max_adc - presamp;
1915  time = max_index * deltaT;
1916  qual = 1.;
1917 
1918  if (max_index == -1)
1919  {
1920  qual = 0.;
1921  return false;
1922  }
1923 
1924  return true;
1925 }

◆ sigprocSincInterp()

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

Definition at line 1927 of file ZdcAnalysisTool.cxx.

1928 {
1929  size_t nsamp = adc.size();
1930  float presamp = adc.at(0);
1931  m_tf1SincInterp->SetParameter(0, deltaT);
1932  for (size_t i = 0; i < nsamp; i++)
1933  {
1934  m_tf1SincInterp->SetParameter(i + 1, adc.at(i) - presamp);
1935  }
1936  amp = m_tf1SincInterp->GetMaximum();
1937  time = m_tf1SincInterp->GetMaximumX();
1938  qual = 1.;
1939  return true;
1940 }

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

◆ m_lowGainOnly

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

◆ m_peak2ndDerivMinThresholdsHG

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

Definition at line 202 of file ZdcAnalysisTool.h.

◆ m_peak2ndDerivMinThresholdsLG

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

Definition at line 203 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_rpdAdcOverflow

unsigned int ZDC::ZdcAnalysisTool::m_rpdAdcOverflow
private

Definition at line 187 of file ZdcAnalysisTool.h.

◆ m_rpdChannelAmplitude

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelAmplitude {this, "RPDChannelAmplitude", "", "RPD channel sum ADC (baseline and pileup subtracted)"}
private

Definition at line 234 of file ZdcAnalysisTool.h.

◆ m_rpdChannelAmplitudeCalib

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelAmplitudeCalib {this, "RPDChannelAmplitudeCalib", "", "RPD channel sum ADC (baseline and pileup subtracted) with output calibration factors applied"}
private

Definition at line 235 of file ZdcAnalysisTool.h.

◆ m_rpdChannelBaseline

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelBaseline {this, "RPDChannelBaseline", "", "RPD channel baseline"}
private

Definition at line 227 of file ZdcAnalysisTool.h.

◆ m_rpdChannelMaxADC

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelMaxADC {this, "RPDChannelMaxADC", "", "RPD channel max ADC (baseline and pileup subtracted)"}
private

Definition at line 236 of file ZdcAnalysisTool.h.

◆ m_rpdChannelMaxADCCalib

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelMaxADCCalib {this, "RPDChannelMaxADCCalib", "", "RPD channel max ADC (baseline and pileup subtracted) with output calibration factors applied"}
private

Definition at line 237 of file ZdcAnalysisTool.h.

◆ m_rpdChannelMaxSample

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelMaxSample {this, "RPDChannelMaxSample", "", "RPD channel max sample"}
private

Definition at line 238 of file ZdcAnalysisTool.h.

◆ m_rpdChannelPileupExpFitMSE

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelPileupExpFitMSE {this, "RPDChannelPileupExpFitMSE", "", "RPD Channel pileup exponential fit mean squared error in baseline samples"}
private

Definition at line 232 of file ZdcAnalysisTool.h.

◆ m_rpdChannelPileupExpFitParamErrs

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelPileupExpFitParamErrs {this, "RPDChannelPileupExpFitParamErrs", "", "RPD channel pileup exponential fit parameter errors"}
private

Definition at line 230 of file ZdcAnalysisTool.h.

◆ m_rpdChannelPileupExpFitParams

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelPileupExpFitParams {this, "RPDChannelPileupExpFitParams", "", "RPD channel pileup exponential fit parameters: exp( [0] + [1]*sample )"}
private

Definition at line 228 of file ZdcAnalysisTool.h.

◆ m_rpdChannelPileupFrac

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelPileupFrac {this, "RPDChannelPileupFrac", "", "RPD channel pileup as fraction of total (nominal baseline-subtracted) sum ADC"}
private

Definition at line 240 of file ZdcAnalysisTool.h.

◆ m_rpdChannelPileupStretchedExpFitMSE

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelPileupStretchedExpFitMSE {this, "RPDChannelPileupStretchedExpFitMSE", "", "RPD channel pileup stretched exponential fit mean squared error in baseline samples"}
private

Definition at line 233 of file ZdcAnalysisTool.h.

◆ m_rpdChannelPileupStretchedExpFitParamErrs

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelPileupStretchedExpFitParamErrs {this, "RPDChannelPileupStretchedExpFitParamErrs", "", "RPD channel pileup stretched exponential fit parameter errors"}
private

Definition at line 231 of file ZdcAnalysisTool.h.

◆ m_rpdChannelPileupStretchedExpFitParams

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelPileupStretchedExpFitParams {this, "RPDChannelPileupStretchedExpFitParams", "", "RPD channel pileup stretched exponential fit parameters: exp( [0] + [1]*(sample + 4)**0.5 + [2]*(sample + 4)**-0.5 )"}
private

Definition at line 229 of file ZdcAnalysisTool.h.

◆ m_rpdChannelStatus

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_rpdChannelStatus {this, "RPDChannelStatus", "", "RPD channel status"}
private

Definition at line 239 of file ZdcAnalysisTool.h.

◆ m_rpdDataAnalyzer

std::vector<std::unique_ptr<RPDDataAnalyzer> > ZDC::ZdcAnalysisTool::m_rpdDataAnalyzer
private

Definition at line 199 of file ZdcAnalysisTool.h.

◆ m_rpdEndSignalSample

unsigned int ZDC::ZdcAnalysisTool::m_rpdEndSignalSample
private

Definition at line 178 of file ZdcAnalysisTool.h.

◆ m_rpdGoodPulseSampleStart

unsigned int ZDC::ZdcAnalysisTool::m_rpdGoodPulseSampleStart
private

Definition at line 181 of file ZdcAnalysisTool.h.

◆ m_rpdGoodPulseSampleStop

unsigned int ZDC::ZdcAnalysisTool::m_rpdGoodPulseSampleStop
private

Definition at line 182 of file ZdcAnalysisTool.h.

◆ m_rpdNbaselineSamples

unsigned int ZDC::ZdcAnalysisTool::m_rpdNbaselineSamples
private

Definition at line 177 of file ZdcAnalysisTool.h.

◆ m_rpdNNegativesAllowed

unsigned int ZDC::ZdcAnalysisTool::m_rpdNNegativesAllowed
private

Definition at line 186 of file ZdcAnalysisTool.h.

◆ m_rpdNominalBaseline

unsigned int ZDC::ZdcAnalysisTool::m_rpdNominalBaseline
private

Definition at line 183 of file ZdcAnalysisTool.h.

◆ m_rpdPileupBaselineStdDevThresh

float ZDC::ZdcAnalysisTool::m_rpdPileupBaselineStdDevThresh
private

Definition at line 185 of file ZdcAnalysisTool.h.

◆ m_rpdPileupBaselineSumThresh

float ZDC::ZdcAnalysisTool::m_rpdPileupBaselineSumThresh
private

Definition at line 184 of file ZdcAnalysisTool.h.

◆ m_rpdPostPulseFracThresh

float ZDC::ZdcAnalysisTool::m_rpdPostPulseFracThresh
private

Definition at line 180 of file ZdcAnalysisTool.h.

◆ m_rpdPulse2ndDerivThresh

float ZDC::ZdcAnalysisTool::m_rpdPulse2ndDerivThresh
private

Definition at line 179 of file ZdcAnalysisTool.h.

◆ m_rpdSideAOutputCalibFactors

std::vector<float> ZDC::ZdcAnalysisTool::m_rpdSideAOutputCalibFactors
private

Definition at line 189 of file ZdcAnalysisTool.h.

◆ m_rpdSideCOutputCalibFactors

std::vector<float> ZDC::ZdcAnalysisTool::m_rpdSideCOutputCalibFactors
private

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

◆ m_zdcDataAnalyzer_40MHz

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

Definition at line 196 of file ZdcAnalysisTool.h.

◆ m_zdcDataAnalyzer_80MHz

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

Definition at line 197 of file ZdcAnalysisTool.h.

◆ m_zdcEnergyCalibFileName

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

Definition at line 130 of file ZdcAnalysisTool.h.

◆ m_zdcModuleAmplitude

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

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

◆ m_zdcModuleCalibEnergy

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

Definition at line 213 of file ZdcAnalysisTool.h.

◆ m_zdcModuleCalibTime

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

Definition at line 214 of file ZdcAnalysisTool.h.

◆ m_zdcModuleChisq

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

Definition at line 217 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 218 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 219 of file ZdcAnalysisTool.h.

◆ m_zdcModuleFitT0

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

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

◆ m_zdcModulePresample

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

Definition at line 223 of file ZdcAnalysisTool.h.

◆ m_zdcModulePreSampleAmp

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

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

◆ m_zdcModuleTime

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

Definition at line 216 of file ZdcAnalysisTool.h.

◆ m_zdcSumAverageTime

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

Definition at line 248 of file ZdcAnalysisTool.h.

◆ m_zdcSumCalibEnergy

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

Definition at line 245 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 246 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 247 of file ZdcAnalysisTool.h.

◆ m_zdcSumModuleMask

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

Definition at line 250 of file ZdcAnalysisTool.h.

◆ m_zdcSumRPDStatus

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::ZdcAnalysisTool::m_zdcSumRPDStatus {this, "ZdcSumRPDStatus", "", "RPD side level status"}
private

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

◆ m_zdcSumUncalibSum

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

Definition at line 243 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 244 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 206 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 208 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:82
ZDC::ZdcAnalysisTool::m_rpdGoodPulseSampleStop
unsigned int m_rpdGoodPulseSampleStop
Definition: ZdcAnalysisTool.h:182
ZDC::ZdcAnalysisTool::m_zdcModuleContainerName
std::string m_zdcModuleContainerName
Definition: ZdcAnalysisTool.h:148
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:201
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
ZDC::ZdcAnalysisTool::m_runNumber
unsigned int m_runNumber
Definition: ZdcAnalysisTool.h:138
ZDC::ZdcAnalysisTool::m_Peak2ndDerivThresh
float m_Peak2ndDerivThresh
Definition: ZdcAnalysisTool.h:167
ZDC::ZdcAnalysisTool::m_rpdPostPulseFracThresh
float m_rpdPostPulseFracThresh
Definition: ZdcAnalysisTool.h:180
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:217
ZDC::ZdcAnalysisTool::m_rpdChannelPileupExpFitParams
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupExpFitParams
Definition: ZdcAnalysisTool.h:228
ZDC::ZdcAnalysisTool::m_zdcModules
const xAOD::ZdcModuleContainer * m_zdcModules
Definition: ZdcAnalysisTool.h:149
ZDC::ZdcAnalysisTool::m_rpdNominalBaseline
unsigned int m_rpdNominalBaseline
Definition: ZdcAnalysisTool.h:183
ZDC::ZdcAnalysisTool::m_zdcModuleCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibEnergy
Definition: ZdcAnalysisTool.h:213
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinThresholdsLG
ZDCDataAnalyzer::ZDCModuleFloatArray m_peak2ndDerivMinThresholdsLG
Definition: ZdcAnalysisTool.h:203
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:191
ZDCDataAnalyzer::ZDCModuleFloatArray
std::array< std::array< float, 4 >, 2 > ZDCModuleFloatArray
Definition: ZDCDataAnalyzer.h:22
ZDCPulseAnalyzer::GetAmpError
float GetAmpError() const
Definition: ZDCPulseAnalyzer.h:535
Data
@ Data
Definition: BaseObject.h:11
ZDC::ZdcAnalysisTool::m_rpdAdcOverflow
unsigned int m_rpdAdcOverflow
Definition: ZdcAnalysisTool.h:187
ZDC::ZdcAnalysisTool::m_rpdChannelBaseline
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelBaseline
Definition: ZdcAnalysisTool.h:227
ZDC::ZdcAnalysisTool::m_fixTau1
bool m_fixTau1
Definition: ZdcAnalysisTool.h:172
ZDC::ZdcAnalysisTool::m_rpdEndSignalSample
unsigned int m_rpdEndSignalSample
Definition: ZdcAnalysisTool.h:178
ZDC::ZdcAnalysisTool::m_rpdChannelPileupStretchedExpFitParams
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupStretchedExpFitParams
Definition: ZdcAnalysisTool.h:229
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:218
ZDC::ZdcAnalysisTool::getUncalibModuleSumErr
float getUncalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:1966
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:73
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
ZDCDataAnalyzer::ZDCModuleIntArray
std::array< std::array< int, 4 >, 2 > ZDCModuleIntArray
Definition: ZDCDataAnalyzer.h:24
ZDC::ZdcAnalysisTool::m_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_rpdChannelMaxADC
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelMaxADC
Definition: ZdcAnalysisTool.h:236
ZDC::ZdcAnalysisTool::m_rpdNbaselineSamples
unsigned int m_rpdNbaselineSamples
Definition: ZdcAnalysisTool.h:177
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:250
ZDCPulseAnalyzer
Definition: ZDCPulseAnalyzer.h:24
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:54
ZDCPulseAnalyzer::GetPresample
float GetPresample() const
Definition: ZDCPulseAnalyzer.h:539
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ZDC::ZdcAnalysisTool::m_zdcModuleStatus
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleStatus
Definition: ZdcAnalysisTool.h:215
ZDC::ZdcAnalysisTool::m_zdcSumAverageTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumAverageTime
Definition: ZdcAnalysisTool.h:248
ZDC::ZdcAnalysisTool::m_rpdChannelAmplitude
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelAmplitude
Definition: ZdcAnalysisTool.h:234
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_rpdSideCOutputCalibFactors
std::vector< float > m_rpdSideCOutputCalibFactors
Definition: ZdcAnalysisTool.h:188
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:291
ZDC::ZdcAnalysisTool::m_rpdChannelMaxSample
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelMaxSample
Definition: ZdcAnalysisTool.h:238
ZDC::ZdcAnalysisTool::m_rpdChannelPileupStretchedExpFitParamErrs
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupStretchedExpFitParamErrs
Definition: ZdcAnalysisTool.h:231
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:249
ZDC::ZdcAnalysisTool::m_zdcModuleAmplitude
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmplitude
Definition: ZdcAnalysisTool.h:212
ZDC::ZdcAnalysisTool::sideFailed
bool sideFailed(int side)
Definition: ZdcAnalysisTool.cxx:1978
ZDC::ZdcAnalysisTool::getModuleSum
float getModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:1942
ZDC::ZdcAnalysisTool::initializepp2023
std::unique_ptr< ZDCDataAnalyzer > initializepp2023()
Definition: ZdcAnalysisTool.cxx:318
ZDC::ZdcAnalysisTool::m_zdcSumFinalEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumFinalEnergy
Definition: ZdcAnalysisTool.h:247
python.PyAthena.module
module
Definition: PyAthena.py:134
ZDC::ZdcAnalysisTool::m_lumiBlock
unsigned int m_lumiBlock
Definition: ZdcAnalysisTool.h:139
ZDCPulseAnalyzer::TimingCorrLog
@ TimingCorrLog
Definition: ZDCPulseAnalyzer.h:51
ZDC::ZdcAnalysisTool::setEnergyCalibrations
void setEnergyCalibrations(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:1737
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
ZDC::ZdcAnalysisTool::m_rpdPulse2ndDerivThresh
float m_rpdPulse2ndDerivThresh
Definition: ZdcAnalysisTool.h:179
ZDC::ZdcAnalysisTool::m_rpdPileupBaselineSumThresh
float m_rpdPileupBaselineSumThresh
Definition: ZdcAnalysisTool.h:184
ZDC::ZdcAnalysisTool::getCalibModuleSumErr
float getCalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:1954
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_rpdChannelPileupExpFitParamErrs
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupExpFitParamErrs
Definition: ZdcAnalysisTool.h:230
ZDC::ZdcAnalysisTool::m_zdcSumUncalibSum
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumUncalibSum
Definition: ZdcAnalysisTool.h:243
ZDCDataAnalyzer::SetNoiseSigmas
void SetNoiseSigmas(const ZDCModuleFloatArray &noiseSigmasHG, const ZDCModuleFloatArray &noiseSigmasLG)
Definition: ZDCDataAnalyzer.cxx:243
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
lumiFormat.i
int i
Definition: lumiFormat.py:92
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:724
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:425
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:99
ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer_80MHz
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer_80MHz
Definition: ZdcAnalysisTool.h:197
ZDCDataAnalyzer::SetADCOverUnderflowValues
void SetADCOverUnderflowValues(const ZDCModuleFloatArray &HGOverflowADC, const ZDCModuleFloatArray &HGUnderflowADC, const ZDCModuleFloatArray &LGOverflowADC)
Definition: ZDCDataAnalyzer.cxx:281
file
TFile * file
Definition: tile_monitor.h:29
ZDC::ZdcAnalysisTool::m_zdcModuleMaxADC
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMaxADC
Definition: ZdcAnalysisTool.h:225
ZDC::ZdcAnalysisTool::m_rpdNNegativesAllowed
unsigned int m_rpdNNegativesAllowed
Definition: ZdcAnalysisTool.h:186
ZDC::ZdcAnalysisTool::m_zdcModuleFitT0
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitT0
Definition: ZdcAnalysisTool.h:220
ZDC::ZdcAnalysisTool::recoZdcModules
StatusCode recoZdcModules(const xAOD::ZdcModuleContainer &moduleContainer, const xAOD::ZdcModuleContainer &moduleSumContainer) override
Definition: ZdcAnalysisTool.cxx:1407
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:1984
DQHistogramMerge.debugLevel
debugLevel
Definition: DQHistogramMerge.py:40
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
ZDCPulseAnalyzer::TimingCorrLin
@ TimingCorrLin
Definition: ZDCPulseAnalyzer.h:51
ZDC::ZdcAnalysisTool::m_zdcModuleMinDeriv2nd
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMinDeriv2nd
Definition: ZdcAnalysisTool.h:224
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:231
ZDC::ZdcAnalysisTool::m_zdcModuleBkgdMaxFraction
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleBkgdMaxFraction
Definition: ZdcAnalysisTool.h:221
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:195
ZDC::ZdcAnalysisTool::setTimeCalibrations
void setTimeCalibrations(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:1802
ZDC::ZdcAnalysisTool::m_tau2
float m_tau2
Definition: ZdcAnalysisTool.h:171
ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergyErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergyErr
Definition: ZdcAnalysisTool.h:246
ZDCDataAnalyzer::enableDelayed
void enableDelayed(float deltaT, const ZDCModuleFloatArray &undelayedDelayedPedestalDiff)
Definition: ZDCDataAnalyzer.cxx:108
ZDC::ZdcAnalysisTool::m_rpdPileupBaselineStdDevThresh
float m_rpdPileupBaselineStdDevThresh
Definition: ZdcAnalysisTool.h:185
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
ZDC::ZdcAnalysisTool::m_rpdChannelMaxADCCalib
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelMaxADCCalib
Definition: ZdcAnalysisTool.h:237
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_rpdChannelPileupFrac
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupFrac
Definition: ZdcAnalysisTool.h:240
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:192
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:214
ZDC::ZdcAnalysisTool::s_debugLevel
static std::atomic< int > s_debugLevel
Definition: ZdcAnalysisTool.h:208
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:518
ZDC::ZdcAnalysisTool::initializeLHCf2022
std::unique_ptr< ZDCDataAnalyzer > initializeLHCf2022()
Definition: ZdcAnalysisTool.cxx:210
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
RPDConfig
Definition: RPDDataAnalyzer.h:18
ZDCPulseAnalyzer::GetMinDeriv2nd
float GetMinDeriv2nd() const
Definition: ZDCPulseAnalyzer.h:555
ZDC::ZdcAnalysisTool::m_rpdSideAOutputCalibFactors
std::vector< float > m_rpdSideAOutputCalibFactors
Definition: ZdcAnalysisTool.h:189
ZDC::ZdcAnalysisTool::m_zdcTriggerEfficiency
std::shared_ptr< ZDCTriggerEfficiency > m_zdcTriggerEfficiency
Definition: ZdcAnalysisTool.h:206
ZDCPulseAnalyzer::GetFitT0
float GetFitT0() const
Definition: ZDCPulseAnalyzer.h:519
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
ZDC::ZdcAnalysisTool::m_zdcModuleFitAmpError
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmpError
Definition: ZdcAnalysisTool.h:219
ZDC::ZdcAnalysisTool::getAverageTime
float getAverageTime(int side)
Definition: ZdcAnalysisTool.cxx:1972
ZDC::ZdcAnalysisTool::m_rpdChannelStatus
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelStatus
Definition: ZdcAnalysisTool.h:239
a
TList * a
Definition: liststreamerinfos.cxx:10
ZDC::ZdcAnalysisTool::m_rpdChannelPileupExpFitMSE
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupExpFitMSE
Definition: ZdcAnalysisTool.h:232
h
ZDC::ZdcAnalysisTool::m_zdcModulePresample
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePresample
Definition: ZdcAnalysisTool.h:223
ZDCPulseAnalyzer::GetBkgdMaxFraction
float GetBkgdMaxFraction() const
Definition: ZDCPulseAnalyzer.h:561
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ZDC::ZdcAnalysisTool::initializeTriggerEffs
void initializeTriggerEffs(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:97
ZDC::ZdcAnalysisTool::m_zdcModuleTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleTime
Definition: ZdcAnalysisTool.h:216
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
ZDC::ZdcAnalysisTool::configureNewRun
StatusCode configureNewRun(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:1387
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:202
ZDC::ZdcAnalysisTool::initializeDefault
std::unique_ptr< ZDCDataAnalyzer > initializeDefault()
Definition: ZdcAnalysisTool.cxx:598
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:196
ZDCDataAnalyzer::SetFitTimeMax
void SetFitTimeMax(float tmax)
Definition: ZDCDataAnalyzer.cxx:217
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:616
ZDC::ZdcAnalysisTool::m_deltaTSample
float m_deltaTSample
Definition: ZdcAnalysisTool.h:164
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
ZDCPulseAnalyzer::GetMaxADC
float GetMaxADC() const
Definition: ZDCPulseAnalyzer.h:541
ZDC::ZdcAnalysisTool::m_zdcSumUncalibSumErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumUncalibSumErr
Definition: ZdcAnalysisTool.h:244
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:1948
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
ZDC::ZdcAnalysisTool::m_lowGainOnly
bool m_lowGainOnly
Definition: ZdcAnalysisTool.h:153
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
ZDC::ZdcAnalysisTool::m_zdcSumRPDStatus
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumRPDStatus
Definition: ZdcAnalysisTool.h:251
ZDC::ZdcAnalysisTool::initialize80MHz
void initialize80MHz()
Definition: ZdcAnalysisTool.cxx:1083
ZDCDataAnalyzer::enableRepass
void enableRepass(const ZDCModuleFloatArray &peak2ndDerivMinRepassHG, const ZDCModuleFloatArray &peak2ndDerivMinRepassLG)
Definition: ZDCDataAnalyzer.cxx:171
calibdata.copy
bool copy
Definition: calibdata.py:27
ZDC::ZdcAnalysisTool::initializePbPb2018
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2018()
Definition: ZdcAnalysisTool.cxx:836
ZDC::ZdcAnalysisTool::m_flipEMDelay
bool m_flipEMDelay
Definition: ZdcAnalysisTool.h:152
ZDC::ZdcAnalysisTool::m_zdcModulePreSampleAmp
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePreSampleAmp
Definition: ZdcAnalysisTool.h:222
ZDC::ZdcAnalysisTool::m_rpdDataAnalyzer
std::vector< std::unique_ptr< RPDDataAnalyzer > > m_rpdDataAnalyzer
Definition: ZdcAnalysisTool.h:199
ZDCDataAnalyzer::SetPeak2ndDerivMinTolerances
void SetPeak2ndDerivMinTolerances(size_t tolerance)
Definition: ZDCDataAnalyzer.cxx:208
ZDCPulseAnalyzer::GetChisq
float GetChisq() const
Definition: ZDCPulseAnalyzer.h:523
ZDC::ZdcAnalysisTool::initializePbPb2015G4
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2015G4()
Definition: ZdcAnalysisTool.cxx:661
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:226
ZDC::ZdcAnalysisTool::m_rpdChannelAmplitudeCalib
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelAmplitudeCalib
Definition: ZdcAnalysisTool.h:235
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:304
ZDC::ZdcAnalysisTool::m_auxSuffix
std::string m_auxSuffix
Definition: ZdcAnalysisTool.h:135
ZDC::ZdcAnalysisTool::initialize40MHz
void initialize40MHz()
Definition: ZdcAnalysisTool.cxx:963
ZDC::ZdcAnalysisTool::m_fixTau2
bool m_fixTau2
Definition: ZdcAnalysisTool.h:173
ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergy
Definition: ZdcAnalysisTool.h:245
fitman.k
k
Definition: fitman.py:528
ZDC::ZdcAnalysisTool::m_rpdChannelPileupStretchedExpFitMSE
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupStretchedExpFitMSE
Definition: ZdcAnalysisTool.h:233
ZDC::ZdcAnalysisTool::m_name
std::string m_name
Definition: ZdcAnalysisTool.h:126
ZDC::ZdcAnalysisTool::m_rpdGoodPulseSampleStart
unsigned int m_rpdGoodPulseSampleStart
Definition: ZdcAnalysisTool.h:181
ZDC::ZdcAnalysisTool::m_eventReady
bool m_eventReady
Definition: ZdcAnalysisTool.h:137
ZDCPulseAnalyzer::GetPreSampleAmp
float GetPreSampleAmp() const
Definition: ZDCPulseAnalyzer.h:560
ZDCDataAnalyzer::SetModuleAmpFractionLG
void SetModuleAmpFractionLG(const ZDCDataAnalyzer::ZDCModuleFloatArray &moduleAmpFractionLG)
Definition: ZDCDataAnalyzer.cxx:252
ZDC::ZdcAnalysisTool::getUncalibModuleSum
float getUncalibModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:1960
RPDConfig::nRows
unsigned int nRows
Definition: RPDDataAnalyzer.h:19
Generated on Fri Jun 28 2024 22:35:48 for ATLAS Offline Software by   doxygen 1.8.18