TrackDepositInCaloTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOTRKMUIDTOOLS_TRACKDEPOSITINCALOTOOL_H
#define CALOTRKMUIDTOOLS_TRACKDEPOSITINCALOTOOL_H
 
// --- Tools ---
#include "ICaloTrkMuIdTools/ITrackDepositInCaloTool.h"
#include "TrkExInterfaces/IExtrapolator.h"
 
// --- Athena common ---
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "CaloDetDescr/CaloDetDescrManager.h"
 
// --- Athena ---
#include "RecoToolInterfaces/IParticleCaloCellAssociationTool.h"
#include "RecoToolInterfaces/IParticleCaloExtensionTool.h"
#include "xAODTracking/TrackParticle.h"
#include "CxxUtils/CachedValue.h"
 
// --- STL ---
#include <map>
#include <vector>
 
// --- Forward declarations ---
class CaloCellContainer;
class CaloPhiRange;
class TileDetDescrManager;
 
class TH1F;
class TH2F;
class ITHistSvc;
 
 
// TrackDepositInCaloTool
class TrackDepositInCaloTool : public AthAlgTool, virtual public ITrackDepositInCaloTool {
public:
    TrackDepositInCaloTool(const std::string& type, const std::string& name, const IInterface* pInterface);
    virtual ~TrackDepositInCaloTool() = default;
 
    StatusCode initialize() override;
 
    std::vector<DepositInCalo> getDeposits(const Trk::TrackParameters* par, const CaloCellContainer* caloCellCont) const override;
 
    std::vector<DepositInCalo> getDeposits(const xAOD::TrackParticle* tp, const CaloCellContainer* caloCellCont,
                                           const CaloExtensionCollection* extensionCache) const override;
 
    std::vector<DepositInCalo> deposits(const Trk::TrackParameters* par, const CaloCellContainer* cellContainer) const override;
    Trk::Surface* createSurface(const CaloDetDescriptor* descr, CaloSurfaceType type) const override;
 
    double calcEnergy(const Trk::TrackParameters* par, const Trk::ParticleHypothesis& particleHypo) const override;
 
private:
    std::unique_ptr<const Trk::TrackParameters> extrapolateToSolenoid(const EventContext& ctx, const Trk::TrackParameters* par,
                                                                      bool oppositeMomentum = false) const;
 
    static std::unique_ptr<Amg::Vector3D> extrapolateR(const Amg::Vector3D& initialPosition, double phi0, double theta0, double r) ;
    static std::unique_ptr<Amg::Vector3D> extrapolateZ(const Amg::Vector3D& initialPosition, double phi0, double theta0, double z) ;
    StatusCode bookHistos();
 
    const CaloCell* getClosestCell(const CaloDetDescrManager* caloDDM,
                                   const Trk::TrackParameters* par,
                                   const CaloDetDescriptor* descr,
                                   const CaloCellContainer* cellContainer) const;
 
 
    static const CaloCell* getClosestCellLAr(const CaloDetDescrManager* caloDDM,
                                             const Trk::TrackParameters* par,
                                             const CaloDetDescriptor* descr,
                                             const CaloCellContainer* caloCellCont);
 
    const CaloCell* getClosestCellTile(const CaloDetDescrManager* caloDDM,
                                       const Trk::TrackParameters* par,
                                       const CaloDetDescriptor* descr,
                                       const CaloCellContainer* caloCellCont) const;
 
    std::vector<const CaloCell*> getCaloCellsForLayer(const CaloDetDescrManager* caloDDM,
                                                      const CaloDetDescriptor* descr,
                                                      const Trk::TrackParameters* parEntrance,
                                                      const Trk::TrackParameters* parExit,
                                                      const CaloCellContainer* caloCellCont) const;
 
    std::vector<const CaloCell*> getCaloCellsForTile(const CaloDetDescrManager* caloDDM,
                                                     const CaloDetDescriptor* descr,
                                                     const Trk::TrackParameters* parEntrance,
                                                     const Trk::TrackParameters* parExit,
                                                     const CaloCellContainer* caloCellCont) const;
 
    StatusCode getTraversedLayers(const CaloDetDescrManager* caloDDM,
                                  const Trk::TrackParameters* par,
                                  std::map<double, const CaloDetDescriptor*>& caloInfo,
                                  std::vector<Amg::Vector3D>& extrapolations) const;
 
    std::unique_ptr<const Trk::TrackParameters> extrapolateToEntranceOfLayer(const EventContext& ctx,
                                                                             const Trk::TrackParameters* par,
                                                                             const CaloDetDescriptor* descr) const;
 
    std::unique_ptr<const Trk::TrackParameters> extrapolateToExitOfLayer(const EventContext& ctx,
                                                                         const Trk::TrackParameters* par,
                                                                         const CaloDetDescriptor* descr) const;
 
    static double distance(const Amg::Vector3D& p1, const Amg::Vector3D& p2) ;
 
    static bool isInsideDomain(double position, double domainCenter, double domainWidth, bool phiVariable = false) ;
    static bool isInsideCell(const Amg::Vector3D& position, const CaloCell* cell) ;
    static bool inCell(const CaloCell* cell, const Amg::Vector3D& pos) ;
 
private:
    // Services & Tools
    ITHistSvc* m_histSvc{};
    ToolHandle<Trk::IExtrapolator> m_extrapolator{this, "ExtrapolatorHandle", ""};
 
    const TileDetDescrManager* m_tileDDM{nullptr};
 
    ToolHandle<Trk::IParticleCaloExtensionTool> m_caloExtensionTool{this, "ParticleCaloExtensionTool", "",
                                                                    "Tool to make the step-wise extrapolation"};
    ToolHandle<Rec::IParticleCaloCellAssociationTool> m_caloCellAssociationTool{this, "ParticleCaloCellAssociationTool", ""};
 
    SG::ReadCondHandleKey<CaloDetDescrManager> m_caloDetDescrMgrKey {
    this,
    "CaloDetDescrManager",
    "CaloDetDescrManager",
    "SG Key for CaloDetDescrManager in the Condition Store"
  };
 
    // Members
    bool m_doExtr;  
    bool m_doHist;  
 
    struct LayerMaps {
      CaloLayerMap m_barrelLayerMap;
      CaloLayerMap m_endCapLayerMap;
    };
    CxxUtils::CachedValue<LayerMaps> m_layerMaps;
 
    LayerMaps initializeDetectorInfo(const CaloDetDescrManager* caloDDM) const;
 
    // Histograms
    struct Hists {
      StatusCode book (ITHistSvc& histSvc);
 
      TH1F* m_hDepositLayer12{};
      TH1F* m_hDepositLayer13{};
      TH1F* m_hDepositLayer14{};
 
      TH2F* m_hParELossEta{};
      TH2F* m_hParELossSample{};
 
      TH1F* m_hDeltaEtaLastPar{};
      TH1F* m_hDeltaRadiusLastPar{};
      TH1F* m_hDepositsInCore{};
      TH1F* m_hDepositsInCone{};
      TH2F* m_hDistDepositsTile{};
      TH2F* m_hDistDepositsHEC{};
 
      TH2F* m_hEMB1vsdPhi{};
      TH2F* m_hEMB2vsdPhi{};
      TH2F* m_hEMB3vsdPhi{};
      TH2F* m_hEMB1vsdEta{};
      TH2F* m_hEMB2vsdEta{};
      TH2F* m_hEMB3vsdEta{};
    };
    std::unique_ptr<Hists> m_h;
    Hists& getHists() const;
 
};
 
#endif