HcalRawToDigiFake.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/global/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <iostream>
#include <unordered_set>
#include <string>
 
//helper
namespace raw_impl {
  template <class T>
  void get(edm::EDGetTokenT<T> tok, edm::Event& e, const std::string& productName = "") {
    edm::Handle<T> h_coll;
    e.getByToken(tok, h_coll);
    auto o_coll = std::make_unique<T>();
    if (h_coll.isValid()) {
      //copy constructor
      o_coll = std::make_unique<T>(*(h_coll.product()));
    }
    if (!productName.empty())
      e.put(std::move(o_coll), productName);
    else
      e.put(std::move(o_coll));
  }
}  // namespace raw_impl
 
class HcalRawToDigiFake : public edm::global::EDProducer<> {
public:
  explicit HcalRawToDigiFake(const edm::ParameterSet& ps);
  ~HcalRawToDigiFake() override;
  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
  void produce(edm::StreamID id, edm::Event& e, const edm::EventSetup& c) const override;
 
private:
  //members
  edm::EDGetTokenT<QIE10DigiCollection> tok_QIE10DigiCollection_;
  edm::EDGetTokenT<QIE11DigiCollection> tok_QIE11DigiCollection_;
  edm::EDGetTokenT<HBHEDigiCollection> tok_HBHEDigiCollection_;
  edm::EDGetTokenT<HFDigiCollection> tok_HFDigiCollection_;
  edm::EDGetTokenT<HODigiCollection> tok_HODigiCollection_;
  edm::EDGetTokenT<HcalTrigPrimDigiCollection> tok_TPDigiCollection_;
  edm::EDGetTokenT<HOTrigPrimDigiCollection> tok_HOTPDigiCollection_;
  edm::EDGetTokenT<HcalCalibDigiCollection> tok_CalibDigiCollection_;
  edm::EDGetTokenT<ZDCDigiCollection> tok_ZDCDigiCollection_;
  edm::EDGetTokenT<QIE10DigiCollection> tok_ZDCQIE10DigiCollection_;
  edm::EDGetTokenT<HcalTTPDigiCollection> tok_TTPDigiCollection_;
  const bool unpackCalib_, unpackZDC_, unpackTTP_;
};
 
HcalRawToDigiFake::HcalRawToDigiFake(edm::ParameterSet const& conf)
    : tok_QIE10DigiCollection_(consumes<QIE10DigiCollection>(conf.getParameter<edm::InputTag>("QIE10"))),
      tok_QIE11DigiCollection_(consumes<QIE11DigiCollection>(conf.getParameter<edm::InputTag>("QIE11"))),
      tok_HBHEDigiCollection_(consumes<HBHEDigiCollection>(conf.getParameter<edm::InputTag>("HBHE"))),
      tok_HFDigiCollection_(consumes<HFDigiCollection>(conf.getParameter<edm::InputTag>("HF"))),
      tok_HODigiCollection_(consumes<HODigiCollection>(conf.getParameter<edm::InputTag>("HO"))),
      tok_TPDigiCollection_(consumes<HcalTrigPrimDigiCollection>(conf.getParameter<edm::InputTag>("TRIG"))),
      tok_HOTPDigiCollection_(consumes<HOTrigPrimDigiCollection>(conf.getParameter<edm::InputTag>("HOTP"))),
      tok_CalibDigiCollection_(consumes<HcalCalibDigiCollection>(conf.getParameter<edm::InputTag>("CALIB"))),
      tok_ZDCDigiCollection_(consumes<ZDCDigiCollection>(conf.getParameter<edm::InputTag>("ZDC"))),
      tok_ZDCQIE10DigiCollection_(consumes<QIE10DigiCollection>(conf.getParameter<edm::InputTag>("ZDCQIE10"))),
      tok_TTPDigiCollection_(consumes<HcalTTPDigiCollection>(conf.getParameter<edm::InputTag>("TTP"))),
      unpackCalib_(conf.getParameter<bool>("UnpackCalib")),
      unpackZDC_(conf.getParameter<bool>("UnpackZDC")),
      unpackTTP_(conf.getParameter<bool>("UnpackTTP")) {
  // products produced...
  produces<QIE10DigiCollection>();
  produces<QIE11DigiCollection>();
  produces<HBHEDigiCollection>();
  produces<HFDigiCollection>();
  produces<HODigiCollection>();
  produces<HcalTrigPrimDigiCollection>();
  produces<HOTrigPrimDigiCollection>();
  if (unpackCalib_)
    produces<HcalCalibDigiCollection>();
  if (unpackZDC_)
    produces<ZDCDigiCollection>();
  if (unpackTTP_)
    produces<HcalTTPDigiCollection>();
  produces<QIE10DigiCollection>("ZDC");
}
 
// Virtual destructor needed.
HcalRawToDigiFake::~HcalRawToDigiFake() {}
 
void HcalRawToDigiFake::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<bool>("UnpackZDC", true);
  desc.add<bool>("UnpackCalib", true);
  desc.add<bool>("UnpackTTP", true);
  //empty tag = not usually produced by simulation
  desc.add<edm::InputTag>("QIE10", edm::InputTag("simHcalDigis", "HFQIE10DigiCollection"));
  desc.add<edm::InputTag>("QIE11", edm::InputTag("simHcalDigis", "HBHEQIE11DigiCollection"));
  desc.add<edm::InputTag>("HBHE", edm::InputTag("simHcalDigis"));
  desc.add<edm::InputTag>("HF", edm::InputTag("simHcalDigis"));
  desc.add<edm::InputTag>("HO", edm::InputTag("simHcalDigis"));
  desc.add<edm::InputTag>("TRIG", edm::InputTag("simHcalTriggerPrimitiveDigis"));
  desc.add<edm::InputTag>("HOTP", edm::InputTag(""));
  desc.add<edm::InputTag>("CALIB", edm::InputTag(""));
  desc.add<edm::InputTag>("ZDC", edm::InputTag("simHcalUnsuppressedDigis"));
  desc.add<edm::InputTag>("ZDCQIE10", edm::InputTag(""));
  desc.add<edm::InputTag>("TTP", edm::InputTag(""));
  //not used, just for compatibility
  desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
  desc.add<int>("firstSample", 0);
  desc.add<int>("lastSample", 0);
  descriptions.add("HcalRawToDigiFake", desc);
}
 
// Functions that gets called by framework every event
void HcalRawToDigiFake::produce(edm::StreamID id, edm::Event& e, const edm::EventSetup& es) const {
  //handle each collection
  raw_impl::get(tok_QIE10DigiCollection_, e);
  raw_impl::get(tok_QIE11DigiCollection_, e);
  raw_impl::get(tok_HBHEDigiCollection_, e);
  raw_impl::get(tok_HFDigiCollection_, e);
  raw_impl::get(tok_HODigiCollection_, e);
  raw_impl::get(tok_TPDigiCollection_, e);
  raw_impl::get(tok_HOTPDigiCollection_, e);
  if (unpackCalib_)
    raw_impl::get(tok_CalibDigiCollection_, e);
  if (unpackZDC_)
    raw_impl::get(tok_ZDCDigiCollection_, e);
  raw_impl::get(tok_ZDCQIE10DigiCollection_, e, "ZDC");
  if (unpackTTP_)
    raw_impl::get(tok_TTPDigiCollection_, e);
}
 
DEFINE_FWK_MODULE(HcalRawToDigiFake);