The ExtrapolationValidation Algorithm runs a number of n test extrapolations from randomly distributed Track Parameters to randombly distributed reference surfcas within. More...

#include <ExtrapolationValidation.h>

Inheritance diagram for Trk::ExtrapolationValidation:

Collaboration diagram for Trk::ExtrapolationValidation:

Public Member Functions
	ExtrapolationValidation (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Athena-Algorithm Constructor.
	~ExtrapolationValidation ()
	Default Destructor.
StatusCode	initialize ()
	standard Athena-Algorithm method
StatusCode	execute ()
	standard Athena-Algorithm method
StatusCode	finalize ()
	standard Athena-Algorithm method
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static Amg::Transform3D	createTransform (double x, double y, double z, double phi=0., double theta=0., double alphaZ=0.)
	private helper method to create a HepTransform

Private Attributes
const TrackingVolume *	m_highestVolume = nullptr
	the highest volume
ToolHandle< IExtrapolator >	m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"}
	The Extrapolator to be retrieved.
Rndm::Numbers *	m_gaussDist = nullptr
	Random Number setup.
Rndm::Numbers *	m_flatDist = nullptr
BooleanProperty	m_materialCollectionValidation {this, "ValidateMaterialCollection", true}
BooleanProperty	m_direct
TTree *	m_validationTree = nullptr
	Root Validation Tree.
StringProperty	m_validationTreeName
StringProperty	m_validationTreeDescription
StringProperty	m_validationTreeFolder
double	m_maximumR = 0.
	maximum R of the highest
double	m_maximumZ = 0.
	maximum halfZ of the highest tracking volume
DoubleProperty	m_sigmaLoc
DoubleProperty	m_sigmaR
DoubleProperty	m_sigmaZ
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
int	m_parameters = 0
	maximum 3 : start - destination - backward
float	m_parameterLoc1 [TRKEXALGS_MAXPARAMETERS] {}
	start local 1
float	m_parameterLoc2 [TRKEXALGS_MAXPARAMETERS] {}
	start local 2
float	m_parameterPhi [TRKEXALGS_MAXPARAMETERS] {}
	start phi
float	m_parameterTheta [TRKEXALGS_MAXPARAMETERS] {}
	start theta
float	m_parameterEta [TRKEXALGS_MAXPARAMETERS] {}
	start eta
float	m_parameterQoverP [TRKEXALGS_MAXPARAMETERS] {}
	start qOverP
float	m_covarianceLoc1 [TRKEXALGS_MAXPARAMETERS] {}
	start local 1
float	m_covarianceLoc2 [TRKEXALGS_MAXPARAMETERS] {}
	start local 2
float	m_covariancePhi [TRKEXALGS_MAXPARAMETERS] {}
	start phi
float	m_covarianceTheta [TRKEXALGS_MAXPARAMETERS] {}
	start theta
float	m_covarianceQoverP [TRKEXALGS_MAXPARAMETERS] {}
	start qOverP
float	m_covarianceDeterminant [TRKEXALGS_MAXPARAMETERS] {}
	start qOverP
int	m_destinationSurfaceType = 0
	destination surface type
float	m_startX = 0.
	startX
float	m_startY = 0.
	startX
float	m_startR = 0.
	startX
float	m_startZ = 0.
	startX
float	m_startP = 0.
	startP
float	m_estimationX = 0.
	estimation in X
float	m_estimationY = 0.
	estimation in Y
float	m_estimationR = 0.
	estimation in R
float	m_estimationZ = 0.
	estimation in Z
float	m_destinationX = 0.
	destination in X
float	m_destinationY = 0.
	destination in Y
float	m_destinationR = 0.
	destination in R
float	m_destinationZ = 0.
	destination in Z
unsigned int	m_triesFront = 0
	events front
unsigned int	m_breaksFront = 0
	breaks front
unsigned int	m_triesBack = 0
	events back
unsigned int	m_breaksBack = 0
	breaks
unsigned int	m_collectedLayerFront = 0
	collected material layers forward
unsigned int	m_collectedLayerBack = 0
	collected material layers backwards
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

The ExtrapolationValidation Algorithm runs a number of n test extrapolations from randomly distributed Track Parameters to randombly distributed reference surfcas within.

a) the Inner Detector if DetFlags.ID_On()
b) the Calorimeter if DetFlags.Calo_On()
c) the Muon System if DetFlags.Muon_On()

and backwards.

It is the TestAlgorithm for 'the' Extrapolator instance provided to client algorithms.

Author: Andreas Salzburger Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Definition at line 56 of file ExtrapolationValidation.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ExtrapolationValidation()

Trk::ExtrapolationValidation::ExtrapolationValidation	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard Athena-Algorithm Constructor.

Definition at line 27 of file ExtrapolationValidation.cxx.

28 :

29 AthAlgorithm(name,pSvcLocator) {}

AthAlgorithm::AthAlgorithm

AthAlgorithm()

Default constructor:

◆ ~ExtrapolationValidation()

Trk::ExtrapolationValidation::~ExtrapolationValidation ( )

Default Destructor.

Definition at line 33 of file ExtrapolationValidation.cxx.

{
  // clear random number generators
  delete m_gaussDist;
  delete m_flatDist;
}

Member Function Documentation

◆ createTransform()

Amg::Transform3D Trk::ExtrapolationValidation::createTransform	(	double	x,
		double	y,
		double	z,
		double	phi = 0.,
		double	theta = 0.,
		double	alphaZ = 0. )

staticprivate

private helper method to create a HepTransform

Definition at line 493 of file ExtrapolationValidation.cxx.

{
 
 if (phi!=0. && theta != 0.){
   // create the Start Surface
   Amg::Vector3D surfacePosition(x,y,z);
   // z direction
   Amg::Vector3D surfaceZdirection(cos(phi)*sin(theta),
                                       sin(phi)*sin(theta),
                                       cos(theta));
   // the global z axis
   Amg::Vector3D zAxis(0.,0.,1.);
   // the y direction
   Amg::Vector3D surfaceYdirection(zAxis.cross(surfaceZdirection));
   // the x direction
   Amg::Vector3D surfaceXdirection(surfaceYdirection.cross(surfaceZdirection));
   
   double nx = 1./sqrt(surfaceXdirection[0]*surfaceXdirection[0]+surfaceXdirection[1]*surfaceXdirection[1]+surfaceXdirection[2]*surfaceXdirection[2]);
   double ny = 1./sqrt(surfaceYdirection[0]*surfaceYdirection[0]+surfaceYdirection[1]*surfaceYdirection[1]+surfaceYdirection[2]*surfaceYdirection[2]);
   surfaceXdirection[0]*=nx;
   surfaceXdirection[1]*=nx;
   surfaceXdirection[2]*=nx;
   
   surfaceYdirection[0]*=ny;
   surfaceYdirection[1]*=ny;
   surfaceYdirection[2]*=ny;
   // the rotation
   Amg::RotationMatrix3D surfaceRotation;
   surfaceRotation.col(0) = surfaceXdirection;
   surfaceRotation.col(1) = surfaceYdirection;
   surfaceRotation.col(2) = surfaceZdirection;
   // return it
   if (alphaZ==0.)
     return Amg::Transform3D(surfaceRotation, surfacePosition);   
   Amg::Transform3D nominalTransform(surfaceRotation, surfacePosition);   
   return Amg::Transform3D(nominalTransform*Amg::AngleAxis3D(alphaZ,zAxis));
   
 }
 
  return Amg::Transform3D(Amg::Translation3D(x,y,z));
}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode Trk::ExtrapolationValidation::execute ( )

standard Athena-Algorithm method

Definition at line 132 of file ExtrapolationValidation.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
  // get the overall dimensions
  if (!m_highestVolume){
     // get TrackingGeometry and highest volume
     const Trk::TrackingGeometry* trackingGeometry = m_extrapolator->trackingGeometry();
     m_highestVolume = trackingGeometry ? trackingGeometry->highestTrackingVolume() : nullptr;
     const Trk::CylinderVolumeBounds* cylBounds = m_highestVolume ? 
         dynamic_cast<const Trk::CylinderVolumeBounds*>(&(m_highestVolume->volumeBounds())) : nullptr;
    // bail out
    if (!cylBounds){
       ATH_MSG_WARNING("No highest TrackingVolume / no VolumeBounds ... pretty useless! ");
       return StatusCode::SUCCESS;   
     }
    // get the numbers
    m_maximumR = cylBounds->outerRadius();
    m_maximumZ = cylBounds->halflengthZ(); 
  }
 
  // intialize the values
  m_parameters             = 0;
  m_destinationSurfaceType = 0;
  // -----------> start
  m_startX                 = 0.;
  m_startY                 = 0.;
  m_startR                 = 0.;
  m_startZ                 = 0.;
  // -----------> estimation
  m_estimationX            = 0.;
  m_estimationY            = 0.;
  m_estimationR            = 0.;
  m_estimationZ            = 0.;
  // -----------> destination
  m_destinationX           = 0.;
  m_destinationY           = 0.;
  m_destinationR           = 0.;
  m_destinationZ           = 0.;
 
   // the local start parameters
   m_parameterLoc1[m_parameters]  = m_sigmaLoc * m_gaussDist->shoot();
   m_parameterLoc2[m_parameters]  = m_sigmaLoc * m_gaussDist->shoot();
   // are adopted for planar and straight line surfaces
   m_parameterPhi[m_parameters]   = M_PI * m_flatDist->shoot();
   m_parameterPhi[m_parameters]  *= (m_flatDist->shoot() > 0.5 ) ? -1. : 1.;
   m_parameterEta[m_parameters]   = m_minEta + m_flatDist->shoot()*(m_maxEta-m_minEta);
   m_parameterTheta[m_parameters] = 2.*std::atan(std::exp(-m_parameterEta[m_parameters]));
 
   m_covarianceLoc1[m_parameters] = std::abs(m_parameterLoc1[m_parameters] * 0.1);
   m_covarianceLoc2[m_parameters] = std::abs(m_parameterLoc2[m_parameters] * 0.1);
   m_covariancePhi[m_parameters] = std::abs(m_parameterPhi[m_parameters] * 0.1);
   m_covarianceTheta[m_parameters] = std::abs(m_parameterTheta[m_parameters] * 0.1);
 
   // this is fine
   double p = m_minP + m_flatDist->shoot()*(m_maxP-m_minP);
   double charge = (m_flatDist->shoot() > 0.5 ) ? -1. : 1.;   
   m_parameterQoverP[m_parameters] = charge/p;
 
   m_covarianceQoverP[m_parameters] = std::abs(m_parameterQoverP[m_parameters] * 0.1);
 
   // for the momentum logging
   m_startP  = p;   
 
   // start
   m_startR          = std::abs(m_sigmaR * m_gaussDist->shoot());
   double surfacePhi = M_PI * m_flatDist->shoot();
   surfacePhi       *= (m_flatDist->shoot() > 0.5 ) ? -1. : 1.;
   m_startX          = m_startR*cos(surfacePhi);
   m_startY          = m_startR*sin(surfacePhi);
   m_startZ          = m_sigmaZ * m_gaussDist->shoot();
 
   // rotate it around Z   
   double alphaZ = M_PI * m_flatDist->shoot();
   alphaZ       *= (m_flatDist->shoot() > 0.5 ) ? -1. : 1.;
 
   // create the plane surface
   Trk::PlaneSurface startSurface(createTransform(m_startX,
                                                  m_startY,
                                                  m_startZ,
                                                  m_parameterPhi[m_parameters],
                                                  m_parameterTheta[m_parameters],
                                                  alphaZ),
                                                  10e3,10e3);
 
 
 
   AmgSymMatrix(5) covariance;
   covariance.setZero();
   ATH_MSG_VERBOSE(m_covarianceLoc1[m_parameters]);
   covariance(0,0) =  m_covarianceLoc1[m_parameters];
   ATH_MSG_VERBOSE(m_covarianceLoc2[m_parameters]);
   covariance(1,1) =  m_covarianceLoc2[m_parameters];
   ATH_MSG_VERBOSE(m_covariancePhi[m_parameters]);
   covariance(2,2) =   m_covariancePhi[m_parameters];
   ATH_MSG_VERBOSE(m_covarianceTheta[m_parameters]);
   covariance(3,3) =  m_covarianceTheta[m_parameters];
   ATH_MSG_VERBOSE(m_covarianceQoverP[m_parameters]);
   covariance(4,4) = m_covarianceQoverP[m_parameters];
   ATH_MSG_VERBOSE("Initial Setting: \n"<<covariance);
   
 
   m_covarianceDeterminant[m_parameters] = covariance.determinant();
 
   // the initial perigee with random numbers
   Trk::AtaPlane startParameters(m_parameterLoc1[m_parameters],
                                 m_parameterLoc2[m_parameters],
                                 m_parameterPhi[m_parameters],
                                 m_parameterTheta[m_parameters],
                                 m_parameterQoverP[m_parameters],
                                 startSurface,
                                 std::move(covariance)); 
   
   ATH_MSG_VERBOSE( "Start Parameters : " << startParameters );
   if(startParameters.covariance())ATH_MSG_VERBOSE( "Start Covariance : \n" << *startParameters.covariance() );
 
 
   // destination position
   m_estimationR        = m_maximumR * m_flatDist->shoot();
 
   // --------------- propagate to find a first intersection ---------------------
   Amg::Transform3D CylTrf;
   CylTrf.setIdentity();
   Trk::CylinderSurface estimationCylinder(CylTrf, m_estimationR, 10e10);
   const Trk::TrackParameters* estimationParameters = m_extrapolator->extrapolateDirectly(ctx,
                                                                                          startParameters,
                                                                                          estimationCylinder,
                                                                                          Trk::alongMomentum,
                                                                                          false).release();
   if (!estimationParameters) {
        ATH_MSG_VERBOSE( "Estimation of intersection did not work - skip event !" );
        return StatusCode::SUCCESS;
   }
   else if (m_highestVolume && estimationParameters && !(m_highestVolume->inside(estimationParameters->position()))){
        ATH_MSG_VERBOSE( "Estimation of intersection is outside the known world - skip event !" );
        delete estimationParameters;
        return StatusCode::SUCCESS;
   }
 
   ATH_MSG_VERBOSE( "Estimation Parameters: " << *estimationParameters );
 
   // record the estimation parameters
   ++m_triesFront;
   ++m_parameters;
   m_parameterLoc1[m_parameters]   = estimationParameters->parameters()[Trk::loc1];
   m_parameterLoc2[m_parameters]   = estimationParameters->parameters()[Trk::loc2];
   m_parameterPhi[m_parameters]    = estimationParameters->parameters()[Trk::phi];
   m_parameterEta[m_parameters]    = estimationParameters->eta();
   m_parameterTheta[m_parameters]  = estimationParameters->parameters()[Trk::theta];
   m_parameterQoverP[m_parameters] = estimationParameters->parameters()[Trk::qOverP];
   if(estimationParameters->covariance()){
     m_covarianceLoc1[m_parameters] = (*estimationParameters->covariance())(0,0);
     m_covarianceLoc2[m_parameters] = (*estimationParameters->covariance())(1,1);
     m_covariancePhi[m_parameters] = (*estimationParameters->covariance())(2,2);
     m_covarianceTheta[m_parameters] = (*estimationParameters->covariance())(3,3);
     m_covarianceQoverP[m_parameters] = (*estimationParameters->covariance())(4,4);
     m_covarianceDeterminant[m_parameters] = (estimationParameters->covariance())->determinant();
   }
   else{
     m_covarianceLoc1[m_parameters] = 0;
     m_covarianceLoc2[m_parameters] = 0;
     m_covariancePhi[m_parameters] = 0;
     m_covarianceTheta[m_parameters] = 0;
     m_covarianceQoverP[m_parameters] = 0;
     m_covarianceDeterminant[m_parameters] = 0;
   }
   // the start Momentum
 
   // get the estimated position
   const Amg::Vector3D& estimatedPosition = estimationParameters->position();
 
   m_estimationX        = estimatedPosition.x();
   m_estimationY        = estimatedPosition.y();
   m_estimationZ        = estimatedPosition.z();
 
   // cleanup for memory reasons
   delete estimationParameters; estimationParameters = nullptr;
 
   // create the radom surface at the destination point
   Trk::PlaneSurface destinationSurface(createTransform(m_estimationX,
                                                        m_estimationY,
                                                        m_estimationZ,
                                                        m_parameterPhi[m_parameters],
                                                        m_parameterTheta[m_parameters]), 10e5 , 10e5);
 
 
   ATH_MSG_VERBOSE( "Extrapolation to Destination Surface: " << destinationSurface );
 
   // the destination parameters
   const Trk::TrackParameters* destParameters = nullptr; 
   // the standard validation ... 
   if (!m_materialCollectionValidation && !m_direct)
       destParameters = m_extrapolator->extrapolate(ctx,
                                                    startParameters,
                                                    destinationSurface, 
                                                    Trk::alongMomentum,
                                                    false,
                                                    static_cast<Trk::ParticleHypothesis>(m_particleType.value()),
                                                    Trk::addNoise).release();
   else if(!m_direct){ // material collection validation
       // get the vector of TrackStateOnSurfaces back
      const std::vector<const Trk::TrackStateOnSurface*>* 
                     collectedMaterial = m_extrapolator->extrapolateM(ctx,
                                                                      startParameters,
                                                                      destinationSurface,
                                                                      Trk::alongMomentum,
                                                                      false,
                                                                      static_cast<Trk::ParticleHypothesis>(m_particleType.value()));
 
      // get the last one and clone it  
      if (collectedMaterial && !collectedMaterial->empty()){
        // get the last track state on surface & clone the destination parameters
        const Trk::TrackStateOnSurface* destinationState = collectedMaterial->back();
        destParameters = destinationState->trackParameters() ? destinationState->trackParameters()->clone() : nullptr;
        m_collectedLayerFront += collectedMaterial->size();
        // delete the layers / cleanup
        for (const auto* tsos : *collectedMaterial) {
          delete tsos;
        }
     }
   }
 
   else{
     destParameters = m_extrapolator->extrapolateDirectly(ctx,
                                                          startParameters,
                                                          destinationSurface, 
                                                          Trk::alongMomentum,
                                                          false,
                                                          static_cast<Trk::ParticleHypothesis>(m_particleType.value())).release();
     
   }
   // ----------------------- check if forward call was successful and continue then
   if (destParameters){
       // successful tries
       ++m_triesBack;
       // record the destination parameters 
       ++m_parameters;
       m_parameterLoc1[m_parameters]   = destParameters->parameters()[Trk::loc1];
       m_parameterLoc2[m_parameters]   = destParameters->parameters()[Trk::loc2];
       m_parameterPhi[m_parameters]    = destParameters->parameters()[Trk::phi];
       m_parameterEta[m_parameters]    = destParameters->eta();
       m_parameterTheta[m_parameters]  = destParameters->parameters()[Trk::theta];
       m_parameterQoverP[m_parameters] = destParameters->parameters()[Trk::qOverP];
       if(destParameters->covariance()){
     m_covarianceLoc1[m_parameters] =  (*destParameters->covariance())(0,0);
     m_covarianceLoc2[m_parameters] =  (*destParameters->covariance())(1,1);
     m_covariancePhi[m_parameters] =  (*destParameters->covariance())(2,2);
     m_covarianceTheta[m_parameters] =  (*destParameters->covariance())(3,3);
     m_covarianceQoverP[m_parameters] = (*destParameters->covariance())(4,4);
     m_covarianceDeterminant[m_parameters] = (destParameters->covariance())->determinant();
       }
       else{
     m_covarianceLoc1[m_parameters] =  0;
     m_covarianceLoc2[m_parameters] =  0;
     m_covariancePhi[m_parameters] =  0;
     m_covarianceTheta[m_parameters] =  0;
     m_covarianceQoverP[m_parameters] = 0;
     m_covarianceDeterminant[m_parameters] = 0;
       }
       // record the destination parameters
       const Amg::Vector3D& destinationPosition = destParameters->position();
       m_destinationX = destinationPosition.x();
       m_destinationY = destinationPosition.y();
       m_destinationZ = destinationPosition.z();
       m_destinationR = destinationPosition.perp();
 
       // now simply go backwards
       const Trk::TrackParameters* backParameters = nullptr;
       // the standard validation ... 
       if (!m_materialCollectionValidation && !m_direct)
            backParameters = m_extrapolator->extrapolate(ctx,
                                                         *destParameters,
                                                         startSurface, 
                                                         Trk::oppositeMomentum,
                                                         false,
                                                         static_cast<Trk::ParticleHypothesis>(m_particleType.value()),
                                                         Trk::removeNoise).release();
       else if(!m_direct){ // material collection validation
            // get the vector of TrackStateOnSurfaces back
            const std::vector<const Trk::TrackStateOnSurface*>* 
                     collectedBackMaterial = m_extrapolator->extrapolateM(ctx,
                                                                          *destParameters,
                                                                          startSurface,
                                                                          Trk::oppositeMomentum,
                                                                          false,
                                                                          static_cast<Trk::ParticleHypothesis>(m_particleType.value()));
            // get the last one and clone it  
            if (collectedBackMaterial && !collectedBackMaterial->empty()){
                // get the last track state on surface & clone the destination parameters
                const Trk::TrackStateOnSurface* startState = collectedBackMaterial->back();
                // assign the last ones of the call
                backParameters = startState->trackParameters() ? startState->trackParameters()->clone() : nullptr;
                m_collectedLayerBack += collectedBackMaterial->size();
                // delete the layers / cleanup
                for (const auto* tsos : *collectedBackMaterial) {
                  delete tsos;
                }
            }
       }
 
       else{
     backParameters = m_extrapolator->extrapolateDirectly(ctx,
                                                        *destParameters,
                                                        startSurface, 
                                                        Trk::oppositeMomentum,
                                                        false,
                                                        static_cast<Trk::ParticleHypothesis>(m_particleType.value())).release();
 
       }
      // ----------------------- check if backward call was successful and continue then
      if (backParameters){
 
          ATH_MSG_VERBOSE( "Back Parameters : " << *backParameters );
 
          // record the back extrapolated ones
          ++m_parameters;
          m_parameterLoc1[m_parameters]   = backParameters->parameters()[Trk::loc1];
          m_parameterLoc2[m_parameters]   = backParameters->parameters()[Trk::loc2];
          m_parameterPhi[m_parameters]    = backParameters->parameters()[Trk::phi];
          m_parameterEta[m_parameters]    = backParameters->eta();
          m_parameterTheta[m_parameters]  = backParameters->parameters()[Trk::theta];
          m_parameterQoverP[m_parameters] = backParameters->parameters()[Trk::qOverP];
      if(backParameters->covariance()){
      m_covarianceLoc1[m_parameters] =  (*backParameters->covariance())(0,0);
      m_covarianceLoc2[m_parameters] =  (*backParameters->covariance())(1,1);
      m_covariancePhi[m_parameters] =  (*backParameters->covariance())(2,2);
      m_covarianceTheta[m_parameters] =  (*backParameters->covariance())(3,3);
      m_covarianceQoverP[m_parameters] = (*backParameters->covariance())(4,4);
      m_covarianceDeterminant[m_parameters] = (backParameters->covariance())->determinant();
      }
      else{
        m_covarianceLoc1[m_parameters] =  0;
      m_covarianceLoc2[m_parameters] =  0;
      m_covariancePhi[m_parameters] =  0;
      m_covarianceTheta[m_parameters] =  0;
      m_covarianceQoverP[m_parameters] = 0;
      m_covarianceDeterminant[m_parameters] = 0;
      }
          // memory cleanup
          delete backParameters;
        } else 
            ++m_breaksBack;
         // memory cleanup
        delete destParameters;
      } else 
        ++m_breaksFront;
    // increase ones more 
    ++m_parameters;
    // memory cleanup
 
  if (m_validationTree)
    m_validationTree->Fill();
   
 
  //std::cout<<"Cleaning up..."<<std::endl;
  //delete covariance;
 
   return StatusCode::SUCCESS;
}

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

◆ finalize()

StatusCode Trk::ExtrapolationValidation::finalize ( )

standard Athena-Algorithm method

Definition at line 110 of file ExtrapolationValidation.cxx.

{
  // Code entered here will be executed once at the end of the program run.
    ATH_MSG_INFO("================== Output Statistics =========================");
    ATH_MSG_INFO("= Navigation : ");
    ATH_MSG_INFO("=  - breaks fwd : " << static_cast<double>(m_breaksFront)/static_cast<double>(m_triesFront)
        << " (" << m_breaksFront << "/" << m_triesFront << ")");
    ATH_MSG_INFO("=  - breaks bwd : " << static_cast<double>(m_breaksBack)/static_cast<double>(m_triesBack)
        << " (" << m_breaksBack << "/" << m_triesBack << ")");
    if (m_materialCollectionValidation){
        ATH_MSG_INFO("= Material collection : ");
        ATH_MSG_INFO("=  - layer collected fwd : " << m_collectedLayerFront );
        ATH_MSG_INFO("=  - layer collected bwd : " << m_collectedLayerBack  );
    }
 
    ATH_MSG_INFO("==============================================================");
  
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode Trk::ExtrapolationValidation::initialize ( )

standard Athena-Algorithm method

Definition at line 43 of file ExtrapolationValidation.cxx.

{
  // Code entered here will be executed once at program start.
  ATH_MSG_INFO( " initialize()" );
 
   // Get Extrapolator from ToolService   
   ATH_CHECK( m_extrapolator.retrieve());
  
   // create the new Tree
   m_validationTree = new TTree(m_validationTreeName.value().c_str(),
                m_validationTreeDescription.value().c_str());
 
   // the branches for the parameters
   m_validationTree->Branch("Parameters",            &m_parameters,     "params/I");
   m_validationTree->Branch("ParametersLoc1",        m_parameterLoc1,   "paramLoc1[params]/F");
   m_validationTree->Branch("ParametersLoc2",        m_parameterLoc2,   "paramLoc2[params]/F");
   m_validationTree->Branch("ParametersPhi",         m_parameterPhi,    "paramPhi[params]/F");
   m_validationTree->Branch("ParametersTheta",       m_parameterTheta,  "paramTheta[params]/F");
   m_validationTree->Branch("ParametersEta",         m_parameterEta,    "paramEta[params]/F");
   m_validationTree->Branch("ParametersQoverP",      m_parameterQoverP, "paramQoverP[params]/F");
   // for the covariance diagonals
   m_validationTree->Branch("CovarianceLoc1",        m_covarianceLoc1,   "covLoc1[params]/F");
   m_validationTree->Branch("CovarianceLoc2",        m_covarianceLoc2,   "covLoc2[params]/F");
   m_validationTree->Branch("CovariancePhi",         m_covariancePhi,    "covPhi[params]/F");
   m_validationTree->Branch("CovarianceTheta",       m_covarianceTheta,  "covTheta[params]/F");
   m_validationTree->Branch("CovarianceQoverP",      m_covarianceQoverP, "covQoverP[params]/F");
   m_validationTree->Branch("CovarianceDeterminant",      m_covarianceDeterminant, "covDet[params]/F");
   // the start Momentum
   m_validationTree->Branch("StartMomentum",         &m_startP,     "startP/F");
   // for the start surface
   m_validationTree->Branch("StartSurfaceX",         &m_startX,     "startX/F");
   m_validationTree->Branch("StartSurfaceY",         &m_startY,     "startY/F");
   m_validationTree->Branch("StartSurfaceR",         &m_startR,     "startR/F");
   m_validationTree->Branch("StartSurfaceZ",         &m_startZ,     "startZ/F");
   // the estimation of the parameters
   m_validationTree->Branch("EstimationSurfaceX",              &m_estimationX,               "estimateX/F");
   m_validationTree->Branch("EstimationSurfaceY",              &m_estimationY,               "estimateY/F");
   m_validationTree->Branch("EstimationSurfaceR",              &m_estimationR,               "estimateR/F");
   m_validationTree->Branch("EstimationSurfaceZ",              &m_estimationZ,               "estimateZ/F");
   // for the surface type   
   m_validationTree->Branch("DestinationSurfaceType",           &m_destinationSurfaceType,     "surfaceType/I");
   m_validationTree->Branch("DestinationSurfaceX",              &m_destinationX,               "surfaceX/F");
   m_validationTree->Branch("DestinationSurfaceY",              &m_destinationY,               "surfaceY/F");
   m_validationTree->Branch("DestinationSurfaceR",              &m_destinationR,               "surfaceR/F");
   m_validationTree->Branch("DestinationSurfaceZ",              &m_destinationZ,               "surfaceZ/F");
 
   // now register the Tree
   SmartIF<ITHistSvc> tHistSvc{service("THistSvc")};
   if (!tHistSvc){
      ATH_MSG_ERROR("initialize() Could not find Hist Service -> Switching ValidationMode Off !" );
      delete m_validationTree; m_validationTree = nullptr;
   }
   if ((tHistSvc->regTree(m_validationTreeFolder, m_validationTree)).isFailure()) {
      ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !" );
      delete m_validationTree; m_validationTree = nullptr;
   }
 
  // intialize the random number generators
  m_gaussDist = new Rndm::Numbers(randSvc(), Rndm::Gauss(0.,1.));
  m_flatDist  = new Rndm::Numbers(randSvc(), Rndm::Flat(0.,1.));
 
  ATH_MSG_INFO( "initialize() successful");
  return StatusCode::SUCCESS;
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ m_breaksBack

unsigned int Trk::ExtrapolationValidation::m_breaksBack = 0

private

breaks

Definition at line 159 of file ExtrapolationValidation.h.

◆ m_breaksFront

unsigned int Trk::ExtrapolationValidation::m_breaksFront = 0

private

breaks front

Definition at line 157 of file ExtrapolationValidation.h.

◆ m_collectedLayerBack

unsigned int Trk::ExtrapolationValidation::m_collectedLayerBack = 0

private

collected material layers backwards

Definition at line 162 of file ExtrapolationValidation.h.

◆ m_collectedLayerFront

unsigned int Trk::ExtrapolationValidation::m_collectedLayerFront = 0

private

collected material layers forward

Definition at line 161 of file ExtrapolationValidation.h.

◆ m_covarianceDeterminant

float Trk::ExtrapolationValidation::m_covarianceDeterminant[TRKEXALGS_MAXPARAMETERS] {}

private

start qOverP

Definition at line 136 of file ExtrapolationValidation.h.

136{};

◆ m_covarianceLoc1

float Trk::ExtrapolationValidation::m_covarianceLoc1[TRKEXALGS_MAXPARAMETERS] {}

private

start local 1

Definition at line 131 of file ExtrapolationValidation.h.

131{};

◆ m_covarianceLoc2

float Trk::ExtrapolationValidation::m_covarianceLoc2[TRKEXALGS_MAXPARAMETERS] {}

private

start local 2

Definition at line 132 of file ExtrapolationValidation.h.

132{};

◆ m_covariancePhi

float Trk::ExtrapolationValidation::m_covariancePhi[TRKEXALGS_MAXPARAMETERS] {}

private

start phi

Definition at line 133 of file ExtrapolationValidation.h.

133{};

◆ m_covarianceQoverP

float Trk::ExtrapolationValidation::m_covarianceQoverP[TRKEXALGS_MAXPARAMETERS] {}

private

start qOverP

Definition at line 135 of file ExtrapolationValidation.h.

135{};

◆ m_covarianceTheta

float Trk::ExtrapolationValidation::m_covarianceTheta[TRKEXALGS_MAXPARAMETERS] {}

private

start theta

Definition at line 134 of file ExtrapolationValidation.h.

134{};

◆ m_destinationR

float Trk::ExtrapolationValidation::m_destinationR = 0.

private

destination in R

Definition at line 152 of file ExtrapolationValidation.h.

◆ m_destinationSurfaceType

int Trk::ExtrapolationValidation::m_destinationSurfaceType = 0

private

destination surface type

Definition at line 138 of file ExtrapolationValidation.h.

◆ m_destinationX

float Trk::ExtrapolationValidation::m_destinationX = 0.

private

destination in X

Definition at line 150 of file ExtrapolationValidation.h.

◆ m_destinationY

float Trk::ExtrapolationValidation::m_destinationY = 0.

private

destination in Y

Definition at line 151 of file ExtrapolationValidation.h.

◆ m_destinationZ

float Trk::ExtrapolationValidation::m_destinationZ = 0.

private

destination in Z

Definition at line 153 of file ExtrapolationValidation.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_direct

BooleanProperty Trk::ExtrapolationValidation::m_direct

private

Initial value:

{this, "ExtrapolateDirectly", false,

"extrapolate directly"}

Definition at line 90 of file ExtrapolationValidation.h.

90 {this, "ExtrapolateDirectly", false,

91 "extrapolate directly"};

◆ m_estimationR

float Trk::ExtrapolationValidation::m_estimationR = 0.

private

estimation in R

Definition at line 147 of file ExtrapolationValidation.h.

◆ m_estimationX

float Trk::ExtrapolationValidation::m_estimationX = 0.

private

estimation in X

Definition at line 145 of file ExtrapolationValidation.h.

◆ m_estimationY

float Trk::ExtrapolationValidation::m_estimationY = 0.

private

estimation in Y

Definition at line 146 of file ExtrapolationValidation.h.

◆ m_estimationZ

float Trk::ExtrapolationValidation::m_estimationZ = 0.

private

estimation in Z

Definition at line 148 of file ExtrapolationValidation.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_extrapolator

ToolHandle<IExtrapolator> Trk::ExtrapolationValidation::m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"}

private

The Extrapolator to be retrieved.

Definition at line 80 of file ExtrapolationValidation.h.

81{this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"};

◆ m_flatDist

Rndm::Numbers* Trk::ExtrapolationValidation::m_flatDist = nullptr

private

Definition at line 85 of file ExtrapolationValidation.h.

◆ m_gaussDist

Rndm::Numbers* Trk::ExtrapolationValidation::m_gaussDist = nullptr

private

Random Number setup.

Definition at line 84 of file ExtrapolationValidation.h.

◆ m_highestVolume

const TrackingVolume* Trk::ExtrapolationValidation::m_highestVolume = nullptr

private

the highest volume

Definition at line 77 of file ExtrapolationValidation.h.

◆ m_materialCollectionValidation

BooleanProperty Trk::ExtrapolationValidation::m_materialCollectionValidation {this, "ValidateMaterialCollection", true}

private

Definition at line 87 of file ExtrapolationValidation.h.

88{this, "ValidateMaterialCollection", true};

◆ m_maxEta

DoubleProperty Trk::ExtrapolationValidation::m_maxEta {this, "StartPerigeeMaxEta", 3.}

private

Definition at line 116 of file ExtrapolationValidation.h.

116{this, "StartPerigeeMaxEta", 3.};

◆ m_maximumR

double Trk::ExtrapolationValidation::m_maximumR = 0.

private

maximum R of the highest

Definition at line 106 of file ExtrapolationValidation.h.

◆ m_maximumZ

double Trk::ExtrapolationValidation::m_maximumZ = 0.

private

maximum halfZ of the highest tracking volume

Definition at line 107 of file ExtrapolationValidation.h.

◆ m_maxP

DoubleProperty Trk::ExtrapolationValidation::m_maxP {this, "StartPerigeeMaxP", 100.*Gaudi::Units::GeV}

private

Definition at line 118 of file ExtrapolationValidation.h.

118{this, "StartPerigeeMaxP", 100.*Gaudi::Units::GeV};

◆ m_minEta

DoubleProperty Trk::ExtrapolationValidation::m_minEta {this, "StartPerigeeMinEta", -3.}

private

Definition at line 115 of file ExtrapolationValidation.h.

115{this, "StartPerigeeMinEta", -3.};

◆ m_minP

DoubleProperty Trk::ExtrapolationValidation::m_minP {this, "StartPerigeeMinP", 0.5*Gaudi::Units::GeV}

private

Definition at line 117 of file ExtrapolationValidation.h.

117{this, "StartPerigeeMinP", 0.5*Gaudi::Units::GeV};

◆ m_parameterEta

float Trk::ExtrapolationValidation::m_parameterEta[TRKEXALGS_MAXPARAMETERS] {}

private

start eta

Definition at line 128 of file ExtrapolationValidation.h.

128{};

◆ m_parameterLoc1

float Trk::ExtrapolationValidation::m_parameterLoc1[TRKEXALGS_MAXPARAMETERS] {}

private

start local 1

Definition at line 124 of file ExtrapolationValidation.h.

124{};

◆ m_parameterLoc2

float Trk::ExtrapolationValidation::m_parameterLoc2[TRKEXALGS_MAXPARAMETERS] {}

private

start local 2

Definition at line 125 of file ExtrapolationValidation.h.

125{};

◆ m_parameterPhi

float Trk::ExtrapolationValidation::m_parameterPhi[TRKEXALGS_MAXPARAMETERS] {}

private

start phi

Definition at line 126 of file ExtrapolationValidation.h.

126{};

◆ m_parameterQoverP

float Trk::ExtrapolationValidation::m_parameterQoverP[TRKEXALGS_MAXPARAMETERS] {}

private

start qOverP

Definition at line 129 of file ExtrapolationValidation.h.

129{};

◆ m_parameters

int Trk::ExtrapolationValidation::m_parameters = 0

private

maximum 3 : start - destination - backward

Definition at line 123 of file ExtrapolationValidation.h.

◆ m_parameterTheta

float Trk::ExtrapolationValidation::m_parameterTheta[TRKEXALGS_MAXPARAMETERS] {}

private

start theta

Definition at line 127 of file ExtrapolationValidation.h.

127{};

◆ m_particleType

IntegerProperty Trk::ExtrapolationValidation::m_particleType

private

Initial value:

{this, "ParticleType", 2,

"the particle type for the extrap."}

Definition at line 120 of file ExtrapolationValidation.h.

120 {this, "ParticleType", 2,

121 "the particle type for the extrap."};

◆ m_sigmaLoc

DoubleProperty Trk::ExtrapolationValidation::m_sigmaLoc

private

Initial value:

{this, "StartPerigeeSigmaLoc",

10.*Gaudi::Units::micrometer, "local sigma of start value"}

Definition at line 109 of file ExtrapolationValidation.h.

109 {this, "StartPerigeeSigmaLoc",

110 10.*Gaudi::Units::micrometer, "local sigma of start value"};

◆ m_sigmaR

DoubleProperty Trk::ExtrapolationValidation::m_sigmaR

private

Initial value:

{this, "StartPerigeeSigmaR",

17.*Gaudi::Units::micrometer, "r sigma of start value"}

Definition at line 111 of file ExtrapolationValidation.h.

111 {this, "StartPerigeeSigmaR",

112 17.*Gaudi::Units::micrometer, "r sigma of start value"};

◆ m_sigmaZ

DoubleProperty Trk::ExtrapolationValidation::m_sigmaZ

private

Initial value:

{this, "StartPerigeeSigmaZ",

50.*Gaudi::Units::millimeter, "Z sigma of start value"}

Definition at line 113 of file ExtrapolationValidation.h.

113 {this, "StartPerigeeSigmaZ",

114 50.*Gaudi::Units::millimeter, "Z sigma of start value"};

◆ m_startP

float Trk::ExtrapolationValidation::m_startP = 0.

private

startP

Definition at line 143 of file ExtrapolationValidation.h.

◆ m_startR

float Trk::ExtrapolationValidation::m_startR = 0.

private

startX

Definition at line 141 of file ExtrapolationValidation.h.

◆ m_startX

float Trk::ExtrapolationValidation::m_startX = 0.

private

startX

Definition at line 139 of file ExtrapolationValidation.h.

◆ m_startY

float Trk::ExtrapolationValidation::m_startY = 0.

private

startX

Definition at line 140 of file ExtrapolationValidation.h.

◆ m_startZ

float Trk::ExtrapolationValidation::m_startZ = 0.

private

startX

Definition at line 142 of file ExtrapolationValidation.h.

◆ m_triesBack

unsigned int Trk::ExtrapolationValidation::m_triesBack = 0

private

events back

Definition at line 158 of file ExtrapolationValidation.h.

◆ m_triesFront

unsigned int Trk::ExtrapolationValidation::m_triesFront = 0

private

events front

Definition at line 156 of file ExtrapolationValidation.h.

◆ m_validationTree

TTree* Trk::ExtrapolationValidation::m_validationTree = nullptr

private

Root Validation Tree.

Definition at line 93 of file ExtrapolationValidation.h.

◆ m_validationTreeDescription

StringProperty Trk::ExtrapolationValidation::m_validationTreeDescription

private

Initial value:

{this, "ValidationTreeDescription",
     "Output of the ExtrapolationValidation Algorithm",
     "validation tree description - second argument in TTree"}

Definition at line 98 of file ExtrapolationValidation.h.

    {this, "ValidationTreeDescription",
     "Output of the ExtrapolationValidation Algorithm",
     "validation tree description - second argument in TTree"};

◆ m_validationTreeFolder

StringProperty Trk::ExtrapolationValidation::m_validationTreeFolder

private

Initial value:

{this, "ValidationTreeFolder", "/val/ExtrapolationValidation",

"stream/folder to for the TTree to be written out"}

Definition at line 102 of file ExtrapolationValidation.h.

103 {this, "ValidationTreeFolder", "/val/ExtrapolationValidation",

104 "stream/folder to for the TTree to be written out"};

◆ m_validationTreeName

StringProperty Trk::ExtrapolationValidation::m_validationTreeName

private

Initial value:

{this, "ValidationTreeName", "ExtrapolationValidation",

"validation tree name - to be acessed by this from root"}

Definition at line 95 of file ExtrapolationValidation.h.

96 {this, "ValidationTreeName", "ExtrapolationValidation",

97 "validation tree name - to be acessed by this from root"};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ ExtrapolationValidation()

◆ ~ExtrapolationValidation()

Member Function Documentation

◆ createTransform()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_breaksBack

◆ m_breaksFront

◆ m_collectedLayerBack

◆ m_collectedLayerFront

◆ m_covarianceDeterminant

◆ m_covarianceLoc1

◆ m_covarianceLoc2

◆ m_covariancePhi

◆ m_covarianceQoverP

◆ m_covarianceTheta

◆ m_destinationR

◆ m_destinationSurfaceType

◆ m_destinationX

◆ m_destinationY

◆ m_destinationZ

◆ m_detStore

◆ m_direct

◆ m_estimationR

◆ m_estimationX

◆ m_estimationY

◆ m_estimationZ

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_extrapolator

◆ m_flatDist

◆ m_gaussDist

◆ m_highestVolume

◆ m_materialCollectionValidation

◆ m_maxEta

◆ m_maximumR

◆ m_maximumZ

◆ m_maxP

◆ m_minEta

◆ m_minP

◆ m_parameterEta

◆ m_parameterLoc1

◆ m_parameterLoc2

◆ m_parameterPhi

◆ m_parameterQoverP

◆ m_parameters

◆ m_parameterTheta

◆ m_particleType

◆ m_sigmaLoc

◆ m_sigmaR

◆ m_sigmaZ

◆ m_startP

◆ m_startR