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 "DataFormats/Candidate/interface/VertexCompositePtrCandidate.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 double time,
                  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& pos,
                  const double time,
                  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 double priorTime,
                  const GlobalError& priorErr,
                  const GlobalPoint& pos,
                  const double time,
                  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 GlobalPoint& priorPos,
                  const double priorTime,
                  const GlobalError& priorErr,
                  const GlobalPoint& pos,
                  const double time,
                  const GlobalError& posError,
                  const std::vector<reco::TransientTrack>& tracks,
                  float chi2,
                  float ndf);

  TransientVertex(const GlobalPoint& priorPos,
                  const GlobalError& priorErr,
                  const double priorTime,
                  const double priorTimeErr,
                  const GlobalPoint& pos,
                  const GlobalError& posError,
                  const double time,
                  const double timeErr,
                  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.is4D() ? theVertexState.error4D() : theVertexState.error();
  }
  GlobalPoint priorPosition() const { return thePriorVertexState.position(); }
  GlobalError priorError() const {
    return thePriorVertexState.is4D() ? thePriorVertexState.error4D() : thePriorVertexState.error();
  }
  double time() const { return theVertexState.time(); }
  double timeError() const { return theVertexState.timeError(); }
  double priorTime() const { return thePriorVertexState.time(); }
  double priorTimeError() const { return thePriorVertexState.timeError(); }
  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;
  operator reco::VertexCompositePtrCandidate() 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