ExtrapolatorComparisonTest.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 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 "GaudiKernel/SystemOfUnits.h"
#include "AthenaKernel/IAthRNGSvc.h"
#include "AthenaKernel/RNGWrapper.h"
#include "TrkExInterfaces/IExtrapolator.h"
// ACTS
#include "ActsGeometryInterfaces/IExtrapolationTool.h"
#include "ActsGeometryInterfaces/GeometryContext.h"
#include "ActsGeometryInterfaces/ITrackingGeometryTool.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<ActsTrk::IExtrapolationTool> m_extrapolationTool{this, "ExtrapolationTool", "ActsExtrapolationTool"};
      
      ToolHandle<Trk::IExtrapolator> m_atlasExtrapolator {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"};
 
      PublicToolHandle<ActsTrk::ITrackingGeometryTool> m_trackingGeometryTool{this, "TrackingGeometryTool", "ActsTrackingGeometryTool"};
 
      DoubleProperty m_sigmaD0
    {this, "StartPerigeeSigmaD0", 17.*Gaudi::Units::micrometer};
      DoubleProperty m_sigmaZ0
    {this, "StartPerigeeSigmaZ0", 50.*Gaudi::Units::micrometer};
      DoubleProperty m_minPhi{this, "StartPerigeeMinPhi", -M_PI};
      DoubleProperty m_maxPhi{this, "StartPerigeeMaxPhi", M_PI};
      DoubleProperty m_minEta{this, "StartPerigeeMinEta", -3.};
      DoubleProperty m_maxEta{this, "StartPerigeeMaxEta", 3.};
      DoubleProperty m_minPt
    {this, "StartPerigeeMinPt", 0.5*Gaudi::Units::GeV};
      DoubleProperty m_maxPt
    {this, "StartPerigeeMaxPt", 50000*Gaudi::Units::GeV};
                                        
      IntegerProperty m_particleType
    {this, "ParticleType", 2, "the particle type for the extrap."};
 
      unsigned int m_referenceSurfaces = 0;
 
      DoubleArrayProperty m_referenceSurfaceRadius
    {this, "ReferenceSurfaceRadius", {}};
      DoubleArrayProperty m_referenceSurfaceHalflength
    {this, "ReferenceSurfaceHalfZ", {}};
      
      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;
      
      IntegerProperty m_eventsPerExecute{this, "EventsPerExecute", 1};
      
      ServiceHandle<PropResultRootWriterSvc> m_atlasPropResultWriterSvc
    {this, "ATLASPropResultRootWriter", "ATLASPropResultRootWriterSvc"};
      ServiceHandle<PropResultRootWriterSvc> m_actsPropResultWriterSvc
    {this, "ACTSPropResultRootWriter", "ACTSPropResultRootWriterSvc"};
      ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc"};
      ATHRNG::RNGWrapper* m_randomEngine = nullptr;
    }; 
} // end of namespace
 
#endif