PATDiObjectProxy.h

Go to the documentation of this file.

#ifndef PhysicsTools_PatUtils_interface_PATDiObjectProxy_h
#define PhysicsTools_PatUtils_interface_PATDiObjectProxy_h

#include "DataFormats/Math/interface/deltaR.h"
#include "Utilities/General/interface/ClassName.h"

#include "DataFormats/PatCandidates/interface/Electron.h"
#include "DataFormats/PatCandidates/interface/Muon.h"
#include "DataFormats/PatCandidates/interface/Tau.h"
#include "DataFormats/PatCandidates/interface/Photon.h"
#include "DataFormats/PatCandidates/interface/Jet.h"
#include "DataFormats/PatCandidates/interface/MET.h"
#include "DataFormats/PatCandidates/interface/GenericParticle.h"
#include "DataFormats/PatCandidates/interface/PFParticle.h"

namespace pat {

/* Now we implement PATDiObjectProxy with typeid & static_casts on the fly. */
class DiObjectProxy {

   public: 
        DiObjectProxy() : cand1_(0), cand2_(0), type1_(0), type2_(0), totalP4ok_(false), totalP4_()  {}
        DiObjectProxy(const reco::Candidate &c1, const reco::Candidate &c2) :
            cand1_(&c1), cand2_(&c2), type1_(&typeid(c1)), type2_(&typeid(c2)), totalP4ok_(false), totalP4_() {}
        
        const reco::Candidate & cand1() const { return *cand1_; }
        const reco::Candidate & cand2() const { return *cand2_; }

        double deltaR() const { return ::deltaR(*cand1_, *cand2_); }
        double deltaPhi() const { return ::deltaPhi(cand1_->phi(), cand2_->phi()); }

        // Implementation notice: return by const reference, not by value, 
        // as it's easier for Reflex.
        const reco::Candidate::LorentzVector & totalP4() const { 
            if (!totalP4ok_) { 
                totalP4_ = cand1_->p4() + cand2_->p4(); 
                totalP4ok_ = true; 
            }
            return totalP4_;
        }

        const Electron & ele()  const { return tryGetOne_<Electron>(); }
        const Muon & mu()  const { return tryGetOne_<Muon>(); }
        const Tau & tau()  const { return tryGetOne_<Tau>(); }
        const Photon & gam()  const { return tryGetOne_<Photon>(); }
        const Jet & jet()  const { return tryGetOne_<Jet>(); }
        const MET & met()  const { return tryGetOne_<MET>(); }
        const GenericParticle & part()  const { return tryGetOne_<GenericParticle>(); }
        const PFParticle & pf()  const { return tryGetOne_<PFParticle>(); }

        const Electron & ele1() const { return tryGet_<Electron>(cand1_, type1_); }
        const Muon & mu1()  const { return tryGet_<Muon>(cand1_, type1_); }
        const Tau & tau1()  const { return tryGet_<Tau>(cand1_, type1_); }
        const Photon & gam1()  const { return tryGet_<Photon>(cand1_, type1_); }
        const Jet & jet1()  const { return tryGet_<Jet>(cand1_, type1_); }
        const MET & met1()  const { return tryGet_<MET>(cand1_, type1_); }
        const GenericParticle & part1()  const { return tryGet_<GenericParticle>(cand1_, type1_); }
        const PFParticle & pf1()  const { return tryGet_<PFParticle>(cand1_, type1_); }

        const Electron & ele2() const { return tryGet_<Electron>(cand2_, type2_); }
        const Muon & mu2()  const { return tryGet_<Muon>(cand2_, type2_); }
        const Tau & tau2()  const { return tryGet_<Tau>(cand2_, type2_); }
        const Photon & gam2()  const { return tryGet_<Photon>(cand2_, type2_); }
        const Jet & jet2()  const { return tryGet_<Jet>(cand2_, type2_); }
        const MET & met2()  const { return tryGet_<MET>(cand2_, type2_); }
        const GenericParticle & part2()  const { return tryGet_<GenericParticle>(cand2_, type2_); }
        const PFParticle & pf2()  const { return tryGet_<PFParticle>(cand2_, type2_); }

    private:

        template<typename T>
        const T & tryGet_(const reco::Candidate *ptr, const std::type_info *type) const {
            if (typeid(T) != *type) {
                throw cms::Exception("Type Error") << "pat::DiObjectProxy: the object of the pair is not of the type you request.\n" 
                                                   << " Item Index in pair: " << (ptr == cand1_ ? "first" : "second") << "\n"
                                                   << " Requested TypeID  : " << ClassName<T>::name() << "\n"
                                                   << " Found TypeID      : " << className(*ptr) << "\n";
            }
            return static_cast<const T &>(*ptr);
        }

        template<typename T> 
        const T & tryGetOne_() const {
            if (typeid(T) == *type1_) {
                if (typeid(T) == *type2_) {
                    throw cms::Exception("Type Error") << "pat::DiObjectProxy: " << 
                        "you can't get use methods that get a particle by type if the two are of the same type!\n" <<
                        " Requested Type:" << ClassName<T>::name() << "\n";
                }
                return static_cast<const T &>(*cand1_);
            } else {
                if (typeid(T) != *type2_) {
                    throw cms::Exception("Type Error") << "pat::DiObjectProxy: " << 
                        "you can't get use methods that get a particle by type if neither of the two is of that type!\n" <<
                        " Requested Type:" << ClassName<T>::name() << "\n" <<
                        " Type of first :" << className(*cand1_) << "\n" <<
                        " Type of second:" << className(*cand2_) << "\n";
                }
                return static_cast<const T &>(*cand2_);
            }
        }

       const reco::Candidate  *cand1_, *cand2_;
       const std::type_info   *type1_, *type2_;

       mutable bool totalP4ok_;
       mutable reco::Candidate::LorentzVector totalP4_;
       

};

}
#endif