CaloRingsBuilder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 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"
 
// STL includes:
#include <string>
#include <vector>
#include <memory>
#include <limits>
 
// 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"
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:


    template<typename T>
    StatusCode executeTemp(
        const T &input,
        ElementLink<xAOD::CaloRingsContainer> &crEL);
    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);
    // static StatusCode getRingSetSeed(
    //     const xAOD::RingSetConf::RawConf &/*rawConf*/,
    //     const xAOD::Jet_v1 &jet,
    //     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;
 
};
 
} // namespace Ringer
 
#endif