TrkMaterialProviderTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TrkMaterialProviderTool_H
#define TrkMaterialProviderTool_H
 
//#define protected public
#include "TrkExInterfaces/IEnergyLossUpdator.h"
#include "TrkExInterfaces/IExtrapolator.h"
#include "TrkTrack/Track.h"
 
// Gaudi
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
 
#include "TrkSurfaces/Surface.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkTrack/TrackStateOnSurface.h"
 
#include "TrkToolInterfaces/ITrkMaterialProviderTool.h"
#include "TrkDetDescrInterfaces/ITrackingVolumesSvc.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "TrkGeometry/TrackingGeometry.h"
#include "TrkDetDescrInterfaces/ITrackingGeometrySvc.h"
#include "TrkExInterfaces/IMultipleScatteringUpdator.h"
#include "TrkGeometry/TrackingVolume.h"
#include "TrkGeometry/MagneticFieldProperties.h"
// For magneticfield
#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
 
#include "RecoToolInterfaces/IMuonCaloEnergyTool.h"
 
#include "MuidInterfaces/IMuidCaloEnergyMeas.h"
#include "MuidInterfaces/IMuidCaloEnergyParam.h"
#include "MuidInterfaces/IMuidTrackIsolation.h"
 
namespace Trk {
  class Surface;
}
 
namespace Rec {
  class CaloMeas;
}
 
class AtlasDetectorID;
 
namespace Trk{  
  
  class TrkMaterialProviderTool final: public AthAlgTool,
    virtual public Trk::ITrkMaterialProviderTool {
      
  public:
      
    TrkMaterialProviderTool(const std::string&,const std::string&,const IInterface*);
    
    virtual ~TrkMaterialProviderTool() = default;
    
    StatusCode initialize();
    StatusCode finalize();
 
    void updateCaloTSOS(const Trk::Track& idTrack, Trk::Track& extrapolatedTrack) const;
 
    void updateCaloTSOS(Trk::Track& track, const Trk::TrackParameters* startParamaters=nullptr) const;
 
    void getCaloMEOT(const Trk::Track& idTrack, const Trk::Track& msTrack, std::vector<MaterialEffectsOnTrack>& calomeots) const;
 
    std::vector<const Trk::TrackStateOnSurface*>*
      getCaloTSOS (const Trk::TrackParameters&  parm, const Trk::Track &muonTrack, const Trk::TrackParameters* parms=nullptr) const;
    
    CaloEnergy* getParamCaloELoss(Trk::Track* track) const;
  
  private:      
 
    Trk::TrackStates* 
      getCaloTSOS (const Trk::TrackParameters&  parm,
           const Trk::Track&            muonTrack,
           const Trk::Surface&      surf,
           Trk::PropDirection       dir,
           Trk::ParticleHypothesis  mateffects,
                   double&                      Eloss,
                   double&                      X0ScaleMS,
                   double&                      ElossScaleMS,
           const Trk::TrackParameters*  parms=nullptr,
           bool                         boundaryCheck=false,
           bool                         removeOoC=false)     const;
 
    const Trk::TrackStateOnSurface* getCaloExitTSOS(const std::vector<const Trk::TrackStateOnSurface*>* caloTSOS, Trk::PropDirection dir) const;
 
    const Trk::TrackStateOnSurface* getCaloEntryTSOS(const std::vector<const Trk::TrackStateOnSurface*>* caloTSOS, Trk::PropDirection dir) const;
 
    void removeOutOfCalo(std::vector<const Trk::TrackStateOnSurface*>* caloTSOS) const;
    void removeMS(std::vector<const Trk::TrackStateOnSurface*>* caloTSOS) const;
 
    static void updateVector(Trk::TrackStates* inputTSOS, 
              Trk::TrackStates::iterator lastID, 
              Trk::TrackStates::iterator firstMS, 
              Trk::TrackStates* caloTSOS) ;
 
    void updateVectorMS(Trk::TrackStates* inputTSOS,
                        const Trk::TrackStates::iterator& firstMS,
                        double X0ScaleMS, double ElossScaleMS) const;
 
    //* Helper to indentify detector volume**/
    unsigned int getVolumeByGeo(const Trk::TrackStateOnSurface* m) const;
 
    /* Helper to delete TSOS (data)vectors 
       Note that DataVector ownership is taken and elements deleted!*/
    static void deleteTSOS(const std::vector<const Trk::TrackStateOnSurface*>* vecTSOS) ;
    static void deleteTSOS(Trk::TrackStates* vecTSOS) ;
 
    //** Helper to printout TSOS details*/
    void printTSOS(const Trk::TrackStateOnSurface* m, const std::string& tag) const;
           
    Trk::TrackStates* 
      modifyTSOSvector(const std::vector<const Trk::TrackStateOnSurface*>* matvec, 
               double scaleX0, 
               double scaleEloss, 
               bool reposition, 
               bool aggregate, 
               bool updateEloss, 
               double caloEnergy, 
               double caloEnergyError, 
               double fsrCaloEnergy,
               double pCaloEntry, 
               double momentumError,
               double& Eloss_tot,
                       bool useMeasuredEnergy=true,
                       double mopEloss=0., double meanElossIoni=0., double sigmaElossIoni=0.) const;
 
    void getMopAndIoniEnergyLoss(const std::vector<const Trk::TrackStateOnSurface*>* matvec,
                 double pCaloEntry,
                 double scaleEloss,
                 double& mopEloss,
                 double& meanElossIoni,
                 double& sigmaElossIoni) const;
 
    bool isIsolatedTrack(double eta, double phi) const;
 
    double getCaloMeasuredEnergy(double eta, double phi, 
                 double mopEloss,
                 double meanElossIoni,
                 double& fsrCaloEnergy) const;
 
    double getFinalMeasuredEnergy(Rec::CaloMeas* caloMeas, 
                  double mopEloss,
                  double meanElossIoni,
                  double eta,
                  double& fsrCaloEnergy) const;
 
    void throwFailedToGetTrackingGeomtry() const;
    const TrackingGeometry* retrieveTrackingGeometry(const EventContext& ctx) const {
 
      if (m_trackingGeometryReadKey.key().empty()) {
        return m_trackingGeometrySvc->trackingGeometry();
      }
      SG::ReadCondHandle<TrackingGeometry> handle(m_trackingGeometryReadKey,
                                                  ctx);
      if (!handle.isValid()) {
        throwFailedToGetTrackingGeomtry();
      }
      return handle.cptr();
    }
 
    PublicToolHandle<Trk::IExtrapolator>                m_muonExtrapolator
       {this,"Extrapolator","Trk::Extrapolator/AtlasExtrapolator",""};
    PublicToolHandle<Trk::IEnergyLossUpdator>           m_elossupdator
       {this,"EnergyLossUpdator","Trk::EnergyLossUpdator/AtlasEnergyLossUpdator",""};
    ServiceHandle<Trk::ITrackingVolumesSvc> m_trackingVolumesSvc
      {this, "TrackingVolumeSvc", "TrackingVolumesSvc/TrackingVolumesSvc"};
    ServiceHandle<ITrackingGeometrySvc> m_trackingGeometrySvc {this, "TrackingGeometrySvc", "", ""};
 
    SG::ReadCondHandleKey<TrackingGeometry>   m_trackingGeometryReadKey
       {this, "TrackingGeometryReadKey", "", "Key of the TrackingGeometry conditions data."};
 
    ToolHandle< Trk::IMultipleScatteringUpdator > m_scattool
      {this, "MultipleScatteringTool",
       "Trk::MultipleScatteringUpdator/AtlasMultipleScatteringUpdator"};
 
    ToolHandle<Rec::IMuidCaloEnergyMeas>  m_caloMeasTool
      {this, "CaloMeasTool", "Rec::MuidCaloEnergyMeas/MuidCaloEnergyMeas"};
    ToolHandle<Rec::IMuidCaloEnergyParam> m_caloParamTool
      {this, "CaloParamTool", "Rec::MuidCaloEnergyParam/MuidCaloEnergyParam"};
    ToolHandle<Rec::IMuidTrackIsolation>  m_trackIsolationTool
      {this, "TrackIsolationTool", "Rec::MuidTrackIsolation/MuidTrackIsolation"};
    ToolHandle<Rec::IMuonCaloEnergyTool>  m_muonCaloEnergyTool {this, 
    "MuonCaloEnergyTool", ""};
 
    const AtlasDetectorID *m_DetID;
    const Trk::Volume* m_calorimeterVolume;
    const Trk::Volume* m_indetVolume;
 
    // Read handle for conditions object to get the field cache
    SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCacheCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                               "Name of the Magnetic Field conditions object key"};
 
    bool m_applyTGScaling;
    bool m_repositionTSOS;
    bool m_aggregateTSOS;
    bool m_updateTSOS;
 
    int m_maxNTracksIso;
    double m_paramPtCut;
    bool m_useCaloEnergyMeasurement;
    bool m_useMuonCaloEnergyTool;
    bool m_overwriteElossParam;
 
  };
} // end namespace
 
#endif // TrkMaterialProviderTool_H