AlignTrack.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRKALIGNEVENT_ALIGNTRACK_H
#define TRKALIGNEVENT_ALIGNTRACK_H
 
#include "GaudiKernel/MsgStream.h"
 
#include "AthContainers/DataVector.h"
#include "CxxUtils/CachedUniquePtr.h"
#include "TrkAlignEvent/AlignTSOS.h"
#include "TrkTrack/Track.h"
 
#include <vector>
#include <fstream>
 
namespace CLHEP {
  class HepSymMatrix;
}
 
namespace Trk {
 
  class AlignVertex;
 
  typedef DataVector<AlignTSOS> AlignTSOSCollection;
  typedef DataVector<AlignTSOS>::const_iterator AlignTSOSIt;
  typedef std::pair<AlignModule*, std::vector<Amg::VectorX> > AlignModuleDerivatives;
  
  class AlignTrack : public Track {
 
  public:
 
    enum AlignTrackType {
        Unknown = 0,               
        Original = 1,              
        NormalRefitted = 2,        
        BeamspotConstrained = 3,   
        VertexConstrained = 4,     
        VertexMember = 5,          
 
        NTrackTypes                
    };
    
    AlignTrack(const Track& associatedTrack);
 
    AlignTrack(const Track& associatedTrack, AlignTSOSCollection * alignTSOSCollection);
 
    AlignTrack(const AlignTrack& alignTrack);
 
    virtual ~AlignTrack();
 
    AlignTrack& operator= (const AlignTrack& alignTrack);
 
    void setAlignTSOSCollection(AlignTSOSCollection * atsosColl);
 
    const AlignTSOSCollection* alignTSOSCollection() const;
 
    AlignTSOSCollection::const_iterator firstAtsos() const;
 
    AlignTSOSCollection::const_iterator lastAtsos() const;
 
    AlignTSOSCollection::iterator firstAtsos();
 
    AlignTSOSCollection::iterator lastAtsos();
 
    const Track * originalTrack() const { return  m_originalTrack; }
 
    void setOriginalTrack(const Track* track) { m_originalTrack = track; }
 
    inline AlignTrackType type() const {return m_type;}
    inline void setType(AlignTrackType type) {m_type = type;}
 
    void doFindPerigee() const { findPerigee();}
 
    bool isSLTrack() const;
 
    static bool isSLTrack(const Track* track);
 
    static void dumpTrackInfo(const Track& track, MsgStream& msg) ;
 
    static void dumpLessTrackInfo(const Track& track, MsgStream& msg) ;
    
    void dump(MsgStream& msg) ;
 
    const Amg::SymMatrixX * localErrorMatrix() const  { return m_localErrorMat; }
 
    const Amg::SymMatrixX * localErrorMatrixInv() const  { return m_localErrorMatInv; }
    
    int nAlignTSOSMeas() const { return m_nAlignTSOSMeas; }
 
    const std::vector<AlignModuleDerivatives>* derivatives() const { return m_derivatives; }
    void setDerivatives(std::vector<AlignModuleDerivatives>* vec) { m_derivatives=vec; }
 
    const std::vector<AlignModuleDerivatives>* derivativeErr() const { return m_derivativeErr; }
    void setDerivativeErr(std::vector<AlignModuleDerivatives>* vec) { m_derivativeErr=vec; }
 
    const std::vector<std::pair<AlignModule*,std::vector<double> > >* actualSecondDerivatives() const { return m_actualSecondDerivatives; }
    void setActualSecondDerivatives(std::vector<std::pair<AlignModule*,std::vector<double> > >* vec) { m_actualSecondDerivatives=vec; }
    
    const Amg::VectorX* residualVector() const { return m_residuals; }
    void setResidualVector(Amg::VectorX* vec) { m_residuals=vec;}
    
    const Amg::SymMatrixX* weightMatrix() const  { return m_weights; }
    void setWeightMatrix( Amg::SymMatrixX* mat) { m_weights=mat; }
 
    const Amg::SymMatrixX* weightMatrixFirstDeriv() const  { return m_weightsFirstDeriv; }
    void setWeightMatrixFirstDeriv( Amg::SymMatrixX* mat) { m_weightsFirstDeriv=mat; }
 
    double chi2() const { return m_chi2; }
    void setChi2(double chi2) { m_chi2=chi2; }
 
    double chi2dof() const { return m_chi2dof; }
    void setChi2dof(double chi2dof) { m_chi2dof=chi2dof; }
 
    const Amg::MatrixX* derivativeMatrix() const { return m_derivativeMatrix; }
    void setDerivativeMatrix(const Amg::MatrixX* matrix);
 
    const Amg::SymMatrixX* fullCovarianceMatrix() const { return m_fullCovarianceMatrix; }
    void setFullCovarianceMatrix(const Amg::SymMatrixX* matrix);
 
    double trackAlignParamQuality(int i) const { return m_trackAlignParamQuality[i]; }
    void setTrackAlignParamQuality(int i, double val) { m_trackAlignParamQuality[i]=val; }
 
    const Trk::Track* trackWithoutScattering() const;
 
    const AlignVertex*    getVtx() const { return m_vtx; }
    AlignVertex*          getVtx()       { return m_vtx; }
    void setVtx(AlignVertex * const vtx)  { m_vtx = vtx; }
 
    bool refitD0()    const { return m_refitD0; }
    bool refitZ0()    const { return m_refitZ0; }
    bool refitPhi()   const { return m_refitPhi; }
    bool refitTheta() const { return m_refitTheta; }
    bool refitQovP()  const { return m_refitQovP; }
       
    void setRefitD0(bool flag)     { m_refitD0    = flag; }
    void setRefitZ0(bool flag)     { m_refitZ0    = flag; }
    void setRefitPhi(bool flag)    { m_refitPhi   = flag; }
    void setRefitTheta(bool flag)  { m_refitTheta = flag; }
    void setRefitQovP(bool flag)   { m_refitQovP  = flag; }
       
   private:
    // methods
    AlignTrack();
    
    void setAlignParameters(); 
 
    const Track * m_originalTrack;
 
    AlignTrackType m_type;
 
    int m_nAlignTSOSMeas;
 
    AlignTSOSCollection * m_alignTSOSCollection{};
 
    Amg::SymMatrixX * m_localErrorMat;               //Symmetric Matrix
 
    Amg::SymMatrixX * m_localErrorMatInv;            //Symmetric Matrix
 
    const Amg::MatrixX * m_derivativeMatrix;      
 
    const Amg::SymMatrixX * m_fullCovarianceMatrix;  //Symmetric Matrix
 
    std::vector<AlignModuleDerivatives > * m_derivatives;  
    std::vector<AlignModuleDerivatives > * m_derivativeErr; 
    std::vector<std::pair<AlignModule *,std::vector<double> > > * m_actualSecondDerivatives;
 
    Amg::VectorX *        m_residuals;
    Amg::MatrixX *        m_weights;              //Symmetric Matrix
    Amg::MatrixX *        m_weightsFirstDeriv;    //Symmetric Matrix
 
    double                m_chi2;
    double                m_chi2dof;
 
    AlignVertex*          m_vtx;
 
    bool                  m_refitD0;
    bool                  m_refitZ0;
    bool                  m_refitPhi;
    bool                  m_refitTheta;
    bool                  m_refitQovP;
   
    double              * m_trackAlignParamQuality; 
 
    CxxUtils::CachedUniquePtr<Trk::Track> m_trackWithoutScattering; 
 
  }; // end class
 
  MsgStream&    operator<< (MsgStream& sl, const AlignTrack::AlignTrackType type);
  std::ostream& operator<< (std::ostream& ol, const AlignTrack::AlignTrackType type);
  std::string dumpAlignTrackType(const AlignTrack::AlignTrackType type);
 
  inline const AlignTSOSCollection * AlignTrack::alignTSOSCollection() const { return m_alignTSOSCollection; }
 
  inline void AlignTrack::setDerivativeMatrix(const Amg::MatrixX * matrix) { 
    if (!m_derivativeMatrix) delete m_derivativeMatrix; 
    m_derivativeMatrix=new Amg::MatrixX(*matrix); 
  }
 
  inline void AlignTrack::setFullCovarianceMatrix(const Amg::SymMatrixX * matrix) { 
    if (!m_fullCovarianceMatrix) delete m_fullCovarianceMatrix; 
    m_fullCovarianceMatrix=new Amg::SymMatrixX(*matrix); 
  }
 
  inline AlignTSOSCollection::const_iterator AlignTrack::firstAtsos() const { return m_alignTSOSCollection->cbegin(); }
  inline AlignTSOSCollection::const_iterator AlignTrack::lastAtsos()  const { return m_alignTSOSCollection->cend(); }
 
  inline AlignTSOSCollection::iterator AlignTrack::firstAtsos() { return m_alignTSOSCollection->begin(); }
  inline AlignTSOSCollection::iterator AlignTrack::lastAtsos()  { return m_alignTSOSCollection->end(); }
 
} // end namespace
 
#endif // TRKALIGNEVENT_ALIGNTRACK_H