TrigL2Vertex.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGINDETEVENT_TRIGL2VERTEX_H
#define TRIGINDETEVENT_TRIGL2VERTEX_H
 
#include <list>
#include <vector>
#include "TrigInDetEvent/TrigInDetTrack.h"
#include "TrkTrack/Track.h"
#include "GaudiKernel/MsgStream.h"
 
#define MAX_SIZE_VERT_COVM  30
 
class TrigVertexFittingNode
{
 public:
  TrigVertexFittingNode(){};
  virtual ~TrigVertexFittingNode(){};
  virtual double getChi2Distance(class TrigL2Vertex*) = 0;
  virtual void updateVertex(class TrigL2Vertex*) = 0;
  virtual MsgStream& report( MsgStream& ) const = 0;   
 protected:
  double m_resid[2];
  double m_V[2][2];
  double m_D[2][MAX_SIZE_VERT_COVM];
};
 
inline MsgStream& operator << ( MsgStream& msg, const TrigVertexFittingNode& node)
{ 
  return node.report(msg); 
}
 
inline MsgStream& operator << ( MsgStream& msg, const TrigVertexFittingNode* node)
{ 
  return node->report(msg); 
}
 
class TrigVertexFitInputTrack : public TrigVertexFittingNode
{
 public:
  TrigVertexFitInputTrack(const TrigInDetTrack*, double);
  TrigVertexFitInputTrack(const Trk::Track*, double);
  ~TrigVertexFitInputTrack();
  const TrigInDetTrack* getTrigTrack();
  const Trk::Track* getTrkTrack();
  void initializeVertex(class TrigL2Vertex*);
  bool linearize(class TrigL2Vertex*);
  virtual double getChi2Distance(class TrigL2Vertex*);
  virtual void updateVertex(class TrigL2Vertex*);
  virtual MsgStream& report( MsgStream& ) const;
  void setIndex(int);
  int getIndex() const;
  int getTrackType();
  bool isActive();
  void activate();
  void mask();
  void setMass(double);
  double getMass() const {return m_mass;}
  const double* Perigee() const;
  double PerigeeCovariance(int,int) const;
 private:
  const TrigInDetTrack* m_pTrigTrack;
  const Trk::Track* m_pTrkTrack;
  int m_nTrackType;
  int m_index;
  double m_mass;
  double m_Vqq[3][3];
  double m_Vuq[2][3];
  double m_Vuu[2][2];
  double m_u[2];
  double m_q[3];
  double m_Perigee[5];
  double m_PerigeeCovariance[5][5];
  double m_A[2][3];
  double m_B[2][3];
  double m_h[2];
 
  bool m_active;
};
 
class TrigVertexFitConstraint : public TrigVertexFittingNode
{
 public:
  TrigVertexFitConstraint(double,const TrigVertexFitInputTrack*, const TrigVertexFitInputTrack*);
  TrigVertexFitConstraint(double,const TrigVertexFitInputTrack*, const TrigVertexFitInputTrack*,
              const TrigVertexFitInputTrack*);
  ~TrigVertexFitConstraint();
  virtual double getChi2Distance(class TrigL2Vertex*);
  virtual void updateVertex(class TrigL2Vertex*);
  virtual MsgStream& report( MsgStream& ) const;
  double getValue();
 private:
  double calculateInvariantMass(TrigL2Vertex* pV);
  std::list<const TrigVertexFitInputTrack*> m_trackList;
  double m_value;
};
 
/*
class TrigVertexCovarianceRow
{
 public:
  TrigVertexCovarianceRow(int);
  ~TrigVertexCovarianceRow();
  double& operator[] (int);
 private:
  int m_size;
  double* m_data;
};
 
class TrigVertexCovariance
{
 public:
  TrigVertexCovariance(int);
  ~TrigVertexCovariance();
  TrigVertexCovarianceRow& operator[] (int);
 private:
  int m_size;
  std::vector<TrigVertexCovarianceRow*>* m_data;
};
*/
 
class TrigL2Vertex
{
 public:
  TrigL2Vertex();
  ~TrigL2Vertex();
  TrigL2Vertex(const TrigL2Vertex&) = delete;
  TrigL2Vertex& operator=(const TrigL2Vertex&) = delete;
  bool prepareForFit();
  void reset();
  double chi2();
  int    ndof();
  double mass();
  double massVariance();
 
  void addChi2(double);
  void addNdof(int);
  void setMass(double);
  void setMassVariance(double);
  int getNumberOfTracks();
  double* getParametersVector();
  //TrigVertexCovariance* m_getCovariance();
  //void m_setCovariance(TrigVertexCovariance*);
 
  bool isVertexFitted();
  bool isMassEstimated();
  bool isReadyForFit();
 
  const TrigVertexFitInputTrack* contains(const TrigInDetTrack*);
  const TrigVertexFitInputTrack* contains(const Trk::Track*);
 
  std::list<TrigVertexFitConstraint*>* getConstraints();
  std::list<TrigVertexFitInputTrack*>* getTracks();
  void setStatus(int);
  int getStatus();
  void setMotherTrack(TrigInDetTrackFitPar*);
  const TrigInDetTrackFitPar* getMotherTrack();
  MsgStream& report( MsgStream& ) const;
  double m_Gk[MAX_SIZE_VERT_COVM][MAX_SIZE_VERT_COVM];
 
 private:
  int m_nTracks,m_nDOF;
  //int m_nTrackType;
  //TrigVertexCovariance* m_Gk;
  
  std::list<TrigVertexFitInputTrack*>* m_pvTracks;
  std::list<TrigVertexFitConstraint*>* m_pvConstraints;
  double m_mass,m_chiSquared;
  double m_massVar;
  int m_nStatus;
  //double* m_Rk;
  double m_Rk[MAX_SIZE_VERT_COVM];
  TrigInDetTrackFitPar* m_P;
  bool m_ready;
};
 
inline MsgStream& operator << ( MsgStream& msg, const TrigL2Vertex& vrt)
{ 
  return vrt.report(msg); 
}
 
inline MsgStream& operator << ( MsgStream& msg, const TrigL2Vertex* vrt)
{ 
  return vrt->report(msg); 
}
 
#endif