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