CandKinResolution.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_CandKinResolution_h
#define DataFormats_PatCandidates_CandKinResolution_h
#include <vector>
#include "DataFormats/CLHEP/interface/AlgebraicObjects.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "DataFormats/Common/interface/ValueMap.h"
 
namespace pat {
  class CandKinResolution {
  public:
    typedef math::XYZTLorentzVector LorentzVector;
    typedef float Scalar;
 
    enum Parametrization {
      Invalid = 0,
      // 4D = 0xN4
      Cart = 0x04,
      ECart = 0x14,
      Spher = 0x24,
      ESpher = 0x34,
      MomDev = 0x44,
      EMomDev = 0x54,
      // 3D =0xN3
      MCCart = 0x03,
      MCSpher = 0x13,
      MCPInvSpher = 0x23,
      EtEtaPhi = 0x33,
      EtThetaPhi = 0x43,
      MCMomDev = 0x53,
      EScaledMomDev = 0x63
    };
    CandKinResolution();
 
    CandKinResolution(Parametrization parametrization,
                      const std::vector<Scalar> &covariances,
                      const std::vector<Scalar> &constraints = std::vector<Scalar>());
 
    CandKinResolution(Parametrization parametrization,
                      const AlgebraicSymMatrix44 &covariance,
                      const std::vector<Scalar> &constraints = std::vector<Scalar>());
    ~CandKinResolution();
 
    Parametrization parametrization() const { return parametrization_; }
 
    uint32_t dimension() const { return dimensionFrom(parametrization_); }
 
    const AlgebraicSymMatrix44 &covariance() const { return covmatrix_; }
 
    const std::vector<Scalar> &constraints() const { return constraints_; }
 
    double resolEta(const LorentzVector &p4) const;
 
    double resolTheta(const LorentzVector &p4) const;
 
    double resolPhi(const LorentzVector &p4) const;
 
    double resolE(const LorentzVector &p4) const;
 
    double resolEt(const LorentzVector &p4) const;
 
    double resolM(const LorentzVector &p4) const;
 
    double resolP(const LorentzVector &p4) const;
 
    double resolPt(const LorentzVector &p4) const;
 
    double resolPInv(const LorentzVector &p4) const;
 
    double resolPx(const LorentzVector &p4) const;
 
    double resolPy(const LorentzVector &p4) const;
 
    double resolPz(const LorentzVector &p4) const;
 
    static int dimensionFrom(Parametrization parametrization) {
      return (static_cast<uint32_t>(parametrization) & 0x0F);
    }
 
    static void fillMatrixFrom(Parametrization parametrization,
                               const std::vector<Scalar> &covariances,
                               AlgebraicSymMatrix44 &covmatrix);
 
  private:
    // persistent
    Parametrization parametrization_;
    std::vector<Scalar> covariances_;
    std::vector<Scalar> constraints_;
 
    // transient
 
    AlgebraicSymMatrix44 covmatrix_;
 
    //methods
 
    void fillMatrix();
 
    void fillVector();
  };
 
  typedef std::vector<CandKinResolution> CandKinResolutionCollection;
  typedef edm::ValueMap<CandKinResolution> CandKinResolutionValueMap;
}  // namespace pat
 
#endif