L1EGammaEEProducer Class Reference

Inheritance diagram for L1EGammaEEProducer:

Public Member Functions
	L1EGammaEEProducer (const edm::ParameterSet &)
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
L1EGammaEECalibrator	calibrator_
edm::EDGetToken	multiclusters_token_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 38 of file L1EGammaEEProducer.cc.

Constructor & Destructor Documentation

L1EGammaEEProducer()

L1EGammaEEProducer::L1EGammaEEProducer ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 49 of file L1EGammaEEProducer.cc.

    : multiclusters_token_(
          consumes<l1t::HGCalMulticlusterBxCollection>(iConfig.getParameter<edm::InputTag>("Multiclusters"))),
      calibrator_(iConfig.getParameter<edm::ParameterSet>("calibrationConfig")) {
  produces<BXVector<l1t::EGamma>>("L1EGammaCollectionBXVWithCuts");
}

Member Function Documentation

produce()

void L1EGammaEEProducer::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overrideprivate

Definition at line 56 of file L1EGammaEEProducer.cc.

                                                                              {
  float minEt_ = 0;
 
  std::unique_ptr<BXVector<l1t::EGamma>> l1EgammaBxCollection(new l1t::EGammaBxCollection);
 
  // retrieve clusters 3D
  edm::Handle<l1t::HGCalMulticlusterBxCollection> multiclusters_h;
  iEvent.getByToken(multiclusters_token_, multiclusters_h);
  const l1t::HGCalMulticlusterBxCollection &multiclusters = *multiclusters_h;
 
  std::vector<const l1t::HGCalMulticluster *> selected_multiclusters;
  std::map<std::pair<int, int>, std::vector<const l1t::HGCalMulticluster *>> etaphi_bins;
 
  // here we loop on the TPGs
  for (auto cl3d = multiclusters.begin(0); cl3d != multiclusters.end(0); cl3d++) {
    if (cl3d->hwQual()) {
      if (cl3d->et() > minEt_) {
        int hw_quality = 1;  // baseline EG ID passed
        if (std::abs(cl3d->eta()) >= 1.52) {
          hw_quality = 2;  // baseline EG ID passed + cleanup of transition region
        }
 
        float calib_factor = calibrator_.calibrationFactor(cl3d->pt(), cl3d->eta());
        l1t::EGamma eg =
            l1t::EGamma(reco::Candidate::PolarLorentzVector(cl3d->pt() / calib_factor, cl3d->eta(), cl3d->phi(), 0.));
        eg.setHwQual(hw_quality);
        eg.setHwIso(1);
        eg.setIsoEt(-1);  // just temporarily as a dummy value
        l1EgammaBxCollection->push_back(0, eg);
        if (hw_quality == 2) {
          // we build the EM interpreted EG object
          l1t::EGamma eg_emint = l1t::EGamma(reco::Candidate::PolarLorentzVector(
              cl3d->iPt(l1t::HGCalMulticluster::EnergyInterpretation::EM), cl3d->eta(), cl3d->phi(), 0.));
          eg_emint.setHwQual(4);
          eg_emint.setHwIso(1);
          eg_emint.setIsoEt(-1);  // just temporarily as a dummy value
          l1EgammaBxCollection->push_back(0, eg_emint);
          // we also prepare for the brem recovery procedure
          selected_multiclusters.push_back(&(*cl3d));
          auto eta_phi_bin = get_eta_phi_bin(&(*cl3d));
          auto bucket = etaphi_bins.find(eta_phi_bin);
          if (bucket == etaphi_bins.end()) {
            std::vector<const l1t::HGCalMulticluster *> vec;
            vec.push_back(&(*cl3d));
            etaphi_bins[eta_phi_bin] = vec;
          } else {
            bucket->second.push_back(&(*cl3d));
          }
        }
      }
    }
  }
 
  std::sort(selected_multiclusters.begin(), selected_multiclusters.end(), l1tp2::compare_cluster_pt);
  std::set<const l1t::HGCalMulticluster *> used_clusters;
  for (const auto &cl3d : selected_multiclusters) {
    if (used_clusters.find(cl3d) == used_clusters.end()) {
      float pt = cl3d->pt();
      // we drop the Had component of the energy
      if (cl3d->hOverE() != -1)
        pt = cl3d->pt() / (1 + cl3d->hOverE());
      reco::Candidate::PolarLorentzVector mom(pt, cl3d->eta(), cl3d->phi(), 0.);
      reco::Candidate::PolarLorentzVector mom_eint(
          cl3d->iPt(l1t::HGCalMulticluster::EnergyInterpretation::EM), cl3d->eta(), cl3d->phi(), 0.);
 
      // this is not yet used
      used_clusters.insert(cl3d);
      auto eta_phi_bin = get_eta_phi_bin(cl3d);
 
      for (int eta_bin : {eta_phi_bin.first - 1, eta_phi_bin.first, eta_phi_bin.first + 1}) {
        for (int phi_bin : {eta_phi_bin.second - 1, eta_phi_bin.second, eta_phi_bin.second + 1}) {
          auto bucket = etaphi_bins.find(std::make_pair(eta_bin, phi_bin));
          if (bucket != etaphi_bins.end()) {
            // this bucket is not empty
            for (const auto &other_cl_ptr : bucket->second) {
              if (used_clusters.find(other_cl_ptr) == used_clusters.end()) {
                if (std::abs(other_cl_ptr->eta() - cl3d->eta()) < 0.02) {
                  if (std::abs(reco::deltaPhi(other_cl_ptr->phi(), cl3d->phi())) < 0.1) {
                    float pt_other = other_cl_ptr->pt();
                    if (other_cl_ptr->hOverE() != -1)
                      pt_other = other_cl_ptr->pt() / (1 + other_cl_ptr->hOverE());
                    mom += reco::Candidate::PolarLorentzVector(pt_other, other_cl_ptr->eta(), other_cl_ptr->phi(), 0.);
                    mom_eint += reco::Candidate::PolarLorentzVector(
                        other_cl_ptr->iPt(l1t::HGCalMulticluster::EnergyInterpretation::EM),
                        other_cl_ptr->eta(),
                        other_cl_ptr->phi(),
                        0.);
                    used_clusters.insert(other_cl_ptr);
                  }
                }
              }
            }
          }
        }
      }
      float calib_factor = calibrator_.calibrationFactor(mom.pt(), mom.eta());
      l1t::EGamma eg =
          l1t::EGamma(reco::Candidate::PolarLorentzVector(mom.pt() / calib_factor, mom.eta(), mom.phi(), 0.));
      eg.setHwQual(3);
      eg.setHwIso(1);
      l1EgammaBxCollection->push_back(0, eg);
 
      l1t::EGamma eg_emint_brec =
          l1t::EGamma(reco::Candidate::PolarLorentzVector(mom_eint.pt(), mom_eint.eta(), mom_eint.phi(), 0.));
      eg_emint_brec.setHwQual(5);
      eg_emint_brec.setHwIso(1);
      l1EgammaBxCollection->push_back(0, eg_emint_brec);
    }
  }
 
  iEvent.put(std::move(l1EgammaBxCollection), "L1EGammaCollectionBXVWithCuts");
}

References funct::abs(), BXVector< T >::begin(), L1EGammaEECalibrator::calibrationFactor(), calibrator_, l1tp2::compare_cluster_pt(), reco::deltaPhi(), HLT_FULL_cff::EGamma, BXVector< T >::end(), get_eta_phi_bin(), iEvent, eostools::move(), multiclusters_token_, DiDispStaMuonMonitor_cfi::pt, l1t::L1Candidate::setHwIso(), l1t::L1Candidate::setHwQual(), l1t::EGamma::setIsoEt(), and jetUpdater_cfi::sort.

Member Data Documentation

calibrator_

L1EGammaEECalibrator L1EGammaEEProducer::calibrator_

private

Definition at line 46 of file L1EGammaEEProducer.cc.

Referenced by produce().

multiclusters_token_

edm::EDGetToken L1EGammaEEProducer::multiclusters_token_

private

Definition at line 45 of file L1EGammaEEProducer.cc.

Referenced by produce().