d8/dc2/SiTrajectoryElement__xk_8h_source.html

/*

  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