InDet::SiTrajectoryElement_xk Class Reference

#include <SiTrajectoryElement_xk.h>

Public Member Functions
	SiTrajectoryElement_xk ()
	SiTrajectoryElement_xk (const SiTrajectoryElement_xk &)
	~SiTrajectoryElement_xk ()=default
SiTrajectoryElement_xk &	operator= (const SiTrajectoryElement_xk &)
const int &	detstatus () const
const int &	inside () const
const int &	ndist () const
	number of crossed without hit - dead + holes
const int &	nlinksF () const
const int &	nlinksB () const
const int &	nholesF () const
const int &	nholesB () const
const int &	dholesF () const
const int &	dholesB () const
const int &	nclustersF () const
const int &	nclustersB () const
const int &	npixelsB () const
const bool &	stereo () const
const int &	status () const
const int &	noiseModel () const
const int &	ndf () const
const int &	ndfF () const
const int &	ndfB () const
const int &	ntsos () const
const double &	step () const
const double &	dist () const
bool	isBarrel () const
const InDetDD::SiDetectorElement *	detElement () const
const InDet::SiCluster *	cluster () const
const InDet::SiCluster *	clusterOld () const
const InDet::SiCluster *	clusterNoAdd () const
Trk::TrackStateOnSurface *	tsos (int i)
bool	isNextClusterHoleB (bool &, double &)
bool	isNextClusterHoleF (bool &, double &)
	checks if removing this cluster from the forward propagation would result in a critical number of holes or double holes.
Methods update with cluster information
bool	addCluster (Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, double &)
bool	addCluster (Trk::PatternTrackParameters &, Trk::PatternTrackParameters &)
bool	addClusterPrecise (Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, double &)
bool	addClusterPreciseWithCorrection (Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, double &)
bool	combineStates (Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, Trk::PatternTrackParameters &)
Methods noise calculation
void	noiseProduction (int, const Trk::PatternTrackParameters &, double rad_length=-1., bool useMomentum=false)
void	noiseInitiate ()
bool	addNextClusterB ()
bool	addNextClusterF ()
bool	addNextClusterB (SiTrajectoryElement_xk &, const InDet::SiCluster *)
bool	addNextClusterF (SiTrajectoryElement_xk &, const InDet::SiCluster *)
void	setCluster (const InDet::SiCluster *)
void	setClusterB (const InDet::SiCluster *, double)
void	setParametersB (Trk::PatternTrackParameters &)
void	setParametersF (Trk::PatternTrackParameters &)
void	setNdist (int)
int	numberClusters () const
const double &	xi2F () const
const double &	xi2B () const
const double &	xi2totalF () const
const double &	xi2totalB () const
const double &	radlength () const
const double &	energylose () const
const Trk::PatternTrackParameters &	parametersPF () const
	track parameters for forward filter / smoother predicted
const Trk::PatternTrackParameters &	parametersUF () const
	updated
const Trk::PatternTrackParameters &	parametersPB () const
	predicted
const Trk::PatternTrackParameters &	parametersUB () const
	observed
const Trk::PatternTrackParameters &	parametersSM () const
const Trk::PatternTrackParameters *	parameters () const
	return pattern parameters matching the status of this element
const Trk::Surface *	surface () const
const InDet::SiClusterLink_xk &	linkF (int i) const
const InDet::SiClusterLink_xk &	linkB (int i) const
Main methods
template<typename T>
bool	set (int st, const InDet::SiDetElementBoundaryLink_xk *&dl, const T &sb, const T &se, const InDet::SiCluster *si, const EventContext &ctx)
	T = InDet::SiClusterCollection::const_iterator or InDet::PixelClusterCollection::const_iterator or InDet::SCT_ClusterCollection::const_iterator.
bool	setDead (const Trk::Surface *)
void	setDeadRadLength (Trk::PatternTrackParameters &)
void	setTools (const InDet::SiTools_xk *)
void	setParameters ()
void	bremNoiseModel ()
Update first trajectory element on the trajectory with
track parameters
bool	firstTrajectorElement (const Trk::TrackParameters &, const EventContext &ctx)
bool	firstTrajectorElement (bool correction)
bool	ForwardPropagationWithoutSearch (SiTrajectoryElement_xk &, const EventContext &)
bool	ForwardPropagationWithoutSearchPreciseWithCorrection (SiTrajectoryElement_xk &, const EventContext &)
bool	ForwardPropagationWithSearch (SiTrajectoryElement_xk &, const EventContext &)
template<typename T>
bool	ForwardPropagationForClusterSeach (int n, const Trk::TrackParameters &Tpa, const InDet::SiDetElementBoundaryLink_xk *&dl, const T &sb, const T &se, const EventContext &ctx)
	T = InDet::SiClusterCollection::const_iterator or InDet::PixelClusterCollection::const_iterator or InDet::SCT_ClusterCollection::const_iterator.
template<typename T>
void	CloseClusterSeach (Trk::PatternTrackParameters &Tpa, const InDet::SiDetElementBoundaryLink_xk *&dl, const T &sb, const T &se)
	T = InDet::SiClusterCollection::const_iterator or InDet::PixelClusterCollection::const_iterator or InDet::SCT_ClusterCollection::const_iterator.
void	eraseClusterForwardPropagation ()
For last detector element initiate smoother
bool	lastTrajectorElement ()
bool	lastTrajectorElementPrecise ()
Backward propagation for smoother
bool	BackwardPropagationSmoother (SiTrajectoryElement_xk &, bool, const EventContext &ctx)
bool	BackwardPropagationPrecise (SiTrajectoryElement_xk &, const EventContext &ctx)
bool	BackwardPropagationFilter (SiTrajectoryElement_xk &, const EventContext &ctx)
Search clusters compatible with track
int	searchClusters (Trk::PatternTrackParameters &, SiClusterLink_xk *)
template<typename T>
int	searchClustersSub (Trk::PatternTrackParameters &, SiClusterLink_xk *)
template<typename T>
int	searchClustersWithoutStereoPIX (Trk::PatternTrackParameters &, SiClusterLink_xk *)
template<typename T>
int	searchClustersWithoutStereoSCT (Trk::PatternTrackParameters &, SiClusterLink_xk *)
template<typename T>
int	searchClustersWithStereo (Trk::PatternTrackParameters &, SiClusterLink_xk *)
Search only clusters without track assosiation compatible with track
template<typename T>
int	searchClustersWithoutStereoAssPIX (Trk::PatternTrackParameters &, SiClusterLink_xk *, const Trk::PRDtoTrackMap &)
template<typename T>
int	searchClustersWithoutStereoAssSCT (Trk::PatternTrackParameters &, SiClusterLink_xk *, const Trk::PRDtoTrackMap &)
template<typename T>
int	searchClustersWithStereoAss (Trk::PatternTrackParameters &, SiClusterLink_xk *, const Trk::PRDtoTrackMap &)
bool	difference () const
	check for a difference between forward and back propagation
Trk::TrackStateOnSurface *	trackStateOnSurface (bool, bool, bool, int)
Trk::TrackStateOnSurface *	trackSimpleStateOnSurface (bool, bool, int)
Trk::TrackStateOnSurface *	trackPerigeeStateOnSurface (const EventContext &ctx)
Step of trajectory calculation
double	step (SiTrajectoryElement_xk &)
double	stepToPerigee ()
Global position of the track parameters
Amg::Vector3D	globalPosition ()
Quality of the trajectory element
double	quality (int &) const
Propagate parameters with covariance
bool	propagate (Trk::PatternTrackParameters &startingParameters, Trk::PatternTrackParameters &outParameters, double &step, const EventContext &ctx)
	Will propagate the startingParameters from their reference to the surface associated with this element and write the result into the second argument.
Propagate parameters without covariance update.
Will propagate the startingParameters from their reference to the surface associated with this element and write the result into the second argument. The third argument records the step length traversed.
bool	propagateParameters (Trk::PatternTrackParameters &startingParameters, Trk::PatternTrackParameters &outParameters, double &step)
	Start from 'startingParameters', propagate to current surface.

Work methods for propagation
enum	IteratorType { SiClusterColl = 0 , PixelClusterColl = 1 , SCT_ClusterColl = 2 , Invalid = 3 }
	Private Data. More...
bool	m_stereo {}
bool	m_utsos [3] {}
bool	m_fieldMode {}
bool	m_useassoTool = false
int	m_status {}
	status flag.
int	m_detstatus {}
	0 (no clusters)
int	m_inside {}
int	m_nMissing {}
int	m_nlinksForward {}
int	m_nlinksBackward {}
int	m_nholesForward {}
int	m_nholesBackward {}
int	m_dholesForward {}
int	m_dholesBackward {}
int	m_nclustersForward {}
int	m_nclustersBackward {}
int	m_npixelsBackward {}
int	m_noisemodel {}
int	m_ndf {}
int	m_ndfForward {}
int	m_ndfBackward {}
int	m_ntsos {}
int	m_maxholes {}
int	m_maxdholes {}
double	m_dist {}
double	m_xi2Forward {}
double	m_xi2Backward {}
double	m_xi2totalForward {}
double	m_xi2totalBackward {}
double	m_radlength {}
double	m_radlengthN {}
double	m_energylose {}
double	m_halflength {}
double	m_step {}
double	m_xi2max {}
double	m_xi2maxNoAdd {}
double	m_xi2maxlink {}
double	m_xi2multi {}
double	m_localTransform [13] {}
double	m_localDir [3] {}
	the transform for this element
double	m_invMoment {}
const InDetDD::SiDetectorElement *	m_detelement {}
const InDet::SiDetElementBoundaryLink_xk *	m_detlink {}
const Trk::Surface *	m_surface {}
bool	transformPlaneToGlobal (bool, Trk::PatternTrackParameters &localParameters, double *globalPars)
	Tramsform from plane to global Will take the surface and parameters from localParameters and populate globalPars with the result.
bool	transformGlobalToPlane (bool updateJacobian, double *globalPars, Trk::PatternTrackParameters &startingParameters, Trk::PatternTrackParameters &outputParameters)
	Tramsform from global to plane surface Will take the global parameters in globalPars, the surface from this trajectory element and populate outputParameters with the result.
bool	rungeKuttaToPlane (bool updateJacobian, double *globalPars)
	Runge Kutta step to plane Updates the "globalPars" array, which is also used to pass the input.
bool	straightLineStepToPlane (bool updateJacobian, double *globalPars)
	Straight line step to plane Updates the "globalPars" array, which is also used to pass the input.

Data members using std::any
std::any is used to cover InDet::PixelClusterCollection::const_iterator InDet::SCT_ClusterCollection::const_iterator InDet::SiClusterCollection::const_iterator used in SiTrajectoryElement_xk.cxx.
std::any	m_sibegin
std::any	m_siend
const InDet::SiCluster *	m_cluster {}
const InDet::SiCluster *	m_clusterOld {}
const InDet::SiCluster *	m_clusterNoAdd {}
Trk::PatternTrackParameters	m_parametersPredForward
	Pattern track parameters.
Trk::PatternTrackParameters	m_parametersUpdatedForward
	Updated state, forward.
Trk::PatternTrackParameters	m_parametersPredBackward
	For backward filtering / smoothing Predicted state, backward.
Trk::PatternTrackParameters	m_parametersUpdatedBackward
	Updated state, backward.
Trk::PatternTrackParameters	m_parametersSM
InDet::SiClusterLink_xk	m_linkForward [10]
InDet::SiClusterLink_xk	m_linkBackward [10]
Trk::NoiseOnSurface	m_noise
const InDet::SiTools_xk *	m_tools {}
MagField::AtlasFieldCache	m_fieldCache
const Trk::IPatternParametersUpdator *	m_updatorTool {}
const Trk::IPatternParametersPropagator *	m_proptool {}
const Trk::IRIO_OnTrackCreator *	m_riotool {}
const Trk::PRDtoTrackMap *	m_prdToTrackMap {}
Trk::TrackStateOnSurface *	m_tsos [3] {}
Amg::MatrixX	m_covariance
Amg::Vector2D	m_position
IteratorType	m_itType {Invalid}
static constexpr double	s_oneOverTwelve {0.08333}
void	patternCovariances (const InDet::SiCluster *, double &, double &, double &) const
	Private Methods.
void	checkBoundaries (const Trk::PatternTrackParameters &pars)

TrackParameters production
std::unique_ptr< Trk::TrackParameters >	trackParameters (bool, int)
std::unique_ptr< Trk::TrackParameters >	trackParametersWithNewDirection (bool, int)
bool	initiateState (Trk::PatternTrackParameters &inputPars, Trk::PatternTrackParameters &outputPars)
	inputPars: input parameters.
bool	initiateStatePrecise (Trk::PatternTrackParameters &, Trk::PatternTrackParameters &)
bool	initiateStateWithCorrection (Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, Trk::PatternTrackParameters &)
void	precisePosCov (Trk::PatternTrackParameters &)
void	lastActive ()
static std::unique_ptr< Trk::TrackParameters >	trackParameters (Trk::PatternTrackParameters &, bool)

Detailed Description

Definition at line 35 of file SiTrajectoryElement_xk.h.

Member Enumeration Documentation

IteratorType

enum InDet::SiTrajectoryElement_xk::IteratorType

private

Private Data.

Enumerator
SiClusterColl
PixelClusterColl
SCT_ClusterColl
Invalid

Definition at line 427 of file SiTrajectoryElement_xk.h.

                        {
        SiClusterColl = 0,
        PixelClusterColl = 1,
        SCT_ClusterColl = 2,
        Invalid = 3
      };

Constructor & Destructor Documentation

SiTrajectoryElement_xk() [1/2]

InDet::SiTrajectoryElement_xk::SiTrajectoryElement_xk

(

)

Definition at line 1915 of file SiTrajectoryElement_xk.cxx.

{
  m_detstatus         =-1  ;
  m_status            = 0  ;
  m_nlinksForward     = 0  ;
  m_nlinksBackward    = 0  ;
  m_nMissing          = 0  ;
  m_radlength         = .03;
  m_radlengthN        = .03;
  m_energylose        = .4 ;
  m_tools             = nullptr  ;
  m_noisemodel        = 0  ;
  m_covariance.resize(2,2);
  m_covariance<<0.,0.,0.,0.;
  m_ndf               = 0 ;
  m_ndfBackward       = 0 ;
  m_ndfForward        = 0 ;
  m_ntsos             = 0 ;
  m_maxholes          = 0 ;
  m_maxdholes         = 0 ;
  m_xi2Forward        = 0.;
  m_xi2Backward       = 0.;
  m_xi2totalForward   = 0.;
  m_xi2totalBackward  = 0.;
  m_halflength        = 0.;
  m_step              = 0.;
  m_xi2max            = 0.;
  m_dist              = 0.;
  m_xi2maxNoAdd       = 0.;
  m_xi2maxlink        = 0.;
  m_xi2multi          = 0.;
  m_invMoment         = 0.;
  m_detelement        = nullptr ;
  m_detlink           = nullptr ;
  m_surface           = nullptr ;
  m_cluster           = nullptr ;
  m_clusterOld        = nullptr ;
  m_clusterNoAdd      = nullptr ;
  m_updatorTool       = nullptr ;
  m_proptool          = nullptr ;
  m_riotool           = nullptr ;
  m_inside            = 0 ;
  m_nholesForward     = 0 ;
  m_nholesBackward    = 0 ;
  m_dholesForward     = 0 ;
  m_dholesBackward    = 0 ;
  m_nclustersForward  = 0 ;
  m_nclustersBackward = 0 ;
  m_npixelsBackward   = 0 ;
  m_stereo      = false   ;
  m_fieldMode   = false   ;
 
  m_tsos[0]=m_tsos[1]=m_tsos[2]=nullptr;
}

SiTrajectoryElement_xk() [2/2]

InDet::SiTrajectoryElement_xk::SiTrajectoryElement_xk

(

const SiTrajectoryElement_xk &

E

)

Definition at line 1970 of file SiTrajectoryElement_xk.cxx.

{
  *this          = E;
}

~SiTrajectoryElement_xk()

InDet::SiTrajectoryElement_xk::~SiTrajectoryElement_xk ( )

default

Member Function Documentation

addCluster() [1/2]

bool InDet::SiTrajectoryElement_xk::addCluster	(	Trk::PatternTrackParameters &	Ta,
		Trk::PatternTrackParameters &	Tb )

Definition at line 2188 of file SiTrajectoryElement_xk.cxx.

{
  if(!m_stereo) {
 
    patternCovariances
      (m_cluster,m_covariance(0,0),m_covariance(1,0),m_covariance(1,1));
    if(m_detelement->isSCT()) {
      return m_updatorTool->addToStateOneDimension
        (Ta,m_cluster->localPosition(),m_covariance,Tb);
    }
    return m_updatorTool->addToState
      (Ta,m_cluster->localPosition(),m_covariance,Tb);
  }
  return m_updatorTool->addToStateOneDimension
    (Ta,m_cluster->localPosition(),m_cluster->localCovariance(),Tb);
}

addCluster() [2/2]

bool InDet::SiTrajectoryElement_xk::addCluster	(	Trk::PatternTrackParameters &	Ta,
		Trk::PatternTrackParameters &	Tb,
		double &	Xi2 )

non-stereo measurements

set m_covariance to the cluster errors

update state

for stereo, use the cluster local covariance directly

Definition at line 2162 of file SiTrajectoryElement_xk.cxx.

{
  int N;
  if(!m_stereo) {
    patternCovariances
      (m_cluster,m_covariance(0,0),m_covariance(1,0),m_covariance(1,1));
    if(m_detelement->isSCT()) {
      return m_updatorTool->addToStateOneDimension
        (Ta,m_cluster->localPosition(),m_covariance,Tb,Xi2,N);
    }
    return m_updatorTool->addToState
      (Ta,m_cluster->localPosition(),m_covariance,Tb,Xi2,N);
  }
  return m_updatorTool->addToStateOneDimension
    (Ta,m_cluster->localPosition(),m_cluster->localCovariance(),Tb,Xi2,N);
}

addClusterPrecise()

bool InDet::SiTrajectoryElement_xk::addClusterPrecise	(	Trk::PatternTrackParameters &	Ta,
		Trk::PatternTrackParameters &	Tb,
		double &	Xi2 )

Definition at line 2211 of file SiTrajectoryElement_xk.cxx.

                                        {
  int N;
  if(m_ndf==1) {
    return m_updatorTool->addToStateOneDimension(Ta,m_position,m_covariance,Tb,Xi2,N);
  }
  else {
    return m_updatorTool->addToState           (Ta,m_position,m_covariance,Tb,Xi2,N);
  }
}

addClusterPreciseWithCorrection()

bool InDet::SiTrajectoryElement_xk::addClusterPreciseWithCorrection	(	Trk::PatternTrackParameters &	Tc,
		Trk::PatternTrackParameters &	Ta,
		Trk::PatternTrackParameters &	Tb,
		double &	Xi2 )

Definition at line 2356 of file SiTrajectoryElement_xk.cxx.

{
  int N;
  precisePosCov(Tc);
 
  if(m_ndf==1) {
    return m_updatorTool->addToStateOneDimension(Ta,m_position,m_covariance,Tb,Xi2,N);
  }
  else         {
    return m_updatorTool->addToState(Ta,m_position,m_covariance,Tb,Xi2,N);
  }
}

addNextClusterB() [1/2]

bool InDet::SiTrajectoryElement_xk::addNextClusterB

(

)

Definition at line 753 of file SiTrajectoryElement_xk.cxx.

{
  if(m_nlinksBackward <= 0) return false;
 
  if(m_cluster) m_xi2totalBackward-=m_xi2Backward;
 
  if(m_nlinksBackward > 1 && m_linkBackward[1].xi2() <= m_xi2max) {
 
    int n = 0;
    for(; n!=m_nlinksBackward-1; ++n) m_linkBackward[n]=m_linkBackward[n+1];
    m_nlinksBackward=n;
 
    m_cluster   = m_linkBackward[0].cluster();
    m_xi2Backward      = m_linkBackward[0].xi2()    ;
    m_xi2totalBackward+= m_xi2Backward              ;
    if(!addCluster(m_parametersPredBackward,m_parametersUpdatedBackward)) return false;
  }
  else {
    m_nlinksBackward = 0;
    m_cluster = nullptr; --m_nclustersBackward; m_ndfBackward-=m_ndf; if(m_ndf==2) --m_npixelsBackward;
    if(m_inside < 0 ) {++m_nholesBackward; ++m_dholesBackward;} m_xi2Backward = 0.;
    if(m_dist   < -2.) ++m_nMissing;
  }
  return true;
}

addNextClusterB() [2/2]

bool InDet::SiTrajectoryElement_xk::addNextClusterB	(	InDet::SiTrajectoryElement_xk &	TE,
		const InDet::SiCluster *	Cl )

Definition at line 813 of file SiTrajectoryElement_xk.cxx.

{
 
  m_clusterOld = m_cluster      ;
  m_cluster    = Cl             ;
  m_nclustersBackward = TE.m_nclustersBackward;
  m_npixelsBackward   = TE.m_npixelsBackward  ;
  m_ndfBackward       = TE.m_ndfBackward      ;
  m_nholesBackward    = TE.m_nholesBackward   ;
  m_nMissing      = TE.m_nMissing     ;
  m_xi2totalBackward  = TE.m_xi2totalBackward ;
 
  TE.m_cluster ? m_dholesBackward = 0 : m_dholesBackward = TE.m_dholesBackward;
 
  if(Cl) {
 
    if(!addCluster(m_parametersPredBackward,m_parametersUpdatedBackward,m_xi2Backward)) return false;
    m_inside    = -1;
    noiseProduction(-1,m_parametersUpdatedBackward);
    ++m_nclustersBackward; m_xi2totalBackward+=m_xi2Backward; m_ndfBackward+=m_ndf; if(m_ndf==2) ++m_npixelsBackward;
  }
  else  {
 
    if(m_inside < 0) {++m_nholesBackward; ++m_dholesBackward;} m_xi2Backward = 0.;
    if(m_dist < -2.) ++m_nMissing;
  }
  return true;
}

addNextClusterF() [1/2]

bool InDet::SiTrajectoryElement_xk::addNextClusterF

(

)

Definition at line 783 of file SiTrajectoryElement_xk.cxx.

{
  if(m_nlinksForward <= 0) return false;
 
  if(m_cluster) m_xi2totalForward-=m_xi2Forward;
 
  if(m_nlinksForward > 1 && m_linkForward[1].xi2() <= m_xi2max) {
 
    int n = 0;
    for(; n!=m_nlinksForward-1; ++n) m_linkForward[n]=m_linkForward[n+1];
    m_nlinksForward=n;
 
    m_cluster   = m_linkForward[0].cluster();
    m_xi2Forward      = m_linkForward[0].xi2()    ;
    m_xi2totalForward+= m_xi2Forward              ;
    if(!addCluster(m_parametersPredForward,m_parametersUpdatedForward)) return false;
  }
  else            {
    m_nlinksForward = 0;
    m_cluster = nullptr; --m_nclustersForward; m_ndfForward-=m_ndf;
    if(m_inside < 0) {++m_nholesForward; ++m_dholesForward;} m_xi2Forward = 0.;
    if(m_dist   < -2.) ++m_nMissing;
  }
  return true;
}

addNextClusterF() [2/2]

bool InDet::SiTrajectoryElement_xk::addNextClusterF	(	InDet::SiTrajectoryElement_xk &	TE,
		const InDet::SiCluster *	Cl )

write the current cluster (if any) into the old cluster slot

and set the current cluster to the one assigned

can be null!

copy running counts from the previous element

if the previous element has a hit, reset incremental hole counter

otherwise start from the running count

if we have a non-null cluster to add

add it to the track, and update our parameters using it

update m_inside to signify we are on the module

update noise to current parameters

update hit counts, chi2, ndf

no hit (nullptr cluster)

if we are within boundaries, add to hole counts

no chi2 contribution here

if crossed

Definition at line 847 of file SiTrajectoryElement_xk.cxx.

{
  m_clusterOld = m_cluster      ;
  m_cluster    = Cl             ;   
  m_nclustersForward = TE.m_nclustersForward;
  m_ndfForward       = TE.m_ndfForward      ;
  m_nholesForward    = TE.m_nholesForward   ;
  m_nMissing      = TE.m_nMissing     ;
  m_xi2totalForward  = TE.m_xi2totalForward ;
  if (TE.m_cluster){
    m_dholesForward = 0;
  }
  else{
    m_dholesForward = TE.m_dholesForward;
  }
  if(Cl) {
    if(!addCluster(m_parametersPredForward,m_parametersUpdatedForward,m_xi2Forward)) return false;
    m_inside    = -1;
    noiseProduction(1,m_parametersUpdatedForward);
    ++m_nclustersForward;
    m_xi2totalForward+=m_xi2Forward;
    m_ndfForward+=m_ndf;
  }
  else  {
    if(m_inside < 0) {
      ++m_nholesForward;
      ++m_dholesForward;
      }
      m_xi2Forward = 0.;
    if(m_dist < -2.) ++m_nMissing;
  }
  return true;
}

BackwardPropagationFilter()

bool InDet::SiTrajectoryElement_xk::BackwardPropagationFilter	(	InDet::SiTrajectoryElement_xk &	TE,
		const EventContext &	ctx )

Definition at line 531 of file SiTrajectoryElement_xk.cxx.

{
  // Track propagation
  //
  if(TE.m_noise.correctionIMom() < 1.) {
 
    if(TE.m_cluster) {
 
      TE.m_parametersUpdatedBackward.addNoise   (TE.m_noise,Trk::oppositeMomentum);
      if(!propagate(TE.m_parametersUpdatedBackward,m_parametersPredBackward,m_step,ctx)) return false;
      TE.m_parametersUpdatedBackward.removeNoise(TE.m_noise,Trk::oppositeMomentum);
      m_dholesBackward = 0;
    }
    else             {
 
      TE.m_parametersPredBackward.addNoise   (TE.m_noise,Trk::oppositeMomentum);
      if(!propagate(TE.m_parametersPredBackward,m_parametersPredBackward,m_step,ctx)) return false;
      TE.m_parametersPredBackward.removeNoise(TE.m_noise,Trk::oppositeMomentum);
      m_dholesBackward = TE.m_dholesBackward;
    }
  }
  else                                  {
 
    if(TE.m_cluster) {
 
      if(!propagate(TE.m_parametersUpdatedBackward,m_parametersPredBackward,m_step,ctx)) return false;
      m_dholesBackward = 0;
    }
    else             {
 
      if(!propagate(TE.m_parametersPredBackward,m_parametersPredBackward,m_step,ctx)) return false;
      m_dholesBackward = TE.m_dholesBackward;
    }
  }
  m_status              = 2;
  m_nlinksBackward      = 0;
  m_clusterOld          = m_cluster;
  m_cluster             = nullptr;
  m_clusterNoAdd        = nullptr;
  m_xi2Backward         = 10000.;
  m_nholesBackward      = TE.m_nholesBackward;
  m_nMissing            = TE.m_nMissing;
  m_nclustersBackward   = TE.m_nclustersBackward;
  m_npixelsBackward     = TE.m_npixelsBackward;
  m_ndfBackward         = TE.m_ndfBackward;
  m_xi2totalBackward    = TE.m_xi2totalBackward;
  m_step               += TE.m_step;
 
  if(m_tools->isITkGeometry() && !m_detelement) {
    setDeadRadLength(m_parametersPredBackward);
    noiseProduction(-1,m_parametersPredBackward);
    return true;
  }
  checkBoundaries(m_parametersPredBackward);
 
  if(m_inside >0 ) {noiseInitiate(); return true;}
 
  if((m_nlinksBackward = searchClusters(m_parametersPredBackward,m_linkBackward))) {
 
    m_xi2Backward =  m_linkBackward[0].xi2();
 
    if     (m_xi2Backward <= m_xi2max     ) {
 
      m_cluster = m_linkBackward[0].cluster();
      if(!addCluster(m_parametersPredBackward,m_parametersUpdatedBackward)) return false;
      noiseProduction(-1,m_parametersUpdatedBackward);
      ++m_nclustersBackward; m_xi2totalBackward+=m_xi2Backward; m_ndfBackward+=m_ndf; if(m_ndf==2) ++m_npixelsBackward;
    }
    else if(m_xi2Backward <= m_xi2maxNoAdd) {
 
      m_clusterNoAdd =  m_linkBackward[0].cluster();
      noiseProduction(-1,m_parametersPredBackward);
    }
  }
  else {
    noiseProduction(-1,m_parametersPredBackward);
  }
 
  if(m_detstatus >=0 && !m_cluster){
    if(m_inside < 0 && !m_clusterNoAdd) {++m_nholesBackward; ++m_dholesBackward;}
    if(m_dist < -2.) ++m_nMissing;
  }
  return true;
}

BackwardPropagationPrecise()

bool InDet::SiTrajectoryElement_xk::BackwardPropagationPrecise	(	InDet::SiTrajectoryElement_xk &	TE,
		const EventContext &	ctx )

Definition at line 719 of file SiTrajectoryElement_xk.cxx.

{
 
  // Track propagation
  //
  double step;
  if(TE.m_cluster) {
 
    if(!propagate(TE.m_parametersUpdatedBackward,m_parametersPredBackward,step,ctx)) return false;
  }
  else             {
 
    if(!propagate(TE.m_parametersPredBackward,m_parametersPredBackward,step,ctx)) return false;
  }
 
  m_parametersPredBackward.addNoise(m_noise,Trk::oppositeMomentum);
 
  // Forward-backward predict parameters
  //
  if(m_cluster) {
    m_status = 3 ;
     if(!addClusterPrecise(m_parametersPredBackward,m_parametersUpdatedBackward,m_xi2Backward)) return false;
  }
  else          {
    m_status = 2 ;
  }
  return true;
}

BackwardPropagationSmoother()

bool InDet::SiTrajectoryElement_xk::BackwardPropagationSmoother	(	InDet::SiTrajectoryElement_xk &	TE,
		bool	isTwoSpacePointsSeed,
		const EventContext &	ctx )

Definition at line 621 of file SiTrajectoryElement_xk.cxx.

{
 
  // Track propagation
  //
  double step;
  if(TE.m_cluster) {
    if(!propagate(TE.m_parametersUpdatedBackward,m_parametersPredBackward,step,ctx)) return false;
    m_dholesBackward = 0;
  }
  else             {
    if(!propagate(TE.m_parametersPredBackward,m_parametersPredBackward,step,ctx)) return false;
    m_dholesBackward = TE.m_dholesBackward;
  }
 
  m_parametersPredBackward.addNoise(m_noise,Trk::oppositeMomentum);
  m_nholesBackward      = TE.m_nholesBackward;
  m_nMissing            = TE.m_nMissing;
  m_nclustersBackward   = TE.m_nclustersBackward;
  m_npixelsBackward     = TE.m_npixelsBackward;
  m_ndfBackward         = TE.m_ndfBackward;
  m_xi2totalBackward    = TE.m_xi2totalBackward;
 
  // remove case if you have trajectory element without actual detector element
  // this happens if you have added a dead cylinder
  if(!m_detelement) {
    m_status = 2;
    return true;
  }
 
  // Forward-backward predict parameters
  //
  if(!combineStates(m_parametersPredBackward,m_parametersPredForward,m_parametersSM)) return false;
 
  m_cluster ? m_status = 3 : m_status = 2;
 
  double Xi2max = m_xi2max; if( isTwoSpacePointsSeed) Xi2max*=2.;
  checkBoundaries(m_parametersSM);
  m_nlinksBackward      = 0;
  m_clusterOld          = m_cluster;
  m_cluster             = nullptr;
  m_clusterNoAdd        = nullptr;
  m_xi2Backward         = 10000.;
 
  //m_step        += TE.m_step               ;
  if(m_inside> 0 ) return true;
 
 
  // For not first cluster on trajectory
  //
  if(!m_clusterOld || m_ndfForward != m_ndf || m_ndfForward+m_ndfBackward >6) {
 
    if((m_nlinksBackward = searchClusters(m_parametersSM,m_linkBackward))) {
 
      m_xi2Backward = m_linkBackward[0].xi2();
 
 
      if     (m_xi2Backward <= Xi2max) {
 
    m_cluster = m_linkBackward[0].cluster();
 
    if(!addCluster(m_parametersPredBackward,m_parametersUpdatedBackward)) return false;
    ++m_nclustersBackward; m_xi2totalBackward+=m_xi2Backward; m_ndfBackward+=m_ndf; if(m_ndf==2) ++m_npixelsBackward;
      }
      else if(m_xi2Backward <= m_xi2maxNoAdd) {
 
    m_clusterNoAdd = m_linkBackward[0].cluster();
      }
    }
    if(m_detstatus >=0 && !m_cluster) {
      if(m_inside < 0 && !m_clusterNoAdd) {++m_nholesBackward; ++m_dholesBackward;}
      if(m_dist < -2.) ++m_nMissing;
    }
    return true;
  }
 
  // For first cluster of short trajectory
  //
  m_cluster =  m_clusterOld;
  if(!addCluster(m_parametersPredBackward,m_parametersUpdatedBackward,m_xi2Backward)) return false;
 
  if     (m_xi2Backward <= Xi2max       ) {++m_nclustersBackward; m_xi2totalBackward+=m_xi2Backward; m_ndfBackward+=m_ndf; if(m_ndf==2) ++m_npixelsBackward;}
  else if(m_xi2Backward <= m_xi2maxNoAdd) {m_cluster      = nullptr; m_clusterNoAdd = m_clusterOld; }
  else                                      {m_cluster      = nullptr;                       }
 
  if(!m_cluster) {
    if(m_inside < 0 && !m_clusterNoAdd) {++m_nholesBackward; ++m_dholesBackward;}
    if(m_dist < -2.) ++m_nMissing;
 
  }
  return true;
}

bremNoiseModel()

void InDet::SiTrajectoryElement_xk::bremNoiseModel

(

)

Definition at line 2334 of file SiTrajectoryElement_xk.cxx.

{
  m_noisemodel = 2;
}

checkBoundaries()

void InDet::SiTrajectoryElement_xk::checkBoundaries ( const Trk::PatternTrackParameters & pars )

private

Definition at line 2405 of file SiTrajectoryElement_xk.cxx.

                                                                                       {
 
    m_inside = m_detlink->intersect(pars, m_dist);
 
}

CloseClusterSeach()

template<typename T>

void InDet::SiTrajectoryElement_xk::CloseClusterSeach	(	Trk::PatternTrackParameters &	Tpa,
		const InDet::SiDetElementBoundaryLink_xk *&	dl,
		const T &	sb,
		const T &	se )

T = InDet::SiClusterCollection::const_iterator or InDet::PixelClusterCollection::const_iterator or InDet::SCT_ClusterCollection::const_iterator.

cluster()

const InDet::SiCluster * InDet::SiTrajectoryElement_xk::cluster ( ) const

inline

Definition at line 73 of file SiTrajectoryElement_xk.h.

{return m_cluster   ;  }  

clusterNoAdd()

const InDet::SiCluster * InDet::SiTrajectoryElement_xk::clusterNoAdd ( ) const

inline

Definition at line 75 of file SiTrajectoryElement_xk.h.

{return m_clusterNoAdd;} 

clusterOld()

const InDet::SiCluster * InDet::SiTrajectoryElement_xk::clusterOld ( ) const

inline

Definition at line 74 of file SiTrajectoryElement_xk.h.

{return m_clusterOld;  }  

combineStates()

bool InDet::SiTrajectoryElement_xk::combineStates	(	Trk::PatternTrackParameters &	Ta,
		Trk::PatternTrackParameters &	Tb,
		Trk::PatternTrackParameters &	Tc )

Definition at line 2227 of file SiTrajectoryElement_xk.cxx.

{
  return m_updatorTool->combineStates(Ta,Tb,Tc);
}

detElement()

const InDetDD::SiDetectorElement * InDet::SiTrajectoryElement_xk::detElement ( ) const

inline

Definition at line 72 of file SiTrajectoryElement_xk.h.

{return m_detelement;  }  

detstatus()

const int & InDet::SiTrajectoryElement_xk::detstatus ( ) const

inline

Definition at line 48 of file SiTrajectoryElement_xk.h.

{return m_detstatus;}

dholesB()

const int & InDet::SiTrajectoryElement_xk::dholesB ( ) const

inline

Definition at line 57 of file SiTrajectoryElement_xk.h.

{return m_dholesBackward;   }

dholesF()

const int & InDet::SiTrajectoryElement_xk::dholesF ( ) const

inline

Definition at line 56 of file SiTrajectoryElement_xk.h.

{return m_dholesForward;   }

difference()

bool InDet::SiTrajectoryElement_xk::difference

(

)

const

check for a difference between forward and back propagation

Definition at line 2073 of file SiTrajectoryElement_xk.cxx.

{
  return m_cluster != m_clusterOld || m_status != 3;
}

dist()

const double & InDet::SiTrajectoryElement_xk::dist ( ) const

inline

Definition at line 69 of file SiTrajectoryElement_xk.h.

{return m_dist;      }

energylose()

const double & InDet::SiTrajectoryElement_xk::energylose ( ) const

inline

Definition at line 126 of file SiTrajectoryElement_xk.h.

{return m_energylose;}

eraseClusterForwardPropagation()

void InDet::SiTrajectoryElement_xk::eraseClusterForwardPropagation

(

)

Definition at line 1336 of file SiTrajectoryElement_xk.cxx.

{
  m_cluster=nullptr;
  --m_nclustersForward;
  m_xi2totalForward-=m_xi2Forward;
  m_ndfForward-=m_ndf;
}

firstTrajectorElement() [1/2]

bool InDet::SiTrajectoryElement_xk::firstTrajectorElement

(

bool

correction

)

reset the cov (off-diagonal to zero, diagonal multiplied by 100)

Definition at line 179 of file SiTrajectoryElement_xk.cxx.

{
 
  if(!m_cluster || !m_status) return false;
  if(m_status > 1 ) m_parametersPredForward = m_parametersUpdatedBackward;
 
  if(correction){
    m_parametersPredForward.diagonalization(10.);
    if(!initiateStateWithCorrection(m_parametersPredBackward,m_parametersPredForward,m_parametersUpdatedForward)) return false;
  }
  else{
    m_parametersPredForward.diagonalization(100.);
    if(!initiateState(m_parametersPredForward,m_parametersUpdatedForward)) return false;
  }
 
  m_invMoment = std::abs(m_parametersUpdatedBackward.parameters()[4]);
  noiseProduction(1,m_parametersUpdatedForward);
 
  m_dist               = -10. ;
  m_xi2Forward         =  0.  ;
  m_xi2totalForward    =  0.  ;
  m_status             =  1   ;
  m_inside             = -1   ;
  m_nMissing           =  0   ;
  m_nlinksForward      =  0   ;
  m_nholesForward      =  0   ;
  m_dholesForward      =  0   ;
  m_clusterNoAdd       =  nullptr   ;
  m_nclustersForward   =  1   ;
  m_ndfForward         = m_ndf;
  return true;
}

firstTrajectorElement() [2/2]

bool InDet::SiTrajectoryElement_xk::firstTrajectorElement	(	const Trk::TrackParameters &	startingParameters,
		const EventContext &	ctx )

if we don't have a cluster, something went wrong!

generate pattern track parameters from the starting parameters

get the surface belonging to our staring pars

Track propagation if needed if we are already on the correct surface, we can assign the params as they ar

otherwise, we need to propagate to "our" surface

write our covariance into the parameters

and initiate our state. parametersUF will be constrained to the local cluster coordinates (with its covariance), while taking the momentum and direction from the input parameters

add noise to the parameter estimate (scattering, eloss)

and init other values

Definition at line 113 of file SiTrajectoryElement_xk.cxx.

{
  if(!m_cluster) return false;

  Trk::PatternTrackParameters startingPatternPars;
  if(!startingPatternPars.production(&startingParameters)) return false;

  const Trk::Surface* pl = &startingPatternPars.associatedSurface();

  if(m_surface==pl) m_parametersPredForward = startingPatternPars;
  else  if(!propagate(startingPatternPars,m_parametersPredForward,m_step,ctx)) return false;
 
  // Initiate track parameters without initial covariance
  //
  double cv[15]={
      1. ,
          0. , 1.,
          0. , 0.,.001,
          0. , 0.,  0.,.001,
          0. , 0.,  0.,  0.,.00001};
 
  if (m_tools->isITkGeometry()) {
    cv[5] = m_ndf==2 ? .1 : .01;
    cv[9] = cv[5];
  }

  m_parametersPredForward.setCovariance(cv);
  initiateState(m_parametersPredForward,m_parametersUpdatedForward);

  if(!m_tools->isITkGeometry()) noiseProduction(1,m_parametersUpdatedForward);
  else noiseProduction(1,m_parametersUpdatedForward,1.);

  m_dist               = -10. ;
  m_step               =  0.  ;
  m_xi2Forward         =  0.  ;
  m_xi2totalForward    =  0.  ;
  m_status             =  1   ;
  m_inside             = -1   ;
  m_nMissing           =  0   ;
  m_nlinksForward      =  0   ;
  m_nholesForward      =  0   ;
  m_dholesForward      =  0   ;
  m_clusterNoAdd       =  nullptr   ;
  m_nclustersForward   =  1   ;
  m_ndfForward         = m_ndf;
  return true;
}

ForwardPropagationForClusterSeach()

template<typename T>

bool InDet::SiTrajectoryElement_xk::ForwardPropagationForClusterSeach	(	int	n,
		const Trk::TrackParameters &	Tpa,
		const InDet::SiDetElementBoundaryLink_xk *&	dl,
		const T &	sb,
		const T &	se,
		const EventContext &	ctx )

T = InDet::SiClusterCollection::const_iterator or InDet::PixelClusterCollection::const_iterator or InDet::SCT_ClusterCollection::const_iterator.

ForwardPropagationWithoutSearch()

bool InDet::SiTrajectoryElement_xk::ForwardPropagationWithoutSearch	(	InDet::SiTrajectoryElement_xk &	TE,
		const EventContext &	ctx )

Track propagation If the starting trajectory element has a cluster:

add noise to the track parameters of the starting TE

propagate to the current element, plug into m_parametersPredForward

and restore the starting TE again

reset the double hole count to zero - we had a cluster

add noise to the starting pars

propagate, plug into m_parametersPredForward

restore starting TE

double hole count is copied from the previous one

copy information from starting TE

Track update If we have a cluster on this element

add it to refine the parameter estimate

set m_inside to signify this is a hit on track

increment cluster count

increment chi² and degrees of freedom

if we have no cluster on this element

check the intersection of the propagated track with this surface

if we have hits on this element

and expect to be inside the active area

then increment the hole counters

for bond gaps, increment ndist

Noise production If the track passes through our element

if we have a cluster, update noise based on the updated parameters

otherwise, update noise based on the predicted parameters

otherwise, reset noise

Definition at line 279 of file SiTrajectoryElement_xk.cxx.

{
  if(TE.m_cluster) {
    TE.m_parametersUpdatedForward.addNoise   (TE.m_noise,Trk::alongMomentum);
    if(!propagate(TE.m_parametersUpdatedForward,m_parametersPredForward,m_step, ctx)) return false;
    TE.m_parametersUpdatedForward.removeNoise(TE.m_noise,Trk::alongMomentum);
    m_dholesForward = 0;
  }
  else             {
    TE.m_parametersPredForward.addNoise   (TE.m_noise,Trk::alongMomentum);
    if(!propagate(TE.m_parametersPredForward,m_parametersPredForward,m_step, ctx)) return false;
    TE.m_parametersPredForward.removeNoise(TE.m_noise,Trk::alongMomentum);
    m_dholesForward = TE.m_dholesForward;
  }

  m_nclustersForward = TE.m_nclustersForward;
  m_nholesForward    = TE.m_nholesForward   ;
  m_nMissing      = TE.m_nMissing     ;
  m_ndfForward       = TE.m_ndfForward      ;
  m_xi2totalForward  = TE.m_xi2totalForward ;
  m_step      += TE.m_step      ;

  if(!m_tools->isITkGeometry() || m_detelement){
    if( m_cluster) {
      if(!addCluster(m_parametersPredForward,m_parametersUpdatedForward,m_xi2Forward)) return false;
      m_inside  = -1;
      ++m_nclustersForward;
      m_xi2totalForward+=m_xi2Forward;
      m_ndfForward+=m_ndf;
    }
    else           {
      checkBoundaries(m_parametersPredForward);
      if( m_detstatus >=0) {
    if(m_inside <  0 ) {
      ++m_nholesForward;
      ++m_dholesForward;
    }
    if(m_dist   < -2.) ++m_nMissing;
      }
    }
  } else setDeadRadLength(m_parametersPredForward);
 

  if(m_inside<=0) {
    if(m_cluster) noiseProduction(1,m_parametersUpdatedForward);
    else          noiseProduction(1,m_parametersPredForward);
  }
  else            {
    noiseInitiate();
  }
  m_status       = 1;
  m_nlinksForward      = 0;
  m_clusterNoAdd = nullptr;
  return true;
}

ForwardPropagationWithoutSearchPreciseWithCorrection()

bool InDet::SiTrajectoryElement_xk::ForwardPropagationWithoutSearchPreciseWithCorrection	(	InDet::SiTrajectoryElement_xk &	TE,
		const EventContext &	ctx )

Definition at line 369 of file SiTrajectoryElement_xk.cxx.

{
  Trk::PatternTrackParameters P;
 
  if(TE.m_cluster) {
    P = TE.m_parametersUpdatedForward;
    m_dholesForward = 0;
  }
  else             {
    P = TE.m_parametersPredForward;
    m_dholesForward = TE.m_dholesForward;
  }
  m_invMoment = TE.m_invMoment;
 
  // Track propagation
  //
  P.addNoise(TE.m_noise,Trk::alongMomentum);
  if(!propagate(P,m_parametersPredForward,m_step,ctx)) return false;
 
  m_nclustersForward = TE.m_nclustersForward;
  m_nholesForward    = TE.m_nholesForward   ;
  m_nMissing         = TE.m_nMissing        ;
  m_ndfForward       = TE.m_ndfForward      ;
  m_xi2totalForward  = TE.m_xi2totalForward ;
  m_step      += TE.m_step      ;
  m_inside     = -1             ;
 
  // Track update
  //
  if(!m_tools->isITkGeometry() || m_detelement){
    if( m_cluster) {
      if(!addClusterPreciseWithCorrection(m_parametersPredForward,m_parametersPredForward,m_parametersUpdatedForward,m_xi2Forward)) return false;
      ++m_nclustersForward; m_xi2totalForward+=m_xi2Forward; m_ndfForward+=m_ndf;
    }
    else           {
      if( m_detstatus >=0) {
        ++m_nholesForward; ++m_dholesForward; ++m_nMissing;
      }
    }
  }
  else setDeadRadLength(m_parametersPredForward);
 
  // Noise production
  //
  m_radlength = .04;
  noiseProduction(1,m_parametersUpdatedBackward,-1, true);
  m_status       = 1;
  m_nlinksForward = 0;
  m_clusterNoAdd = nullptr;
  return true;
}

ForwardPropagationWithSearch()

bool InDet::SiTrajectoryElement_xk::ForwardPropagationWithSearch	(	InDet::SiTrajectoryElement_xk &	TE,
		const EventContext &	ctx )

Track propagation as usual, if the previous element has a cluster, propagate the updated parameters. otherwise the predicted ones.

double hole running counter is reset if the prev element has a cluster

reset old fwd propagation info

note the socially distant semicolons!

current cluster --> old cluster, reset current

copy running counts from previous element

re-evaluate if we are expected to intersect this element based on the updated prediction

if we are not passing through this element, reset noise production and return

now perform cluster search.

if we found any:

set chi2 to the one for the first candidate

if the chi2 is acceptable:

use first cluster as cluster on this element

try to add it to the trajectory, update our parameters

update noise based on this cluster

increment running cluster count for forward trajectory

increment total chi2 for forward trajectory

and the degrees of freedom as well

if we have an outlier:

update outlier cluster member

and reset noise

end of branch for found clusters

reset noise if nothing was found

if we are in an active module (with nonzero clusters) and didn't find anything:

if we expect a hit, and didn't see an outlier: increment hole counts

if we are well within bounds, increment nDist (may be bond-gap case)

end of case covering no found cluster

Definition at line 427 of file SiTrajectoryElement_xk.cxx.

{
  if(TE.m_cluster) {
 
    TE.m_parametersUpdatedForward.addNoise   (TE.m_noise,Trk::alongMomentum);
    if(!propagate(TE.m_parametersUpdatedForward,m_parametersPredForward,m_step,ctx)) return false;
    TE.m_parametersUpdatedForward.removeNoise(TE.m_noise,Trk::alongMomentum);
    m_dholesForward = 0;
  }
  else             {
 
    TE.m_parametersPredForward.addNoise   (TE.m_noise,Trk::alongMomentum);
    if(!propagate(TE.m_parametersPredForward,m_parametersPredForward,m_step,ctx)) return false;
    TE.m_parametersPredForward.removeNoise(TE.m_noise,Trk::alongMomentum);
    m_dholesForward = TE.m_dholesForward;
  }

  m_status             =         1                           ;  
  m_nlinksForward      =         0                           ;
  m_clusterOld   = m_cluster                                 ;
  m_cluster      =         nullptr                           ;
  m_clusterNoAdd =         nullptr                           ;
  m_xi2Forward         =    10000.                           ;

  m_nholesForward      = TE.m_nholesForward                        ;
  m_nMissing           = TE.m_nMissing                             ;
  m_nclustersForward   = TE.m_nclustersForward                     ;
  m_ndfForward         = TE.m_ndfForward                           ;
  m_xi2totalForward    = TE.m_xi2totalForward                      ;
  m_step              += TE.m_step                                 ;
 
  if(m_tools->isITkGeometry() && !m_detelement) {
    setDeadRadLength(m_parametersPredForward);
    noiseProduction(1,m_parametersPredForward);
    return true;
  }

  checkBoundaries(m_parametersPredForward);

  if(m_inside > 0) {
    noiseInitiate(); return true;
  }

  m_nlinksForward=searchClusters(m_parametersPredForward,m_linkForward);
  if(m_nlinksForward!=0) {
    m_xi2Forward =  m_linkForward[0].xi2();

    if     (m_xi2Forward <= m_xi2max    ) {
      m_cluster = m_linkForward[0].cluster();
      if(!addCluster(m_parametersPredForward,m_parametersUpdatedForward)) return false;
      noiseProduction(1,m_parametersUpdatedForward);
      ++m_nclustersForward;
      m_xi2totalForward+=m_xi2Forward;
      m_ndfForward+=m_ndf;
    }
    else if(m_xi2Forward <= m_xi2maxNoAdd) {
      m_clusterNoAdd =  m_linkForward[0].cluster();
      noiseProduction(1,m_parametersPredForward);
    }
  } 
  else {
    noiseProduction(1,m_parametersPredForward);
  }
  if(m_detstatus >=0 && !m_cluster) {
    if(m_inside < 0 && !m_clusterNoAdd) {
      ++m_nholesForward;
      ++m_dholesForward;
    }
    if(m_dist < -2. ) ++m_nMissing;
  } 
  return true;
}

globalPosition()

Amg::Vector3D InDet::SiTrajectoryElement_xk::globalPosition

(

)

Definition at line 1282 of file SiTrajectoryElement_xk.cxx.

{
  if    (m_status == 1) {
    if(m_cluster)  return m_parametersUpdatedForward.position();
    else           return m_parametersPredForward.position();
  }
  else if(m_status == 2) {
    if(m_cluster)  return m_parametersUpdatedBackward.position();
    else           return m_parametersPredBackward.position();
  }
  else if(m_status == 3) {
 
    Amg::Vector3D gp(0.,0.,0.);
    bool QA; Trk::PatternTrackParameters S1,SM,S2(parametersPF());
 
    if(m_cluster) S1 = parametersUB();
    else          S1 = parametersPB();
 
    QA = m_updatorTool->combineStates(S1,S2,SM);
 
    if(QA) {
      gp = SM.position();
    }
    return gp;
  }
  Amg::Vector3D gp(0.,0.,0.);
  return gp;
}

initiateState()

bool InDet::SiTrajectoryElement_xk::initiateState	(	Trk::PatternTrackParameters &	inputPars,
		Trk::PatternTrackParameters &	outputPars )

inputPars: input parameters.

outputPars: output parameters. Gives outputPars the x and (for pix) the y of the associated cluster, and the corresponding cov elements, and copies all other elements else from inputPars

Gives Tb the x and (for pix) the y of the cluster, and the corresponding cov elements, and copies everything else from inputPars

Definition at line 2248 of file SiTrajectoryElement_xk.cxx.

{
  if (m_tools->isITkGeometry()) {
    // using pattern covariance for all clusters for ITk
    Amg::MatrixX cov(2,2);
    patternCovariances(m_cluster,cov(0,0),cov(1,0),cov(1,1));
    return outputPars.initiate(inputPars,m_cluster->localPosition(),cov);
  }
  return outputPars.initiate(inputPars,m_cluster->localPosition(),m_cluster->localCovariance());
}

initiateStatePrecise()

bool InDet::SiTrajectoryElement_xk::initiateStatePrecise	(	Trk::PatternTrackParameters &	inputPars,
		Trk::PatternTrackParameters &	outputPars )

Definition at line 2266 of file SiTrajectoryElement_xk.cxx.

{
  return outputPars.initiate(inputPars,m_position,m_covariance);
}

initiateStateWithCorrection()

bool InDet::SiTrajectoryElement_xk::initiateStateWithCorrection	(	Trk::PatternTrackParameters &	Tc,
		Trk::PatternTrackParameters &	Ta,
		Trk::PatternTrackParameters &	Tb )

Definition at line 2343 of file SiTrajectoryElement_xk.cxx.

{
  precisePosCov(Tc);
  return Tb.initiate(Ta,m_position,m_covariance);
}

inside()

const int & InDet::SiTrajectoryElement_xk::inside ( ) const

inline

Definition at line 49 of file SiTrajectoryElement_xk.h.

{return m_inside;    }

isBarrel()

bool InDet::SiTrajectoryElement_xk::isBarrel ( ) const

inline

Definition at line 70 of file SiTrajectoryElement_xk.h.

{return m_detelement->isBarrel();}

isNextClusterHoleB()

bool InDet::SiTrajectoryElement_xk::isNextClusterHoleB	(	bool &	cl,
		double &	X )

Definition at line 2082 of file SiTrajectoryElement_xk.cxx.

{
  cl = false             ;
  X  = m_xi2totalBackward-m_xi2Backward;
 
  if(m_nlinksBackward >  1 && m_linkBackward[1].xi2() <= m_xi2max) {
    X+=m_linkBackward[1].xi2();
    cl = true; return true;
  }
 
  if(m_inside < 0) {
    return m_nholesBackward < m_maxholes && m_dholesBackward < m_maxdholes;
  }
  return true;
}

isNextClusterHoleF()

bool InDet::SiTrajectoryElement_xk::isNextClusterHoleF	(	bool &	cl,
		double &	X )

checks if removing this cluster from the forward propagation would result in a critical number of holes or double holes.

Fills "cl" with true if we would still find another cluster after removing the preferred one. Fills X with the chi square we would have on removal. Return true if we would not get a problematic number of holes

chi2 if we drop this cluster

not used in SiTrajectory?

if we have another good cluster on this element which could replace the current one were it dropped:

add the chi2 of the second forward link to the second arg

set the return-arg signifying we would still see a cluster and return

if we expect a hit:

return true if we are below the max allowed holes (so we can add one)

otherwise return false

if we do not expect a hit return true

Definition at line 2103 of file SiTrajectoryElement_xk.cxx.

{
  cl = false             ;
  X  = m_xi2totalForward-m_xi2Forward;
  if(m_detstatus == 2) return false;
  if(m_nlinksForward >  1 && m_linkForward[1].xi2() <= m_xi2max) {
    X+=m_linkForward[1].xi2();
    cl = true;
    return true;
  }
  if(m_inside < 0) {
    if(m_nholesForward < m_maxholes && m_dholesForward < m_maxdholes) return true;
    return false;
  }
  return true;
}

lastActive()

void InDet::SiTrajectoryElement_xk::lastActive

(

)

Definition at line 2313 of file SiTrajectoryElement_xk.cxx.

{
  m_detstatus = 2;
}

lastTrajectorElement()

bool InDet::SiTrajectoryElement_xk::lastTrajectorElement

(

)

Definition at line 217 of file SiTrajectoryElement_xk.cxx.

{
  if(m_status==0 || !m_cluster) return false;
  noiseProduction(1,m_parametersUpdatedForward);
 
  m_parametersSM = m_parametersPredForward;
  m_parametersPredBackward = m_parametersUpdatedForward;
  m_parametersPredBackward.diagonalization(100.);
  if(!initiateState(m_parametersPredBackward,m_parametersUpdatedBackward)) return false;
 
  m_status              =      3 ;
  m_inside              =     -1 ;
  m_nMissing            =      0 ;
  m_nlinksBackward      =      0 ;
  m_nholesBackward      =      0 ;
  m_dholesBackward      =      0 ;
  m_clusterNoAdd        =      nullptr ;
  m_nclustersBackward   =      1 ;
  m_ndf == 2 ? m_npixelsBackward = 1 : m_npixelsBackward = 0;
  m_ndfBackward         =  m_ndf ;
  m_xi2Backward         =  m_xi2Forward;
  m_xi2totalBackward    =  m_xi2Forward;
  m_dist                =    -10.;
  return true;
}

lastTrajectorElementPrecise()

bool InDet::SiTrajectoryElement_xk::lastTrajectorElementPrecise

(

)

Definition at line 247 of file SiTrajectoryElement_xk.cxx.

{
  if(m_status==0 || !m_cluster) return false;
  m_radlength = .04;
  noiseProduction(1,m_parametersUpdatedForward);
 
  m_parametersSM = m_parametersPredForward;
  m_parametersPredBackward = m_parametersUpdatedForward;
  m_parametersPredBackward.diagonalization(10.);
  if(!initiateStatePrecise(m_parametersPredBackward,m_parametersUpdatedBackward)) return false;
  m_status             =  3;
  m_inside             = -1;
  m_nMissing           =  0;
  m_nlinksBackward     =  0;
  m_nholesBackward     =  0;
  m_dholesBackward     =  0;
  m_clusterNoAdd       =  nullptr;
  m_nclustersBackward  =  1;
  m_clusterNoAdd       =  nullptr;
  m_npixelsBackward = m_ndf==2 ? 1 : 0;
  m_ndfBackward        =  m_ndf ;
  m_xi2Backward        =  m_xi2Forward;
  m_xi2totalBackward   =  m_xi2Forward; // As in 21.9, should this be m_xi2totalForward instead?
  m_dist         =    -10.;
  return true;
}

linkB()

const InDet::SiClusterLink_xk & InDet::SiTrajectoryElement_xk::linkB ( int i ) const

inline

Definition at line 146 of file SiTrajectoryElement_xk.h.

{return m_linkBackward[i];}

linkF()

const InDet::SiClusterLink_xk & InDet::SiTrajectoryElement_xk::linkF ( int i ) const

inline

Definition at line 145 of file SiTrajectoryElement_xk.h.

{return m_linkForward[i];}

nclustersB()

const int & InDet::SiTrajectoryElement_xk::nclustersB ( ) const

inline

Definition at line 59 of file SiTrajectoryElement_xk.h.

{return m_nclustersBackward;}

nclustersF()

const int & InDet::SiTrajectoryElement_xk::nclustersF ( ) const

inline

Definition at line 58 of file SiTrajectoryElement_xk.h.

{return m_nclustersForward;}

ndf()

const int & InDet::SiTrajectoryElement_xk::ndf ( ) const

inline

Definition at line 64 of file SiTrajectoryElement_xk.h.

{return m_ndf;       }

ndfB()

const int & InDet::SiTrajectoryElement_xk::ndfB ( ) const

inline

Definition at line 66 of file SiTrajectoryElement_xk.h.

{return m_ndfBackward;      }

ndfF()

const int & InDet::SiTrajectoryElement_xk::ndfF ( ) const

inline

Definition at line 65 of file SiTrajectoryElement_xk.h.

{return m_ndfForward;      }

ndist()

const int & InDet::SiTrajectoryElement_xk::ndist ( ) const

inline

number of crossed without hit - dead + holes

Definition at line 51 of file SiTrajectoryElement_xk.h.

{return m_nMissing ;    }

nholesB()

const int & InDet::SiTrajectoryElement_xk::nholesB ( ) const

inline

Definition at line 55 of file SiTrajectoryElement_xk.h.

{return m_nholesBackward;   }

nholesF()

const int & InDet::SiTrajectoryElement_xk::nholesF ( ) const

inline

Definition at line 54 of file SiTrajectoryElement_xk.h.

{return m_nholesForward;   }

nlinksB()

const int & InDet::SiTrajectoryElement_xk::nlinksB ( ) const

inline

Definition at line 53 of file SiTrajectoryElement_xk.h.

{return m_nlinksBackward;   }

nlinksF()

const int & InDet::SiTrajectoryElement_xk::nlinksF ( ) const

inline

Definition at line 52 of file SiTrajectoryElement_xk.h.

{return m_nlinksForward;   }

noiseInitiate()

void InDet::SiTrajectoryElement_xk::noiseInitiate

(

)

Definition at line 2239 of file SiTrajectoryElement_xk.cxx.

{
  m_noisemodel = 1; m_noise.initiate();
}

noiseModel()

const int & InDet::SiTrajectoryElement_xk::noiseModel ( ) const

inline

Definition at line 63 of file SiTrajectoryElement_xk.h.

{return m_noisemodel;}

noiseProduction()

void InDet::SiTrajectoryElement_xk::noiseProduction	(	int	Dir,
		const Trk::PatternTrackParameters &	Tp,
		double	rad_length = -1.,
		bool	useMomentum = false )

qoverp

projection of direction normal to surface

number of radiation lengths when crossing this surface

134 is a very magic number related to multiple scattering, used frequently throught the track finder chain. Here we use it to estimate the scattering impact on the errors

1 - Az² --> squared transverse direction component

if too small, set to a reasonable minimum

azimuthal component: scale with 1/d

muon model

estimate e-loss

impact on covariance

impact on momentum

electron model - much more generous

for forward direction, invert correction

store in noise object

Definition at line 1120 of file SiTrajectoryElement_xk.cxx.

{
 
  int Model = m_noisemodel;
  if(Model < 1 || Model > 2) return;
  if (rad_length<0.) rad_length=m_radlength;
 
  double q = useMomentum ? m_invMoment : std::abs(Tp.parameters()[4]);   

  double s = std::abs(m_localDir[0]*m_localTransform[6]+
              m_localDir[1]*m_localTransform[7]+
              m_localDir[2]*m_localTransform[8]);
  if(m_tools->isITkGeometry() && !m_detelement) s = sqrt(m_localDir[0]*m_localDir[0]+m_localDir[1]*m_localDir[1]);
 
  if(m_tools->isITkGeometry()){
    if (s < .01) s = 100.;
    else s = 1./s;
  }
  else{
    if (s  < .05) s = 20.;
    else s = 1./s;
  }

  m_radlengthN = s*m_radlength;
  double covariancePola = (134.*m_radlengthN)*(q*q);
  if(m_tools->isITkGeometry()){
    double qc      = (1.+.038*log(m_radlengthN))*q;
    covariancePola = (185.*m_radlengthN)*qc*qc;
  }

  double d = (1.-m_localDir[2])*(1.+m_localDir[2]);
  if(d < 1.e-5) d = 1.e-5;
  double covarianceAzim = covariancePola/d;
 
  double covarianceIMom;
  double correctionIMom;

  if(Model==1) {
    double        dp = m_energylose*q*s;
    covarianceIMom = (.2*dp*dp)*(q*q);
    correctionIMom = 1.-dp;
  }
  else {
    correctionIMom = .70;
    covarianceIMom = (correctionIMom-1.)*(correctionIMom-1.)*(q*q);
  }
  if(Dir>0) correctionIMom = 1./correctionIMom;
  m_noise.set(covarianceAzim,covariancePola,covarianceIMom,correctionIMom);
}

npixelsB()

const int & InDet::SiTrajectoryElement_xk::npixelsB ( ) const

inline

Definition at line 60 of file SiTrajectoryElement_xk.h.

{return m_npixelsBackward;  }

ntsos()

const int & InDet::SiTrajectoryElement_xk::ntsos ( ) const

inline

Definition at line 67 of file SiTrajectoryElement_xk.h.

{return m_ntsos;     }

numberClusters()

int InDet::SiTrajectoryElement_xk::numberClusters

(

)

const

Definition at line 2037 of file SiTrajectoryElement_xk.cxx.

{
  int n = 0;
  if (m_detstatus<=0) return n;
 
  if (m_itType==PixelClusterColl) {
    const InDet::PixelClusterCollection::const_iterator* sibegin
      = std::any_cast<const InDet::PixelClusterCollection::const_iterator>(&m_sibegin);
    const InDet::PixelClusterCollection::const_iterator* siend
      = std::any_cast<const InDet::PixelClusterCollection::const_iterator>(&m_siend);
    if (sibegin==nullptr or siend==nullptr) return 0;
    for (InDet::PixelClusterCollection::const_iterator p = *sibegin; p!=*siend; ++p) {
      ++n;
    }
  } else if (m_itType==SCT_ClusterColl) {
    const InDet::SCT_ClusterCollection::const_iterator* sibegin
      = std::any_cast<const InDet::SCT_ClusterCollection::const_iterator>(&m_sibegin);
    const InDet::SCT_ClusterCollection::const_iterator* siend
      = std::any_cast<const InDet::SCT_ClusterCollection::const_iterator>(&m_siend);
    if (sibegin==nullptr or siend==nullptr) return 0;
    for (InDet::SCT_ClusterCollection::const_iterator p = *sibegin; p!=*siend; ++p) {
      ++n;
    }
  } else {
    const InDet::SiClusterCollection::const_iterator* sibegin
      = std::any_cast<const InDet::SiClusterCollection::const_iterator>(&m_sibegin);
    const InDet::SiClusterCollection::const_iterator* siend
      = std::any_cast<const InDet::SiClusterCollection::const_iterator>(&m_siend);
    if (sibegin==nullptr or siend==nullptr) return 0;
    for (InDet::SiClusterCollection::const_iterator p = *sibegin; p!=*siend; ++p) {
      ++n;
    }
  }
  return n;
}

operator=()

InDet::SiTrajectoryElement_xk & InDet::SiTrajectoryElement_xk::operator=

(

const SiTrajectoryElement_xk &

E

)

Definition at line 1977 of file SiTrajectoryElement_xk.cxx.

{
  if(&E==this) return(*this);
 
  m_fieldMode                 = E.m_fieldMode   ;
  m_status                    = E.m_status      ;
  m_detstatus                 = E.m_detstatus   ;
  m_inside                    = E.m_inside      ;
  m_nMissing                  = E.m_nMissing    ;
  m_stereo                    = E.m_stereo      ;
  m_detelement                = E.m_detelement  ;
  m_detlink                   = E.m_detlink     ;
  m_surface                   = E.m_surface     ;
  m_sibegin                   = E.m_sibegin     ;
  m_siend                     = E.m_siend       ;
  m_cluster                   = E.m_cluster     ;
  m_clusterOld                = E.m_clusterOld  ;
  m_clusterNoAdd              = E.m_clusterNoAdd;
  m_parametersPredForward     = E.m_parametersPredForward;
  m_parametersUpdatedForward  = E.m_parametersUpdatedForward;
  m_parametersPredBackward    = E.m_parametersPredBackward;
  m_parametersUpdatedBackward = E.m_parametersUpdatedBackward;
  m_parametersSM              = E.m_parametersSM;
  m_dist                      = E.m_dist            ;
  m_xi2Forward                = E.m_xi2Forward      ;
  m_xi2Backward               = E.m_xi2Backward     ;
  m_xi2totalForward           = E.m_xi2totalForward ;
  m_xi2totalBackward          = E.m_xi2totalBackward;
  m_radlength                 = E.m_radlength       ;
  m_radlengthN                = E.m_radlengthN      ;
  m_energylose                = E.m_energylose      ;
  m_halflength                = E.m_halflength      ;
  m_step                      = E.m_step            ;
  m_nlinksForward             = E.m_nlinksForward   ;
  m_nlinksBackward            = E.m_nlinksBackward  ;
  m_nholesForward             = E.m_nholesForward   ;
  m_nholesBackward            = E.m_nholesBackward  ;
  m_dholesForward             = E.m_dholesForward   ;
  m_dholesBackward            = E.m_dholesBackward  ;
  m_noisemodel                = E.m_noisemodel      ;
  m_ndf                       = E.m_ndf             ;
  m_ndfForward                = E.m_ndfForward      ;
  m_ndfBackward               = E.m_ndfBackward     ;
  m_ntsos                     = E.m_ntsos           ;
  m_nclustersForward          = E.m_nclustersForward   ;
  m_nclustersBackward         = E.m_nclustersBackward  ;
  m_npixelsBackward           = E.m_npixelsBackward    ;
  m_noise                     = E.m_noise       ;
  m_tools                     = E.m_tools       ;
  m_covariance                = E.m_covariance  ;
  m_position                  = E.m_position    ;
  m_invMoment                 = E.m_invMoment   ;
  for(int i=0; i!=m_nlinksForward; ++i) {m_linkForward[i]=E.m_linkForward[i];}
  for(int i=0; i!=m_nlinksBackward; ++i) {m_linkBackward[i]=E.m_linkBackward[i];}
  for(int i=0; i!=m_ntsos  ; ++i) {m_tsos [i]=E.m_tsos [i];}
  for(int i=0; i!=m_ntsos  ; ++i) {m_utsos[i]=E.m_utsos [i];}
  return(*this);
}

parameters()

const Trk::PatternTrackParameters * InDet::SiTrajectoryElement_xk::parameters

(

)

const

return pattern parameters matching the status of this element

Returns

nullptr or pointer to the internal pattern track parameters PF, UF, PB, UB, SM depending on m_status and m_cluster The returned pointer is owned by this element.

parametersPB()

const Trk::PatternTrackParameters & InDet::SiTrajectoryElement_xk::parametersPB ( ) const

inline

predicted

Definition at line 133 of file SiTrajectoryElement_xk.h.

{return m_parametersPredBackward;} 

parametersPF()

const Trk::PatternTrackParameters & InDet::SiTrajectoryElement_xk::parametersPF ( ) const

inline

track parameters for forward filter / smoother predicted

Definition at line 129 of file SiTrajectoryElement_xk.h.

{return m_parametersPredForward;} 

parametersSM()

const Trk::PatternTrackParameters & InDet::SiTrajectoryElement_xk::parametersSM ( ) const

inline

Definition at line 136 of file SiTrajectoryElement_xk.h.

{return m_parametersSM;} 

parametersUB()

const Trk::PatternTrackParameters & InDet::SiTrajectoryElement_xk::parametersUB ( ) const

inline

observed

Definition at line 135 of file SiTrajectoryElement_xk.h.

{return m_parametersUpdatedBackward;} 

parametersUF()

const Trk::PatternTrackParameters & InDet::SiTrajectoryElement_xk::parametersUF ( ) const

inline

updated

Definition at line 131 of file SiTrajectoryElement_xk.h.

{return m_parametersUpdatedForward;} 

patternCovariances()

void InDet::SiTrajectoryElement_xk::patternCovariances ( const InDet::SiCluster * c, double & covX, double & covXY, double & covY ) const

private

Private Methods.

sigma ~pitch / sqrt(12)

if larger error in cluster covariance, replace covx by it

strips: take y error from cov

pixels: again take either pitch/sqrt(12) or the cluster cov, whichever is larger

Definition at line 2276 of file SiTrajectoryElement_xk.cxx.

{
  const Amg::MatrixX& v = c->localCovariance();
  if (m_tools->useFastTracking() and m_stereo) {
    // in fast tracking mode, endcap strip clusters use cluster covariance terms
    covX=v(0,0);
    covY=v(1,1);
    covXY=v(1,0);
    return;
  }
  covX  = c->width().phiR();
  covX*=(covX*s_oneOverTwelve);  
  covXY = c->localCovariance()(1,0);
 
  if(!m_tools->useFastTracking()){
    if(covX < v(0,0)) covX=v(0,0);  
    covXY = 0.;
  }
 
  if(m_ndf==1) {    
    covY=v(1,1);
  }
  else         {
    covY=c->width().z();
    covY*=(covY*s_oneOverTwelve);
    if(!m_tools->useFastTracking()){
      if(covY < v(1,1)) covY=v(1,1);
    }
  }
}

precisePosCov()

void InDet::SiTrajectoryElement_xk::precisePosCov

(

Trk::PatternTrackParameters &

Tc

)

Definition at line 2376 of file SiTrajectoryElement_xk.cxx.

{
 
  m_position   = m_cluster->localPosition  ();
  m_covariance = m_cluster->localCovariance();
 
  if(m_ndf==1) return;
 
  const Amg::Vector2D& colRow = m_cluster->width().colRow();
  if(colRow.x()==1. && colRow.y()==1.) return;
 
  std::unique_ptr<Trk::TrackParameters> tr = Tc.convert(true);
  std::unique_ptr<const Trk::RIO_OnTrack> ri(m_riotool->correct(*m_cluster, *tr, Gaudi::Hive::currentContext()));
 
  m_position   = ri->localParameters();
  m_covariance = ri->localCovariance();
 
}

propagate()

bool InDet::SiTrajectoryElement_xk::propagate	(	Trk::PatternTrackParameters &	startingParameters,
		Trk::PatternTrackParameters &	outputParameters,
		double &	StepLength,
		const EventContext &	ctx )

Will propagate the startingParameters from their reference to the surface associated with this element and write the result into the second argument.

Start from 'startingParameters', propagate to current surface.

The third argument records the step length traversed.

Write into outputParameters and wrote step to surface into StepLength

helper field to store global frame parameters Convention: 0-2: Position 3-5: Direction 6: qoverp 7 - 41: jacobian 42-44: extension of jacobian for dA/ds 45: step length

transform starting parameters to global, write into globalParameters

if running with field, use Runge Kutta. Will update globalParameters to the result in global coordinates

otherwise, we can use the straight line

Update step length

and finally transform from global back to local, and write into the output parameters.

Definition at line 1378 of file SiTrajectoryElement_xk.cxx.

                                                                   {
  if (Trk::SurfaceType::Plane == m_surface->type() and
    Trk::SurfaceType::Plane == startingParameters.associatedSurface().type()) {
    bool useJac = (startingParameters.iscovariance());
    double globalParameters[64];    

    if(!transformPlaneToGlobal(useJac,startingParameters,globalParameters)) return false;
    if( m_fieldMode) {
      if(!rungeKuttaToPlane      (useJac,globalParameters)) return false;
    }
    else {
      if(!straightLineStepToPlane(useJac,globalParameters)) return false;
    }
    StepLength = globalParameters[45];
    return transformGlobalToPlane(useJac,globalParameters,startingParameters,outputParameters);
  } else {
    if (!m_proptool->propagate (ctx,
                                startingParameters, *m_surface, outputParameters,
                                Trk::anyDirection, m_tools->fieldTool(), StepLength, Trk::pion))
      return false;
 
    double sinPhi,cosPhi,sinTheta,cosTheta;
    sincos(outputParameters.parameters()[2],&sinPhi,&cosPhi);
    sincos(outputParameters.parameters()[3],&sinTheta,&cosTheta);
    m_localDir[0] = cosPhi*sinTheta;
    m_localDir[1] = sinPhi*sinTheta;
    m_localDir[2] =    cosTheta;
    return true;
  }
}

propagateParameters()

bool InDet::SiTrajectoryElement_xk::propagateParameters	(	Trk::PatternTrackParameters &	startingParameters,
		Trk::PatternTrackParameters &	outputParameters,
		double &	StepLength )

Start from 'startingParameters', propagate to current surface.

Write into outputParameters and wrote step to surface into StepLength

helper field to store global frame parameters Convention: 0-2: Position 3-5: Direction 6: qoverp 7 - 41: jacobian 42-44: extension of jacobian for dA/ds 45: step length

if running with field, use Runge Kutta. Will update globalParameters to the result in global coordinates

otherwise, we can use the straight line

Update step length

and finally transform from global back to local, and write into the output parameters.

Definition at line 1432 of file SiTrajectoryElement_xk.cxx.

                                                                          {
  bool useJac = false;
  double globalParameters[64];    
  if(!transformPlaneToGlobal(useJac,startingParameters,globalParameters)) return false;
  if( m_fieldMode) {
    if(!rungeKuttaToPlane (useJac,globalParameters)) return false;
  }
  else {
    if(!straightLineStepToPlane(useJac,globalParameters)) return false;
  }
  StepLength = globalParameters[45];
  return transformGlobalToPlane(useJac,globalParameters,startingParameters,outputParameters);
}

quality()

double InDet::SiTrajectoryElement_xk::quality

(

int &

holes

)

const

Definition at line 1348 of file SiTrajectoryElement_xk.cxx.

{
 
  if(!m_cluster && !m_clusterNoAdd) {
 
    if(m_detstatus < 0) return 0.;
 
    if     (m_inside <  0) {
      double w = 2.-m_xi2max; if(++holes > 1) w*=2.; return w;
    }
    else if(m_inside == 0) return -1.;
    else                   return  0.;
  }
 
  double w,X,Xc = m_xi2max+2.;
  m_status == 1 ? X = m_xi2Forward        : X = m_xi2Backward;
  m_ndf    == 2 ? w = 1.2*(Xc-X*.5) : w = Xc-X  ; if(w < -1.) w = -1.;
  holes    = 0;
 
  return w;
}

radlength()

const double & InDet::SiTrajectoryElement_xk::radlength ( ) const

inline

Definition at line 125 of file SiTrajectoryElement_xk.h.

{return m_radlength ;}

rungeKuttaToPlane()

bool InDet::SiTrajectoryElement_xk::rungeKuttaToPlane	(	bool	updateJacobian,
		double *	globalPars )

Runge Kutta step to plane Updates the "globalPars" array, which is also used to pass the input.

This array follows the convention outlined above (46 components)

minimum step length

step length below which we are allowed to use a helical approximation

tolerance before reducing step length

Minimum momentum check

dA/ds

This is a conversion from p to half-curvature (1/2R), when multiplied with the orthogonal field component Curvature = 2 * Pi x B x sin(angle)

abs(qoverp)

projection of global direction onto local Z-axis

distance orthogonal to surface in units of direction z-component

if we are sufficiently close in Z already, add a final straight line step corresponding to the remaining difference to get the estimate on the surface, update step length, and return the result

if we are too far away, Limit the step size to 0.3 * p

holders for the B-field

get the field at our reference point

if the step is sifficiently small, we are allowed to use a helical model

S/3

S/4

2 S/curvature radius, when multiplied with the appropriate field

First point

equip field with conversion factor to 2S/curvature

v cross B

updated position for field eval

field at updated position

if assuming helix, homogenous field

Parameters calculation if the step grew too small, or we traveled more than 2 meters, abort, this went badly wrong...

New step estimation

if the remaining step is below threshold, we can finish with a small linear step

if we ran past the surface and changed signs more than twice, abort

if absolute step size is decreasing, we keep going

if step increased, try the other direction

otherwise refine step length if shorter than before

update field for next iteration

Definition at line 1660 of file SiTrajectoryElement_xk.cxx.

{
  const double Smin = .1        ;
  const double Shel = 5.        ;
  const double dlt  = .001      ;

  if(std::abs(globalPars[6]) > .05) return false;
 
 
  int    it    =               0;
  double* R    =          &globalPars[ 0];            // Coordinates
 
  double* A    =          &globalPars[ 3];            // Directions
 
  double* sA   =          &globalPars[42];            
  double  Pi   =  149.89626*globalPars[6];            
  double  Pa   = std::abs      (globalPars[6]);           

  double  a    = A[0]*m_localTransform[6]+A[1]*m_localTransform[7]+A[2]*m_localTransform[8];
  if(a==0.) return false;
  double  S    = ((m_localTransform[12]-R[0]*m_localTransform[6])-(R[1]*m_localTransform[7]+R[2]*m_localTransform[8]))/a;
  double  S0   = std::abs(S)                                                ;

  if(S0 <= Smin) {
    R[0]+=(A[0]*S);
    R[1]+=(A[1]*S);
    R[2]+=(A[2]*S);
    globalPars[45]+=S;
    return true;
  }
  else  if( (Pa*S0) > .3) {
    if (S >0) S = 0.3 / Pa;
    else S = -0.3/Pa;
  }
 
  bool   ste   = false;

  double f0[3];
  double f[3];

  m_fieldCache.getFieldZR(R,f0);
 
 
  while(true) {
 
    bool Helix = false;
    if(std::abs(S) < Shel) Helix = true;
    double S3=(1./3.)*S;      
    double S4=.25*S;          
    double PS2=Pi*S;          

    double H0[3] = {f0[0]*PS2,      
                    f0[1]*PS2,
                    f0[2]*PS2};
 
    double A0    = A[1]*H0[2]-A[2]*H0[1]            ;     
    double B0    = A[2]*H0[0]-A[0]*H0[2]            ;
    double C0    = A[0]*H0[1]-A[1]*H0[0]            ;
 
    double A2    = A0+A[0]                          ;
    double B2    = B0+A[1]                          ;
    double C2    = C0+A[2]                          ;
 
    double A1    = A2+A[0]                          ;
    double B1    = B2+A[1]                          ;
    double C1    = C2+A[2]                          ;
 
    // Second point
    //
    if(!Helix) {
      double gP[3]={R[0]+A1*S4,       
                    R[1]+B1*S4,
                    R[2]+C1*S4};
 
      m_fieldCache.getFieldZR(gP,f);  
 
    }
    else  {
      f[0]=f0[0];
      f[1]=f0[1];
      f[2]=f0[2];
    }
 
    double H1[3] = {f[0]*PS2,
                    f[1]*PS2,
                    f[2]*PS2};
    double A3    = (A[0]+B2*H1[2])-C2*H1[1]    ;
    double B3    = (A[1]+C2*H1[0])-A2*H1[2]    ;
    double C3    = (A[2]+A2*H1[1])-B2*H1[0]    ;
 
    double A4    = (A[0]+B3*H1[2])-C3*H1[1]    ;
    double B4    = (A[1]+C3*H1[0])-A3*H1[2]    ;
    double C4    = (A[2]+A3*H1[1])-B3*H1[0]    ;
 
    double A5    = 2.*A4-A[0]                  ;
    double B5    = 2.*B4-A[1]                  ;
    double C5    = 2.*C4-A[2]                  ;
 
    // Last point
    //
    if(!Helix) {
      double gP[3]={R[0]+S*A4,
                    R[1]+S*B4,
                    R[2]+S*C4};
 
      m_fieldCache.getFieldZR(gP,f);
 
    }
    else{
      f[0]=f0[0];
      f[1]=f0[1];
      f[2]=f0[2];
    }
 
    double H2[3] = {f[0]*PS2,
                    f[1]*PS2,
                    f[2]*PS2};
 
    double A6    = B5*H2[2]-C5*H2[1]           ;
    double B6    = C5*H2[0]-A5*H2[2]           ;
    double C6    = A5*H2[1]-B5*H2[0]           ;
 
    // Test approximation quality on give step and possible step reduction
    //
    if(!ste) {
      double EST = std::abs((A1+A6)-(A3+A4))+std::abs((B1+B6)-(B3+B4))+std::abs((C1+C6)-(C3+C4));
      if(EST>dlt) {
        S*=.6;
        continue;
      }
    }

    if((!ste && S0 > std::abs(S)*100.) || std::abs(globalPars[45]+=S) > 2000.) return false;
    ste = true;
 
    double A0arr[3]{A0,B0,C0};
    double A3arr[3]{A3,B3,C3};
    double A4arr[3]{A4,B4,C4};
    double A6arr[3]{A6,B6,C6};
 
    if(Jac) {
      Trk::propJacobian(globalPars,H0,H1,H2,A,A0arr,A3arr,A4arr,A6arr,S3);
    }
 
    R[0]+=(A2+A3+A4)*S3;
    A[0] = ((A0+2.*A3)+(A5+A6));
    R[1]+=(B2+B3+B4)*S3;
    A[1] = ((B0+2.*B3)+(B5+B6));
    R[2]+=(C2+C3+C4)*S3;
    A[2] = ((C0+2.*C3)+(C5+C6));
    if(!m_tools->isITkGeometry()){
      A[0] *= 1./3.;
      A[1] *= 1./3.;
      A[2] *= 1./3.;
    }
 
    double D   = 1./sqrt(A[0]*A[0]+A[1]*A[1]+A[2]*A[2]);
    A[0]*=D; A[1]*=D; A[2]*=D;

    double  a    = A[0]*m_localTransform[6]+A[1]*m_localTransform[7]+A[2]*m_localTransform[8];
    if(a==0.) return false;
    double  Sn   = ((m_localTransform[12]-R[0]*m_localTransform[6])-(R[1]*m_localTransform[7]+R[2]*m_localTransform[8]))/a;
    double aSn = std::abs(Sn);

    if(aSn <= Smin) {
      double Sl = 2./S;
      sA[0] = A6*Sl;
      sA[1] = B6*Sl;
      sA[2] = C6*Sl;
 
      R[0]+=(A[0]*Sn);
      R[1]+=(A[1]*Sn);
      R[2]+=(A[2]*Sn);
      globalPars[45]+=Sn;
 
      return true;
    }
 
    double aS = std::abs(S);

    if     (  S*Sn < 0. ) {
      if(++it > 2) return false;
      if (aSn < aS) S = Sn;
      else S =-S;
    }
    else if( aSn  < aS  ) S = Sn;

    f0[0]=f[0];
    f0[1]=f[1];
    f0[2]=f[2];
  }
  return false;
}

searchClusters()

int InDet::SiTrajectoryElement_xk::searchClusters	(	Trk::PatternTrackParameters &	Tp,
		SiClusterLink_xk *	L )

delegate work to subsystem-specific template implementation

Definition at line 2399 of file SiTrajectoryElement_xk.cxx.

                                                                                                  {
  if (m_itType==PixelClusterColl) return searchClustersSub<InDet::PixelClusterCollection::const_iterator>(Tp, L);
  if (m_itType==SCT_ClusterColl) return searchClustersSub<InDet::SCT_ClusterCollection::const_iterator>(Tp, L);
  return searchClustersSub<InDet::SiClusterCollection::const_iterator>(Tp, L);
}

searchClustersSub()

template<typename T>

int InDet::SiTrajectoryElement_xk::searchClustersSub	(	Trk::PatternTrackParameters &	,
		SiClusterLink_xk *	)

searchClustersWithoutStereoAssPIX()

template<typename T>

int InDet::SiTrajectoryElement_xk::searchClustersWithoutStereoAssPIX	(	Trk::PatternTrackParameters &	,
		SiClusterLink_xk *	,
		const Trk::PRDtoTrackMap &	)

searchClustersWithoutStereoAssSCT()

template<typename T>

int InDet::SiTrajectoryElement_xk::searchClustersWithoutStereoAssSCT	(	Trk::PatternTrackParameters &	,
		SiClusterLink_xk *	,
		const Trk::PRDtoTrackMap &	)

searchClustersWithoutStereoPIX()

template<typename T>

int InDet::SiTrajectoryElement_xk::searchClustersWithoutStereoPIX	(	Trk::PatternTrackParameters &	,
		SiClusterLink_xk *	)

searchClustersWithoutStereoSCT()

template<typename T>

int InDet::SiTrajectoryElement_xk::searchClustersWithoutStereoSCT	(	Trk::PatternTrackParameters &	,
		SiClusterLink_xk *	)

searchClustersWithStereo()

template<typename T>

int InDet::SiTrajectoryElement_xk::searchClustersWithStereo	(	Trk::PatternTrackParameters &	,
		SiClusterLink_xk *	)

searchClustersWithStereoAss()

template<typename T>

int InDet::SiTrajectoryElement_xk::searchClustersWithStereoAss	(	Trk::PatternTrackParameters &	,
		SiClusterLink_xk *	,
		const Trk::PRDtoTrackMap &	)

set()

template<typename T>

bool InDet::SiTrajectoryElement_xk::set	(	int	st,
		const InDet::SiDetElementBoundaryLink_xk *&	dl,
		const T &	sb,
		const T &	se,
		const InDet::SiCluster *	si,
		const EventContext &	ctx )

T = InDet::SiClusterCollection::const_iterator or InDet::PixelClusterCollection::const_iterator or InDet::SCT_ClusterCollection::const_iterator.

setCluster()

void InDet::SiTrajectoryElement_xk::setCluster

(

const InDet::SiCluster *

Cl

)

Definition at line 2130 of file SiTrajectoryElement_xk.cxx.

{
  m_cluster = Cl;
}

setClusterB()

void InDet::SiTrajectoryElement_xk::setClusterB	(	const InDet::SiCluster *	Cl,
		double	Xi2 )

Definition at line 2135 of file SiTrajectoryElement_xk.cxx.

{
  m_cluster = Cl ;
  m_status  = 2  ;
  m_xi2Backward = Xi2;
}

setDead()

bool InDet::SiTrajectoryElement_xk::setDead

(

const Trk::Surface *

SU

)

Definition at line 29 of file SiTrajectoryElement_xk.cxx.

{
  m_fieldMode    = false;
  if(m_tools->fieldTool().magneticFieldMode()!=0) m_fieldMode = true;
  m_status       = 0                       ;
  m_detstatus    = 0                       ;
  m_nMissing        = 0                       ;
  m_nlinksForward      = 0                       ;
  m_nlinksBackward     = 0                       ;
  m_nholesForward      = 0                       ;
  m_nholesBackward     = 0                       ;
  m_dholesForward      = 0                       ;
  m_dholesBackward     = 0                       ;
  m_nclustersForward   = 0                       ;
  m_nclustersBackward  = 0                       ;
  m_npixelsBackward    = 0                       ;
  m_ndfForward         = 0                       ;
  m_ndfBackward        = 0                       ;
  m_ntsos              = 0                       ;
  m_detelement   = nullptr                       ;
  m_detlink      = nullptr                       ;
  m_surface      = SU                      ;
  m_cluster      = nullptr                       ;
  m_clusterOld   = nullptr                       ;
  m_clusterNoAdd = nullptr                       ;
  noiseInitiate()                          ;
  m_radlength    = -1.                     ;
  m_inside       = -1                      ;
  m_localDir[0] = 1.;
  m_localDir[1] = 0.;
  m_localDir[2] = 0.;
  return true;
}

setDeadRadLength()

void InDet::SiTrajectoryElement_xk::setDeadRadLength

(

Trk::PatternTrackParameters &

Tp

)

Definition at line 68 of file SiTrajectoryElement_xk.cxx.

{
  if(m_radlength >= 0.) return;
  double z = std::abs(Tp.parameters()[1]);
  if     (z <  50.)   m_radlength = .0075;
  else if(z <  205.)  m_radlength = .02;
  else if(z <  360.)  m_radlength = .03+(z-205.)*0.000129032;
  else if(z <  570.)  m_radlength = .035+(z-360.)*9.04762e-05;
  else if(z <  1500.) m_radlength = .054+(z-570.)*1.82796e-05;
  else if(z <  2400.) m_radlength = .071+(z-1500.)*7.14286e-06;
  else                m_radlength = .078;
 
}

setNdist()

void InDet::SiTrajectoryElement_xk::setNdist

(

int

n

)

Definition at line 2153 of file SiTrajectoryElement_xk.cxx.

{
  m_nMissing = n;
}

setParameters()

void InDet::SiTrajectoryElement_xk::setParameters

(

)

Definition at line 98 of file SiTrajectoryElement_xk.cxx.

{
  m_maxholes     = m_tools->maxholes   ()  ;
  m_maxdholes    = m_tools->maxdholes  ()  ;
  m_xi2max       = m_tools->xi2max     ()  ;
  m_xi2maxNoAdd  = m_tools->xi2maxNoAdd()  ;
  m_xi2maxlink   = m_tools->xi2maxlink ()  ;
  m_xi2multi     = m_tools->xi2multi   ()  ;
}

setParametersB()

void InDet::SiTrajectoryElement_xk::setParametersB

(

Trk::PatternTrackParameters &

P

)

Definition at line 2143 of file SiTrajectoryElement_xk.cxx.

{
  m_parametersUpdatedBackward = P;
}

setParametersF()

void InDet::SiTrajectoryElement_xk::setParametersF

(

Trk::PatternTrackParameters &

P

)

Definition at line 2148 of file SiTrajectoryElement_xk.cxx.

{
  m_parametersUpdatedForward = P;
}

setTools()

void InDet::SiTrajectoryElement_xk::setTools

(

const InDet::SiTools_xk *

t

)

Definition at line 87 of file SiTrajectoryElement_xk.cxx.

{
  m_tools        = t                      ;
  m_prdToTrackMap= m_tools->PRDtoTrackMap();
  m_useassoTool  = m_tools->usePRDtoTrackAssociation() ;
  m_updatorTool  = m_tools->updatorTool ();
  m_proptool     = m_tools->propTool    ();
  m_riotool      = m_tools->rioTool     ();
  m_tools->fieldCondObj()->getInitializedCache (m_fieldCache);
}

status()

const int & InDet::SiTrajectoryElement_xk::status ( ) const

inline

Definition at line 62 of file SiTrajectoryElement_xk.h.

{return m_status;    }

step() [1/2]

const double & InDet::SiTrajectoryElement_xk::step ( ) const

inline

Definition at line 68 of file SiTrajectoryElement_xk.h.

{return m_step;      }

step() [2/2]

double InDet::SiTrajectoryElement_xk::step

(

InDet::SiTrajectoryElement_xk &

TE

)

Definition at line 1256 of file SiTrajectoryElement_xk.cxx.

{
  Trk::PatternTrackParameters Ta,Tb;
 
  if    (TE.m_status == 1) {
    if(TE.m_cluster) Ta = TE.m_parametersUpdatedForward;
    else             Ta = TE.m_parametersPredForward;
  }
  else if(TE.m_status == 2) {
    if(TE.m_cluster) Ta = TE.m_parametersUpdatedBackward;
    else             Ta = TE.m_parametersPredBackward;
  }
  else if(TE.m_status == 3) {
    Ta = TE.m_parametersSM;
  }
  double step = 0.;
  bool   Q    = propagateParameters(Ta,Tb,step);
  if(Q) return step;
  return 0.;
}

stepToPerigee()

double InDet::SiTrajectoryElement_xk::stepToPerigee

(

)

Definition at line 1315 of file SiTrajectoryElement_xk.cxx.

{
  Amg::Vector3D M;
  Amg::Vector3D P;
 
  if(m_cluster) {
    M = m_parametersUpdatedBackward.momentum();
    P = m_parametersUpdatedBackward.position();
  }
  else          {
    M = m_parametersPredBackward.momentum();
    P = m_parametersPredBackward.position();
  }
 
  return -(P[0]*M[0]+P[1]*M[1]);
}

stereo()

const bool & InDet::SiTrajectoryElement_xk::stereo ( ) const

inline

Definition at line 61 of file SiTrajectoryElement_xk.h.

{return m_stereo;    }

straightLineStepToPlane()

bool InDet::SiTrajectoryElement_xk::straightLineStepToPlane	(	bool	updateJacobian,
		double *	globalPars )

Straight line step to plane Updates the "globalPars" array, which is also used to pass the input.

This array follows the convention outlined above (46 components)

Definition at line 1889 of file SiTrajectoryElement_xk.cxx.

{
  double*  R   = &globalPars[ 0];             // Start coordinates
  double*  A   = &globalPars[ 3];             // Start directions
  double  a    = A[0]*m_localTransform[6]+A[1]*m_localTransform[7]+A[2]*m_localTransform[8];
  if(a==0.) return false;
  double  S    = ((m_localTransform[12]-R[0]*m_localTransform[6])-(R[1]*m_localTransform[7]+R[2]*m_localTransform[8]))/a;
  globalPars[45]        = S;
 
  // Track parameters in last point
  //
  R[0]+=(A[0]*S); R[1]+=(A[1]*S); R[2]+=(A[2]*S); if(!Jac) return true;
 
  // Derivatives of track parameters in last point
  //
  for(int i=7; i<42; i+=7) {
 
    double* dR = &globalPars[i  ];
    double* dA = &globalPars[i+3];
    dR[0]+=(dA[0]*S); dR[1]+=(dA[1]*S); dR[2]+=(dA[2]*S);
  }
  return true;
}

surface()

const Trk::Surface * InDet::SiTrajectoryElement_xk::surface ( ) const

inline

Definition at line 144 of file SiTrajectoryElement_xk.h.

{return m_surface;}

trackParameters() [1/2]

std::unique_ptr< Trk::TrackParameters > InDet::SiTrajectoryElement_xk::trackParameters	(	bool	cov,
		int	Q )

Definition at line 1071 of file SiTrajectoryElement_xk.cxx.

{
  if (m_status == 1) {
    if (m_cluster) {
      return m_parametersUpdatedForward.convert(cov);
    } else {
      return m_parametersPredForward.convert(cov);
    }
  } else if (m_status == 2) {
    if (m_cluster) {
      return m_parametersUpdatedBackward.convert(cov);
    } else {
      return m_parametersPredBackward.convert(cov);
    }
  } else if (m_status == 3) {
    if (Q == 0) {
      if (m_cluster) {
        if (addCluster(m_parametersSM, m_parametersSM)) {
          return m_parametersSM.convert(cov);
        } else if ((*m_parametersUpdatedBackward.covariance())(4, 4) <
                   (*m_parametersPredForward.covariance())(4, 4)) {
          return m_parametersUpdatedBackward.convert(cov);
        } else {
          return m_parametersPredForward.convert(cov);
        }
      } else
        return m_parametersSM.convert(cov);
    }
    if (Q == 1) {
      if (m_cluster) {
        return m_parametersUpdatedBackward.convert(cov);
      }
    }
    if (Q == 2) {
      if (m_cluster) {
        return m_parametersUpdatedForward.convert(cov);
      }
    }
  }
  return nullptr;
}

trackParameters() [2/2]

std::unique_ptr< Trk::TrackParameters > InDet::SiTrajectoryElement_xk::trackParameters ( Trk::PatternTrackParameters & Tp, bool cov )

static

Definition at line 1244 of file SiTrajectoryElement_xk.cxx.

{
  Tp.changeDirection();
  return Tp.convert(cov);
}

trackParametersWithNewDirection()

std::unique_ptr< Trk::TrackParameters > InDet::SiTrajectoryElement_xk::trackParametersWithNewDirection	(	bool	cov,
		int	Q )

Definition at line 1195 of file SiTrajectoryElement_xk.cxx.

{
  if (m_status == 1) {
    if (m_cluster) {
      return trackParameters(m_parametersUpdatedForward, cov);
    } else {
      return trackParameters(m_parametersPredForward, cov);
    }
 
  } else if (m_status == 2) {
    if (m_cluster) {
      return trackParameters(m_parametersUpdatedBackward, cov);
    } else {
      return trackParameters(m_parametersPredBackward, cov);
    }
  } else if (m_status == 3) {
 
    if (Q == 0) {
      if (m_cluster) {
        if (addCluster(m_parametersSM, m_parametersSM))
          return trackParameters(m_parametersSM, cov);
        else if ((*m_parametersUpdatedBackward.covariance())(4, 4) <
                 (*m_parametersPredForward.covariance())(4, 4)) {
          return trackParameters(m_parametersUpdatedBackward, cov);
        } else {
          return trackParameters(m_parametersPredForward, cov);
        }
      } else {
        return trackParameters(m_parametersSM, cov);
      }
    }
    if (Q == 1) {
      if (m_cluster){
        return trackParameters(m_parametersUpdatedBackward, cov);
      }
    }
    if (Q == 2) {
      if (m_cluster){
        return trackParameters(m_parametersUpdatedForward, cov);
      }
    }
  }
  return nullptr;
}

trackPerigeeStateOnSurface()

Trk::TrackStateOnSurface * InDet::SiTrajectoryElement_xk::trackPerigeeStateOnSurface

(

const EventContext &

ctx

)

Definition at line 1042 of file SiTrajectoryElement_xk.cxx.

{
  if(&m_parametersUpdatedBackward.associatedSurface()!=m_surface) return nullptr;
 
  double step                   ;
  Trk::PatternTrackParameters Tp;
 
  Trk::PerigeeSurface per;
 
  bool Q = m_proptool->propagate
    (ctx,
   m_parametersUpdatedBackward, per,Tp,Trk::anyDirection,m_tools->fieldTool(),step,Trk::pion);
 
  if(Q) {
    std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes>  typePattern;
    typePattern.set(Trk::TrackStateOnSurface::Perigee);
    return new Trk::TrackStateOnSurface(nullptr,Tp.convert(true),nullptr,typePattern);
  }
  return nullptr;
}

trackSimpleStateOnSurface()

Trk::TrackStateOnSurface * InDet::SiTrajectoryElement_xk::trackSimpleStateOnSurface	(	bool	change,
		bool	cov,
		int	Q )

Definition at line 979 of file SiTrajectoryElement_xk.cxx.

{
  if(!m_detelement) {
    return nullptr;
  }
 
  std::unique_ptr<Trk::TrackParameters> tp = nullptr;
 
  if (Q) {
    if (!change) {
      tp = trackParameters(cov, Q);
    } else {
      tp = trackParametersWithNewDirection(cov, Q);
    }
    if (!tp) {
      return nullptr;
    }
    if (&tp->associatedSurface() != m_surface) {
       return nullptr;
    }
  }
 
  IdentifierHash iH = m_detelement->identifyHash();
  std::unique_ptr<Trk::MeasurementBase> ro{};
  std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> pat(
    0);
 
  const InDet::SiCluster* cl = nullptr;
  if (m_cluster) {
    cl = m_cluster;
    pat.set(Trk::TrackStateOnSurface::Measurement);
  } else {
    cl = m_clusterNoAdd;
    pat.set(Trk::TrackStateOnSurface::Outlier);
  }
  pat.set(Trk::TrackStateOnSurface::Scatterer);
 
  Trk::LocalParameters locp = Trk::LocalParameters(cl->localPosition());
  Amg::MatrixX cv = cl->localCovariance();
 
  Trk::FitQualityOnSurface fq{};
  if     (m_status == 1) fq = Trk::FitQualityOnSurface(m_xi2Forward,m_ndf);
  else                   fq = Trk::FitQualityOnSurface(m_xi2Backward,m_ndf);
 
  if (m_ndf == 1) {
    const InDet::SCT_Cluster* sc = static_cast<const InDet::SCT_Cluster*>(cl);
    if (sc)
      ro = std::make_unique<InDet::SCT_ClusterOnTrack>(sc, std::move(locp), std::move(cv), iH, sc->globalPosition());
  } else {
    const InDet::PixelCluster* pc = static_cast<const InDet::PixelCluster*>(cl);
    if (pc)
      ro = std::make_unique<InDet::PixelClusterOnTrack>(
        pc, std::move(locp), std::move(cv), iH, pc->globalPosition(), pc->gangedPixel());
  }
  return new Trk::TrackStateOnSurface(fq, std::move(ro), std::move(tp), nullptr, pat);
}

trackStateOnSurface()

Trk::TrackStateOnSurface * InDet::SiTrajectoryElement_xk::trackStateOnSurface	(	bool	change,
		bool	cov,
		bool	multi,
		int	Q )

Definition at line 902 of file SiTrajectoryElement_xk.cxx.

{
  std::unique_ptr<Trk::TrackParameters> tp = nullptr;
  if (!change) {
    tp = trackParameters(cov, Q);
  } else {
    tp = trackParametersWithNewDirection(cov, Q);
  }
  if (!tp) {
    return nullptr;
  }
  if (&tp->associatedSurface() != m_surface) {
    return nullptr;
  }
 
  Trk::FitQualityOnSurface fq{};
  std::unique_ptr<Trk::MeasurementBase> ro{};
 
  if (m_status == 1) {
    fq = Trk::FitQualityOnSurface(m_xi2Forward, m_ndf);
  } else {
    fq = Trk::FitQualityOnSurface(m_xi2Backward, m_ndf);
  }
 
  std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> pat(
    0);
 
  if (m_cluster) {
    ro.reset(m_riotool->correct(*m_cluster, *tp, Gaudi::Hive::currentContext()));
    pat.set(Trk::TrackStateOnSurface::Measurement);
  } else {
    ro.reset(m_riotool->correct(*m_clusterNoAdd, *tp, Gaudi::Hive::currentContext()));
    pat.set(Trk::TrackStateOnSurface::Outlier);
  }
  auto sa = Trk::ScatteringAngles(
    0., 0., std::sqrt(m_noise.covarianceAzim()), std::sqrt(m_noise.covariancePola()));
 
  auto meTemplate = std::make_unique<Trk::MaterialEffectsOnTrack>(
    m_radlengthN, sa, tp->associatedSurface());
 
  pat.set(Trk::TrackStateOnSurface::Scatterer);
  Trk::TrackStateOnSurface* sos =
    new Trk::TrackStateOnSurface(fq, std::move(ro), std::move(tp), meTemplate->uniqueClone(), pat);
 
  m_tsos[0] = sos;
  m_utsos[0] = true;
  m_ntsos = 1;
 
  if (multi && m_cluster && m_ndf == 2 && m_nlinksBackward > 1) {
    for(int i=1; i!= m_nlinksBackward; ++i) {
      if(m_linkBackward[i].xi2() > m_xi2multi) break;
      std::unique_ptr<Trk::TrackParameters> tpn{};
      if (!change) {
        tpn = trackParameters(cov, Q);
      } else {
        tpn = trackParametersWithNewDirection(cov, Q);
      }
      if (!tpn){
        break;
      }
      auto fqn = Trk::FitQualityOnSurface(m_linkBackward[i].xi2(),m_ndf);
      std::unique_ptr<Trk::MeasurementBase> ron(m_riotool->correct(
        *m_linkBackward[i].cluster(), *(sos->trackParameters()), Gaudi::Hive::currentContext()) );
      m_tsos[m_ntsos] = new Trk::TrackStateOnSurface(
        fqn, std::move(ron), std::move(tpn), meTemplate->uniqueClone(), pat);
      m_utsos[m_ntsos] = false;
      if(++m_ntsos == 3) break;
    }
  }
  return sos;
}

transformGlobalToPlane()

bool InDet::SiTrajectoryElement_xk::transformGlobalToPlane	(	bool	useJac,
		double *	globalPars,
		Trk::PatternTrackParameters &	startingParameters,
		Trk::PatternTrackParameters &	outputParameters )

Tramsform from global to plane surface Will take the global parameters in globalPars, the surface from this trajectory element and populate outputParameters with the result.

If covariance update ("updateJacobian") is requested, also transport the covariance from "startingParameters" using the jacobian stored in the globalPars and write this into outputParameters. Convention for globalPars: /dL0 /dL1 /dPhi /dThe /dCM X ->globalPars[0] dX / globalPars[ 7] globalPars[14] globalPars[21] globalPars[28] globalPars[35]
Y ->globalPars[1] dY / globalPars[ 8] globalPars[15] globalPars[22] globalPars[29] globalPars[36]
Z ->globalPars[2] dZ / globalPars[ 9] globalPars[16] globalPars[23] globalPars[30] globalPars[37]
Ax ->globalPars[3] dAx/ globalPars[10] globalPars[17] globalPars[24] globalPars[31] globalPars[38]
Ay ->globalPars[4] dAy/ globalPars[11] globalPars[18] globalPars[25] globalPars[32] globalPars[39]
Az ->globalPars[5] dAz/ globalPars[12] globalPars[19] globalPars[26] globalPars[33] globalPars[40]
CM ->globalPars[6] dCM/ globalPars[13] globalPars[20] globalPars[27] globalPars[34] globalPars[41]

• dA/dS (42-44) and step (45)

Convention for globalPars: /dL0 /dL1 /dPhi /dThe /dCM X ->globalPars[0] dX / globalPars[ 7] globalPars[14] globalPars[21] globalPars[28] globalPars[35] Y ->globalPars[1] dY / globalPars[ 8] globalPars[15] globalPars[22] globalPars[29] globalPars[36] Z ->globalPars[2] dZ / globalPars[ 9] globalPars[16] globalPars[23] globalPars[30] globalPars[37] Ax ->globalPars[3] dAx/ globalPars[10] globalPars[17] globalPars[24] globalPars[31] globalPars[38] Ay ->globalPars[4] dAy/ globalPars[11] globalPars[18] globalPars[25] globalPars[32] globalPars[39] Az ->globalPars[5] dAz/ globalPars[12] globalPars[19] globalPars[26] globalPars[33] globalPars[40] CM ->globalPars[6] dCM/ globalPars[13] globalPars[20] globalPars[27] globalPars[34] globalPars[41]

local x,y,z axes in global frame

distance of global position to origin of local frame

local parameters obtained by transforming from global

local X

local Y

phi (from global direction x,y)

theta (from global cosTheta)

qoverp

update local direction vector

Condition trajectory on surface

transverse direction component

unit direction vector in the X,Y plane

covariance matrix production using jacobian - CovNEW = J*CovOLD*Jt

check for negative diagonals in the cov

write into output parameters. Assign our surface to them

Definition at line 1551 of file SiTrajectoryElement_xk.cxx.

{
  double Ax[3] = {m_localTransform[0],m_localTransform[1],m_localTransform[2]};
  double Ay[3] = {m_localTransform[3],m_localTransform[4],m_localTransform[5]};
  double Az[3] = {m_localTransform[6],m_localTransform[7],m_localTransform[8]};
  double d [3] = {globalPars[0]-m_localTransform[ 9],
                  globalPars[1]-m_localTransform[10],
                  globalPars[2]-m_localTransform[11]};

  double p[5] = {
     d[0]*Ax[0]+d[1]*Ax[1]+d[2]*Ax[2],            
         d[0]*Ay[0]+d[1]*Ay[1]+d[2]*Ay[2],            
         atan2(globalPars[4],globalPars[3]),          
         acos(globalPars[5]),                         
         globalPars[6]                                
  };

  m_localDir[0] = globalPars[3];
  m_localDir[1] = globalPars[4];
  m_localDir[2] = globalPars[5];
 
  if (useJac) {
    double A  = Az[0]*globalPars[3]+Az[1]*globalPars[4]+Az[2]*globalPars[5];
    if(A!=0.) A=1./A;
    double s0 = Az[0]*globalPars[ 7]+Az[1]*globalPars[ 8]+Az[2]*globalPars[ 9];
    double s1 = Az[0]*globalPars[14]+Az[1]*globalPars[15]+Az[2]*globalPars[16];
    double s2 = Az[0]*globalPars[21]+Az[1]*globalPars[22]+Az[2]*globalPars[23];
    double s3 = Az[0]*globalPars[28]+Az[1]*globalPars[29]+Az[2]*globalPars[30];
    double s4 = Az[0]*globalPars[35]+Az[1]*globalPars[36]+Az[2]*globalPars[37];
    double T0 =(Ax[0]*globalPars[ 3]+Ax[1]*globalPars[ 4]+Ax[2]*globalPars[ 5])*A;
    double T1 =(Ay[0]*globalPars[ 3]+Ay[1]*globalPars[ 4]+Ay[2]*globalPars[ 5])*A;
    double n  = 1./globalPars[6];
 
    double Jac[21];
 
    // Jacobian production
    //
    Jac[ 0] = (Ax[0]*globalPars[ 7]+Ax[1]*globalPars[ 8])+(Ax[2]*globalPars[ 9]-s0*T0);    // dL0/dL0
    Jac[ 1] = (Ax[0]*globalPars[14]+Ax[1]*globalPars[15])+(Ax[2]*globalPars[16]-s1*T0);    // dL0/dL1
    Jac[ 2] = (Ax[0]*globalPars[21]+Ax[1]*globalPars[22])+(Ax[2]*globalPars[23]-s2*T0);    // dL0/dPhi
    Jac[ 3] = (Ax[0]*globalPars[28]+Ax[1]*globalPars[29])+(Ax[2]*globalPars[30]-s3*T0);    // dL0/dThe
    Jac[ 4] =((Ax[0]*globalPars[35]+Ax[1]*globalPars[36])+(Ax[2]*globalPars[37]-s4*T0))*n; // dL0/dCM
 
    Jac[ 5] = (Ay[0]*globalPars[ 7]+Ay[1]*globalPars[ 8])+(Ay[2]*globalPars[ 9]-s0*T1);    // dL1/dL0
    Jac[ 6] = (Ay[0]*globalPars[14]+Ay[1]*globalPars[15])+(Ay[2]*globalPars[16]-s1*T1);    // dL1/dL1
    Jac[ 7] = (Ay[0]*globalPars[21]+Ay[1]*globalPars[22])+(Ay[2]*globalPars[23]-s2*T1);    // dL1/dPhi
    Jac[ 8] = (Ay[0]*globalPars[28]+Ay[1]*globalPars[29])+(Ay[2]*globalPars[30]-s3*T1);    // dL1/dThe
    Jac[ 9] =((Ay[0]*globalPars[35]+Ay[1]*globalPars[36])+(Ay[2]*globalPars[37]-s4*T1))*n; // dL1/dCM
 
    double P3=0;
    double P4=0;
    double C = globalPars[3]*globalPars[3]+globalPars[4]*globalPars[4];
    if(C > 1.e-20) {
      C= 1./C ;
      P3 = globalPars[3]*C;
      P4 =globalPars[4]*C;
      C =-sqrt(C);
    }
    else{
      C=-1.e10;
      P3 = 1.;
      P4 =0.;
    }
 
    double T2  =(P3*globalPars[43]-P4*globalPars[42])*A;
    double C44 = C*globalPars[44]           *A;
 
    Jac[10] = P3*globalPars[11]-P4*globalPars[10]-s0*T2;    // dPhi/dL0
    Jac[11] = P3*globalPars[18]-P4*globalPars[17]-s1*T2;    // dPhi/dL1
    Jac[12] = P3*globalPars[25]-P4*globalPars[24]-s2*T2;    // dPhi/dPhi
    Jac[13] = P3*globalPars[32]-P4*globalPars[31]-s3*T2;    // dPhi/dThe
    Jac[14] =(P3*globalPars[39]-P4*globalPars[38]-s4*T2)*n; // dPhi/dCM
 
    Jac[15] = C*globalPars[12]-s0*C44;             // dThe/dL0
    Jac[16] = C*globalPars[19]-s1*C44;             // dThe/dL1
    Jac[17] = C*globalPars[26]-s2*C44;             // dThe/dPhi
    Jac[18] = C*globalPars[33]-s3*C44;             // dThe/dThe
    Jac[19] =(C*globalPars[40]-s4*C44)*n;          // dThe/dCM
    Jac[20] = 1.;                         // dCM /dCM

    AmgSymMatrix(5) newCov = Trk::RungeKuttaUtils::newCovarianceMatrix(Jac, *startingParameters.covariance());
    outputParameters.setParametersWithCovariance(m_surface, p, newCov);

    const AmgSymMatrix(5) & t = *outputParameters.covariance();
    if(t(0, 0)<=0. || t(1, 1)<=0. || t(2, 2)<=0. || t(3, 3)<=0. || t(4, 4)<=0.) return false;
  } else {
    outputParameters.setParameters(m_surface,p);
  }
 
  return true;
}

transformPlaneToGlobal()

bool InDet::SiTrajectoryElement_xk::transformPlaneToGlobal	(	bool	useJac,
		Trk::PatternTrackParameters &	localParameters,
		double *	globalPars )

Tramsform from plane to global Will take the surface and parameters from localParameters and populate globalPars with the result.

globalPars needs to be at least 46 elements long. Convention: /dL0 /dL1 /dPhi /dThe /dCM X ->globalPars[0] dX / globalPars[ 7] globalPars[14] globalPars[21] globalPars[28] globalPars[35]
Y ->globalPars[1] dY / globalPars[ 8] globalPars[15] globalPars[22] globalPars[29] globalPars[36]
Z ->globalPars[2] dZ / globalPars[ 9] globalPars[16] globalPars[23] globalPars[30] globalPars[37]
Ax ->globalPars[3] dAx/ globalPars[10] globalPars[17] globalPars[24] globalPars[31] globalPars[38]
Ay ->globalPars[4] dAy/ globalPars[11] globalPars[18] globalPars[25] globalPars[32] globalPars[39]
Az ->globalPars[5] dAz/ globalPars[12] globalPars[19] globalPars[26] globalPars[33] globalPars[40]
CM ->globalPars[6] dCM/ globalPars[13] globalPars[20] globalPars[27] globalPars[34] globalPars[41]

• dA/dS (42-44) and step (45)

globalPars needs to be at least 46 elements long. Convention: /dL0 /dL1 /dPhi /dThe /dCM X ->globalPars[0] dX / globalPars[ 7] globalPars[14] globalPars[21] globalPars[28] globalPars[35] Y ->globalPars[1] dY / globalPars[ 8] globalPars[15] globalPars[22] globalPars[29] globalPars[36] Z ->globalPars[2] dZ / globalPars[ 9] globalPars[16] globalPars[23] globalPars[30] globalPars[37] Ax ->globalPars[3] dAx/ globalPars[10] globalPars[17] globalPars[24] globalPars[31] globalPars[38] Ay ->globalPars[4] dAy/ globalPars[11] globalPars[18] globalPars[25] globalPars[32] globalPars[39] Az ->globalPars[5] dAz/ globalPars[12] globalPars[19] globalPars[26] globalPars[33] globalPars[40] CM ->globalPars[6] dCM/ globalPars[13] globalPars[20] globalPars[27] globalPars[34] globalPars[41]

obtain trigonometric functions required for transform

get the surface corresponding to the local parameters

get the associated transform from the surface

Get the local x and y axis in the global frame

position

direction vectors

qoeverp // Az

for very high momenta, truncate to avoid zero

Update jacobian if requested

d(Ax,Ay,Az)/ds

Step length is initialised to zero - no propagation done yet

Definition at line 1476 of file SiTrajectoryElement_xk.cxx.

                                                   {
  double sinPhi,cosPhi,cosTheta,sintheta;
  sincos(localParameters.parameters()[2],&sinPhi,&cosPhi);
  sincos(localParameters.parameters()[3],&sintheta,&cosTheta);
  if (m_tools->isITkGeometry()) {
    if(std::abs(sintheta) < std::abs(localParameters.parameters()[4])*50.) return false;
  }
  const Trk::Surface* pSurface=&localParameters.associatedSurface();
  if (!pSurface){
    throw(std::runtime_error("TrackParameters associated surface is null pointer in InDet::SiTrajectoryElement_xk::transformPlaneToGlobal"));
  }
  const Amg::Transform3D& T  = pSurface->transform();

  double Ax[3] = {T(0,0),T(1,0),T(2,0)};
  double Ay[3] = {T(0,1),T(1,1),T(2,1)};

  globalPars[ 0] = localParameters.parameters()[0]*Ax[0]+localParameters.parameters()[1]*Ay[0]+T(0,3);                    // X
  globalPars[ 1] = localParameters.parameters()[0]*Ax[1]+localParameters.parameters()[1]*Ay[1]+T(1,3);                    // Y
  globalPars[ 2] = localParameters.parameters()[0]*Ax[2]+localParameters.parameters()[1]*Ay[2]+T(2,3);                    // Z
  globalPars[ 3] = cosPhi*sintheta;                                                         // Ax
  globalPars[ 4] = sinPhi*sintheta;                                                         // Ay
  globalPars[ 5] = cosTheta;
  globalPars[ 6] = localParameters.parameters()[4];                                                   // CM
  if(std::abs(globalPars[6])<1.e-20) {
    if (globalPars[6] < 0){
      globalPars[6]=-1.e-20;
    }
    else globalPars[6]= 1.e-20;
  }

  if(useJac) {
 
    //     /dL1   |      /dL2    |    /dPhi    |    /dThe     |    /dCM     |
    globalPars[ 7]  = Ax[0]; globalPars[14] = Ay[0]; globalPars[21] =   0.; globalPars[28] =    0.; globalPars[35] =   0.; // dX /
    globalPars[ 8]  = Ax[1]; globalPars[15] = Ay[1]; globalPars[22] =   0.; globalPars[29] =    0.; globalPars[36] =   0.; // dY /
    globalPars[ 9]  = Ax[2]; globalPars[16] = Ay[2]; globalPars[23] =   0.; globalPars[30] =    0.; globalPars[37] =   0.; // dZ /
    globalPars[10]  =    0.; globalPars[17] =    0.; globalPars[24] =-globalPars[4]; globalPars[31] = cosPhi*cosTheta; globalPars[38] =   0.; // dAx/
    globalPars[11]  =    0.; globalPars[18] =    0.; globalPars[25] = globalPars[3]; globalPars[32] = sinPhi*cosTheta; globalPars[39] =   0.; // dAy/
    globalPars[12]  =    0.; globalPars[19] =    0.; globalPars[26] =   0.; globalPars[33] =   -sintheta; globalPars[40] =   0.; // dAz/

    globalPars[42]  =    0.;
    globalPars[43] =    0.;
    globalPars[44] =   0.;
  }
  globalPars[45] =   0.;
  return true;
}

tsos()

Trk::TrackStateOnSurface * InDet::SiTrajectoryElement_xk::tsos

(

int

i

)

Definition at line 2318 of file SiTrajectoryElement_xk.cxx.

{
  if(i<0 || i>2) return nullptr;
 
  bool us = m_utsos[i];
  m_utsos[i] = true;
 
  if(us) return new Trk::TrackStateOnSurface(*m_tsos[i]);
 
  return m_tsos[i];
}

xi2B()

const double & InDet::SiTrajectoryElement_xk::xi2B ( ) const

inline

Definition at line 122 of file SiTrajectoryElement_xk.h.

{return m_xi2Backward      ;}

xi2F()

const double & InDet::SiTrajectoryElement_xk::xi2F ( ) const

inline

Definition at line 121 of file SiTrajectoryElement_xk.h.

{return m_xi2Forward      ;}

xi2totalB()

const double & InDet::SiTrajectoryElement_xk::xi2totalB ( ) const

inline

Definition at line 124 of file SiTrajectoryElement_xk.h.

{return m_xi2totalBackward ;}

xi2totalF()

const double & InDet::SiTrajectoryElement_xk::xi2totalF ( ) const

inline

Definition at line 123 of file SiTrajectoryElement_xk.h.

{return m_xi2totalForward ;}

Member Data Documentation

m_cluster

const InDet::SiCluster* InDet::SiTrajectoryElement_xk::m_cluster {}

private

Definition at line 495 of file SiTrajectoryElement_xk.h.

{}     ;

m_clusterNoAdd

const InDet::SiCluster* InDet::SiTrajectoryElement_xk::m_clusterNoAdd {}

private

Definition at line 497 of file SiTrajectoryElement_xk.h.

{};

m_clusterOld

const InDet::SiCluster* InDet::SiTrajectoryElement_xk::m_clusterOld {}

private

Definition at line 496 of file SiTrajectoryElement_xk.h.

{}  ;

m_covariance

Amg::MatrixX InDet::SiTrajectoryElement_xk::m_covariance

private

Definition at line 523 of file SiTrajectoryElement_xk.h.

m_detelement

const InDetDD::SiDetectorElement* InDet::SiTrajectoryElement_xk::m_detelement {}

private

Definition at line 480 of file SiTrajectoryElement_xk.h.

{}  ;

m_detlink

const InDet::SiDetElementBoundaryLink_xk* InDet::SiTrajectoryElement_xk::m_detlink {}

private

Definition at line 481 of file SiTrajectoryElement_xk.h.

{}     ;

m_detstatus

int InDet::SiTrajectoryElement_xk::m_detstatus {}

private

0 (no clusters)

Definition at line 443 of file SiTrajectoryElement_xk.h.

{}   ; 

m_dholesBackward

int InDet::SiTrajectoryElement_xk::m_dholesBackward {}

private

Definition at line 451 of file SiTrajectoryElement_xk.h.

{}     ;

m_dholesForward

int InDet::SiTrajectoryElement_xk::m_dholesForward {}

private

Definition at line 450 of file SiTrajectoryElement_xk.h.

{}     ;

m_dist

double InDet::SiTrajectoryElement_xk::m_dist {}

private

Definition at line 462 of file SiTrajectoryElement_xk.h.

{}        ;

m_energylose

double InDet::SiTrajectoryElement_xk::m_energylose {}

private

Definition at line 469 of file SiTrajectoryElement_xk.h.

{}  ;

m_fieldCache

MagField::AtlasFieldCache InDet::SiTrajectoryElement_xk::m_fieldCache

private

Definition at line 516 of file SiTrajectoryElement_xk.h.

m_fieldMode

bool InDet::SiTrajectoryElement_xk::m_fieldMode {}

private

Definition at line 436 of file SiTrajectoryElement_xk.h.

{}   ;

m_halflength

double InDet::SiTrajectoryElement_xk::m_halflength {}

private

Definition at line 470 of file SiTrajectoryElement_xk.h.

{}  ;

m_inside

int InDet::SiTrajectoryElement_xk::m_inside {}

private

Definition at line 444 of file SiTrajectoryElement_xk.h.

{}      ;

m_invMoment

double InDet::SiTrajectoryElement_xk::m_invMoment {}

private

Definition at line 478 of file SiTrajectoryElement_xk.h.

{}   ;

m_itType

IteratorType InDet::SiTrajectoryElement_xk::m_itType {Invalid}

private

Definition at line 528 of file SiTrajectoryElement_xk.h.

{Invalid};

m_linkBackward

InDet::SiClusterLink_xk InDet::SiTrajectoryElement_xk::m_linkBackward[10]

private

Definition at line 513 of file SiTrajectoryElement_xk.h.

m_linkForward

InDet::SiClusterLink_xk InDet::SiTrajectoryElement_xk::m_linkForward[10]

private

Definition at line 512 of file SiTrajectoryElement_xk.h.

m_localDir

double InDet::SiTrajectoryElement_xk::m_localDir[3] {}

private

the transform for this element

Definition at line 477 of file SiTrajectoryElement_xk.h.

{}      ;

m_localTransform

double InDet::SiTrajectoryElement_xk::m_localTransform[13] {}

private

Definition at line 476 of file SiTrajectoryElement_xk.h.

{}      ;     

m_maxdholes

int InDet::SiTrajectoryElement_xk::m_maxdholes {}

private

Definition at line 461 of file SiTrajectoryElement_xk.h.

{}   ;

m_maxholes

int InDet::SiTrajectoryElement_xk::m_maxholes {}

private

Definition at line 460 of file SiTrajectoryElement_xk.h.

{}    ;

m_nclustersBackward

int InDet::SiTrajectoryElement_xk::m_nclustersBackward {}

private

Definition at line 453 of file SiTrajectoryElement_xk.h.

{}  ;

m_nclustersForward

int InDet::SiTrajectoryElement_xk::m_nclustersForward {}

private

Definition at line 452 of file SiTrajectoryElement_xk.h.

{}  ;

m_ndf

int InDet::SiTrajectoryElement_xk::m_ndf {}

private

Definition at line 456 of file SiTrajectoryElement_xk.h.

{}         ;

m_ndfBackward

int InDet::SiTrajectoryElement_xk::m_ndfBackward {}

private

Definition at line 458 of file SiTrajectoryElement_xk.h.

{}        ;

m_ndfForward

int InDet::SiTrajectoryElement_xk::m_ndfForward {}

private

Definition at line 457 of file SiTrajectoryElement_xk.h.

{}        ;

m_nholesBackward

int InDet::SiTrajectoryElement_xk::m_nholesBackward {}

private

Definition at line 449 of file SiTrajectoryElement_xk.h.

{}     ;

m_nholesForward

int InDet::SiTrajectoryElement_xk::m_nholesForward {}

private

Definition at line 448 of file SiTrajectoryElement_xk.h.

{}     ;

m_nlinksBackward

int InDet::SiTrajectoryElement_xk::m_nlinksBackward {}

private

Definition at line 447 of file SiTrajectoryElement_xk.h.

{}     ;

m_nlinksForward

int InDet::SiTrajectoryElement_xk::m_nlinksForward {}

private

Definition at line 446 of file SiTrajectoryElement_xk.h.

{}     ;

m_nMissing

int InDet::SiTrajectoryElement_xk::m_nMissing {}

private

Definition at line 445 of file SiTrajectoryElement_xk.h.

{}       ;

m_noise

Trk::NoiseOnSurface InDet::SiTrajectoryElement_xk::m_noise

private

Definition at line 514 of file SiTrajectoryElement_xk.h.

m_noisemodel

int InDet::SiTrajectoryElement_xk::m_noisemodel {}

private

Definition at line 455 of file SiTrajectoryElement_xk.h.

{}  ;

m_npixelsBackward

int InDet::SiTrajectoryElement_xk::m_npixelsBackward {}

private

Definition at line 454 of file SiTrajectoryElement_xk.h.

{}    ;

m_ntsos

int InDet::SiTrajectoryElement_xk::m_ntsos {}

private

Definition at line 459 of file SiTrajectoryElement_xk.h.

{}       ;

m_parametersPredBackward

Trk::PatternTrackParameters InDet::SiTrajectoryElement_xk::m_parametersPredBackward

private

For backward filtering / smoothing Predicted state, backward.

Definition at line 508 of file SiTrajectoryElement_xk.h.

m_parametersPredForward

Trk::PatternTrackParameters InDet::SiTrajectoryElement_xk::m_parametersPredForward

private

Pattern track parameters.

For forward filtering / smoothing Predicted state, forward

Definition at line 503 of file SiTrajectoryElement_xk.h.

m_parametersSM

Trk::PatternTrackParameters InDet::SiTrajectoryElement_xk::m_parametersSM

private

Definition at line 511 of file SiTrajectoryElement_xk.h.

m_parametersUpdatedBackward

Trk::PatternTrackParameters InDet::SiTrajectoryElement_xk::m_parametersUpdatedBackward

private

Updated state, backward.

Definition at line 510 of file SiTrajectoryElement_xk.h.

m_parametersUpdatedForward

Trk::PatternTrackParameters InDet::SiTrajectoryElement_xk::m_parametersUpdatedForward

private

Updated state, forward.

Definition at line 505 of file SiTrajectoryElement_xk.h.

m_position

Amg::Vector2D InDet::SiTrajectoryElement_xk::m_position

private

Definition at line 524 of file SiTrajectoryElement_xk.h.

m_prdToTrackMap

const Trk::PRDtoTrackMap* InDet::SiTrajectoryElement_xk::m_prdToTrackMap {}

private

Definition at line 520 of file SiTrajectoryElement_xk.h.

{};      

m_proptool

const Trk::IPatternParametersPropagator* InDet::SiTrajectoryElement_xk::m_proptool {}

private

Definition at line 518 of file SiTrajectoryElement_xk.h.

{}    ;

m_radlength

double InDet::SiTrajectoryElement_xk::m_radlength {}

private

Definition at line 467 of file SiTrajectoryElement_xk.h.

{}   ;

m_radlengthN

double InDet::SiTrajectoryElement_xk::m_radlengthN {}

private

Definition at line 468 of file SiTrajectoryElement_xk.h.

{}  ;

m_riotool

const Trk::IRIO_OnTrackCreator* InDet::SiTrajectoryElement_xk::m_riotool {}

private

Definition at line 519 of file SiTrajectoryElement_xk.h.

{}     ;

m_sibegin

std::any InDet::SiTrajectoryElement_xk::m_sibegin

private

Definition at line 492 of file SiTrajectoryElement_xk.h.

m_siend

std::any InDet::SiTrajectoryElement_xk::m_siend

private

Definition at line 493 of file SiTrajectoryElement_xk.h.

m_status

int InDet::SiTrajectoryElement_xk::m_status {}

private

status flag.

Start as 0. set to 1 if set up for forward set to 2 if set up for backward set to 3 by lastTrajectoryElement or BackwardPropagationSmoother if m_cluster

Definition at line 442 of file SiTrajectoryElement_xk.h.

{}      ;  

m_step

double InDet::SiTrajectoryElement_xk::m_step {}

private

Definition at line 471 of file SiTrajectoryElement_xk.h.

{}        ;

m_stereo

bool InDet::SiTrajectoryElement_xk::m_stereo {}

private

Definition at line 434 of file SiTrajectoryElement_xk.h.

{}      ;

m_surface

const Trk::Surface* InDet::SiTrajectoryElement_xk::m_surface {}

private

Definition at line 482 of file SiTrajectoryElement_xk.h.

{}     ;

m_tools

const InDet::SiTools_xk* InDet::SiTrajectoryElement_xk::m_tools {}

private

Definition at line 515 of file SiTrajectoryElement_xk.h.

{}       ; 

m_tsos

Trk::TrackStateOnSurface* InDet::SiTrajectoryElement_xk::m_tsos[3] {}

private

Definition at line 522 of file SiTrajectoryElement_xk.h.

{}     ;

m_updatorTool

const Trk::IPatternParametersUpdator* InDet::SiTrajectoryElement_xk::m_updatorTool {}

private

Definition at line 517 of file SiTrajectoryElement_xk.h.

{} ;

m_useassoTool

bool InDet::SiTrajectoryElement_xk::m_useassoTool = false

private

Definition at line 437 of file SiTrajectoryElement_xk.h.

m_utsos

bool InDet::SiTrajectoryElement_xk::m_utsos[3] {}

private

Definition at line 435 of file SiTrajectoryElement_xk.h.

{}    ;

m_xi2Backward

double InDet::SiTrajectoryElement_xk::m_xi2Backward {}

private

Definition at line 464 of file SiTrajectoryElement_xk.h.

{}        ;

m_xi2Forward

double InDet::SiTrajectoryElement_xk::m_xi2Forward {}

private

Definition at line 463 of file SiTrajectoryElement_xk.h.

{}        ;

m_xi2max

double InDet::SiTrajectoryElement_xk::m_xi2max {}

private

Definition at line 472 of file SiTrajectoryElement_xk.h.

{}      ;

m_xi2maxlink

double InDet::SiTrajectoryElement_xk::m_xi2maxlink {}

private

Definition at line 474 of file SiTrajectoryElement_xk.h.

{}  ;  

m_xi2maxNoAdd

double InDet::SiTrajectoryElement_xk::m_xi2maxNoAdd {}

private

Definition at line 473 of file SiTrajectoryElement_xk.h.

{} ;

m_xi2multi

double InDet::SiTrajectoryElement_xk::m_xi2multi {}

private

Definition at line 475 of file SiTrajectoryElement_xk.h.

{}    ;

m_xi2totalBackward

double InDet::SiTrajectoryElement_xk::m_xi2totalBackward {}

private

Definition at line 466 of file SiTrajectoryElement_xk.h.

{}   ;

m_xi2totalForward

double InDet::SiTrajectoryElement_xk::m_xi2totalForward {}

private

Definition at line 465 of file SiTrajectoryElement_xk.h.

{}   ;

s_oneOverTwelve

double InDet::SiTrajectoryElement_xk::s_oneOverTwelve {0.08333}

staticconstexprprivate

Definition at line 526 of file SiTrajectoryElement_xk.h.

{0.08333}           ;

---

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

• SiTrajectoryElement_xk.h
• SiTrajectoryElement_xk.cxx