CaloRingsBuilder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALORINGERTOOLS_CALORINGSBUILDER_H
#define CALORINGERTOOLS_CALORINGSBUILDER_H
 
// Base includes:
#include "CaloRingerTools/ICaloRingsBuilder.h"
#include "AthenaBaseComps/AthAlgTool.h"
 
// Wrap-around phi helper include:
#include "CaloGeoHelpers/CaloPhiRange.h"
 
#include "CaloDetDescr/CaloDetDescrManager.h"
 
// xAOD Includes:
#include "xAODBase/IParticle.h"
#include "xAODCaloRings/RingSetContainerFwd.h"
#include "xAODCaloRings/CaloRingsContainerFwd.h"
#include "xAODCaloRings/tools/AtlasGeoPoint.h"
 
// StoreGate includes:
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
// Forward declarations
#include "xAODCaloEvent/CaloClusterFwd.h"
#include "xAODJet/JetContainer.h"
 
// STL includes:
#include <string>
#include <vector>
#include <limits>
 
class CaloCellContainer;
class CaloCellList;
 
namespace Ringer
{
 
    class CaloRingsBuilder : public ::AthAlgTool,
                             virtual public ICaloRingsBuilder
    {
 
    public:

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

        ~CaloRingsBuilder();


        virtual StatusCode initialize() override;

        virtual StatusCode preExecute(xAOD::CaloRingsContainer *crCont, xAOD::RingSetContainer *rsCont, const std::size_t nReserve = 0) override;
        virtual StatusCode execute(const xAOD::IParticle &particle,
                                   ElementLink<xAOD::CaloRingsContainer> &clRingsLink) override;
        virtual StatusCode execute(const xAOD::CaloCluster &cluster,
                                   ElementLink<xAOD::CaloRingsContainer> &clRingsLink) override;
        virtual StatusCode finalize() override;


        const xAOD::RingSetConf::RawConfCollection &rawConf() override
        {
            return m_rsRawConfCol;
        };

        bool useShowerShapeBarycenter() override
        {
            return m_useShowShapeBarycenter;
        };

 
        std::size_t nRingSets() const override { return m_nRingSets; }
 
        const SG::WriteHandleKey<xAOD::CaloRingsContainer> &crContName() const override { return m_crContName; }
        const SG::WriteHandleKey<xAOD::RingSetContainer> &rsContName() const override { return m_rsContName; }
 
    protected:

        virtual StatusCode buildRingSet(
            const xAOD::RingSetConf::RawConf &rawConf,
            const AtlasGeoPoint &seed,
            xAOD::RingSet *rs);
        StatusCode getRingSetSeed(
            const xAOD::RingSetConf::RawConf &conf,
            const xAOD::CaloCluster &cluster,
            AtlasGeoPoint &seed);
        static StatusCode getRingSetSeed(
            const xAOD::RingSetConf::RawConf & /*rawConf*/,
            const xAOD::IParticle &part,
            AtlasGeoPoint &seed);


        SG::WriteHandleKey<xAOD::CaloRingsContainer> m_crContName{
            this,
            "CaloRingsContainerName",
            "CaloRings",
            "Name of the CaloRings container"};

        SG::WriteHandleKey<xAOD::RingSetContainer> m_rsContName{
            this,
            "RingSetContainerName",
            "RingSets",
            "Name of the RingSets container"};

        SG::ReadHandleKey<CaloCellContainer> m_cellsContName{
            this,
            "CellsContainerName",
            "AllCalo",
            "Key to obtain the cell container"};

        Gaudi::Property<std::vector<float>> m_etaWidth{
            this,
            "EtaWidth",
            {},
            "Each RingSet ring eta width."};

        Gaudi::Property<std::vector<float>> m_phiWidth{
            this,
            "PhiWidth",
            {},
            "Each RingSet ring phi width."};

        Gaudi::Property<float> m_cellMaxDEtaDist{
            this,
            "CellMaxDEtaDist", 0,
            "Maximum cell distance to the seed in eta."};

        Gaudi::Property<float> m_cellMaxDPhiDist{
            this,
            "CellMaxDPhiDist", 0,
            "Maximum cell distance to the seed in phi."};

        Gaudi::Property<std::vector<unsigned int>> m_nRings{
            this,
            "NRings",
            {},
            "Each RingSet number of rings."};

        Gaudi::Property<float> m_minEnergy{
            this,
            "MinPartEnergy", std::numeric_limits<float>::lowest(),
            "Minimum particle/cluster energy to build rings (GeV)."};

        Gaudi::Property<std::vector<int /*=CaloCell_ID::CaloSample*/>>
            m_layers{
                this,
                "Layers",
                {},
                "Concatenated list of layers which will be used "
                "to build the RingSets"};

        Gaudi::Property<std::vector<unsigned int>> m_nLayers{
            this,
            "RingSetNLayers",
            {},
            "Each RingSet number of layers from the Layers "
            "configurable property to use."};

        Gaudi::Property<bool> m_useShowShapeBarycenter{
            this,
            "useShowerShapeBarycenter", false,
            "Switch to use shower barycenter for each layer, "
            "instead of the cluster center."};

        Gaudi::Property<bool> m_doTransverseEnergy{
            this,
            "doTransverseEnergy", false,
            "Switch to use raw cell energy, "
            "instead of cells ET."};
 
        SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey{this, "CaloDetDescrManager", "CaloDetDescrManager"};



        xAOD::RingSetContainer *m_rsCont;
        xAOD::CaloRingsContainer *m_crCont;
        xAOD::RingSetConf::RawConfCollection m_rsRawConfCol;
        AtlasGeoPoint m_lastValidSeed;
        static const CaloPhiRange m_phiHelper;
        size_t m_nRingSets;
 
    private:

        template <typename T>
        StatusCode executeTemp(
            const T &input,
            ElementLink<xAOD::CaloRingsContainer> &crEL);
    };
 
} // namespace Ringer
 
#endif