ZDC::RpdSubtractCentroidTool Class Reference

#include <RpdSubtractCentroidTool.h>

Inheritance diagram for ZDC::RpdSubtractCentroidTool:

Collaboration 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. More...
StatusCode	recoZdcModules (const xAOD::ZdcModuleContainer &moduleContainer, const xAOD::ZdcModuleContainer &moduleSumContainer) override
StatusCode	reprocessZdc () override
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

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
enum	SubstepStatus { SubstepStatus::Success, SubstepStatus::Failure, SubstepStatus::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::ReadDecorHandleKey< xAOD::ZdcModuleContainer > &readHandleKey, std::string const &key)
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 > &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...

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. More...
std::optional< std::array< float, 2 > >	m_ZDCFinalEnergy
	ZDC analysis status on each side. More...
std::optional< std::array< float, 2 > >	m_EMCalibEnergy
	ZDC final (calibrated) energy on each side. More...
std::optional< std::array< std::bitset< ZDCPulseAnalyzer::N_STATUS_BITS >, 2 > >	m_EMStatus
	EM calibrated energy on each side. More...
std::array< std::array< std::array< RPDChannelData, RPDUtils::nCols >, RPDUtils::nRows >, 2 >	m_RPDChannelData {}
	EM modlue status word on each side. More...
std::array< float, 2 >	m_alignmentXOffset {}
	RPD channel data for each channel (first index row, then index column) on each side. More...
std::array< float, 2 >	m_alignmentYOffset {}
	geometry + crossing angle correction in x (ATLAS coordinates) More...
std::array< float, 2 >	m_avgXCentroid {}
	geometry + crossing angle correction in y (ATLAS coordinates) More...
std::array< float, 2 >	m_avgYCentroid {}
	average x centroid More...
bool	m_eventValid = false
	average y centroid More...
std::array< std::bitset< N_STATUS_BITS >, 2 >	m_centroidStatus {1 << ValidBit, 1 << ValidBit}
	event status More...
std::array< std::vector< float >, 2 >	m_subtrAmp
	centroid status (valid by default) on each side More...
std::array< std::array< float, RPDUtils::nRows >, 2 >	m_subtrAmpRowSum {}
	subtracted amplitude for each channel on each side More...
std::array< std::array< float, RPDUtils::nCols >, 2 >	m_subtrAmpColSum {}
	subtracted amplitude for each row on each side More...
std::array< float, 2 >	m_subtrAmpSum {}
	subtracted amplitude for each column on each side More...
std::array< float, 2 >	m_xCentroidPreGeomCorPreAvgSubtr {}
	subtracted amplitude sum on each side More...
std::array< float, 2 >	m_yCentroidPreGeomCorPreAvgSubtr {}
	x centroid before geomerty correction and before average subtraction (RPD detector coordinates) on each side More...
std::array< float, 2 >	m_xCentroidPreAvgSubtr {}
	y centroid before geomerty correction and before average subtraction (RPD detector coordinates) on each side More...
std::array< float, 2 >	m_yCentroidPreAvgSubtr {}
	x centroid after geomerty correction and before average subtraction on each side More...
std::array< float, 2 >	m_xCentroid {}
	y centroid after geomerty correction and before average subtraction on each side More...
std::array< float, 2 >	m_yCentroid {}
	x centroid after geomerty correction and after average subtraction on each side More...
std::array< std::vector< float >, 2 >	m_xRowCentroid
	y centroid after geomerty correction and after average subtraction on each side More...
std::array< std::vector< float >, 2 >	m_yColCentroid
	the x centroid for each row on each side More...
std::array< float, 2 >	m_reactionPlaneAngle {}
	the y centroid for each column on each side More...
float	m_cosDeltaReactionPlaneAngle = 0
	reaction plane angle on each side More...
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_xposRelKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_yposRelKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_rowKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_colKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_ZDCModuleCalibEnergyKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_ZDCModuleStatusKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_RPDChannelAmplitudeKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_RPDChannelAmplitudeCalibKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_RPDChannelMaxADCKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_RPDChannelMaxADCCalibKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_RPDChannelPileupFracKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_RPDChannelStatusKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_RPDSideStatusKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_ZDCFinalEnergyKey
SG::ReadDecorHandleKey< xAOD::ZdcModuleContainer >	m_ZDCStatusKey
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) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
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 ZDC::RpdSubtractCentroidTool::SubstepStatus

strongprivate

cosine of difference between reaction plane angles of the two sides

Enumerator
Success
Failure
SkipEvent

Definition at line 170 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()

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

inlinestaticprivate

Definition at line 102 of file RpdSubtractCentroidTool.h.

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

calculateDetectorCentroid()

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

private

Definition at line 387 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 424 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;
  // 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;
  m_reactionPlaneAngle.at(side) = angle;
}

checkZdcRpdValidity()

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

private

Definition at line 292 of file RpdSubtractCentroidTool.cxx.

                                                                   {
  if (m_readZDCDecorations) {
    if (!m_ZDCSideStatus->at(side)) {
      // 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() [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.

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

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.

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

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.

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

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.

  {
    return PBASE::declareProperty(t);
  }

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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

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.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  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.

{ return m_detStore; }

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.

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

{ 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

geometryCorrection()

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

private

ROTATIONS CORRECTIONS GO HERE

Definition at line 413 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 ( )

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

                                               {
  // first initialize reconstruction parameters from config string
  if (m_configuration == "default" || m_configuration == "pp2023" || m_configuration == "PbPb2023") {
    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;
  } else if (m_configuration == "pp2024" || m_configuration == "PbPb2024") {
    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());
 
  // zdc modules read keys
  ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_xposRelKey, ".xposRel"));
  ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_yposRelKey, ".yposRel"));
  ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_rowKey, ".row"));
  ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_colKey, ".col"));
 
  if (m_readZDCDecorations) {
    ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_ZDCModuleCalibEnergyKey, ".CalibEnergy"));
    ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_ZDCModuleStatusKey, ".Status"));
  }
  ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_RPDChannelAmplitudeKey, ".RPDChannelAmplitude"));
  ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_RPDChannelAmplitudeCalibKey, ".RPDChannelAmplitudeCalib"));
  ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_RPDChannelMaxADCKey, ".RPDChannelMaxADC"));
  ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_RPDChannelMaxADCCalibKey, ".RPDChannelMaxADCCalib"));
  ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_RPDChannelPileupFracKey, ".RPDChannelPileupFrac"));
  ATH_CHECK(initializeKey(m_ZDCModuleContainerName, m_RPDChannelStatusKey, ".RPDChannelStatus"));
 
  // zdc sums read keys
  ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_RPDSideStatusKey, ".RPDStatus"));
  if (m_readZDCDecorations) {
    ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_ZDCFinalEnergyKey, ".FinalEnergy"));
    ATH_CHECK(initializeKey(m_ZDCSumContainerName, m_ZDCStatusKey, ".Status"));
  }
 
  // zdc sums write keys
  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() [1/2]

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

private

Definition at line 36 of file RpdSubtractCentroidTool.cxx.

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

initializeKey() [2/2]

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

private

Definition at line 41 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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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

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

inlinestaticprivate

Definition at line 101 of file RpdSubtractCentroidTool.h.

{ return x >= 0; }

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() [1/2]

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

print() [2/2]

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

pure virtualinherited

Print the state of the tool.

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

readAOD()

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

private

Definition at line 195 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;
  }
 
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float> xposRelHandle(m_xposRelKey);
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float> yposRelHandle(m_yposRelKey);
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, unsigned short> rowHandle(m_rowKey);
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, unsigned short> colHandle(m_colKey);
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float> rpdChannelSumAdcHandle(m_RPDChannelAmplitudeKey);
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float> rpdChannelSumAdcCalibHandle(m_RPDChannelAmplitudeCalibKey);
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float> rpdChannelMaxADCHandle(m_RPDChannelMaxADCKey);
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float> rpdChannelMaxADCCalibHandle(m_RPDChannelMaxADCCalibKey);
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float> rpdChannelPileupFracHandle(m_RPDChannelPileupFracKey);
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, unsigned int> rpdChannelStatusHandle(m_RPDChannelStatusKey);
  SG::ReadDecorHandle<xAOD::ZdcModuleContainer, unsigned int> rpdSideStatusHandle(m_RPDSideStatusKey);
  std::optional<SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float>> zdcModuleCalibEnergyHandle;
  std::optional<SG::ReadDecorHandle<xAOD::ZdcModuleContainer, unsigned int>> zdcModuleStatusHandle;
  std::optional<SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float>> zdcFinalEnergyHandle;
  std::optional<SG::ReadDecorHandle<xAOD::ZdcModuleContainer, unsigned int>> zdcStatusHandle;
  if (m_readZDCDecorations) {
    zdcModuleCalibEnergyHandle = SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float>(m_ZDCModuleCalibEnergyKey);
    zdcModuleStatusHandle = SG::ReadDecorHandle<xAOD::ZdcModuleContainer, unsigned int>(m_ZDCModuleStatusKey);
    zdcFinalEnergyHandle = SG::ReadDecorHandle<xAOD::ZdcModuleContainer, float>(m_ZDCFinalEnergyKey);
    zdcStatusHandle = SG::ReadDecorHandle<xAOD::ZdcModuleContainer, unsigned int>(m_ZDCStatusKey);
  }
 
  ATH_MSG_DEBUG("Processing modules");
 
  for (auto 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) = (*zdcModuleCalibEnergyHandle)(*zdcModule);
        m_EMStatus->at(side) = (*zdcModuleStatusHandle)(*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
      unsigned int const channel = zdcModule->zdcChannel();
      auto const& row = rowHandle(*zdcModule);
      auto const& col = colHandle(*zdcModule);
      m_RPDChannelData.at(side).at(row).at(col).channel = channel;
      m_RPDChannelData.at(side).at(row).at(col).xposRel = xposRelHandle(*zdcModule);
      m_RPDChannelData.at(side).at(row).at(col).yposRel = yposRelHandle(*zdcModule);
      m_RPDChannelData.at(side).at(row).at(col).row = rowHandle(*zdcModule);
      m_RPDChannelData.at(side).at(row).at(col).col = colHandle(*zdcModule);
      if (m_useRPDSumAdc) {
        if (m_useCalibDecorations) {
          m_RPDChannelData.at(side).at(row).at(col).amp = rpdChannelSumAdcCalibHandle(*zdcModule);
        } else {
          m_RPDChannelData.at(side).at(row).at(col).amp = rpdChannelSumAdcHandle(*zdcModule);
        }
      } else {
        if (m_useCalibDecorations) {
          m_RPDChannelData.at(side).at(row).at(col).amp = rpdChannelMaxADCCalibHandle(*zdcModule);
        } else {
          m_RPDChannelData.at(side).at(row).at(col).amp = rpdChannelMaxADCHandle(*zdcModule);
        }
      }
      m_RPDChannelData.at(side).at(row).at(col).pileupFrac = rpdChannelPileupFracHandle(*zdcModule);
      m_RPDChannelData.at(side).at(row).at(col).status = rpdChannelStatusHandle(*zdcModule);
    }
  }
 
  for (auto 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) = rpdSideStatusHandle(*zdcSum);
    if (m_ZDCSideStatus) m_ZDCSideStatus->at(side) = (*zdcStatusHandle)(*zdcSum);
    if (m_ZDCFinalEnergy) m_ZDCFinalEnergy->at(side) = (*zdcFinalEnergyHandle)(*zdcSum);
  }
 
  return SubstepStatus::Success;
}

recoZdcModules()

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

overridevirtual

Implements ZDC::IZdcAnalysisTool.

Definition at line 481 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 518 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 173 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 419 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 349 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 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.

                                               {
    // 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 437 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 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 131 of file RpdSubtractCentroidTool.h.

m_alignmentYOffset

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

private

geometry + crossing angle correction in x (ATLAS coordinates)

Definition at line 132 of file RpdSubtractCentroidTool.h.

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 137 of file RpdSubtractCentroidTool.h.

m_avgYCentroid

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

private

average x centroid

Definition at line 138 of file RpdSubtractCentroidTool.h.

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 257 of file RpdSubtractCentroidTool.h.

m_centroidStatus

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

private

event status

Definition at line 143 of file RpdSubtractCentroidTool.h.

m_centroidStatusKey

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

private

Initial value:

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

Definition at line 261 of file RpdSubtractCentroidTool.h.

m_colKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_colKey

private

Initial value:

{
    this, "colKey", "",
    "Column index of RPD channel"
  }

Definition at line 207 of file RpdSubtractCentroidTool.h.

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 166 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 309 of file RpdSubtractCentroidTool.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_EMCalibEnergy

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

private

ZDC final (calibrated) energy on each side.

Definition at line 125 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 126 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 191 of file RpdSubtractCentroidTool.h.

m_eventValid

bool ZDC::RpdSubtractCentroidTool::m_eventValid = false

private

average y centroid

Definition at line 142 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 106 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 165 of file RpdSubtractCentroidTool.h.

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 305 of file RpdSubtractCentroidTool.h.

m_readZDCDecorations

bool ZDC::RpdSubtractCentroidTool::m_readZDCDecorations = false

private

Definition at line 107 of file RpdSubtractCentroidTool.h.

m_rowKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_rowKey

private

Initial value:

{
    this, "rowKey", "",
    "Row index of RPD channel"
  }

Definition at line 203 of file RpdSubtractCentroidTool.h.

m_RPDChannelAmplitudeCalibKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_RPDChannelAmplitudeCalibKey

private

Initial value:

{
    this, "RPDChannelAmplitudeCalibKey", "",
    "Calibrated RPD channel amplitude"
  }

Definition at line 223 of file RpdSubtractCentroidTool.h.

m_RPDChannelAmplitudeKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_RPDChannelAmplitudeKey

private

Initial value:

{
    this, "RPDChannelAmplitudeKey", "",
    "RPD channel amplitude"
  }

Definition at line 219 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 127 of file RpdSubtractCentroidTool.h.

m_RPDChannelMaxADCCalibKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_RPDChannelMaxADCCalibKey

private

Initial value:

{
    this, "RPDChannelMaxADCCalibKey", "",
    "Calibrated RPD channel max ADC"
  }

Definition at line 231 of file RpdSubtractCentroidTool.h.

m_RPDChannelMaxADCKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_RPDChannelMaxADCKey

private

Initial value:

{
    this, "RPDChannelMaxADCKey", "",
    "RPD channel max ADC"
  }

Definition at line 227 of file RpdSubtractCentroidTool.h.

m_RPDChannelPileupFracKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_RPDChannelPileupFracKey

private

Initial value:

{
    this, "RPDChannelPileupFracKey", "",
    "RPD channel (out of time) pileup as a fraction of non-pileup sum"
  }

Definition at line 235 of file RpdSubtractCentroidTool.h.

m_RPDChannelStatusKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_RPDChannelStatusKey

private

Initial value:

{
    this, "RPDChannelStatusKey", "",
    "RPD channel status word"
  }

Definition at line 239 of file RpdSubtractCentroidTool.h.

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 265 of file RpdSubtractCentroidTool.h.

m_RPDSideStatus

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

private

Definition at line 122 of file RpdSubtractCentroidTool.h.

m_RPDSideStatusKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_RPDSideStatusKey

private

Initial value:

{
    this, "RPDStatusKey", "",
    "RPD side status word"
  }

Definition at line 243 of file RpdSubtractCentroidTool.h.

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 269 of file RpdSubtractCentroidTool.h.

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 144 of file RpdSubtractCentroidTool.h.

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 149 of file RpdSubtractCentroidTool.h.

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 148 of file RpdSubtractCentroidTool.h.

m_subtrAmpSum

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

private

subtracted amplitude for each column on each side

Definition at line 150 of file RpdSubtractCentroidTool.h.

m_useCalibDecorations

bool ZDC::RpdSubtractCentroidTool::m_useCalibDecorations {}

private

Definition at line 97 of file RpdSubtractCentroidTool.h.

m_useRPDSumAdc

bool ZDC::RpdSubtractCentroidTool::m_useRPDSumAdc {}

private

Definition at line 96 of file RpdSubtractCentroidTool.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::RpdSubtractCentroidTool::m_writeAux {}

private

Definition at line 77 of file RpdSubtractCentroidTool.h.

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 155 of file RpdSubtractCentroidTool.h.

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 289 of file RpdSubtractCentroidTool.h.

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 153 of file RpdSubtractCentroidTool.h.

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 281 of file RpdSubtractCentroidTool.h.

m_xCentroidPreGeomCorPreAvgSubtr

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

private

subtracted amplitude sum on each side

Definition at line 151 of file RpdSubtractCentroidTool.h.

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 273 of file RpdSubtractCentroidTool.h.

m_xposRelKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_xposRelKey

private

Initial value:

{
    this, "xposRelKey", "",
    "X position of RPD tile center relative to center of RPD active area"
  }

Definition at line 195 of file RpdSubtractCentroidTool.h.

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 157 of file RpdSubtractCentroidTool.h.

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 297 of file RpdSubtractCentroidTool.h.

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 156 of file RpdSubtractCentroidTool.h.

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 293 of file RpdSubtractCentroidTool.h.

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 154 of file RpdSubtractCentroidTool.h.

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 285 of file RpdSubtractCentroidTool.h.

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 152 of file RpdSubtractCentroidTool.h.

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 277 of file RpdSubtractCentroidTool.h.

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 161 of file RpdSubtractCentroidTool.h.

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 301 of file RpdSubtractCentroidTool.h.

m_yposRelKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_yposRelKey

private

Initial value:

{
    this, "yposRelKey", "",
    "Y position of RPD tile center relative to center of RPD active area"
  }

Definition at line 199 of file RpdSubtractCentroidTool.h.

m_ZDCFinalEnergy

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

private

ZDC analysis status on each side.

Definition at line 124 of file RpdSubtractCentroidTool.h.

m_ZDCFinalEnergyKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_ZDCFinalEnergyKey

private

Initial value:

{
    this, "FinalEnergyKey", "",
    "ZDC final energy"
  }

Definition at line 247 of file RpdSubtractCentroidTool.h.

m_ZDCModuleCalibEnergyKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_ZDCModuleCalibEnergyKey

private

Initial value:

{
    this, "CalibEnergyKey", "",
    "ZDC module amplitude"
  }

Definition at line 211 of file RpdSubtractCentroidTool.h.

m_ZDCModuleContainerName

std::string ZDC::RpdSubtractCentroidTool::m_ZDCModuleContainerName

private

Definition at line 75 of file RpdSubtractCentroidTool.h.

m_ZDCModuleStatusKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_ZDCModuleStatusKey

private

Initial value:

{
    this, "ZDCModuleStatusKey", "",
    "ZDC module status word"
  }

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

m_ZDCStatusKey

SG::ReadDecorHandleKey<xAOD::ZdcModuleContainer> ZDC::RpdSubtractCentroidTool::m_ZDCStatusKey

private

Initial value:

{
    this, "ZDCStatusKey", "",
    "ZDC sum status word"
  }

Definition at line 251 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:

• RpdSubtractCentroidTool.h
• RpdSubtractCentroidTool.cxx