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;
    }
  };

}

#endif