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"
#include "DataFormats/Common/interface/BoolCache.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 (static_cast<uint32_t>(parametrization_) & 0x0F);
        }

        const AlgebraicSymMatrix44 & covariance()  const { 
            if (!hasMatrix_) { fillMatrix(); hasMatrix_ = true; }
            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 ;

     private:
        // persistent 
        Parametrization parametrization_;
        std::vector<Scalar> covariances_;
        std::vector<Scalar> constraints_;

        // transient

        mutable edm::BoolCache       hasMatrix_;
    
        mutable AlgebraicSymMatrix44 covmatrix_;

        //methods

        void fillMatrix() const ; // const: the matrix is mutable

        void fillVector() ;
  };

  typedef std::vector<CandKinResolution>   CandKinResolutionCollection;
  typedef edm::ValueMap<CandKinResolution> CandKinResolutionValueMap;
}

#endif