StaticNavigationEngine.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
// StaticNavigationEngine.h, (c) ATLAS Detector software
 
#ifndef TRKEXENGINE_STATICNAVIGATIONENGINE_H
#define TRKEXENGINE_STATICNAVIGATIONENGINE_H
 
// Gaudi
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
// Trk
#include "TrkExInterfaces/INavigationEngine.h"
#include "TrkExInterfaces/ExtrapolationMacros.h"
#include "TrkExUtils/ExtrapolationCell.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkNeutralParameters/NeutralParameters.h"
#include "TrkVolumes/BoundarySurface.h"
// throw GaudiExceptions where necessary
#include "GaudiKernel/GaudiException.h"
 
#include "StoreGate/ReadCondHandleKey.h"
#include "TrkGeometry/TrackingGeometry.h"
 
#include "CxxUtils/checker_macros.h"
 
 
namespace Trk {
 
  class IPropagationEngine;
  class IMaterialEffectsEngine;
    
  class StaticNavigationEngine : public AthAlgTool, virtual public INavigationEngine {
 
      public:
        StaticNavigationEngine(const std::string&,const std::string&,const IInterface*);
        
        ~StaticNavigationEngine();
 
        StatusCode initialize();
        
        StatusCode finalize();
 
        using INavigationEngine::resolveBoundary;
        using INavigationEngine::resolvePosition;
 
        virtual ExtrapolationCode resolveBoundary(Trk::ExCellCharged& eCell, PropDirection dir=alongMomentum) const;                                                                                         
 
        virtual ExtrapolationCode resolveBoundary(Trk::ExCellNeutral& eCelll, PropDirection dir=alongMomentum) const;
 
        virtual ExtrapolationCode resolvePosition(Trk::ExCellCharged& eCell, PropDirection dir=alongMomentum, bool noLoop=false) const;                                                                                         
 
        virtual ExtrapolationCode resolvePosition(Trk::ExCellNeutral& eCelll, PropDirection dir=alongMomentum, bool noLoop=false) const;
 
        virtual const TrackingGeometry& trackingGeometry() const;
 
     private:
 
        StringProperty m_sopPrefix_prop{this, "OutputPrefix", ""};
        StringProperty m_sopPostfix_prop{this, "OutputPostfix", ""};
 
        template <class T> ExtrapolationCode resolveBoundaryT(ExtrapolationCell<T>& eCell,
                                                             PropDirection dir=alongMomentum) const;
                                                             
        template <class T> ExtrapolationCode resolvePositionT(ExtrapolationCell<T>& eCell,
                                  PropDirection dir=alongMomentum,
                                                              bool noLoop=false) const;
                                                             
        template <class T> ExtrapolationCode handleBoundaryT(ExtrapolationCell<T>& eCell,
                                                             const BoundarySurface<TrackingVolume>& bSurfaceTV, 
                                                             PropDirection dir=alongMomentum,
                                                             bool stepout=false) const;     
                                             
 
        void throwFailedToGetTrackingGeomtry() const;
        const TrackingGeometry* retrieveTrackingGeometry(const EventContext& ctx) const {
          SG::ReadCondHandle<TrackingGeometry>  handle(m_trackingGeometryReadKey,ctx);
           if (!handle.isValid()) {
              EX_MSG_FATAL("", "updateGeo", "", "Could not load TrackingGeometry with name '" << m_trackingGeometryReadKey.key() << "'. Aborting." );
              throwFailedToGetTrackingGeomtry();
           }
           return handle.cptr();
        }
 
        SG::ReadCondHandleKey<TrackingGeometry>   m_trackingGeometryReadKey
           {this, "TrackingGeometryReadKey", "", "Key of the TrackingGeometry conditions data."};
 
        StatusCode  updateTrackingGeometry() const; 
        
        ToolHandle<IPropagationEngine>     m_propagationEngine{this, "PropagationEngine", "Trk::PropagationEngine/AtlasStaticPropagation"};        
        ToolHandle<IMaterialEffectsEngine> m_materialEffectsEngine{this, "MaterialEffectsEngine", "Trk::MaterialEffectsEngine/AtlasStaticNavigationMaterialEffects"};    
 
        std::string                                          m_trackingGeometryName;      
            
    };
 
    inline const Trk::TrackingGeometry& StaticNavigationEngine::trackingGeometry() const {
       const Trk::TrackingGeometry *tracking_geometry = retrieveTrackingGeometry(Gaudi::Hive::currentContext());
       if (!tracking_geometry){
          EX_MSG_FATAL("", "updateGeo", "", "Did not get valid TrackingGeometry. Aborting." );
          throw GaudiException("ExtrapolationEngine", "Problem with TrackingGeometry loading.", StatusCode::FAILURE);
       }
       return *tracking_geometry;
    }
 
} // end of namespace
 
#include "StaticNavigationEngine.icc"  
 
#endif // TRKEXENGINE_STATICNAVIGATIONENGINE_H