ATLAS Offline Software
Public Member Functions | List of all members
InDet::SiTrajectoryElement_xk Class Referencefinal

#include <SiTrajectoryElement_xk.h>

Collaboration diagram for InDet::SiTrajectoryElement_xk:

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 More...
 
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. More...
 
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 More...
 
const Trk::PatternTrackParameters & parametersUF () const
 updated More...
 
const Trk::PatternTrackParameters & parametersPB () const
 predicted More...
 
const Trk::PatternTrackParameters & parametersUB () const
 observed More...
 
const Trk::PatternTrackParameters & parametersSM () const
 
const Trk::PatternTrackParameters * parameters () const
 return pattern parameters matching the status of this element More...
 
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. More...
 
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. More...
 
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. More...
 
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 More...
 
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. More...
 
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. More...
 

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

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. More...
 
int m_detstatus {}
 0 (no clusters) More...
 
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 More...
 
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. More...
 
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. More...
 
bool rungeKuttaToPlane (bool updateJacobian, double *globalPars)
 Runge Kutta step to plane Updates the "globalPars" array, which is also used to pass the input. More...
 
bool straightLineStepToPlane (bool updateJacobian, double *globalPars)
 Straight line step to plane Updates the "globalPars" array, which is also used to pass the input. More...
 

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. More...
 
Trk::PatternTrackParameters m_parametersUpdatedForward
 Updated state, forward. More...
 
Trk::PatternTrackParameters m_parametersPredBackward
 For backward filtering / smoothing Predicted state, backward. More...
 
Trk::PatternTrackParameters m_parametersUpdatedBackward
 Updated state, backward. More...
 
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. More...
 
void checkBoundaries (const Trk::PatternTrackParameters &pars)
 

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.

427  {
428  SiClusterColl = 0,
429  PixelClusterColl = 1,
430  SCT_ClusterColl = 2,
431  Invalid = 3
432  };

Constructor & Destructor Documentation

◆ SiTrajectoryElement_xk() [1/2]

InDet::SiTrajectoryElement_xk::SiTrajectoryElement_xk ( )

Definition at line 1915 of file SiTrajectoryElement_xk.cxx.

1916 {
1917  m_detstatus =-1 ;
1918  m_status = 0 ;
1919  m_nlinksForward = 0 ;
1920  m_nlinksBackward = 0 ;
1921  m_nMissing = 0 ;
1922  m_radlength = .03;
1923  m_radlengthN = .03;
1924  m_energylose = .4 ;
1925  m_tools = nullptr ;
1926  m_noisemodel = 0 ;
1927  m_covariance.resize(2,2);
1928  m_covariance<<0.,0.,0.,0.;
1929  m_ndf = 0 ;
1930  m_ndfBackward = 0 ;
1931  m_ndfForward = 0 ;
1932  m_ntsos = 0 ;
1933  m_maxholes = 0 ;
1934  m_maxdholes = 0 ;
1935  m_xi2Forward = 0.;
1936  m_xi2Backward = 0.;
1937  m_xi2totalForward = 0.;
1938  m_xi2totalBackward = 0.;
1939  m_halflength = 0.;
1940  m_step = 0.;
1941  m_xi2max = 0.;
1942  m_dist = 0.;
1943  m_xi2maxNoAdd = 0.;
1944  m_xi2maxlink = 0.;
1945  m_xi2multi = 0.;
1946  m_invMoment = 0.;
1947  m_detelement = nullptr ;
1948  m_detlink = nullptr ;
1949  m_surface = nullptr ;
1950  m_cluster = nullptr ;
1951  m_clusterOld = nullptr ;
1952  m_clusterNoAdd = nullptr ;
1953  m_updatorTool = nullptr ;
1954  m_proptool = nullptr ;
1955  m_riotool = nullptr ;
1956  m_inside = 0 ;
1957  m_nholesForward = 0 ;
1958  m_nholesBackward = 0 ;
1959  m_dholesForward = 0 ;
1960  m_dholesBackward = 0 ;
1961  m_nclustersForward = 0 ;
1962  m_nclustersBackward = 0 ;
1963  m_npixelsBackward = 0 ;
1964  m_stereo = false ;
1965  m_fieldMode = false ;
1966 
1967  m_tsos[0]=m_tsos[1]=m_tsos[2]=nullptr;
1968 }

◆ SiTrajectoryElement_xk() [2/2]

InDet::SiTrajectoryElement_xk::SiTrajectoryElement_xk ( const SiTrajectoryElement_xk &  E)

Definition at line 1970 of file SiTrajectoryElement_xk.cxx.

1971 {
1972  *this = E;
1973 }

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

2190 {
2191  if(!m_stereo) {
2192 
2193  patternCovariances
2194  (m_cluster,m_covariance(0,0),m_covariance(1,0),m_covariance(1,1));
2195  if(m_detelement->isSCT()) {
2196  return m_updatorTool->addToStateOneDimension
2197  (Ta,m_cluster->localPosition(),m_covariance,Tb);
2198  }
2199  return m_updatorTool->addToState
2200  (Ta,m_cluster->localPosition(),m_covariance,Tb);
2201  }
2202  return m_updatorTool->addToStateOneDimension
2203  (Ta,m_cluster->localPosition(),m_cluster->localCovariance(),Tb);
2204 }

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

2164 {
2165  int N;
2167  if(!m_stereo) {
2169  patternCovariances
2170  (m_cluster,m_covariance(0,0),m_covariance(1,0),m_covariance(1,1));
2172  if(m_detelement->isSCT()) {
2173  return m_updatorTool->addToStateOneDimension
2174  (Ta,m_cluster->localPosition(),m_covariance,Tb,Xi2,N);
2175  }
2176  return m_updatorTool->addToState
2177  (Ta,m_cluster->localPosition(),m_covariance,Tb,Xi2,N);
2178  }
2180  return m_updatorTool->addToStateOneDimension
2181  (Ta,m_cluster->localPosition(),m_cluster->localCovariance(),Tb,Xi2,N);
2182 }

◆ addClusterPrecise()

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

Definition at line 2211 of file SiTrajectoryElement_xk.cxx.

2213  {
2214  int N;
2215  if(m_ndf==1) {
2216  return m_updatorTool->addToStateOneDimension(Ta,m_position,m_covariance,Tb,Xi2,N);
2217  }
2218  else {
2219  return m_updatorTool->addToState (Ta,m_position,m_covariance,Tb,Xi2,N);
2220  }
2221 }

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

2360 {
2361  int N;
2362  precisePosCov(Tc);
2363 
2364  if(m_ndf==1) {
2365  return m_updatorTool->addToStateOneDimension(Ta,m_position,m_covariance,Tb,Xi2,N);
2366  }
2367  else {
2368  return m_updatorTool->addToState(Ta,m_position,m_covariance,Tb,Xi2,N);
2369  }
2370 }

◆ addNextClusterB() [1/2]

bool InDet::SiTrajectoryElement_xk::addNextClusterB ( )

Definition at line 753 of file SiTrajectoryElement_xk.cxx.

754 {
755  if(m_nlinksBackward <= 0) return false;
756 
757  if(m_cluster) m_xi2totalBackward-=m_xi2Backward;
758 
759  if(m_nlinksBackward > 1 && m_linkBackward[1].xi2() <= m_xi2max) {
760 
761  int n = 0;
762  for(; n!=m_nlinksBackward-1; ++n) m_linkBackward[n]=m_linkBackward[n+1];
763  m_nlinksBackward=n;
764 
765  m_cluster = m_linkBackward[0].cluster();
766  m_xi2Backward = m_linkBackward[0].xi2() ;
767  m_xi2totalBackward+= m_xi2Backward ;
768  if(!addCluster(m_parametersPredBackward,m_parametersUpdatedBackward)) return false;
769  }
770  else {
771  m_nlinksBackward = 0;
772  m_cluster = nullptr; --m_nclustersBackward; m_ndfBackward-=m_ndf; if(m_ndf==2) --m_npixelsBackward;
773  if(m_inside < 0 ) {++m_nholesBackward; ++m_dholesBackward;} m_xi2Backward = 0.;
774  if(m_dist < -2.) ++m_nMissing;
775  }
776  return true;
777 }

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

815 {
816 
817  m_clusterOld = m_cluster ;
818  m_cluster = Cl ;
819  m_nclustersBackward = TE.m_nclustersBackward;
820  m_npixelsBackward = TE.m_npixelsBackward ;
821  m_ndfBackward = TE.m_ndfBackward ;
822  m_nholesBackward = TE.m_nholesBackward ;
823  m_nMissing = TE.m_nMissing ;
824  m_xi2totalBackward = TE.m_xi2totalBackward ;
825 
826  TE.m_cluster ? m_dholesBackward = 0 : m_dholesBackward = TE.m_dholesBackward;
827 
828  if(Cl) {
829 
830  if(!addCluster(m_parametersPredBackward,m_parametersUpdatedBackward,m_xi2Backward)) return false;
831  m_inside = -1;
832  noiseProduction(-1,m_parametersUpdatedBackward);
833  ++m_nclustersBackward; m_xi2totalBackward+=m_xi2Backward; m_ndfBackward+=m_ndf; if(m_ndf==2) ++m_npixelsBackward;
834  }
835  else {
836 
837  if(m_inside < 0) {++m_nholesBackward; ++m_dholesBackward;} m_xi2Backward = 0.;
838  if(m_dist < -2.) ++m_nMissing;
839  }
840  return true;
841 }

◆ addNextClusterF() [1/2]

bool InDet::SiTrajectoryElement_xk::addNextClusterF ( )

Definition at line 783 of file SiTrajectoryElement_xk.cxx.

784 {
785  if(m_nlinksForward <= 0) return false;
786 
787  if(m_cluster) m_xi2totalForward-=m_xi2Forward;
788 
789  if(m_nlinksForward > 1 && m_linkForward[1].xi2() <= m_xi2max) {
790 
791  int n = 0;
792  for(; n!=m_nlinksForward-1; ++n) m_linkForward[n]=m_linkForward[n+1];
793  m_nlinksForward=n;
794 
795  m_cluster = m_linkForward[0].cluster();
796  m_xi2Forward = m_linkForward[0].xi2() ;
797  m_xi2totalForward+= m_xi2Forward ;
798  if(!addCluster(m_parametersPredForward,m_parametersUpdatedForward)) return false;
799  }
800  else {
801  m_nlinksForward = 0;
802  m_cluster = nullptr; --m_nclustersForward; m_ndfForward-=m_ndf;
803  if(m_inside < 0) {++m_nholesForward; ++m_dholesForward;} m_xi2Forward = 0.;
804  if(m_dist < -2.) ++m_nMissing;
805  }
806  return true;
807 }

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

849 {
851  m_clusterOld = m_cluster ;
853  m_cluster = Cl ;
854  m_nclustersForward = TE.m_nclustersForward;
856  m_ndfForward = TE.m_ndfForward ;
857  m_nholesForward = TE.m_nholesForward ;
858  m_nMissing = TE.m_nMissing ;
859  m_xi2totalForward = TE.m_xi2totalForward ;
862  if (TE.m_cluster){
863  m_dholesForward = 0;
864  }
866  else{
867  m_dholesForward = TE.m_dholesForward;
868  }
870  if(Cl) {
872  if(!addCluster(m_parametersPredForward,m_parametersUpdatedForward,m_xi2Forward)) return false;
874  m_inside = -1;
876  noiseProduction(1,m_parametersUpdatedForward);
878  ++m_nclustersForward;
879  m_xi2totalForward+=m_xi2Forward;
880  m_ndfForward+=m_ndf;
881  }
883  else {
885  if(m_inside < 0) {
886  ++m_nholesForward;
887  ++m_dholesForward;
888  }
890  m_xi2Forward = 0.;
892  if(m_dist < -2.) ++m_nMissing;
893  }
894  return true;
895 }

◆ BackwardPropagationFilter()

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

Definition at line 531 of file SiTrajectoryElement_xk.cxx.

533 {
534  // Track propagation
535  //
536  if(TE.m_noise.correctionIMom() < 1.) {
537 
538  if(TE.m_cluster) {
539 
540  TE.m_parametersUpdatedBackward.addNoise (TE.m_noise,Trk::oppositeMomentum);
541  if(!propagate(TE.m_parametersUpdatedBackward,m_parametersPredBackward,m_step,ctx)) return false;
542  TE.m_parametersUpdatedBackward.removeNoise(TE.m_noise,Trk::oppositeMomentum);
543  m_dholesBackward = 0;
544  }
545  else {
546 
547  TE.m_parametersPredBackward.addNoise (TE.m_noise,Trk::oppositeMomentum);
548  if(!propagate(TE.m_parametersPredBackward,m_parametersPredBackward,m_step,ctx)) return false;
549  TE.m_parametersPredBackward.removeNoise(TE.m_noise,Trk::oppositeMomentum);
550  m_dholesBackward = TE.m_dholesBackward;
551  }
552  }
553  else {
554 
555  if(TE.m_cluster) {
556 
557  if(!propagate(TE.m_parametersUpdatedBackward,m_parametersPredBackward,m_step,ctx)) return false;
558  m_dholesBackward = 0;
559  }
560  else {
561 
562  if(!propagate(TE.m_parametersPredBackward,m_parametersPredBackward,m_step,ctx)) return false;
563  m_dholesBackward = TE.m_dholesBackward;
564  }
565  }
566  m_status = 2;
567  m_nlinksBackward = 0;
568  m_clusterOld = m_cluster;
569  m_cluster = nullptr;
570  m_clusterNoAdd = nullptr;
571  m_xi2Backward = 10000.;
572  m_nholesBackward = TE.m_nholesBackward;
573  m_nMissing = TE.m_nMissing;
574  m_nclustersBackward = TE.m_nclustersBackward;
575  m_npixelsBackward = TE.m_npixelsBackward;
576  m_ndfBackward = TE.m_ndfBackward;
577  m_xi2totalBackward = TE.m_xi2totalBackward;
578  m_step += TE.m_step;
579 
580  if(m_tools->isITkGeometry() && !m_detelement) {
581  setDeadRadLength(m_parametersPredBackward);
582  noiseProduction(-1,m_parametersPredBackward);
583  return true;
584  }
585  checkBoundaries(m_parametersPredBackward);
586 
587  if(m_inside >0 ) {noiseInitiate(); return true;}
588 
589  if((m_nlinksBackward = searchClusters(m_parametersPredBackward,m_linkBackward))) {
590 
591  m_xi2Backward = m_linkBackward[0].xi2();
592 
593  if (m_xi2Backward <= m_xi2max ) {
594 
595  m_cluster = m_linkBackward[0].cluster();
596  if(!addCluster(m_parametersPredBackward,m_parametersUpdatedBackward)) return false;
597  noiseProduction(-1,m_parametersUpdatedBackward);
598  ++m_nclustersBackward; m_xi2totalBackward+=m_xi2Backward; m_ndfBackward+=m_ndf; if(m_ndf==2) ++m_npixelsBackward;
599  }
600  else if(m_xi2Backward <= m_xi2maxNoAdd) {
601 
602  m_clusterNoAdd = m_linkBackward[0].cluster();
603  noiseProduction(-1,m_parametersPredBackward);
604  }
605  }
606  else {
607  noiseProduction(-1,m_parametersPredBackward);
608  }
609 
610  if(m_detstatus >=0 && !m_cluster){
611  if(m_inside < 0 && !m_clusterNoAdd) {++m_nholesBackward; ++m_dholesBackward;}
612  if(m_dist < -2.) ++m_nMissing;
613  }
614  return true;
615 }

◆ BackwardPropagationPrecise()

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

Definition at line 719 of file SiTrajectoryElement_xk.cxx.

721 {
722 
723  // Track propagation
724  //
725  double step;
726  if(TE.m_cluster) {
727 
728  if(!propagate(TE.m_parametersUpdatedBackward,m_parametersPredBackward,step,ctx)) return false;
729  }
730  else {
731 
732  if(!propagate(TE.m_parametersPredBackward,m_parametersPredBackward,step,ctx)) return false;
733  }
734 
735  m_parametersPredBackward.addNoise(m_noise,Trk::oppositeMomentum);
736 
737  // Forward-backward predict parameters
738  //
739  if(m_cluster) {
740  m_status = 3 ;
741  if(!addClusterPrecise(m_parametersPredBackward,m_parametersUpdatedBackward,m_xi2Backward)) return false;
742  }
743  else {
744  m_status = 2 ;
745  }
746  return true;
747 }

◆ BackwardPropagationSmoother()

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

Definition at line 621 of file SiTrajectoryElement_xk.cxx.

623 {
624 
625  // Track propagation
626  //
627  double step;
628  if(TE.m_cluster) {
629  if(!propagate(TE.m_parametersUpdatedBackward,m_parametersPredBackward,step,ctx)) return false;
630  m_dholesBackward = 0;
631  }
632  else {
633  if(!propagate(TE.m_parametersPredBackward,m_parametersPredBackward,step,ctx)) return false;
634  m_dholesBackward = TE.m_dholesBackward;
635  }
636 
637  m_parametersPredBackward.addNoise(m_noise,Trk::oppositeMomentum);
638  m_nholesBackward = TE.m_nholesBackward;
639  m_nMissing = TE.m_nMissing;
640  m_nclustersBackward = TE.m_nclustersBackward;
641  m_npixelsBackward = TE.m_npixelsBackward;
642  m_ndfBackward = TE.m_ndfBackward;
643  m_xi2totalBackward = TE.m_xi2totalBackward;
644 
645  // remove case if you have trajectory element without actual detector element
646  // this happens if you have added a dead cylinder
647  if(!m_detelement) {
648  m_status = 2;
649  return true;
650  }
651 
652  // Forward-backward predict parameters
653  //
654  if(!combineStates(m_parametersPredBackward,m_parametersPredForward,m_parametersSM)) return false;
655 
656  m_cluster ? m_status = 3 : m_status = 2;
657 
658  double Xi2max = m_xi2max; if( isTwoSpacePointsSeed) Xi2max*=2.;
659  checkBoundaries(m_parametersSM);
660  m_nlinksBackward = 0;
661  m_clusterOld = m_cluster;
662  m_cluster = nullptr;
663  m_clusterNoAdd = nullptr;
664  m_xi2Backward = 10000.;
665 
666  //m_step += TE.m_step ;
667  if(m_inside> 0 ) return true;
668 
669 
670  // For not first cluster on trajectory
671  //
672  if(!m_clusterOld || m_ndfForward != m_ndf || m_ndfForward+m_ndfBackward >6) {
673 
674  if((m_nlinksBackward = searchClusters(m_parametersSM,m_linkBackward))) {
675 
676  m_xi2Backward = m_linkBackward[0].xi2();
677 
678 
679  if (m_xi2Backward <= Xi2max) {
680 
681  m_cluster = m_linkBackward[0].cluster();
682 
683  if(!addCluster(m_parametersPredBackward,m_parametersUpdatedBackward)) return false;
684  ++m_nclustersBackward; m_xi2totalBackward+=m_xi2Backward; m_ndfBackward+=m_ndf; if(m_ndf==2) ++m_npixelsBackward;
685  }
686  else if(m_xi2Backward <= m_xi2maxNoAdd) {
687 
688  m_clusterNoAdd = m_linkBackward[0].cluster();
689  }
690  }
691  if(m_detstatus >=0 && !m_cluster) {
692  if(m_inside < 0 && !m_clusterNoAdd) {++m_nholesBackward; ++m_dholesBackward;}
693  if(m_dist < -2.) ++m_nMissing;
694  }
695  return true;
696  }
697 
698  // For first cluster of short trajectory
699  //
700  m_cluster = m_clusterOld;
701  if(!addCluster(m_parametersPredBackward,m_parametersUpdatedBackward,m_xi2Backward)) return false;
702 
703  if (m_xi2Backward <= Xi2max ) {++m_nclustersBackward; m_xi2totalBackward+=m_xi2Backward; m_ndfBackward+=m_ndf; if(m_ndf==2) ++m_npixelsBackward;}
704  else if(m_xi2Backward <= m_xi2maxNoAdd) {m_cluster = nullptr; m_clusterNoAdd = m_clusterOld; }
705  else {m_cluster = nullptr; }
706 
707  if(!m_cluster) {
708  if(m_inside < 0 && !m_clusterNoAdd) {++m_nholesBackward; ++m_dholesBackward;}
709  if(m_dist < -2.) ++m_nMissing;
710 
711  }
712  return true;
713 }

◆ bremNoiseModel()

void InDet::SiTrajectoryElement_xk::bremNoiseModel ( )

Definition at line 2334 of file SiTrajectoryElement_xk.cxx.

2335 {
2336  m_noisemodel = 2;
2337 }

◆ checkBoundaries()

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

Definition at line 2405 of file SiTrajectoryElement_xk.cxx.

2405  {
2406 
2407  m_inside = m_detlink->intersect(pars, m_dist);
2408 
2409 }

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

73 {return m_cluster ; }

◆ clusterNoAdd()

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

Definition at line 75 of file SiTrajectoryElement_xk.h.

75 {return m_clusterNoAdd;}

◆ clusterOld()

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

Definition at line 74 of file SiTrajectoryElement_xk.h.

74 {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.

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

◆ detElement()

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

Definition at line 72 of file SiTrajectoryElement_xk.h.

72 {return m_detelement; }

◆ detstatus()

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

Definition at line 48 of file SiTrajectoryElement_xk.h.

48 {return m_detstatus;}

◆ dholesB()

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

Definition at line 57 of file SiTrajectoryElement_xk.h.

57 {return m_dholesBackward; }

◆ dholesF()

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

Definition at line 56 of file SiTrajectoryElement_xk.h.

56 {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.

2074 {
2075  return m_cluster != m_clusterOld || m_status != 3;
2076 }

◆ dist()

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

Definition at line 69 of file SiTrajectoryElement_xk.h.

69 {return m_dist; }

◆ energylose()

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

Definition at line 126 of file SiTrajectoryElement_xk.h.

126 {return m_energylose;}

◆ eraseClusterForwardPropagation()

void InDet::SiTrajectoryElement_xk::eraseClusterForwardPropagation ( )

Definition at line 1336 of file SiTrajectoryElement_xk.cxx.

1337 {
1338  m_cluster=nullptr;
1339  --m_nclustersForward;
1340  m_xi2totalForward-=m_xi2Forward;
1341  m_ndfForward-=m_ndf;
1342 }

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

180 {
181 
182  if(!m_cluster || !m_status) return false;
183  if(m_status > 1 ) m_parametersPredForward = m_parametersUpdatedBackward;
184 
185  if(correction){
186  m_parametersPredForward.diagonalization(10.);
187  if(!initiateStateWithCorrection(m_parametersPredBackward,m_parametersPredForward,m_parametersUpdatedForward)) return false;
188  }
189  else{
191  m_parametersPredForward.diagonalization(100.);
192  if(!initiateState(m_parametersPredForward,m_parametersUpdatedForward)) return false;
193  }
194 
195  m_invMoment = std::abs(m_parametersUpdatedBackward.parameters()[4]);
196  noiseProduction(1,m_parametersUpdatedForward);
197 
198  m_dist = -10. ;
199  m_xi2Forward = 0. ;
200  m_xi2totalForward = 0. ;
201  m_status = 1 ;
202  m_inside = -1 ;
203  m_nMissing = 0 ;
204  m_nlinksForward = 0 ;
205  m_nholesForward = 0 ;
206  m_dholesForward = 0 ;
207  m_clusterNoAdd = nullptr ;
208  m_nclustersForward = 1 ;
209  m_ndfForward = m_ndf;
210  return true;
211 }

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

115 {
117  if(!m_cluster) return false;
118 
120  Trk::PatternTrackParameters startingPatternPars;
121  if(!startingPatternPars.production(&startingParameters)) return false;
122 
124  const Trk::Surface* pl = &startingPatternPars.associatedSurface();
125 
128  if(m_surface==pl) m_parametersPredForward = startingPatternPars;
130  else if(!propagate(startingPatternPars,m_parametersPredForward,m_step,ctx)) return false;
131 
132  // Initiate track parameters without initial covariance
133  //
134  double cv[15]={
135  1. ,
136  0. , 1.,
137  0. , 0.,.001,
138  0. , 0., 0.,.001,
139  0. , 0., 0., 0.,.00001};
140 
141  if (m_tools->isITkGeometry()) {
142  cv[5] = m_ndf==2 ? .1 : .01;
143  cv[9] = cv[5];
144  }
145 
147  m_parametersPredForward.setCovariance(cv);
152  initiateState(m_parametersPredForward,m_parametersUpdatedForward);
153 
155  if(!m_tools->isITkGeometry()) noiseProduction(1,m_parametersUpdatedForward);
156  else noiseProduction(1,m_parametersUpdatedForward,1.);
157 
159  m_dist = -10. ;
160  m_step = 0. ;
161  m_xi2Forward = 0. ;
162  m_xi2totalForward = 0. ;
163  m_status = 1 ;
164  m_inside = -1 ;
165  m_nMissing = 0 ;
166  m_nlinksForward = 0 ;
167  m_nholesForward = 0 ;
168  m_dholesForward = 0 ;
169  m_clusterNoAdd = nullptr ;
170  m_nclustersForward = 1 ;
171  m_ndfForward = m_ndf;
172  return true;
173 }

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

281 {
284  if(TE.m_cluster) {
286  TE.m_parametersUpdatedForward.addNoise (TE.m_noise,Trk::alongMomentum);
288  if(!propagate(TE.m_parametersUpdatedForward,m_parametersPredForward,m_step, ctx)) return false;
290  TE.m_parametersUpdatedForward.removeNoise(TE.m_noise,Trk::alongMomentum);
292  m_dholesForward = 0;
293  }
294  else {
296  TE.m_parametersPredForward.addNoise (TE.m_noise,Trk::alongMomentum);
298  if(!propagate(TE.m_parametersPredForward,m_parametersPredForward,m_step, ctx)) return false;
300  TE.m_parametersPredForward.removeNoise(TE.m_noise,Trk::alongMomentum);
302  m_dholesForward = TE.m_dholesForward;
303  }
304 
306  m_nclustersForward = TE.m_nclustersForward;
307  m_nholesForward = TE.m_nholesForward ;
308  m_nMissing = TE.m_nMissing ;
309  m_ndfForward = TE.m_ndfForward ;
310  m_xi2totalForward = TE.m_xi2totalForward ;
311  m_step += TE.m_step ;
312 
315  if(!m_tools->isITkGeometry() || m_detelement){
316  if( m_cluster) {
318  if(!addCluster(m_parametersPredForward,m_parametersUpdatedForward,m_xi2Forward)) return false;
320  m_inside = -1;
322  ++m_nclustersForward;
324  m_xi2totalForward+=m_xi2Forward;
325  m_ndfForward+=m_ndf;
326  }
328  else {
330  checkBoundaries(m_parametersPredForward);
332  if( m_detstatus >=0) {
334  if(m_inside < 0 ) {
336  ++m_nholesForward;
337  ++m_dholesForward;
338  }
340  if(m_dist < -2.) ++m_nMissing;
341  }
342  }
343  } else setDeadRadLength(m_parametersPredForward);
344 
345 
348  if(m_inside<=0) {
350  if(m_cluster) noiseProduction(1,m_parametersUpdatedForward);
352  else noiseProduction(1,m_parametersPredForward);
353  }
355  else {
356  noiseInitiate();
357  }
358  m_status = 1;
359  m_nlinksForward = 0;
360  m_clusterNoAdd = nullptr;
361  return true;
362 }

◆ ForwardPropagationWithoutSearchPreciseWithCorrection()

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

Definition at line 369 of file SiTrajectoryElement_xk.cxx.

371 {
372  Trk::PatternTrackParameters P;
373 
374  if(TE.m_cluster) {
375  P = TE.m_parametersUpdatedForward;
376  m_dholesForward = 0;
377  }
378  else {
379  P = TE.m_parametersPredForward;
380  m_dholesForward = TE.m_dholesForward;
381  }
382  m_invMoment = TE.m_invMoment;
383 
384  // Track propagation
385  //
386  P.addNoise(TE.m_noise,Trk::alongMomentum);
387  if(!propagate(P,m_parametersPredForward,m_step,ctx)) return false;
388 
389  m_nclustersForward = TE.m_nclustersForward;
390  m_nholesForward = TE.m_nholesForward ;
391  m_nMissing = TE.m_nMissing ;
392  m_ndfForward = TE.m_ndfForward ;
393  m_xi2totalForward = TE.m_xi2totalForward ;
394  m_step += TE.m_step ;
395  m_inside = -1 ;
396 
397  // Track update
398  //
399  if(!m_tools->isITkGeometry() || m_detelement){
400  if( m_cluster) {
401  if(!addClusterPreciseWithCorrection(m_parametersPredForward,m_parametersPredForward,m_parametersUpdatedForward,m_xi2Forward)) return false;
402  ++m_nclustersForward; m_xi2totalForward+=m_xi2Forward; m_ndfForward+=m_ndf;
403  }
404  else {
405  if( m_detstatus >=0) {
406  ++m_nholesForward; ++m_dholesForward; ++m_nMissing;
407  }
408  }
409  }
410  else setDeadRadLength(m_parametersPredForward);
411 
412  // Noise production
413  //
414  m_radlength = .04;
415  noiseProduction(1,m_parametersUpdatedBackward,-1, true);
416  m_status = 1;
417  m_nlinksForward = 0;
418  m_clusterNoAdd = nullptr;
419  return true;
420 }

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

429 {
433  if(TE.m_cluster) {
434 
435  TE.m_parametersUpdatedForward.addNoise (TE.m_noise,Trk::alongMomentum);
436  if(!propagate(TE.m_parametersUpdatedForward,m_parametersPredForward,m_step,ctx)) return false;
437  TE.m_parametersUpdatedForward.removeNoise(TE.m_noise,Trk::alongMomentum);
439  m_dholesForward = 0;
440  }
441  else {
442 
443  TE.m_parametersPredForward.addNoise (TE.m_noise,Trk::alongMomentum);
444  if(!propagate(TE.m_parametersPredForward,m_parametersPredForward,m_step,ctx)) return false;
445  TE.m_parametersPredForward.removeNoise(TE.m_noise,Trk::alongMomentum);
446  m_dholesForward = TE.m_dholesForward;
447  }
448 
450  m_status = 1 ;
451  m_nlinksForward = 0 ;
453  m_clusterOld = m_cluster ;
454  m_cluster = nullptr ;
455  m_clusterNoAdd = nullptr ;
456  m_xi2Forward = 10000. ;
457 
459  m_nholesForward = TE.m_nholesForward ;
460  m_nMissing = TE.m_nMissing ;
461  m_nclustersForward = TE.m_nclustersForward ;
462  m_ndfForward = TE.m_ndfForward ;
463  m_xi2totalForward = TE.m_xi2totalForward ;
464  m_step += TE.m_step ;
465 
466  if(m_tools->isITkGeometry() && !m_detelement) {
467  setDeadRadLength(m_parametersPredForward);
468  noiseProduction(1,m_parametersPredForward);
469  return true;
470  }
471 
473  checkBoundaries(m_parametersPredForward);
474 
476  if(m_inside > 0) {
477  noiseInitiate(); return true;
478  }
479 
481  m_nlinksForward=searchClusters(m_parametersPredForward,m_linkForward);
483  if(m_nlinksForward!=0) {
485  m_xi2Forward = m_linkForward[0].xi2();
486 
488  if (m_xi2Forward <= m_xi2max ) {
490  m_cluster = m_linkForward[0].cluster();
492  if(!addCluster(m_parametersPredForward,m_parametersUpdatedForward)) return false;
494  noiseProduction(1,m_parametersUpdatedForward);
496  ++m_nclustersForward;
498  m_xi2totalForward+=m_xi2Forward;
500  m_ndfForward+=m_ndf;
501  }
503  else if(m_xi2Forward <= m_xi2maxNoAdd) {
505  m_clusterNoAdd = m_linkForward[0].cluster();
507  noiseProduction(1,m_parametersPredForward);
508  }
509  }
510  else {
512  noiseProduction(1,m_parametersPredForward);
513  }
515  if(m_detstatus >=0 && !m_cluster) {
517  if(m_inside < 0 && !m_clusterNoAdd) {
518  ++m_nholesForward;
519  ++m_dholesForward;
520  }
522  if(m_dist < -2. ) ++m_nMissing;
523  }
524  return true;
525 }

◆ globalPosition()

Amg::Vector3D InDet::SiTrajectoryElement_xk::globalPosition ( )

Definition at line 1282 of file SiTrajectoryElement_xk.cxx.

1283 {
1284  if (m_status == 1) {
1285  if(m_cluster) return m_parametersUpdatedForward.position();
1286  else return m_parametersPredForward.position();
1287  }
1288  else if(m_status == 2) {
1289  if(m_cluster) return m_parametersUpdatedBackward.position();
1290  else return m_parametersPredBackward.position();
1291  }
1292  else if(m_status == 3) {
1293 
1294  Amg::Vector3D gp(0.,0.,0.);
1295  bool QA; Trk::PatternTrackParameters S1,SM,S2(parametersPF());
1296 
1297  if(m_cluster) S1 = parametersUB();
1298  else S1 = parametersPB();
1299 
1300  QA = m_updatorTool->combineStates(S1,S2,SM);
1301 
1302  if(QA) {
1303  gp = SM.position();
1304  }
1305  return gp;
1306  }
1307  Amg::Vector3D gp(0.,0.,0.);
1308  return gp;
1309 }

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

2250 {
2253  if (m_tools->isITkGeometry()) {
2254  // using pattern covariance for all clusters for ITk
2255  Amg::MatrixX cov(2,2);
2256  patternCovariances(m_cluster,cov(0,0),cov(1,0),cov(1,1));
2257  return outputPars.initiate(inputPars,m_cluster->localPosition(),cov);
2258  }
2259  return outputPars.initiate(inputPars,m_cluster->localPosition(),m_cluster->localCovariance());
2260 }

◆ initiateStatePrecise()

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

Definition at line 2266 of file SiTrajectoryElement_xk.cxx.

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

◆ initiateStateWithCorrection()

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

Definition at line 2343 of file SiTrajectoryElement_xk.cxx.

2346 {
2347  precisePosCov(Tc);
2348  return Tb.initiate(Ta,m_position,m_covariance);
2349 }

◆ inside()

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

Definition at line 49 of file SiTrajectoryElement_xk.h.

49 {return m_inside; }

◆ isBarrel()

bool InDet::SiTrajectoryElement_xk::isBarrel ( ) const
inline

Definition at line 70 of file SiTrajectoryElement_xk.h.

70 {return m_detelement->isBarrel();}

◆ isNextClusterHoleB()

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

Definition at line 2082 of file SiTrajectoryElement_xk.cxx.

2083 {
2084  cl = false ;
2085  X = m_xi2totalBackward-m_xi2Backward;
2086 
2087  if(m_nlinksBackward > 1 && m_linkBackward[1].xi2() <= m_xi2max) {
2088  X+=m_linkBackward[1].xi2();
2089  cl = true; return true;
2090  }
2091 
2092  if(m_inside < 0) {
2093  return m_nholesBackward < m_maxholes && m_dholesBackward < m_maxdholes;
2094  }
2095  return true;
2096 }

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

2104 {
2105  cl = false ;
2107  X = m_xi2totalForward-m_xi2Forward;
2109  if(m_detstatus == 2) return false;
2112  if(m_nlinksForward > 1 && m_linkForward[1].xi2() <= m_xi2max) {
2114  X+=m_linkForward[1].xi2();
2116  cl = true;
2117  return true;
2118  }
2120  if(m_inside < 0) {
2122  if(m_nholesForward < m_maxholes && m_dholesForward < m_maxdholes) return true;
2124  return false;
2125  }
2127  return true;
2128 }

◆ lastActive()

void InDet::SiTrajectoryElement_xk::lastActive ( )

Definition at line 2313 of file SiTrajectoryElement_xk.cxx.

2314 {
2315  m_detstatus = 2;
2316 }

◆ lastTrajectorElement()

bool InDet::SiTrajectoryElement_xk::lastTrajectorElement ( )

Definition at line 217 of file SiTrajectoryElement_xk.cxx.

218 {
219  if(m_status==0 || !m_cluster) return false;
220  noiseProduction(1,m_parametersUpdatedForward);
221 
222  m_parametersSM = m_parametersPredForward;
223  m_parametersPredBackward = m_parametersUpdatedForward;
224  m_parametersPredBackward.diagonalization(100.);
225  if(!initiateState(m_parametersPredBackward,m_parametersUpdatedBackward)) return false;
226 
227  m_status = 3 ;
228  m_inside = -1 ;
229  m_nMissing = 0 ;
230  m_nlinksBackward = 0 ;
231  m_nholesBackward = 0 ;
232  m_dholesBackward = 0 ;
233  m_clusterNoAdd = nullptr ;
234  m_nclustersBackward = 1 ;
235  m_ndf == 2 ? m_npixelsBackward = 1 : m_npixelsBackward = 0;
236  m_ndfBackward = m_ndf ;
237  m_xi2Backward = m_xi2Forward;
238  m_xi2totalBackward = m_xi2Forward;
239  m_dist = -10.;
240  return true;
241 }

◆ lastTrajectorElementPrecise()

bool InDet::SiTrajectoryElement_xk::lastTrajectorElementPrecise ( )

Definition at line 247 of file SiTrajectoryElement_xk.cxx.

248 {
249  if(m_status==0 || !m_cluster) return false;
250  m_radlength = .04;
251  noiseProduction(1,m_parametersUpdatedForward);
252 
253  m_parametersSM = m_parametersPredForward;
254  m_parametersPredBackward = m_parametersUpdatedForward;
255  m_parametersPredBackward.diagonalization(10.);
256  if(!initiateStatePrecise(m_parametersPredBackward,m_parametersUpdatedBackward)) return false;
257  m_status = 3;
258  m_inside = -1;
259  m_nMissing = 0;
260  m_nlinksBackward = 0;
261  m_nholesBackward = 0;
262  m_dholesBackward = 0;
263  m_clusterNoAdd = nullptr;
264  m_nclustersBackward = 1;
265  m_clusterNoAdd = nullptr;
266  m_npixelsBackward = m_ndf==2 ? 1 : 0;
267  m_ndfBackward = m_ndf ;
268  m_xi2Backward = m_xi2Forward;
269  m_xi2totalBackward = m_xi2Forward; // As in 21.9, should this be m_xi2totalForward instead?
270  m_dist = -10.;
271  return true;
272 }

◆ linkB()

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

Definition at line 146 of file SiTrajectoryElement_xk.h.

146 {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.

145 {return m_linkForward[i];}

◆ nclustersB()

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

Definition at line 59 of file SiTrajectoryElement_xk.h.

59 {return m_nclustersBackward;}

◆ nclustersF()

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

Definition at line 58 of file SiTrajectoryElement_xk.h.

58 {return m_nclustersForward;}

◆ ndf()

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

Definition at line 64 of file SiTrajectoryElement_xk.h.

64 {return m_ndf; }

◆ ndfB()

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

Definition at line 66 of file SiTrajectoryElement_xk.h.

66 {return m_ndfBackward; }

◆ ndfF()

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

Definition at line 65 of file SiTrajectoryElement_xk.h.

65 {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.

51 {return m_nMissing ; }

◆ nholesB()

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

Definition at line 55 of file SiTrajectoryElement_xk.h.

55 {return m_nholesBackward; }

◆ nholesF()

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

Definition at line 54 of file SiTrajectoryElement_xk.h.

54 {return m_nholesForward; }

◆ nlinksB()

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

Definition at line 53 of file SiTrajectoryElement_xk.h.

53 {return m_nlinksBackward; }

◆ nlinksF()

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

Definition at line 52 of file SiTrajectoryElement_xk.h.

52 {return m_nlinksForward; }

◆ noiseInitiate()

void InDet::SiTrajectoryElement_xk::noiseInitiate ( )

Definition at line 2239 of file SiTrajectoryElement_xk.cxx.

2240 {
2241  m_noisemodel = 1; m_noise.initiate();
2242 }

◆ noiseModel()

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

Definition at line 63 of file SiTrajectoryElement_xk.h.

63 {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.

1122 {
1123 
1124  int Model = m_noisemodel;
1125  if(Model < 1 || Model > 2) return;
1126  if (rad_length<0.) rad_length=m_radlength;
1127 
1128  double q = useMomentum ? m_invMoment : std::abs(Tp.parameters()[4]);
1129 
1131  double s = std::abs(m_localDir[0]*m_localTransform[6]+
1132  m_localDir[1]*m_localTransform[7]+
1133  m_localDir[2]*m_localTransform[8]);
1134  if(m_tools->isITkGeometry() && !m_detelement) s = sqrt(m_localDir[0]*m_localDir[0]+m_localDir[1]*m_localDir[1]);
1135 
1136  if(m_tools->isITkGeometry()){
1137  if (s < .01) s = 100.;
1138  else s = 1./s;
1139  }
1140  else{
1141  if (s < .05) s = 20.;
1142  else s = 1./s;
1143  }
1144 
1146  m_radlengthN = s*m_radlength;
1150  double covariancePola = (134.*m_radlengthN)*(q*q);
1151  if(m_tools->isITkGeometry()){
1152  double qc = (1.+.038*log(m_radlengthN))*q;
1153  covariancePola = (185.*m_radlengthN)*qc*qc;
1154  }
1155 
1157  double d = (1.-m_localDir[2])*(1.+m_localDir[2]);
1159  if(d < 1.e-5) d = 1.e-5;
1161  double covarianceAzim = covariancePola/d;
1162 
1163  double covarianceIMom;
1164  double correctionIMom;
1165 
1167  if(Model==1) {
1169  double dp = m_energylose*q*s;
1171  covarianceIMom = (.2*dp*dp)*(q*q);
1173  correctionIMom = 1.-dp;
1174  }
1176  else {
1177  correctionIMom = .70;
1178  covarianceIMom = (correctionIMom-1.)*(correctionIMom-1.)*(q*q);
1179  }
1181  if(Dir>0) correctionIMom = 1./correctionIMom;
1183  m_noise.set(covarianceAzim,covariancePola,covarianceIMom,correctionIMom);
1184 }

◆ npixelsB()

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

Definition at line 60 of file SiTrajectoryElement_xk.h.

60 {return m_npixelsBackward; }

◆ ntsos()

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

Definition at line 67 of file SiTrajectoryElement_xk.h.

67 {return m_ntsos; }

◆ numberClusters()

int InDet::SiTrajectoryElement_xk::numberClusters ( ) const

Definition at line 2037 of file SiTrajectoryElement_xk.cxx.

2038 {
2039  int n = 0;
2040  if (m_detstatus<=0) return n;
2041 
2042  if (m_itType==PixelClusterColl) {
2043  const InDet::PixelClusterCollection::const_iterator* sibegin
2044  = std::any_cast<const InDet::PixelClusterCollection::const_iterator>(&m_sibegin);
2045  const InDet::PixelClusterCollection::const_iterator* siend
2046  = std::any_cast<const InDet::PixelClusterCollection::const_iterator>(&m_siend);
2047  if (sibegin==nullptr or siend==nullptr) return 0;
2048  for (InDet::PixelClusterCollection::const_iterator p = *sibegin; p!=*siend; ++p) {
2049  ++n;
2050  }
2051  } else if (m_itType==SCT_ClusterColl) {
2052  const InDet::SCT_ClusterCollection::const_iterator* sibegin
2053  = std::any_cast<const InDet::SCT_ClusterCollection::const_iterator>(&m_sibegin);
2054  const InDet::SCT_ClusterCollection::const_iterator* siend
2055  = std::any_cast<const InDet::SCT_ClusterCollection::const_iterator>(&m_siend);
2056  if (sibegin==nullptr or siend==nullptr) return 0;
2057  for (InDet::SCT_ClusterCollection::const_iterator p = *sibegin; p!=*siend; ++p) {
2058  ++n;
2059  }
2060  } else {
2061  const InDet::SiClusterCollection::const_iterator* sibegin
2062  = std::any_cast<const InDet::SiClusterCollection::const_iterator>(&m_sibegin);
2063  const InDet::SiClusterCollection::const_iterator* siend
2064  = std::any_cast<const InDet::SiClusterCollection::const_iterator>(&m_siend);
2065  if (sibegin==nullptr or siend==nullptr) return 0;
2066  for (InDet::SiClusterCollection::const_iterator p = *sibegin; p!=*siend; ++p) {
2067  ++n;
2068  }
2069  }
2070  return n;
2071 }

◆ operator=()

InDet::SiTrajectoryElement_xk & InDet::SiTrajectoryElement_xk::operator= ( const SiTrajectoryElement_xk &  E)

Definition at line 1977 of file SiTrajectoryElement_xk.cxx.

1979 {
1980  if(&E==this) return(*this);
1981 
1982  m_fieldMode = E.m_fieldMode ;
1983  m_status = E.m_status ;
1984  m_detstatus = E.m_detstatus ;
1985  m_inside = E.m_inside ;
1986  m_nMissing = E.m_nMissing ;
1987  m_stereo = E.m_stereo ;
1988  m_detelement = E.m_detelement ;
1989  m_detlink = E.m_detlink ;
1990  m_surface = E.m_surface ;
1991  m_sibegin = E.m_sibegin ;
1992  m_siend = E.m_siend ;
1993  m_cluster = E.m_cluster ;
1994  m_clusterOld = E.m_clusterOld ;
1995  m_clusterNoAdd = E.m_clusterNoAdd;
1996  m_parametersPredForward = E.m_parametersPredForward;
1997  m_parametersUpdatedForward = E.m_parametersUpdatedForward;
1998  m_parametersPredBackward = E.m_parametersPredBackward;
1999  m_parametersUpdatedBackward = E.m_parametersUpdatedBackward;
2000  m_parametersSM = E.m_parametersSM;
2001  m_dist = E.m_dist ;
2002  m_xi2Forward = E.m_xi2Forward ;
2003  m_xi2Backward = E.m_xi2Backward ;
2004  m_xi2totalForward = E.m_xi2totalForward ;
2005  m_xi2totalBackward = E.m_xi2totalBackward;
2006  m_radlength = E.m_radlength ;
2007  m_radlengthN = E.m_radlengthN ;
2008  m_energylose = E.m_energylose ;
2009  m_halflength = E.m_halflength ;
2010  m_step = E.m_step ;
2011  m_nlinksForward = E.m_nlinksForward ;
2012  m_nlinksBackward = E.m_nlinksBackward ;
2013  m_nholesForward = E.m_nholesForward ;
2014  m_nholesBackward = E.m_nholesBackward ;
2015  m_dholesForward = E.m_dholesForward ;
2016  m_dholesBackward = E.m_dholesBackward ;
2017  m_noisemodel = E.m_noisemodel ;
2018  m_ndf = E.m_ndf ;
2019  m_ndfForward = E.m_ndfForward ;
2020  m_ndfBackward = E.m_ndfBackward ;
2021  m_ntsos = E.m_ntsos ;
2022  m_nclustersForward = E.m_nclustersForward ;
2023  m_nclustersBackward = E.m_nclustersBackward ;
2024  m_npixelsBackward = E.m_npixelsBackward ;
2025  m_noise = E.m_noise ;
2026  m_tools = E.m_tools ;
2027  m_covariance = E.m_covariance ;
2028  m_position = E.m_position ;
2029  m_invMoment = E.m_invMoment ;
2030  for(int i=0; i!=m_nlinksForward; ++i) {m_linkForward[i]=E.m_linkForward[i];}
2031  for(int i=0; i!=m_nlinksBackward; ++i) {m_linkBackward[i]=E.m_linkBackward[i];}
2032  for(int i=0; i!=m_ntsos ; ++i) {m_tsos [i]=E.m_tsos [i];}
2033  for(int i=0; i!=m_ntsos ; ++i) {m_utsos[i]=E.m_utsos [i];}
2034  return(*this);
2035 }

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

133 {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.

129 {return m_parametersPredForward;}

◆ parametersSM()

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

Definition at line 136 of file SiTrajectoryElement_xk.h.

136 {return m_parametersSM;}

◆ parametersUB()

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

observed

Definition at line 135 of file SiTrajectoryElement_xk.h.

135 {return m_parametersUpdatedBackward;}

◆ parametersUF()

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

updated

Definition at line 131 of file SiTrajectoryElement_xk.h.

131 {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.

2278 {
2279  const Amg::MatrixX& v = c->localCovariance();
2280  if (m_tools->useFastTracking() and m_stereo) {
2281  // in fast tracking mode, endcap strip clusters use cluster covariance terms
2282  covX=v(0,0);
2283  covY=v(1,1);
2284  covXY=v(1,0);
2285  return;
2286  }
2287  covX = c->width().phiR();
2288  covX*=(covX*s_oneOverTwelve);
2289  covXY = c->localCovariance()(1,0);
2290 
2291  if(!m_tools->useFastTracking()){
2292  if(covX < v(0,0)) covX=v(0,0);
2293  covXY = 0.;
2294  }
2295 
2296  if(m_ndf==1) {
2297  covY=v(1,1);
2298  }
2299  else {
2301  covY=c->width().z();
2302  covY*=(covY*s_oneOverTwelve);
2303  if(!m_tools->useFastTracking()){
2304  if(covY < v(1,1)) covY=v(1,1);
2305  }
2306  }
2307 }

◆ precisePosCov()

void InDet::SiTrajectoryElement_xk::precisePosCov ( Trk::PatternTrackParameters &  Tc)

Definition at line 2376 of file SiTrajectoryElement_xk.cxx.

2377 {
2378 
2379  m_position = m_cluster->localPosition ();
2380  m_covariance = m_cluster->localCovariance();
2381 
2382  if(m_ndf==1) return;
2383 
2384  const Amg::Vector2D& colRow = m_cluster->width().colRow();
2385  if(colRow.x()==1. && colRow.y()==1.) return;
2386 
2387  std::unique_ptr<Trk::TrackParameters> tr = Tc.convert(true);
2388  std::unique_ptr<const Trk::RIO_OnTrack> ri(m_riotool->correct(*m_cluster, *tr, Gaudi::Hive::currentContext()));
2389 
2390  m_position = ri->localParameters();
2391  m_covariance = ri->localCovariance();
2392 
2393 }

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

1381  {
1382  if (Trk::SurfaceType::Plane == m_surface->type() and
1383  Trk::SurfaceType::Plane == startingParameters.associatedSurface().type()) {
1384  bool useJac = (startingParameters.iscovariance());
1385  double globalParameters[64];
1386 
1395  if(!transformPlaneToGlobal(useJac,startingParameters,globalParameters)) return false;
1397  if( m_fieldMode) {
1398  if(!rungeKuttaToPlane (useJac,globalParameters)) return false;
1399  }
1401  else {
1402  if(!straightLineStepToPlane(useJac,globalParameters)) return false;
1403  }
1405  StepLength = globalParameters[45];
1407  return transformGlobalToPlane(useJac,globalParameters,startingParameters,outputParameters);
1408  } else {
1409  if (!m_proptool->propagate (ctx,
1410  startingParameters, *m_surface, outputParameters,
1411  Trk::anyDirection, m_tools->fieldTool(), StepLength, Trk::pion))
1412  return false;
1413 
1414  double sinPhi,cosPhi,sinTheta,cosTheta;
1415  sincos(outputParameters.parameters()[2],&sinPhi,&cosPhi);
1416  sincos(outputParameters.parameters()[3],&sinTheta,&cosTheta);
1417  m_localDir[0] = cosPhi*sinTheta;
1418  m_localDir[1] = sinPhi*sinTheta;
1419  m_localDir[2] = cosTheta;
1420  return true;
1421  }
1422 }

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

1434  {
1435  bool useJac = false;
1436  double globalParameters[64];
1437  if(!transformPlaneToGlobal(useJac,startingParameters,globalParameters)) return false;
1447  if( m_fieldMode) {
1448  if(!rungeKuttaToPlane (useJac,globalParameters)) return false;
1449  }
1451  else {
1452  if(!straightLineStepToPlane(useJac,globalParameters)) return false;
1453  }
1455  StepLength = globalParameters[45];
1457  return transformGlobalToPlane(useJac,globalParameters,startingParameters,outputParameters);
1458 }

◆ quality()

double InDet::SiTrajectoryElement_xk::quality ( int &  holes) const

Definition at line 1348 of file SiTrajectoryElement_xk.cxx.

1349 {
1350 
1351  if(!m_cluster && !m_clusterNoAdd) {
1352 
1353  if(m_detstatus < 0) return 0.;
1354 
1355  if (m_inside < 0) {
1356  double w = 2.-m_xi2max; if(++holes > 1) w*=2.; return w;
1357  }
1358  else if(m_inside == 0) return -1.;
1359  else return 0.;
1360  }
1361 
1362  double w,X,Xc = m_xi2max+2.;
1363  m_status == 1 ? X = m_xi2Forward : X = m_xi2Backward;
1364  m_ndf == 2 ? w = 1.2*(Xc-X*.5) : w = Xc-X ; if(w < -1.) w = -1.;
1365  holes = 0;
1366 
1367  return w;
1368 }

◆ radlength()

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

Definition at line 125 of file SiTrajectoryElement_xk.h.

125 {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.

1662 {
1664  const double Smin = .1 ;
1667  const double Shel = 5. ;
1669  const double dlt = .001 ;
1670 
1672  if(std::abs(globalPars[6]) > .05) return false;
1673 
1674 
1675  int it = 0;
1676  double* R = &globalPars[ 0]; // Coordinates
1677 
1678  double* A = &globalPars[ 3]; // Directions
1679 
1680  double* sA = &globalPars[42];
1681  double Pi = 149.89626*globalPars[6];
1682  double Pa = std::abs (globalPars[6]);
1684 
1686  double a = A[0]*m_localTransform[6]+A[1]*m_localTransform[7]+A[2]*m_localTransform[8];
1687  if(a==0.) return false;
1689  double S = ((m_localTransform[12]-R[0]*m_localTransform[6])-(R[1]*m_localTransform[7]+R[2]*m_localTransform[8]))/a;
1690  double S0 = std::abs(S) ;
1691 
1695  if(S0 <= Smin) {
1696  R[0]+=(A[0]*S);
1697  R[1]+=(A[1]*S);
1698  R[2]+=(A[2]*S);
1699  globalPars[45]+=S;
1700  return true;
1701  }
1704  else if( (Pa*S0) > .3) {
1705  if (S >0) S = 0.3 / Pa;
1706  else S = -0.3/Pa;
1707  }
1708 
1709  bool ste = false;
1710 
1712  double f0[3];
1713  double f[3];
1714 
1716  m_fieldCache.getFieldZR(R,f0);
1717 
1718 
1719  while(true) {
1720 
1721  bool Helix = false;
1723  if(std::abs(S) < Shel) Helix = true;
1724  double S3=(1./3.)*S;
1725  double S4=.25*S;
1726  double PS2=Pi*S;
1727 
1730  double H0[3] = {f0[0]*PS2,
1731  f0[1]*PS2,
1732  f0[2]*PS2};
1733 
1734  double A0 = A[1]*H0[2]-A[2]*H0[1] ;
1735  double B0 = A[2]*H0[0]-A[0]*H0[2] ;
1736  double C0 = A[0]*H0[1]-A[1]*H0[0] ;
1737 
1738  double A2 = A0+A[0] ;
1739  double B2 = B0+A[1] ;
1740  double C2 = C0+A[2] ;
1741 
1742  double A1 = A2+A[0] ;
1743  double B1 = B2+A[1] ;
1744  double C1 = C2+A[2] ;
1745 
1746  // Second point
1747  //
1748  if(!Helix) {
1749  double gP[3]={R[0]+A1*S4,
1750  R[1]+B1*S4,
1751  R[2]+C1*S4};
1752 
1753  m_fieldCache.getFieldZR(gP,f);
1754 
1755  }
1757  else {
1758  f[0]=f0[0];
1759  f[1]=f0[1];
1760  f[2]=f0[2];
1761  }
1762 
1763  double H1[3] = {f[0]*PS2,
1764  f[1]*PS2,
1765  f[2]*PS2};
1766  double A3 = (A[0]+B2*H1[2])-C2*H1[1] ;
1767  double B3 = (A[1]+C2*H1[0])-A2*H1[2] ;
1768  double C3 = (A[2]+A2*H1[1])-B2*H1[0] ;
1769 
1770  double A4 = (A[0]+B3*H1[2])-C3*H1[1] ;
1771  double B4 = (A[1]+C3*H1[0])-A3*H1[2] ;
1772  double C4 = (A[2]+A3*H1[1])-B3*H1[0] ;
1773 
1774  double A5 = 2.*A4-A[0] ;
1775  double B5 = 2.*B4-A[1] ;
1776  double C5 = 2.*C4-A[2] ;
1777 
1778  // Last point
1779  //
1780  if(!Helix) {
1781  double gP[3]={R[0]+S*A4,
1782  R[1]+S*B4,
1783  R[2]+S*C4};
1784 
1785  m_fieldCache.getFieldZR(gP,f);
1786 
1787  }
1788  else{
1789  f[0]=f0[0];
1790  f[1]=f0[1];
1791  f[2]=f0[2];
1792  }
1793 
1794  double H2[3] = {f[0]*PS2,
1795  f[1]*PS2,
1796  f[2]*PS2};
1797 
1798  double A6 = B5*H2[2]-C5*H2[1] ;
1799  double B6 = C5*H2[0]-A5*H2[2] ;
1800  double C6 = A5*H2[1]-B5*H2[0] ;
1801 
1802  // Test approximation quality on give step and possible step reduction
1803  //
1804  if(!ste) {
1805  double EST = std::abs((A1+A6)-(A3+A4))+std::abs((B1+B6)-(B3+B4))+std::abs((C1+C6)-(C3+C4));
1806  if(EST>dlt) {
1807  S*=.6;
1808  continue;
1809  }
1810  }
1811 
1814  if((!ste && S0 > std::abs(S)*100.) || std::abs(globalPars[45]+=S) > 2000.) return false;
1815  ste = true;
1816 
1817  double A0arr[3]{A0,B0,C0};
1818  double A3arr[3]{A3,B3,C3};
1819  double A4arr[3]{A4,B4,C4};
1820  double A6arr[3]{A6,B6,C6};
1821 
1822  if(Jac) {
1823  Trk::propJacobian(globalPars,H0,H1,H2,A,A0arr,A3arr,A4arr,A6arr,S3);
1824  }
1825 
1826  R[0]+=(A2+A3+A4)*S3;
1827  A[0] = ((A0+2.*A3)+(A5+A6));
1828  R[1]+=(B2+B3+B4)*S3;
1829  A[1] = ((B0+2.*B3)+(B5+B6));
1830  R[2]+=(C2+C3+C4)*S3;
1831  A[2] = ((C0+2.*C3)+(C5+C6));
1832  if(!m_tools->isITkGeometry()){
1833  A[0] *= 1./3.;
1834  A[1] *= 1./3.;
1835  A[2] *= 1./3.;
1836  }
1837 
1838  double D = 1./sqrt(A[0]*A[0]+A[1]*A[1]+A[2]*A[2]);
1839  A[0]*=D; A[1]*=D; A[2]*=D;
1840 
1843  double a = A[0]*m_localTransform[6]+A[1]*m_localTransform[7]+A[2]*m_localTransform[8];
1844  if(a==0.) return false;
1845  double Sn = ((m_localTransform[12]-R[0]*m_localTransform[6])-(R[1]*m_localTransform[7]+R[2]*m_localTransform[8]))/a;
1846  double aSn = std::abs(Sn);
1847 
1850  if(aSn <= Smin) {
1851  double Sl = 2./S;
1852  sA[0] = A6*Sl;
1853  sA[1] = B6*Sl;
1854  sA[2] = C6*Sl;
1855 
1856  R[0]+=(A[0]*Sn);
1857  R[1]+=(A[1]*Sn);
1858  R[2]+=(A[2]*Sn);
1859  globalPars[45]+=Sn;
1860 
1861  return true;
1862  }
1863 
1864  double aS = std::abs(S);
1865 
1867  if ( S*Sn < 0. ) {
1868  if(++it > 2) return false;
1870  if (aSn < aS) S = Sn;
1872  else S =-S;
1873  }
1875  else if( aSn < aS ) S = Sn;
1876 
1878  f0[0]=f[0];
1879  f0[1]=f[1];
1880  f0[2]=f[2];
1881  }
1882  return false;
1883 }

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

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

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

2131 {
2132  m_cluster = Cl;
2133 }

◆ setClusterB()

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

Definition at line 2135 of file SiTrajectoryElement_xk.cxx.

2136 {
2137  m_cluster = Cl ;
2138  m_status = 2 ;
2139  m_xi2Backward = Xi2;
2140 }

◆ setDead()

bool InDet::SiTrajectoryElement_xk::setDead ( const Trk::Surface *  SU)

Definition at line 29 of file SiTrajectoryElement_xk.cxx.

30 {
31  m_fieldMode = false;
32  if(m_tools->fieldTool().magneticFieldMode()!=0) m_fieldMode = true;
33  m_status = 0 ;
34  m_detstatus = 0 ;
35  m_nMissing = 0 ;
36  m_nlinksForward = 0 ;
37  m_nlinksBackward = 0 ;
38  m_nholesForward = 0 ;
39  m_nholesBackward = 0 ;
40  m_dholesForward = 0 ;
41  m_dholesBackward = 0 ;
42  m_nclustersForward = 0 ;
43  m_nclustersBackward = 0 ;
44  m_npixelsBackward = 0 ;
45  m_ndfForward = 0 ;
46  m_ndfBackward = 0 ;
47  m_ntsos = 0 ;
48  m_detelement = nullptr ;
49  m_detlink = nullptr ;
50  m_surface = SU ;
51  m_cluster = nullptr ;
52  m_clusterOld = nullptr ;
53  m_clusterNoAdd = nullptr ;
54  noiseInitiate() ;
55  m_radlength = -1. ;
56  m_inside = -1 ;
57  m_localDir[0] = 1.;
58  m_localDir[1] = 0.;
59  m_localDir[2] = 0.;
60  return true;
61 }

◆ setDeadRadLength()

void InDet::SiTrajectoryElement_xk::setDeadRadLength ( Trk::PatternTrackParameters &  Tp)

Definition at line 68 of file SiTrajectoryElement_xk.cxx.

69 {
70  if(m_radlength >= 0.) return;
71  double z = std::abs(Tp.parameters()[1]);
72  if (z < 50.) m_radlength = .0075;
73  else if(z < 205.) m_radlength = .02;
74  else if(z < 360.) m_radlength = .03+(z-205.)*0.000129032;
75  else if(z < 570.) m_radlength = .035+(z-360.)*9.04762e-05;
76  else if(z < 1500.) m_radlength = .054+(z-570.)*1.82796e-05;
77  else if(z < 2400.) m_radlength = .071+(z-1500.)*7.14286e-06;
78  else m_radlength = .078;
79 
80 }

◆ setNdist()

void InDet::SiTrajectoryElement_xk::setNdist ( int  n)

Definition at line 2153 of file SiTrajectoryElement_xk.cxx.

2154 {
2155  m_nMissing = n;
2156 }

◆ setParameters()

void InDet::SiTrajectoryElement_xk::setParameters ( )

Definition at line 98 of file SiTrajectoryElement_xk.cxx.

99 {
100  m_maxholes = m_tools->maxholes () ;
101  m_maxdholes = m_tools->maxdholes () ;
102  m_xi2max = m_tools->xi2max () ;
103  m_xi2maxNoAdd = m_tools->xi2maxNoAdd() ;
104  m_xi2maxlink = m_tools->xi2maxlink () ;
105  m_xi2multi = m_tools->xi2multi () ;
106 }

◆ setParametersB()

void InDet::SiTrajectoryElement_xk::setParametersB ( Trk::PatternTrackParameters &  P)

Definition at line 2143 of file SiTrajectoryElement_xk.cxx.

2144 {
2145  m_parametersUpdatedBackward = P;
2146 }

◆ setParametersF()

void InDet::SiTrajectoryElement_xk::setParametersF ( Trk::PatternTrackParameters &  P)

Definition at line 2148 of file SiTrajectoryElement_xk.cxx.

2149 {
2150  m_parametersUpdatedForward = P;
2151 }

◆ setTools()

void InDet::SiTrajectoryElement_xk::setTools ( const InDet::SiTools_xk *  t)

Definition at line 87 of file SiTrajectoryElement_xk.cxx.

88 {
89  m_tools = t ;
90  m_prdToTrackMap= m_tools->PRDtoTrackMap();
91  m_useassoTool = m_tools->usePRDtoTrackAssociation() ;
92  m_updatorTool = m_tools->updatorTool ();
93  m_proptool = m_tools->propTool ();
94  m_riotool = m_tools->rioTool ();
95  m_tools->fieldCondObj()->getInitializedCache (m_fieldCache);
96 }

◆ status()

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

Definition at line 62 of file SiTrajectoryElement_xk.h.

62 {return m_status; }

◆ step() [1/2]

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

Definition at line 68 of file SiTrajectoryElement_xk.h.

68 {return m_step; }

◆ step() [2/2]

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

Definition at line 1256 of file SiTrajectoryElement_xk.cxx.

1258 {
1259  Trk::PatternTrackParameters Ta,Tb;
1260 
1261  if (TE.m_status == 1) {
1262  if(TE.m_cluster) Ta = TE.m_parametersUpdatedForward;
1263  else Ta = TE.m_parametersPredForward;
1264  }
1265  else if(TE.m_status == 2) {
1266  if(TE.m_cluster) Ta = TE.m_parametersUpdatedBackward;
1267  else Ta = TE.m_parametersPredBackward;
1268  }
1269  else if(TE.m_status == 3) {
1270  Ta = TE.m_parametersSM;
1271  }
1272  double step = 0.;
1273  bool Q = propagateParameters(Ta,Tb,step);
1274  if(Q) return step;
1275  return 0.;
1276 }

◆ stepToPerigee()

double InDet::SiTrajectoryElement_xk::stepToPerigee ( )

Definition at line 1315 of file SiTrajectoryElement_xk.cxx.

1316 {
1317  Amg::Vector3D M;
1318  Amg::Vector3D P;
1319 
1320  if(m_cluster) {
1321  M = m_parametersUpdatedBackward.momentum();
1322  P = m_parametersUpdatedBackward.position();
1323  }
1324  else {
1325  M = m_parametersPredBackward.momentum();
1326  P = m_parametersPredBackward.position();
1327  }
1328 
1329  return -(P[0]*M[0]+P[1]*M[1]);
1330 }

◆ stereo()

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

Definition at line 61 of file SiTrajectoryElement_xk.h.

61 {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.

1891 {
1892  double* R = &globalPars[ 0]; // Start coordinates
1893  double* A = &globalPars[ 3]; // Start directions
1895  double a = A[0]*m_localTransform[6]+A[1]*m_localTransform[7]+A[2]*m_localTransform[8];
1896  if(a==0.) return false;
1897  double S = ((m_localTransform[12]-R[0]*m_localTransform[6])-(R[1]*m_localTransform[7]+R[2]*m_localTransform[8]))/a;
1898  globalPars[45] = S;
1899 
1900  // Track parameters in last point
1901  //
1902  R[0]+=(A[0]*S); R[1]+=(A[1]*S); R[2]+=(A[2]*S); if(!Jac) return true;
1903 
1904  // Derivatives of track parameters in last point
1905  //
1906  for(int i=7; i<42; i+=7) {
1907 
1908  double* dR = &globalPars[i ];
1909  double* dA = &globalPars[i+3];
1910  dR[0]+=(dA[0]*S); dR[1]+=(dA[1]*S); dR[2]+=(dA[2]*S);
1911  }
1912  return true;
1913 }

◆ surface()

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

Definition at line 144 of file SiTrajectoryElement_xk.h.

144 {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.

1072 {
1073  if (m_status == 1) {
1074  if (m_cluster) {
1075  return m_parametersUpdatedForward.convert(cov);
1076  } else {
1077  return m_parametersPredForward.convert(cov);
1078  }
1079  } else if (m_status == 2) {
1080  if (m_cluster) {
1081  return m_parametersUpdatedBackward.convert(cov);
1082  } else {
1083  return m_parametersPredBackward.convert(cov);
1084  }
1085  } else if (m_status == 3) {
1086  if (Q == 0) {
1087  if (m_cluster) {
1088  if (addCluster(m_parametersSM, m_parametersSM)) {
1089  return m_parametersSM.convert(cov);
1090  } else if ((*m_parametersUpdatedBackward.covariance())(4, 4) <
1091  (*m_parametersPredForward.covariance())(4, 4)) {
1092  return m_parametersUpdatedBackward.convert(cov);
1093  } else {
1094  return m_parametersPredForward.convert(cov);
1095  }
1096  } else
1097  return m_parametersSM.convert(cov);
1098  }
1099  if (Q == 1) {
1100  if (m_cluster) {
1101  return m_parametersUpdatedBackward.convert(cov);
1102  }
1103  }
1104  if (Q == 2) {
1105  if (m_cluster) {
1106  return m_parametersUpdatedForward.convert(cov);
1107  }
1108  }
1109  }
1110  return nullptr;
1111 }

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

1246 {
1247  Tp.changeDirection();
1248  return Tp.convert(cov);
1249 }

◆ trackParametersWithNewDirection()

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

Definition at line 1195 of file SiTrajectoryElement_xk.cxx.

1196 {
1197  if (m_status == 1) {
1198  if (m_cluster) {
1199  return trackParameters(m_parametersUpdatedForward, cov);
1200  } else {
1201  return trackParameters(m_parametersPredForward, cov);
1202  }
1203 
1204  } else if (m_status == 2) {
1205  if (m_cluster) {
1206  return trackParameters(m_parametersUpdatedBackward, cov);
1207  } else {
1208  return trackParameters(m_parametersPredBackward, cov);
1209  }
1210  } else if (m_status == 3) {
1211 
1212  if (Q == 0) {
1213  if (m_cluster) {
1214  if (addCluster(m_parametersSM, m_parametersSM))
1215  return trackParameters(m_parametersSM, cov);
1216  else if ((*m_parametersUpdatedBackward.covariance())(4, 4) <
1217  (*m_parametersPredForward.covariance())(4, 4)) {
1218  return trackParameters(m_parametersUpdatedBackward, cov);
1219  } else {
1220  return trackParameters(m_parametersPredForward, cov);
1221  }
1222  } else {
1223  return trackParameters(m_parametersSM, cov);
1224  }
1225  }
1226  if (Q == 1) {
1227  if (m_cluster){
1228  return trackParameters(m_parametersUpdatedBackward, cov);
1229  }
1230  }
1231  if (Q == 2) {
1232  if (m_cluster){
1233  return trackParameters(m_parametersUpdatedForward, cov);
1234  }
1235  }
1236  }
1237  return nullptr;
1238 }

◆ trackPerigeeStateOnSurface()

Trk::TrackStateOnSurface * InDet::SiTrajectoryElement_xk::trackPerigeeStateOnSurface ( const EventContext &  ctx)

Definition at line 1042 of file SiTrajectoryElement_xk.cxx.

1043 {
1044  if(&m_parametersUpdatedBackward.associatedSurface()!=m_surface) return nullptr;
1045 
1046  double step ;
1047  Trk::PatternTrackParameters Tp;
1048 
1049  Trk::PerigeeSurface per;
1050 
1051  bool Q = m_proptool->propagate
1052  (ctx,
1053  m_parametersUpdatedBackward, per,Tp,Trk::anyDirection,m_tools->fieldTool(),step,Trk::pion);
1054 
1055  if(Q) {
1056  std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
1057  typePattern.set(Trk::TrackStateOnSurface::Perigee);
1058  return new Trk::TrackStateOnSurface(nullptr,Tp.convert(true),nullptr,typePattern);
1059  }
1060  return nullptr;
1061 }

◆ trackSimpleStateOnSurface()

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

Definition at line 979 of file SiTrajectoryElement_xk.cxx.

981 {
982  if(!m_detelement) {
983  return nullptr;
984  }
985 
986  std::unique_ptr<Trk::TrackParameters> tp = nullptr;
987 
988  if (Q) {
989  if (!change) {
990  tp = trackParameters(cov, Q);
991  } else {
992  tp = trackParametersWithNewDirection(cov, Q);
993  }
994  if (!tp) {
995  return nullptr;
996  }
997  if (&tp->associatedSurface() != m_surface) {
998  return nullptr;
999  }
1000  }
1001 
1002  IdentifierHash iH = m_detelement->identifyHash();
1003  std::unique_ptr<Trk::MeasurementBase> ro{};
1004  std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> pat(
1005  0);
1006 
1007  const InDet::SiCluster* cl = nullptr;
1008  if (m_cluster) {
1009  cl = m_cluster;
1010  pat.set(Trk::TrackStateOnSurface::Measurement);
1011  } else {
1012  cl = m_clusterNoAdd;
1013  pat.set(Trk::TrackStateOnSurface::Outlier);
1014  }
1015  pat.set(Trk::TrackStateOnSurface::Scatterer);
1016 
1017  Trk::LocalParameters locp = Trk::LocalParameters(cl->localPosition());
1018  Amg::MatrixX cv = cl->localCovariance();
1019 
1020  Trk::FitQualityOnSurface fq{};
1021  if (m_status == 1) fq = Trk::FitQualityOnSurface(m_xi2Forward,m_ndf);
1022  else fq = Trk::FitQualityOnSurface(m_xi2Backward,m_ndf);
1023 
1024  if (m_ndf == 1) {
1025  const InDet::SCT_Cluster* sc = static_cast<const InDet::SCT_Cluster*>(cl);
1026  if (sc)
1027  ro = std::make_unique<InDet::SCT_ClusterOnTrack>(sc, std::move(locp), std::move(cv), iH, sc->globalPosition());
1028  } else {
1029  const InDet::PixelCluster* pc = static_cast<const InDet::PixelCluster*>(cl);
1030  if (pc)
1031  ro = std::make_unique<InDet::PixelClusterOnTrack>(
1032  pc, std::move(locp), std::move(cv), iH, pc->globalPosition(), pc->gangedPixel());
1033  }
1034  return new Trk::TrackStateOnSurface(fq, std::move(ro), std::move(tp), nullptr, pat);
1035 }

◆ trackStateOnSurface()

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

Definition at line 902 of file SiTrajectoryElement_xk.cxx.

903 {
904  std::unique_ptr<Trk::TrackParameters> tp = nullptr;
905  if (!change) {
906  tp = trackParameters(cov, Q);
907  } else {
908  tp = trackParametersWithNewDirection(cov, Q);
909  }
910  if (!tp) {
911  return nullptr;
912  }
913  if (&tp->associatedSurface() != m_surface) {
914  return nullptr;
915  }
916 
917  Trk::FitQualityOnSurface fq{};
918  std::unique_ptr<Trk::MeasurementBase> ro{};
919 
920  if (m_status == 1) {
921  fq = Trk::FitQualityOnSurface(m_xi2Forward, m_ndf);
922  } else {
923  fq = Trk::FitQualityOnSurface(m_xi2Backward, m_ndf);
924  }
925 
926  std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> pat(
927  0);
928 
929  if (m_cluster) {
930  ro.reset(m_riotool->correct(*m_cluster, *tp, Gaudi::Hive::currentContext()));
931  pat.set(Trk::TrackStateOnSurface::Measurement);
932  } else {
933  ro.reset(m_riotool->correct(*m_clusterNoAdd, *tp, Gaudi::Hive::currentContext()));
934  pat.set(Trk::TrackStateOnSurface::Outlier);
935  }
936  auto sa = Trk::ScatteringAngles(
937  0., 0., std::sqrt(m_noise.covarianceAzim()), std::sqrt(m_noise.covariancePola()));
938 
939  auto meTemplate = std::make_unique<Trk::MaterialEffectsOnTrack>(
940  m_radlengthN, sa, tp->associatedSurface());
941 
942  pat.set(Trk::TrackStateOnSurface::Scatterer);
943  Trk::TrackStateOnSurface* sos =
944  new Trk::TrackStateOnSurface(fq, std::move(ro), std::move(tp), meTemplate->uniqueClone(), pat);
945 
946  m_tsos[0] = sos;
947  m_utsos[0] = true;
948  m_ntsos = 1;
949 
950  if (multi && m_cluster && m_ndf == 2 && m_nlinksBackward > 1) {
951  for(int i=1; i!= m_nlinksBackward; ++i) {
952  if(m_linkBackward[i].xi2() > m_xi2multi) break;
953  std::unique_ptr<Trk::TrackParameters> tpn{};
954  if (!change) {
955  tpn = trackParameters(cov, Q);
956  } else {
957  tpn = trackParametersWithNewDirection(cov, Q);
958  }
959  if (!tpn){
960  break;
961  }
962  auto fqn = Trk::FitQualityOnSurface(m_linkBackward[i].xi2(),m_ndf);
963  std::unique_ptr<Trk::MeasurementBase> ron(m_riotool->correct(
964  *m_linkBackward[i].cluster(), *(sos->trackParameters()), Gaudi::Hive::currentContext()) );
965  m_tsos[m_ntsos] = new Trk::TrackStateOnSurface(
966  fqn, std::move(ron), std::move(tpn), meTemplate->uniqueClone(), pat);
967  m_utsos[m_ntsos] = false;
968  if(++m_ntsos == 3) break;
969  }
970  }
971  return sos;
972 }

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

1553 {
1555  double Ax[3] = {m_localTransform[0],m_localTransform[1],m_localTransform[2]};
1556  double Ay[3] = {m_localTransform[3],m_localTransform[4],m_localTransform[5]};
1557  double Az[3] = {m_localTransform[6],m_localTransform[7],m_localTransform[8]};
1559  double d [3] = {globalPars[0]-m_localTransform[ 9],
1560  globalPars[1]-m_localTransform[10],
1561  globalPars[2]-m_localTransform[11]};
1562 
1564  double p[5] = {
1565  d[0]*Ax[0]+d[1]*Ax[1]+d[2]*Ax[2],
1566  d[0]*Ay[0]+d[1]*Ay[1]+d[2]*Ay[2],
1567  atan2(globalPars[4],globalPars[3]),
1568  acos(globalPars[5]),
1569  globalPars[6]
1570  };
1571 
1573  m_localDir[0] = globalPars[3];
1574  m_localDir[1] = globalPars[4];
1575  m_localDir[2] = globalPars[5];
1576 
1577  if (useJac) {
1579  double A = Az[0]*globalPars[3]+Az[1]*globalPars[4]+Az[2]*globalPars[5];
1580  if(A!=0.) A=1./A;
1581  double s0 = Az[0]*globalPars[ 7]+Az[1]*globalPars[ 8]+Az[2]*globalPars[ 9];
1582  double s1 = Az[0]*globalPars[14]+Az[1]*globalPars[15]+Az[2]*globalPars[16];
1583  double s2 = Az[0]*globalPars[21]+Az[1]*globalPars[22]+Az[2]*globalPars[23];
1584  double s3 = Az[0]*globalPars[28]+Az[1]*globalPars[29]+Az[2]*globalPars[30];
1585  double s4 = Az[0]*globalPars[35]+Az[1]*globalPars[36]+Az[2]*globalPars[37];
1586  double T0 =(Ax[0]*globalPars[ 3]+Ax[1]*globalPars[ 4]+Ax[2]*globalPars[ 5])*A;
1587  double T1 =(Ay[0]*globalPars[ 3]+Ay[1]*globalPars[ 4]+Ay[2]*globalPars[ 5])*A;
1588  double n = 1./globalPars[6];
1589 
1590  double Jac[21];
1591 
1592  // Jacobian production
1593  //
1594  Jac[ 0] = (Ax[0]*globalPars[ 7]+Ax[1]*globalPars[ 8])+(Ax[2]*globalPars[ 9]-s0*T0); // dL0/dL0
1595  Jac[ 1] = (Ax[0]*globalPars[14]+Ax[1]*globalPars[15])+(Ax[2]*globalPars[16]-s1*T0); // dL0/dL1
1596  Jac[ 2] = (Ax[0]*globalPars[21]+Ax[1]*globalPars[22])+(Ax[2]*globalPars[23]-s2*T0); // dL0/dPhi
1597  Jac[ 3] = (Ax[0]*globalPars[28]+Ax[1]*globalPars[29])+(Ax[2]*globalPars[30]-s3*T0); // dL0/dThe
1598  Jac[ 4] =((Ax[0]*globalPars[35]+Ax[1]*globalPars[36])+(Ax[2]*globalPars[37]-s4*T0))*n; // dL0/dCM
1599 
1600  Jac[ 5] = (Ay[0]*globalPars[ 7]+Ay[1]*globalPars[ 8])+(Ay[2]*globalPars[ 9]-s0*T1); // dL1/dL0
1601  Jac[ 6] = (Ay[0]*globalPars[14]+Ay[1]*globalPars[15])+(Ay[2]*globalPars[16]-s1*T1); // dL1/dL1
1602  Jac[ 7] = (Ay[0]*globalPars[21]+Ay[1]*globalPars[22])+(Ay[2]*globalPars[23]-s2*T1); // dL1/dPhi
1603  Jac[ 8] = (Ay[0]*globalPars[28]+Ay[1]*globalPars[29])+(Ay[2]*globalPars[30]-s3*T1); // dL1/dThe
1604  Jac[ 9] =((Ay[0]*globalPars[35]+Ay[1]*globalPars[36])+(Ay[2]*globalPars[37]-s4*T1))*n; // dL1/dCM
1605 
1606  double P3=0;
1607  double P4=0;
1609  double C = globalPars[3]*globalPars[3]+globalPars[4]*globalPars[4];
1610  if(C > 1.e-20) {
1611  C= 1./C ;
1613  P3 = globalPars[3]*C;
1614  P4 =globalPars[4]*C;
1615  C =-sqrt(C);
1616  }
1617  else{
1618  C=-1.e10;
1619  P3 = 1.;
1620  P4 =0.;
1621  }
1622 
1623  double T2 =(P3*globalPars[43]-P4*globalPars[42])*A;
1624  double C44 = C*globalPars[44] *A;
1625 
1626  Jac[10] = P3*globalPars[11]-P4*globalPars[10]-s0*T2; // dPhi/dL0
1627  Jac[11] = P3*globalPars[18]-P4*globalPars[17]-s1*T2; // dPhi/dL1
1628  Jac[12] = P3*globalPars[25]-P4*globalPars[24]-s2*T2; // dPhi/dPhi
1629  Jac[13] = P3*globalPars[32]-P4*globalPars[31]-s3*T2; // dPhi/dThe
1630  Jac[14] =(P3*globalPars[39]-P4*globalPars[38]-s4*T2)*n; // dPhi/dCM
1631 
1632  Jac[15] = C*globalPars[12]-s0*C44; // dThe/dL0
1633  Jac[16] = C*globalPars[19]-s1*C44; // dThe/dL1
1634  Jac[17] = C*globalPars[26]-s2*C44; // dThe/dPhi
1635  Jac[18] = C*globalPars[33]-s3*C44; // dThe/dThe
1636  Jac[19] =(C*globalPars[40]-s4*C44)*n; // dThe/dCM
1637  Jac[20] = 1.; // dCM /dCM
1638 
1640  AmgSymMatrix(5) newCov = Trk::RungeKuttaUtils::newCovarianceMatrix(Jac, *startingParameters.covariance());
1641  outputParameters.setParametersWithCovariance(m_surface, p, newCov);
1642 
1644  const AmgSymMatrix(5) & t = *outputParameters.covariance();
1645  if(t(0, 0)<=0. || t(1, 1)<=0. || t(2, 2)<=0. || t(3, 3)<=0. || t(4, 4)<=0.) return false;
1646  } else {
1648  outputParameters.setParameters(m_surface,p);
1649  }
1650 
1651  return true;
1652 }

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

1478  {
1480  double sinPhi,cosPhi,cosTheta,sintheta;
1481  sincos(localParameters.parameters()[2],&sinPhi,&cosPhi);
1482  sincos(localParameters.parameters()[3],&sintheta,&cosTheta);
1483  if (m_tools->isITkGeometry()) {
1484  if(std::abs(sintheta) < std::abs(localParameters.parameters()[4])*50.) return false;
1485  }
1487  const Trk::Surface* pSurface=&localParameters.associatedSurface();
1488  if (!pSurface){
1489  throw(std::runtime_error("TrackParameters associated surface is null pointer in InDet::SiTrajectoryElement_xk::transformPlaneToGlobal"));
1490  }
1492  const Amg::Transform3D& T = pSurface->transform();
1493 
1495  double Ax[3] = {T(0,0),T(1,0),T(2,0)};
1496  double Ay[3] = {T(0,1),T(1,1),T(2,1)};
1497 
1499  globalPars[ 0] = localParameters.parameters()[0]*Ax[0]+localParameters.parameters()[1]*Ay[0]+T(0,3); // X
1500  globalPars[ 1] = localParameters.parameters()[0]*Ax[1]+localParameters.parameters()[1]*Ay[1]+T(1,3); // Y
1501  globalPars[ 2] = localParameters.parameters()[0]*Ax[2]+localParameters.parameters()[1]*Ay[2]+T(2,3); // Z
1503  globalPars[ 3] = cosPhi*sintheta; // Ax
1504  globalPars[ 4] = sinPhi*sintheta; // Ay
1505  globalPars[ 5] = cosTheta;
1507  globalPars[ 6] = localParameters.parameters()[4]; // CM
1509  if(std::abs(globalPars[6])<1.e-20) {
1510  if (globalPars[6] < 0){
1511  globalPars[6]=-1.e-20;
1512  }
1513  else globalPars[6]= 1.e-20;
1514  }
1515 
1517  if(useJac) {
1518 
1519  // /dL1 | /dL2 | /dPhi | /dThe | /dCM |
1520  globalPars[ 7] = Ax[0]; globalPars[14] = Ay[0]; globalPars[21] = 0.; globalPars[28] = 0.; globalPars[35] = 0.; // dX /
1521  globalPars[ 8] = Ax[1]; globalPars[15] = Ay[1]; globalPars[22] = 0.; globalPars[29] = 0.; globalPars[36] = 0.; // dY /
1522  globalPars[ 9] = Ax[2]; globalPars[16] = Ay[2]; globalPars[23] = 0.; globalPars[30] = 0.; globalPars[37] = 0.; // dZ /
1523  globalPars[10] = 0.; globalPars[17] = 0.; globalPars[24] =-globalPars[4]; globalPars[31] = cosPhi*cosTheta; globalPars[38] = 0.; // dAx/
1524  globalPars[11] = 0.; globalPars[18] = 0.; globalPars[25] = globalPars[3]; globalPars[32] = sinPhi*cosTheta; globalPars[39] = 0.; // dAy/
1525  globalPars[12] = 0.; globalPars[19] = 0.; globalPars[26] = 0.; globalPars[33] = -sintheta; globalPars[40] = 0.; // dAz/
1526 
1528  globalPars[42] = 0.;
1529  globalPars[43] = 0.;
1530  globalPars[44] = 0.;
1531  }
1533  globalPars[45] = 0.;
1534  return true;
1535 }

◆ tsos()

Trk::TrackStateOnSurface * InDet::SiTrajectoryElement_xk::tsos ( int  i)

Definition at line 2318 of file SiTrajectoryElement_xk.cxx.

2319 {
2320  if(i<0 || i>2) return nullptr;
2321 
2322  bool us = m_utsos[i];
2323  m_utsos[i] = true;
2324 
2325  if(us) return new Trk::TrackStateOnSurface(*m_tsos[i]);
2326 
2327  return m_tsos[i];
2328 }

◆ xi2B()

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

Definition at line 122 of file SiTrajectoryElement_xk.h.

122 {return m_xi2Backward ;}

◆ xi2F()

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

Definition at line 121 of file SiTrajectoryElement_xk.h.

121 {return m_xi2Forward ;}

◆ xi2totalB()

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

Definition at line 124 of file SiTrajectoryElement_xk.h.

124 {return m_xi2totalBackward ;}

◆ xi2totalF()

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

Definition at line 123 of file SiTrajectoryElement_xk.h.

123 {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.

◆ 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

constexpr double InDet::SiTrajectoryElement_xk::s_oneOverTwelve {0.08333}
staticconstexprprivate

Definition at line 526 of file SiTrajectoryElement_xk.h.

The documentation for this class was generated from the following files:
InDet::SiTrajectoryElement_xk::addClusterPrecise
bool addClusterPrecise(Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, double &)
Definition: SiTrajectoryElement_xk.cxx:2211
Trk::NoiseOnSurface::covariancePola
const double & covariancePola() const
Definition: NoiseOnSurface.h:40
InDet::SiTrajectoryElement_xk::m_xi2Forward
double m_xi2Forward
Definition: SiTrajectoryElement_xk.h:463
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
make_hlt_rep.pars
pars
Definition: make_hlt_rep.py:90
Trk::LocalParameters
Definition: LocalParameters.h:98
Trk::TrackStateOnSurface::trackParameters
const TrackParameters * trackParameters() const
return ptr to trackparameters const overload
InDet::SiTrajectoryElement_xk::step
const double & step() const
Definition: SiTrajectoryElement_xk.h:68
InDet::SiTrajectoryElement_xk::rungeKuttaToPlane
bool rungeKuttaToPlane(bool updateJacobian, double *globalPars)
Runge Kutta step to plane Updates the "globalPars" array, which is also used to pass the input.
Definition: SiTrajectoryElement_xk.cxx:1661
TileDCSDataPlotter.dp
dp
Definition: TileDCSDataPlotter.py:840
ReadCellNoiseFromCoolCompare.s1
s1
Definition: ReadCellNoiseFromCoolCompare.py:378
Trk::NoiseOnSurface::correctionIMom
const double & correctionIMom() const
Definition: NoiseOnSurface.h:42
Trk::TrackStateOnSurface::Perigee
@ Perigee
This represents a perigee, and so will contain a Perigee object only.
Definition: TrackStateOnSurface.h:117
S1
struct TBPatternUnitContext S1
Trk::IRIO_OnTrackCreator::correct
virtual RIO_OnTrack * correct(const PrepRawData &hit, const TrackParameters &trk, const EventContext &ctx) const =0
abstract base method for the creation of RIO_OnTrack it takes a RIO (PrepRawData) and the given Track...
InDet::SiTrajectoryElement_xk::m_nholesForward
int m_nholesForward
Definition: SiTrajectoryElement_xk.h:448
InDet::SiTrajectoryElement_xk::m_xi2maxNoAdd
double m_xi2maxNoAdd
Definition: SiTrajectoryElement_xk.h:473
Trk::IPatternParametersPropagator::propagate
virtual bool propagate(const ::EventContext &ctx, PatternTrackParameters &, const Surface &, PatternTrackParameters &, PropDirection, const MagneticFieldProperties &, ParticleHypothesis particle=pion) const =0
Interfaces WITH EventContext (new)
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:27
InDet::SiTrajectoryElement_xk::m_localDir
double m_localDir[3]
the transform for this element
Definition: SiTrajectoryElement_xk.h:477
InDet::SiTrajectoryElement_xk::m_energylose
double m_energylose
Definition: SiTrajectoryElement_xk.h:469
Trk::PatternTrackParameters::associatedSurface
virtual const Surface & associatedSurface() const override final
Access to the Surface associated to the Parameters.
InDet::SiTrajectoryElement_xk::transformGlobalToPlane
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,...
Definition: SiTrajectoryElement_xk.cxx:1552
InDet::SiTrajectoryElement_xk::propagateParameters
bool propagateParameters(Trk::PatternTrackParameters &startingParameters, Trk::PatternTrackParameters &outParameters, double &step)
Start from 'startingParameters', propagate to current surface.
Definition: SiTrajectoryElement_xk.cxx:1432
InDet::SiTrajectoryElement_xk::combineStates
bool combineStates(Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, Trk::PatternTrackParameters &)
Definition: SiTrajectoryElement_xk.cxx:2228
InDet::SiTrajectoryElement_xk::noiseInitiate
void noiseInitiate()
Definition: SiTrajectoryElement_xk.cxx:2239
InDet::SiTrajectoryElement_xk::m_tsos
Trk::TrackStateOnSurface * m_tsos[3]
Definition: SiTrajectoryElement_xk.h:522
MagField::AtlasFieldCache::getFieldZR
void getFieldZR(const double *ATH_RESTRICT xyz, double *ATH_RESTRICT bxyz, double *ATH_RESTRICT deriv=nullptr)
get B field valaue on the z-r plane at given position works only inside the solenoid.
Definition: AtlasFieldCache.cxx:86
InDet::SiTrajectoryElement_xk::m_nlinksForward
int m_nlinksForward
Definition: SiTrajectoryElement_xk.h:446
Trk::PerigeeSurface
Definition: PerigeeSurface.h:43
InDet::SiTrajectoryElement_xk::initiateStateWithCorrection
bool initiateStateWithCorrection(Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, Trk::PatternTrackParameters &)
Definition: SiTrajectoryElement_xk.cxx:2343
InDet::SiTrajectoryElement_xk::m_nlinksBackward
int m_nlinksBackward
Definition: SiTrajectoryElement_xk.h:447
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
Trk::oppositeMomentum
@ oppositeMomentum
Definition: PropDirection.h:21
InDet::SiTrajectoryElement_xk::m_detlink
const InDet::SiDetElementBoundaryLink_xk * m_detlink
Definition: SiTrajectoryElement_xk.h:481
InDet::SiTrajectoryElement_xk::m_status
int m_status
status flag.
Definition: SiTrajectoryElement_xk.h:442
InDetDD::holes
@ holes
Definition: InDetDD_Defs.h:17
hist_file_dump.d
d
Definition: hist_file_dump.py:137
Trk::IPatternParametersUpdator::addToState
virtual bool addToState(PatternTrackParameters &, const Amg::Vector2D &, const Amg::MatrixX &, PatternTrackParameters &) const =0
add a PRD-level local position to a track state given by pattern track pars (no chi2 calculated).
DMTest::P
P_v1 P
Definition: P.h:23
S3
struct TBPatternUnitContext S3
InDet::SiTrajectoryElement_xk::m_riotool
const Trk::IRIO_OnTrackCreator * m_riotool
Definition: SiTrajectoryElement_xk.h:519
InDet::SiTrajectoryElement_xk::m_cluster
const InDet::SiCluster * m_cluster
Definition: SiTrajectoryElement_xk.h:495
DMTest::C
C_v1 C
Definition: C.h:26
Trk::PrepRawData::localCovariance
const Amg::MatrixX & localCovariance() const
return const ref to the error matrix
skel.it
it
Definition: skel.GENtoEVGEN.py:396
plotBeamSpotVxVal.cov
cov
Definition: plotBeamSpotVxVal.py:201
InDet::SiTrajectoryElement_xk::m_covariance
Amg::MatrixX m_covariance
Definition: SiTrajectoryElement_xk.h:523
InDet::SiTrajectoryElement_xk::m_ndfForward
int m_ndfForward
Definition: SiTrajectoryElement_xk.h:457
MCP::ScaleSmearParam::s0
@ s0
ParticleTest.tp
tp
Definition: ParticleTest.py:25
Trk::ScatteringAngles
represents a deflection of the track caused through multiple scattering in material.
Definition: ScatteringAngles.h:26
Trk::PatternTrackParameters::convert
std::unique_ptr< TrackParameters > convert(bool) const
Definition: PatternTrackParameters.cxx:26
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
InDet::SiTrajectoryElement_xk::m_dist
double m_dist
Definition: SiTrajectoryElement_xk.h:462
InDet::SiTrajectoryElement_xk::addClusterPreciseWithCorrection
bool addClusterPreciseWithCorrection(Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, double &)
Definition: SiTrajectoryElement_xk.cxx:2356
ReadCellNoiseFromCoolCompare.s4
s4
Definition: ReadCellNoiseFromCoolCompare.py:381
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
Trk::propJacobian
ATH_ALWAYS_INLINE void propJacobian(double *ATH_RESTRICT P, const double *ATH_RESTRICT H0, const double *ATH_RESTRICT H1, const double *ATH_RESTRICT H2, const double *ATH_RESTRICT A, const double *ATH_RESTRICT A0, const double *ATH_RESTRICT A3, const double *ATH_RESTRICT A4, const double *ATH_RESTRICT A6, const double S3)
This provides an inline helper function for updating the jacobian during Runge-Kutta propagation.
Definition: JacobianHelper.h:41
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
InDet::SiTrajectoryElement_xk::patternCovariances
void patternCovariances(const InDet::SiCluster *, double &, double &, double &) const
Private Methods.
Definition: SiTrajectoryElement_xk.cxx:2277
PlotCalibFromCool.multi
multi
Definition: PlotCalibFromCool.py:99
InDet::SiTools_xk::PRDtoTrackMap
const Trk::PRDtoTrackMap * PRDtoTrackMap() const
Definition: SiTools_xk.h:87
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:560
Trk::IPatternParametersUpdator::addToStateOneDimension
virtual bool addToStateOneDimension(PatternTrackParameters &, const Amg::Vector2D &, const Amg::MatrixX &, PatternTrackParameters &) const =0
add an explicitly one-dimensional measurement without chi2 calculation to pattern pars.
mc.SM
SM
Definition: mc.PhPy8EG_A14NNPDF23_DY_SLQ_example.py:47
Trk::PatternTrackParameters::setParameters
void setParameters(const Surface *, const double *)
JetTiledMap::S
@ S
Definition: TiledEtaPhiMap.h:44
InDet::SiTrajectoryElement_xk::m_xi2totalBackward
double m_xi2totalBackward
Definition: SiTrajectoryElement_xk.h:466
InDet::SiTrajectoryElement_xk::parametersUB
const Trk::PatternTrackParameters & parametersUB() const
observed
Definition: SiTrajectoryElement_xk.h:135
InDet::SiTools_xk::xi2maxlink
const double & xi2maxlink() const
Definition: SiTools_xk.h:60
H2
#define H2(x, y, z)
Definition: MD5.cxx:115
InDet::SiTrajectoryElement_xk::m_maxholes
int m_maxholes
Definition: SiTrajectoryElement_xk.h:460
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:50
InDetDD::SolidStateDetectorElementBase::identifyHash
virtual IdentifierHash identifyHash() const override final
identifier hash (inline)
InDet::SiTrajectoryElement_xk::m_surface
const Trk::Surface * m_surface
Definition: SiTrajectoryElement_xk.h:482
InDet::SiTrajectoryElement_xk::m_nholesBackward
int m_nholesBackward
Definition: SiTrajectoryElement_xk.h:449
InDet::SiTrajectoryElement_xk::m_itType
IteratorType m_itType
Definition: SiTrajectoryElement_xk.h:528
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
InDet::SiTrajectoryElement_xk::m_detstatus
int m_detstatus
0 (no clusters)
Definition: SiTrajectoryElement_xk.h:443
Monitored::X
@ X
Definition: HistogramFillerUtils.h:24
InDet::SiTrajectoryElement_xk::m_inside
int m_inside
Definition: SiTrajectoryElement_xk.h:444
InDet::SiTrajectoryElement_xk::m_siend
std::any m_siend
Definition: SiTrajectoryElement_xk.h:493
Trk::TrackStateOnSurface::Outlier
@ Outlier
This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used ...
Definition: TrackStateOnSurface.h:122
dqt_zlumi_alleff_HIST.A
A
Definition: dqt_zlumi_alleff_HIST.py:110
InDet::SiTrajectoryElement_xk::m_xi2totalForward
double m_xi2totalForward
Definition: SiTrajectoryElement_xk.h:465
InDet::SiTrajectoryElement_xk::m_parametersPredBackward
Trk::PatternTrackParameters m_parametersPredBackward
For backward filtering / smoothing Predicted state, backward.
Definition: SiTrajectoryElement_xk.h:508
InDet::SiTrajectoryElement_xk::noiseProduction
void noiseProduction(int, const Trk::PatternTrackParameters &, double rad_length=-1., bool useMomentum=false)
Definition: SiTrajectoryElement_xk.cxx:1121
InDet::SiTools_xk::isITkGeometry
const bool & isITkGeometry() const
Definition: SiTools_xk.h:73
Trk::FitQualityOnSurface
Definition: FitQualityOnSurface.h:19
tools.zlumi_mc_cf.correction
def correction(mu, runmode, campaign, run=None)
Definition: zlumi_mc_cf.py:4
InDet::SiTrajectoryElement_xk::propagate
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 elemen...
Definition: SiTrajectoryElement_xk.cxx:1378
InDet::SiTrajectoryElement_xk::parametersPB
const Trk::PatternTrackParameters & parametersPB() const
predicted
Definition: SiTrajectoryElement_xk.h:133
InDet::SiTools_xk::xi2maxNoAdd
const double & xi2maxNoAdd() const
Definition: SiTools_xk.h:59
A
InDet::SiTools_xk::fieldTool
const Trk::MagneticFieldProperties & fieldTool() const
Definition: SiTools_xk.h:47
AtlasFieldCacheCondObj::getInitializedCache
void getInitializedCache(MagField::AtlasFieldCache &cache) const
get B field cache for evaluation as a function of 2-d or 3-d position.
Definition: AtlasFieldCacheCondObj.h:32
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
InDet::SiTrajectoryElement_xk::m_parametersUpdatedForward
Trk::PatternTrackParameters m_parametersUpdatedForward
Updated state, forward.
Definition: SiTrajectoryElement_xk.h:505
InDet::SiTrajectoryElement_xk::m_utsos
bool m_utsos[3]
Definition: SiTrajectoryElement_xk.h:435
InDet::SiTrajectoryElement_xk::Invalid
@ Invalid
Definition: SiTrajectoryElement_xk.h:431
InDet::SiTrajectoryElement_xk::m_localTransform
double m_localTransform[13]
Definition: SiTrajectoryElement_xk.h:476
InDet::SiTrajectoryElement_xk::m_position
Amg::Vector2D m_position
Definition: SiTrajectoryElement_xk.h:524
InDet::SiTrajectoryElement_xk::m_parametersUpdatedBackward
Trk::PatternTrackParameters m_parametersUpdatedBackward
Updated state, backward.
Definition: SiTrajectoryElement_xk.h:510
InDet::SiTrajectoryElement_xk::m_updatorTool
const Trk::IPatternParametersUpdator * m_updatorTool
Definition: SiTrajectoryElement_xk.h:517
InDet::SiTrajectoryElement_xk::m_linkForward
InDet::SiClusterLink_xk m_linkForward[10]
Definition: SiTrajectoryElement_xk.h:512
InDet::SiTools_xk::useFastTracking
const bool & useFastTracking() const
Definition: SiTools_xk.h:72
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
beamspotman.n
n
Definition: beamspotman.py:731
Trk::PatternTrackParameters::removeNoise
void removeNoise(const NoiseOnSurface &, PropDirection)
Trk::PatternTrackParameters::changeDirection
void changeDirection()
Definition: PatternTrackParameters.cxx:368
InDet::SiTrajectoryElement_xk::m_ntsos
int m_ntsos
Definition: SiTrajectoryElement_xk.h:459
InDet::SiTrajectoryElement_xk::m_detelement
const InDetDD::SiDetectorElement * m_detelement
Definition: SiTrajectoryElement_xk.h:480
InDet::SiTrajectoryElement_xk::initiateStatePrecise
bool initiateStatePrecise(Trk::PatternTrackParameters &, Trk::PatternTrackParameters &)
Definition: SiTrajectoryElement_xk.cxx:2267
InDet::SiDetElementBoundaryLink_xk::intersect
int intersect(const Trk::PatternTrackParameters &, double &) const
Definition: SiDetElementBoundaryLink_xk.cxx:178
Trk::pion
@ pion
Definition: ParticleHypothesis.h:29
Epos_Base_Fragment.Model
Model
Definition: Epos_Base_Fragment.py:10
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
InDet::SiTrajectoryElement_xk::m_dholesBackward
int m_dholesBackward
Definition: SiTrajectoryElement_xk.h:451
InDet::SiTrajectoryElement_xk::initiateState
bool initiateState(Trk::PatternTrackParameters &inputPars, Trk::PatternTrackParameters &outputPars)
inputPars: input parameters.
Definition: SiTrajectoryElement_xk.cxx:2249
InDet::SiTrajectoryElement_xk::straightLineStepToPlane
bool straightLineStepToPlane(bool updateJacobian, double *globalPars)
Straight line step to plane Updates the "globalPars" array, which is also used to pass the input.
Definition: SiTrajectoryElement_xk.cxx:1890
InDet::SiTrajectoryElement_xk::checkBoundaries
void checkBoundaries(const Trk::PatternTrackParameters &pars)
Definition: SiTrajectoryElement_xk.cxx:2405
InDet::SiTools_xk::maxholes
const int & maxholes() const
Definition: SiTools_xk.h:63
InDet::SiTrajectoryElement_xk::m_useassoTool
bool m_useassoTool
Definition: SiTrajectoryElement_xk.h:437
InDet::SiTrajectoryElement_xk::m_noise
Trk::NoiseOnSurface m_noise
Definition: SiTrajectoryElement_xk.h:514
InDet::SiTrajectoryElement_xk::m_parametersPredForward
Trk::PatternTrackParameters m_parametersPredForward
Pattern track parameters.
Definition: SiTrajectoryElement_xk.h:503
InDet::SiTrajectoryElement_xk::m_fieldMode
bool m_fieldMode
Definition: SiTrajectoryElement_xk.h:436
hist_file_dump.f
f
Definition: hist_file_dump.py:135
InDet::SiTrajectoryElement_xk::parametersPF
const Trk::PatternTrackParameters & parametersPF() const
track parameters for forward filter / smoother predicted
Definition: SiTrajectoryElement_xk.h:129
InDet::SiTrajectoryElement_xk::m_nclustersBackward
int m_nclustersBackward
Definition: SiTrajectoryElement_xk.h:453
Trk::PatternTrackParameters::addNoise
void addNoise(const NoiseOnSurface &, PropDirection)
AnalysisUtils::Delta::R
double R(const INavigable4Momentum *p1, const double v_eta, const double v_phi)
Definition: AnalysisMisc.h:49
Trk::PatternTrackParameters::setCovariance
void setCovariance(const double *)
InDet::SiTools_xk::fieldCondObj
const AtlasFieldCacheCondObj * fieldCondObj() const
Definition: SiTools_xk.h:51
InDet::SCT_Cluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/SCT_Cluster.h:34
InDet::SiTools_xk::xi2multi
const double & xi2multi() const
Definition: SiTools_xk.h:61
Trk::NoiseOnSurface::set
void set(const double &, const double &, const double &, const double &)
Definition: NoiseOnSurface.h:116
InDet::SiClusterLink_xk::cluster
const InDet::SiCluster * cluster() const
Definition: SiClusterLink_xk.h:40
InDet::SiTrajectoryElement_xk::m_nclustersForward
int m_nclustersForward
Definition: SiTrajectoryElement_xk.h:452
RungeKuttaUtils
Definition: RungeKuttaUtils.h:30
InDet::SiTrajectoryElement_xk::m_stereo
bool m_stereo
Definition: SiTrajectoryElement_xk.h:434
Trk::PatternTrackParameters::iscovariance
bool iscovariance() const
Definition: PatternTrackParameters.h:42
dso-stats.pat
pat
Definition: dso-stats.py:39
InDet::SiTrajectoryElement_xk::precisePosCov
void precisePosCov(Trk::PatternTrackParameters &)
Definition: SiTrajectoryElement_xk.cxx:2376
Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition: FakeTrackBuilder.h:9
InDet::SiTrajectoryElement_xk::m_npixelsBackward
int m_npixelsBackward
Definition: SiTrajectoryElement_xk.h:454
InDet::SiTrajectoryElement_xk::m_prdToTrackMap
const Trk::PRDtoTrackMap * m_prdToTrackMap
Definition: SiTrajectoryElement_xk.h:520
ReadCellNoiseFromCoolCompare.s3
s3
Definition: ReadCellNoiseFromCoolCompare.py:380
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
InDet::SiTrajectoryElement_xk::m_proptool
const Trk::IPatternParametersPropagator * m_proptool
Definition: SiTrajectoryElement_xk.h:518
InDet::SiTrajectoryElement_xk::PixelClusterColl
@ PixelClusterColl
Definition: SiTrajectoryElement_xk.h:429
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
Trk::IPatternParametersUpdator::combineStates
virtual bool combineStates(PatternTrackParameters &, PatternTrackParameters &, PatternTrackParameters &) const =0
combine two track states into a resulting state.
Trk::PrepRawData::localPosition
const Amg::Vector2D & localPosition() const
return the local position reference
InDet::SiTrajectoryElement_xk::m_xi2max
double m_xi2max
Definition: SiTrajectoryElement_xk.h:472
InDet::SiTrajectoryElement_xk::m_noisemodel
int m_noisemodel
Definition: SiTrajectoryElement_xk.h:455
InDet::SiTrajectoryElement_xk::m_sibegin
std::any m_sibegin
Definition: SiTrajectoryElement_xk.h:492
InDetDD::SiDetectorElement::isBarrel
bool isBarrel() const
Trk::PatternTrackParameters::initiate
bool initiate(PatternTrackParameters &, const Amg::Vector2D &, const Amg::MatrixX &)
Definition: PatternTrackParameters.cxx:321
InDet::SiTrajectoryElement_xk::m_step
double m_step
Definition: SiTrajectoryElement_xk.h:471
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::MagneticFieldProperties::magneticFieldMode
MagneticFieldMode magneticFieldMode() const
Returns the MagneticFieldMode as specified.
InDet::SiTrajectoryElement_xk::m_maxdholes
int m_maxdholes
Definition: SiTrajectoryElement_xk.h:461
InDet::SiTrajectoryElement_xk::m_halflength
double m_halflength
Definition: SiTrajectoryElement_xk.h:470
InDet::SiTrajectoryElement_xk::m_ndfBackward
int m_ndfBackward
Definition: SiTrajectoryElement_xk.h:458
InDet::SiTrajectoryElement_xk::m_linkBackward
InDet::SiClusterLink_xk m_linkBackward[10]
Definition: SiTrajectoryElement_xk.h:513
InDet::PixelCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:49
InDet::SiTrajectoryElement_xk::m_parametersSM
Trk::PatternTrackParameters m_parametersSM
Definition: SiTrajectoryElement_xk.h:511
python.PyAthena.v
v
Definition: PyAthena.py:154
InDet::SiTrajectoryElement_xk::s_oneOverTwelve
static constexpr double s_oneOverTwelve
Definition: SiTrajectoryElement_xk.h:526
InDet::SiTrajectoryElement_xk::SCT_ClusterColl
@ SCT_ClusterColl
Definition: SiTrajectoryElement_xk.h:430
InDet::SiTrajectoryElement_xk::m_fieldCache
MagField::AtlasFieldCache m_fieldCache
Definition: SiTrajectoryElement_xk.h:516
InDet::SiCluster::width
const InDet::SiWidth & width() const
return width class reference
InDet::SiTools_xk::propTool
const Trk::IPatternParametersPropagator * propTool() const
Definition: SiTools_xk.h:49
a
TList * a
Definition: liststreamerinfos.cxx:10
InDet::SiTrajectoryElement_xk::searchClusters
int searchClusters(Trk::PatternTrackParameters &, SiClusterLink_xk *)
Definition: SiTrajectoryElement_xk.cxx:2399
InDet::SiTools_xk::updatorTool
const Trk::IPatternParametersUpdator * updatorTool() const
Definition: SiTools_xk.h:50
InDet::SiTrajectoryElement_xk::transformPlaneToGlobal
bool transformPlaneToGlobal(bool, Trk::PatternTrackParameters &localParameters, double *globalPars)
Tramsform from plane to global Will take the surface and parameters from localParameters and populate...
Definition: SiTrajectoryElement_xk.cxx:1476
InDet::SiTools_xk::usePRDtoTrackAssociation
bool usePRDtoTrackAssociation() const
Definition: SiTools_xk.h:67
InDet::SiTrajectoryElement_xk::SiClusterColl
@ SiClusterColl
Definition: SiTrajectoryElement_xk.h:428
Trk::PatternTrackParameters
Definition: PatternTrackParameters.h:32
InDet::SiTrajectoryElement_xk::m_clusterOld
const InDet::SiCluster * m_clusterOld
Definition: SiTrajectoryElement_xk.h:496
InDet::SiTrajectoryElement_xk::setDeadRadLength
void setDeadRadLength(Trk::PatternTrackParameters &)
Definition: SiTrajectoryElement_xk.cxx:68
ReadCellNoiseFromCoolCompare.s2
s2
Definition: ReadCellNoiseFromCoolCompare.py:379
InDet::SiTrajectoryElement_xk::m_xi2multi
double m_xi2multi
Definition: SiTrajectoryElement_xk.h:475
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
InDet::SiTrajectoryElement_xk::addCluster
bool addCluster(Trk::PatternTrackParameters &, Trk::PatternTrackParameters &, double &)
Definition: SiTrajectoryElement_xk.cxx:2163
Trk::NoiseOnSurface::initiate
void initiate()
Definition: NoiseOnSurface.h:107
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
InDet::SiTrajectoryElement_xk::m_clusterNoAdd
const InDet::SiCluster * m_clusterNoAdd
Definition: SiTrajectoryElement_xk.h:497
S2
struct TBPatternUnitContext S2
InDet::SiTrajectoryElement_xk::m_radlengthN
double m_radlengthN
Definition: SiTrajectoryElement_xk.h:468
Trk::TrackStateOnSurface::Scatterer
@ Scatterer
This represents a scattering point on the track, and so will contain TrackParameters and MaterialEffe...
Definition: TrackStateOnSurface.h:113
InDet::SiWidth::colRow
const Amg::Vector2D & colRow() const
Definition: SiWidth.h:115
InDet::SiTrajectoryElement_xk::m_dholesForward
int m_dholesForward
Definition: SiTrajectoryElement_xk.h:450
InDet::SiTrajectoryElement_xk::m_xi2Backward
double m_xi2Backward
Definition: SiTrajectoryElement_xk.h:464
extractSporadic.q
list q
Definition: extractSporadic.py:98
InDet::SiTrajectoryElement_xk::m_ndf
int m_ndf
Definition: SiTrajectoryElement_xk.h:456
InDet::SiTrajectoryElement_xk::m_xi2maxlink
double m_xi2maxlink
Definition: SiTrajectoryElement_xk.h:474
Trk::PatternTrackParameters::production
bool production(const TrackParameters *)
Definition: PatternTrackParameters.cxx:42
Trk::SurfaceType::Plane
@ Plane
InDet::SiTools_xk::rioTool
const Trk::IRIO_OnTrackCreator * rioTool() const
Definition: SiTools_xk.h:53
InDetDD::SiDetectorElement::isSCT
bool isSCT() const
InDet::SiTools_xk::xi2max
const double & xi2max() const
Definition: SiTools_xk.h:57
InDet::SiTrajectoryElement_xk::m_invMoment
double m_invMoment
Definition: SiTrajectoryElement_xk.h:478
InDet::SiTrajectoryElement_xk::m_tools
const InDet::SiTools_xk * m_tools
Definition: SiTrajectoryElement_xk.h:515
Trk::PatternTrackParameters::position
Amg::Vector3D position() const
Definition: PatternTrackParameters.cxx:79
InDet::Xi2max
@ Xi2max
Definition: IInDetEtaDependentCutsSvc.h:17
Trk::PatternTrackParameters::momentum
Amg::Vector3D momentum() const
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
InDet::SiTrajectoryElement_xk::m_nMissing
int m_nMissing
Definition: SiTrajectoryElement_xk.h:445
InDet::SiTrajectoryElement_xk::trackParameters
std::unique_ptr< Trk::TrackParameters > trackParameters(bool, int)
Definition: SiTrajectoryElement_xk.cxx:1071
InDet::SiClusterLink_xk::xi2
const double & xi2() const
Definition: SiClusterLink_xk.h:41
Trk::StepLength
@ StepLength
Definition: MaterialAssociationType.h:17
Trk::PatternTrackParameters::diagonalization
void diagonalization(double)
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:75
python.exampleDriverScript.Dir
Dir
Definition: exampleDriverScript.py:20
Trk::Surface::transform
const Amg::Transform3D & transform() const
Returns HepGeom::Transform3D by reference.
python.compressB64.c
def c
Definition: compressB64.py:93
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:26
Trk::Surface::type
constexpr virtual SurfaceType type() const =0
Returns the Surface type to avoid dynamic casts.
InDet::SiCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/SiCluster.h:40
VP1PartSpect::Pi
@ Pi
Definition: VP1PartSpectFlags.h:27
InDet::SiTrajectoryElement_xk::m_radlength
double m_radlength
Definition: SiTrajectoryElement_xk.h:467
python.SystemOfUnits.pc
float pc
Definition: SystemOfUnits.py:99
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
InDet::SiTrajectoryElement_xk::trackParametersWithNewDirection
std::unique_ptr< Trk::TrackParameters > trackParametersWithNewDirection(bool, int)
Definition: SiTrajectoryElement_xk.cxx:1195
InDet::SiTools_xk::maxdholes
const int & maxdholes() const
Definition: SiTools_xk.h:64
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
Trk::NoiseOnSurface::covarianceAzim
const double & covarianceAzim() const
Definition: NoiseOnSurface.h:39
Generated on Fri Jan 10 2025 21:54:11 for ATLAS Offline Software by   doxygen 1.8.18