MTDUncalibratedRecHitProducer.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"

#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/FTLDigi/interface/FTLDigiCollections.h"
#include "DataFormats/FTLRecHit/interface/FTLRecHitCollections.h"

#include "RecoLocalFastTime/FTLCommonAlgos/interface/MTDUncalibratedRecHitAlgoBase.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"

class MTDUncalibratedRecHitProducer : public edm::stream::EDProducer<> {
  
 public:
  explicit MTDUncalibratedRecHitProducer(const edm::ParameterSet& ps);
  ~MTDUncalibratedRecHitProducer() override;
  void produce(edm::Event& evt, const edm::EventSetup& es) override;
  
 private:
  
  const edm::EDGetTokenT<BTLDigiCollection> ftlbDigis_; // collection of BTL digis
  const edm::EDGetTokenT<ETLDigiCollection> ftleDigis_; // collection of ETL digis
  
  const std::string ftlbInstance_; // instance name of barrel hits
  const std::string ftleInstance_; // instance name of endcap hits
  
  std::unique_ptr<BTLUncalibratedRecHitAlgoBase> barrel_;
  std::unique_ptr<ETLUncalibratedRecHitAlgoBase> endcap_;
};

MTDUncalibratedRecHitProducer::MTDUncalibratedRecHitProducer(const edm::ParameterSet& ps) :
  ftlbDigis_( consumes<BTLDigiCollection>( ps.getParameter<edm::InputTag>("barrelDigis") ) ),
  ftleDigis_( consumes<ETLDigiCollection>( ps.getParameter<edm::InputTag>("endcapDigis") ) ),
  ftlbInstance_( ps.getParameter<std::string>("BarrelHitsName") ),
  ftleInstance_( ps.getParameter<std::string>("EndcapHitsName") ) {

  produces< FTLUncalibratedRecHitCollection >(ftlbInstance_);
  produces< FTLUncalibratedRecHitCollection >(ftleInstance_);

  auto sumes = consumesCollector();

  const edm::ParameterSet& barrel = ps.getParameterSet("barrel");
  const std::string& barrelAlgo = barrel.getParameter<std::string>("algoName");
  barrel_ = std::unique_ptr<BTLUncalibratedRecHitAlgoBase>{ BTLUncalibratedRecHitAlgoFactory::get()->create(barrelAlgo, barrel, sumes) };

  const edm::ParameterSet& endcap = ps.getParameterSet("endcap");
  const std::string& endcapAlgo = endcap.getParameter<std::string>("algoName");
  endcap_ = std::unique_ptr<ETLUncalibratedRecHitAlgoBase>{ ETLUncalibratedRecHitAlgoFactory::get()->create(endcapAlgo, endcap, sumes) };
}

MTDUncalibratedRecHitProducer::~MTDUncalibratedRecHitProducer() {
}

void
MTDUncalibratedRecHitProducer::produce(edm::Event& evt, const edm::EventSetup& es) {

  // tranparently get things from event setup
  barrel_->getEventSetup(es);
  endcap_->getEventSetup(es);

  barrel_->getEvent(evt);
  endcap_->getEvent(evt);
  
  // prepare output
  auto barrelRechits = std::make_unique<FTLUncalibratedRecHitCollection>();
  auto endcapRechits = std::make_unique<FTLUncalibratedRecHitCollection>();
  
  edm::Handle< BTLDigiCollection > hBarrel;
  evt.getByToken( ftlbDigis_, hBarrel );  
  barrelRechits->reserve(hBarrel->size()/2);
  for(const auto& digi : *hBarrel) {
    barrelRechits->emplace_back( barrel_->makeRecHit(digi) );
  }

  edm::Handle< ETLDigiCollection > hEndcap;
  evt.getByToken( ftleDigis_, hEndcap );  
  endcapRechits->reserve(hEndcap->size()/2);
  for(const auto& digi : *hEndcap) {
    endcapRechits->emplace_back( endcap_->makeRecHit(digi) );
  }

  // put the collection of recunstructed hits in the event
  evt.put(std::move(barrelRechits), ftlbInstance_);
  evt.put(std::move(endcapRechits), ftleInstance_);
}

#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE( MTDUncalibratedRecHitProducer );