#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. More...

	~ExtrapolationValidation ()
	Default Destructor. More...

StatusCode	initialize ()
	standard Athena-Algorithm method More...

StatusCode	execute ()
	standard Athena-Algorithm method More...

StatusCode	finalize ()
	standard Athena-Algorithm method More...

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

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 More...

Private Attributes
const TrackingVolume *	m_highestVolume = nullptr
	the highest volume More...

ToolHandle< IExtrapolator >	m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"}
	The Extrapolator to be retrieved. More...

Rndm::Numbers *	m_gaussDist = nullptr
	Random Number setup. More...

Rndm::Numbers *	m_flatDist = nullptr

BooleanProperty	m_materialCollectionValidation {this, "ValidateMaterialCollection", true}

BooleanProperty	m_direct

TTree *	m_validationTree = nullptr
	Root Validation Tree. More...

StringProperty	m_validationTreeName

StringProperty	m_validationTreeDescription

StringProperty	m_validationTreeFolder

double	m_maximumR = 0.
	maximum R of the highest More...

double	m_maximumZ = 0.
	maximum halfZ of the highest tracking volume More...

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 More...

float	m_parameterLoc1 [TRKEXALGS_MAXPARAMETERS] {}
	start local 1 More...

float	m_parameterLoc2 [TRKEXALGS_MAXPARAMETERS] {}
	start local 2 More...

float	m_parameterPhi [TRKEXALGS_MAXPARAMETERS] {}
	start phi More...

float	m_parameterTheta [TRKEXALGS_MAXPARAMETERS] {}
	start theta More...

float	m_parameterEta [TRKEXALGS_MAXPARAMETERS] {}
	start eta More...

float	m_parameterQoverP [TRKEXALGS_MAXPARAMETERS] {}
	start qOverP More...

float	m_covarianceLoc1 [TRKEXALGS_MAXPARAMETERS] {}
	start local 1 More...

float	m_covarianceLoc2 [TRKEXALGS_MAXPARAMETERS] {}
	start local 2 More...

float	m_covariancePhi [TRKEXALGS_MAXPARAMETERS] {}
	start phi More...

float	m_covarianceTheta [TRKEXALGS_MAXPARAMETERS] {}
	start theta More...

float	m_covarianceQoverP [TRKEXALGS_MAXPARAMETERS] {}
	start qOverP More...

float	m_covarianceDeterminant [TRKEXALGS_MAXPARAMETERS] {}
	start qOverP More...

int	m_destinationSurfaceType = 0
	destination surface type More...

float	m_startX = 0.
	startX More...

float	m_startY = 0.
	startX More...

float	m_startR = 0.
	startX More...

float	m_startZ = 0.
	startX More...

float	m_startP = 0.
	startP More...

float	m_estimationX = 0.
	estimation in X More...

float	m_estimationY = 0.
	estimation in Y More...

float	m_estimationR = 0.
	estimation in R More...

float	m_estimationZ = 0.
	estimation in Z More...

float	m_destinationX = 0.
	destination in X More...

float	m_destinationY = 0.
	destination in Y More...

float	m_destinationR = 0.
	destination in R More...

float	m_destinationZ = 0.
	destination in Z More...

unsigned int	m_triesFront = 0
	events front More...

unsigned int	m_breaksFront = 0
	breaks front More...

unsigned int	m_triesBack = 0
	events back More...

unsigned int	m_breaksBack = 0
	breaks More...

unsigned int	m_collectedLayerFront = 0
	collected material layers forward More...

unsigned int	m_collectedLayerBack = 0
	collected material layers backwards More...

DataObjIDColl	m_extendedExtraObjects

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

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) {}

◆ ~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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > & 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; }

◆ evtStore() [1/2]

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; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ 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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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, PyAthena::Alg, and AthHistogramAlgorithm.

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.

◆ m_covarianceLoc1

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

private

start local 1

Definition at line 131 of file ExtrapolationValidation.h.

◆ m_covarianceLoc2

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

private

start local 2

Definition at line 132 of file ExtrapolationValidation.h.

◆ m_covariancePhi

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

private

start phi

Definition at line 133 of file ExtrapolationValidation.h.

◆ m_covarianceQoverP

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

private

start qOverP

Definition at line 135 of file ExtrapolationValidation.h.

◆ m_covarianceTheta

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

private

start theta

Definition at line 134 of file ExtrapolationValidation.h.

◆ 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.

◆ 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.

◆ 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.

◆ m_maxEta

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

private

Definition at line 116 of file ExtrapolationValidation.h.

◆ 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.

◆ m_minEta

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

private

Definition at line 115 of file ExtrapolationValidation.h.

◆ m_minP

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

private

Definition at line 117 of file ExtrapolationValidation.h.

◆ m_parameterEta

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

private

start eta

Definition at line 128 of file ExtrapolationValidation.h.

◆ m_parameterLoc1

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

private

start local 1

Definition at line 124 of file ExtrapolationValidation.h.

◆ m_parameterLoc2

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

private

start local 2

Definition at line 125 of file ExtrapolationValidation.h.

◆ m_parameterPhi

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

private

start phi

Definition at line 126 of file ExtrapolationValidation.h.

◆ m_parameterQoverP

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

private

start qOverP

Definition at line 129 of file ExtrapolationValidation.h.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ 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