GEDGsfElectronFinalizer Class Reference

Inheritance diagram for GEDGsfElectronFinalizer:

Public Member Functions
	GEDGsfElectronFinalizer (const edm::ParameterSet &)
void	produce (edm::Event &, const edm::EventSetup &) override
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 Attributes
std::unique_ptr< ModifyObjectValueBase >	gedRegression_
const edm::EDGetTokenT< reco::PFCandidateCollection >	pfCandidates_
const edm::EDGetTokenT< reco::GsfElectronCollection >	previousGsfElectrons_
const edm::EDPutTokenT< reco::GsfElectronCollection >	putToken_
std::vector< edm::EDGetTokenT< edm::ValueMap< float > > >	tokenElectronIsoVals_

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 12 of file GEDGsfElectronFinalizer.cc.

Constructor & Destructor Documentation

GEDGsfElectronFinalizer()

GEDGsfElectronFinalizer::GEDGsfElectronFinalizer ( const edm::ParameterSet &  cfg )

explicit

Definition at line 32 of file GEDGsfElectronFinalizer.cc.

    : previousGsfElectrons_(consumes<GsfElectronCollection>(cfg.getParameter<InputTag>("previousGsfElectronsTag"))),
      pfCandidates_(consumes<reco::PFCandidateCollection>(cfg.getParameter<InputTag>("pfCandidatesTag"))),
      putToken_{produces<reco::GsfElectronCollection>()} {
  edm::ParameterSet pfIsoVals(cfg.getParameter<edm::ParameterSet>("pfIsolationValues"));

  tokenElectronIsoVals_ = {consumes<ValueMap<float> >(pfIsoVals.getParameter<InputTag>("pfSumChargedHadronPt")),
                           consumes<ValueMap<float> >(pfIsoVals.getParameter<InputTag>("pfSumPhotonEt")),
                           consumes<ValueMap<float> >(pfIsoVals.getParameter<InputTag>("pfSumNeutralHadronEt")),
                           consumes<ValueMap<float> >(pfIsoVals.getParameter<InputTag>("pfSumPUPt")),
                           consumes<ValueMap<float> >(pfIsoVals.getParameter<InputTag>("pfSumEcalClusterEt")),
                           consumes<ValueMap<float> >(pfIsoVals.getParameter<InputTag>("pfSumHcalClusterEt"))};

  if (cfg.existsAs<edm::ParameterSet>("regressionConfig")) {
    auto const& iconf = cfg.getParameterSet("regressionConfig");
    auto const& mname = iconf.getParameter<std::string>("modifierName");
    auto cc = consumesCollector();
    gedRegression_ = ModifyObjectValueFactory::get()->create(mname, iconf, cc);
  }
}

Member Function Documentation

produce()

void GEDGsfElectronFinalizer::produce ( edm::Event &  event, const edm::EventSetup &  setup  )

override

Definition at line 53 of file GEDGsfElectronFinalizer.cc.

References funct::abs(), gedRegression_, reco::GsfElectron::gsfTrack(), mps_fire::i, eostools::move(), reco::GsfElectron::mvaOutput(), pfCandidates_, previousGsfElectrons_, putToken_, reco::GsfElectron::setMvaOutput(), reco::GsfElectron::setPassPflowPreselection(), reco::GsfElectron::setPfIsolationVariables(), singleTopDQM_cfi::setup, reco::GsfElectron::MvaOutput::status, reco::GsfElectron::PflowIsolationVariables::sumChargedHadronPt, reco::GsfElectron::PflowIsolationVariables::sumEcalClusterEt, reco::GsfElectron::PflowIsolationVariables::sumHcalClusterEt, reco::GsfElectron::PflowIsolationVariables::sumNeutralHadronEt, reco::GsfElectron::PflowIsolationVariables::sumPhotonEt, reco::GsfElectron::PflowIsolationVariables::sumPUPt, and tokenElectronIsoVals_.

                                                                                 {
  // Output collection
  reco::GsfElectronCollection outputElectrons;

  if (gedRegression_) {
    gedRegression_->setEvent(event);
    gedRegression_->setEventContent(setup);
  }

  // read input collections
  // electrons
  auto gedElectronHandle = event.getHandle(previousGsfElectrons_);

  // PFCandidates
  auto pfCandidateHandle = event.getHandle(pfCandidates_);
  // value maps
  std::vector<edm::ValueMap<float> const*> isolationValueMaps(tokenElectronIsoVals_.size());

  for (unsigned i = 0; i < tokenElectronIsoVals_.size(); ++i) {
    isolationValueMaps[i] = &event.get(tokenElectronIsoVals_[i]);
  }

  // prepare a map of PFCandidates having a valid GsfTrackRef to save time
  std::map<reco::GsfTrackRef, const reco::PFCandidate*> gsfPFMap;
  for (auto const& pfCand : *pfCandidateHandle) {
    // First check that the GsfTrack is non null
    if (pfCand.gsfTrackRef().isNonnull()) {
      if (abs(pfCand.pdgId()) == 11)  // consider only the electrons
        gsfPFMap[pfCand.gsfTrackRef()] = &pfCand;
    }
  }

  // Now loop on the electrons
  unsigned nele = gedElectronHandle->size();
  for (unsigned iele = 0; iele < nele; ++iele) {
    reco::GsfElectronRef myElectronRef(gedElectronHandle, iele);

    reco::GsfElectron newElectron(*myElectronRef);
    reco::GsfElectron::PflowIsolationVariables isoVariables;
    isoVariables.sumChargedHadronPt = (*(isolationValueMaps)[0])[myElectronRef];
    isoVariables.sumPhotonEt = (*(isolationValueMaps)[1])[myElectronRef];
    isoVariables.sumNeutralHadronEt = (*(isolationValueMaps)[2])[myElectronRef];
    isoVariables.sumPUPt = (*(isolationValueMaps)[3])[myElectronRef];
    isoVariables.sumEcalClusterEt = (*(isolationValueMaps)[4])[myElectronRef];
    isoVariables.sumHcalClusterEt = (*(isolationValueMaps)[5])[myElectronRef];

    newElectron.setPfIsolationVariables(isoVariables);

    // now set a status if not already done (in GEDGsfElectronProducer.cc)
    //     std::cout << " previous status " << newElectron.mvaOutput().status << std::endl;
    if (newElectron.mvaOutput().status <= 0) {
      reco::GsfElectron::MvaOutput myMvaOutput(newElectron.mvaOutput());
      if (gsfPFMap.find(newElectron.gsfTrack()) != gsfPFMap.end()) {
        // it means that there is a PFCandidate with the same GsfTrack
        myMvaOutput.status = 3;  //as defined in PFCandidateEGammaExtra.h
        //this is currently fully redundant with mvaOutput.stats so candidate for removal
        newElectron.setPassPflowPreselection(true);
      } else {
        myMvaOutput.status = 4;  //
        //this is currently fully redundant with mvaOutput.stats so candidate for removal
        newElectron.setPassPflowPreselection(false);
      }
      newElectron.setMvaOutput(myMvaOutput);
    }

    if (gedRegression_) {
      gedRegression_->modifyObject(newElectron);
    }
    outputElectrons.push_back(newElectron);
  }

  event.emplace(putToken_, std::move(outputElectrons));
}

Member Data Documentation

gedRegression_

std::unique_ptr<ModifyObjectValueBase> GEDGsfElectronFinalizer::gedRegression_

private

Definition at line 22 of file GEDGsfElectronFinalizer.cc.

Referenced by produce().

pfCandidates_

const edm::EDGetTokenT<reco::PFCandidateCollection> GEDGsfElectronFinalizer::pfCandidates_

private

Definition at line 20 of file GEDGsfElectronFinalizer.cc.

Referenced by produce().

previousGsfElectrons_

const edm::EDGetTokenT<reco::GsfElectronCollection> GEDGsfElectronFinalizer::previousGsfElectrons_

private

Definition at line 19 of file GEDGsfElectronFinalizer.cc.

Referenced by produce().

putToken_

const edm::EDPutTokenT<reco::GsfElectronCollection> GEDGsfElectronFinalizer::putToken_

private

Definition at line 24 of file GEDGsfElectronFinalizer.cc.

Referenced by produce().

tokenElectronIsoVals_

std::vector<edm::EDGetTokenT<edm::ValueMap<float> > > GEDGsfElectronFinalizer::tokenElectronIsoVals_

private

Definition at line 21 of file GEDGsfElectronFinalizer.cc.

Referenced by produce().