Vertex.h

Go to the documentation of this file.

#ifndef VertexReco_Vertex_h
#define VertexReco_Vertex_h
 
#include <Rtypes.h>
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/Math/interface/Error.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/Common/interface/RefToBase.h"
#include <Math/GenVector/PxPyPzE4D.h>
#include <Math/GenVector/PxPyPzM4D.h>
#include "DataFormats/Math/interface/LorentzVector.h"
 
namespace reco {
 
  class Track;
 
  class Vertex {
  public:
    typedef std::vector<TrackBaseRef>::const_iterator trackRef_iterator;
    typedef math::XYZPoint Point;
    enum { dimension = 3, dimension4D = 4 };
    typedef math::Error<dimension>::type Error;
    typedef math::Error<dimension>::type CovarianceMatrix;
    typedef math::Error<dimension4D>::type Error4D;
    typedef math::Error<dimension4D>::type CovarianceMatrix4D;
    enum { size = dimension * (dimension + 1) / 2, size4D = (dimension4D) * (dimension4D + 1) / 2 };
    typedef unsigned int index;
    Vertex() : chi2_(0.0), ndof_(0), position_(0., 0., 0.), time_(0.) {
      validity_ = false;
      for (int i = 0; i < size4D; ++i)
        covariance_[i] = 0.;
    }
    Vertex(const Point &, const Error &);
    Vertex(const Point &, const Error4D &, double);
    Vertex(const Point &, const Error &, double chi2, double ndof, size_t size);
    Vertex(const Point &, const Error4D &, double time, double chi2, double ndof, size_t size);
    bool isValid() const { return validity_; }
    bool isFake() const { return (chi2_ == 0 && ndof_ == 0 && tracks_.empty()); }
    void add(const TrackBaseRef &r, float w = 1.0);
    void add(const TrackBaseRef &r, const Track &refTrack, float w = 1.0);
    void removeTracks();
 
    template <typename TREF>
    float trackWeight(const TREF &r) const {
      int i = 0;
      for (auto const &t : tracks_) {
        if ((r.id() == t.id()) & (t.key() == r.key()))
          return weights_[i] / 255.f;
        ++i;
      }
      return 0;
    }
    trackRef_iterator tracks_begin() const;
    trackRef_iterator tracks_end() const;
    size_t tracksSize() const;
    const TrackBaseRef &trackRefAt(size_t idx) const { return tracks_[idx]; }
    double chi2() const { return chi2_; }
    double ndof() const { return ndof_; }
    double normalizedChi2() const { return ndof_ != 0 ? chi2_ / ndof_ : chi2_ * 1e6; }
    const Point &position() const { return position_; }
    double x() const { return position_.X(); }
    double y() const { return position_.Y(); }
    double z() const { return position_.Z(); }
    double t() const { return time_; }
    double xError() const { return sqrt(covariance(0, 0)); }
    double yError() const { return sqrt(covariance(1, 1)); }
    double zError() const { return sqrt(covariance(2, 2)); }
    double tError() const { return sqrt(covariance(3, 3)); }
    // Note that:
    //   double error( int i, int j ) const
    // is OBSOLETE, use covariance(i, j)
    double covariance(int i, int j) const { return covariance_[idx(i, j)]; }
    CovarianceMatrix covariance() const {
      Error m;
      fill(m);
      return m;
    }
    CovarianceMatrix4D covariance4D() const {
      Error4D m;
      fill(m);
      return m;
    }
 
    Error error() const {
      Error m;
      fill(m);
      return m;
    }
    Error4D error4D() const {
      Error4D m;
      fill(m);
      return m;
    }
 
    void fill(CovarianceMatrix &v) const;
    void fill(CovarianceMatrix4D &v) const;
 
    bool hasRefittedTracks() const { return !refittedTracks_.empty(); }
 
    TrackBaseRef originalTrack(const Track &refTrack) const;
 
    Track refittedTrack(const TrackBaseRef &track) const;
 
    Track refittedTrack(const TrackRef &track) const;
 
    const std::vector<Track> &refittedTracks() const { return refittedTracks_; }
 
    math::XYZTLorentzVectorD p4(float mass = 0.13957018, float minWeight = 0.5) const;
 
    unsigned int nTracks(float minWeight = 0.5) const;
 
    class TrackEqual {
    public:
      TrackEqual(const Track &t) : track_(t) {}
      bool operator()(const Track &t) const { return t.pt() == track_.pt(); }
 
    private:
      const Track &track_;
    };
 
  private:
    float chi2_;
    float ndof_;
    Point position_;
    float covariance_[size4D];
    std::vector<TrackBaseRef> tracks_;
    std::vector<Track> refittedTracks_;
    std::vector<uint8_t> weights_;
    bool validity_;
    double time_;
 
    index idx(index i, index j) const {
      int a = (i <= j ? i : j), b = (i <= j ? j : i);
      return b * (b + 1) / 2 + a;
    }
  };
 
}  // namespace reco
 
#endif