HLTScoutingEgammaProducer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    HLTrigger/Egamma
// Class:      HLTScoutingEgammaProducer
//
//
// Original Author:  David G. Sheffield (Rutgers)
//         Created:  Mon, 20 Jul 2015
//
//
 
#include "HLTScoutingEgammaProducer.h"
 
//
// constructors and destructor
//
HLTScoutingEgammaProducer::HLTScoutingEgammaProducer(const edm::ParameterSet& iConfig)
    : EgammaCandidateCollection_(
          consumes<reco::RecoEcalCandidateCollection>(iConfig.getParameter<edm::InputTag>("EgammaCandidates"))),
      EgammaGsfTrackCollection_(
          consumes<reco::GsfTrackCollection>(iConfig.getParameter<edm::InputTag>("EgammaGsfTracks"))),
      SigmaIEtaIEtaMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("SigmaIEtaIEtaMap"))),
      HoverEMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("HoverEMap"))),
      DetaMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("DetaMap"))),
      DphiMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("DphiMap"))),
      MissingHitsMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("MissingHitsMap"))),
      OneOEMinusOneOPMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("OneOEMinusOneOPMap"))),
      EcalPFClusterIsoMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("EcalPFClusterIsoMap"))),
      EleGsfTrackIsoMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("EleGsfTrackIsoMap"))),
      HcalPFClusterIsoMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("HcalPFClusterIsoMap"))),
      egammaPtCut(iConfig.getParameter<double>("egammaPtCut")),
      egammaEtaCut(iConfig.getParameter<double>("egammaEtaCut")),
      egammaHoverECut(iConfig.getParameter<double>("egammaHoverECut")) {
  //register products
  produces<ScoutingElectronCollection>();
  produces<ScoutingPhotonCollection>();
}
 
HLTScoutingEgammaProducer::~HLTScoutingEgammaProducer() = default;
 
// ------------ method called to produce the data  ------------
void HLTScoutingEgammaProducer::produce(edm::StreamID sid, edm::Event& iEvent, edm::EventSetup const& setup) const {
  using namespace edm;
 
  std::unique_ptr<ScoutingElectronCollection> outElectrons(new ScoutingElectronCollection());
  std::unique_ptr<ScoutingPhotonCollection> outPhotons(new ScoutingPhotonCollection());
 
  // Get RecoEcalCandidate
  Handle<reco::RecoEcalCandidateCollection> EgammaCandidateCollection;
  if (!iEvent.getByToken(EgammaCandidateCollection_, EgammaCandidateCollection)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Get GsfTrack
  Handle<reco::GsfTrackCollection> EgammaGsfTrackCollection;
  if (!iEvent.getByToken(EgammaGsfTrackCollection_, EgammaGsfTrackCollection)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Get SigmaIEtaIEtaMap
  Handle<RecoEcalCandMap> SigmaIEtaIEtaMap;
  if (!iEvent.getByToken(SigmaIEtaIEtaMap_, SigmaIEtaIEtaMap)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Get HoverEMap
  Handle<RecoEcalCandMap> HoverEMap;
  if (!iEvent.getByToken(HoverEMap_, HoverEMap)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Get DetaMap
  Handle<RecoEcalCandMap> DetaMap;
  if (!iEvent.getByToken(DetaMap_, DetaMap)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Get DphiMap
  Handle<RecoEcalCandMap> DphiMap;
  if (!iEvent.getByToken(DphiMap_, DphiMap)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Get MissingHitsMap
  Handle<RecoEcalCandMap> MissingHitsMap;
  if (!iEvent.getByToken(MissingHitsMap_, MissingHitsMap)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Get 1/E - 1/p Map
  Handle<RecoEcalCandMap> OneOEMinusOneOPMap;
  if (!iEvent.getByToken(OneOEMinusOneOPMap_, OneOEMinusOneOPMap)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Get EcalPFClusterIsoMap
  Handle<RecoEcalCandMap> EcalPFClusterIsoMap;
  if (!iEvent.getByToken(EcalPFClusterIsoMap_, EcalPFClusterIsoMap)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Get EleGsfTrackIsoMap
  Handle<RecoEcalCandMap> EleGsfTrackIsoMap;
  if (!iEvent.getByToken(EleGsfTrackIsoMap_, EleGsfTrackIsoMap)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Get HcalPFClusterIsoMap
  Handle<RecoEcalCandMap> HcalPFClusterIsoMap;
  if (!iEvent.getByToken(HcalPFClusterIsoMap_, HcalPFClusterIsoMap)) {
    iEvent.put(std::move(outElectrons));
    iEvent.put(std::move(outPhotons));
    return;
  }
 
  // Produce electrons and photons
  int index = 0;
  for (auto& candidate : *EgammaCandidateCollection) {
    reco::RecoEcalCandidateRef candidateRef = getRef(EgammaCandidateCollection, index);
    ++index;
    if (candidateRef.isNull() && !candidateRef.isAvailable())
      continue;
 
    if ((*HoverEMap)[candidateRef] > egammaHoverECut)
      continue;
    if (candidate.pt() < egammaPtCut)
      continue;
    if (fabs(candidate.eta()) > egammaEtaCut)
      continue;
 
    reco::SuperClusterRef scRef = candidate.superCluster();
    if (scRef.isNull() && !scRef.isAvailable())
      continue;
    float d0 = 0.0;
    float dz = 0.0;
    int charge = -999;
    for (auto& track : *EgammaGsfTrackCollection) {
      RefToBase<TrajectorySeed> seed = track.extra()->seedRef();
      reco::ElectronSeedRef elseed = seed.castTo<reco::ElectronSeedRef>();
      RefToBase<reco::CaloCluster> caloCluster = elseed->caloCluster();
      reco::SuperClusterRef scRefFromTrk = caloCluster.castTo<reco::SuperClusterRef>();
      if (scRefFromTrk == scRef) {
        d0 = track.d0();
        dz = track.dz();
        charge = track.charge();
      }
    }
    if (charge == -999) {  // No associated track. Candidate is a scouting photon
      outPhotons->emplace_back(candidate.pt(),
                               candidate.eta(),
                               candidate.phi(),
                               candidate.mass(),
                               (*SigmaIEtaIEtaMap)[candidateRef],
                               (*HoverEMap)[candidateRef],
                               (*EcalPFClusterIsoMap)[candidateRef],
                               (*HcalPFClusterIsoMap)[candidateRef]);
    } else {  // Candidate is a scouting electron
      outElectrons->emplace_back(candidate.pt(),
                                 candidate.eta(),
                                 candidate.phi(),
                                 candidate.mass(),
                                 d0,
                                 dz,
                                 (*DetaMap)[candidateRef],
                                 (*DphiMap)[candidateRef],
                                 (*SigmaIEtaIEtaMap)[candidateRef],
                                 (*HoverEMap)[candidateRef],
                                 (*OneOEMinusOneOPMap)[candidateRef],
                                 (*MissingHitsMap)[candidateRef],
                                 charge,
                                 (*EcalPFClusterIsoMap)[candidateRef],
                                 (*HcalPFClusterIsoMap)[candidateRef],
                                 (*EleGsfTrackIsoMap)[candidateRef]);
    }
  }
 
  // Put output
  iEvent.put(std::move(outElectrons));
  iEvent.put(std::move(outPhotons));
}
 
// ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
void HLTScoutingEgammaProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("EgammaCandidates", edm::InputTag("hltEgammaCandidates"));
  desc.add<edm::InputTag>("EgammaGsfTracks", edm::InputTag("hltEgammaGsfTracks"));
  desc.add<edm::InputTag>("SigmaIEtaIEtaMap", edm::InputTag("hltEgammaClusterShape:sigmaIEtaIEta5x5"));
  desc.add<edm::InputTag>("HoverEMap", edm::InputTag("hltEgammaHoverE"));
  desc.add<edm::InputTag>("DetaMap", edm::InputTag("hltEgammaGsfTrackVars:Deta"));
  desc.add<edm::InputTag>("DphiMap", edm::InputTag("hltEgammaGsfTrackVars:Dphi"));
  desc.add<edm::InputTag>("MissingHitsMap", edm::InputTag("hltEgammaGsfTrackVars:MissingHits"));
  desc.add<edm::InputTag>("OneOEMinusOneOPMap", edm::InputTag("hltEgammaGsfTrackVars:OneOESuperMinusOneOP"));
  desc.add<edm::InputTag>("EcalPFClusterIsoMap", edm::InputTag("hltEgammaEcalPFClusterIso"));
  desc.add<edm::InputTag>("EleGsfTrackIsoMap", edm::InputTag("hltEgammaEleGsfTrackIso"));
  desc.add<edm::InputTag>("HcalPFClusterIsoMap", edm::InputTag("hltEgammaHcalPFClusterIso"));
  desc.add<double>("egammaPtCut", 4.0);
  desc.add<double>("egammaEtaCut", 2.5);
  desc.add<double>("egammaHoverECut", 1.0);
  descriptions.add("hltScoutingEgammaProducer", desc);
}
 
// declare this class as a framework plugin
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(HLTScoutingEgammaProducer);