SiTrajectoryElement_xk.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/

//  Header file for class SiTrajectoryElement_xk
// (c) ATLAS Detector software
// Class for trajector elements in Pixels and SCT
// Version 1.0 3/10/2004 I.Gavrilenko
 
#ifndef SiTrajectoryElement_xk_H
#define SiTrajectoryElement_xk_H
 
#include "InDetPrepRawData/SiClusterCollection.h"
#include "InDetPrepRawData/PixelClusterCollection.h"
#include "InDetPrepRawData/SCT_ClusterCollection.h"
#include "SiSPSeededTrackFinderData/SiClusterLink_xk.h"
#include "SiSPSeededTrackFinderData/SiDetElementBoundaryLink_xk.h"
#include "SiSPSeededTrackFinderData/SiTools_xk.h"
#include "TrkPatternParameters/PatternTrackParameters.h"
#include "TrkPatternParameters/NoiseOnSurface.h"
#include "TrkTrack/TrackStateOnSurface.h"
#include "TrkEventUtils/PRDtoTrackMap.h"
// MagField cache
#include "MagFieldElements/AtlasFieldCache.h"
 
#include <any>
 
namespace InDet{
 
  class SiTrajectoryElement_xk final
    {
      // Public methods:
      
    public:
      
      SiTrajectoryElement_xk();
      SiTrajectoryElement_xk(const SiTrajectoryElement_xk&);
      ~SiTrajectoryElement_xk() = default;
      SiTrajectoryElement_xk& operator  = (const SiTrajectoryElement_xk&);
 
      const int&  detstatus   () const {return m_detstatus;}
      const int&  inside      () const {return m_inside;    }
      const int&  ndist       () const {return m_nMissing ;    }
      const int&  nlinksF     () const {return m_nlinksForward;   }
      const int&  nlinksB     () const {return m_nlinksBackward;   }
      const int&  nholesF     () const {return m_nholesForward;   }
      const int&  nholesB     () const {return m_nholesBackward;   }
      const int&  dholesF     () const {return m_dholesForward;   }
      const int&  dholesB     () const {return m_dholesBackward;   }
      const int&  nclustersF  () const {return m_nclustersForward;}
      const int&  nclustersB  () const {return m_nclustersBackward;}
      const int&  npixelsB    () const {return m_npixelsBackward;  }
      const bool& stereo      () const {return m_stereo;    }
      const int&  status      () const {return m_status;    }
      const int&  noiseModel  () const {return m_noisemodel;}
      const int&  ndf         () const {return m_ndf;       }
      const int&  ndfF        () const {return m_ndfForward;      }
      const int&  ndfB        () const {return m_ndfBackward;      }
      const int&  ntsos       () const {return m_ntsos;     }
      const double& step      () const {return m_step;      }
      const double& dist      () const {return m_dist;      }
      bool        isBarrel    () const {return m_detelement->isBarrel();}
 
      const InDetDD::SiDetectorElement* detElement  () const {return m_detelement;  }  
      const InDet::SiCluster*           cluster     () const {return m_cluster   ;  }  
      const InDet::SiCluster*           clusterOld  () const {return m_clusterOld;  }  
      const InDet::SiCluster*           clusterNoAdd() const {return m_clusterNoAdd;} 
      Trk::TrackStateOnSurface*         tsos (int i);
 
      bool isNextClusterHoleB(bool&,double&);
      bool isNextClusterHoleF(bool&,double&);


      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&);


      // if rad_length==-1, then the private member m_radlength is used.
      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 {return m_xi2Forward      ;}
      const double& xi2B      () const {return m_xi2Backward      ;}
      const double& xi2totalF () const {return m_xi2totalForward ;}
      const double& xi2totalB () const {return m_xi2totalBackward ;}
      const double& radlength () const {return m_radlength ;}
      const double& energylose() const {return m_energylose;}
      const Trk::PatternTrackParameters& parametersPF() const {return m_parametersPredForward;} 
      const Trk::PatternTrackParameters& parametersUF() const {return m_parametersUpdatedForward;} 
      const Trk::PatternTrackParameters& parametersPB() const {return m_parametersPredBackward;} 
      const Trk::PatternTrackParameters& parametersUB() const {return m_parametersUpdatedBackward;} 
      const Trk::PatternTrackParameters& parametersSM() const {return m_parametersSM;} 

      const Trk::PatternTrackParameters* parameters() const;
 
      const Trk::Surface*  surface()  const {return m_surface;}
      const InDet::SiClusterLink_xk& linkF (int i) const {return m_linkForward[i];}
      const InDet::SiClusterLink_xk& linkB (int i) const {return m_linkBackward[i];}
 


      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);
 
      bool setDead(const Trk::Surface*);
      void setDeadRadLength(Trk::PatternTrackParameters&);
      void setTools(const InDet::SiTools_xk*); 
      void setParameters(); 
      void bremNoiseModel();


      bool firstTrajectorElement(const Trk::TrackParameters&, const EventContext& ctx);
      bool firstTrajectorElement(bool correction);

      // @name Forward propagation  

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

      template <typename T>
        void CloseClusterSeach
    (Trk::PatternTrackParameters& Tpa,
     const InDet::SiDetElementBoundaryLink_xk*& dl,
     const T& sb, 
     const T& se);
      
      void eraseClusterForwardPropagation();


      bool lastTrajectorElement();
      bool lastTrajectorElementPrecise();


      bool BackwardPropagationSmoother(SiTrajectoryElement_xk&,bool, const EventContext& ctx);
      bool BackwardPropagationPrecise (SiTrajectoryElement_xk&, const EventContext& ctx);
      bool BackwardPropagationFilter  (SiTrajectoryElement_xk&, const EventContext& ctx);


      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*);


      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;

      // @name TrackStateOnSurface production  

      Trk::TrackStateOnSurface* trackStateOnSurface(bool,bool,bool,int);
      Trk::TrackStateOnSurface* trackSimpleStateOnSurface(bool,bool,int);
      Trk::TrackStateOnSurface* trackPerigeeStateOnSurface(const EventContext& ctx);


      std::unique_ptr<Trk::TrackParameters> trackParameters(bool,int);
      std::unique_ptr<Trk::TrackParameters> trackParametersWithNewDirection(bool,int);
      static std::unique_ptr<Trk::TrackParameters> trackParameters(Trk::PatternTrackParameters&,bool);

      // @name Initiate state

      bool initiateState(Trk::PatternTrackParameters& inputPars,Trk::PatternTrackParameters& outputPars);
      bool initiateStatePrecise(Trk::PatternTrackParameters&,Trk::PatternTrackParameters&);
      bool initiateStateWithCorrection(Trk::PatternTrackParameters&,Trk::PatternTrackParameters&,Trk::PatternTrackParameters&);
      void precisePosCov(Trk::PatternTrackParameters&);

      // @name Last detector elements with clusters

      void lastActive();


      double step(SiTrajectoryElement_xk&);
      double stepToPerigee();


      Amg::Vector3D globalPosition();


      double quality(int&) const;



      bool propagate(Trk::PatternTrackParameters  & startingParameters,
                     Trk::PatternTrackParameters  & outParameters,
                     double                       & step,
                     const EventContext& ctx);


      bool propagateParameters(Trk::PatternTrackParameters& startingParameters,
                               Trk::PatternTrackParameters& outParameters,
                               double                     & step);


 
        
      // /////////////////////////////////////////////////////////////////////////////////
      bool transformPlaneToGlobal(bool,
                                  Trk::PatternTrackParameters& localParameters,
                                  double* globalPars);
 
  
      // /////////////////////////////////////////////////////////////////////////////////
      bool transformGlobalToPlane(bool updateJacobian,
                                  double* globalPars ,
                                  Trk::PatternTrackParameters& startingParameters,
                                  Trk::PatternTrackParameters& outputParameters);
 
            
      bool rungeKuttaToPlane(bool updateJacobian, double* globalPars);
      bool straightLineStepToPlane(bool updateJacobian, double* globalPars);
 
 
    private:
      
 
      enum IteratorType {
        SiClusterColl = 0,
        PixelClusterColl = 1,
        SCT_ClusterColl = 2,
        Invalid = 3
      };
 
      bool                                        m_stereo{}      ;
      bool                                        m_utsos[3]{}    ;
      bool                                        m_fieldMode{}   ;
      bool                                        m_useassoTool = false ;
      int                                         m_status{}      ;  
      int                                         m_detstatus{}   ; 
      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]{}      ;
      double                                      m_invMoment{}   ;
 
      const InDetDD::SiDetectorElement*           m_detelement{}  ;
      const InDet::SiDetElementBoundaryLink_xk*   m_detlink{}     ;
      const Trk::Surface*                         m_surface{}     ;
      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; 
      Trk::PatternTrackParameters                 m_parametersUpdatedForward; 
      Trk::PatternTrackParameters                 m_parametersPredBackward; 
      Trk::PatternTrackParameters                 m_parametersUpdatedBackward;
      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    ;
 
      static constexpr double s_oneOverTwelve{0.08333}           ;
 
      IteratorType m_itType{Invalid};

      
      void patternCovariances(const InDet::SiCluster*,double&,double&,double&) const;
      void checkBoundaries(const Trk::PatternTrackParameters & pars);
    };
  
} // end of name space
 
#include "SiSPSeededTrackFinderData/SiTrajectoryElement_xk.icc"
 
#endif // SiTrajectoryElement_xk