pat::PATElectronSlimmer Class Reference

Slimmer of PAT Electrons. More...

Inheritance diagram for pat::PATElectronSlimmer:

Public Member Functions
void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) final
	PATElectronSlimmer (const edm::ParameterSet &iConfig)
void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) final
	~PATElectronSlimmer () 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
const StringCutObjectSelector< pat::Electron >	dropBasicClusters_
const StringCutObjectSelector< pat::Electron >	dropClassifications_
const StringCutObjectSelector< pat::Electron >	dropCorrections_
const StringCutObjectSelector< pat::Electron >	dropExtrapolations_
const StringCutObjectSelector< pat::Electron >	dropIsolations_
const StringCutObjectSelector< pat::Electron >	dropPFlowClusters_
const StringCutObjectSelector< pat::Electron >	dropPreshowerClusters_
const StringCutObjectSelector< pat::Electron >	dropRecHits_
const StringCutObjectSelector< pat::Electron >	dropSaturation_
const StringCutObjectSelector< pat::Electron >	dropSeedCluster_
const StringCutObjectSelector< pat::Electron >	dropShapes_
const StringCutObjectSelector< pat::Electron >	dropSuperClusters_
const EcalClusterLazyTools::ESGetTokens	ecalClusterToolsESGetTokens_
std::unique_ptr< pat::ObjectModifier< pat::Electron > >	electronModifier_
const bool	linkToPackedPF_
const bool	modifyElectron_
const edm::EDGetTokenT< pat::PackedCandidateCollection >	pc_
const edm::EDGetTokenT< edm::Association< pat::PackedCandidateCollection > >	pf2pc_
const edm::EDGetTokenT< edm::ValueMap< std::vector< reco::PFCandidateRef > > >	reco2pf_
const edm::EDGetTokenT< EcalRecHitCollection >	reducedBarrelRecHitCollectionToken_
const edm::EDGetTokenT< EcalRecHitCollection >	reducedEndcapRecHitCollectionToken_
const StringCutObjectSelector< pat::Electron >	saveNonZSClusterShapes_
const edm::EDGetTokenT< edm::View< pat::Electron > >	src_

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

Slimmer of PAT Electrons.

Definition at line 26 of file PATElectronSlimmer.cc.

Constructor & Destructor Documentation

PATElectronSlimmer()

pat::PATElectronSlimmer::PATElectronSlimmer ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 56 of file PATElectronSlimmer.cc.

    : src_(consumes<edm::View<pat::Electron>>(iConfig.getParameter<edm::InputTag>("src"))),
      dropSuperClusters_(iConfig.getParameter<std::string>("dropSuperCluster")),
      dropBasicClusters_(iConfig.getParameter<std::string>("dropBasicClusters")),
      dropPFlowClusters_(iConfig.getParameter<std::string>("dropPFlowClusters")),
      dropPreshowerClusters_(iConfig.getParameter<std::string>("dropPreshowerClusters")),
      dropSeedCluster_(iConfig.getParameter<std::string>("dropSeedCluster")),
      dropRecHits_(iConfig.getParameter<std::string>("dropRecHits")),
      dropCorrections_(iConfig.getParameter<std::string>("dropCorrections")),
      dropIsolations_(iConfig.getParameter<std::string>("dropIsolations")),
      dropShapes_(iConfig.getParameter<std::string>("dropShapes")),
      dropSaturation_(iConfig.getParameter<std::string>("dropSaturation")),
      dropExtrapolations_(iConfig.getParameter<std::string>("dropExtrapolations")),
      dropClassifications_(iConfig.getParameter<std::string>("dropClassifications")),
      reco2pf_(mayConsume<edm::ValueMap<std::vector<reco::PFCandidateRef>>>(
          iConfig.getParameter<edm::InputTag>("recoToPFMap"))),
      pf2pc_(mayConsume<edm::Association<pat::PackedCandidateCollection>>(
          iConfig.getParameter<edm::InputTag>("packedPFCandidates"))),
      pc_(mayConsume<pat::PackedCandidateCollection>(iConfig.getParameter<edm::InputTag>("packedPFCandidates"))),
      linkToPackedPF_(iConfig.getParameter<bool>("linkToPackedPFCandidates")),
      saveNonZSClusterShapes_(iConfig.getParameter<std::string>("saveNonZSClusterShapes")),
      reducedBarrelRecHitCollectionToken_(
          consumes(iConfig.getParameter<edm::InputTag>("reducedBarrelRecHitCollection"))),
      reducedEndcapRecHitCollectionToken_(
          consumes(iConfig.getParameter<edm::InputTag>("reducedEndcapRecHitCollection"))),
      ecalClusterToolsESGetTokens_{consumesCollector()},
      modifyElectron_(iConfig.getParameter<bool>("modifyElectrons")) {
  if (modifyElectron_) {
    const edm::ParameterSet& mod_config = iConfig.getParameter<edm::ParameterSet>("modifierConfig");
    electronModifier_ = std::make_unique<pat::ObjectModifier<pat::Electron>>(mod_config, consumesCollector());
  }
 
  mayConsume<EcalRecHitCollection>(edm::InputTag("reducedEcalRecHitsEB"));
  mayConsume<EcalRecHitCollection>(edm::InputTag("reducedEcalRecHitsEE"));
 
  produces<std::vector<pat::Electron>>();
}

~PATElectronSlimmer()

pat::PATElectronSlimmer::~PATElectronSlimmer ( )

inlineoverride

Definition at line 29 of file PATElectronSlimmer.cc.

{}

Member Function Documentation

beginLuminosityBlock()

void pat::PATElectronSlimmer::beginLuminosityBlock ( const edm::LuminosityBlock &  , const edm::EventSetup &  iSetup  )

final

Definition at line 94 of file PATElectronSlimmer.cc.

{}

produce()

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

final

Definition at line 96 of file PATElectronSlimmer.cc.

                                                                                 {
  using namespace edm;
  using namespace std;
 
  Handle<View<pat::Electron>> src;
  iEvent.getByToken(src_, src);
 
  Handle<edm::ValueMap<std::vector<reco::PFCandidateRef>>> reco2pf;
  Handle<edm::Association<pat::PackedCandidateCollection>> pf2pc;
  Handle<pat::PackedCandidateCollection> pc;
  if (linkToPackedPF_) {
    iEvent.getByToken(reco2pf_, reco2pf);
    iEvent.getByToken(pf2pc_, pf2pc);
    iEvent.getByToken(pc_, pc);
  }
  noZS::EcalClusterLazyTools lazyToolsNoZS(iEvent,
                                           ecalClusterToolsESGetTokens_.get(iSetup),
                                           reducedBarrelRecHitCollectionToken_,
                                           reducedEndcapRecHitCollectionToken_);
 
  auto out = std::make_unique<std::vector<pat::Electron>>();
  out->reserve(src->size());
 
  if (modifyElectron_) {
    electronModifier_->setEvent(iEvent);
  }
  if (modifyElectron_)
    electronModifier_->setEventContent(iSetup);
 
  std::vector<unsigned int> keys;
  for (View<pat::Electron>::const_iterator it = src->begin(), ed = src->end(); it != ed; ++it) {
    out->push_back(*it);
    pat::Electron& electron = out->back();
 
    if (modifyElectron_) {
      electronModifier_->modify(electron);
    }
 
    if (dropSuperClusters_(electron)) {
      electron.superCluster_.clear();
      electron.embeddedSuperCluster_ = false;
    }
    if (dropBasicClusters_(electron)) {
      electron.basicClusters_.clear();
    }
    if (dropSuperClusters_(electron) || dropPFlowClusters_(electron)) {
      electron.pflowSuperCluster_.clear();
      electron.embeddedPflowSuperCluster_ = false;
    }
    if (dropBasicClusters_(electron) || dropPFlowClusters_(electron)) {
      electron.pflowBasicClusters_.clear();
    }
    if (dropPreshowerClusters_(electron)) {
      electron.preshowerClusters_.clear();
    }
    if (dropPreshowerClusters_(electron) || dropPFlowClusters_(electron)) {
      electron.pflowPreshowerClusters_.clear();
    }
    if (dropSeedCluster_(electron)) {
      electron.seedCluster_.clear();
      electron.embeddedSeedCluster_ = false;
    }
    if (dropRecHits_(electron)) {
      electron.recHits_ = EcalRecHitCollection();
      electron.embeddedRecHits_ = false;
    }
    if (dropCorrections_(electron)) {
      electron.setCorrections(reco::GsfElectron::Corrections());
    }
    if (dropIsolations_(electron)) {
      electron.setDr03Isolation(reco::GsfElectron::IsolationVariables());
      electron.setDr04Isolation(reco::GsfElectron::IsolationVariables());
      electron.setPfIsolationVariables(reco::GsfElectron::PflowIsolationVariables());
    }
    if (dropShapes_(electron)) {
      electron.setShowerShape(reco::GsfElectron::ShowerShape());
    }
    if (dropSaturation_(electron)) {
      electron.setSaturationInfo(reco::GsfElectron::SaturationInfo());
    }
    if (dropExtrapolations_(electron)) {
      electron.setTrackExtrapolations(reco::GsfElectron::TrackExtrapolations());
    }
    if (dropClassifications_(electron)) {
      electron.setClassificationVariables(reco::GsfElectron::ClassificationVariables());
      electron.setClassification(reco::GsfElectron::Classification());
    }
    if (linkToPackedPF_) {
      //std::cout << " PAT  electron in  " << src.id() << " comes from " << electron.refToOrig_.id() << ", " << electron.refToOrig_.key() << std::endl;
      keys.clear();
      for (auto const& pf : (*reco2pf)[electron.refToOrig_]) {
        if (pf2pc->contains(pf.id())) {
          keys.push_back((*pf2pc)[pf].key());
        }
      }
      electron.setAssociatedPackedPFCandidates(
          edm::RefProd<pat::PackedCandidateCollection>(pc), keys.begin(), keys.end());
      //std::cout << "Electron with pt " << electron.pt() << " associated to " << electron.associatedPackedFCandidateIndices_.size() << " PF Candidates\n";
      //if there's just one PF Cand then it's me, otherwise I have no univoque parent so my ref will be null
      if (keys.size() == 1) {
        electron.refToOrig_ = electron.sourceCandidatePtr(0);
      } else {
        electron.refToOrig_ = reco::CandidatePtr(pc.id());
      }
    }
    if (saveNonZSClusterShapes_(electron)) {
      const auto& vCov = lazyToolsNoZS.localCovariances(*(electron.superCluster()->seed()));
      electron.full5x5_setSigmaIetaIphi(vCov[1]);
    }
  }
 
  iEvent.put(std::move(out));
}

References HPSPFTauProducerPuppi_cfi::electron, edm::HandleBase::id(), iEvent, crabWrapper::key, relativeConstraints::keys, eostools::move(), MillePedeFileConverter_cfg::out, packedPFCandidateRefMixer_cfi::pf, and TrackRefitter_38T_cff::src.

Member Data Documentation

dropBasicClusters_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropBasicClusters_

private

Definition at line 37 of file PATElectronSlimmer.cc.

dropClassifications_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropClassifications_

private

Definition at line 39 of file PATElectronSlimmer.cc.

dropCorrections_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropCorrections_

private

Definition at line 39 of file PATElectronSlimmer.cc.

dropExtrapolations_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropExtrapolations_

private

Definition at line 39 of file PATElectronSlimmer.cc.

dropIsolations_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropIsolations_

private

Definition at line 39 of file PATElectronSlimmer.cc.

dropPFlowClusters_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropPFlowClusters_

private

Definition at line 37 of file PATElectronSlimmer.cc.

dropPreshowerClusters_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropPreshowerClusters_

private

Definition at line 37 of file PATElectronSlimmer.cc.

dropRecHits_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropRecHits_

private

Definition at line 37 of file PATElectronSlimmer.cc.

dropSaturation_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropSaturation_

private

Definition at line 39 of file PATElectronSlimmer.cc.

dropSeedCluster_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropSeedCluster_

private

Definition at line 37 of file PATElectronSlimmer.cc.

dropShapes_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropShapes_

private

Definition at line 39 of file PATElectronSlimmer.cc.

dropSuperClusters_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::dropSuperClusters_

private

Definition at line 37 of file PATElectronSlimmer.cc.

ecalClusterToolsESGetTokens_

const EcalClusterLazyTools::ESGetTokens pat::PATElectronSlimmer::ecalClusterToolsESGetTokens_

private

Definition at line 49 of file PATElectronSlimmer.cc.

electronModifier_

std::unique_ptr<pat::ObjectModifier<pat::Electron> > pat::PATElectronSlimmer::electronModifier_

private

Definition at line 51 of file PATElectronSlimmer.cc.

linkToPackedPF_

const bool pat::PATElectronSlimmer::linkToPackedPF_

private

Definition at line 45 of file PATElectronSlimmer.cc.

modifyElectron_

const bool pat::PATElectronSlimmer::modifyElectron_

private

Definition at line 50 of file PATElectronSlimmer.cc.

pc_

const edm::EDGetTokenT<pat::PackedCandidateCollection> pat::PATElectronSlimmer::pc_

private

Definition at line 44 of file PATElectronSlimmer.cc.

pf2pc_

const edm::EDGetTokenT<edm::Association<pat::PackedCandidateCollection> > pat::PATElectronSlimmer::pf2pc_

private

Definition at line 43 of file PATElectronSlimmer.cc.

reco2pf_

const edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef> > > pat::PATElectronSlimmer::reco2pf_

private

Definition at line 42 of file PATElectronSlimmer.cc.

reducedBarrelRecHitCollectionToken_

const edm::EDGetTokenT<EcalRecHitCollection> pat::PATElectronSlimmer::reducedBarrelRecHitCollectionToken_

private

Definition at line 47 of file PATElectronSlimmer.cc.

reducedEndcapRecHitCollectionToken_

const edm::EDGetTokenT<EcalRecHitCollection> pat::PATElectronSlimmer::reducedEndcapRecHitCollectionToken_

private

Definition at line 47 of file PATElectronSlimmer.cc.

saveNonZSClusterShapes_

const StringCutObjectSelector<pat::Electron> pat::PATElectronSlimmer::saveNonZSClusterShapes_

private

Definition at line 46 of file PATElectronSlimmer.cc.

src_

const edm::EDGetTokenT<edm::View<pat::Electron> > pat::PATElectronSlimmer::src_

private

Definition at line 35 of file PATElectronSlimmer.cc.