ExtrapolationEngine.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
// ExtrapolationEngine.h, (c) ATLAS Detector software
 
#ifndef TRKEXINTERFACES_EXTRAPOLATIONENGINE_H
#define TRKEXINTERFACES_EXTRAPOLATIONENGINE_H
 
// Gaudi
#include "AthenaBaseComps/AthAlgTool.h"
#include "AthenaBaseComps/AthCheckedComponent.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
// Trk
#include "TrkDetDescrInterfaces/ITrackingGeometrySvc.h"
#include "TrkExInterfaces/IExtrapolationEngine.h"
#include "TrkExInterfaces/ExtrapolationMacros.h"
#include "TrkExUtils/ExtrapolationCell.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkNeutralParameters/NeutralParameters.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 INavigationEngine;        
 
  class ExtrapolationEngine : public AthCheckedComponent<AthAlgTool>, virtual public IExtrapolationEngine {
      
      friend class NavigationInitTest;
      
      public:
        ExtrapolationEngine(const std::string&,const std::string&,const IInterface*);
        
        ~ExtrapolationEngine();
 
        StatusCode initialize();
        
        StatusCode finalize();
        
        using IExtrapolationEngine::extrapolate;
        
        virtual ExtrapolationCode extrapolate(ExCellCharged& ecCharged,
                                              const Surface* sf = 0,
                                              const BoundaryCheck& bcheck = true) const;
 
        virtual ExtrapolationCode extrapolate(ExCellNeutral& ecNeutral,
                                              const Surface* sf = 0,
                                              const BoundaryCheck& bcheck = true) const;
                         
                         
        GeometryType geometryType() const;                           
                         
     private:
        template <class T> ExtrapolationCode extrapolateT(ExtrapolationCell<T>& eCell,
                                                          const Surface* sf = 0,
                                                          PropDirection dir=alongMomentum,
                                                          const BoundaryCheck& bcheck = true) const;
            
        template <class T>  ExtrapolationCode initNavigation(ExtrapolationCell<T>& eCell,
                                                             const Surface* sf = 0,
                                                             PropDirection dir=alongMomentum) const;
                
                
        const TrackingGeometry& trackingGeometry() 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."};
 
        ToolHandleArray<IExtrapolationEngine> m_extrapolationEngines{ this, "ExtrapolationEngines", {} };   
        ToolHandle<IPropagationEngine> m_propagationEngine{this, "PropagationEngine", "Trk::PropagationEngine/AtlasStaticPropagation"};         
        ToolHandle<INavigationEngine>  m_navigationEngine{this, "NavigationEngine", "Trk::StaticNavigationEngine/AtlasStaticNavigation"};          
        std::vector<const IExtrapolationEngine*>            m_eeAccessor;                
 
 
        bool                                                m_forceSearchInit; 
    
    };
 
  inline GeometryType  ExtrapolationEngine::geometryType() const 
      { return Trk::Master; }
 
 
  inline const Trk::TrackingGeometry& ExtrapolationEngine::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 "ExtrapolationEngine.icc"  
 
#endif // TRKEXINTERFACES_IEXTRAPOLATIONENGINE_H