#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
	the highest volume More...

ToolHandle< IExtrapolator >	m_extrapolator
	The Extrapolator to be retrieved. More...

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

Rndm::Numbers *	m_flatDist

bool	m_materialCollectionValidation
	run the material collection More...

bool	m_direct

TTree *	m_validationTree
	Root Validation Tree. More...

std::string	m_validationTreeName
	validation tree name - to be acessed by this from root More...

std::string	m_validationTreeDescription
	validation tree description - second argument in TTree More...

std::string	m_validationTreeFolder
	stream/folder to for the TTree to be written out More...

double	m_maximumR
	maximum R of the highest More...

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

double	m_sigmaLoc
	local sigma of start value More...

double	m_sigmaR
	r sigma of start value More...

double	m_sigmaZ
	Z sigma of start value. More...

double	m_minEta
	Minimal eta value. More...

double	m_maxEta
	Maximal eta value. More...

double	m_minP
	Minimal p value. More...

double	m_maxP
	Maximal p value. More...

int	m_particleType
	the particle typre for the extrap. More...

int	m_parameters
	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
	destination surface type More...

float	m_startX
	startX More...

float	m_startY
	startX More...

float	m_startR
	startX More...

float	m_startZ
	startX More...

float	m_startP
	startP More...

float	m_estimationX
	estimation in X More...

float	m_estimationY
	estimation in Y More...

float	m_estimationR
	estimation in R More...

float	m_estimationZ
	estimation in Z More...

float	m_destinationX
	destination in X More...

float	m_destinationY
	destination in Y More...

float	m_destinationR
	destination in R More...

float	m_destinationZ
	destination in Z More...

unsigned int	m_triesFront
	events front More...

unsigned int	m_breaksFront
	breaks front More...

unsigned int	m_triesBack
	events back More...

unsigned int	m_breaksBack
	breaks More...

unsigned int	m_collectedLayerFront
	collected material layers forward More...

unsigned int	m_collectedLayerBack
	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 55 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 29 of file ExtrapolationValidation.cxx.

   :
   AthAlgorithm(name,pSvcLocator),
   m_highestVolume(nullptr),
   m_extrapolator("Trk::Extrapolator/AtlasExtrapolator"),
   m_gaussDist(nullptr),
   m_flatDist(nullptr),
   m_materialCollectionValidation(true),
   m_direct(false),
   m_validationTree(nullptr),  
   m_validationTreeName("ExtrapolationValidation"),
   m_validationTreeDescription("Output of the ExtrapolationValidation Algorithm"),
   m_validationTreeFolder("/val/ExtrapolationValidation"),
   m_maximumR(0.),
   m_maximumZ(0.),
   m_sigmaLoc(10.*Gaudi::Units::micrometer),
   m_sigmaR(17.*Gaudi::Units::micrometer),                   
   m_sigmaZ(50.*Gaudi::Units::millimeter),
   m_minEta(-3.),                    
   m_maxEta(3.),                    
   m_minP(0.5*Gaudi::Units::GeV),                      
   m_maxP(100.*Gaudi::Units::GeV),
   m_particleType(2),
   m_parameters(0),
   m_parameterLoc1{},    
   m_parameterLoc2{},    
   m_parameterPhi{},     
   m_parameterTheta{},   
   m_parameterEta{},     
   m_parameterQoverP{},  
   m_covarianceLoc1{},    
   m_covarianceLoc2{},    
   m_covariancePhi{},     
   m_covarianceTheta{},   
   m_covarianceQoverP{},  
   m_covarianceDeterminant{},  
   m_destinationSurfaceType(0),
   m_startX{},      
   m_startY{},      
   m_startR{},      
   m_startZ{},      
   m_startP{},      
   m_estimationX(0.),
   m_estimationY(0.),
   m_estimationR(0.),
   m_estimationZ(0.),
   m_destinationX(0.),
   m_destinationY(0.),
   m_destinationR(0.),
   m_destinationZ(0.),
   m_triesFront(0),
   m_breaksFront(0),
   m_triesBack(0),
   m_breaksBack(0),
   m_collectedLayerFront(0),
   m_collectedLayerBack(0)  
 {
   // used algorithms and alg tools
   declareProperty("Extrapolator",                m_extrapolator);
   declareProperty("ValidateMaterialCollection",  m_materialCollectionValidation);
   declareProperty("ExtrapolateDirectly", m_direct);
   // TTree handling
   declareProperty("ValidationTreeName",          m_validationTreeName);
   declareProperty("ValidationTreeDescription",   m_validationTreeDescription);
   declareProperty("ValidationTreeFolder",        m_validationTreeFolder);
   // algorithm steering
   declareProperty("StartPerigeeSigmaLoc"      , m_sigmaLoc);
   declareProperty("StartPerigeeSigmaR"        , m_sigmaR);
   declareProperty("StartPerigeeSigmaZ"        , m_sigmaZ);
   declareProperty("StartPerigeeMinEta"        , m_minEta);
   declareProperty("StartPerigeeMaxEta"        , m_maxEta);
   declareProperty("StartPerigeeMinP"          , m_minP);
   declareProperty("StartPerigeeMaxP"          , m_maxP);
   declareProperty("ParticleType"              , m_particleType);
  
 }

◆ ~ExtrapolationValidation()

Trk::ExtrapolationValidation::~ExtrapolationValidation ( )

Default Destructor.

Definition at line 108 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 566 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 206 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] = fabs( m_parameterLoc1[m_parameters] * 0.1);                                          
    m_covarianceLoc2[m_parameters] =  fabs( m_parameterLoc2[m_parameters] * 0.1);                                        
    m_covariancePhi[m_parameters] =   fabs( m_parameterPhi[m_parameters] * 0.1);
    m_covarianceTheta[m_parameters] =  fabs(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] =  fabs(m_parameterQoverP[m_parameters] * 0.1);
  
    // for the momentum logging
    m_startP  = p;   
  
    // start
    m_startR          = fabs(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,
                                                     (Trk::ParticleHypothesis)m_particleType,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,
                                                                       (Trk::ParticleHypothesis)m_particleType);
  
       // 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
         std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIter    =  collectedMaterial->begin();
         std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIterEnd =  collectedMaterial->end();
         for ( ; tsosIter != tsosIterEnd; delete(*tsosIter), ++tsosIter);
      }
    }
  
    else{
      destParameters = m_extrapolator->extrapolateDirectly(ctx,
                                                           startParameters,
                                                           destinationSurface, 
                                                           Trk::alongMomentum,
                                                           false,
                                                           (Trk::ParticleHypothesis)m_particleType).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,
                                                          (Trk::ParticleHypothesis)m_particleType,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,
                                                                           (Trk::ParticleHypothesis)m_particleType);
             // 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
                 std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIter    =  collectedBackMaterial->begin();
                 std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIterEnd =  collectedBackMaterial->end();
                 for ( ; tsosIter != tsosIterEnd; delete(*tsosIter), ++tsosIter);
             }
        }
  
        else{
      backParameters = m_extrapolator->extrapolateDirectly(ctx,
                                                         *destParameters,
                                                         startSurface, 
                                                         Trk::oppositeMomentum,
                                                         false,
                                                         (Trk::ParticleHypothesis)m_particleType).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 184 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 : " << double(m_breaksFront)/double(m_triesFront) 
         << " (" << m_breaksFront << "/" << m_triesFront << ")");
     ATH_MSG_INFO("=  - breaks bwd : " << double(m_breaksBack)/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 118 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.c_str(), m_validationTreeDescription.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

private

breaks

Definition at line 144 of file ExtrapolationValidation.h.

◆ m_breaksFront

unsigned int Trk::ExtrapolationValidation::m_breaksFront

private

breaks front

Definition at line 142 of file ExtrapolationValidation.h.

◆ m_collectedLayerBack

unsigned int Trk::ExtrapolationValidation::m_collectedLayerBack

private

collected material layers backwards

Definition at line 147 of file ExtrapolationValidation.h.

◆ m_collectedLayerFront

unsigned int Trk::ExtrapolationValidation::m_collectedLayerFront

private

collected material layers forward

Definition at line 146 of file ExtrapolationValidation.h.

◆ m_covarianceDeterminant

float Trk::ExtrapolationValidation::m_covarianceDeterminant[TRKEXALGS_MAXPARAMETERS]

private

start qOverP

Definition at line 121 of file ExtrapolationValidation.h.

◆ m_covarianceLoc1

float Trk::ExtrapolationValidation::m_covarianceLoc1[TRKEXALGS_MAXPARAMETERS]

private

start local 1

Definition at line 116 of file ExtrapolationValidation.h.

◆ m_covarianceLoc2

float Trk::ExtrapolationValidation::m_covarianceLoc2[TRKEXALGS_MAXPARAMETERS]

private

start local 2

Definition at line 117 of file ExtrapolationValidation.h.

◆ m_covariancePhi

float Trk::ExtrapolationValidation::m_covariancePhi[TRKEXALGS_MAXPARAMETERS]

private

start phi

Definition at line 118 of file ExtrapolationValidation.h.

◆ m_covarianceQoverP

float Trk::ExtrapolationValidation::m_covarianceQoverP[TRKEXALGS_MAXPARAMETERS]

private

start qOverP

Definition at line 120 of file ExtrapolationValidation.h.

◆ m_covarianceTheta

float Trk::ExtrapolationValidation::m_covarianceTheta[TRKEXALGS_MAXPARAMETERS]

private

start theta

Definition at line 119 of file ExtrapolationValidation.h.

◆ m_destinationR

float Trk::ExtrapolationValidation::m_destinationR

private

destination in R

Definition at line 137 of file ExtrapolationValidation.h.

◆ m_destinationSurfaceType

int Trk::ExtrapolationValidation::m_destinationSurfaceType

private

destination surface type

Definition at line 123 of file ExtrapolationValidation.h.

◆ m_destinationX

float Trk::ExtrapolationValidation::m_destinationX

private

destination in X

Definition at line 135 of file ExtrapolationValidation.h.

◆ m_destinationY

float Trk::ExtrapolationValidation::m_destinationY

private

destination in Y

Definition at line 136 of file ExtrapolationValidation.h.

◆ m_destinationZ

float Trk::ExtrapolationValidation::m_destinationZ

private

destination in Z

Definition at line 138 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

bool Trk::ExtrapolationValidation::m_direct

private

Definition at line 87 of file ExtrapolationValidation.h.

◆ m_estimationR

float Trk::ExtrapolationValidation::m_estimationR

private

estimation in R

Definition at line 132 of file ExtrapolationValidation.h.

◆ m_estimationX

float Trk::ExtrapolationValidation::m_estimationX

private

estimation in X

Definition at line 130 of file ExtrapolationValidation.h.

◆ m_estimationY

float Trk::ExtrapolationValidation::m_estimationY

private

estimation in Y

Definition at line 131 of file ExtrapolationValidation.h.

◆ m_estimationZ

float Trk::ExtrapolationValidation::m_estimationZ

private

estimation in Z

Definition at line 133 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

private

The Extrapolator to be retrieved.

Definition at line 79 of file ExtrapolationValidation.h.

◆ m_flatDist

Rndm::Numbers* Trk::ExtrapolationValidation::m_flatDist

private

Definition at line 83 of file ExtrapolationValidation.h.

◆ m_gaussDist

Rndm::Numbers* Trk::ExtrapolationValidation::m_gaussDist

private

Random Number setup.

Definition at line 82 of file ExtrapolationValidation.h.

◆ m_highestVolume

const TrackingVolume* Trk::ExtrapolationValidation::m_highestVolume

private

the highest volume

Definition at line 76 of file ExtrapolationValidation.h.

◆ m_materialCollectionValidation

bool Trk::ExtrapolationValidation::m_materialCollectionValidation

private

run the material collection

Definition at line 85 of file ExtrapolationValidation.h.

◆ m_maxEta

double Trk::ExtrapolationValidation::m_maxEta

private

Maximal eta value.

Definition at line 102 of file ExtrapolationValidation.h.

◆ m_maximumR

double Trk::ExtrapolationValidation::m_maximumR

private

maximum R of the highest

Definition at line 95 of file ExtrapolationValidation.h.

◆ m_maximumZ

double Trk::ExtrapolationValidation::m_maximumZ

private

maximum halfZ of the highest tracking volume

Definition at line 96 of file ExtrapolationValidation.h.

◆ m_maxP

double Trk::ExtrapolationValidation::m_maxP

private

Maximal p value.

Definition at line 104 of file ExtrapolationValidation.h.

◆ m_minEta

double Trk::ExtrapolationValidation::m_minEta

private

Minimal eta value.

Definition at line 101 of file ExtrapolationValidation.h.

◆ m_minP

double Trk::ExtrapolationValidation::m_minP

private

Minimal p value.

Definition at line 103 of file ExtrapolationValidation.h.

◆ m_parameterEta

float Trk::ExtrapolationValidation::m_parameterEta[TRKEXALGS_MAXPARAMETERS]

private

start eta

Definition at line 113 of file ExtrapolationValidation.h.

◆ m_parameterLoc1

float Trk::ExtrapolationValidation::m_parameterLoc1[TRKEXALGS_MAXPARAMETERS]

private

start local 1

Definition at line 109 of file ExtrapolationValidation.h.

◆ m_parameterLoc2

float Trk::ExtrapolationValidation::m_parameterLoc2[TRKEXALGS_MAXPARAMETERS]

private

start local 2

Definition at line 110 of file ExtrapolationValidation.h.

◆ m_parameterPhi

float Trk::ExtrapolationValidation::m_parameterPhi[TRKEXALGS_MAXPARAMETERS]

private

start phi

Definition at line 111 of file ExtrapolationValidation.h.

◆ m_parameterQoverP

float Trk::ExtrapolationValidation::m_parameterQoverP[TRKEXALGS_MAXPARAMETERS]

private

start qOverP

Definition at line 114 of file ExtrapolationValidation.h.

◆ m_parameters

int Trk::ExtrapolationValidation::m_parameters

private

maximum 3 : start - destination - backward

Definition at line 108 of file ExtrapolationValidation.h.

◆ m_parameterTheta

float Trk::ExtrapolationValidation::m_parameterTheta[TRKEXALGS_MAXPARAMETERS]

private

start theta

Definition at line 112 of file ExtrapolationValidation.h.

◆ m_particleType

int Trk::ExtrapolationValidation::m_particleType

private

the particle typre for the extrap.

Definition at line 106 of file ExtrapolationValidation.h.

◆ m_sigmaLoc

double Trk::ExtrapolationValidation::m_sigmaLoc

private

local sigma of start value

Definition at line 98 of file ExtrapolationValidation.h.

◆ m_sigmaR

double Trk::ExtrapolationValidation::m_sigmaR

private

r sigma of start value

Definition at line 99 of file ExtrapolationValidation.h.

◆ m_sigmaZ

double Trk::ExtrapolationValidation::m_sigmaZ

private

Z sigma of start value.

Definition at line 100 of file ExtrapolationValidation.h.

◆ m_startP

float Trk::ExtrapolationValidation::m_startP

private

startP

Definition at line 128 of file ExtrapolationValidation.h.

◆ m_startR

float Trk::ExtrapolationValidation::m_startR

private

startX

Definition at line 126 of file ExtrapolationValidation.h.

◆ m_startX

float Trk::ExtrapolationValidation::m_startX

private

startX

Definition at line 124 of file ExtrapolationValidation.h.

◆ m_startY

float Trk::ExtrapolationValidation::m_startY

private

startX

Definition at line 125 of file ExtrapolationValidation.h.

◆ m_startZ

float Trk::ExtrapolationValidation::m_startZ

private

startX

Definition at line 127 of file ExtrapolationValidation.h.

◆ m_triesBack

unsigned int Trk::ExtrapolationValidation::m_triesBack

private

events back

Definition at line 143 of file ExtrapolationValidation.h.

◆ m_triesFront

unsigned int Trk::ExtrapolationValidation::m_triesFront

private

events front

Definition at line 141 of file ExtrapolationValidation.h.

◆ m_validationTree

TTree* Trk::ExtrapolationValidation::m_validationTree

private

Root Validation Tree.

Definition at line 89 of file ExtrapolationValidation.h.

◆ m_validationTreeDescription

std::string Trk::ExtrapolationValidation::m_validationTreeDescription

private

validation tree description - second argument in TTree

Definition at line 92 of file ExtrapolationValidation.h.

◆ m_validationTreeFolder

std::string Trk::ExtrapolationValidation::m_validationTreeFolder

private

stream/folder to for the TTree to be written out

Definition at line 93 of file ExtrapolationValidation.h.

◆ m_validationTreeName

std::string Trk::ExtrapolationValidation::m_validationTreeName

private

validation tree name - to be acessed by this from root

Definition at line 91 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