AlignVertex.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRKALIGNEVENT_ALIGNVERTEX_H
#define TRKALIGNEVENT_ALIGNVERTEX_H
 
#include "GaudiKernel/MsgStream.h"
#include "AthenaBaseComps/AthAlgTool.h"
 
#include "TrkTrack/Track.h"
#include "VxVertex/VxCandidate.h"
#include "xAODTracking/Vertex.h"
#include "TrkAlignEvent/AlignTrack.h"
 
#include "TrkEventPrimitives/ParticleHypothesis.h"
 
#include "AthContainers/DataVector.h"
#include <vector>
#include <fstream>

 
 
namespace Trk {
 
  typedef std::vector<AlignTrack**> AlignTrackCollection;
  typedef std::vector<AlignTrack**>::const_iterator AlignTrackIt;
  typedef std::pair<const AlignModule*, std::vector<Amg::VectorX> > AlignModuleVertexDerivatives;
  
  class AlignVertex {
 
  public:
 
    enum AlignVertexType{
        Unknown = 0,               
        Primary = 1,               
        Refitted = 2,              
        Accumulated = 3,           
 
        NVertexTypes               
    };
    
    AlignVertex();

    AlignVertex(const xAOD::Vertex* originalVertex);
    
    AlignVertex( const AlignVertex & rhs);
    
    AlignVertex & operator=( const AlignVertex & rhs);

    ~AlignVertex();
 

    const AlignTrackCollection* alignTrackCollection() const;

    AlignTrackCollection::const_iterator firstATrack() const;

    AlignTrackCollection::const_iterator lastATrack() const;

    const xAOD::Vertex * originalVertex() const { return  m_original; }
    inline const Amg::Vector3D*  originalPosition() const {return m_originalPosition;}

    void setOriginalVertex(const xAOD::Vertex* vertex) { m_original = vertex; }

    inline AlignVertexType type() const {return m_type;}
    inline void setType(AlignVertexType type) {m_type = type;}

    inline const Amg::Vector3D*   position()   const {return m_position;}
    inline const AmgSymMatrix(3)* covariance() const {return m_covariance;}

    const std::vector<AlignModuleVertexDerivatives>* derivatives() const { return m_derivatives; }
    void setDerivatives(std::vector<AlignModuleVertexDerivatives>* vec) { m_derivatives=vec; }
    void addDerivatives(std::vector<AlignModuleVertexDerivatives>* vec);
 

    void dump(MsgStream& msg) ;

    void incrementVector(const Amg::Vector3D& vtxV)     { (*m_vVector)+=vtxV; }
    void incrementMatrix(const AmgSymMatrix(3) vtxM)   { (*m_matrix)+=vtxM; }
 

    void fitVertex();

    int  Ntracks() const { return m_nTracks; }

    void setConstraint(AmgSymMatrix(3)*, Amg::Vector3D*); 
 
    const AmgSymMatrix(3)* Qmatrix() const { return m_qMatrix; }
 
    const Amg::Vector3D* Vvector() const { return m_vVector; }
 
    void setUnconstrained() { m_constrained=false; }
 
    bool Constrained() const { return m_constrained; }
 
       
   private:
    int                    m_nTracks;
    
    AmgSymMatrix(3)*       m_matrix;
    Amg::Vector3D*         m_vector;
 
    const xAOD::Vertex*    m_original;
    Amg::Vector3D*         m_originalPosition;
 
    AlignTrackCollection   m_alignTracks;
 
    Amg::Vector3D*         m_position;
    AmgSymMatrix(3) *      m_covariance;
 
    std::vector<AlignModuleVertexDerivatives > * m_derivatives;
 
    AmgSymMatrix(3)*       m_qMatrix;
    Amg::Vector3D*         m_vVector;
    bool                   m_constrained;
 
 
    AlignVertexType        m_type;
    
  }; // end class
 
 
} // end namespace
 
#endif // TRKALIGNEVENT_ALIGNVERTEX_H