/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_7/src/CommonTools/RecoAlgos/src/CandidateProducer.h

Go to the documentation of this file.

#ifndef RecoAlgos_CandidateProducer_h
#define RecoAlgos_CandidateProducer_h

#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/ParameterSet/interface/ParameterSetfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "CommonTools/UtilAlgos/interface/MasterCollectionHelper.h"
#include "CommonTools/UtilAlgos/interface/AnySelector.h"
#include "CommonTools/UtilAlgos/interface/EventSetupInitTrait.h"

namespace converter {
  namespace helper {
    template<typename T>
    struct CandConverter { };
    
    struct ConcreteCreator { 
      template<typename CColl, typename Comp, typename Conv>
      static void create(size_t idx, CColl & cands, const Comp & components, Conv & converter) {
        typename Conv::Candidate c;
        typedef edm::Ref<std::vector<typename Conv::value_type> > ref_type;
        ref_type ref = components.template getConcreteRef<ref_type>(idx);
        converter.convert(ref, c);
        cands.push_back(c);
      }
    };
    
    struct PolymorphicCreator { 
      template<typename CColl, typename Comp, typename Conv>
      static void create(size_t idx, CColl & cands, const Comp & components, Conv & converter) {
        typename Conv::Candidate * c = new typename Conv::Candidate;
        typedef edm::Ref<std::vector<typename Conv::value_type> > ref_type;
        ref_type ref = components.template getConcreteRef<ref_type>(idx);
        converter.convert(ref, * c);
        cands.push_back(c);
      }
    };

    template<typename CColl>
    struct CandCreator { 
      typedef ConcreteCreator type;
    };

    template<>
    struct CandCreator<reco::CandidateCollection> { 
      typedef PolymorphicCreator type;
    };
  }
}

template<typename TColl, typename CColl, typename Selector = AnySelector,
         typename Conv = typename converter::helper::CandConverter<typename TColl::value_type>::type,
         typename Creator = typename converter::helper::CandCreator<CColl>::type,
         typename Init = typename ::reco::modules::EventSetupInit<Selector>::type>
class CandidateProducer : public edm::EDProducer {
public:
  CandidateProducer(const edm::ParameterSet & cfg) :
    src_(cfg.template getParameter<edm::InputTag>("src")), 
    converter_(cfg),
    selector_(reco::modules::make<Selector>(cfg)),
    initialized_(false) {
    produces<CColl>();
  }
  ~CandidateProducer() { }
  
private:
  void beginRun(const edm::Run&, const edm::EventSetup& es) override {
    if (!initialized_) {
      converter_.beginFirstRun(es);
      initialized_ = true;
    }
  }
  void produce(edm::Event& evt, const edm::EventSetup& es) override {
    edm::Handle<TColl> src;
    evt.getByLabel(src_, src);
    Init::init(selector_, evt, es);
    ::helper::MasterCollection<TColl> master(src);
    std::auto_ptr<CColl> cands(new CColl);
    if(src->size()!= 0) {
      size_t size = src->size();
      cands->reserve(size);
      for(size_t idx = 0; idx != size; ++ idx) {
        if(selector_((*src)[idx]))
          Creator::create(master.index(idx), *cands, master, converter_);
      }
    }
    evt.put(cands);
  }
  edm::InputTag src_;
  Conv converter_;
  Selector selector_;
  bool initialized_;
};

#endif