ExtrapolatorComparisonTest.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
// ExtrapolatorComparisonTest.h, (c) ATLAS Detector software
 
#ifndef TRKEXALGS_TRKEXTRAPOLATORCOMPARISONTEST_H
#define TRKEXALGS_TRKEXTRAPOLATORCOMPARISONTEST_H
 
// Gaudi includes
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
 
// ATHENA
#include "GaudiKernel/ServiceHandle.h"
#include "Gaudi/Property.h"  /*no forward decl: typedef*/
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/EventContext.h"
#include "AthenaKernel/IAthRNGSvc.h"
#include "AthenaKernel/RNGWrapper.h"
#include "TrkExInterfaces/IExtrapolator.h"
// ACTS
#include "ActsGeometryInterfaces/IActsExtrapolationTool.h"
#include "ActsGeometryInterfaces/ActsGeometryContext.h"
#include "TrkExAlgs/PropResultRootWriterSvc.h"
#include "Acts/EventData/TrackParameters.hpp"
// STL
#include <memory>
#include <vector>
#include <fstream>
#include <mutex>
 
namespace Acts {
  class TrackingGeometry;
  
  namespace detail {
    struct Step;
  }
}
 
struct perigeeParameters {
 double m_d0    ;
 double m_z0    ;
 double m_phi   ;
 double m_eta   ;
 double m_pt    ;
 double m_charge;
 perigeeParameters(double d0, double z0, double phi, double eta, double pt, double charge):
 m_d0(d0), m_z0(z0), m_phi(phi), m_eta(eta), m_pt(pt), m_charge(charge) {}
};
 
namespace Trk 
{
  class ExtrapolatorComparisonTest : public AthReentrantAlgorithm
    {
    public:
 
       ExtrapolatorComparisonTest(const std::string& name, ISvcLocator* pSvcLocator);
       ~ExtrapolatorComparisonTest();
 
       StatusCode          initialize() override;
       StatusCode          execute(const EventContext& ctx) const override;
       StatusCode          finalize() override;
       
    private:
 
      struct ActsTrackWrapper
      {
        ActsTrackWrapper(const Acts::BoundTrackParameters* trackParams, Acts::GeometryContext& ctx)
        : m_params(trackParams)
        , m_geometryContext(ctx) {};
 
        Acts::Vector3 position() const {return m_params->position(m_geometryContext);}
        Acts::BoundVector parameters() const {return m_params->parameters();}
        const std::optional<Acts::BoundSquareMatrix>& covariance() const {return m_params->covariance();}
 
      private:
        const Acts::BoundTrackParameters* m_params;
        Acts::GeometryContext m_geometryContext;
      };
      
      void generatePerigee(std::vector<perigeeParameters>& parameters);
 
      ToolHandle<IActsExtrapolationTool> m_extrapolationTool{this, "ExtrapolationTool", "ActsExtrapolationTool"};
      
      ToolHandle<Trk::IExtrapolator> m_atlasExtrapolator {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"};
 
 
      double                            m_sigmaD0;                    
      double                            m_sigmaZ0;                    
      double                            m_minPhi;                     
      double                            m_maxPhi;                     
      double                            m_minEta;                     
      double                            m_maxEta;                     
      double                            m_minPt;                      
      double                            m_maxPt;                      
                                        
      int                               m_particleType;               
 
      unsigned int                                     m_referenceSurfaces;
 
      std::vector<double>                              m_referenceSurfaceRadius;
      std::vector<double>                              m_referenceSurfaceHalflength;
      
      std::vector<double>                              m_referenceSurfaceNegativeBoundary;
      std::vector<double>                              m_referenceSurfacePositiveBoundary;
      
      std::vector< std::vector<const Trk::Surface*> >  m_atlasReferenceSurfaceTriples;
      std::vector< std::vector< std::shared_ptr<const Acts::Surface> > > m_actsReferenceSurfaceTriples;
      
      int m_eventsPerExecute;
      
      ServiceHandle<PropResultRootWriterSvc> m_atlasPropResultWriterSvc;
      ServiceHandle<PropResultRootWriterSvc> m_actsPropResultWriterSvc;
      ServiceHandle<IAthRNGSvc> m_rndmSvc;
      ATHRNG::RNGWrapper* m_randomEngine = nullptr;
    }; 
} // end of namespace
 
#endif