VertexingHelper.h

Go to the documentation of this file.

#ifndef PhysicsTools_PatAlgos_interface_VertexingHelper_h
#define PhysicsTools_PatAlgos_interface_VertexingHelper_h

#include "DataFormats/PatCandidates/interface/Vertexing.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "PhysicsTools/PatUtils/interface/VertexAssociationSelector.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/Event.h"

#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"

#include "PhysicsTools/UtilAlgos/interface/ParameterAdapter.h"
namespace reco {
    namespace modules {
        template<> 
        struct ParameterAdapter<pat::VertexAssociationSelector> { 
            static pat::VertexAssociationSelector make(const edm::ParameterSet & iConfig) {
                pat::VertexAssociationSelector::Config assoconf;
                if (iConfig.existsAs<double>("deltaZ"))  assoconf.dZ = iConfig.getParameter<double>("deltaZ");
                if (iConfig.existsAs<double>("deltaR"))  assoconf.dR = iConfig.getParameter<double>("deltaR");
                if (iConfig.existsAs<double>("sigmasZ")) assoconf.sigmasZ = iConfig.getParameter<double>("sigmasZ");
                if (iConfig.existsAs<double>("sigmasR")) assoconf.sigmasR = iConfig.getParameter<double>("sigmasR");
                return pat::VertexAssociationSelector(assoconf);
            }
        };
    }
}

namespace pat { namespace helper {
    class VertexingHelper {
        public:
            VertexingHelper() : enabled_(false) {}
            VertexingHelper(const edm::ParameterSet &iConfig) ;
    
            bool enabled() const {  return enabled_; }

            void newEvent(const edm::Event &event) ;

            void newEvent(const edm::Event &event, const edm::EventSetup & setup) ;

            template<typename AnyCandRef>
            pat::VertexAssociation  operator()(const AnyCandRef &) const ;

        private: 
            bool enabled_;
        
            bool playback_;
       
            pat::VertexAssociationSelector assoSelector_;

            //-------- Tools for production of vertex associations -------
            edm::InputTag vertices_;
            edm::Handle<reco::VertexCollection > vertexHandle_;
            bool useTracks_;
            edm::ESHandle<TransientTrackBuilder> ttBuilder_;
          
            //--------- Tools for reading vertex associations (playback mode) ----- 
            edm::InputTag vertexAssociations_;
            edm::Handle<edm::ValueMap<pat::VertexAssociation> > vertexAssoMap_;

            reco::TrackBaseRef  getTrack_(const reco::Candidate &c) const ;
            
            pat::VertexAssociation associate(const reco::Candidate &) const ;

    }; // class

    template<typename AnyCandRef>
    pat::VertexAssociation
    pat::helper::VertexingHelper::operator()(const AnyCandRef &cand) const 
    {
        if (playback_) {
            const pat::VertexAssociation &assoc = (*vertexAssoMap_)[cand];
            return assoSelector_(assoc) ? assoc : pat::VertexAssociation();
        } else {
            return associate( *cand );
        }

    }

} }




#endif