L1EGammaEEProducer Class Reference

Inheritance diagram for L1EGammaEEProducer:

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

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<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 37 of file L1EGammaEEProducer.cc.

Constructor & Destructor Documentation

L1EGammaEEProducer()

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

explicit

Definition at line 48 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 55 of file L1EGammaEEProducer.cc.

References funct::abs(), BXVector< T >::begin(), L1EGammaEECalibrator::calibrationFactor(), calibrator_, l1tp2::compare_cluster_pt(), reco::deltaPhi(), HLT_2022v12_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.

                                                                              {
  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");
}

Member Data Documentation

calibrator_

L1EGammaEECalibrator L1EGammaEEProducer::calibrator_

private

Definition at line 45 of file L1EGammaEEProducer.cc.

Referenced by produce().

multiclusters_token_

edm::EDGetToken L1EGammaEEProducer::multiclusters_token_

private

Definition at line 44 of file L1EGammaEEProducer.cc.

Referenced by produce().