VertexCompositePtrCandidate.h

Go to the documentation of this file.

#ifndef DataFormats_Candidate_VertexCompositePtrCandidate_H
#define DataFormats_Candidate_VertexCompositePtrCandidate_H

#include "DataFormats/Candidate/interface/VertexCompositePtrCandidateFwd.h"
#include "DataFormats/Candidate/interface/CompositePtrCandidate.h"

namespace reco {
  class VertexCompositePtrCandidate : public CompositePtrCandidate {
  public:
    enum { dimension4D = 4 };
    typedef math::Error<dimension4D>::type CovarianceMatrix4D;
    enum { size4D = dimension4D * (dimension4D + 1) / 2 };

    VertexCompositePtrCandidate() : CompositePtrCandidate(), chi2_(0), ndof_(0), time_(0) {}
    VertexCompositePtrCandidate(
        Charge q, const LorentzVector &p4, const Point &vtx, int pdgId = 0, int status = 0, bool integerCharge = true)
        : CompositePtrCandidate(q, p4, vtx, pdgId, status, integerCharge), chi2_(0), ndof_(0), time_(0) {}
    VertexCompositePtrCandidate(Charge q,
                                const LorentzVector &p4,
                                const Point &vtx,
                                double time,
                                int pdgId = 0,
                                int status = 0,
                                bool integerCharge = true)
        : CompositePtrCandidate(q, p4, vtx, pdgId, status, integerCharge), chi2_(0), ndof_(0), time_(time) {}
    VertexCompositePtrCandidate(Charge q,
                                const LorentzVector &p4,
                                const Point &vtx,
                                const CovarianceMatrix &err,
                                double chi2,
                                double ndof,
                                int pdgId = 0,
                                int status = 0,
                                bool integerCharge = true);
    VertexCompositePtrCandidate(Charge q,
                                const LorentzVector &p4,
                                const Point &vtx,
                                double time,
                                const CovarianceMatrix4D &err,
                                double chi2,
                                double ndof,
                                int pdgId = 0,
                                int status = 0,
                                bool integerCharge = true);
    explicit VertexCompositePtrCandidate(const Candidate &p) : CompositePtrCandidate(p), chi2_(0), ndof_(0), time_(0) {}
    explicit VertexCompositePtrCandidate(const CompositePtrCandidate &p)
        : CompositePtrCandidate(p), chi2_(0), ndof_(0), time_(0) {}
    ~VertexCompositePtrCandidate() override;
    VertexCompositePtrCandidate *clone() const override;

    double vertexChi2() const override { return chi2_; }
    double vertexNdof() const override { return ndof_; }
    double vertexNormalizedChi2() const override { return chi2_ / ndof_; }
    double vertexCovariance(int i, int j) const override { return covariance_[idx(i, j)]; }
    using reco::LeafCandidate::vertexCovariance;  // avoid hiding the
    CovarianceMatrix4D vertexCovariance4D() const {
      CovarianceMatrix4D m;
      fillVertexCovariance(m);
      return m;
    }

    void fillVertexCovariance(CovarianceMatrix &v) const override;
    void fillVertexCovariance(CovarianceMatrix4D &v) const;

    void setChi2AndNdof(double chi2, double ndof) {
      chi2_ = chi2;
      ndof_ = ndof;
    }
    void setCovariance(const CovarianceMatrix &m);
    void setCovariance(const CovarianceMatrix4D &m);

    // set time
    void setTime(double time) { time_ = time; }

    typedef math::Error<dimension>::type Error;
    typedef math::Error<dimension4D>::type Error4D;
    const Point &position() const { return vertex(); }
    double t() const { return time_; }
    double tError() const { return std::sqrt(vertexCovariance(3, 3)); }
    Error error() const {
      Error m;
      fillVertexCovariance(m);
      return m;
    }
    Error4D error4D() const {
      Error4D m;
      fillVertexCovariance(m);
      return m;
    }

  private:
    Double32_t chi2_;
    Double32_t ndof_;
    Double32_t covariance_[size4D];
    Double32_t 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