#include <RpdSubtractCentroidTool.h>

Inheritance diagram for ZDC::RpdSubtractCentroidTool:

Classes
struct	RPDChannelData

Public Types

enum {
ValidBit = 0 , HasCentroidBit = 1 , ZDCInvalidBit = 2 , InsufficientZDCEnergyBit = 3 ,
ExcessiveZDCEnergyBit = 4 , EMInvalidBit = 5 , InsufficientEMEnergyBit = 6 , ExcessiveEMEnergyBit = 7 ,
RPDInvalidBit = 8 , PileupBit = 9 , ExcessivePileupBit = 10 , ZeroSumBit = 11 ,
ExcessiveSubtrUnderflowBit = 12 , Row0ValidBit = 13 , Row1ValidBit = 14 , Row2ValidBit = 15 ,
Row3ValidBit = 16 , Col0ValidBit = 17 , Col1ValidBit = 18 , Col2ValidBit = 19 ,
Col3ValidBit = 20 , N_STATUS_BITS
}

Public Member Functions
	RpdSubtractCentroidTool (const std::string &name)
	~RpdSubtractCentroidTool () override=default
	RpdSubtractCentroidTool (RpdSubtractCentroidTool const &)=delete
RpdSubtractCentroidTool &	operator= (RpdSubtractCentroidTool const &)=delete
	RpdSubtractCentroidTool (RpdSubtractCentroidTool &&)=delete
RpdSubtractCentroidTool &	operator= (RpdSubtractCentroidTool &&)=delete
StatusCode	initialize () override
	Dummy implementation of the initialisation function.
StatusCode	recoZdcModules (const xAOD::ZdcModuleContainer &moduleContainer, const xAOD::ZdcModuleContainer &moduleSumContainer) override
StatusCode	reprocessZdc () override
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
enum class	SubstepStatus { Success , Failure , SkipEvent }
	cosine of difference between reaction plane angles of the two sides More...
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	initializeKey (std::string const &containerName, SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > &writeHandleKey, std::string const &key)
void	reset ()
SubstepStatus	readAOD (xAOD::ZdcModuleContainer const &moduleContainer, xAOD::ZdcModuleContainer const &moduleSumContainer)
bool	checkZdcRpdValidity (unsigned int side)
bool	subtractRpdAmplitudes (unsigned int side)
void	calculateDetectorCentroid (unsigned int side)
void	geometryCorrection (unsigned int side)
void	subtractAverageCentroid (unsigned int side)
void	calculateReactionPlaneAngle (unsigned int side)
void	writeAOD (xAOD::ZdcModuleContainer const &moduleSumContainer) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static bool	nonNegative (float const x)
static bool	anyNonNegative (std::vector< float > const &v)

Private Attributes
std::string	m_configuration
std::string	m_ZDCModuleContainerName
std::string	m_ZDCSumContainerName
bool	m_writeAux {}
std::string	m_auxSuffix
RPDUtils::OptionalToolProperty< std::vector< float > >	m_forceMinZDCEnergy
RPDUtils::OptionalToolProperty< std::vector< float > >	m_forceMaxZDCEnergy
RPDUtils::OptionalToolProperty< std::vector< float > >	m_forceMinEMEnergy
RPDUtils::OptionalToolProperty< std::vector< float > >	m_forceMaxEMEnergy
RPDUtils::OptionalToolProperty< std::vector< float > >	m_forcePileupMaxFrac
RPDUtils::OptionalToolProperty< std::vector< float > >	m_forceMaximumNegativeSubtrAmpFrac
RPDUtils::OptionalToolProperty< bool >	m_forceUseRPDSumAdc
RPDUtils::OptionalToolProperty< bool >	m_forceUseCalibDecorations
std::vector< float >	m_minZDCEnergy
std::vector< float >	m_maxZDCEnergy
std::vector< float >	m_minEMEnergy
std::vector< float >	m_maxEMEnergy
std::vector< float >	m_pileupMaxFrac
std::vector< float >	m_maximumNegativeSubtrAmpFrac
bool	m_useRPDSumAdc {}
bool	m_useCalibDecorations {}
bool	m_initialized = false
bool	m_readZDCDecorations = false
std::array< std::bitset< RPDDataAnalyzer::N_STATUS_BITS >, 2 >	m_RPDSideStatus {}
std::optional< std::array< unsigned int, 2 > >	m_ZDCSideStatus
	RPD analysis status word on each side.
std::optional< std::array< float, 2 > >	m_ZDCFinalEnergy
	ZDC analysis status on each side.
std::optional< std::array< float, 2 > >	m_EMCalibEnergy
	ZDC final (calibrated) energy on each side.
std::optional< std::array< std::bitset< ZDCPulseAnalyzer::N_STATUS_BITS >, 2 > >	m_EMStatus
	EM calibrated energy on each side.
std::array< std::array< std::array< RPDChannelData, RPDUtils::nCols >, RPDUtils::nRows >, 2 >	m_RPDChannelData {}
	EM modlue status word on each side.
std::array< float, 2 >	m_alignmentXOffset {}
	RPD channel data for each channel (first index row, then index column) on each side.
std::array< float, 2 >	m_alignmentYOffset {}
	geometry + crossing angle correction in x (ATLAS coordinates)
std::array< float, 2 >	m_avgXCentroid {}
	geometry + crossing angle correction in y (ATLAS coordinates)
std::array< float, 2 >	m_avgYCentroid {}
	average x centroid
bool	m_eventValid = false
	average y centroid
std::array< std::bitset< N_STATUS_BITS >, 2 >	m_centroidStatus {1 << ValidBit, 1 << ValidBit}
	event status
std::array< std::vector< float >, 2 >	m_subtrAmp
	centroid status (valid by default) on each side
std::array< std::array< float, RPDUtils::nRows >, 2 >	m_subtrAmpRowSum {}
	subtracted amplitude for each channel on each side
std::array< std::array< float, RPDUtils::nCols >, 2 >	m_subtrAmpColSum {}
	subtracted amplitude for each row on each side
std::array< float, 2 >	m_subtrAmpSum {}
	subtracted amplitude for each column on each side
std::array< float, 2 >	m_xCentroidPreGeomCorPreAvgSubtr {}
	subtracted amplitude sum on each side
std::array< float, 2 >	m_yCentroidPreGeomCorPreAvgSubtr {}
	x centroid before geomerty correction and before average subtraction (RPD detector coordinates) on each side
std::array< float, 2 >	m_xCentroidPreAvgSubtr {}
	y centroid before geomerty correction and before average subtraction (RPD detector coordinates) on each side
std::array< float, 2 >	m_yCentroidPreAvgSubtr {}
	x centroid after geomerty correction and before average subtraction on each side
std::array< float, 2 >	m_xCentroid {}
	y centroid after geomerty correction and before average subtraction on each side
std::array< float, 2 >	m_yCentroid {}
	x centroid after geomerty correction and after average subtraction on each side
std::array< std::vector< float >, 2 >	m_xRowCentroid
	y centroid after geomerty correction and after average subtraction on each side
std::array< std::vector< float >, 2 >	m_yColCentroid
	the x centroid for each row on each side
std::array< float, 2 >	m_reactionPlaneAngle {}
	the y centroid for each column on each side
float	m_cosDeltaReactionPlaneAngle = 0
	reaction plane angle on each side
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_centroidEventValidKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_centroidStatusKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_RPDChannelSubtrAmpKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_RPDSubtrAmpSumKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_xCentroidPreGeomCorPreAvgSubtrKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_yCentroidPreGeomCorPreAvgSubtrKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_xCentroidPreAvgSubtrKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_yCentroidPreAvgSubtrKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_xCentroidKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_yCentroidKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_xRowCentroidKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_yColCentroidKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_reactionPlaneAngleKey
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer >	m_cosDeltaReactionPlaneAngleKey
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 28 of file RpdSubtractCentroidTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
ValidBit
HasCentroidBit
ZDCInvalidBit
InsufficientZDCEnergyBit
ExcessiveZDCEnergyBit
EMInvalidBit
InsufficientEMEnergyBit
ExcessiveEMEnergyBit
RPDInvalidBit
PileupBit
ExcessivePileupBit
ZeroSumBit
ExcessiveSubtrUnderflowBit
Row0ValidBit
Row1ValidBit
Row2ValidBit
Row3ValidBit
Col0ValidBit
Col1ValidBit
Col2ValidBit
Col3ValidBit
N_STATUS_BITS

Definition at line 31 of file RpdSubtractCentroidTool.h.

       {
    ValidBit                     =  0, // analysis and output are valid
    HasCentroidBit               =  1, // centroid was calculated but analysis is invalid
    ZDCInvalidBit                =  2, // ZDC analysis on this side failed => analysis is invalid
    InsufficientZDCEnergyBit     =  3, // ZDC energy on this side is below minimum => analysis is invalid
    ExcessiveZDCEnergyBit        =  4, // ZDC energy on this side is above maximum => analysis is invalid
    EMInvalidBit                 =  5, // EM analysis on this side failed => analysis is invalid
    InsufficientEMEnergyBit      =  6, // EM energy on this side is below minimum => analysis is invalid
    ExcessiveEMEnergyBit         =  7, // EM energy on this side is above maximum => analysis is invalid
    RPDInvalidBit                =  8, // RPD analysis on this side was invalid => calculation stopped and analysis is invalid
    PileupBit                    =  9, // pileup was detected in RPD on this side
    ExcessivePileupBit           = 10, // pileup was detected in RPD on this side and a channel exceeded the fractional limit => analysis is invalid
    ZeroSumBit                   = 11, // sum of subtracted RPD amplitudes on this side was not positive => calculation stopped and analysis is invalid
    ExcessiveSubtrUnderflowBit   = 12, // a subtracted RPD amplitude on this side was negative and exceeded the fractional limit => analysis is invalid
 
    Row0ValidBit                 = 13, // row 0 x centroid is valid
    Row1ValidBit                 = 14, // row 1 x centroid is valid
    Row2ValidBit                 = 15, // row 2 x centroid is valid
    Row3ValidBit                 = 16, // row 3 x centroid is valid
    Col0ValidBit                 = 17, // column 0 y centroid is valid
    Col1ValidBit                 = 18, // column 1 y centroid is valid
    Col2ValidBit                 = 19, // column 2 y centroid is valid
    Col3ValidBit                 = 20, // column 3 y centroid is valid
 
    N_STATUS_BITS
  };

◆ SubstepStatus

enum class ZDC::RpdSubtractCentroidTool::SubstepStatus

strongprivate

cosine of difference between reaction plane angles of the two sides

Enumerator
Success
Failure
SkipEvent

Definition at line 169 of file RpdSubtractCentroidTool.h.

                           {
    Success, // continue to next step
    Failure, // stop (do not proceed to next step) and propagate error to Athena
    SkipEvent, // stop (do not proceed to next step) and tell Athena the event was a success
  };

Constructor & Destructor Documentation

◆ RpdSubtractCentroidTool() [1/3]

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

explicit

Definition at line 18 of file RpdSubtractCentroidTool.cxx.

  : asg::AsgTool(name)
{
  declareProperty("ZDCModuleContainerName", m_ZDCModuleContainerName = "ZdcModules", "Location of ZDC processed data");
  declareProperty("ZDCSumContainerName", m_ZDCSumContainerName = "ZdcSums", "Location of ZDC processed sums");
  declareProperty("Configuration", m_configuration = "default");
  declareProperty("WriteAux", m_writeAux = true, "If true, write AOD decorations");
  declareProperty("AuxSuffix", m_auxSuffix = "", "Suffix to add to AOD decorations for reading and writing");
  declareProperty("MinZDCEnergy", m_forceMinZDCEnergy, "Minimum (calibrated) ZDC energy for valid centroid (negative to disable); per side");
  declareProperty("MaxZDCEnergy", m_forceMaxZDCEnergy, "Maximum (calibrated) ZDC energy for valid centroid (negative to disable); per side");
  declareProperty("MinEMEnergy", m_forceMinEMEnergy, "Minimum (calibrated) EM energy for valid centroid (negative to disable); per side");
  declareProperty("MaxEMEnergy", m_forceMaxEMEnergy, "Minimum (calibrated) EM energy for valid centroid (negative to disable); per side");
  declareProperty("PileupMaxFrac", m_forcePileupMaxFrac, "Maximum fractional pileup allowed in an RPD channel for valid centroid; per side");
  declareProperty("ExcessiveSubtrUnderflowFrac", m_forceMaximumNegativeSubtrAmpFrac, "If any RPD channel subtracted amplitude is negative and its fraction of subtracted amplitude sum is greater than or equal to this number, the centroid is invalid; per side");
  declareProperty("UseRPDSumAdc", m_forceUseRPDSumAdc, "If true, use RPD channel sum ADC for centroid calculation, else use RPD channel max ADC");
  declareProperty("UseCalibDecorations", m_forceUseCalibDecorations, "If true, use RPD channel sum/max ADC decorations with output calibration factors applied during reconstruction, else use decorations with raw values");
}

◆ ~RpdSubtractCentroidTool()

ZDC::RpdSubtractCentroidTool::~RpdSubtractCentroidTool ( )

overridedefault

◆ RpdSubtractCentroidTool() [2/3]

ZDC::RpdSubtractCentroidTool::RpdSubtractCentroidTool ( RpdSubtractCentroidTool const & )

delete

◆ RpdSubtractCentroidTool() [3/3]

ZDC::RpdSubtractCentroidTool::RpdSubtractCentroidTool ( RpdSubtractCentroidTool && )

delete

Member Function Documentation

◆ anyNonNegative()

bool ZDC::RpdSubtractCentroidTool::anyNonNegative ( std::vector< float > const & v )

inlinestaticprivate

Definition at line 101 of file RpdSubtractCentroidTool.h.

101{ return std::any_of(v.begin(), v.end(), nonNegative); }

ZDC::RpdSubtractCentroidTool::nonNegative

static bool nonNegative(float const x)

Definition RpdSubtractCentroidTool.h:100

python.PyAthena.v

v

Definition PyAthena.py:154

◆ calculateDetectorCentroid()

void ZDC::RpdSubtractCentroidTool::calculateDetectorCentroid ( unsigned int side )

private

Definition at line 351 of file RpdSubtractCentroidTool.cxx.

                                                                         {
  for (unsigned int col = 0; col < RPDUtils::nCols; col++) {
    m_xCentroidPreGeomCorPreAvgSubtr.at(side) += m_subtrAmpColSum.at(side).at(col)*m_RPDChannelData.at(side).at(0).at(col).xposRel/m_subtrAmpSum.at(side);
  }
 
  for (unsigned int row = 0; row < RPDUtils::nRows; row++) {
    m_yCentroidPreGeomCorPreAvgSubtr.at(side) += m_subtrAmpRowSum.at(side).at(row)*m_RPDChannelData.at(side).at(row).at(0).yposRel/m_subtrAmpSum.at(side);
  }
 
  for (unsigned int row = 0; row < RPDUtils::nRows; row++) {
    if (m_subtrAmpRowSum.at(side).at(row) <= 0) continue;
    for (unsigned int col = 0; col < RPDUtils::nCols; col++) {
      m_xRowCentroid.at(side).at(row) += m_RPDChannelData.at(side).at(row).at(col).subtrAmp*m_RPDChannelData.at(side).at(row).at(col).xposRel/m_subtrAmpRowSum.at(side).at(row);
    }
    m_centroidStatus.at(side).set(Row0ValidBit + row, true);
  }
 
  for (unsigned int col = 0; col < RPDUtils::nCols; col++) {
    if (m_subtrAmpColSum.at(side).at(col) <= 0) continue;
    for (unsigned int row = 0; row < RPDUtils::nRows; row++) {
      m_yColCentroid.at(side).at(col) += m_RPDChannelData.at(side).at(row).at(col).subtrAmp*m_RPDChannelData.at(side).at(row).at(col).yposRel/m_subtrAmpColSum.at(side).at(col);
    }
    m_centroidStatus.at(side).set(Col0ValidBit + col, true);
  }
}

◆ calculateReactionPlaneAngle()

void ZDC::RpdSubtractCentroidTool::calculateReactionPlaneAngle ( unsigned int side )

private

Definition at line 388 of file RpdSubtractCentroidTool.cxx.

                                                                           {
  auto angle = std::atan2(m_yCentroid.at(side), m_xCentroid.at(side));
  // our angles are now simply the angle of the centroid in ATLAS coordinates on either side
  // however, we expect correlated deflection, so we want the difference between the angles
  // to be small when the centroids are in opposite quadrants of the two RPDs
  // therefore, we add pi to side A (chosen arbitrarily)
  if (side == RPDUtils::sideA) angle += std::numbers::pi_v<float>;
  // also, restrict to [-pi, pi)
  // we choose this rather than (-pi, pi] for ease of binning the edge case +/- pi
  if (angle >= std::numbers::pi) angle -= 2*std::numbers::pi_v<float>;
  m_reactionPlaneAngle.at(side) = angle;
}

◆ checkZdcRpdValidity()

bool ZDC::RpdSubtractCentroidTool::checkZdcRpdValidity ( unsigned int side )

private

Definition at line 256 of file RpdSubtractCentroidTool.cxx.

                                                                   {
  if (m_readZDCDecorations) {
    if (m_ZDCSideStatus->at(side) == 0) {
      // zdc bad
      m_centroidStatus.at(side).set(ZDCInvalidBit, true);
      m_centroidStatus.at(side).set(ValidBit, false);
    } else {
      // zdc good
      if (m_ZDCFinalEnergy->at(side) < m_minZDCEnergy.at(side)) {
        m_centroidStatus.at(side).set(InsufficientZDCEnergyBit, true);
        m_centroidStatus.at(side).set(ValidBit, false);
      }
      if (m_ZDCFinalEnergy->at(side) > m_maxZDCEnergy.at(side)) {
        m_centroidStatus.at(side).set(ExcessiveZDCEnergyBit, true);
        m_centroidStatus.at(side).set(ValidBit, false);
      }
    }
 
    if (m_EMStatus->at(side)[ZDCPulseAnalyzer::FailBit]) {
      // em bad
      m_centroidStatus.at(side).set(EMInvalidBit, true);
      m_centroidStatus.at(side).set(ValidBit, false);
    } else {
      // em good
      if (m_EMCalibEnergy->at(side) < m_minEMEnergy.at(side)) {
        m_centroidStatus.at(side).set(InsufficientEMEnergyBit, true);
        m_centroidStatus.at(side).set(ValidBit, false);
      }
      if (m_EMCalibEnergy->at(side) > m_maxEMEnergy.at(side)) {
        m_centroidStatus.at(side).set(ExcessiveEMEnergyBit, true);
        m_centroidStatus.at(side).set(ValidBit, false);
      }
    }
  }
 
  if (m_RPDSideStatus.at(side)[RPDDataAnalyzer::OutOfTimePileupBit]) {
    m_centroidStatus.at(side).set(PileupBit, true);
  }
 
  for (unsigned int row = 0; row < RPDUtils::nRows; row++) {
    for (unsigned int col = 0; col < RPDUtils::nCols; col++) {
      if (m_RPDChannelData.at(side).at(row).at(col).pileupFrac > m_pileupMaxFrac.at(side)) {
        m_centroidStatus.at(side).set(ExcessivePileupBit, true);
        m_centroidStatus.at(side).set(ValidBit, false);
      }
    }
  }
 
  if (!m_RPDSideStatus.at(side)[RPDDataAnalyzer::ValidBit]) {
    m_centroidStatus.at(side).set(RPDInvalidBit, true);
    m_centroidStatus.at(side).set(ValidBit, false);
    return false;
  }
 
  return true;
}

◆ declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

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

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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

◆ geometryCorrection()

void ZDC::RpdSubtractCentroidTool::geometryCorrection ( unsigned int side )

private

ROTATIONS CORRECTIONS GO HERE

Definition at line 377 of file RpdSubtractCentroidTool.cxx.

                                                                  {
  m_xCentroidPreAvgSubtr.at(side) = m_xCentroidPreGeomCorPreAvgSubtr.at(side) - m_alignmentXOffset.at(side);
  m_yCentroidPreAvgSubtr.at(side) = m_yCentroidPreGeomCorPreAvgSubtr.at(side) - m_alignmentYOffset.at(side);
}

◆ 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

ptr	The 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.

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

◆ 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

ptr	The 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.

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

◆ getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

◆ initialize()

StatusCode ZDC::RpdSubtractCentroidTool::initialize ( void )

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 41 of file RpdSubtractCentroidTool.cxx.

                                               {
  // first initialize reconstruction parameters
  m_minZDCEnergy = {-1.0, -1.0};
  m_maxZDCEnergy = {-1.0, -1.0};
  m_minEMEnergy = {-1.0, -1.0};
  m_maxEMEnergy = {-1.0, -1.0};
  m_pileupMaxFrac = {1.0, 1.0};
  m_maximumNegativeSubtrAmpFrac = {1.0, 1.0};
  m_useRPDSumAdc = true;
  m_useCalibDecorations = true;
 
  // then overwrite inidividual parameters from configuration if any were provided
  if (m_forceMinZDCEnergy.has_value()) {
    m_minZDCEnergy = m_forceMinZDCEnergy.value();
  }
  if (m_forceMaxZDCEnergy.has_value()) {
    m_maxZDCEnergy = m_forceMaxZDCEnergy.value();
  }
  if (m_forceMinEMEnergy.has_value()) {
    m_minEMEnergy = m_forceMinEMEnergy.value();
  }
  if (m_forceMaxEMEnergy.has_value()) {
    m_maxEMEnergy = m_forceMaxEMEnergy.value();
  }
  if (m_forcePileupMaxFrac.has_value()) {
    m_pileupMaxFrac = m_forcePileupMaxFrac.value();
  }
  if (m_forceMaximumNegativeSubtrAmpFrac.has_value()) {
    m_maximumNegativeSubtrAmpFrac = m_forceMaximumNegativeSubtrAmpFrac.value();
  }
  if (m_forceUseRPDSumAdc.has_value()) {
    m_useRPDSumAdc = m_forceUseRPDSumAdc.value();
  }
  if (m_forceUseCalibDecorations.has_value()) {
    m_useCalibDecorations = m_forceUseCalibDecorations.value();
  }
 
  // if any ZDC/EM energy threshold is nonnegative, ZDC decorations must be read
  m_readZDCDecorations = anyNonNegative(m_minZDCEnergy) || anyNonNegative(m_maxZDCEnergy) || anyNonNegative(m_minEMEnergy) || anyNonNegative(m_maxEMEnergy);
 
  for (auto const side : RPDUtils::sides) {
    if (m_minZDCEnergy.at(side) < 0) m_minZDCEnergy.at(side) = -std::numeric_limits<float>::infinity();
    if (m_maxZDCEnergy.at(side) < 0) m_maxZDCEnergy.at(side) = std::numeric_limits<float>::infinity();
    if (m_minEMEnergy.at(side) < 0) m_minEMEnergy.at(side) = -std::numeric_limits<float>::infinity();
    if (m_maxEMEnergy.at(side) < 0) m_maxEMEnergy.at(side) = std::numeric_limits<float>::infinity();
  }
 
  ATH_MSG_DEBUG("RpdSubtractCentroidTool reconstruction parameters:");
  ATH_MSG_DEBUG("config = " << m_configuration);
  ATH_MSG_DEBUG("minZDCEnergy = " << RPDUtils::vecToString(m_minZDCEnergy));
  ATH_MSG_DEBUG("maxZDCEnergy = " << RPDUtils::vecToString(m_maxZDCEnergy));
  ATH_MSG_DEBUG("minEMEnergy = " << RPDUtils::vecToString(m_minEMEnergy));
  ATH_MSG_DEBUG("maxEMEnergy = " << RPDUtils::vecToString(m_maxEMEnergy));
  ATH_MSG_DEBUG("pileupMaxFrac = " << RPDUtils::vecToString(m_pileupMaxFrac));
  ATH_MSG_DEBUG("maximumNegativeSubtrAmpFrac = " << RPDUtils::vecToString(m_maximumNegativeSubtrAmpFrac));
  ATH_MSG_DEBUG("useRPDSumAdc = " << m_useRPDSumAdc);
  ATH_MSG_DEBUG("useCalibDecorations = " << m_useCalibDecorations);
 
  if (m_readZDCDecorations) {
    ATH_MSG_DEBUG("RpdSubtractCentroidTool is configured to check ZDC or EM energy; ZDC-related ReadDecorHandleKey's will be initialized");
    m_ZDCSideStatus = {0, 0};
    m_ZDCFinalEnergy = {0, 0};
    m_EMCalibEnergy = {0, 0};
    m_EMStatus = {0, 0};
  }
 
  ATH_CHECK(m_eventInfoKey.initialize());
 
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_centroidEventValidKey, ".centroidEventValid"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_centroidStatusKey, ".centroidStatus"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_RPDChannelSubtrAmpKey, ".RPDChannelSubtrAmp"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_RPDSubtrAmpSumKey, ".RPDSubtrAmpSum"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_xCentroidPreGeomCorPreAvgSubtrKey, ".xCentroidPreGeomCorPreAvgSubtr"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_yCentroidPreGeomCorPreAvgSubtrKey, ".yCentroidPreGeomCorPreAvgSubtr"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_xCentroidPreAvgSubtrKey, ".xCentroidPreAvgSubtr"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_yCentroidPreAvgSubtrKey, ".yCentroidPreAvgSubtr"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_xCentroidKey, ".xCentroid"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_yCentroidKey, ".yCentroid"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_xRowCentroidKey, ".xRowCentroid"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_yColCentroidKey, ".yColCentroid"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_reactionPlaneAngleKey, ".reactionPlaneAngle"));
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_cosDeltaReactionPlaneAngleKey, ".cosDeltaReactionPlaneAngle"));
 
  if (m_writeAux && !m_auxSuffix.empty()) {
    ATH_MSG_DEBUG("suffix string = " << m_auxSuffix);
  }
 
  m_initialized = true;
 
  return StatusCode::SUCCESS;
}

◆ initializeKey()

StatusCode ZDC::RpdSubtractCentroidTool::initializeKey	(	std::string const &	containerName,
		SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > &	writeHandleKey,
		std::string const &	key )

private

Definition at line 36 of file RpdSubtractCentroidTool.cxx.

                                                                                                                                                                      {
  writeHandleKey = containerName + key + m_auxSuffix;
  return writeHandleKey.initialize();
}

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

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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

                                                  {
 
      return MSG::name( msg().level() );
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ nonNegative()

bool ZDC::RpdSubtractCentroidTool::nonNegative ( float const x )

inlinestaticprivate

Definition at line 100 of file RpdSubtractCentroidTool.h.

100{ return x >= 0; }

x

#define x

◆ operator=() [1/2]

RpdSubtractCentroidTool & ZDC::RpdSubtractCentroidTool::operator= ( RpdSubtractCentroidTool && )

delete

◆ operator=() [2/2]

RpdSubtractCentroidTool & ZDC::RpdSubtractCentroidTool::operator= ( RpdSubtractCentroidTool const & )

delete

◆ 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()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

◆ readAOD()

RpdSubtractCentroidTool::SubstepStatus ZDC::RpdSubtractCentroidTool::readAOD	(	xAOD::ZdcModuleContainer const &	moduleContainer,
		xAOD::ZdcModuleContainer const &	moduleSumContainer )

private

Definition at line 155 of file RpdSubtractCentroidTool.cxx.

                                                                                                                                                                     {
  // initialize read handles from read handle keys
  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
  if (!eventInfo.isValid()) {
    return SubstepStatus::Failure;
  }
  // RPD decorations are always needed
  if (eventInfo->isEventFlagBitSet(xAOD::EventInfo::ForwardDet, ZdcEventInfo::RPDDECODINGERROR)) {
    ATH_MSG_WARNING("RPD decoding error found - abandoning RPD centroid reco!");
    return SubstepStatus::SkipEvent;
  }
  // ZDC decorations are sometimes needed
  if (m_readZDCDecorations && eventInfo->isEventFlagBitSet(xAOD::EventInfo::ForwardDet, ZdcEventInfo::ZDCDECODINGERROR)) {
    ATH_MSG_WARNING("ZDC decoding error found - abandoning RPD centroid reco!");
    return SubstepStatus::SkipEvent;
  }
 
  // nominally, aux suffix is added to read key, since upstream tools were probably configured to write decorations with the same suffix
  // however, certain decorations remain unchanged in a reprocessing (e.g., those written by ZdcRecChannelToolLucrod), in which case the suffix should NOT be added
  static SG::ConstAccessor<float> const xposRelAcc("xposRel");
  static SG::ConstAccessor<float> const yposRelAcc("yposRel");
  static SG::ConstAccessor<unsigned short> const rowAcc("row");
  static SG::ConstAccessor<unsigned short> const colAcc("col");
  static SG::ConstAccessor<float> const rpdChannelSumAdcAcc("RPDChannelAmplitude" + m_auxSuffix);
  static SG::ConstAccessor<float> const rpdChannelSumAdcCalibAcc("RPDChannelAmplitudeCalib" + m_auxSuffix);
  static SG::ConstAccessor<float> const rpdChannelMaxADCAcc("RPDChannelMaxADC" + m_auxSuffix);
  static SG::ConstAccessor<float> const rpdChannelMaxADCCalibAcc("RPDChannelMaxADCCalib" + m_auxSuffix);
  static SG::ConstAccessor<float> const rpdChannelPileupFracAcc("RPDChannelPileupFrac" + m_auxSuffix);
  static SG::ConstAccessor<unsigned int> const rpdChannelStatusAcc("RPDChannelStatus" + m_auxSuffix);
  static SG::ConstAccessor<unsigned int> const rpdSideStatusAcc("RPDStatus" + m_auxSuffix);
  static auto const zdcModuleCalibEnergyAcc = m_readZDCDecorations
    ? std::optional<SG::ConstAccessor<float>>("CalibEnergy" + m_auxSuffix)
    : std::nullopt;
  static auto const zdcModuleStatusAcc = m_readZDCDecorations
    ? std::optional<SG::ConstAccessor<unsigned int>>("Status" + m_auxSuffix)
    : std::nullopt;
  static auto const zdcFinalEnergyAcc = m_readZDCDecorations
    ? std::optional<SG::ConstAccessor<float>>("FinalEnergy" + m_auxSuffix)
    : std::nullopt;
  static auto const zdcStatusAcc = m_readZDCDecorations
    ? std::optional<SG::ConstAccessor<unsigned int>>("Status" + m_auxSuffix)
    : std::nullopt;
 
  ATH_MSG_DEBUG("Processing modules");
 
  for (auto const * const zdcModule : moduleContainer) {
    unsigned int const side = RPDUtils::ZDCSideToSideIndex(zdcModule->zdcSide());
    if (zdcModule->zdcType() == RPDUtils::ZDCModuleZDCType && zdcModule->zdcModule() == RPDUtils::ZDCModuleEMModule) {
      // this is a ZDC module and this is an EM module
      if (m_readZDCDecorations) {
        m_EMCalibEnergy->at(side) = (*zdcModuleCalibEnergyAcc)(*zdcModule);
        m_EMStatus->at(side) = (*zdcModuleStatusAcc)(*zdcModule);
      }
    } else if (zdcModule->zdcType() == RPDUtils::ZDCModuleRPDType) {
      // this is a Run 3 RPD module
      // (it is assumed that this tool will not be invoked otherwise)
      //
      if (zdcModule->zdcChannel() < 0 || static_cast<unsigned int>(zdcModule->zdcChannel()) > RPDUtils::nChannels - 1) {
        ATH_MSG_ERROR("Invalid RPD channel found on side " << side << ": channel number = " << zdcModule->zdcChannel());
      }
      // channel numbers are fixed in mapping in ZdcConditions, numbered 0-15
      auto const channel = zdcModule->zdcChannel();
      auto const& row = rowAcc(*zdcModule);
      auto const& col = colAcc(*zdcModule);
      m_RPDChannelData.at(side).at(row).at(col).channel = static_cast<unsigned int>(channel);
      m_RPDChannelData.at(side).at(row).at(col).xposRel = xposRelAcc(*zdcModule);
      m_RPDChannelData.at(side).at(row).at(col).yposRel = yposRelAcc(*zdcModule);
      m_RPDChannelData.at(side).at(row).at(col).row = rowAcc(*zdcModule);
      m_RPDChannelData.at(side).at(row).at(col).col = colAcc(*zdcModule);
      if (m_useRPDSumAdc) {
        if (m_useCalibDecorations) {
          m_RPDChannelData.at(side).at(row).at(col).amp = rpdChannelSumAdcCalibAcc(*zdcModule);
        } else {
          m_RPDChannelData.at(side).at(row).at(col).amp = rpdChannelSumAdcAcc(*zdcModule);
        }
      } else {
        if (m_useCalibDecorations) {
          m_RPDChannelData.at(side).at(row).at(col).amp = rpdChannelMaxADCCalibAcc(*zdcModule);
        } else {
          m_RPDChannelData.at(side).at(row).at(col).amp = rpdChannelMaxADCAcc(*zdcModule);
        }
      }
      m_RPDChannelData.at(side).at(row).at(col).pileupFrac = rpdChannelPileupFracAcc(*zdcModule);
      m_RPDChannelData.at(side).at(row).at(col).status = rpdChannelStatusAcc(*zdcModule);
    }
  }
 
  for (auto const * const zdcSum: moduleSumContainer) {
    if (zdcSum->zdcSide() == RPDUtils::ZDCSumsGlobalZDCSide) {
      // skip global sum (it's like the side between sides)
      continue;
    }
    unsigned int const side = RPDUtils::ZDCSideToSideIndex(zdcSum->zdcSide());
    m_RPDSideStatus.at(side) = rpdSideStatusAcc(*zdcSum);
    if (m_ZDCSideStatus) m_ZDCSideStatus->at(side) = (*zdcStatusAcc)(*zdcSum);
    if (m_ZDCFinalEnergy) m_ZDCFinalEnergy->at(side) = (*zdcFinalEnergyAcc)(*zdcSum);
  }
 
  return SubstepStatus::Success;
}

◆ recoZdcModules()

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

overridevirtual

Implements ZDC::IZdcAnalysisTool.

Definition at line 445 of file RpdSubtractCentroidTool.cxx.

                                                                                                                                                  {
  if (moduleContainer.empty()) {
    // no modules - do nothing
    return StatusCode::SUCCESS;
  }
  reset();
  switch (readAOD(moduleContainer, moduleSumContainer)) {
    case SubstepStatus::Success:
      // do nothing - proceed
      break;
    case SubstepStatus::Failure:
      // stop and propagate error to Athena
      return StatusCode::FAILURE;
    case SubstepStatus::SkipEvent:
      // stop and tell Athena the event was a success
      return StatusCode::SUCCESS;
  }
  for (auto const side : RPDUtils::sides) {
    if (!checkZdcRpdValidity(side)) continue; // rpd invalid -> don't calculate centroid
    if (!subtractRpdAmplitudes(side)) continue; // bad total sum -> don't calculate centroid
    calculateDetectorCentroid(side);
    geometryCorrection(side);
    subtractAverageCentroid(side);
    calculateReactionPlaneAngle(side);
    m_centroidStatus.at(side).set(HasCentroidBit, true);
  }
  if (m_centroidStatus.at(RPDUtils::sideC)[HasCentroidBit] && m_centroidStatus.at(RPDUtils::sideA)[HasCentroidBit]) {
    m_cosDeltaReactionPlaneAngle = std::cos(m_reactionPlaneAngle.at(RPDUtils::sideC) - m_reactionPlaneAngle.at(RPDUtils::sideA));
  }
  if (m_centroidStatus.at(RPDUtils::sideC)[ValidBit] && m_centroidStatus.at(RPDUtils::sideA)[ValidBit]) {
    m_eventValid = true; // event is good for analysis
  }
  writeAOD(moduleSumContainer);
  ATH_MSG_DEBUG("Finishing event processing");
  return StatusCode::SUCCESS;
}

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

  {
    h.renounce();
    PBASE::renounce (h);
  }

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

                                                          {
    handlesArray.renounce();
  }

◆ reprocessZdc()

StatusCode ZDC::RpdSubtractCentroidTool::reprocessZdc ( )

overridevirtual

Implements ZDC::IZdcAnalysisTool.

Definition at line 482 of file RpdSubtractCentroidTool.cxx.

                                                 {
  if (!m_initialized) {
    ATH_MSG_WARNING("Tool not initialized!");
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Trying to retrieve " << m_ZDCModuleContainerName);
  xAOD::ZdcModuleContainer const* zdcModules = nullptr;
  ATH_CHECK(evtStore()->retrieve(zdcModules, m_ZDCModuleContainerName));
  xAOD::ZdcModuleContainer const* zdcSums = nullptr;
  ATH_CHECK(evtStore()->retrieve(zdcSums, m_ZDCSumContainerName));
  ATH_CHECK(recoZdcModules(*zdcModules, *zdcSums));
  return StatusCode::SUCCESS;
}

◆ reset()

void ZDC::RpdSubtractCentroidTool::reset ( )

private

Definition at line 133 of file RpdSubtractCentroidTool.cxx.

                                    {
  m_eventValid = false;
  for (auto& status : m_centroidStatus) {
    status.reset();
    status.set(ValidBit, true);
  }
  RPDUtils::helpZero(m_subtrAmp);
  RPDUtils::helpZero(m_subtrAmpRowSum);
  RPDUtils::helpZero(m_subtrAmpColSum);
  RPDUtils::helpZero(m_subtrAmpSum);
  RPDUtils::helpZero(m_xCentroidPreGeomCorPreAvgSubtr);
  RPDUtils::helpZero(m_yCentroidPreGeomCorPreAvgSubtr);
  RPDUtils::helpZero(m_xCentroidPreAvgSubtr);
  RPDUtils::helpZero(m_yCentroidPreAvgSubtr);
  RPDUtils::helpZero(m_xCentroid);
  RPDUtils::helpZero(m_yCentroid);
  RPDUtils::helpZero(m_xRowCentroid);
  RPDUtils::helpZero(m_yColCentroid);
  RPDUtils::helpZero(m_reactionPlaneAngle);
  m_cosDeltaReactionPlaneAngle = 0;
}

◆ subtractAverageCentroid()

void ZDC::RpdSubtractCentroidTool::subtractAverageCentroid ( unsigned int side )

private

Definition at line 383 of file RpdSubtractCentroidTool.cxx.

                                                                       {
  m_xCentroid.at(side) = m_xCentroidPreAvgSubtr.at(side) - m_avgXCentroid.at(side);
  m_yCentroid.at(side) = m_yCentroidPreAvgSubtr.at(side) - m_avgYCentroid.at(side);
}

◆ subtractRpdAmplitudes()

bool ZDC::RpdSubtractCentroidTool::subtractRpdAmplitudes ( unsigned int side )

private

Definition at line 313 of file RpdSubtractCentroidTool.cxx.

                                                                     {
  for (unsigned int row = 0; row < RPDUtils::nRows; row++) {
    for (unsigned int col = 0; col < RPDUtils::nCols; col++) {
      float subtrAmp {};
      if (row == RPDUtils::nRows - 1) {
        // top row -> nothing to subtract
        subtrAmp = m_RPDChannelData.at(side).at(row).at(col).amp;
      } else {
        // other rows -> subtract the tile above this one
        subtrAmp = m_RPDChannelData.at(side).at(row).at(col).amp - m_RPDChannelData.at(side).at(row + 1).at(col).amp;
      }
      m_RPDChannelData.at(side).at(row).at(col).subtrAmp = subtrAmp;
      m_subtrAmp.at(side).at(m_RPDChannelData.at(side).at(row).at(col).channel) = subtrAmp;
      m_subtrAmpRowSum.at(side).at(row) += subtrAmp;
      m_subtrAmpColSum.at(side).at(col) += subtrAmp;
      m_subtrAmpSum.at(side) += subtrAmp;
    }
  }
 
  if (m_subtrAmpSum.at(side) <= 0) {
    m_centroidStatus.at(side).set(ZeroSumBit, true);
    m_centroidStatus.at(side).set(ValidBit, false);
    return false;
  }
 
  for (unsigned int row = 0; row < RPDUtils::nRows; row++) {
    for (unsigned int col = 0; col < RPDUtils::nCols; col++) {
      const float &subtrAmp = m_RPDChannelData.at(side).at(row).at(col).subtrAmp;
      if (subtrAmp < 0 && -subtrAmp/m_subtrAmpSum.at(side) > m_maximumNegativeSubtrAmpFrac.at(side)) {
        m_centroidStatus.at(side).set(ExcessiveSubtrUnderflowBit, true);
        m_centroidStatus.at(side).set(ValidBit, false);
      }
    }
  }
 
  return true;
}

◆ 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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

◆ writeAOD()

void ZDC::RpdSubtractCentroidTool::writeAOD ( xAOD::ZdcModuleContainer const & moduleSumContainer ) const

private

Definition at line 401 of file RpdSubtractCentroidTool.cxx.

                                                                                             {
  if (!m_writeAux) return;
  ATH_MSG_DEBUG("Adding variables with suffix = " + m_auxSuffix);
 
  // initialize write handles from write handle keys
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, char> centroidEventValidHandle(m_centroidEventValidKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, unsigned int> centroidStatusHandle(m_centroidStatusKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, std::vector<float>> rpdChannelSubtrAmpHandle(m_RPDChannelSubtrAmpKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, float> rpdSubtrAmpSumHandle(m_RPDSubtrAmpSumKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, float> xCentroidPreGeomCorPreAvgSubtrHandle(m_xCentroidPreGeomCorPreAvgSubtrKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, float> yCentroidPreGeomCorPreAvgSubtrHandle(m_yCentroidPreGeomCorPreAvgSubtrKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, float> xCentroidPreAvgSubtrHandle(m_xCentroidPreAvgSubtrKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, float> yCentroidPreAvgSubtrHandle(m_yCentroidPreAvgSubtrKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, float> xCentroidHandle(m_xCentroidKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, float> yCentroidHandle(m_yCentroidKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, std::vector<float>> xRowCentroidHandle(m_xRowCentroidKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, std::vector<float>> yColCentroidHandle(m_yColCentroidKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, float> reactionPlaneAngleHandle(m_reactionPlaneAngleKey);
  SG::WriteDecorHandle<xAOD::ZdcModuleContainer, float> cosDeltaReactionPlaneAngleHandle(m_cosDeltaReactionPlaneAngleKey);
 
  for (auto const * const zdcSum: moduleSumContainer) {
    if (zdcSum->zdcSide() == RPDUtils::ZDCSumsGlobalZDCSide) {
      // global sum container
      // event status is bool, but stored as char to save disk space
      centroidEventValidHandle(*zdcSum) = static_cast<char>(m_eventValid);
      cosDeltaReactionPlaneAngleHandle(*zdcSum) = m_cosDeltaReactionPlaneAngle;
      continue;
    }
    unsigned int const side = RPDUtils::ZDCSideToSideIndex(zdcSum->zdcSide());
    centroidStatusHandle(*zdcSum) = static_cast<unsigned int>(m_centroidStatus.at(side).to_ulong());
    rpdChannelSubtrAmpHandle(*zdcSum) = m_subtrAmp.at(side);
    rpdSubtrAmpSumHandle(*zdcSum) = m_subtrAmpSum.at(side);
    xCentroidPreGeomCorPreAvgSubtrHandle(*zdcSum) = m_xCentroidPreGeomCorPreAvgSubtr.at(side);
    yCentroidPreGeomCorPreAvgSubtrHandle(*zdcSum) = m_yCentroidPreGeomCorPreAvgSubtr.at(side);
    xCentroidPreAvgSubtrHandle(*zdcSum) = m_xCentroidPreAvgSubtr.at(side);
    yCentroidPreAvgSubtrHandle(*zdcSum) = m_yCentroidPreAvgSubtr.at(side);
    xCentroidHandle(*zdcSum) = m_xCentroid.at(side);
    yCentroidHandle(*zdcSum) = m_yCentroid.at(side);
    xRowCentroidHandle(*zdcSum) = m_xRowCentroid.at(side);
    yColCentroidHandle(*zdcSum) = m_yColCentroid.at(side);
    reactionPlaneAngleHandle(*zdcSum) = m_reactionPlaneAngle.at(side);
  }
}

Member Data Documentation

◆ m_alignmentXOffset

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_alignmentXOffset {}

private

RPD channel data for each channel (first index row, then index column) on each side.

Definition at line 130 of file RpdSubtractCentroidTool.h.

130{};

◆ m_alignmentYOffset

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_alignmentYOffset {}

private

geometry + crossing angle correction in x (ATLAS coordinates)

Definition at line 131 of file RpdSubtractCentroidTool.h.

131{};

◆ m_auxSuffix

std::string ZDC::RpdSubtractCentroidTool::m_auxSuffix

private

Definition at line 78 of file RpdSubtractCentroidTool.h.

◆ m_avgXCentroid

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_avgXCentroid {}

private

geometry + crossing angle correction in y (ATLAS coordinates)

ROTATIONS GO HERE

Definition at line 136 of file RpdSubtractCentroidTool.h.

136{};

◆ m_avgYCentroid

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_avgYCentroid {}

private

average x centroid

Definition at line 137 of file RpdSubtractCentroidTool.h.

137{};

◆ m_centroidEventValidKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_centroidEventValidKey

private

Initial value:

{
    this, "centroidEventValidKey", "",
    "Event status: true if both centroids are valid, else false"
  }

Definition at line 193 of file RpdSubtractCentroidTool.h.

                                                                        {
    this, "centroidEventValidKey", "",
    "Event status: true if both centroids are valid, else false"
  };

◆ m_centroidStatus

std::array<std::bitset<N_STATUS_BITS>, 2> ZDC::RpdSubtractCentroidTool::m_centroidStatus {1 << ValidBit, 1 << ValidBit}

private

event status

Definition at line 142 of file RpdSubtractCentroidTool.h.

142{1 << ValidBit, 1 << ValidBit};

◆ m_centroidStatusKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_centroidStatusKey

private

Initial value:

{
    this, "centroidStatusKey", "",
    "Centroid status word"
  }

Definition at line 197 of file RpdSubtractCentroidTool.h.

                                                                    {
    this, "centroidStatusKey", "",
    "Centroid status word"
  };

◆ m_configuration

std::string ZDC::RpdSubtractCentroidTool::m_configuration

private

Definition at line 74 of file RpdSubtractCentroidTool.h.

◆ m_cosDeltaReactionPlaneAngle

float ZDC::RpdSubtractCentroidTool::m_cosDeltaReactionPlaneAngle = 0

private

reaction plane angle on each side

Definition at line 165 of file RpdSubtractCentroidTool.h.

◆ m_cosDeltaReactionPlaneAngleKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_cosDeltaReactionPlaneAngleKey

private

Initial value:

{
    this, "cosDeltaReactionPlaneAngleKey", "",
    "Cosine of the difference between the reaction plane angles of the two sides"
  }

Definition at line 245 of file RpdSubtractCentroidTool.h.

                                                                                {
    this, "cosDeltaReactionPlaneAngleKey", "",
    "Cosine of the difference between the reaction plane angles of the two sides"
  };

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

std::optional<std::array<float, 2> > ZDC::RpdSubtractCentroidTool::m_EMCalibEnergy

private

ZDC final (calibrated) energy on each side.

Definition at line 124 of file RpdSubtractCentroidTool.h.

◆ m_EMStatus

std::optional<std::array<std::bitset<ZDCPulseAnalyzer::N_STATUS_BITS>, 2> > ZDC::RpdSubtractCentroidTool::m_EMStatus

private

EM calibrated energy on each side.

Definition at line 125 of file RpdSubtractCentroidTool.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> ZDC::RpdSubtractCentroidTool::m_eventInfoKey

private

Initial value:

{
    this, "EventInfoKey", "EventInfo",
    "Location of the event info"
  }

Definition at line 188 of file RpdSubtractCentroidTool.h.

                                                {
    this, "EventInfoKey", "EventInfo",
    "Location of the event info"
  };

◆ m_eventValid

bool ZDC::RpdSubtractCentroidTool::m_eventValid = false

private

average y centroid

Definition at line 141 of file RpdSubtractCentroidTool.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_forceMaxEMEnergy

RPDUtils::OptionalToolProperty<std::vector<float> > ZDC::RpdSubtractCentroidTool::m_forceMaxEMEnergy

private

Definition at line 83 of file RpdSubtractCentroidTool.h.

◆ m_forceMaximumNegativeSubtrAmpFrac

RPDUtils::OptionalToolProperty<std::vector<float> > ZDC::RpdSubtractCentroidTool::m_forceMaximumNegativeSubtrAmpFrac

private

Definition at line 85 of file RpdSubtractCentroidTool.h.

◆ m_forceMaxZDCEnergy

RPDUtils::OptionalToolProperty<std::vector<float> > ZDC::RpdSubtractCentroidTool::m_forceMaxZDCEnergy

private

Definition at line 81 of file RpdSubtractCentroidTool.h.

◆ m_forceMinEMEnergy

RPDUtils::OptionalToolProperty<std::vector<float> > ZDC::RpdSubtractCentroidTool::m_forceMinEMEnergy

private

Definition at line 82 of file RpdSubtractCentroidTool.h.

◆ m_forceMinZDCEnergy

RPDUtils::OptionalToolProperty<std::vector<float> > ZDC::RpdSubtractCentroidTool::m_forceMinZDCEnergy

private

Definition at line 80 of file RpdSubtractCentroidTool.h.

◆ m_forcePileupMaxFrac

RPDUtils::OptionalToolProperty<std::vector<float> > ZDC::RpdSubtractCentroidTool::m_forcePileupMaxFrac

private

Definition at line 84 of file RpdSubtractCentroidTool.h.

◆ m_forceUseCalibDecorations

RPDUtils::OptionalToolProperty<bool> ZDC::RpdSubtractCentroidTool::m_forceUseCalibDecorations

private

Definition at line 87 of file RpdSubtractCentroidTool.h.

◆ m_forceUseRPDSumAdc

RPDUtils::OptionalToolProperty<bool> ZDC::RpdSubtractCentroidTool::m_forceUseRPDSumAdc

private

Definition at line 86 of file RpdSubtractCentroidTool.h.

◆ m_initialized

bool ZDC::RpdSubtractCentroidTool::m_initialized = false

private

Definition at line 105 of file RpdSubtractCentroidTool.h.

◆ m_maxEMEnergy

std::vector<float> ZDC::RpdSubtractCentroidTool::m_maxEMEnergy

private

Definition at line 93 of file RpdSubtractCentroidTool.h.

◆ m_maximumNegativeSubtrAmpFrac

std::vector<float> ZDC::RpdSubtractCentroidTool::m_maximumNegativeSubtrAmpFrac

private

Definition at line 95 of file RpdSubtractCentroidTool.h.

◆ m_maxZDCEnergy

std::vector<float> ZDC::RpdSubtractCentroidTool::m_maxZDCEnergy

private

Definition at line 91 of file RpdSubtractCentroidTool.h.

◆ m_minEMEnergy

std::vector<float> ZDC::RpdSubtractCentroidTool::m_minEMEnergy

private

Definition at line 92 of file RpdSubtractCentroidTool.h.

◆ m_minZDCEnergy

std::vector<float> ZDC::RpdSubtractCentroidTool::m_minZDCEnergy

private

Definition at line 90 of file RpdSubtractCentroidTool.h.

◆ m_pileupMaxFrac

std::vector<float> ZDC::RpdSubtractCentroidTool::m_pileupMaxFrac

private

Definition at line 94 of file RpdSubtractCentroidTool.h.

◆ m_reactionPlaneAngle

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_reactionPlaneAngle {}

private

the y centroid for each column on each side

Definition at line 164 of file RpdSubtractCentroidTool.h.

164{};

◆ m_reactionPlaneAngleKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_reactionPlaneAngleKey

private

Initial value:

{
    this, "reactionPlaneAngleKey", "",
    "Reaction plane angle in [-pi, pi) from the positive x axis"
  }

Definition at line 241 of file RpdSubtractCentroidTool.h.

                                                                        {
    this, "reactionPlaneAngleKey", "",
    "Reaction plane angle in [-pi, pi) from the positive x axis"
  };

◆ m_readZDCDecorations

bool ZDC::RpdSubtractCentroidTool::m_readZDCDecorations = false

private

Definition at line 106 of file RpdSubtractCentroidTool.h.

◆ m_RPDChannelData

std::array<std::array<std::array<RPDChannelData, RPDUtils::nCols>, RPDUtils::nRows>, 2> ZDC::RpdSubtractCentroidTool::m_RPDChannelData {}

private

EM modlue status word on each side.

Definition at line 126 of file RpdSubtractCentroidTool.h.

126{};

◆ m_RPDChannelSubtrAmpKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_RPDChannelSubtrAmpKey

private

Initial value:

{
    this, "RPDChannelSubtrAmpKey", "",
    "RPD channel subtracted amplitudes (tile mass) used in centroid calculation"
  }

Definition at line 201 of file RpdSubtractCentroidTool.h.

                                                                        {
    this, "RPDChannelSubtrAmpKey", "",
    "RPD channel subtracted amplitudes (tile mass) used in centroid calculation"
  };

◆ m_RPDSideStatus

std::array<std::bitset<RPDDataAnalyzer::N_STATUS_BITS>, 2> ZDC::RpdSubtractCentroidTool::m_RPDSideStatus {}

private

Definition at line 121 of file RpdSubtractCentroidTool.h.

121{};

◆ m_RPDSubtrAmpSumKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_RPDSubtrAmpSumKey

private

Initial value:

{
    this, "RPDSubtrAmpSumKey", "",
    "Sum of RPD channel subtracted amplitudes (total mass) used in centroid calculation"
  }

Definition at line 205 of file RpdSubtractCentroidTool.h.

                                                                    {
    this, "RPDSubtrAmpSumKey", "",
    "Sum of RPD channel subtracted amplitudes (total mass) used in centroid calculation"
  };

◆ m_subtrAmp

std::array<std::vector<float>, 2> ZDC::RpdSubtractCentroidTool::m_subtrAmp

private

Initial value:

= {
    std::vector<float>(RPDUtils::nChannels, 0.0),
    std::vector<float>(RPDUtils::nChannels, 0.0)
  }

centroid status (valid by default) on each side

Definition at line 143 of file RpdSubtractCentroidTool.h.

                                             {
    std::vector<float>(RPDUtils::nChannels, 0.0),
    std::vector<float>(RPDUtils::nChannels, 0.0)
  }; 

◆ m_subtrAmpColSum

std::array<std::array<float, RPDUtils::nCols>, 2> ZDC::RpdSubtractCentroidTool::m_subtrAmpColSum {}

private

subtracted amplitude for each row on each side

Definition at line 148 of file RpdSubtractCentroidTool.h.

148{};

◆ m_subtrAmpRowSum

std::array<std::array<float, RPDUtils::nRows>, 2> ZDC::RpdSubtractCentroidTool::m_subtrAmpRowSum {}

private

subtracted amplitude for each channel on each side

Definition at line 147 of file RpdSubtractCentroidTool.h.

147{};

◆ m_subtrAmpSum

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_subtrAmpSum {}

private

subtracted amplitude for each column on each side

Definition at line 149 of file RpdSubtractCentroidTool.h.

149{};

◆ m_useCalibDecorations

bool ZDC::RpdSubtractCentroidTool::m_useCalibDecorations {}

private

Definition at line 97 of file RpdSubtractCentroidTool.h.

97{};

◆ m_useRPDSumAdc

bool ZDC::RpdSubtractCentroidTool::m_useRPDSumAdc {}

private

Definition at line 96 of file RpdSubtractCentroidTool.h.

96{};

◆ 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::RpdSubtractCentroidTool::m_writeAux {}

private

Definition at line 77 of file RpdSubtractCentroidTool.h.

77{};

◆ m_xCentroid

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_xCentroid {}

private

y centroid after geomerty correction and before average subtraction on each side

Definition at line 154 of file RpdSubtractCentroidTool.h.

154{};

◆ m_xCentroidKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_xCentroidKey

private

Initial value:

{
    this, "xCentroidKey", "",
    "X centroid after geometry corrections and after average centroid subtraction"
  }

Definition at line 225 of file RpdSubtractCentroidTool.h.

                                                               {
    this, "xCentroidKey", "",
    "X centroid after geometry corrections and after average centroid subtraction"
  };

◆ m_xCentroidPreAvgSubtr

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_xCentroidPreAvgSubtr {}

private

y centroid before geomerty correction and before average subtraction (RPD detector coordinates) on each side

Definition at line 152 of file RpdSubtractCentroidTool.h.

152{};

◆ m_xCentroidPreAvgSubtrKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_xCentroidPreAvgSubtrKey

private

Initial value:

{
    this, "xCentroidPreAvgSubtrKey", "",
    "X centroid after geometry corrections and before average centroid subtraction"
  }

Definition at line 217 of file RpdSubtractCentroidTool.h.

                                                                          {
    this, "xCentroidPreAvgSubtrKey", "",
    "X centroid after geometry corrections and before average centroid subtraction"
  };

◆ m_xCentroidPreGeomCorPreAvgSubtr

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_xCentroidPreGeomCorPreAvgSubtr {}

private

subtracted amplitude sum on each side

Definition at line 150 of file RpdSubtractCentroidTool.h.

150{};

◆ m_xCentroidPreGeomCorPreAvgSubtrKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_xCentroidPreGeomCorPreAvgSubtrKey

private

Initial value:

{
    this, "xCentroidPreGeomCorPreAvgSubtrKey", "",
    "X centroid before geometry corrections and before average centroid subtraction (RPD detector coordinates)"
  }

Definition at line 209 of file RpdSubtractCentroidTool.h.

                                                                                    {
    this, "xCentroidPreGeomCorPreAvgSubtrKey", "",
    "X centroid before geometry corrections and before average centroid subtraction (RPD detector coordinates)"
  };

◆ m_xRowCentroid

std::array<std::vector<float>, 2> ZDC::RpdSubtractCentroidTool::m_xRowCentroid

private

Initial value:

= {
    std::vector<float>(RPDUtils::nRows, 0.0),
    std::vector<float>(RPDUtils::nRows, 0.0)
  }

y centroid after geomerty correction and after average subtraction on each side

Definition at line 156 of file RpdSubtractCentroidTool.h.

                                                 {
    std::vector<float>(RPDUtils::nRows, 0.0),
    std::vector<float>(RPDUtils::nRows, 0.0)
  }; 

◆ m_xRowCentroidKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_xRowCentroidKey

private

Initial value:

{
    this, "xRowCentroidKey", "",
    "Row X centroids before geometry corrections and before average centroid subtraction (RPD detector coordinates)"
  }

Definition at line 233 of file RpdSubtractCentroidTool.h.

                                                                  {
    this, "xRowCentroidKey", "",
    "Row X centroids before geometry corrections and before average centroid subtraction (RPD detector coordinates)"
  };

◆ m_yCentroid

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_yCentroid {}

private

x centroid after geomerty correction and after average subtraction on each side

Definition at line 155 of file RpdSubtractCentroidTool.h.

155{};

◆ m_yCentroidKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_yCentroidKey

private

Initial value:

{
    this, "yCentroidKey", "",
    "Y centroid after geometry corrections and after average centroid subtraction"
  }

Definition at line 229 of file RpdSubtractCentroidTool.h.

                                                               {
    this, "yCentroidKey", "",
    "Y centroid after geometry corrections and after average centroid subtraction"
  };

◆ m_yCentroidPreAvgSubtr

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_yCentroidPreAvgSubtr {}

private

x centroid after geomerty correction and before average subtraction on each side

Definition at line 153 of file RpdSubtractCentroidTool.h.

153{};

◆ m_yCentroidPreAvgSubtrKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_yCentroidPreAvgSubtrKey

private

Initial value:

{
    this, "yCentroidPreAvgSubtrKey", "",
    "Y centroid after geometry corrections and before average centroid subtraction"
  }

Definition at line 221 of file RpdSubtractCentroidTool.h.

                                                                          {
    this, "yCentroidPreAvgSubtrKey", "",
    "Y centroid after geometry corrections and before average centroid subtraction"
  };

◆ m_yCentroidPreGeomCorPreAvgSubtr

std::array<float, 2> ZDC::RpdSubtractCentroidTool::m_yCentroidPreGeomCorPreAvgSubtr {}

private

x centroid before geomerty correction and before average subtraction (RPD detector coordinates) on each side

Definition at line 151 of file RpdSubtractCentroidTool.h.

151{};

◆ m_yCentroidPreGeomCorPreAvgSubtrKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_yCentroidPreGeomCorPreAvgSubtrKey

private

Initial value:

{
    this, "yCentroidPreGeomCorPreAvgSubtrKey", "",
    "Y centroid before geometry corrections and before average centroid subtraction (RPD detector coordinates)"
  }

Definition at line 213 of file RpdSubtractCentroidTool.h.

                                                                                    {
    this, "yCentroidPreGeomCorPreAvgSubtrKey", "",
    "Y centroid before geometry corrections and before average centroid subtraction (RPD detector coordinates)"
  };

◆ m_yColCentroid

std::array<std::vector<float>, 2> ZDC::RpdSubtractCentroidTool::m_yColCentroid

private

Initial value:

= {
    std::vector<float>(RPDUtils::nCols, 0.0),
    std::vector<float>(RPDUtils::nCols, 0.0)
  }

the x centroid for each row on each side

Definition at line 160 of file RpdSubtractCentroidTool.h.

                                                 {
    std::vector<float>(RPDUtils::nCols, 0.0),
    std::vector<float>(RPDUtils::nCols, 0.0)
  }; 

◆ m_yColCentroidKey

SG::WriteDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_yColCentroidKey

private

Initial value:

{
    this, "yColCentroidKey", "",
    "Column Y centroids before geometry corrections and before average centroid subtraction (RPD detector coordinates)"
  }

Definition at line 237 of file RpdSubtractCentroidTool.h.

                                                                  {
    this, "yColCentroidKey", "",
    "Column Y centroids before geometry corrections and before average centroid subtraction (RPD detector coordinates)"
  };

◆ m_ZDCFinalEnergy

std::optional<std::array<float, 2> > ZDC::RpdSubtractCentroidTool::m_ZDCFinalEnergy

private

ZDC analysis status on each side.

Definition at line 123 of file RpdSubtractCentroidTool.h.

◆ m_ZDCModuleContainerName

std::string ZDC::RpdSubtractCentroidTool::m_ZDCModuleContainerName

private

Definition at line 75 of file RpdSubtractCentroidTool.h.

◆ m_ZDCSideStatus

std::optional<std::array<unsigned int, 2> > ZDC::RpdSubtractCentroidTool::m_ZDCSideStatus

private

RPD analysis status word on each side.

Definition at line 122 of file RpdSubtractCentroidTool.h.

◆ m_ZDCSumContainerName

std::string ZDC::RpdSubtractCentroidTool::m_ZDCSumContainerName

private

Definition at line 76 of file RpdSubtractCentroidTool.h.

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

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ anonymous enum

◆ SubstepStatus

Constructor & Destructor Documentation

◆ RpdSubtractCentroidTool() [1/3]

◆ ~RpdSubtractCentroidTool()

◆ RpdSubtractCentroidTool() [2/3]

◆ RpdSubtractCentroidTool() [3/3]

Member Function Documentation

◆ anyNonNegative()

◆ calculateDetectorCentroid()

◆ calculateReactionPlaneAngle()

◆ checkZdcRpdValidity()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ geometryCorrection()

◆ getKey()

◆ getName()

◆ getProperty()

◆ initialize()

◆ initializeKey()

◆ inputHandles()

◆ msg()

◆ msg_level_name()

◆ msgLvl()

◆ nonNegative()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ outputHandles()

◆ print()

◆ readAOD()

◆ recoZdcModules()

◆ renounce()

◆ renounceArray()

◆ reprocessZdc()

◆ reset()

◆ subtractAverageCentroid()

◆ subtractRpdAmplitudes()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

◆ writeAOD()

Member Data Documentation

◆ m_alignmentXOffset

◆ m_alignmentYOffset

◆ m_auxSuffix

◆ m_avgXCentroid

◆ m_avgYCentroid

◆ m_centroidEventValidKey

◆ m_centroidStatus

◆ m_centroidStatusKey

◆ m_configuration

◆ m_cosDeltaReactionPlaneAngle

◆ m_cosDeltaReactionPlaneAngleKey

◆ m_detStore

◆ m_EMCalibEnergy

◆ m_EMStatus

◆ m_eventInfoKey

◆ m_eventValid

◆ m_evtStore

◆ m_forceMaxEMEnergy

◆ m_forceMaximumNegativeSubtrAmpFrac

◆ m_forceMaxZDCEnergy

◆ m_forceMinEMEnergy

◆ m_forceMinZDCEnergy

◆ m_forcePileupMaxFrac