CaloCalibClusterMomentsMaker2 Class Reference

Calculate calibration hit based moments for CaloCluster objects using Primary Particle ID. More...

#include <CaloCalibClusterMomentsMaker2.h>

Inheritance diagram for CaloCalibClusterMomentsMaker2:

Classes
class	CalibHitIPhiIEtaRange
class	MyCellInfo
class	MyClusInfo

Public Types
typedef std::map< Identifier, MyCellInfo >	CellInfoSet_t
typedef std::vector< MyClusInfo >	ClusInfo_t
using	ClusList = std::vector<std::vector<int> >
typedef std::pair< std::string, xAOD::CaloCluster::MomentType >	moment_name_pair
typedef std::vector< moment_name_pair >	moment_name_vector
typedef std::set< moment_name_pair >	moment_name_set

Public Member Functions
	CaloCalibClusterMomentsMaker2 (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *theClusColl) const override
	Execute on an entire collection of clusters.
virtual StatusCode	initialize () override
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
	DeclareInterfaceID (CaloClusterCollectionProcessor, 1, 0)

Static Public Member Functions
static void	initializeOutOfClusterDistanceTables (int n_phi_out, int n_eta_out, double out_phi_max, double out_eta_max, const double(&rmaxOut)[3], std::array< std::vector< std::vector< CalibHitIPhiIEtaRange > >, 3 > &i_phi_eta)
	Precompute eta/phi lookup tables for quick out-of-cluster hit association to clusters.
static void	buildCellInfoMap (const xAOD::CaloClusterContainer &theClusColl, CellInfoSet_t &cellInfo)
	Build a map of calorimeter cells contributing to clusters.
static void	buildOutOfClusterClusterLists (const xAOD::CaloClusterContainer &theClusColl, const ClusInfo_t &clusInfoVec, int n_phi_out, int n_eta_out, double out_phi_max, double out_eta_max, const std::array< std::vector< std::vector< CalibHitIPhiIEtaRange > >, 3 > &i_phi_eta, const std::array< bool, 3 > &doOutOfCluster, const std::array< ClusList *, 3 > &clusLists)
	Build lookup lists of clusters for out-of-cluster energy sharing.
template<class InvalidUniqueIdHandler>
static void	accumulateClusterCalibHits (const std::vector< const CaloCalibrationHitContainer * > &v_cchc, const CellInfoSet_t &cellInfo, const CaloCell_ID &calo_id, ClusInfo_t &clusInfoVec, unsigned int &nHitsTotal, unsigned int &nHitsWithoutParticleUID, bool useParticleID, InvalidUniqueIdHandler &&invalidUniqueIdHandler)
	Accumulate calibration-hit energy inside clusters.
template<class AddOutOfClusterEnergy>
static void	accumulateOutOfClusterEnergy (const std::vector< const CaloCalibrationHitContainer * > &v_cchc, const CellInfoSet_t &cellInfo, const CaloDetDescrManager &calo_dd_man, const ClusInfo_t &clusInfoVec, int n_phi_out, int n_eta_out, double out_phi_max, double out_eta_max, const std::array< bool, 3 > &doOutOfCluster, const std::array< const ClusList *, 3 > &clusLists, AddOutOfClusterEnergy &&addOutOfClusterEnergy)

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	keys_dm_energy_sharing { kMatchDmOff , kMatchDmLoose , kMatchDmMedium , kMatchDmTight }
enum	keys_calib_frac_origin { kCalibFracEM , kCalibFracHAD , kCalibFracREST , kCalibFracMax }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
template<class AddDeadMaterialEnergy>
void	accumulateDeadMaterialEnergy (const std::vector< const CaloCalibrationHitContainer * > &v_dmcchc, const xAOD::CaloClusterContainer &theClusColl, const ClusInfo_t &clusInfoVec, const ClusList &clusList, bool useParticleID, AddDeadMaterialEnergy &&addDeadMaterialEnergy) const
	Accumulate dead-material calibration-hit energy assigned to clusters.
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 double	angle_mollier_factor (double x)

Private Attributes
std::vector< std::string >	m_momentsNames
moment_name_vector	m_validNames
moment_name_set	m_validMoments
std::vector< std::string >	m_momentsNamesAOD
std::set< xAOD::CaloCluster::MomentType >	m_momentsAOD
SG::ReadHandleKeyArray< CaloCalibrationHitContainer >	m_CalibrationHitContainerNames
SG::ReadHandleKeyArray< CaloCalibrationHitContainer >	m_DMCalibrationHitContainerNames
SG::ReadHandleKey< xAOD::TruthParticleContainer >	m_truthParticleContainerKey {this,"TruthParticles","TruthParticles","ReadHandleKey for truth particle container"}
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloDetDescrMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}
const CaloCell_ID *	m_calo_id {}
const CaloDM_ID *	m_caloDM_ID {}
const CaloDmDescrManager *	m_caloDmDescrManager {}
int	m_n_phi_out {}
int	m_n_eta_out {}
double	m_out_phi_max {}
double	m_out_eta_max {}
double	m_rmaxOut [3] {}
std::array< std::vector< std::vector< CalibHitIPhiIEtaRange > >, 3 >	m_i_phi_eta
std::atomic< bool >	m_foundAllContainers {}
bool	m_doDeadEnergySharing {}
bool	m_doOutOfClusterL {}
bool	m_doOutOfClusterM {}
bool	m_doOutOfClusterT {}
bool	m_doDeadL {}
bool	m_doDeadM {}
bool	m_doDeadT {}
bool	m_useParticleID {}
bool	m_doCalibFrac {}
float	m_energyMin {}
float	m_energyMinCalib {}
float	m_apars_alpha {}
float	m_apars_r0 {}
int	m_MatchDmType {}
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

Calculate calibration hit based moments for CaloCluster objects using Primary Particle ID.

Version

Id

CaloCalibClusterMomentsMaker2.h,v 1.8 2009-05-18 16:16:48 pospelov Exp

Author

Sven Menke menke.nosp@m.@mpp.nosp@m.mu.mp.nosp@m.g.de, Gennady Pospelov guenn.nosp@m.adi..nosp@m.pospe.nosp@m.lov@.nosp@m.cern..nosp@m.ch

Date

17-June-2008

Definition at line 42 of file CaloCalibClusterMomentsMaker2.h.

Member Typedef Documentation

CellInfoSet_t

typedef std::map<Identifier, MyCellInfo> CaloCalibClusterMomentsMaker2::CellInfoSet_t

Definition at line 57 of file CaloCalibClusterMomentsMaker2.h.

ClusInfo_t

typedef std::vector<MyClusInfo> CaloCalibClusterMomentsMaker2::ClusInfo_t

Definition at line 84 of file CaloCalibClusterMomentsMaker2.h.

ClusList

using CaloCalibClusterMomentsMaker2::ClusList = std::vector<std::vector<int> >

Definition at line 85 of file CaloCalibClusterMomentsMaker2.h.

moment_name_pair

typedef std::pair<std::string, xAOD::CaloCluster::MomentType> CaloCalibClusterMomentsMaker2::moment_name_pair

Definition at line 87 of file CaloCalibClusterMomentsMaker2.h.

moment_name_set

typedef std::set<moment_name_pair> CaloCalibClusterMomentsMaker2::moment_name_set

Definition at line 89 of file CaloCalibClusterMomentsMaker2.h.

moment_name_vector

typedef std::vector<moment_name_pair> CaloCalibClusterMomentsMaker2::moment_name_vector

Definition at line 88 of file CaloCalibClusterMomentsMaker2.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

keys_calib_frac_origin

enum CaloCalibClusterMomentsMaker2::keys_calib_frac_origin

private

Enumerator
kCalibFracEM
kCalibFracHAD
kCalibFracREST
kCalibFracMax

Definition at line 466 of file CaloCalibClusterMomentsMaker2.h.

{kCalibFracEM, kCalibFracHAD, kCalibFracREST, kCalibFracMax};

keys_dm_energy_sharing

enum CaloCalibClusterMomentsMaker2::keys_dm_energy_sharing

private

Enumerator
kMatchDmOff
kMatchDmLoose
kMatchDmMedium
kMatchDmTight

Definition at line 465 of file CaloCalibClusterMomentsMaker2.h.

{kMatchDmOff, kMatchDmLoose, kMatchDmMedium, kMatchDmTight};

Constructor & Destructor Documentation

CaloCalibClusterMomentsMaker2()

CaloCalibClusterMomentsMaker2::CaloCalibClusterMomentsMaker2	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 104 of file CaloCalibClusterMomentsMaker2.cxx.

  : AthAlgTool(type, name, parent), 
    m_calo_id(nullptr),
    m_caloDM_ID(nullptr),
    m_caloDmDescrManager(nullptr),
    m_useParticleID(true),
    m_energyMin(200*MeV),
    m_energyMinCalib(20*MeV),
    m_apars_alpha(0.5),
    m_apars_r0(0.2),
    m_MatchDmType(kMatchDmLoose)
{
  declareInterface<CaloClusterCollectionProcessor>(this);
  // Name(s) of Moments to calculate
  declareProperty("MomentsNames", m_momentsNames);
  m_validNames.reserve(s_validMomentNames.size());
  for (const auto& [thisName, moment] : s_validMomentNames) {
    m_validNames.emplace_back(thisName, moment);
  }
 
  // Name(s) of Moments which can be stored on the AOD - all others go to ESD
  m_momentsNamesAOD.reserve(s_aodMomentNames.size());
  for (const std::string_view thisName : s_aodMomentNames) {
    m_momentsNamesAOD.emplace_back(thisName);
  }
 
  declareProperty("AODMomentsNames", m_momentsNamesAOD);
  declareProperty("CalibrationHitContainerNames", m_CalibrationHitContainerNames);
  declareProperty("DMCalibrationHitContainerNames", m_DMCalibrationHitContainerNames);
  m_n_phi_out = 127; // not more than 127 since we store indices (-127,...-1,0,...,126) and have 8 bits only
  m_n_eta_out = 127;
  m_out_phi_max = M_PI;
  m_out_eta_max = 6;
 
  m_rmaxOut[0] = 1.0;
  m_rmaxOut[1] = 0.5; 
  m_rmaxOut[2] = 0.3;
 
  for (int im = 0; im < 3; im++) {
    m_i_phi_eta[im].resize(m_n_eta_out);
  }
  m_doDeadEnergySharing = false;
  m_foundAllContainers = false;
  m_doOutOfClusterL = false;
  m_doOutOfClusterM = false;
  m_doOutOfClusterT = false;
  m_doDeadL = false;
  m_doDeadM = false;
  m_doDeadT = false;
  m_doCalibFrac = false;
 
  declareProperty("MatchDmType", m_MatchDmType);
  declareProperty("UseParticleID", m_useParticleID);
}

Member Function Documentation

accumulateClusterCalibHits()

template<class InvalidUniqueIdHandler>

void CaloCalibClusterMomentsMaker2::accumulateClusterCalibHits ( const std::vector< const CaloCalibrationHitContainer * > & v_cchc, const CellInfoSet_t & cellInfo, const CaloCell_ID & calo_id, ClusInfo_t & clusInfoVec, unsigned int & nHitsTotal, unsigned int & nHitsWithoutParticleUID, bool useParticleID, InvalidUniqueIdHandler && invalidUniqueIdHandler )

inlinestatic

Accumulate calibration-hit energy inside clusters.

Loops over the input calibration hit containers and, for hits whose cells belong to one or more clusters, adds the corresponding weighted energy to the per-cluster calibration-energy bookkeeping.

If useParticleID is true, the per-particle contribution map is also filled and hits with undefined particle ID are counted. If false, only the total in-cluster calibration energy and per-sampling contributions are accumulated.

Template Parameters

InvalidUniqueIdHandler

Callable invoked when an invalid unique ID is encountered.

Parameters

	v_cchc	Input calibration hit containers.
	cellInfo	Map from cell Identifier to per-cluster contribution info.
	calo_id	Calorimeter cell identifier helper.
[out]	clusInfoVec	Per-cluster calibration information to be updated.
[out]	nHitsTotal	Total number of calibration hits processed.
[out]	nHitsWithoutParticleUID	Number of hits with undefined particle ID.
	useParticleID	Flag controlling whether truth particle IDs are used.
	invalidUniqueIdHandler	Callback invoked when an invalid unique ID is found.

Definition at line 199 of file CaloCalibClusterMomentsMaker2.h.

  {
    for (const CaloCalibrationHitContainer* cchc : v_cchc) {
      for (const CaloCalibrationHit* hit : *cchc) {
        const Identifier myId = hit->cellID();
        typename CellInfoSet_t::const_iterator pos = cellInfo.find(myId);
 
        if (pos != cellInfo.end()) {
          const CaloSampling::CaloSample nsmp =
              CaloSampling::CaloSample(calo_id.calo_sample(myId));
 
          for (const std::pair<int, double>& p : pos->second) {
            const int iClus = p.first;
            const double weight = p.second;
 
            if (useParticleID) {
              const int uniqueID = HepMC::uniqueID(hit);
              if (uniqueID == HepMC::INVALID_PARTICLE_ID) {
                invalidUniqueIdHandler();
                break;
              }
              clusInfoVec[iClus].Add(weight * hit->energyTotal(),
                                     nsmp,
                                     static_cast<unsigned int>(uniqueID));
            }
            else {
              clusInfoVec[iClus].Add(weight * hit->energyTotal(), nsmp);
            }
          }
        }
 
        if (useParticleID && HepMC::uniqueID(hit) == HepMC::UNDEFINED_ID) {
          ++nHitsWithoutParticleUID;
        }
        ++nHitsTotal;
      }
    }
  }

accumulateDeadMaterialEnergy()

template<class AddDeadMaterialEnergy>

void CaloCalibClusterMomentsMaker2::accumulateDeadMaterialEnergy ( const std::vector< const CaloCalibrationHitContainer * > & v_dmcchc, const xAOD::CaloClusterContainer & theClusColl, const ClusInfo_t & clusInfoVec, const ClusList & clusList, bool useParticleID, AddDeadMaterialEnergy && addDeadMaterialEnergy ) const

inlineprivate

Accumulate dead-material calibration-hit energy assigned to clusters.

Reusable implementation of the MomentsMaker2 "way2" dead-material sharing algorithm. Dead-material hits are assigned to nearby clusters using the same sampling-neighbour, energy-threshold and distance-weighting criteria as ENG_CALIB_DEAD_* in CaloCalibClusterMomentsMaker2.

Template Parameters

AddDeadMaterialEnergy

Callable with signature addDeadMaterialEnergy(int iClus, int uniqueID, int nDmArea, double energy).

Definition at line 337 of file CaloCalibClusterMomentsMaker2.h.

  {
    for (const CaloCalibrationHitContainer* dmcchc : v_dmcchc) {
      for (const CaloCalibrationHit* hit : *dmcchc) {
        const Identifier myId = hit->cellID();
        if (!m_calo_id->is_lar_dm(myId) && !m_calo_id->is_tile_dm(myId)) {
          continue;
        }
 
        const CaloDmDescrElement* myCDDE = m_caloDmDescrManager->get_element(myId);
        if (!myCDDE) {
          continue;
        }
 
        int uniqueID = HepMC::UNDEFINED_ID;
        if (useParticleID) {
          uniqueID = HepMC::uniqueID(hit);
        }
 
        const int jeO = static_cast<int>(std::floor(m_n_eta_out * (myCDDE->eta() / m_out_eta_max)));
        if (jeO < -m_n_eta_out || jeO >= m_n_eta_out) {
          continue;
        }
 
        int jpO = static_cast<int>(std::floor(m_n_phi_out * (myCDDE->phi() / m_out_phi_max)));
        if (jpO < -m_n_phi_out) {
          jpO += 2 * m_n_phi_out;
        }
        if (jpO >= m_n_phi_out) {
          jpO -= 2 * m_n_phi_out;
        }
 
        const int nDmArea = m_caloDmDescrManager->get_dm_area(myId);
        const CaloDmRegion* dmRegion = m_caloDmDescrManager->get_dm_region(myId);
        if (!dmRegion) {
          continue;
        }
 
        std::vector<int> hitClusIndex;
        std::vector<double> hitClusEffEnergy;
        hitClusIndex.reserve(theClusColl.size());
        hitClusEffEnergy.reserve(theClusColl.size());
        double hitClusNorm = 0.0;
 
        const std::vector<int>& matchingClusters =
            clusList[(jpO + m_n_phi_out) * (2 * m_n_eta_out + 1) + jeO + m_n_eta_out];
 
        for (int iClus : matchingClusters) {
          const xAOD::CaloCluster* theCluster = theClusColl.at(iClus);
          const MyClusInfo& clusInfo = clusInfoVec[iClus];
          auto pos = clusInfo.engCalibParticle.find(uniqueID);
          if (pos == clusInfo.engCalibParticle.end()) {
            continue;
          }
 
          const double engClusTruthUniqueIDCalib = pos->second.engTot;
          if (engClusTruthUniqueIDCalib <= m_energyMinCalib || theCluster->e() <= m_energyMin) {
            continue;
          }
 
          double sum_smp_energy = 0.0;
          for (unsigned int i_smp = 0; i_smp < dmRegion->m_CaloSampleNeighbours.size(); ++i_smp) {
            const CaloSampling::CaloSample nsmp =
                static_cast<CaloSampling::CaloSample>(dmRegion->m_CaloSampleNeighbours[i_smp]);
            if ((dmRegion->m_CaloSampleEtaMin[i_smp] - 0.5) <= theCluster->eta() &&
                theCluster->eta() <= (dmRegion->m_CaloSampleEtaMax[i_smp] + 0.5)) {
              sum_smp_energy += pos->second.engSmp[nsmp];
            }
          }
          if (sum_smp_energy <= 0.0) {
            continue;
          }
 
          double phi_diff = myCDDE->phi() - theCluster->phi();
          if (phi_diff <= -M_PI) {
            phi_diff += 2. * M_PI;
          }
          else if (phi_diff > M_PI) {
            phi_diff -= 2. * M_PI;
          }
          const double eta_diff = myCDDE->eta() - theCluster->eta();
          const float distance = std::sqrt(eta_diff * eta_diff + phi_diff * phi_diff);
          const double effEner = std::pow(sum_smp_energy, m_apars_alpha) * std::exp(-distance / m_apars_r0);
 
          hitClusIndex.push_back(iClus);
          hitClusEffEnergy.push_back(effEner);
          hitClusNorm += effEner;
        }
 
        if (hitClusNorm <= 0.0) {
          continue;
        }
 
        const double inv_hitClusNorm = 1.0 / hitClusNorm;
        for (std::size_t i = 0; i < hitClusIndex.size(); ++i) {
          const int iClus = hitClusIndex[i];
          const double dm_weight = hitClusEffEnergy[i] * inv_hitClusNorm;
          addDeadMaterialEnergy(iClus, uniqueID, nDmArea, hit->energyTotal() * dm_weight);
        }
      }
    }
  }

accumulateOutOfClusterEnergy()

template<class AddOutOfClusterEnergy>

void CaloCalibClusterMomentsMaker2::accumulateOutOfClusterEnergy ( const std::vector< const CaloCalibrationHitContainer * > & v_cchc, const CellInfoSet_t & cellInfo, const CaloDetDescrManager & calo_dd_man, const ClusInfo_t & clusInfoVec, int n_phi_out, int n_eta_out, double out_phi_max, double out_eta_max, const std::array< bool, 3 > & doOutOfCluster, const std::array< const ClusList *, 3 > & clusLists, AddOutOfClusterEnergy && addOutOfClusterEnergy )

inlinestatic

Definition at line 247 of file CaloCalibClusterMomentsMaker2.h.

  {
    for (const CaloCalibrationHitContainer* cchc : v_cchc) {
      for (const CaloCalibrationHit* hit : *cchc) {
        const Identifier myId = hit->cellID();
        typename CellInfoSet_t::const_iterator pos = cellInfo.find(myId);
        if (pos != cellInfo.end()) {
          continue;
        }
 
        const CaloDetDescrElement* myCDDE = calo_dd_man.get_element(myId);
        const int uniqueID = HepMC::uniqueID(hit);
        if (!myCDDE) {
          continue;
        }
 
        const int jeO = static_cast<int>(std::floor(n_eta_out * (myCDDE->eta() / out_eta_max)));
        if (jeO < -n_eta_out || jeO >= n_eta_out) {
          continue;
        }
 
        int jpO = static_cast<int>(std::floor(n_phi_out * (myCDDE->phi() / out_phi_max)));
        if (jpO < -n_phi_out) jpO += 2 * n_phi_out;
        if (jpO >= n_phi_out) jpO -= 2 * n_phi_out;
 
        for (unsigned int ii = 0; ii < 3; ++ii) {
          const ClusList* pClusList = clusLists[ii];
          if (!doOutOfCluster[ii] || pClusList == nullptr) {
            continue;
          }
 
          double hitClusNorm = 0.0;
          std::vector<int> hitClusIndex;
          std::vector<double> hitClusEffEnergy;
          const std::vector<int>& matchingClusters =
              (*pClusList)[(jpO + n_phi_out) * (2 * n_eta_out + 1) + jeO + n_eta_out];
 
          for (int iClus : matchingClusters) {
            const MyClusInfo& clusInfo = clusInfoVec[iClus];
            auto partPos = clusInfo.engCalibParticle.find(uniqueID);
            if (partPos == clusInfo.engCalibParticle.end()) {
              continue;
            }
            hitClusNorm += partPos->second.engTot;
            hitClusEffEnergy.push_back(partPos->second.engTot);
            hitClusIndex.push_back(iClus);
          }
 
          if (hitClusNorm <= 0.0) {
            continue;
          }
 
          const double inv_hitClusNorm = 1.0 / hitClusNorm;
          for (std::size_t i = 0; i < hitClusIndex.size(); ++i) {
            const int iClus = hitClusIndex[i];
            const double w = hitClusEffEnergy[i] * inv_hitClusNorm;
            addOutOfClusterEnergy(ii, iClus, uniqueID, w * hit->energyTotal());
          }
        }
      }
    }
  }

angle_mollier_factor()

double CaloCalibClusterMomentsMaker2::angle_mollier_factor ( double x )

staticprivate

Definition at line 787 of file CaloCalibClusterMomentsMaker2.cxx.

{
  double eta = fabs(x);
  double ff;
  if (eta < 1.6) {
    ff = atan(5.0 * 1.7 / (200.0 * cosh(eta)));
  } else if (eta < 3.2) {
    ff = atan(5.0 * 1.6 / (420. / tanh(eta)));
  } else {
    ff = atan(5.0 * 0.95 / (505. / tanh(eta)));
  }
  return ff * (1. / atan(5.0 * 1.7 / 200.0));
}

buildCellInfoMap()

void CaloCalibClusterMomentsMaker2::buildCellInfoMap ( const xAOD::CaloClusterContainer & theClusColl, CellInfoSet_t & cellInfo )

static

Build a map of calorimeter cells contributing to clusters.

Iterates over all clusters and their constituent cells and constructs a map keyed by cell Identifier. For each cell, stores the list of clusters it contributes to together with the corresponding weights.

This structure is used to efficiently associate calibration hits with clusters during subsequent accumulation steps.

Parameters

	theClusColl	Input container of calorimeter clusters.
[out]	cellInfo	Map from cell Identifier to per-cluster contribution info.

Definition at line 319 of file CaloCalibClusterMomentsMaker2.cxx.

{
  cellInfo.clear();
 
  int iClus = 0;
  for (const xAOD::CaloCluster* theCluster : theClusColl) {
    xAOD::CaloCluster::const_cell_iterator cellIter = theCluster->cell_begin();
    xAOD::CaloCluster::const_cell_iterator cellIterEnd = theCluster->cell_end();
 
    for (; cellIter != cellIterEnd; ++cellIter) {
      const CaloCell* pCell = *cellIter;
      const Identifier myId = pCell->ID();
 
      MyCellInfo info(iClus, cellIter.weight());
      CellInfoSet_t::iterator bookmark = cellInfo.lower_bound(myId);
      if (bookmark == cellInfo.end() || bookmark->first != myId) {
        if (bookmark != cellInfo.begin()) {
          --bookmark;
        }
        cellInfo.emplace_hint(bookmark, myId, std::move(info));
      }
      else {
        bookmark->second.Add(info);
      }
    }
 
    ++iClus;
  }
}

buildOutOfClusterClusterLists()

void CaloCalibClusterMomentsMaker2::buildOutOfClusterClusterLists ( const xAOD::CaloClusterContainer & theClusColl, const ClusInfo_t & clusInfoVec, int n_phi_out, int n_eta_out, double out_phi_max, double out_eta_max, const std::array< std::vector< std::vector< CalibHitIPhiIEtaRange > >, 3 > & i_phi_eta, const std::array< bool, 3 > & doOutOfCluster, const std::array< ClusList *, 3 > & clusLists )

static

Build lookup lists of clusters for out-of-cluster energy sharing.

For each working point (loose/medium/tight), constructs a grid-indexed lookup structure that maps (η, φ) bins to lists of nearby clusters. These lists are later used to distribute calibration hit energy to clusters lying within the configured angular distance.

The lookup is based on the precomputed tables from initializeOutOfClusterDistanceTables().

Parameters

	theClusColl	Input container of calorimeter clusters.
	clusInfoVec	Per-cluster calibration information.
	n_phi_out	Number of φ bins in the lookup grid.
	n_eta_out	Number of η bins in the lookup grid.
	out_phi_max	Maximum |φ| range covered by the grid.
	out_eta_max	Maximum |η| range covered by the grid.
	i_phi_eta	Precomputed lookup tables for each working point.
	doOutOfCluster	Flags enabling each working point.
[out]	clusLists	Output cluster index lists (non-owning pointers).

Definition at line 354 of file CaloCalibClusterMomentsMaker2.cxx.

{
  for (unsigned int ii = 0; ii < 3; ++ii) {
    ClusList* pClusList = clusLists[ii];
    if (!doOutOfCluster[ii] || pClusList == nullptr) {
      continue;
    }
 
    int iClus = -1;
    for (const xAOD::CaloCluster* theCluster : theClusColl) {
      ++iClus;
      const MyClusInfo& clusInfo = clusInfoVec[iClus];
 
      if (clusInfo.engCalibIn.engTot <= 0.) {
        continue;
      }
 
      int iEtaSign = 1;
      if (theCluster->eta() < 0.) {
        iEtaSign = -1;
      }
 
      const int jeta = static_cast<int>(std::floor(n_eta_out * (theCluster->eta() / out_eta_max)));
      int jphi = static_cast<int>(std::floor(n_phi_out * (theCluster->phi() / out_phi_max)));
 
      if (jeta < -n_eta_out || jeta >= n_eta_out) {
        continue;
      }
 
      if (jphi < -n_phi_out) {
        jphi += 2 * n_phi_out;
      }
      if (jphi >= n_phi_out) {
        jphi -= 2 * n_phi_out;
      }
 
      unsigned int iEtaBin = static_cast<unsigned int>(jeta);
      if (jeta < 0) {
        iEtaBin = std::abs(jeta) - 1;
      }
 
      const std::vector<CalibHitIPhiIEtaRange>& bins = i_phi_eta[ii][iEtaBin];
      for (const CalibHitIPhiIEtaRange& range : bins) {
        int jp = range.iPhi + jphi;
        if (jp < -n_phi_out) {
          jp += 2 * n_phi_out;
        }
        if (jp >= n_phi_out) {
          jp -= 2 * n_phi_out;
        }
 
        const int jEtaMin = (iEtaSign < 0) ? -range.iEtaMax - 1 : range.iEtaMin;
        const int jEtaMax = (iEtaSign < 0) ? -range.iEtaMin - 1 : range.iEtaMax;
 
        for (int je = jEtaMin; je <= jEtaMax; ++je) {
          (*pClusList)[(jp + n_phi_out) * (2 * n_eta_out + 1) + je + n_eta_out].push_back(iClus);
        }
      }
    }
  }
}

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

DeclareInterfaceID()

CaloClusterCollectionProcessor::DeclareInterfaceID ( CaloClusterCollectionProcessor , 1 , 0  )

inherited

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.

{ return m_detStore; }

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.

{ return m_evtStore; }

execute()

StatusCode CaloCalibClusterMomentsMaker2::execute ( const EventContext & ctx, xAOD::CaloClusterContainer * collection ) const

overridevirtual

Execute on an entire collection of clusters.

Parameters

collection

The container of clusters. param ctx The event context.

Implements CaloClusterCollectionProcessor.

Definition at line 429 of file CaloCalibClusterMomentsMaker2.cxx.

{  
 
  ATH_MSG_DEBUG("Starting CaloCalibClusterMomentsMaker2::execute");
  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloDetDescrMgrKey,ctx};
  const CaloDetDescrManager* calo_dd_man = *caloMgrHandle;
 
  bool foundAllContainers (true);
  std::vector<const CaloCalibrationHitContainer *> v_cchc;
  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& key :
         m_CalibrationHitContainerNames)
  {
    SG::ReadHandle<CaloCalibrationHitContainer> cchc (key, ctx);
    if ( !cchc.isValid() ) {
      if (m_foundAllContainers) {
        // print ERROR message only if there was at least one event with
        // all containers
        msg(MSG::ERROR) << "SG does not contain calibration hit container "
                        << key.key() << endmsg;
      }
      foundAllContainers = false;
    }
    else {
      v_cchc.push_back(cchc.cptr());
    }
  }
 
  std::vector<const CaloCalibrationHitContainer *> v_dmcchc;
  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& key :
         m_DMCalibrationHitContainerNames)
  {
    SG::ReadHandle<CaloCalibrationHitContainer> cchc (key, ctx);
    if ( !cchc.isValid() ) {
      if (m_foundAllContainers) {
        // print ERROR message only if there was at least one event with
        // all containers
        ATH_MSG_ERROR("SG does not contain DM calibration hit container "
                      << key.key());
      }
      foundAllContainers = false;
    }
    else {
      v_dmcchc.push_back(cchc.cptr());
    }
  }
 
  if ( !m_foundAllContainers && foundAllContainers ) {
    m_foundAllContainers = true;
  }
 
  if ( !foundAllContainers ) {
    return StatusCode::SUCCESS;
  }
  ATH_MSG_DEBUG("SG has all containers ");
 
  // will contain detailed info about cluster calibration energies
  ClusInfo_t clusInfoVec(theClusColl->size());
 
  CellInfoSet_t cellInfo;
  buildCellInfoMap(*theClusColl, cellInfo);
 
  xAOD::CaloClusterContainer::iterator clusIter = theClusColl->begin();
  xAOD::CaloClusterContainer::iterator clusIterEnd = theClusColl->end();
 
  /* ********************************************
   calculate total calib energy inside clusters
   ******************************************** */
  unsigned int nHitsTotal = 0;
  unsigned int nHitsWithoutParticleUID = 0;
 
  accumulateClusterCalibHits(
      v_cchc,
      cellInfo,
      *m_calo_id,
      clusInfoVec,
      nHitsTotal,
      nHitsWithoutParticleUID,
      m_useParticleID,
      [this]() {
        ATH_MSG_ERROR("Invalid uniqueID detected - this sample cannot be properly analysed.");
      });
 
  // if all calibration hits have ParticleUID (i.e. GenParticle::id()) == 0
  // when simulation was done without ParticleUID
  bool doCalibFrac = m_doCalibFrac;
  bool useParticleID = m_useParticleID;
  if (m_useParticleID && (nHitsTotal == nHitsWithoutParticleUID)) {
    ATH_MSG_INFO("Calibration hits do not have ParticleUID, ids of particle-caused hits are always 0. Continuing without ParticleID machinery.");
    useParticleID = false;
  }
 
  // reading particle information for later calculation of calibration energy fraction caused
  // by particles of different types
  SG::ReadHandle<xAOD::TruthParticleContainer> truthParticleContainerReadHandle(m_truthParticleContainerKey, ctx);
 
  if (doCalibFrac && !truthParticleContainerReadHandle.isValid()) {
    ATH_MSG_WARNING("Invalid read handle to TruthParticleContainer with key: "
                    << m_truthParticleContainerKey.key());
    doCalibFrac = false;
  }
 
  std::array<std::vector<double>, 3> engCalibOut;
 
  /* ****************************************************************
   lists of clusters populating given area [eta*phi][iClus list]
   **************************************************************** */
  std::array<ClusList, 3> clusLists;
  const std::array<bool, 3> doOutOfCluster{{
    m_doOutOfClusterL, m_doOutOfClusterM, m_doOutOfClusterT
  }};
  const std::array<bool, 3> doClusterLists{{
    m_doOutOfClusterL || m_doDeadL ||
      (m_doDeadEnergySharing && m_MatchDmType == kMatchDmLoose),
    m_doOutOfClusterM || m_doDeadM ||
      (m_doDeadEnergySharing && m_MatchDmType == kMatchDmMedium),
    m_doOutOfClusterT || m_doDeadT ||
      (m_doDeadEnergySharing && m_MatchDmType == kMatchDmTight)
  }};
 
  for (unsigned int ii = 0; ii < 3; ++ii) {
    if (doClusterLists[ii]) {
      clusLists[ii].resize((2 * m_n_phi_out + 1) * (2 * m_n_eta_out + 1));
      engCalibOut[ii].resize(theClusColl->size(), 0.0);
    }
  }
 
  std::array<ClusList*, 3> clusListPtrs{{&clusLists[0], &clusLists[1], &clusLists[2]}};
  buildOutOfClusterClusterLists(
      *theClusColl,
      clusInfoVec,
      m_n_phi_out,
      m_n_eta_out,
      m_out_phi_max,
      m_out_eta_max,
      m_i_phi_eta,
      doClusterLists,
      clusListPtrs);
 
  /* ****************************************************************
   calculate out-of-cluster energy of clusters
   **************************************************************** */
  if ( m_doOutOfClusterL || m_doOutOfClusterM || m_doOutOfClusterT ) {
    std::array<const ClusList*, 3> constClusListPtrs{{
      &clusLists[0], &clusLists[1], &clusLists[2]
    }};
    accumulateOutOfClusterEnergy(
        v_cchc,
        cellInfo,
        *calo_dd_man,
        clusInfoVec,
        m_n_phi_out,
        m_n_eta_out,
        m_out_phi_max,
        m_out_eta_max,
        doOutOfCluster,
        constClusListPtrs,
        [&engCalibOut](unsigned int ii, int iClus, int /*uniqueID*/, double energy) {
          engCalibOut[ii][iClus] += energy;
        });
  }
 
  // ------------------------------------------------------------------------
  // calculate dead-material energy of clusters (way2)
  // + energy is shared among clusters within certain area
  // + distance to clusters and energy in specific samplings are used as sharing criteria
  // + calculations are done separately for different dead material areas
  ClusList* pClusList = nullptr;
  if ( m_MatchDmType == kMatchDmLoose ) {
    pClusList = &clusLists[0];
  } else if ( m_MatchDmType == kMatchDmMedium ) {
    pClusList = &clusLists[1];
  } else if ( m_MatchDmType == kMatchDmTight ) {
    pClusList = &clusLists[2];
  }
 
  if (m_doDeadEnergySharing && pClusList) {
    accumulateDeadMaterialEnergy(
        v_dmcchc,
        *theClusColl,
        clusInfoVec,
        *pClusList,
        useParticleID,
        [&clusInfoVec](int iClus, int /*uniqueID*/, int nDmArea, double energy) {
          clusInfoVec[iClus].engCalibDeadInArea[nDmArea] += energy;
          clusInfoVec[iClus].engCalibDeadInArea[CaloDmDescrArea::DMA_ALL] += energy;
        });
  } // doDeadEnergySharing
 
  // fraction of calibration energies caused by different particles
  std::vector<double> engCalibFrac;
  engCalibFrac.resize(kCalibFracMax, 0.0);
 
  std::map<unsigned int, int> truthIDToPdgCodeMap;
 
  // loop on truth particle container is slow, so put needed information in a map for faster key lookup in later loops
  for ( const auto *thisTruthParticle : *truthParticleContainerReadHandle ) {
 
    if (!thisTruthParticle) {
      ATH_MSG_WARNING("Got invalid pointer to TruthParticle");
      continue;
    }
 
    truthIDToPdgCodeMap[HepMC::uniqueID(thisTruthParticle)] = thisTruthParticle->pdgId();
  } // truth particle loop
 
  // assign moments
  int iClus = 0;
  for (clusIter = theClusColl->begin(), iClus = 0;
       clusIter != clusIterEnd;
       ++clusIter, ++iClus) {
    xAOD::CaloCluster * theCluster = *clusIter;
    MyClusInfo& clusInfo = clusInfoVec[iClus];
 
    // total DM energy assigned to cluster
    double eng_calib_dead_tot = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_ALL]
          + clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerB]
          + clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerE]
          + clusInfo.engCalibIn.engSmp[CaloSampling::TileGap3];
    // DM energy before barrel presampler, inside it, and between presampler and strips
    double eng_calib_dead_emb0 = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EMB0]
          + clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EMB1]
          + clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerB];
    // DM energy between barrel and tile
    double eng_calib_dead_tile0 = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EMB3_TILE0];
    // DM energy before scintillator and inside scintillator
    double eng_calib_dead_tileg3 = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_SCN]
          + clusInfo.engCalibIn.engSmp[CaloSampling::TileGap3];
    // DM energy before endcap presampler, inside it and between presampler and strips
    double eng_calib_dead_eme0 = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EME0]
          + clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EME12]
          + clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerE];
    // DM energy between emec and hec
    double eng_calib_dead_hec0 = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EME3_HEC0];
    // DM energy before FCAL and between HEC and FCAL
    double eng_calib_dead_fcal = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_FCAL0]
          + clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_HEC_FCAL];
    // DM leakage behind the calorimeter
    double eng_calib_dead_leakage = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_LEAK];
    // the rest of DM energy which remains unclassified
    double eng_calib_dead_unclass = eng_calib_dead_tot - eng_calib_dead_emb0 - eng_calib_dead_tile0
          - eng_calib_dead_tileg3 - eng_calib_dead_eme0 - eng_calib_dead_hec0 - eng_calib_dead_fcal
          - eng_calib_dead_leakage;
 
    if (doCalibFrac) {
/*****************************************************************************
Calculation of energy fraction caused by particles of different types
*****************************************************************************/
      engCalibFrac.assign(kCalibFracMax, 0.0);
      if (clusInfo.engCalibIn.engTot > 0.0) {
        // each MyClusInfo has a map of particle's uniqueID (GenParticle::id()) and particle calibration deposits in given cluster
        for (const auto& p : clusInfo.engCalibParticle) {
          int pdg_id = 0;
          if (auto it = truthIDToPdgCodeMap.find(p.first); it != truthIDToPdgCodeMap.end()) {
            pdg_id = it->second;
          } else {
            ATH_MSG_WARNING("truthIDToPdgCodeMap cannot find an entry with uniqueID " << p.first);
            continue;
          }
          if (std::abs(pdg_id) == 211) {
            engCalibFrac[kCalibFracHAD] += p.second.engTot;
          } else if (pdg_id == 111 || pdg_id == 22 || std::abs(pdg_id) == 11) {
            engCalibFrac[kCalibFracEM] += p.second.engTot;
          } else {
            engCalibFrac[kCalibFracREST] += p.second.engTot;
          }
        }
        for (size_t i = 0; i < engCalibFrac.size(); i++) {
          engCalibFrac[i] = engCalibFrac[i] / clusInfo.engCalibIn.engTot;
        }
      }
    }
 
    if ( !m_momentsNames.empty() ) {
      std::vector<double> myMoments(m_validMoments.size(), 0);
      // assign moments
      moment_name_set::const_iterator vMomentsIter = m_validMoments.begin();
      moment_name_set::const_iterator vMomentsIterEnd = m_validMoments.end();
 
      int iMoment = 0;
      for (; vMomentsIter != vMomentsIterEnd; ++vMomentsIter, ++iMoment) {
        // now calculate the actual moments
        switch (vMomentsIter->second) {
        case xAOD::CaloCluster::ENG_CALIB_TOT:
          ATH_MSG_DEBUG("Inserting ENG_CALIB_TOT");
          myMoments[iMoment] = clusInfo.engCalibIn.engTot;
          break;
        case xAOD::CaloCluster::ENG_CALIB_OUT_L:
          myMoments[iMoment] = engCalibOut[0][iClus];
          break;
        case xAOD::CaloCluster::ENG_CALIB_OUT_M:
          myMoments[iMoment] = engCalibOut[1][iClus];
          break;
        case xAOD::CaloCluster::ENG_CALIB_OUT_T:
          myMoments[iMoment] = engCalibOut[2][iClus];
          break;
        case xAOD::CaloCluster::ENG_CALIB_EMB0:
          myMoments[iMoment] = clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerB];
          break;
        case xAOD::CaloCluster::ENG_CALIB_EME0:
          myMoments[iMoment] = clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerE];
          break;
        case xAOD::CaloCluster::ENG_CALIB_TILEG3:
          myMoments[iMoment] = clusInfo.engCalibIn.engSmp[CaloSampling::TileGap3];
          break;
        case xAOD::CaloCluster::ENG_CALIB_DEAD_TOT:
          myMoments[iMoment] = eng_calib_dead_tot;
          break;
        case xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0:
          myMoments[iMoment] = eng_calib_dead_emb0;
          break;
        case xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0:
          myMoments[iMoment] = eng_calib_dead_tile0;
          break;
        case xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3:
          myMoments[iMoment] = eng_calib_dead_tileg3;
          break;
        case xAOD::CaloCluster::ENG_CALIB_DEAD_EME0:
          myMoments[iMoment] = eng_calib_dead_eme0;
          break;
        case xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0:
          myMoments[iMoment] = eng_calib_dead_hec0;
          break;
        case xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL:
          myMoments[iMoment] = eng_calib_dead_fcal;
          break;
        case xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE:
          myMoments[iMoment] = eng_calib_dead_leakage;
          break;
        case xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS:
          myMoments[iMoment] = eng_calib_dead_unclass;
          break;
        case xAOD::CaloCluster::ENG_CALIB_FRAC_EM:
          myMoments[iMoment] = engCalibFrac[kCalibFracEM];
          break;
        case xAOD::CaloCluster::ENG_CALIB_FRAC_HAD:
          myMoments[iMoment] = engCalibFrac[kCalibFracHAD];
          break;
        case xAOD::CaloCluster::ENG_CALIB_FRAC_REST:
          myMoments[iMoment] = engCalibFrac[kCalibFracREST];
          break;
        default:
          // nothing to be done for other moments
          break;
        }
 
        theCluster->insertMoment(vMomentsIter->second, myMoments[iMoment]);
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

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

initialize()

StatusCode CaloCalibClusterMomentsMaker2::initialize ( )

overridevirtual

Definition at line 164 of file CaloCalibClusterMomentsMaker2.cxx.

{
  ATH_MSG_INFO("Initializing " << name());
 
  for (const std::string& name : m_momentsNames) {
    bool isValid(false);
    for (const moment_name_pair& vname : m_validNames) {
      if (name == vname.first) {
        m_validMoments.insert(vname);
        isValid = true;
        ATH_MSG_DEBUG("Inserting " << name);
        break;
      }
    }
    if (!isValid) {
      msg() << MSG::ERROR << "Moment " << name
            << " is not a valid Moment name and will be ignored! "
            << "Valid names are:";
      for (unsigned int i = 0; i < m_validNames.size(); i++) {
        msg() << (i == 0 ? " " : ", ") << m_validNames[i].first;
      }
      msg() << endmsg;
    }
  }
 
  // to switch on clever DeadMaterial assignment procedure
  // and check if tight, medium and/or loose versions for out-of-cluster and 
  // simple dead-material assignment are wanted
  for (const moment_name_pair& vname : m_validNames) {
    switch (vname.second) {
    case xAOD::CaloCluster::ENG_CALIB_DEAD_TOT:
      m_doDeadEnergySharing = true;
      break;
    case xAOD::CaloCluster::ENG_CALIB_OUT_L:
      m_doOutOfClusterL = true;
      break;
    case xAOD::CaloCluster::ENG_CALIB_OUT_M:
      m_doOutOfClusterM = true;
      break;
    case xAOD::CaloCluster::ENG_CALIB_OUT_T:
      m_doOutOfClusterT = true;
      break;
    case xAOD::CaloCluster::ENG_CALIB_FRAC_EM:
      m_doCalibFrac = true;
      break;
    case xAOD::CaloCluster::ENG_CALIB_FRAC_HAD:
      m_doCalibFrac = true;
      break;
    case xAOD::CaloCluster::ENG_CALIB_FRAC_REST:
      m_doCalibFrac = true;
      break;
    default:
      break;
    }
  }
  
  if (m_doCalibFrac && !m_useParticleID) {
    ATH_MSG_INFO("Usage of ParticleID was switched off (UseParticleID==False), no ENG_CALIB_FRAC_* moments will be available");
    m_doCalibFrac = false;
  }
 
  for (const std::string& name : m_momentsNamesAOD) {
    for (const moment_name_pair& vname : m_validNames) {
      if (vname.first == name) {
        m_momentsAOD.insert(vname.second);
        break;
      }
    }
  }
  if (m_momentsAOD.find(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT) != m_momentsAOD.end()) {
    m_doDeadEnergySharing = true;
  }
 
  // dead material identifier description manager
  m_caloDmDescrManager = CaloDmDescrManager::instance(); 
 
  ATH_CHECK(detStore()->retrieve(m_calo_id, "CaloCell_ID"));
  ATH_CHECK(detStore()->retrieve(m_caloDM_ID));
 
  initializeOutOfClusterDistanceTables(
      m_n_phi_out,
      m_n_eta_out,
      m_out_phi_max,
      m_out_eta_max,
      m_rmaxOut,
      m_i_phi_eta);
 
  ATH_CHECK(m_CalibrationHitContainerNames.initialize());
  ATH_CHECK(m_DMCalibrationHitContainerNames.initialize());
  ATH_CHECK(m_truthParticleContainerKey.initialize());
  ATH_CHECK(m_caloDetDescrMgrKey.initialize());
 
  return StatusCode::SUCCESS;
}

initializeOutOfClusterDistanceTables()

void CaloCalibClusterMomentsMaker2::initializeOutOfClusterDistanceTables ( int n_phi_out, int n_eta_out, double out_phi_max, double out_eta_max, const double(&) rmaxOut[3], std::array< std::vector< std::vector< CalibHitIPhiIEtaRange > >, 3 > & i_phi_eta )

static

Precompute eta/phi lookup tables for quick out-of-cluster hit association to clusters.

Builds, for three search radius definitions (loose/medium/tight), a set of eta-dependent lookup tables that map relative (Δη, Δφ) regions to discrete index ranges. These tables are later used to efficiently find clusters within a given angular distance of a calibration hit.

The tables are organized as: [working point][eta bin] -> vector of (phi bin, eta min/max) ranges.

Parameters

	n_phi_out	Number of bins in φ used for the lookup grid.
	n_eta_out	Number of bins in η used for the lookup grid.
	out_phi_max	Maximum |φ| range covered by the lookup grid.
	out_eta_max	Maximum |η| range covered by the lookup grid.
	rmaxOut	Array of angular distance cuts (one per working point).
[out]	i_phi_eta	Output lookup tables to be filled.

Definition at line 260 of file CaloCalibClusterMomentsMaker2.cxx.

{
  for (int im = 0; im < 3; ++im) {
    i_phi_eta[im].clear();
    i_phi_eta[im].resize(n_eta_out);
  }
 
  for (int jeta = 0; jeta < n_eta_out; ++jeta) {
    const double eta0 = (jeta + 0.5) * out_eta_max / n_eta_out;
    HepLorentzVector middle(1, 0, 0, 1);
    middle.setREtaPhi(1. / std::cosh(eta0), eta0, 0.0);
 
    double x_rmaxOut[3];
    for (int im = 0; im < 3; ++im) {
      x_rmaxOut[im] = rmaxOut[im] * angle_mollier_factor(eta0);
    }
 
    for (int jp = -n_phi_out; jp < n_phi_out; ++jp) {
      const double phi = (jp + 0.5) * out_phi_max / n_phi_out;
      int ietaMin[3] = {n_eta_out, n_eta_out, n_eta_out};
      int ietaMax[3] = {-n_eta_out, -n_eta_out, -n_eta_out};
 
      for (int je = -n_eta_out; je < n_eta_out; ++je) {
        const double eta = (je + 0.5) * out_eta_max / n_eta_out;
        HepLorentzVector cpoint(1, 0, 0, 1);
        cpoint.setREtaPhi(1. / std::cosh(eta), eta, phi);
        const double r = middle.angle(cpoint.vect());
        for (int im = 0; im < 3; ++im) {
          if (r < x_rmaxOut[im]) {
            if (je < ietaMin[im]) {
              ietaMin[im] = je;
            }
            if (je > ietaMax[im]) {
              ietaMax[im] = je;
            }
          }
        }
      }
 
      for (int im = 0; im < 3; ++im) {
        if (ietaMin[im] <= ietaMax[im]) {
          CalibHitIPhiIEtaRange theRange{};
          theRange.iPhi = static_cast<char>(jp);
          theRange.iEtaMin = static_cast<char>(ietaMin[im]);
          theRange.iEtaMax = static_cast<char>(ietaMax[im]);
          i_phi_eta[im][jeta].push_back(theRange);
        }
      }
    }
  }
}

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

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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.

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

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 >, and AthCheckedComponent<::AthAlgTool >.

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

Member Data Documentation

m_apars_alpha

float CaloCalibClusterMomentsMaker2::m_apars_alpha {}

private

Definition at line 478 of file CaloCalibClusterMomentsMaker2.h.

{};

m_apars_r0

float CaloCalibClusterMomentsMaker2::m_apars_r0 {}

private

Definition at line 479 of file CaloCalibClusterMomentsMaker2.h.

{};

m_CalibrationHitContainerNames

SG::ReadHandleKeyArray<CaloCalibrationHitContainer> CaloCalibClusterMomentsMaker2::m_CalibrationHitContainerNames

private

Definition at line 451 of file CaloCalibClusterMomentsMaker2.h.

m_calo_id

const CaloCell_ID* CaloCalibClusterMomentsMaker2::m_calo_id {}

private

Definition at line 455 of file CaloCalibClusterMomentsMaker2.h.

{};

m_caloDetDescrMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> CaloCalibClusterMomentsMaker2::m_caloDetDescrMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}

private

Definition at line 454 of file CaloCalibClusterMomentsMaker2.h.

{this,"CaloDetDescrManager", "CaloDetDescrManager"};

m_caloDM_ID

const CaloDM_ID* CaloCalibClusterMomentsMaker2::m_caloDM_ID {}

private

Definition at line 456 of file CaloCalibClusterMomentsMaker2.h.

{};

m_caloDmDescrManager

const CaloDmDescrManager* CaloCalibClusterMomentsMaker2::m_caloDmDescrManager {}

private

Definition at line 457 of file CaloCalibClusterMomentsMaker2.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_DMCalibrationHitContainerNames

SG::ReadHandleKeyArray<CaloCalibrationHitContainer> CaloCalibClusterMomentsMaker2::m_DMCalibrationHitContainerNames

private

Definition at line 452 of file CaloCalibClusterMomentsMaker2.h.

m_doCalibFrac

bool CaloCalibClusterMomentsMaker2::m_doCalibFrac {}

private

Definition at line 475 of file CaloCalibClusterMomentsMaker2.h.

{};

m_doDeadEnergySharing

bool CaloCalibClusterMomentsMaker2::m_doDeadEnergySharing {}

private

Definition at line 467 of file CaloCalibClusterMomentsMaker2.h.

{};

m_doDeadL

bool CaloCalibClusterMomentsMaker2::m_doDeadL {}

private

Definition at line 471 of file CaloCalibClusterMomentsMaker2.h.

{};

m_doDeadM

bool CaloCalibClusterMomentsMaker2::m_doDeadM {}

private

Definition at line 472 of file CaloCalibClusterMomentsMaker2.h.

{};

m_doDeadT

bool CaloCalibClusterMomentsMaker2::m_doDeadT {}

private

Definition at line 473 of file CaloCalibClusterMomentsMaker2.h.

{};

m_doOutOfClusterL

bool CaloCalibClusterMomentsMaker2::m_doOutOfClusterL {}

private

Definition at line 468 of file CaloCalibClusterMomentsMaker2.h.

{};

m_doOutOfClusterM

bool CaloCalibClusterMomentsMaker2::m_doOutOfClusterM {}

private

Definition at line 469 of file CaloCalibClusterMomentsMaker2.h.

{};

m_doOutOfClusterT

bool CaloCalibClusterMomentsMaker2::m_doOutOfClusterT {}

private

Definition at line 470 of file CaloCalibClusterMomentsMaker2.h.

{};

m_energyMin

float CaloCalibClusterMomentsMaker2::m_energyMin {}

private

Definition at line 476 of file CaloCalibClusterMomentsMaker2.h.

{};

m_energyMinCalib

float CaloCalibClusterMomentsMaker2::m_energyMinCalib {}

private

Definition at line 477 of file CaloCalibClusterMomentsMaker2.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_foundAllContainers

std::atomic<bool> CaloCalibClusterMomentsMaker2::m_foundAllContainers {}

mutableprivate

Definition at line 464 of file CaloCalibClusterMomentsMaker2.h.

{};

m_i_phi_eta

std::array<std::vector<std::vector<CalibHitIPhiIEtaRange> >, 3> CaloCalibClusterMomentsMaker2::m_i_phi_eta

private

Definition at line 463 of file CaloCalibClusterMomentsMaker2.h.

m_MatchDmType

int CaloCalibClusterMomentsMaker2::m_MatchDmType {}

private

Definition at line 480 of file CaloCalibClusterMomentsMaker2.h.

{};

m_momentsAOD

std::set<xAOD::CaloCluster::MomentType> CaloCalibClusterMomentsMaker2::m_momentsAOD

private

Definition at line 450 of file CaloCalibClusterMomentsMaker2.h.

m_momentsNames

std::vector<std::string> CaloCalibClusterMomentsMaker2::m_momentsNames

private

Definition at line 446 of file CaloCalibClusterMomentsMaker2.h.

m_momentsNamesAOD

std::vector<std::string> CaloCalibClusterMomentsMaker2::m_momentsNamesAOD

private

Definition at line 449 of file CaloCalibClusterMomentsMaker2.h.

m_n_eta_out

int CaloCalibClusterMomentsMaker2::m_n_eta_out {}

private

Definition at line 459 of file CaloCalibClusterMomentsMaker2.h.

{};

m_n_phi_out

int CaloCalibClusterMomentsMaker2::m_n_phi_out {}

private

Definition at line 458 of file CaloCalibClusterMomentsMaker2.h.

{};

m_out_eta_max

double CaloCalibClusterMomentsMaker2::m_out_eta_max {}

private

Definition at line 461 of file CaloCalibClusterMomentsMaker2.h.

{};

m_out_phi_max

double CaloCalibClusterMomentsMaker2::m_out_phi_max {}

private

Definition at line 460 of file CaloCalibClusterMomentsMaker2.h.

{};

m_rmaxOut

double CaloCalibClusterMomentsMaker2::m_rmaxOut[3] {}

private

Definition at line 462 of file CaloCalibClusterMomentsMaker2.h.

{};

m_truthParticleContainerKey

SG::ReadHandleKey<xAOD::TruthParticleContainer> CaloCalibClusterMomentsMaker2::m_truthParticleContainerKey {this,"TruthParticles","TruthParticles","ReadHandleKey for truth particle container"}

private

Definition at line 453 of file CaloCalibClusterMomentsMaker2.h.

{this,"TruthParticles","TruthParticles","ReadHandleKey for truth particle container"};

m_useParticleID

bool CaloCalibClusterMomentsMaker2::m_useParticleID {}

private

Definition at line 474 of file CaloCalibClusterMomentsMaker2.h.

{};

m_validMoments

moment_name_set CaloCalibClusterMomentsMaker2::m_validMoments

private

Definition at line 448 of file CaloCalibClusterMomentsMaker2.h.

m_validNames

moment_name_vector CaloCalibClusterMomentsMaker2::m_validNames

private

Definition at line 447 of file CaloCalibClusterMomentsMaker2.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.

---

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

• CaloCalibClusterMomentsMaker2.h
• CaloCalibClusterMomentsMaker2.cxx