ExtrapolationValidation.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
// ExtrapolationValidation.h, (c) ATLAS Detector software
 
#ifndef TRKEXALGS_EXTRAPOLATIONVALIDATION_H
#define TRKEXALGS_EXTRAPOLATIONVALIDATION_H
 
// Gaudi includes
#include "AthenaBaseComps/AthAlgorithm.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/IRndmGenSvc.h"
#include "GaudiKernel/RndmGenerators.h"
#include "GaudiKernel/SystemOfUnits.h"
#include "EventPrimitives/EventPrimitives.h"
#include "GeoPrimitives/GeoPrimitivesHelpers.h"
#include <string>
 
#include "TrkExInterfaces/IExtrapolator.h"
 
class TTree;
 
#ifndef TRKEXALGS_MAXPARAMETERS
#define TRKEXALGS_MAXPARAMETERS 10
#endif
 
namespace Trk 
{
 
  class Surface;
  class TrackingGeometry;
  class TrackingVolume;
 
  class ExtrapolationValidation : public AthAlgorithm
    {
    public:
 
       ExtrapolationValidation(const std::string& name, ISvcLocator* pSvcLocator);
       ~ExtrapolationValidation();
 
       StatusCode          initialize();
       StatusCode          execute();
       StatusCode          finalize();
 
    private:
      static Amg::Transform3D createTransform(double x, double y, double z, double phi=0., double theta=0., double alphaZ=0.);      
 
      const TrackingVolume* m_highestVolume = nullptr;
 
      ToolHandle<IExtrapolator> m_extrapolator
    {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"};
 
      Rndm::Numbers* m_gaussDist = nullptr;
      Rndm::Numbers* m_flatDist = nullptr;
 
      BooleanProperty m_materialCollectionValidation
    {this, "ValidateMaterialCollection", true};
 
      BooleanProperty m_direct{this, "ExtrapolateDirectly", false,
    "extrapolate directly"};
 
      TTree* m_validationTree = nullptr;            
 
      StringProperty m_validationTreeName
    {this, "ValidationTreeName", "ExtrapolationValidation",
     "validation tree name - to be acessed by this from root"};
      StringProperty m_validationTreeDescription
    {this, "ValidationTreeDescription",
     "Output of the ExtrapolationValidation Algorithm",
     "validation tree description - second argument in TTree"};
      StringProperty m_validationTreeFolder
    {this, "ValidationTreeFolder", "/val/ExtrapolationValidation",
     "stream/folder to for the TTree to be written out"};
 
      double m_maximumR = 0.;                  
      double m_maximumZ = 0.;                  
 
      DoubleProperty m_sigmaLoc{this, "StartPerigeeSigmaLoc",
    10.*Gaudi::Units::micrometer, "local sigma of start value"};
      DoubleProperty m_sigmaR{this, "StartPerigeeSigmaR",
    17.*Gaudi::Units::micrometer, "r sigma of start value"};
      DoubleProperty m_sigmaZ{this, "StartPerigeeSigmaZ",
    50.*Gaudi::Units::millimeter, "Z sigma of start value"};
      DoubleProperty m_minEta{this, "StartPerigeeMinEta", -3.};
      DoubleProperty m_maxEta{this, "StartPerigeeMaxEta", 3.};
      DoubleProperty m_minP{this, "StartPerigeeMinP", 0.5*Gaudi::Units::GeV};
      DoubleProperty m_maxP{this, "StartPerigeeMaxP", 100.*Gaudi::Units::GeV};
 
      IntegerProperty m_particleType{this, "ParticleType", 2,
    "the particle type for the extrap."};
 
      int m_parameters = 0;          
      float m_parameterLoc1[TRKEXALGS_MAXPARAMETERS]{};    
      float m_parameterLoc2[TRKEXALGS_MAXPARAMETERS]{};    
      float m_parameterPhi[TRKEXALGS_MAXPARAMETERS]{};     
      float m_parameterTheta[TRKEXALGS_MAXPARAMETERS]{};   
      float m_parameterEta[TRKEXALGS_MAXPARAMETERS]{};     
      float m_parameterQoverP[TRKEXALGS_MAXPARAMETERS]{};  
 
      float m_covarianceLoc1[TRKEXALGS_MAXPARAMETERS]{};    
      float m_covarianceLoc2[TRKEXALGS_MAXPARAMETERS]{};    
      float m_covariancePhi[TRKEXALGS_MAXPARAMETERS]{};     
      float m_covarianceTheta[TRKEXALGS_MAXPARAMETERS]{};   
      float m_covarianceQoverP[TRKEXALGS_MAXPARAMETERS]{};  
      float m_covarianceDeterminant[TRKEXALGS_MAXPARAMETERS]{};  
 
      int m_destinationSurfaceType = 0;  
      float m_startX = 0.;      
      float m_startY = 0.;      
      float m_startR = 0.;      
      float m_startZ = 0.;      
      float m_startP = 0.;      
 
      float m_estimationX = 0.;      
      float m_estimationY = 0.;      
      float m_estimationR = 0.;      
      float m_estimationZ = 0.;      
 
      float m_destinationX = 0.;      
      float m_destinationY = 0.;      
      float m_destinationR = 0.;      
      float m_destinationZ = 0.;      
      
      // ---- output statistics
      unsigned int m_triesFront = 0;    
      unsigned int m_breaksFront = 0;  
      unsigned int m_triesBack = 0;    
      unsigned int m_breaksBack = 0;   
 
      unsigned int m_collectedLayerFront = 0;    
      unsigned int m_collectedLayerBack = 0;    
      
    }; 
} // end of namespace
 
#endif