TransientVertex.h

Go to the documentation of this file.

#ifndef _Vtx_TransientVertex_H_
#define _Vtx_TransientVertex_H_

#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/GlobalError.h"
#include "TrackingTools/TransientTrack/interface/TransientTrack.h"
#include "RecoVertex/VertexPrimitives/interface/VertexState.h"
#include "RecoVertex/VertexPrimitives/interface/TTtoTTmap.h"
#include "DataFormats/VertexReco/interface/Vertex.h"

#include <vector>
#include <map>

class TransientVertex {//: public reco::Vertex {

public:

  typedef std::map<reco::TransientTrack, float> TransientTrackToFloatMap;

  TransientVertex();

  TransientVertex(const GlobalPoint & pos, const GlobalError & posError,
        const std::vector<reco::TransientTrack> & tracks, float chi2);

  TransientVertex(const GlobalPoint & pos, const GlobalError & posError,
        const std::vector<reco::TransientTrack> & tracks, float chi2, float ndf);

  TransientVertex(const GlobalPoint & priorPos, const GlobalError & priorErr,
        const GlobalPoint & pos, const GlobalError & posError,
        const std::vector<reco::TransientTrack> & tracks, float chi2);

  TransientVertex(const GlobalPoint & priorPos, const GlobalError & priorErr,
        const GlobalPoint & pos, const GlobalError & posError,
        const std::vector<reco::TransientTrack> & tracks, float chi2, float ndf);

  TransientVertex(const VertexState & state, 
            const std::vector<reco::TransientTrack> & tracks, float chi2);

  TransientVertex(const VertexState & state, 
            const std::vector<reco::TransientTrack> & tracks, float chi2, float ndf);

  TransientVertex(const VertexState & prior,
            const VertexState & state,
            const std::vector<reco::TransientTrack> & tracks, float chi2);

  TransientVertex(const VertexState & prior,
            const VertexState & state,
            const std::vector<reco::TransientTrack> & tracks, float chi2, float ndf);


//   /** Constructor defining the RecVertex by its 3D position
//    *  and position uncertainty, its associated tracks, its chi-squared
//    *  and its number of degrees of freedom, and the track weights. 
//    *  The ndf can be a float.
//    */
//   TransientVertex(const VertexState & state, 
//          const std::vector<reco::TransientTrack> & tracks, float chi2, float ndf, 
//          const reco::TransientTrackToFloatMap & weightMap);


  VertexState const & vertexState() const { return theVertexState; }
  GlobalPoint position() const { return theVertexState.position(); }
  GlobalError positionError() const { return theVertexState.error(); }
  GlobalPoint priorPosition() const { return thePriorVertexState.position(); }
  GlobalError priorError() const { return thePriorVertexState.error(); }
  bool hasPrior() const { return withPrior; }

//   /** Implements method of abstract Vertex.
//    *  Returns track pointer container by value
//    */
//   Vertex::TrackPtrContainer tracks() const;

  float totalChiSquared() const { return theChi2; }
  float normalisedChiSquared() const {
    return totalChiSquared() / degreesOfFreedom();
  }
  float degreesOfFreedom() const { return theNDF; }

  bool isValid() const {
    return vertexValid;
  }

  std::vector<reco::TransientTrack> const & originalTracks() const {
    return theOriginalTracks;
  }


  bool hasRefittedTracks() const { return withRefittedTracks; }


  std::vector<reco::TransientTrack> const &  refittedTracks() const {
    return theRefittedTracks;
  }

  reco::TransientTrack originalTrack(const reco::TransientTrack & refTrack) const;

  reco::TransientTrack refittedTrack(const reco::TransientTrack & track) const;


  void refittedTracks(const std::vector<reco::TransientTrack> & refittedTracks);

  bool hasTrackWeight() const { return theWeightMapIsAvailable; }


  float trackWeight(const reco::TransientTrack & track) const;

  TransientTrackToFloatMap weightMap() const { return theWeightMap; }

  void weightMap(const TransientTrackToFloatMap & theMap);

  bool tkToTkCovarianceIsAvailable() const { return theCovMapAvailable; }

  AlgebraicMatrix33 tkToTkCovariance(const reco::TransientTrack& t1, 
                const reco::TransientTrack& t2) const;
  void tkToTkCovariance(const TTtoTTmap &covMap);

  operator reco::Vertex() const;

private:


  mutable VertexState thePriorVertexState;
  mutable VertexState theVertexState;

//   void addTracks(const std::vector<reco::TransientTrack> & tracks);

  std::vector<reco::TransientTrack> theOriginalTracks;
  std::vector<reco::TransientTrack> theRefittedTracks;


  float theChi2;
  float theNDF;
  bool vertexValid;
  bool withPrior, theWeightMapIsAvailable, theCovMapAvailable;
  bool withRefittedTracks;
  TTtoTTmap theCovMap;
  TransientTrackToFloatMap theWeightMap;

};

#endif