StaticEngine.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

// StaticEngine.h, (c) ATLAS Detector software
 
#ifndef TRKEXENINGE_STATICENGINE_H
#define TRKEXENINGE_STATICENGINE_H
 
#ifndef TRKEXENINGE_OUTPUTHELPER 
#define TRKEXENINGE_OUTPUTHELPER 
#define OH_CHECKFOUND(object) ( object ? "found" : "not found")
#endif
 
// Gaudi
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
// Trk
#include "TrkExInterfaces/IExtrapolationEngine.h"
#include "TrkExInterfaces/ExtrapolationMacros.h"
#include "TrkExUtils/ExtrapolationCell.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkNeutralParameters/NeutralParameters.h"
 
#include "CxxUtils/checker_macros.h"
 
namespace Trk {
 
  class IPropagationEngine;    
  class IMaterialEffectsEngine;
  class INavigationEngine;    
 
    
  class ATLAS_NOT_THREAD_SAFE StaticEngine : public AthAlgTool, virtual public IExtrapolationEngine {
 
      public:
          
        enum ResolveLayerType {
          StartLayer                = 0,
          NavigationLayer           = 1,
          PassThroughLayer          = 2,
          SubStructureLayer         = 3,
          DestinationLayer          = 4,
          StartAndDestinationLayer  = 6,
          UndefinedLayer            = 5
        };          
        
        StaticEngine(const std::string&,const std::string&,const IInterface*);
        
        virtual ~StaticEngine();

        virtual StatusCode initialize() override;
        
        virtual StatusCode finalize() override;
        
        using IExtrapolationEngine::extrapolate;
        
        virtual ExtrapolationCode extrapolate(ExCellCharged& ecCharged,
                                              const Surface* sf = 0,
                                              const BoundaryCheck& bcheck = true) const override;
 

        virtual ExtrapolationCode extrapolate(ExCellNeutral& ecNeutral,
                                              const Surface* sf = 0,
                                              const BoundaryCheck& bcheck = true) const override;
                         
        virtual GeometryType geometryType() const override;
                         
     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 initNavigationT(ExtrapolationCell<T>& eCell,
                                                             const Surface* sf = 0,
                                                             PropDirection dir=alongMomentum,
                                                             BoundaryCheck bcheck = true) const;
                                                                                                            
        template <class T> ExtrapolationCode handleLayerT(ExtrapolationCell<T>& eCell,
                                                          const Surface* sf = 0,
                                                          PropDirection dir=alongMomentum,
                                                          BoundaryCheck bcheck = true) const;  
                                                  
        template <class T> ExtrapolationCode resolveLayerT(ExtrapolationCell<T>& eCell,
                                                           const Trk::Surface* sf,
                                                           PropDirection dir=alongMomentum,
                                                           BoundaryCheck bcheck = true,
                                                           bool hasSubStructure = false,
                                                           bool isStartLayer = false,
                                                           bool isDestinationLayer =false) const;  
        template <class T> ExtrapolationCode handleReturnT(ExtrapolationCode eCode,
                                                           ExtrapolationCell<T>& eCell,
                                                           const Surface* sf = 0,
                                                           PropDirection dir=alongMomentum,
                                                           BoundaryCheck bcheck = true) const;
             
        ToolHandle<IPropagationEngine>     m_propagationEngine{this, "PropagationEngine", "Trk::PropagationEngine/AtlasStaticPropagation"};        
        ToolHandle<INavigationEngine>      m_navigationEngine{this, "NavigationEngine", "Trk::StaticNavigationEngine/AtlasStaticNavigation"};         
        ToolHandle<IMaterialEffectsEngine> m_materialEffectsEngine{this, "MaterialEffectsEngine", "Trk::MaterialEffectsEngine/AtlasStaticNavigationMaterialEffects"};    
 
        StringProperty m_sopPrefix_prop{this, "OutputPrefix", ""};
        StringProperty m_sopPostfix_prop{this, "OutputPostfix", ""};
            
    };
 
  inline GeometryType StaticEngine::geometryType() const 
      { return Trk::Static; }
 
 
} // end of namespace

#include "StaticEngine.icc"  
 
#endif // TRKEXINTERFACES_IStaticEngine_H