BaseTreeFiller.h

Go to the documentation of this file.

#ifndef PhysicsTools_TagAndProbe_BaseTreeFiller_h
#define PhysicsTools_TagAndProbe_BaseTreeFiller_h

#include <vector>
#include <string>
#include <stdint.h>

#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "DataFormats/METReco/interface/MET.h"
#include "DataFormats/METReco/interface/METCollection.h"
#include "DataFormats/METReco/interface/CaloMET.h"
#include "DataFormats/METReco/interface/CaloMETCollection.h"
#include "DataFormats/METReco/interface/PFMET.h"
#include "DataFormats/METReco/interface/PFMETCollection.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "CommonTools/Utils/interface/StringCutObjectSelector.h"
#include "CommonTools/Utils/interface/StringObjectFunction.h"

#include <TTree.h>
#include <boost/utility.hpp>


namespace tnp {

class ProbeVariable {
    public:
        ProbeVariable(const std::string &name, const std::string &expression) :
            name_(name), external_(false), function_(expression) {}

        ProbeVariable(const std::string &name, const edm::EDGetTokenT<edm::ValueMap<float> > &srcToken) :
            name_(name), external_(true), function_("-1"), srcToken_(srcToken) {}

        ~ProbeVariable() ;

        float * address() const { return &value_; }

        const std::string & name() const { return name_; }

        void init(const edm::Event &iEvent) const {
            if (external_) iEvent.getByToken(srcToken_, handle_);
        }

        void fill(const reco::CandidateBaseRef &probe) const {
            value_ = external_ ? (*handle_)[probe] : function_(*probe);
        }

    private:
        std::string name_;
        mutable float value_;

        bool external_;
        // ---- this below is used if 'external_' is false
        StringObjectFunction<reco::Candidate,true> function_;
        // In releases older than 3.4.X, it can be parially emulated by PATStringObjectFunction (PhysicsTools/PatUtils/interface/StringParserTools.h)
        // Or you can use StringObjectFunction<reco::Candidate> and get only reco::Candidate methods

        // ---- this below is used if 'external_' is true
        edm::EDGetTokenT<edm::ValueMap<float> > srcToken_;
        mutable edm::Handle<edm::ValueMap<float> > handle_;
};

class ProbeFlag {
    public:
        ProbeFlag(const std::string &name, const std::string &cut) :
            name_(name), external_(false), cut_(cut) {}

        ProbeFlag(const std::string &name, const edm::EDGetTokenT<edm::View<reco::Candidate> > &srcToken) :
            name_(name), external_(true), cut_(""), srcToken_(srcToken) {}

        ~ProbeFlag() ;

        int32_t * address() const { return &value_; }

        const std::string & name() const { return name_; }

        void init(const edm::Event &iEvent) const ;

        void fill(const reco::CandidateBaseRef &probe) const ;

    private:
        std::string name_;
        mutable int32_t value_;

        bool external_;
        // ---- this below is used if 'external_' is false
        StringCutObjectSelector<reco::Candidate,true> cut_;

        // ---- this below is used if 'external_' is true
        edm::EDGetTokenT<edm::View<reco::Candidate> > srcToken_;
        mutable std::vector<reco::CandidateBaseRef> passingProbes_;
};


// This class inherits from boost::noncopyable, as copying it would break the addresses in the TTree
class BaseTreeFiller : boost::noncopyable {
    public:
        BaseTreeFiller(const char *name, const edm::ParameterSet& config, edm::ConsumesCollector && iC) : BaseTreeFiller(name, config, iC) {};
        BaseTreeFiller(const char *name, const edm::ParameterSet& config, edm::ConsumesCollector & iC);

        BaseTreeFiller(BaseTreeFiller &main, const edm::ParameterSet &iConfig, edm::ConsumesCollector && iC, const std::string &branchNamePrefix);

        ~BaseTreeFiller();

        //implementation notice: we declare 'const' the methods which don't change the configuration
        //                       and that can't mess up the addresses in the TTree.

        void init(const edm::Event &iEvent) const ;

        void fill(const reco::CandidateBaseRef &probe) const ;

        void writeProvenance(const edm::ParameterSet &pset) const ;

    //get the pileup weight informations
    bool storePUweight() const {return storePUweight_;};

    protected:

        std::vector<ProbeVariable> vars_;
        std::vector<ProbeFlag>     flags_;

        enum WeightMode { None, Fixed, External };
        WeightMode weightMode_;
        edm::EDGetTokenT<double> weightSrcToken_;
    edm::EDGetTokenT<double> PUweightSrcToken_;
        edm::EDGetTokenT<reco::VertexCollection> recVtxsToken_;
        edm::EDGetTokenT<reco::BeamSpot> beamSpotToken_;
        edm::EDGetTokenT<reco::CaloMETCollection> metToken_;
        edm::EDGetTokenT<reco::METCollection> tcmetToken_;
        edm::EDGetTokenT<reco::PFMETCollection> pfmetToken_;

        bool ignoreExceptions_;

        bool addRunLumiInfo_;

    bool storePUweight_;

    bool addEventVariablesInfo_;

        void addBranches_(TTree *tree, const edm::ParameterSet &iConfig, edm::ConsumesCollector & iC, const std::string &branchNamePrefix="") ;

        //implementation notice: these two are 'mutable' because we will fill them from a 'const' method
        mutable TTree * tree_;
        mutable float weight_;
    mutable float PUweight_;
        mutable uint32_t run_, lumi_, mNPV_;
        mutable uint64_t event_;

        mutable float mPVx_,mPVy_,mPVz_,mBSx_,mBSy_,mBSz_;

        mutable float mMET_,mSumET_,mMETSign_,mtcMET_,mtcSumET_,
      mtcMETSign_,mpfMET_,mpfSumET_,mpfMETSign_;
};


} //namespace

#endif