CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Private Attributes
pat::PATElectronProducer Class Reference

Produces pat::Electron's. More...

Inheritance diagram for pat::PATElectronProducer:
edm::stream::EDProducer<>

Public Member Functions

 PATElectronProducer (const edm::ParameterSet &iConfig)
 
void produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override
 
 ~PATElectronProducer () 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
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &descriptions)
 

Private Types

typedef edm::RefToBase< reco::GsfElectron > ElectronBaseRef
 
typedef std::vector< edm::Handle< edm::Association< reco::GenParticleCollection > > > GenAssociations
 
typedef std::vector< edm::Handle< edm::ValueMap< IsoDeposit > > > IsoDepositMaps
 
typedef std::pair< pat::IsolationKeys, edm::InputTag > IsolationLabel
 
typedef std::vector< IsolationLabel > IsolationLabels
 
typedef std::vector< edm::Handle< edm::ValueMap< double > > > IsolationValueMaps
 
typedef std::pair< std::string, edm::InputTag > NameTag
 

Private Member Functions

void embedHighLevel (pat::Electron &anElectron, reco::GsfTrackRef track, reco::TransientTrack &tt, reco::Vertex &primaryVertex, bool primaryVertexIsValid, reco::BeamSpot &beamspot, bool beamspotIsValid)
 
void fillElectron (Electron &aElectron, const ElectronBaseRef &electronRef, const reco::CandidateBaseRef &baseRef, const GenAssociations &genMatches, const IsoDepositMaps &deposits, const bool pfId, const IsolationValueMaps &isolationValues, const IsolationValueMaps &isolationValuesNoPFId) const
 common electron filling, for both the standard and PF2PAT case More...
 
void fillElectron2 (Electron &anElectron, const reco::CandidatePtr &candPtrForIsolation, const reco::CandidatePtr &candPtrForGenMatch, const reco::CandidatePtr &candPtrForLoader, const GenAssociations &genMatches, const IsoDepositMaps &deposits, const IsolationValueMaps &isolationValues) const
 
template<typename T >
void readIsolationLabels (const edm::ParameterSet &iConfig, const char *psetName, IsolationLabels &labels, std::vector< edm::EDGetTokenT< edm::ValueMap< T >>> &tokens)
 
void setElectronMiniIso (pat::Electron &anElectron, const pat::PackedCandidateCollection *pc)
 

Private Attributes

const bool addEfficiencies_
 
const bool addElecID_
 
bool addGenMatch_
 
const bool addMVAVariables_
 mva input variables More...
 
const bool addPFClusterIso_
 
const bool addPuppiIsolation_
 
const bool addResolutions_
 
const edm::EDGetTokenT< reco::BeamSpot > beamLineToken_
 
bool computeMiniIso_
 
const EcalClusterLazyTools::ESGetTokens ecalClusterToolsESGetTokens_
 
const edm::EDGetTokenT< edm::ValueMap< float > > ecalPFClusterIsoT_
 
const CaloTopology * ecalTopology_
 
const edm::ESGetToken< CaloTopology, CaloTopologyRecord > ecalTopologyToken_
 
pat::helper::EfficiencyLoader efficiencyLoader_
 
std::vector< NameTag > elecIDSrcs_
 
std::vector< edm::EDGetTokenT< edm::ValueMap< float > > > elecIDTokens_
 
const edm::EDGetTokenT< edm::View< reco::GsfElectron > > electronToken_
 
const bool embedBasicClusters_
 
bool embedGenMatch_
 
const bool embedGsfElectronCore_
 
const bool embedGsfTrack_
 
const bool embedHighLevelSelection_
 embed high level selection variables? More...
 
const bool embedPFCandidate_
 
const bool embedPflowBasicClusters_
 
const bool embedPflowPreshowerClusters_
 
const bool embedPflowSuperCluster_
 
const bool embedPreshowerClusters_
 
const bool embedRecHits_
 
const bool embedSeedCluster_
 
const bool embedSuperCluster_
 
const bool embedTrack_
 
std::vector< edm::EDGetTokenT< edm::Association< reco::GenParticleCollection > > > genMatchTokens_
 
const edm::EDGetTokenT< edm::ValueMap< float > > hcalPFClusterIsoT_
 
const edm::EDGetTokenT< reco::ConversionCollection > hConversionsToken_
 
IsolationLabels isoDepositLabels_
 
std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > > isoDepositTokens_
 
IsolationLabels isolationValueLabels_
 
IsolationLabels isolationValueLabelsNoPFId_
 
std::vector< edm::EDGetTokenT< edm::ValueMap< double > > > isolationValueNoPFIdTokens_
 
std::vector< edm::EDGetTokenT< edm::ValueMap< double > > > isolationValueTokens_
 
pat::helper::MultiIsolator isolator_
 
pat::helper::MultiIsolator::IsolationValuePairs isolatorTmpStorage_
 
std::vector< double > miniIsoParamsB_
 
std::vector< double > miniIsoParamsE_
 
edm::EDGetTokenT< pat::PackedCandidateCollection > pcToken_
 
const edm::EDGetTokenT< edm::ValueMap< reco::PFCandidatePtr > > pfCandidateMapToken_
 
const edm::EDGetTokenT< edm::ValueMap< std::vector< reco::PFCandidateRef > > > pfCandidateMultiMapToken_
 
const edm::EDGetTokenT< reco::PFCandidateCollection > pfElecToken_
 
const GreaterByPt< Electron > pTComparator_
 
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_charged_hadrons_
 
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_neutral_hadrons_
 
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_photons_
 
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_charged_hadrons_
 
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_neutral_hadrons_
 
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_photons_
 
const edm::EDGetTokenT< std::vector< reco::Vertex > > pvToken_
 
const edm::InputTag reducedBarrelRecHitCollection_
 
const edm::EDGetTokenT< EcalRecHitCollection > reducedBarrelRecHitCollectionToken_
 
const edm::InputTag reducedEndcapRecHitCollection_
 
const edm::EDGetTokenT< EcalRecHitCollection > reducedEndcapRecHitCollectionToken_
 
pat::helper::KinResolutionsLoader resolutionLoader_
 
const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord > trackBuilderToken_
 
const bool useParticleFlow_
 pflow specific More...
 
const bool usePfCandidateMultiMap_
 
pat::PATUserDataHelper< pat::Electron > userDataHelper_
 
const bool useUserData_
 

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

Produces pat::Electron's.

The PATElectronProducer produces analysis-level pat::Electron's starting from a collection of objects of reco::GsfElectron.

Author
Steven Lowette, James Lamb\
Version
Id
PATElectronProducer.h,v 1.31 2013/02/27 23:26:56 wmtan Exp

Definition at line 68 of file PATElectronProducer.cc.

Member Typedef Documentation

◆ ElectronBaseRef

typedef edm::RefToBase<reco::GsfElectron> pat::PATElectronProducer::ElectronBaseRef
private

Definition at line 130 of file PATElectronProducer.cc.

◆ GenAssociations

typedef std::vector<edm::Handle<edm::Association<reco::GenParticleCollection> > > pat::PATElectronProducer::GenAssociations
private

Definition at line 100 of file PATElectronProducer.cc.

◆ IsoDepositMaps

typedef std::vector<edm::Handle<edm::ValueMap<IsoDeposit> > > pat::PATElectronProducer::IsoDepositMaps
private

Definition at line 131 of file PATElectronProducer.cc.

◆ IsolationLabel

typedef std::pair<pat::IsolationKeys, edm::InputTag> pat::PATElectronProducer::IsolationLabel
private

Definition at line 165 of file PATElectronProducer.cc.

◆ IsolationLabels

typedef std::vector<IsolationLabel> pat::PATElectronProducer::IsolationLabels
private

Definition at line 166 of file PATElectronProducer.cc.

◆ IsolationValueMaps

typedef std::vector<edm::Handle<edm::ValueMap<double> > > pat::PATElectronProducer::IsolationValueMaps
private

Definition at line 132 of file PATElectronProducer.cc.

◆ NameTag

typedef std::pair<std::string, edm::InputTag> pat::PATElectronProducer::NameTag
private

Definition at line 177 of file PATElectronProducer.cc.

Constructor & Destructor Documentation

◆ PATElectronProducer()

PATElectronProducer::PATElectronProducer ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 270 of file PATElectronProducer.cc.

271  : // general configurables
272  electronToken_(consumes<edm::View<reco::GsfElectron>>(iConfig.getParameter<edm::InputTag>("electronSource"))),
273  hConversionsToken_(consumes<reco::ConversionCollection>(edm::InputTag("allConversions"))),
274  embedGsfElectronCore_(iConfig.getParameter<bool>("embedGsfElectronCore")),
275  embedGsfTrack_(iConfig.getParameter<bool>("embedGsfTrack")),
276  embedSuperCluster_(iConfig.getParameter<bool>("embedSuperCluster")),
277  embedPflowSuperCluster_(iConfig.getParameter<bool>("embedPflowSuperCluster")),
278  embedSeedCluster_(iConfig.getParameter<bool>("embedSeedCluster")),
279  embedBasicClusters_(iConfig.getParameter<bool>("embedBasicClusters")),
280  embedPreshowerClusters_(iConfig.getParameter<bool>("embedPreshowerClusters")),
281  embedPflowBasicClusters_(iConfig.getParameter<bool>("embedPflowBasicClusters")),
282  embedPflowPreshowerClusters_(iConfig.getParameter<bool>("embedPflowPreshowerClusters")),
283  embedTrack_(iConfig.getParameter<bool>("embedTrack")),
284  addGenMatch_(iConfig.getParameter<bool>("addGenMatch")),
285  embedGenMatch_(addGenMatch_ ? iConfig.getParameter<bool>("embedGenMatch") : false),
286  embedRecHits_(iConfig.getParameter<bool>("embedRecHits")),
287  // pflow configurables
288  useParticleFlow_(iConfig.getParameter<bool>("useParticleFlow")),
289  usePfCandidateMultiMap_(iConfig.getParameter<bool>("usePfCandidateMultiMap")),
290  pfElecToken_(!usePfCandidateMultiMap_
291  ? consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfElectronSource"))
292  : edm::EDGetTokenT<reco::PFCandidateCollection>()),
293  pfCandidateMapToken_(!usePfCandidateMultiMap_ ? mayConsume<edm::ValueMap<reco::PFCandidatePtr>>(
294  iConfig.getParameter<edm::InputTag>("pfCandidateMap"))
295  : edm::EDGetTokenT<edm::ValueMap<reco::PFCandidatePtr>>()),
296  pfCandidateMultiMapToken_(usePfCandidateMultiMap_
297  ? consumes<edm::ValueMap<std::vector<reco::PFCandidateRef>>>(
298  iConfig.getParameter<edm::InputTag>("pfCandidateMultiMap"))
299  : edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef>>>()),
300  embedPFCandidate_(iConfig.getParameter<bool>("embedPFCandidate")),
301  // mva input variables
302  addMVAVariables_(iConfig.getParameter<bool>("addMVAVariables")),
303  reducedBarrelRecHitCollection_(iConfig.getParameter<edm::InputTag>("reducedBarrelRecHitCollection")),
304  reducedBarrelRecHitCollectionToken_(mayConsume<EcalRecHitCollection>(reducedBarrelRecHitCollection_)),
305  reducedEndcapRecHitCollection_(iConfig.getParameter<edm::InputTag>("reducedEndcapRecHitCollection")),
306  reducedEndcapRecHitCollectionToken_(mayConsume<EcalRecHitCollection>(reducedEndcapRecHitCollection_)),
307  ecalClusterToolsESGetTokens_{consumesCollector()},
308  // PFCluster Isolation maps
309  addPFClusterIso_(iConfig.getParameter<bool>("addPFClusterIso")),
310  addPuppiIsolation_(iConfig.getParameter<bool>("addPuppiIsolation")),
311  ecalPFClusterIsoT_(consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("ecalPFClusterIsoMap"))),
312  hcalPFClusterIsoT_(consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("hcalPFClusterIsoMap"))),
313  // embed high level selection variables?
314  embedHighLevelSelection_(iConfig.getParameter<bool>("embedHighLevelSelection")),
315  beamLineToken_(consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamLineSrc"))),
316  pvToken_(mayConsume<std::vector<reco::Vertex>>(iConfig.getParameter<edm::InputTag>("pvSrc"))),
317  addElecID_(iConfig.getParameter<bool>("addElectronID")),
318  pTComparator_(),
319  isolator_(iConfig.getParameter<edm::ParameterSet>("userIsolation"), consumesCollector(), false),
320  addEfficiencies_(iConfig.getParameter<bool>("addEfficiencies")),
321  addResolutions_(iConfig.getParameter<bool>("addResolutions")),
322  useUserData_(iConfig.exists("userData")),
323  ecalTopologyToken_{esConsumes()},
324  trackBuilderToken_{esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))} {
325  // MC matching configurables (scheduled mode)
326 
327  if (addGenMatch_) {
328  genMatchTokens_.push_back(consumes<edm::Association<reco::GenParticleCollection>>(
329  iConfig.getParameter<edm::InputTag>("genParticleMatch")));
330  }
331  // resolution configurables
332  if (addResolutions_) {
333  resolutionLoader_ =
334  pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
335  }
336  if (addPuppiIsolation_) {
337  //puppi
338  PUPPIIsolation_charged_hadrons_ =
339  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationChargedHadrons"));
340  PUPPIIsolation_neutral_hadrons_ =
341  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationNeutralHadrons"));
342  PUPPIIsolation_photons_ =
343  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationPhotons"));
344  //puppiNoLeptons
345  PUPPINoLeptonsIsolation_charged_hadrons_ =
346  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationChargedHadrons"));
347  PUPPINoLeptonsIsolation_neutral_hadrons_ =
348  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationNeutralHadrons"));
349  PUPPINoLeptonsIsolation_photons_ =
350  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationPhotons"));
351  }
352  // electron ID configurables
353  if (addElecID_) {
354  // it might be a single electron ID
355  if (iConfig.existsAs<edm::InputTag>("electronIDSource")) {
356  elecIDSrcs_.push_back(NameTag("", iConfig.getParameter<edm::InputTag>("electronIDSource")));
357  }
358  // or there might be many of them
359  if (iConfig.existsAs<edm::ParameterSet>("electronIDSources")) {
360  // please don't configure me twice
361  if (!elecIDSrcs_.empty()) {
362  throw cms::Exception("Configuration")
363  << "PATElectronProducer: you can't specify both 'electronIDSource' and 'electronIDSources'\n";
364  }
365  // read the different electron ID names
366  edm::ParameterSet idps = iConfig.getParameter<edm::ParameterSet>("electronIDSources");
367  std::vector<std::string> names = idps.getParameterNamesForType<edm::InputTag>();
368  for (std::vector<std::string>::const_iterator it = names.begin(), ed = names.end(); it != ed; ++it) {
369  elecIDSrcs_.push_back(NameTag(*it, idps.getParameter<edm::InputTag>(*it)));
370  }
371  }
372  // but in any case at least once
373  if (elecIDSrcs_.empty()) {
374  throw cms::Exception("Configuration")
375  << "PATElectronProducer: id addElectronID is true, you must specify either:\n"
376  << "\tInputTag electronIDSource = <someTag>\n"
377  << "or\n"
378  << "\tPSet electronIDSources = { \n"
379  << "\t\tInputTag <someName> = <someTag> // as many as you want \n "
380  << "\t}\n";
381  }
382  }
383  elecIDTokens_ = edm::vector_transform(
384  elecIDSrcs_, [this](NameTag const& tag) { return mayConsume<edm::ValueMap<float>>(tag.second); });
385  // construct resolution calculator
386 
387  // // IsoDeposit configurables
388  // if (iConfig.exists("isoDeposits")) {
389  // edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>("isoDeposits");
390  // if (depconf.exists("tracker")) isoDepositLabels_.push_back(std::make_pair(TrackerIso, depconf.getParameter<edm::InputTag>("tracker")));
391  // if (depconf.exists("ecal")) isoDepositLabels_.push_back(std::make_pair(ECalIso, depconf.getParameter<edm::InputTag>("ecal")));
392  // if (depconf.exists("hcal")) isoDepositLabels_.push_back(std::make_pair(HCalIso, depconf.getParameter<edm::InputTag>("hcal")));
393 
394  // if (depconf.exists("user")) {
395  // std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
396  // std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
397  // int key = UserBaseIso;
398  // for ( ; it != ed; ++it, ++key) {
399  // isoDepositLabels_.push_back(std::make_pair(IsolationKeys(key), *it));
400  // }
401  // }
402  // }
403  // isoDepositTokens_ = edm::vector_transform(isoDepositLabels_, [this](std::pair<IsolationKeys,edm::InputTag> const & label){return consumes<edm::ValueMap<IsoDeposit> >(label.second);});
404 
405  // for mini-iso
406  computeMiniIso_ = iConfig.getParameter<bool>("computeMiniIso");
407  miniIsoParamsE_ = iConfig.getParameter<std::vector<double>>("miniIsoParamsE");
408  miniIsoParamsB_ = iConfig.getParameter<std::vector<double>>("miniIsoParamsB");
409  if (computeMiniIso_ && (miniIsoParamsE_.size() != 9 || miniIsoParamsB_.size() != 9)) {
410  throw cms::Exception("ParameterError") << "miniIsoParams must have exactly 9 elements.\n";
411  }
412  if (computeMiniIso_)
413  pcToken_ = consumes<pat::PackedCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfCandsForMiniIso"));
414 
415  // read isoDeposit labels, for direct embedding
416  readIsolationLabels(iConfig, "isoDeposits", isoDepositLabels_, isoDepositTokens_);
417  // read isolation value labels, for direct embedding
418  readIsolationLabels(iConfig, "isolationValues", isolationValueLabels_, isolationValueTokens_);
419  // read isolation value labels for non PF identified electron, for direct embedding
420  readIsolationLabels(iConfig, "isolationValuesNoPFId", isolationValueLabelsNoPFId_, isolationValueNoPFIdTokens_);
421  // Efficiency configurables
422  if (addEfficiencies_) {
423  efficiencyLoader_ =
424  pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"), consumesCollector());
425  }
426  // Check to see if the user wants to add user data
427  if (useUserData_) {
428  userDataHelper_ =
429  PATUserDataHelper<Electron>(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector());
430  }
431 
432  // consistency check
433  if (useParticleFlow_ && usePfCandidateMultiMap_)
434  throw cms::Exception("Configuration", "usePfCandidateMultiMap not supported when useParticleFlow is set to true");
435 
436  // produces vector of muons
437  produces<std::vector<Electron>>();
438 }
pat::PATUserDataHelper
Assists in assimilating all pat::UserData into pat objects.
Definition: PATUserDataHelper.h:48
deDxTools::esConsumes
ESGetTokenH3DDVariant esConsumes(std::string const &Record, edm::ConsumesCollector &)
Definition: DeDxTools.cc:283
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
pat::PATElectronProducer::hConversionsToken_
const edm::EDGetTokenT< reco::ConversionCollection > hConversionsToken_
Definition: PATElectronProducer.cc:80
pat::PATElectronProducer::PUPPINoLeptonsIsolation_charged_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_charged_hadrons_
Definition: PATElectronProducer.cc:205
pat::PATElectronProducer::pTComparator_
const GreaterByPt< Electron > pTComparator_
Definition: PATElectronProducer.cc:182
pat::PATElectronProducer::readIsolationLabels
void readIsolationLabels(const edm::ParameterSet &iConfig, const char *psetName, IsolationLabels &labels, std::vector< edm::EDGetTokenT< edm::ValueMap< T >>> &tokens)
Definition: PATElectronProducer.cc:218
pat::PATElectronProducer::PUPPIIsolation_charged_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_charged_hadrons_
Definition: PATElectronProducer.cc:201
pat::PATElectronProducer::useParticleFlow_
const bool useParticleFlow_
pflow specific
Definition: PATElectronProducer.cc:105
pat::PATElectronProducer::pfElecToken_
const edm::EDGetTokenT< reco::PFCandidateCollection > pfElecToken_
Definition: PATElectronProducer.cc:107
pat::PATElectronProducer::miniIsoParamsE_
std::vector< double > miniIsoParamsE_
Definition: PATElectronProducer.cc:97
pat::PATElectronProducer::PUPPIIsolation_neutral_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_neutral_hadrons_
Definition: PATElectronProducer.cc:202
pat::PATElectronProducer::ecalPFClusterIsoT_
const edm::EDGetTokenT< edm::ValueMap< float > > ecalPFClusterIsoT_
Definition: PATElectronProducer.cc:122
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:681
pat::PATElectronProducer::reducedBarrelRecHitCollection_
const edm::InputTag reducedBarrelRecHitCollection_
Definition: PATElectronProducer.cc:114
pat::PATElectronProducer::hcalPFClusterIsoT_
const edm::EDGetTokenT< edm::ValueMap< float > > hcalPFClusterIsoT_
Definition: PATElectronProducer.cc:123
edm::ParameterSet::existsAs
bool existsAs(std::string const &parameterName, bool trackiness=true) const
checks if a parameter exists as a given type
Definition: ParameterSet.h:171
edm::vector_transform
auto vector_transform(std::vector< InputType > const &input, Function predicate) -> std::vector< typename std::remove_cv< typename std::remove_reference< decltype(predicate(input.front()))>::type >::type >
Definition: transform.h:11
pat::PATElectronProducer::elecIDTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< float > > > elecIDTokens_
Definition: PATElectronProducer.cc:179
names
const std::string names[nVars_]
Definition: PhotonIDValueMapProducer.cc:124
pat::PATElectronProducer::ecalTopologyToken_
const edm::ESGetToken< CaloTopology, CaloTopologyRecord > ecalTopologyToken_
Definition: PATElectronProducer.cc:210
pat::PATElectronProducer::electronToken_
const edm::EDGetTokenT< edm::View< reco::GsfElectron > > electronToken_
Definition: PATElectronProducer.cc:79
pat::PATElectronProducer::addMVAVariables_
const bool addMVAVariables_
mva input variables
Definition: PATElectronProducer.cc:113
pat::PATElectronProducer::miniIsoParamsB_
std::vector< double > miniIsoParamsB_
Definition: PATElectronProducer.cc:98
pat::PATElectronProducer::pvToken_
const edm::EDGetTokenT< std::vector< reco::Vertex > > pvToken_
Definition: PATElectronProducer.cc:128
pat::PATElectronProducer::pfCandidateMapToken_
const edm::EDGetTokenT< edm::ValueMap< reco::PFCandidatePtr > > pfCandidateMapToken_
Definition: PATElectronProducer.cc:108
pat::PATElectronProducer::isolator_
pat::helper::MultiIsolator isolator_
Definition: PATElectronProducer.cc:184
pat::PATElectronProducer::PUPPIIsolation_photons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_photons_
Definition: PATElectronProducer.cc:203
pat::PATElectronProducer::embedHighLevelSelection_
const bool embedHighLevelSelection_
embed high level selection variables?
Definition: PATElectronProducer.cc:126
makeGlobalPositionRcd_cfg.tag
tag
Definition: makeGlobalPositionRcd_cfg.py:6
pat::PATElectronProducer::genMatchTokens_
std::vector< edm::EDGetTokenT< edm::Association< reco::GenParticleCollection > > > genMatchTokens_
Definition: PATElectronProducer.cc:102
edm::ParameterSet::getParameterNamesForType
std::vector< std::string > getParameterNamesForType(bool trackiness=true) const
Definition: ParameterSet.h:179
pat::PATElectronProducer::isoDepositTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > > isoDepositTokens_
Definition: PATElectronProducer.cc:187
pat::PATElectronProducer::PUPPINoLeptonsIsolation_neutral_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_neutral_hadrons_
Definition: PATElectronProducer.cc:206
pat::PATElectronProducer::ecalClusterToolsESGetTokens_
const EcalClusterLazyTools::ESGetTokens ecalClusterToolsESGetTokens_
Definition: PATElectronProducer.cc:118
pat::PATElectronProducer::reducedEndcapRecHitCollectionToken_
const edm::EDGetTokenT< EcalRecHitCollection > reducedEndcapRecHitCollectionToken_
Definition: PATElectronProducer.cc:117
pat::PATElectronProducer::reducedEndcapRecHitCollection_
const edm::InputTag reducedEndcapRecHitCollection_
Definition: PATElectronProducer.cc:116
pat::PATElectronProducer::NameTag
std::pair< std::string, edm::InputTag > NameTag
Definition: PATElectronProducer.cc:177
pat::PATElectronProducer::PUPPINoLeptonsIsolation_photons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_photons_
Definition: PATElectronProducer.cc:207
pat::PATElectronProducer::beamLineToken_
const edm::EDGetTokenT< reco::BeamSpot > beamLineToken_
Definition: PATElectronProducer.cc:127
pat::PATElectronProducer::isolationValueNoPFIdTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< double > > > isolationValueNoPFIdTokens_
Definition: PATElectronProducer.cc:191
pat::PATElectronProducer::efficiencyLoader_
pat::helper::EfficiencyLoader efficiencyLoader_
Definition: PATElectronProducer.cc:194
pat::PATElectronProducer::reducedBarrelRecHitCollectionToken_
const edm::EDGetTokenT< EcalRecHitCollection > reducedBarrelRecHitCollectionToken_
Definition: PATElectronProducer.cc:115
pat::PATElectronProducer::trackBuilderToken_
const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord > trackBuilderToken_
Definition: PATElectronProducer.cc:211
pat::PATElectronProducer::pfCandidateMultiMapToken_
const edm::EDGetTokenT< edm::ValueMap< std::vector< reco::PFCandidateRef > > > pfCandidateMultiMapToken_
Definition: PATElectronProducer.cc:109
pat::PATElectronProducer::userDataHelper_
pat::PATUserDataHelper< pat::Electron > userDataHelper_
Definition: PATElectronProducer.cc:208
pat::PATElectronProducer::isolationValueLabelsNoPFId_
IsolationLabels isolationValueLabelsNoPFId_
Definition: PATElectronProducer.cc:190
pat::PATElectronProducer::isolationValueLabels_
IsolationLabels isolationValueLabels_
Definition: PATElectronProducer.cc:188
pat::PATElectronProducer::resolutionLoader_
pat::helper::KinResolutionsLoader resolutionLoader_
Definition: PATElectronProducer.cc:197
pat::PATElectronProducer::isolationValueTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< double > > > isolationValueTokens_
Definition: PATElectronProducer.cc:189
pat::PATElectronProducer::pcToken_
edm::EDGetTokenT< pat::PackedCandidateCollection > pcToken_
Definition: PATElectronProducer.cc:95
pat::PATElectronProducer::elecIDSrcs_
std::vector< NameTag > elecIDSrcs_
Definition: PATElectronProducer.cc:178

◆ ~PATElectronProducer()

PATElectronProducer::~PATElectronProducer ( )
override

Definition at line 440 of file PATElectronProducer.cc.

440 {}

Member Function Documentation

◆ embedHighLevel()

void PATElectronProducer::embedHighLevel ( pat::Electron &  anElectron,
reco::GsfTrackRef  track,
reco::TransientTrack &  tt,
reco::Vertex &  primaryVertex,
bool  primaryVertexIsValid,
reco::BeamSpot &  beamspot,
bool  beamspotIsValid 
)
private

Definition at line 1405 of file PATElectronProducer.cc.

References pat::Electron::BS2D, pat::Electron::BS3D, BeamMonitor_cff::primaryVertex, pat::Electron::PV2D, pat::Electron::PV3D, pat::Electron::PVDZ, mps_fire::result, pat::Electron::setDB(), IPTools::signedImpactParameter3D(), and HLT_2023v12_cff::track.

Referenced by produce().

1411  {
1412  // Correct to PV
1413  // PV2D
1414  anElectron.setDB(track->dxy(primaryVertex.position()),
1415  track->dxyError(primaryVertex.position(), primaryVertex.covariance()),
1416  pat::Electron::PV2D);
1417 
1418  // PV3D
1419  std::pair<bool, Measurement1D> result =
1420  IPTools::signedImpactParameter3D(tt, GlobalVector(track->px(), track->py(), track->pz()), primaryVertex);
1421  double d0_corr = result.second.value();
1422  double d0_err = primaryVertexIsValid ? result.second.error() : -1.0;
1423  anElectron.setDB(d0_corr, d0_err, pat::Electron::PV3D);
1424 
1425  // Correct to beam spot
1426  // BS2D
1427  anElectron.setDB(track->dxy(beamspot), track->dxyError(beamspot), pat::Electron::BS2D);
1428 
1429  // make a fake vertex out of beam spot
1430  reco::Vertex vBeamspot(beamspot.position(), beamspot.covariance3D());
1431 
1432  // BS3D
1433  result = IPTools::signedImpactParameter3D(tt, GlobalVector(track->px(), track->py(), track->pz()), vBeamspot);
1434  d0_corr = result.second.value();
1435  d0_err = beamspotIsValid ? result.second.error() : -1.0;
1436  anElectron.setDB(d0_corr, d0_err, pat::Electron::BS3D);
1437 
1438  // PVDZ
1439  anElectron.setDB(
1440  track->dz(primaryVertex.position()), std::hypot(track->dzError(), primaryVertex.zError()), pat::Electron::PVDZ);
1441 }
mps_fire.result
result
Definition: mps_fire.py:311
IPTools::signedImpactParameter3D
std::pair< bool, Measurement1D > signedImpactParameter3D(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:81
pat::Electron::setDB
void setDB(double dB, double edB, IPTYPE type)
Set impact parameter of a certain type and its uncertainty.
tt
Definition: TTTypes.h:54
BeamMonitor_cff.primaryVertex
primaryVertex
hltOfflineBeamSpot for HLTMON
Definition: BeamMonitor_cff.py:7
GlobalVector
Global3DVector GlobalVector
Definition: GlobalVector.h:10
HLT_2023v12_cff.track
track
Definition: HLT_2023v12_cff.py:9604

◆ fillDescriptions()

void PATElectronProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions)
static

Definition at line 1229 of file PATElectronProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addOptional(), pat::helper::KinResolutionsLoader::fillDescription(), pat::PATUserDataHelper< ObjectType >::fillDescription(), edm::ParameterSetDescription::ifValue(), ProducerED_cfi::InputTag, or, edm::ParameterSetDescription::setAllowAnything(), edm::ParameterSetDescription::setComment(), and edm::ParameterDescriptionNode::setComment().

1229  {
1230  edm::ParameterSetDescription iDesc;
1231  iDesc.setComment("PAT electron producer module");
1232 
1233  // input source
1234  iDesc.add<edm::InputTag>("pfCandidateMap", edm::InputTag("no default"))->setComment("input collection");
1235  iDesc.add<edm::InputTag>("electronSource", edm::InputTag("no default"))->setComment("input collection");
1236 
1237  iDesc.ifValue(
1238  edm::ParameterDescription<bool>("addPFClusterIso", false, true),
1239  true >> (edm::ParameterDescription<edm::InputTag>(
1240  "ecalPFClusterIsoMap", edm::InputTag("electronEcalPFClusterIsolationProducer"), true) and
1241  edm::ParameterDescription<edm::InputTag>(
1242  "hcalPFClusterIsoMap", edm::InputTag("electronHcalPFClusterIsolationProducer"), true)) or
1243  false >> (edm::ParameterDescription<edm::InputTag>("ecalPFClusterIsoMap", edm::InputTag(""), true) and
1244  edm::ParameterDescription<edm::InputTag>("hcalPFClusterIsoMap", edm::InputTag(""), true)));
1245 
1246  iDesc.ifValue(edm::ParameterDescription<bool>("addPuppiIsolation", false, true),
1247  true >> (edm::ParameterDescription<edm::InputTag>(
1248  "puppiIsolationChargedHadrons",
1249  edm::InputTag("egmElectronPUPPIIsolation", "h+-DR030-BarVeto000-EndVeto001"),
1250  true) and
1251  edm::ParameterDescription<edm::InputTag>(
1252  "puppiIsolationNeutralHadrons",
1253  edm::InputTag("egmElectronPUPPIIsolation", "h0-DR030-BarVeto000-EndVeto000"),
1254  true) and
1255  edm::ParameterDescription<edm::InputTag>(
1256  "puppiIsolationPhotons",
1257  edm::InputTag("egmElectronPUPPIIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
1258  true) and
1259  edm::ParameterDescription<edm::InputTag>(
1260  "puppiNoLeptonsIsolationChargedHadrons",
1261  edm::InputTag("egmElectronPUPPINoLeptonsIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
1262  true) and
1263  edm::ParameterDescription<edm::InputTag>(
1264  "puppiNoLeptonsIsolationNeutralHadrons",
1265  edm::InputTag("egmElectronPUPPINoLeptonsIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
1266  true) and
1267  edm::ParameterDescription<edm::InputTag>(
1268  "puppiNoLeptonsIsolationPhotons",
1269  edm::InputTag("egmElectronPUPPINoLeptonsIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
1270  true)) or
1271  false >> edm::EmptyGroupDescription());
1272 
1273  // embedding
1274  iDesc.add<bool>("embedGsfElectronCore", true)->setComment("embed external gsf electron core");
1275  iDesc.add<bool>("embedGsfTrack", true)->setComment("embed external gsf track");
1276  iDesc.add<bool>("embedSuperCluster", true)->setComment("embed external super cluster");
1277  iDesc.add<bool>("embedPflowSuperCluster", true)->setComment("embed external super cluster");
1278  iDesc.add<bool>("embedSeedCluster", true)->setComment("embed external seed cluster");
1279  iDesc.add<bool>("embedBasicClusters", true)->setComment("embed external basic clusters");
1280  iDesc.add<bool>("embedPreshowerClusters", true)->setComment("embed external preshower clusters");
1281  iDesc.add<bool>("embedPflowBasicClusters", true)->setComment("embed external pflow basic clusters");
1282  iDesc.add<bool>("embedPflowPreshowerClusters", true)->setComment("embed external pflow preshower clusters");
1283  iDesc.add<bool>("embedTrack", false)->setComment("embed external track");
1284  iDesc.add<bool>("embedRecHits", true)->setComment("embed external RecHits");
1285 
1286  // pf specific parameters
1287  iDesc.add<edm::InputTag>("pfElectronSource", edm::InputTag("pfElectrons"))
1288  ->setComment("particle flow input collection");
1289  auto&& usePfCandidateMultiMap = edm::ParameterDescription<bool>("usePfCandidateMultiMap", false, true);
1290  usePfCandidateMultiMap.setComment(
1291  "take ParticleFlow candidates from pfCandidateMultiMap instead of matching to pfElectrons by Gsf track "
1292  "reference");
1293  iDesc.ifValue(usePfCandidateMultiMap,
1294  true >> edm::ParameterDescription<edm::InputTag>("pfCandidateMultiMap", true) or
1295  false >> edm::EmptyGroupDescription());
1296  iDesc.add<bool>("useParticleFlow", false)->setComment("whether to use particle flow or not");
1297  iDesc.add<bool>("embedPFCandidate", false)->setComment("embed external particle flow object");
1298 
1299  // MC matching configurables
1300  iDesc.add<bool>("addGenMatch", true)->setComment("add MC matching");
1301  iDesc.add<bool>("embedGenMatch", false)->setComment("embed MC matched MC information");
1302  std::vector<edm::InputTag> emptySourceVector;
1303  iDesc
1304  .addNode(edm::ParameterDescription<edm::InputTag>("genParticleMatch", edm::InputTag(), true) xor
1305  edm::ParameterDescription<std::vector<edm::InputTag>>("genParticleMatch", emptySourceVector, true))
1306  ->setComment("input with MC match information");
1307 
1308  // electron ID configurables
1309  iDesc.add<bool>("addElectronID", true)->setComment("add electron ID variables");
1310  edm::ParameterSetDescription electronIDSourcesPSet;
1311  electronIDSourcesPSet.setAllowAnything();
1312  iDesc
1313  .addNode(
1314  edm::ParameterDescription<edm::InputTag>("electronIDSource", edm::InputTag(), true) xor
1315  edm::ParameterDescription<edm::ParameterSetDescription>("electronIDSources", electronIDSourcesPSet, true))
1316  ->setComment("input with electron ID variables");
1317 
1318  // mini-iso
1319  iDesc.add<bool>("computeMiniIso", false)->setComment("whether or not to compute and store electron mini-isolation");
1320  iDesc.add<edm::InputTag>("pfCandsForMiniIso", edm::InputTag("packedPFCandidates"))
1321  ->setComment("collection to use to compute mini-iso");
1322  iDesc.add<std::vector<double>>("miniIsoParamsE", std::vector<double>())
1323  ->setComment("mini-iso parameters to use for endcap electrons");
1324  iDesc.add<std::vector<double>>("miniIsoParamsB", std::vector<double>())
1325  ->setComment("mini-iso parameters to use for barrel electrons");
1326 
1327  // IsoDeposit configurables
1328  edm::ParameterSetDescription isoDepositsPSet;
1329  isoDepositsPSet.addOptional<edm::InputTag>("tracker");
1330  isoDepositsPSet.addOptional<edm::InputTag>("ecal");
1331  isoDepositsPSet.addOptional<edm::InputTag>("hcal");
1332  isoDepositsPSet.addOptional<edm::InputTag>("pfAllParticles");
1333  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedHadrons");
1334  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedAll");
1335  isoDepositsPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
1336  isoDepositsPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
1337  isoDepositsPSet.addOptional<edm::InputTag>("pfPhotons");
1338  isoDepositsPSet.addOptional<std::vector<edm::InputTag>>("user");
1339  iDesc.addOptional("isoDeposits", isoDepositsPSet);
1340 
1341  // isolation values configurables
1342  edm::ParameterSetDescription isolationValuesPSet;
1343  isolationValuesPSet.addOptional<edm::InputTag>("tracker");
1344  isolationValuesPSet.addOptional<edm::InputTag>("ecal");
1345  isolationValuesPSet.addOptional<edm::InputTag>("hcal");
1346  isolationValuesPSet.addOptional<edm::InputTag>("pfAllParticles");
1347  isolationValuesPSet.addOptional<edm::InputTag>("pfChargedHadrons");
1348  isolationValuesPSet.addOptional<edm::InputTag>("pfChargedAll");
1349  isolationValuesPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
1350  isolationValuesPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
1351  isolationValuesPSet.addOptional<edm::InputTag>("pfPhotons");
1352  isolationValuesPSet.addOptional<std::vector<edm::InputTag>>("user");
1353  iDesc.addOptional("isolationValues", isolationValuesPSet);
1354 
1355  // isolation values configurables
1356  edm::ParameterSetDescription isolationValuesNoPFIdPSet;
1357  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("tracker");
1358  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("ecal");
1359  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("hcal");
1360  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfAllParticles");
1361  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfChargedHadrons");
1362  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfChargedAll");
1363  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
1364  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
1365  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfPhotons");
1366  isolationValuesNoPFIdPSet.addOptional<std::vector<edm::InputTag>>("user");
1367  iDesc.addOptional("isolationValuesNoPFId", isolationValuesNoPFIdPSet);
1368 
1369  // Efficiency configurables
1370  edm::ParameterSetDescription efficienciesPSet;
1371  efficienciesPSet.setAllowAnything(); // TODO: the pat helper needs to implement a description.
1372  iDesc.add("efficiencies", efficienciesPSet);
1373  iDesc.add<bool>("addEfficiencies", false);
1374 
1375  // Check to see if the user wants to add user data
1376  edm::ParameterSetDescription userDataPSet;
1377  PATUserDataHelper<Electron>::fillDescription(userDataPSet);
1378  iDesc.addOptional("userData", userDataPSet);
1379 
1380  // electron shapes
1381  iDesc.add<bool>("addMVAVariables", true)->setComment("embed extra variables in pat::Electron : sip3d, sigmaIEtaIPhi");
1382  iDesc.add<edm::InputTag>("reducedBarrelRecHitCollection", edm::InputTag("reducedEcalRecHitsEB"));
1383  iDesc.add<edm::InputTag>("reducedEndcapRecHitCollection", edm::InputTag("reducedEcalRecHitsEE"));
1384 
1385  edm::ParameterSetDescription isolationPSet;
1386  isolationPSet.setAllowAnything(); // TODO: the pat helper needs to implement a description.
1387  iDesc.add("userIsolation", isolationPSet);
1388 
1389  // Resolution configurables
1390  pat::helper::KinResolutionsLoader::fillDescription(iDesc);
1391 
1392  iDesc.add<bool>("embedHighLevelSelection", true)->setComment("embed high level selection");
1393  edm::ParameterSetDescription highLevelPSet;
1394  highLevelPSet.setAllowAnything();
1395  iDesc.addNode(edm::ParameterDescription<edm::InputTag>("beamLineSrc", edm::InputTag(), true))
1396  ->setComment("input with high level selection");
1397  iDesc.addNode(edm::ParameterDescription<edm::InputTag>("pvSrc", edm::InputTag(), true))
1398  ->setComment("input with high level selection");
1399 
1400  descriptions.add("PATElectronProducer", iDesc);
1401 }
edm::ParameterDescriptionNode::setComment
void setComment(std::string const &value)
Definition: ParameterDescriptionNode.cc:106
edm::ParameterSetDescription::ifValue
ParameterDescriptionNode * ifValue(ParameterDescription< T > const &switchParameter, std::unique_ptr< ParameterDescriptionCases< T >> cases)
Definition: ParameterSetDescription.h:220
ProducerED_cfi.InputTag
InputTag
Definition: ProducerED_cfi.py:5
edm::ParameterSetDescription::addOptional
ParameterDescriptionBase * addOptional(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:105
edm::ParameterSetDescription::setAllowAnything
void setAllowAnything()
allow any parameter label/value pairs
Definition: ParameterSetDescription.cc:37
edm::ParameterSetDescription::addNode
ParameterDescriptionNode * addNode(ParameterDescriptionNode const &node)
Definition: ParameterSetDescription.cc:41
pat::PATUserDataHelper::fillDescription
static void fillDescription(edm::ParameterSetDescription &iDesc)
Definition: PATUserDataHelper.h:134
edm::ParameterSetDescription::setComment
void setComment(std::string const &value)
Definition: ParameterSetDescription.cc:33
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
pat::helper::KinResolutionsLoader::fillDescription
static void fillDescription(edm::ParameterSetDescription &iDesc)
Method for documentation and validation of PSet.
Definition: KinResolutionsLoader.cc:33
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57

◆ fillElectron()

void PATElectronProducer::fillElectron ( Electron &  aElectron,
const ElectronBaseRef &  electronRef,
const reco::CandidateBaseRef &  baseRef,
const GenAssociations &  genMatches,
const IsoDepositMaps &  deposits,
const bool  pfId,
const IsolationValueMaps &  isolationValues,
const IsolationValueMaps &  isolationValuesNoPFId 
) const
private

common electron filling, for both the standard and PF2PAT case

Definition at line 1024 of file PATElectronProducer.cc.

References addGenMatch_, pat::PATObject< ObjectType >::addGenParticleRef(), cms::cuda::assert(), CandIsolatorFromDeposits_cfi::deposits, efficiencyLoader_, pat::Electron::embedBasicClusters(), embedBasicClusters_, embedGenMatch_, pat::PATObject< ObjectType >::embedGenParticle(), pat::Electron::embedGsfElectronCore(), embedGsfElectronCore_, pat::Electron::embedGsfTrack(), embedGsfTrack_, pat::Electron::embedPflowBasicClusters(), embedPflowBasicClusters_, pat::Electron::embedPflowPreshowerClusters(), embedPflowPreshowerClusters_, pat::Electron::embedPflowSuperCluster(), embedPflowSuperCluster_, pat::Electron::embedPreshowerClusters(), embedPreshowerClusters_, pat::Electron::embedSeedCluster(), embedSeedCluster_, pat::Electron::embedSuperCluster(), embedSuperCluster_, pat::Electron::embedTrack(), embedTrack_, pat::helper::EfficiencyLoader::enabled(), pat::helper::KinResolutionsLoader::enabled(), dqmdumpme::first, mps_fire::i, edm::Ref< C, T, F >::isNull(), isoDepositLabels_, isolationValueLabels_, isolationValueLabelsNoPFId_, displacedMuonProducer_cff::isolationValues, electronProducer_cff::isolationValuesNoPFId, dqmiolumiharvest::j, dqmiodumpmetadata::n, pat::Electron::pfCandidateRef(), resolutionLoader_, pat::helper::EfficiencyLoader::setEfficiencies(), pat::Lepton< LeptonType >::setIsoDeposit(), pat::Lepton< LeptonType >::setIsolation(), pat::helper::KinResolutionsLoader::setResolutions(), source, and useParticleFlow_.

Referenced by produce().

1031  {
1032  //COLIN: might want to use the PFCandidate 4-mom. Which one is in use now?
1033  // if (useParticleFlow_)
1034  // aMuon.setP4( aMuon.pfCandidateRef()->p4() );
1035 
1036  //COLIN:
1037  //In the embedding case, the reference cannot be used to look into a value map.
1038  //therefore, one has to had the PFCandidateRef to this function, which becomes a bit
1039  //too much specific.
1040 
1041  // in fact, this function needs a baseref or ptr for genmatch
1042  // and a baseref or ptr for isodeposits and isolationvalues.
1043  // baseref is not needed
1044  // the ptrForIsolation and ptrForMatching should be defined upstream.
1045 
1046  // is the concrete elecRef needed for the efficiency loader? what is this loader?
1047  // how can we make it compatible with the particle flow electrons?
1048 
1049  if (embedGsfElectronCore_)
1050  anElectron.embedGsfElectronCore();
1051  if (embedGsfTrack_)
1052  anElectron.embedGsfTrack();
1053  if (embedSuperCluster_)
1054  anElectron.embedSuperCluster();
1055  if (embedPflowSuperCluster_)
1056  anElectron.embedPflowSuperCluster();
1057  if (embedSeedCluster_)
1058  anElectron.embedSeedCluster();
1059  if (embedBasicClusters_)
1060  anElectron.embedBasicClusters();
1061  if (embedPreshowerClusters_)
1062  anElectron.embedPreshowerClusters();
1063  if (embedPflowBasicClusters_)
1064  anElectron.embedPflowBasicClusters();
1065  if (embedPflowPreshowerClusters_)
1066  anElectron.embedPflowPreshowerClusters();
1067  if (embedTrack_)
1068  anElectron.embedTrack();
1069 
1070  // store the match to the generated final state muons
1071  if (addGenMatch_) {
1072  for (size_t i = 0, n = genMatches.size(); i < n; ++i) {
1073  if (useParticleFlow_) {
1074  reco::GenParticleRef genElectron = (*genMatches[i])[anElectron.pfCandidateRef()];
1075  anElectron.addGenParticleRef(genElectron);
1076  } else {
1077  reco::GenParticleRef genElectron = (*genMatches[i])[elecRef];
1078  anElectron.addGenParticleRef(genElectron);
1079  }
1080  }
1081  if (embedGenMatch_)
1082  anElectron.embedGenParticle();
1083  }
1084 
1085  if (efficiencyLoader_.enabled()) {
1086  efficiencyLoader_.setEfficiencies(anElectron, elecRef);
1087  }
1088 
1089  if (resolutionLoader_.enabled()) {
1090  resolutionLoader_.setResolutions(anElectron);
1091  }
1092 
1093  for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
1094  if (useParticleFlow_) {
1095  reco::PFCandidateRef pfcandref = anElectron.pfCandidateRef();
1096  assert(!pfcandref.isNull());
1097  reco::CandidatePtr source = pfcandref->sourceCandidatePtr(0);
1098  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[source]);
1099  } else
1100  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[elecRef]);
1101  }
1102 
1103  for (size_t j = 0; j < isolationValues.size(); ++j) {
1104  if (useParticleFlow_) {
1105  reco::CandidatePtr source = anElectron.pfCandidateRef()->sourceCandidatePtr(0);
1106  anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[source]);
1107  } else if (pfId) {
1108  anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[elecRef]);
1109  }
1110  }
1111 
1112  //for electrons not identified as PF electrons
1113  for (size_t j = 0; j < isolationValuesNoPFId.size(); ++j) {
1114  if (!pfId) {
1115  anElectron.setIsolation(isolationValueLabelsNoPFId_[j].first, (*isolationValuesNoPFId[j])[elecRef]);
1116  }
1117  }
1118 }
pat::helper::EfficiencyLoader::enabled
bool enabled() const
&#39;true&#39; if this there is at least one efficiency configured
Definition: EfficiencyLoader.h:25
mps_fire.i
i
Definition: mps_fire.py:429
pat::PATElectronProducer::useParticleFlow_
const bool useParticleFlow_
pflow specific
Definition: PATElectronProducer.cc:105
pat::helper::EfficiencyLoader::setEfficiencies
void setEfficiencies(pat::PATObject< T > &obj, const R &originalRef) const
Sets the efficiencies for this object, using the reference to the original objects.
Definition: EfficiencyLoader.h:41
pat::helper::KinResolutionsLoader::setResolutions
void setResolutions(pat::PATObject< T > &obj) const
Sets the efficiencies for this object, using the reference to the original objects.
Definition: KinResolutionsLoader.h:52
cms::cuda::assert
assert(be >=bs)
pat::helper::KinResolutionsLoader::enabled
bool enabled() const
&#39;true&#39; if this there is at least one efficiency configured
Definition: KinResolutionsLoader.h:30
CandIsolatorFromDeposits_cfi.deposits
deposits
Definition: CandIsolatorFromDeposits_cfi.py:4
edm::Ref::isNull
bool isNull() const
Checks for null.
Definition: Ref.h:235
pat::PATElectronProducer::efficiencyLoader_
pat::helper::EfficiencyLoader efficiencyLoader_
Definition: PATElectronProducer.cc:194
pat::PATElectronProducer::isolationValueLabelsNoPFId_
IsolationLabels isolationValueLabelsNoPFId_
Definition: PATElectronProducer.cc:190
pat::PATElectronProducer::isolationValueLabels_
IsolationLabels isolationValueLabels_
Definition: PATElectronProducer.cc:188
pat::PATElectronProducer::resolutionLoader_
pat::helper::KinResolutionsLoader resolutionLoader_
Definition: PATElectronProducer.cc:197
source
static std::string const source
Definition: EdmProvDump.cc:49
electronProducer_cff.isolationValuesNoPFId
isolationValuesNoPFId
Definition: electronProducer_cff.py:34
displacedMuonProducer_cff.isolationValues
isolationValues
Definition: displacedMuonProducer_cff.py:86

◆ fillElectron2()

void PATElectronProducer::fillElectron2 ( Electron &  anElectron,
const reco::CandidatePtr &  candPtrForIsolation,
const reco::CandidatePtr &  candPtrForGenMatch,
const reco::CandidatePtr &  candPtrForLoader,
const GenAssociations &  genMatches,
const IsoDepositMaps &  deposits,
const IsolationValueMaps &  isolationValues 
) const
private

Definition at line 1120 of file PATElectronProducer.cc.

References addGenMatch_, pat::PATObject< ObjectType >::addGenParticleRef(), edm::contains(), CandIsolatorFromDeposits_cfi::deposits, pat::EcalIso, efficiencyLoader_, pat::Electron::embedBasicClusters(), embedBasicClusters_, embedGenMatch_, pat::PATObject< ObjectType >::embedGenParticle(), pat::Electron::embedGsfElectronCore(), embedGsfElectronCore_, pat::Electron::embedGsfTrack(), embedGsfTrack_, pat::Electron::embedPflowBasicClusters(), embedPflowBasicClusters_, pat::Electron::embedPflowPreshowerClusters(), embedPflowPreshowerClusters_, pat::Electron::embedPflowSuperCluster(), embedPflowSuperCluster_, pat::Electron::embedPreshowerClusters(), embedPreshowerClusters_, pat::Electron::embedSeedCluster(), embedSeedCluster_, pat::Electron::embedSuperCluster(), embedSuperCluster_, pat::Electron::embedTrack(), embedTrack_, pat::helper::EfficiencyLoader::enabled(), pat::helper::KinResolutionsLoader::enabled(), dqmdumpme::first, pat::HcalIso, mps_fire::i, edm::Ptr< T >::id(), isoDepositLabels_, isolationValueLabels_, displacedMuonProducer_cff::isolationValues, dqmiolumiharvest::j, dqmiodumpmetadata::n, reco::GsfElectron::p4(), pat::Electron::pfCandidateRef(), resolutionLoader_, pat::Electron::setEcalDrivenMomentum(), pat::helper::EfficiencyLoader::setEfficiencies(), pat::Lepton< LeptonType >::setIsoDeposit(), pat::Lepton< LeptonType >::setIsolation(), reco::GsfElectron::setP4(), pat::helper::KinResolutionsLoader::setResolutions(), and pat::TrackIso.

Referenced by produce().

1126  {
1127  //COLIN/Florian: use the PFCandidate 4-mom.
1128  anElectron.setEcalDrivenMomentum(anElectron.p4());
1129  anElectron.setP4(anElectron.pfCandidateRef()->p4());
1130 
1131  // is the concrete elecRef needed for the efficiency loader? what is this loader?
1132  // how can we make it compatible with the particle flow electrons?
1133 
1134  if (embedGsfElectronCore_)
1135  anElectron.embedGsfElectronCore();
1136  if (embedGsfTrack_)
1137  anElectron.embedGsfTrack();
1138  if (embedSuperCluster_)
1139  anElectron.embedSuperCluster();
1140  if (embedPflowSuperCluster_)
1141  anElectron.embedPflowSuperCluster();
1142  if (embedSeedCluster_)
1143  anElectron.embedSeedCluster();
1144  if (embedBasicClusters_)
1145  anElectron.embedBasicClusters();
1146  if (embedPreshowerClusters_)
1147  anElectron.embedPreshowerClusters();
1148  if (embedPflowBasicClusters_)
1149  anElectron.embedPflowBasicClusters();
1150  if (embedPflowPreshowerClusters_)
1151  anElectron.embedPflowPreshowerClusters();
1152  if (embedTrack_)
1153  anElectron.embedTrack();
1154 
1155  // store the match to the generated final state muons
1156 
1157  if (addGenMatch_) {
1158  for (size_t i = 0, n = genMatches.size(); i < n; ++i) {
1159  reco::GenParticleRef genElectron = (*genMatches[i])[candPtrForGenMatch];
1160  anElectron.addGenParticleRef(genElectron);
1161  }
1162  if (embedGenMatch_)
1163  anElectron.embedGenParticle();
1164  }
1165 
1166  //COLIN what's this? does it have to be GsfElectron specific?
1167  if (efficiencyLoader_.enabled()) {
1168  efficiencyLoader_.setEfficiencies(anElectron, candPtrForLoader);
1169  }
1170 
1171  if (resolutionLoader_.enabled()) {
1172  resolutionLoader_.setResolutions(anElectron);
1173  }
1174 
1175  for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
1176  if (isoDepositLabels_[j].first == pat::TrackIso || isoDepositLabels_[j].first == pat::EcalIso ||
1177  isoDepositLabels_[j].first == pat::HcalIso || deposits[j]->contains(candPtrForGenMatch.id())) {
1178  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[candPtrForGenMatch]);
1179  } else if (deposits[j]->contains(candPtrForIsolation.id())) {
1180  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[candPtrForIsolation]);
1181  } else {
1182  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[candPtrForIsolation->sourceCandidatePtr(0)]);
1183  }
1184  }
1185 
1186  for (size_t j = 0; j < isolationValues.size(); ++j) {
1187  if (isolationValueLabels_[j].first == pat::TrackIso || isolationValueLabels_[j].first == pat::EcalIso ||
1188  isolationValueLabels_[j].first == pat::HcalIso || isolationValues[j]->contains(candPtrForGenMatch.id())) {
1189  anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[candPtrForGenMatch]);
1190  } else if (isolationValues[j]->contains(candPtrForIsolation.id())) {
1191  anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[candPtrForIsolation]);
1192  } else {
1193  anElectron.setIsolation(isolationValueLabels_[j].first,
1194  (*isolationValues[j])[candPtrForIsolation->sourceCandidatePtr(0)]);
1195  }
1196  }
1197 }
pat::helper::EfficiencyLoader::enabled
bool enabled() const
&#39;true&#39; if this there is at least one efficiency configured
Definition: EfficiencyLoader.h:25
reco::GsfElectron::setP4
void setP4(P4Kind kind, const LorentzVector &p4, float p4Error, bool setCandidate)
Definition: GsfElectron.cc:194
mps_fire.i
i
Definition: mps_fire.py:429
pat::Lepton::setIsolation
void setIsolation(IsolationKeys key, float value)
Definition: Lepton.h:115
edm::contains
bool contains(EventRange const &lh, EventID const &rh)
Definition: EventRange.cc:37
edm::Ptr::id
ProductID id() const
Accessor for product ID.
Definition: Ptr.h:160
pat::helper::EfficiencyLoader::setEfficiencies
void setEfficiencies(pat::PATObject< T > &obj, const R &originalRef) const
Sets the efficiencies for this object, using the reference to the original objects.
Definition: EfficiencyLoader.h:41
pat::Electron::embedSuperCluster
void embedSuperCluster()
method to store the electron&#39;s SuperCluster internally
pat::Electron::embedGsfElectronCore
void embedGsfElectronCore()
method to store the electron&#39;s core internally
pat::helper::KinResolutionsLoader::setResolutions
void setResolutions(pat::PATObject< T > &obj) const
Sets the efficiencies for this object, using the reference to the original objects.
Definition: KinResolutionsLoader.h:52
pat::Electron::setEcalDrivenMomentum
void setEcalDrivenMomentum(const Candidate::LorentzVector &mom)
Definition: Electron.h:204
pat::Electron::embedPflowSuperCluster
void embedPflowSuperCluster()
method to store the electron&#39;s PflowSuperCluster internally
pat::Electron::pfCandidateRef
reco::PFCandidateRef pfCandidateRef() const
reference to the source PFCandidates; null if this has been built from a standard electron ...
pat::Lepton::setIsoDeposit
void setIsoDeposit(IsolationKeys key, const IsoDeposit &dep)
Sets the IsoDeposit associated with some key; if it is already existent, it is overwritten.
Definition: Lepton.h:191
pat::Electron::embedSeedCluster
void embedSeedCluster()
method to store the electron&#39;s seedcluster internally
pat::PATObject::embedGenParticle
void embedGenParticle()
Definition: PATObject.h:768
pat::helper::KinResolutionsLoader::enabled
bool enabled() const
&#39;true&#39; if this there is at least one efficiency configured
Definition: KinResolutionsLoader.h:30
CandIsolatorFromDeposits_cfi.deposits
deposits
Definition: CandIsolatorFromDeposits_cfi.py:4
pat::Electron::embedPflowBasicClusters
void embedPflowBasicClusters()
method to store the electron&#39;s pflow basic clusters
reco::GsfElectron::p4
const LorentzVector & p4(P4Kind kind) const
Definition: GsfElectron.cc:217
pat::Electron::embedBasicClusters
void embedBasicClusters()
method to store the electron&#39;s basic clusters
pat::Electron::embedGsfTrack
void embedGsfTrack()
method to store the electron&#39;s GsfTrack internally
pat::PATObject::addGenParticleRef
void addGenParticleRef(const reco::GenParticleRef &ref)
Definition: PATObject.h:751
pat::PATElectronProducer::efficiencyLoader_
pat::helper::EfficiencyLoader efficiencyLoader_
Definition: PATElectronProducer.cc:194
pat::Electron::embedPreshowerClusters
void embedPreshowerClusters()
method to store the electron&#39;s preshower clusters
pat::PATElectronProducer::isolationValueLabels_
IsolationLabels isolationValueLabels_
Definition: PATElectronProducer.cc:188
pat::PATElectronProducer::resolutionLoader_
pat::helper::KinResolutionsLoader resolutionLoader_
Definition: PATElectronProducer.cc:197
pat::Electron::embedPflowPreshowerClusters
void embedPflowPreshowerClusters()
method to store the electron&#39;s pflow preshower clusters
pat::Electron::embedTrack
void embedTrack()
method to store the electron&#39;s Track internally
displacedMuonProducer_cff.isolationValues
isolationValues
Definition: displacedMuonProducer_cff.py:86

◆ produce()

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

Definition at line 442 of file PATElectronProducer.cc.

References IPTools::absoluteImpactParameter3D(), pat::PATUserDataHelper< ObjectType >::add(), addElecID_, addGenMatch_, addMVAVariables_, addPFClusterIso_, addPuppiIsolation_, Reference_intrackfit_cff::barrel, beamLineToken_, pwdgSkimBPark_cfi::beamSpot, pat::helper::MultiIsolator::beginEvent(), nano_mu_local_reco_cff::bool, TransientTrackBuilder::build(), computeMiniIso_, CandIsolatorFromDeposits_cfi::deposits, reco::PFCandidate::e, DetId::Ecal, EcalBarrel, ecalClusterToolsESGetTokens_, EcalEndcap, ecalPFClusterIsoT_, ecalTopology_, ecalTopologyToken_, efficiencyLoader_, elecIDSrcs_, elecIDTokens_, pwdgSkimBPark_cfi::electrons, electronToken_, embedBasicClusters_, embedGenMatch_, embedHighLevel(), embedHighLevelSelection_, pat::Electron::embedPFCandidate(), embedPFCandidate_, embedPflowBasicClusters_, pat::Electron::embedRecHits(), embedRecHits_, pat::helper::EfficiencyLoader::enabled(), pat::helper::KinResolutionsLoader::enabled(), pat::helper::MultiIsolator::enabled(), pat::helper::MultiIsolator::endEvent(), pat::helper::MultiIsolator::fill(), fillElectron(), fillElectron2(), dqmdumpme::first, genMatchTokens_, EcalClusterLazyToolsBase::ESGetTokens::get(), edm::EventSetup::getData(), edm::EventSetup::getHandle(), CaloTopology::getSubdetectorTopology(), CaloSubdetectorTopology::getWindow(), ConversionTools::hasMatchedConversion(), hcalPFClusterIsoT_, hConversionsToken_, mps_fire::i, heavyIonCSV_trainingSettings::idx, iEvent, electrons_cff::ip3d, edm::Ptr< T >::isNonnull(), isoDepositLabels_, isoDepositTokens_, isolationValueNoPFIdTokens_, displacedMuonProducer_cff::isolationValues, electronProducer_cff::isolationValuesNoPFId, isolationValueTokens_, isolator_, isolatorTmpStorage_, edm::HandleBase::isValid(), dqmiolumiharvest::j, reco::Matched, reco::HitPattern::MISSING_INNER_HITS, eostools::move(), pat::helper::EfficiencyLoader::newEvent(), pat::helper::KinResolutionsLoader::newEvent(), patElectronEAIsoCorrectionProducer_cfi::patElectrons, pcToken_, packedPFCandidateRefMixer_cfi::pf, pfCandidateMapToken_, pfCandidateMultiMapToken_, pfElecToken_, electronIsolatorFromEffectiveArea_cfi::pfElectrons, reco::GsfElectron::pfIsolationVariables(), reco::BeamSpot::position(), BeamMonitor_cff::primaryVertex, edm::Handle< T >::product(), pTComparator_, PUPPIIsolation_charged_hadrons_, PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_photons_, PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_photons_, edm::SortedCollection< T, SORT >::push_back(), pvToken_, FastTrackerRecHitMaskProducer_cfi::recHits, reducedBarrelRecHitCollectionToken_, electronIdMVAProducer_cfi::reducedEBRecHitCollection, electronIdMVAProducer_cfi::reducedEERecHitCollection, reducedEndcapRecHitCollectionToken_, resolutionLoader_, fileCollector::seed, pat::Electron::setElectronIDs(), setElectronMiniIso(), pat::Lepton< LeptonType >::setIsoDeposit(), pat::Lepton< LeptonType >::setIsolation(), pat::Electron::setIsolationPUPPI(), pat::Electron::setIsolationPUPPINoLeptons(), pat::Electron::setIsPF(), pat::Electron::setMvaVariables(), pat::Electron::setPassConversionVeto(), pat::Electron::setPFCandidateRef(), reco::GsfElectron::setPfIsolationVariables(), jetUpdater_cfi::sort, edm::SortedCollection< T, SORT >::sort(), reco::GsfElectron::PflowIsolationVariables::sumEcalClusterEt, reco::GsfElectron::PflowIsolationVariables::sumHcalClusterEt, HLT_2023v12_cff::track, trackBuilderToken_, tier0::unique(), useParticleFlow_, usePfCandidateMultiMap_, userDataHelper_, and useUserData_.

442  {
443  // switch off embedding (in unschedules mode)
444  if (iEvent.isRealData()) {
445  addGenMatch_ = false;
446  embedGenMatch_ = false;
447  }
448 
449  ecalTopology_ = &iSetup.getData(ecalTopologyToken_);
450 
451  // Get the collection of electrons from the event
452  edm::Handle<edm::View<reco::GsfElectron>> electrons;
453  iEvent.getByToken(electronToken_, electrons);
454 
455  edm::Handle<PackedCandidateCollection> pc;
456  if (computeMiniIso_)
457  iEvent.getByToken(pcToken_, pc);
458 
459  // for additional mva variables
460  edm::InputTag reducedEBRecHitCollection(string("reducedEcalRecHitsEB"));
461  edm::InputTag reducedEERecHitCollection(string("reducedEcalRecHitsEE"));
462  //EcalClusterLazyTools lazyTools(iEvent, iSetup, reducedEBRecHitCollection, reducedEERecHitCollection);
463  EcalClusterLazyTools lazyTools(iEvent,
464  ecalClusterToolsESGetTokens_.get(iSetup),
465  reducedBarrelRecHitCollectionToken_,
466  reducedEndcapRecHitCollectionToken_);
467 
468  // for conversion veto selection
469  edm::Handle<reco::ConversionCollection> hConversions;
470  iEvent.getByToken(hConversionsToken_, hConversions);
471 
472  // Get the ESHandle for the transient track builder, if needed for
473  // high level selection embedding
474  edm::ESHandle<TransientTrackBuilder> trackBuilder;
475 
476  if (isolator_.enabled())
477  isolator_.beginEvent(iEvent, iSetup);
478 
479  if (efficiencyLoader_.enabled())
480  efficiencyLoader_.newEvent(iEvent);
481  if (resolutionLoader_.enabled())
482  resolutionLoader_.newEvent(iEvent, iSetup);
483 
484  IsoDepositMaps deposits(isoDepositTokens_.size());
485  for (size_t j = 0, nd = isoDepositTokens_.size(); j < nd; ++j) {
486  iEvent.getByToken(isoDepositTokens_[j], deposits[j]);
487  }
488 
489  IsolationValueMaps isolationValues(isolationValueTokens_.size());
490  for (size_t j = 0; j < isolationValueTokens_.size(); ++j) {
491  iEvent.getByToken(isolationValueTokens_[j], isolationValues[j]);
492  }
493 
494  IsolationValueMaps isolationValuesNoPFId(isolationValueNoPFIdTokens_.size());
495  for (size_t j = 0; j < isolationValueNoPFIdTokens_.size(); ++j) {
496  iEvent.getByToken(isolationValueNoPFIdTokens_[j], isolationValuesNoPFId[j]);
497  }
498 
499  // prepare the MC matching
500  GenAssociations genMatches(genMatchTokens_.size());
501  if (addGenMatch_) {
502  for (size_t j = 0, nd = genMatchTokens_.size(); j < nd; ++j) {
503  iEvent.getByToken(genMatchTokens_[j], genMatches[j]);
504  }
505  }
506 
507  // prepare ID extraction
508  std::vector<edm::Handle<edm::ValueMap<float>>> idhandles;
509  std::vector<pat::Electron::IdPair> ids;
510  if (addElecID_) {
511  idhandles.resize(elecIDSrcs_.size());
512  ids.resize(elecIDSrcs_.size());
513  for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
514  iEvent.getByToken(elecIDTokens_[i], idhandles[i]);
515  ids[i].first = elecIDSrcs_[i].first;
516  }
517  }
518 
519  // prepare the high level selection:
520  // needs beamline
521  reco::TrackBase::Point beamPoint(0, 0, 0);
522  reco::Vertex primaryVertex;
523  reco::BeamSpot beamSpot;
524  bool beamSpotIsValid = false;
525  bool primaryVertexIsValid = false;
526 
527  // Get the beamspot
528  edm::Handle<reco::BeamSpot> beamSpotHandle;
529  iEvent.getByToken(beamLineToken_, beamSpotHandle);
530 
531  if (embedHighLevelSelection_) {
532  // Get the primary vertex
533  edm::Handle<std::vector<reco::Vertex>> pvHandle;
534  iEvent.getByToken(pvToken_, pvHandle);
535 
536  // This is needed by the IPTools methods from the tracking group
537  trackBuilder = iSetup.getHandle(trackBuilderToken_);
538 
539  if (pvHandle.isValid() && !pvHandle->empty()) {
540  primaryVertex = pvHandle->at(0);
541  primaryVertexIsValid = true;
542  } else {
543  edm::LogError("DataNotAvailable")
544  << "No primary vertex available from EventSetup, not adding high level selection \n";
545  }
546  }
547  //value maps for puppi isolation
548  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_charged_hadrons;
549  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_neutral_hadrons;
550  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_photons;
551  //value maps for puppiNoLeptons isolation
552  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_charged_hadrons;
553  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_neutral_hadrons;
554  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_photons;
555  if (addPuppiIsolation_) {
556  //puppi
557  iEvent.getByToken(PUPPIIsolation_charged_hadrons_, PUPPIIsolation_charged_hadrons);
558  iEvent.getByToken(PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_neutral_hadrons);
559  iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons);
560  //puppiNoLeptons
561  iEvent.getByToken(PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_charged_hadrons);
562  iEvent.getByToken(PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons);
563  iEvent.getByToken(PUPPINoLeptonsIsolation_photons_, PUPPINoLeptonsIsolation_photons);
564  }
565 
566  std::vector<Electron>* patElectrons = new std::vector<Electron>();
567 
568  if (useParticleFlow_) {
569  edm::Handle<reco::PFCandidateCollection> pfElectrons;
570  iEvent.getByToken(pfElecToken_, pfElectrons);
571  unsigned index = 0;
572 
573  for (reco::PFCandidateConstIterator i = pfElectrons->begin(); i != pfElectrons->end(); ++i, ++index) {
574  reco::PFCandidateRef pfRef(pfElectrons, index);
575  reco::PFCandidatePtr ptrToPFElectron(pfElectrons, index);
576  // reco::CandidateBaseRef pfBaseRef( pfRef );
577 
578  reco::GsfTrackRef PfTk = i->gsfTrackRef();
579 
580  bool Matched = false;
581  bool MatchedToAmbiguousGsfTrack = false;
582  for (edm::View<reco::GsfElectron>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end();
583  ++itElectron) {
584  unsigned int idx = itElectron - electrons->begin();
585  auto elePtr = electrons->ptrAt(idx);
586  if (Matched || MatchedToAmbiguousGsfTrack)
587  continue;
588 
589  reco::GsfTrackRef EgTk = itElectron->gsfTrack();
590 
591  if (itElectron->gsfTrack() == i->gsfTrackRef()) {
592  Matched = true;
593  } else {
594  for (auto const& it : itElectron->ambiguousGsfTracks()) {
595  MatchedToAmbiguousGsfTrack |= (bool)(i->gsfTrackRef() == it);
596  }
597  }
598 
599  if (Matched || MatchedToAmbiguousGsfTrack) {
600  // ptr needed for finding the matched gen particle
601  reco::CandidatePtr ptrToGsfElectron(electrons, idx);
602 
603  // ref to base needed for the construction of the pat object
604  const edm::RefToBase<reco::GsfElectron>& elecsRef = electrons->refAt(idx);
605  Electron anElectron(elecsRef);
606  anElectron.setPFCandidateRef(pfRef);
607  if (addPuppiIsolation_) {
608  anElectron.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[elePtr],
609  (*PUPPIIsolation_neutral_hadrons)[elePtr],
610  (*PUPPIIsolation_photons)[elePtr]);
611  anElectron.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[elePtr],
612  (*PUPPINoLeptonsIsolation_neutral_hadrons)[elePtr],
613  (*PUPPINoLeptonsIsolation_photons)[elePtr]);
614  } else {
615  anElectron.setIsolationPUPPI(-999., -999., -999.);
616  anElectron.setIsolationPUPPINoLeptons(-999., -999., -999.);
617  }
618 
619  //it should be always true when particleFlow electrons are used.
620  anElectron.setIsPF(true);
621 
622  if (embedPFCandidate_)
623  anElectron.embedPFCandidate();
624 
625  if (useUserData_) {
626  userDataHelper_.add(anElectron, iEvent, iSetup);
627  }
628 
629  double ip3d = -999; // for mva variable
630 
631  // embed high level selection
632  if (embedHighLevelSelection_) {
633  // get the global track
634  const reco::GsfTrackRef& track = PfTk;
635 
636  // Make sure the collection it points to is there
637  if (track.isNonnull() && track.isAvailable()) {
638  reco::TransientTrack tt = trackBuilder->build(track);
639  embedHighLevel(anElectron, track, tt, primaryVertex, primaryVertexIsValid, beamSpot, beamSpotIsValid);
640 
641  std::pair<bool, Measurement1D> ip3dpv = IPTools::absoluteImpactParameter3D(tt, primaryVertex);
642  ip3d = ip3dpv.second.value(); // for mva variable
643  }
644  }
645 
646  //Electron Id
647 
648  if (addElecID_) {
649  //STANDARD EL ID
650  for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
651  ids[i].second = (*idhandles[i])[elecsRef];
652  }
653  //SPECIFIC PF ID
654  ids.push_back(std::make_pair("pf_evspi", pfRef->mva_e_pi()));
655  ids.push_back(std::make_pair("pf_evsmu", pfRef->mva_e_mu()));
656  anElectron.setElectronIDs(ids);
657  }
658 
659  if (addMVAVariables_) {
660  // add missing mva variables
661  const auto& vCov = lazyTools.localCovariances(*(itElectron->superCluster()->seed()));
662  anElectron.setMvaVariables(vCov[1], ip3d);
663  }
664  // PFClusterIso
665  if (addPFClusterIso_) {
666  // Get PFCluster Isolation
667  edm::Handle<edm::ValueMap<float>> ecalPFClusterIsoMapH;
668  iEvent.getByToken(ecalPFClusterIsoT_, ecalPFClusterIsoMapH);
669  edm::Handle<edm::ValueMap<float>> hcalPFClusterIsoMapH;
670  iEvent.getByToken(hcalPFClusterIsoT_, hcalPFClusterIsoMapH);
671  reco::GsfElectron::PflowIsolationVariables newPFIsol = anElectron.pfIsolationVariables();
672  newPFIsol.sumEcalClusterEt = (*ecalPFClusterIsoMapH)[elecsRef];
673  newPFIsol.sumHcalClusterEt = (*hcalPFClusterIsoMapH)[elecsRef];
674  anElectron.setPfIsolationVariables(newPFIsol);
675  }
676 
677  std::vector<DetId> selectedCells;
678  bool barrel = itElectron->isEB();
679  //loop over sub clusters
680  if (embedBasicClusters_) {
681  for (reco::CaloCluster_iterator clusIt = itElectron->superCluster()->clustersBegin();
682  clusIt != itElectron->superCluster()->clustersEnd();
683  ++clusIt) {
684  //get seed (max energy xtal)
685  DetId seed = lazyTools.getMaximum(**clusIt).first;
686  //get all xtals in 5x5 window around the seed
687  std::vector<DetId> dets5x5 =
688  (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
689  : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
690  selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
691 
692  //get all xtals belonging to cluster
693  for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
694  selectedCells.push_back(hit.first);
695  }
696  }
697  }
698 
699  if (embedPflowBasicClusters_ && itElectron->parentSuperCluster().isNonnull()) {
700  for (reco::CaloCluster_iterator clusIt = itElectron->parentSuperCluster()->clustersBegin();
701  clusIt != itElectron->parentSuperCluster()->clustersEnd();
702  ++clusIt) {
703  //get seed (max energy xtal)
704  DetId seed = lazyTools.getMaximum(**clusIt).first;
705  //get all xtals in 5x5 window around the seed
706  std::vector<DetId> dets5x5 =
707  (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
708  : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
709  selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
710 
711  //get all xtals belonging to cluster
712  for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
713  selectedCells.push_back(hit.first);
714  }
715  }
716  }
717 
718  //remove duplicates
719  std::sort(selectedCells.begin(), selectedCells.end());
720  std::unique(selectedCells.begin(), selectedCells.end());
721 
722  // Retrieve the corresponding RecHits
723 
724  edm::Handle<EcalRecHitCollection> rechitsH;
725  if (barrel)
726  iEvent.getByToken(reducedBarrelRecHitCollectionToken_, rechitsH);
727  else
728  iEvent.getByToken(reducedEndcapRecHitCollectionToken_, rechitsH);
729 
730  EcalRecHitCollection selectedRecHits;
731  const EcalRecHitCollection* recHits = rechitsH.product();
732 
733  unsigned nSelectedCells = selectedCells.size();
734  for (unsigned icell = 0; icell < nSelectedCells; ++icell) {
735  EcalRecHitCollection::const_iterator it = recHits->find(selectedCells[icell]);
736  if (it != recHits->end()) {
737  selectedRecHits.push_back(*it);
738  }
739  }
740  selectedRecHits.sort();
741  if (embedRecHits_)
742  anElectron.embedRecHits(&selectedRecHits);
743 
744  // set conversion veto selection
745  bool passconversionveto = false;
746  if (hConversions.isValid()) {
747  // this is recommended method
748  passconversionveto =
749  !ConversionTools::hasMatchedConversion(*itElectron, *hConversions, beamSpotHandle->position());
750  } else {
751  // use missing hits without vertex fit method
752  passconversionveto =
753  itElectron->gsfTrack()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) < 1;
754  }
755 
756  anElectron.setPassConversionVeto(passconversionveto);
757 
758  // fillElectron(anElectron,elecsRef,pfBaseRef,
759  // genMatches, deposits, isolationValues);
760 
761  //COLIN small warning !
762  // we are currently choosing to take the 4-momentum of the PFCandidate;
763  // the momentum of the GsfElectron is saved though
764  // we must therefore match the GsfElectron.
765  // because of this, we should not change the source of the electron matcher
766  // to the collection of PFElectrons in the python configuration
767  // I don't know what to do with the efficiencyLoader, since I don't know
768  // what this class is for.
769  fillElectron2(
770  anElectron, ptrToPFElectron, ptrToGsfElectron, ptrToGsfElectron, genMatches, deposits, isolationValues);
771 
772  //COLIN need to use fillElectron2 in the non-pflow case as well, and to test it.
773 
774  if (computeMiniIso_)
775  setElectronMiniIso(anElectron, pc.product());
776 
777  patElectrons->push_back(anElectron);
778  }
779  }
780  //if( !Matched && !MatchedToAmbiguousGsfTrack) std::cout << "!!!!A pf electron could not be matched to a gsf!!!!" << std::endl;
781  }
782  }
783 
784  else {
785  edm::Handle<reco::PFCandidateCollection> pfElectrons;
786  edm::Handle<edm::ValueMap<reco::PFCandidatePtr>> ValMapH;
787  edm::Handle<edm::ValueMap<std::vector<reco::PFCandidateRef>>> ValMultiMapH;
788  bool pfCandsPresent = false, valMapPresent = false;
789  if (usePfCandidateMultiMap_) {
790  iEvent.getByToken(pfCandidateMultiMapToken_, ValMultiMapH);
791  } else {
792  pfCandsPresent = iEvent.getByToken(pfElecToken_, pfElectrons);
793  valMapPresent = iEvent.getByToken(pfCandidateMapToken_, ValMapH);
794  }
795 
796  for (edm::View<reco::GsfElectron>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end();
797  ++itElectron) {
798  // construct the Electron from the ref -> save ref to original object
799  //FIXME: looks like a lot of instances could be turned into const refs
800  unsigned int idx = itElectron - electrons->begin();
801  edm::RefToBase<reco::GsfElectron> elecsRef = electrons->refAt(idx);
802  reco::CandidateBaseRef elecBaseRef(elecsRef);
803  Electron anElectron(elecsRef);
804  auto elePtr = electrons->ptrAt(idx);
805 
806  // Is this GsfElectron also identified as an e- in the particle flow?
807  bool pfId = false;
808 
809  if (usePfCandidateMultiMap_) {
810  for (const reco::PFCandidateRef& pf : (*ValMultiMapH)[elePtr]) {
811  if (pf->particleId() == reco::PFCandidate::e) {
812  pfId = true;
813  anElectron.setPFCandidateRef(pf);
814  break;
815  }
816  }
817  } else if (pfCandsPresent) {
818  // PF electron collection not available.
819  const reco::GsfTrackRef& trkRef = itElectron->gsfTrack();
820  int index = 0;
821  for (reco::PFCandidateConstIterator ie = pfElectrons->begin(); ie != pfElectrons->end(); ++ie, ++index) {
822  if (ie->particleId() != reco::PFCandidate::e)
823  continue;
824  const reco::GsfTrackRef& pfTrkRef = ie->gsfTrackRef();
825  if (trkRef == pfTrkRef) {
826  pfId = true;
827  reco::PFCandidateRef pfRef(pfElectrons, index);
828  anElectron.setPFCandidateRef(pfRef);
829  break;
830  }
831  }
832  } else if (valMapPresent) {
833  // use value map if PF collection not available
834  const edm::ValueMap<reco::PFCandidatePtr>& myValMap(*ValMapH);
835  // Get the PFCandidate
836  const reco::PFCandidatePtr& pfElePtr(myValMap[elecsRef]);
837  pfId = pfElePtr.isNonnull();
838  }
839  // set PFId function
840  anElectron.setIsPF(pfId);
841 
842  // add resolution info
843 
844  // Isolation
845  if (isolator_.enabled()) {
846  isolator_.fill(*electrons, idx, isolatorTmpStorage_);
847  typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
848  // better to loop backwards, so the vector is resized less times
849  for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(),
850  ed = isolatorTmpStorage_.rend();
851  it != ed;
852  ++it) {
853  anElectron.setIsolation(it->first, it->second);
854  }
855  }
856 
857  for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
858  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[elecsRef]);
859  }
860 
861  // add electron ID info
862  if (addElecID_) {
863  for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
864  ids[i].second = (*idhandles[i])[elecsRef];
865  }
866  anElectron.setElectronIDs(ids);
867  }
868 
869  if (useUserData_) {
870  userDataHelper_.add(anElectron, iEvent, iSetup);
871  }
872 
873  double ip3d = -999; //for mva variable
874 
875  // embed high level selection
876  if (embedHighLevelSelection_) {
877  // get the global track
878  reco::GsfTrackRef track = itElectron->gsfTrack();
879 
880  // Make sure the collection it points to is there
881  if (track.isNonnull() && track.isAvailable()) {
882  reco::TransientTrack tt = trackBuilder->build(track);
883  embedHighLevel(anElectron, track, tt, primaryVertex, primaryVertexIsValid, beamSpot, beamSpotIsValid);
884 
885  std::pair<bool, Measurement1D> ip3dpv = IPTools::absoluteImpactParameter3D(tt, primaryVertex);
886  ip3d = ip3dpv.second.value(); // for mva variable
887  }
888  }
889 
890  if (addMVAVariables_) {
891  // add mva variables
892  const auto& vCov = lazyTools.localCovariances(*(itElectron->superCluster()->seed()));
893  anElectron.setMvaVariables(vCov[1], ip3d);
894  }
895 
896  // PFCluster Isolation
897  if (addPFClusterIso_) {
898  // Get PFCluster Isolation
899  edm::Handle<edm::ValueMap<float>> ecalPFClusterIsoMapH;
900  iEvent.getByToken(ecalPFClusterIsoT_, ecalPFClusterIsoMapH);
901  edm::Handle<edm::ValueMap<float>> hcalPFClusterIsoMapH;
902  iEvent.getByToken(hcalPFClusterIsoT_, hcalPFClusterIsoMapH);
903  reco::GsfElectron::PflowIsolationVariables newPFIsol = anElectron.pfIsolationVariables();
904  newPFIsol.sumEcalClusterEt = (*ecalPFClusterIsoMapH)[elecsRef];
905  newPFIsol.sumHcalClusterEt = (*hcalPFClusterIsoMapH)[elecsRef];
906  anElectron.setPfIsolationVariables(newPFIsol);
907  }
908 
909  if (addPuppiIsolation_) {
910  anElectron.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[elePtr],
911  (*PUPPIIsolation_neutral_hadrons)[elePtr],
912  (*PUPPIIsolation_photons)[elePtr]);
913  anElectron.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[elePtr],
914  (*PUPPINoLeptonsIsolation_neutral_hadrons)[elePtr],
915  (*PUPPINoLeptonsIsolation_photons)[elePtr]);
916  } else {
917  anElectron.setIsolationPUPPI(-999., -999., -999.);
918  anElectron.setIsolationPUPPINoLeptons(-999., -999., -999.);
919  }
920 
921  std::vector<DetId> selectedCells;
922  bool barrel = itElectron->isEB();
923  //loop over sub clusters
924  if (embedBasicClusters_) {
925  for (reco::CaloCluster_iterator clusIt = itElectron->superCluster()->clustersBegin();
926  clusIt != itElectron->superCluster()->clustersEnd();
927  ++clusIt) {
928  //get seed (max energy xtal)
929  DetId seed = lazyTools.getMaximum(**clusIt).first;
930  //get all xtals in 5x5 window around the seed
931  std::vector<DetId> dets5x5 =
932  (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
933  : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
934  selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
935 
936  //get all xtals belonging to cluster
937  for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
938  selectedCells.push_back(hit.first);
939  }
940  }
941  }
942 
943  if (embedPflowBasicClusters_ && itElectron->parentSuperCluster().isNonnull()) {
944  for (reco::CaloCluster_iterator clusIt = itElectron->parentSuperCluster()->clustersBegin();
945  clusIt != itElectron->parentSuperCluster()->clustersEnd();
946  ++clusIt) {
947  //get seed (max energy xtal)
948  DetId seed = lazyTools.getMaximum(**clusIt).first;
949  //get all xtals in 5x5 window around the seed
950  std::vector<DetId> dets5x5 =
951  (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
952  : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
953  selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
954 
955  //get all xtals belonging to cluster
956  for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
957  selectedCells.push_back(hit.first);
958  }
959  }
960  }
961 
962  //remove duplicates
963  std::sort(selectedCells.begin(), selectedCells.end());
964  std::unique(selectedCells.begin(), selectedCells.end());
965 
966  // Retrieve the corresponding RecHits
967 
968  edm::Handle<EcalRecHitCollection> rechitsH;
969  if (barrel)
970  iEvent.getByToken(reducedBarrelRecHitCollectionToken_, rechitsH);
971  else
972  iEvent.getByToken(reducedEndcapRecHitCollectionToken_, rechitsH);
973 
974  EcalRecHitCollection selectedRecHits;
975  const EcalRecHitCollection* recHits = rechitsH.product();
976 
977  unsigned nSelectedCells = selectedCells.size();
978  for (unsigned icell = 0; icell < nSelectedCells; ++icell) {
979  EcalRecHitCollection::const_iterator it = recHits->find(selectedCells[icell]);
980  if (it != recHits->end()) {
981  selectedRecHits.push_back(*it);
982  }
983  }
984  selectedRecHits.sort();
985  if (embedRecHits_)
986  anElectron.embedRecHits(&selectedRecHits);
987 
988  // set conversion veto selection
989  bool passconversionveto = false;
990  if (hConversions.isValid()) {
991  // this is recommended method
992  passconversionveto =
993  !ConversionTools::hasMatchedConversion(*itElectron, *hConversions, beamSpotHandle->position());
994  } else {
995  // use missing hits without vertex fit method
996  passconversionveto =
997  itElectron->gsfTrack()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) < 1;
998  }
999  anElectron.setPassConversionVeto(passconversionveto);
1000 
1001  // add sel to selected
1002  fillElectron(
1003  anElectron, elecsRef, elecBaseRef, genMatches, deposits, pfId, isolationValues, isolationValuesNoPFId);
1004 
1005  if (computeMiniIso_)
1006  setElectronMiniIso(anElectron, pc.product());
1007 
1008  patElectrons->push_back(anElectron);
1009  }
1010  }
1011 
1012  // sort electrons in pt
1013  std::sort(patElectrons->begin(), patElectrons->end(), pTComparator_);
1014 
1015  // add the electrons to the event output
1016  std::unique_ptr<std::vector<Electron>> ptr(patElectrons);
1017  iEvent.put(std::move(ptr));
1018 
1019  // clean up
1020  if (isolator_.enabled())
1021  isolator_.endEvent();
1022 }
pat::helper::EfficiencyLoader::enabled
bool enabled() const
&#39;true&#39; if this there is at least one efficiency configured
Definition: EfficiencyLoader.h:25
pat::helper::EfficiencyLoader::newEvent
void newEvent(const edm::Event &event)
To be called for each new event, reads in the ValueMaps for efficiencies.
Definition: EfficiencyLoader.cc:21
jetUpdater_cfi.sort
sort
Definition: jetUpdater_cfi.py:30
pat::PATElectronProducer::hConversionsToken_
const edm::EDGetTokenT< reco::ConversionCollection > hConversionsToken_
Definition: PATElectronProducer.cc:80
pat::PATElectronProducer::PUPPINoLeptonsIsolation_charged_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_charged_hadrons_
Definition: PATElectronProducer.cc:205
mps_fire.i
i
Definition: mps_fire.py:429
pat::PATElectronProducer::pTComparator_
const GreaterByPt< Electron > pTComparator_
Definition: PATElectronProducer.cc:182
edm::EventSetup::getData
T const & getData(const ESGetToken< T, R > &iToken) const noexcept(false)
Definition: EventSetup.h:119
pat::PATElectronProducer::PUPPIIsolation_charged_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_charged_hadrons_
Definition: PATElectronProducer.cc:201
pat::helper::MultiIsolator::enabled
bool enabled() const
True if it has a non null configuration.
Definition: MultiIsolator.h:55
FastTrackerRecHitMaskProducer_cfi.recHits
recHits
Definition: FastTrackerRecHitMaskProducer_cfi.py:8
pat::PATElectronProducer::useParticleFlow_
const bool useParticleFlow_
pflow specific
Definition: PATElectronProducer.cc:105
pat::PATElectronProducer::pfElecToken_
const edm::EDGetTokenT< reco::PFCandidateCollection > pfElecToken_
Definition: PATElectronProducer.cc:107
reco::BeamSpot::position
const Point & position() const
position
Definition: BeamSpot.h:59
heavyIonCSV_trainingSettings.idx
idx
Definition: heavyIonCSV_trainingSettings.py:5
pat::PATElectronProducer::PUPPIIsolation_neutral_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_neutral_hadrons_
Definition: PATElectronProducer.cc:202
pat::PATElectronProducer::ecalPFClusterIsoT_
const edm::EDGetTokenT< edm::ValueMap< float > > ecalPFClusterIsoT_
Definition: PATElectronProducer.cc:122
edm::Handle::product
T const * product() const
Definition: Handle.h:70
pat::PATElectronProducer::embedHighLevel
void embedHighLevel(pat::Electron &anElectron, reco::GsfTrackRef track, reco::TransientTrack &tt, reco::Vertex &primaryVertex, bool primaryVertexIsValid, reco::BeamSpot &beamspot, bool beamspotIsValid)
Definition: PATElectronProducer.cc:1405
edm::SortedCollection< EcalRecHit >::const_iterator
std::vector< EcalRecHit >::const_iterator const_iterator
Definition: SortedCollection.h:80
IPTools::absoluteImpactParameter3D
std::pair< bool, Measurement1D > absoluteImpactParameter3D(const reco::TransientTrack &transientTrack, const reco::Vertex &vertex)
Definition: IPTools.cc:38
edm::SortedCollection::push_back
void push_back(T const &t)
Definition: SortedCollection.h:188
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
pat::PATElectronProducer::hcalPFClusterIsoT_
const edm::EDGetTokenT< edm::ValueMap< float > > hcalPFClusterIsoT_
Definition: PATElectronProducer.cc:123
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:129
reco::PFCandidateConstIterator
PFCandidateCollection::const_iterator PFCandidateConstIterator
iterator
Definition: PFCandidateFwd.h:18
pat::PATElectronProducer::elecIDTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< float > > > elecIDTokens_
Definition: PATElectronProducer.cc:179
electrons_cff.ip3d
ip3d
Definition: electrons_cff.py:306
pat::PATElectronProducer::ecalTopologyToken_
const edm::ESGetToken< CaloTopology, CaloTopologyRecord > ecalTopologyToken_
Definition: PATElectronProducer.cc:210
pat::PATElectronProducer::electronToken_
const edm::EDGetTokenT< edm::View< reco::GsfElectron > > electronToken_
Definition: PATElectronProducer.cc:79
pat::PATElectronProducer::addMVAVariables_
const bool addMVAVariables_
mva input variables
Definition: PATElectronProducer.cc:113
packedPFCandidateRefMixer_cfi.pf
pf
Definition: packedPFCandidateRefMixer_cfi.py:4
pat::helper::MultiIsolator::fill
void fill(const edm::View< T > &coll, int idx, IsolationValuePairs &isolations) const
Definition: MultiIsolator.h:84
TransientTrackBuilder::build
reco::TransientTrack build(const reco::Track *p) const
Definition: TransientTrackBuilder.cc:20
pat::PATElectronProducer::pvToken_
const edm::EDGetTokenT< std::vector< reco::Vertex > > pvToken_
Definition: PATElectronProducer.cc:128
pat::PATElectronProducer::pfCandidateMapToken_
const edm::EDGetTokenT< edm::ValueMap< reco::PFCandidatePtr > > pfCandidateMapToken_
Definition: PATElectronProducer.cc:108
EcalClusterLazyToolsBase::ESGetTokens::get
ESData get(edm::EventSetup const &eventSetup) const
Definition: EcalClusterLazyTools.h:64
pat::PATElectronProducer::isolator_
pat::helper::MultiIsolator isolator_
Definition: PATElectronProducer.cc:184
pat::PATElectronProducer::GenAssociations
std::vector< edm::Handle< edm::Association< reco::GenParticleCollection > > > GenAssociations
Definition: PATElectronProducer.cc:100
pat::PATElectronProducer::PUPPIIsolation_photons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_photons_
Definition: PATElectronProducer.cc:203
iEvent
int iEvent
Definition: GenABIO.cc:224
tt
Definition: TTTypes.h:54
pat::helper::MultiIsolator::beginEvent
void beginEvent(const edm::Event &event, const edm::EventSetup &eventSetup)
Definition: MultiIsolator.cc:79
pat::PATElectronProducer::embedHighLevelSelection_
const bool embedHighLevelSelection_
embed high level selection variables?
Definition: PATElectronProducer.cc:126
patElectronEAIsoCorrectionProducer_cfi.patElectrons
patElectrons
Definition: patElectronEAIsoCorrectionProducer_cfi.py:4
pat::helper::KinResolutionsLoader::newEvent
void newEvent(const edm::Event &event, const edm::EventSetup &setup)
To be called for each new event, reads in the EventSetup object.
Definition: KinResolutionsLoader.cc:27
pat::PATElectronProducer::genMatchTokens_
std::vector< edm::EDGetTokenT< edm::Association< reco::GenParticleCollection > > > genMatchTokens_
Definition: PATElectronProducer.cc:102
ConversionTools::hasMatchedConversion
static bool hasMatchedConversion(const reco::GsfElectron &ele, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, bool allowCkfMatch=true, float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=0)
Definition: ConversionTools.cc:181
tier0.unique
def unique(seq, keepstr=True)
Definition: tier0.py:24
pat::helper::KinResolutionsLoader::enabled
bool enabled() const
&#39;true&#39; if this there is at least one efficiency configured
Definition: KinResolutionsLoader.h:30
CandIsolatorFromDeposits_cfi.deposits
deposits
Definition: CandIsolatorFromDeposits_cfi.py:4
pat::PATElectronProducer::IsoDepositMaps
std::vector< edm::Handle< edm::ValueMap< IsoDeposit > > > IsoDepositMaps
Definition: PATElectronProducer.cc:131
pat::PATElectronProducer::isoDepositTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > > isoDepositTokens_
Definition: PATElectronProducer.cc:187
pat::PATElectronProducer::PUPPINoLeptonsIsolation_neutral_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_neutral_hadrons_
Definition: PATElectronProducer.cc:206
pat::PATElectronProducer::ecalClusterToolsESGetTokens_
const EcalClusterLazyTools::ESGetTokens ecalClusterToolsESGetTokens_
Definition: PATElectronProducer.cc:118
pat::PATElectronProducer::reducedEndcapRecHitCollectionToken_
const edm::EDGetTokenT< EcalRecHitCollection > reducedEndcapRecHitCollectionToken_
Definition: PATElectronProducer.cc:117
CaloSubdetectorTopology::getWindow
virtual std::vector< DetId > getWindow(const DetId &id, const int &northSouthSize, const int &eastWestSize) const
Definition: CaloSubdetectorTopology.cc:4
reco::TrackBase::Point
math::XYZPoint Point
point in the space
Definition: TrackBase.h:80
edm::EventSetup::getHandle
ESHandle< T > getHandle(const ESGetToken< T, R > &iToken) const
Definition: EventSetup.h:130
pat::PATElectronProducer::PUPPINoLeptonsIsolation_photons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_photons_
Definition: PATElectronProducer.cc:207
electronIdMVAProducer_cfi.reducedEERecHitCollection
reducedEERecHitCollection
Definition: electronIdMVAProducer_cfi.py:8
pat::PATElectronProducer::IsolationValueMaps
std::vector< edm::Handle< edm::ValueMap< double > > > IsolationValueMaps
Definition: PATElectronProducer.cc:132
pat::PATUserDataHelper::add
void add(ObjectType &patObject, edm::Event const &iEvent, edm::EventSetup const &iSetup)
Definition: PATUserDataHelper.h:113
DetId
Definition: DetId.h:17
pat::helper::MultiIsolator::IsolationValuePairs
std::vector< std::pair< pat::IsolationKeys, float > > IsolationValuePairs
Definition: MultiIsolator.h:17
pat::PATElectronProducer::beamLineToken_
const edm::EDGetTokenT< reco::BeamSpot > beamLineToken_
Definition: PATElectronProducer.cc:127
pat::PATElectronProducer::isolationValueNoPFIdTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< double > > > isolationValueNoPFIdTokens_
Definition: PATElectronProducer.cc:191
CaloTopology::getSubdetectorTopology
const CaloSubdetectorTopology * getSubdetectorTopology(const DetId &id) const
access the subdetector Topology for the given subdetector directly
Definition: CaloTopology.cc:17
pat::PATElectronProducer::efficiencyLoader_
pat::helper::EfficiencyLoader efficiencyLoader_
Definition: PATElectronProducer.cc:194
pat::PATElectronProducer::reducedBarrelRecHitCollectionToken_
const edm::EDGetTokenT< EcalRecHitCollection > reducedBarrelRecHitCollectionToken_
Definition: PATElectronProducer.cc:115
pat::PATElectronProducer::trackBuilderToken_
const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord > trackBuilderToken_
Definition: PATElectronProducer.cc:211
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
pat::PATElectronProducer::pfCandidateMultiMapToken_
const edm::EDGetTokenT< edm::ValueMap< std::vector< reco::PFCandidateRef > > > pfCandidateMultiMapToken_
Definition: PATElectronProducer.cc:109
pat::PATElectronProducer::userDataHelper_
pat::PATUserDataHelper< pat::Electron > userDataHelper_
Definition: PATElectronProducer.cc:208
pat::PATElectronProducer::fillElectron2
void fillElectron2(Electron &anElectron, const reco::CandidatePtr &candPtrForIsolation, const reco::CandidatePtr &candPtrForGenMatch, const reco::CandidatePtr &candPtrForLoader, const GenAssociations &genMatches, const IsoDepositMaps &deposits, const IsolationValueMaps &isolationValues) const
Definition: PATElectronProducer.cc:1120
pat::PATElectronProducer::ecalTopology_
const CaloTopology * ecalTopology_
Definition: PATElectronProducer.cc:213
nano_mu_local_reco_cff.bool
bool
Definition: nano_mu_local_reco_cff.py:13
pat::PATElectronProducer::setElectronMiniIso
void setElectronMiniIso(pat::Electron &anElectron, const pat::PackedCandidateCollection *pc)
Definition: PATElectronProducer.cc:1199
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
electronIdMVAProducer_cfi.reducedEBRecHitCollection
reducedEBRecHitCollection
Definition: electronIdMVAProducer_cfi.py:7
pat::PATElectronProducer::resolutionLoader_
pat::helper::KinResolutionsLoader resolutionLoader_
Definition: PATElectronProducer.cc:197
electronIsolatorFromEffectiveArea_cfi.pfElectrons
pfElectrons
Definition: electronIsolatorFromEffectiveArea_cfi.py:5
pat::PATElectronProducer::isolationValueTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< double > > > isolationValueTokens_
Definition: PATElectronProducer.cc:189
Reference_intrackfit_cff.barrel
list barrel
Definition: Reference_intrackfit_cff.py:37
pat::PATElectronProducer::isolatorTmpStorage_
pat::helper::MultiIsolator::IsolationValuePairs isolatorTmpStorage_
Definition: PATElectronProducer.cc:185
BeamMonitor_cff.primaryVertex
primaryVertex
hltOfflineBeamSpot for HLTMON
Definition: BeamMonitor_cff.py:7
pat::PATElectronProducer::pcToken_
edm::EDGetTokenT< pat::PackedCandidateCollection > pcToken_
Definition: PATElectronProducer.cc:95
eostools.move
def move(src, dest)
Definition: eostools.py:511
pat::PATElectronProducer::fillElectron
void fillElectron(Electron &aElectron, const ElectronBaseRef &electronRef, const reco::CandidateBaseRef &baseRef, const GenAssociations &genMatches, const IsoDepositMaps &deposits, const bool pfId, const IsolationValueMaps &isolationValues, const IsolationValueMaps &isolationValuesNoPFId) const
common electron filling, for both the standard and PF2PAT case
Definition: PATElectronProducer.cc:1024
electronProducer_cff.isolationValuesNoPFId
isolationValuesNoPFId
Definition: electronProducer_cff.py:34
HLT_2023v12_cff.track
track
Definition: HLT_2023v12_cff.py:9604
pat::PATElectronProducer::elecIDSrcs_
std::vector< NameTag > elecIDSrcs_
Definition: PATElectronProducer.cc:178
displacedMuonProducer_cff.isolationValues
isolationValues
Definition: displacedMuonProducer_cff.py:86

◆ readIsolationLabels()

template<typename T >
void pat::PATElectronProducer::readIsolationLabels ( const edm::ParameterSet &  iConfig,
const char *  psetName,
IsolationLabels &  labels,
std::vector< edm::EDGetTokenT< edm::ValueMap< T >>> &  tokens 
)
private

fill the labels vector from the contents of the parameter set, for the isodeposit or isolation values embedding

Definition at line 218 of file PATElectronProducer.cc.

References pat::EcalIso, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), pat::HcalIso, crabWrapper::key, label, SummaryClient_cfi::labels, pat::PfAllParticleIso, pat::PfChargedAllIso, pat::PfChargedHadronIso, pat::PfGammaIso, pat::PfNeutralHadronIso, pat::PfPUChargedHadronIso, crabTemplate::psetName, pat::TrackIso, pat::UserBaseIso, and edm::vector_transform().

221  {
222  labels.clear();
223 
224  if (iConfig.exists(psetName)) {
225  edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>(psetName);
226 
227  if (depconf.exists("tracker"))
228  labels.push_back(std::make_pair(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker")));
229  if (depconf.exists("ecal"))
230  labels.push_back(std::make_pair(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal")));
231  if (depconf.exists("hcal"))
232  labels.push_back(std::make_pair(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal")));
233  if (depconf.exists("pfAllParticles")) {
234  labels.push_back(std::make_pair(pat::PfAllParticleIso, depconf.getParameter<edm::InputTag>("pfAllParticles")));
235  }
236  if (depconf.exists("pfChargedHadrons")) {
237  labels.push_back(
238  std::make_pair(pat::PfChargedHadronIso, depconf.getParameter<edm::InputTag>("pfChargedHadrons")));
239  }
240  if (depconf.exists("pfChargedAll")) {
241  labels.push_back(std::make_pair(pat::PfChargedAllIso, depconf.getParameter<edm::InputTag>("pfChargedAll")));
242  }
243  if (depconf.exists("pfPUChargedHadrons")) {
244  labels.push_back(
245  std::make_pair(pat::PfPUChargedHadronIso, depconf.getParameter<edm::InputTag>("pfPUChargedHadrons")));
246  }
247  if (depconf.exists("pfNeutralHadrons")) {
248  labels.push_back(
249  std::make_pair(pat::PfNeutralHadronIso, depconf.getParameter<edm::InputTag>("pfNeutralHadrons")));
250  }
251  if (depconf.exists("pfPhotons")) {
252  labels.push_back(std::make_pair(pat::PfGammaIso, depconf.getParameter<edm::InputTag>("pfPhotons")));
253  }
254  if (depconf.exists("user")) {
255  std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag>>("user");
256  std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
257  int key = pat::IsolationKeys::UserBaseIso;
258  for (; it != ed; ++it, ++key) {
259  labels.push_back(std::make_pair(pat::IsolationKeys(key), *it));
260  }
261  }
262  }
263  tokens = edm::vector_transform(
264  labels, [this](IsolationLabel const& label) { return consumes<edm::ValueMap<T>>(label.second); });
265 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
pat::PATElectronProducer::IsolationLabel
std::pair< pat::IsolationKeys, edm::InputTag > IsolationLabel
Definition: PATElectronProducer.cc:165
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:681
pat::IsolationKeys
IsolationKeys
Enum defining isolation keys.
Definition: Isolation.h:9
edm::vector_transform
auto vector_transform(std::vector< InputType > const &input, Function predicate) -> std::vector< typename std::remove_cv< typename std::remove_reference< decltype(predicate(input.front()))>::type >::type >
Definition: transform.h:11
label
char const * label
Definition: PFTauDecayModeTools.cc:11
SummaryClient_cfi.labels
labels
Definition: SummaryClient_cfi.py:61

◆ setElectronMiniIso()

void PATElectronProducer::setElectronMiniIso ( pat::Electron &  anElectron,
const pat::PackedCandidateCollection *  pc 
)
private

Definition at line 1199 of file PATElectronProducer.cc.

References pat::getMiniPFIsolation(), reco::GsfElectron::isEE(), miniIsoParamsB_, miniIsoParamsE_, reco::LeafCandidate::polarP4(), and pat::Lepton< LeptonType >::setMiniPFIsolation().

Referenced by produce().

1199  {
1200  pat::PFIsolation miniiso;
1201  if (anElectron.isEE())
1202  miniiso = pat::getMiniPFIsolation(pc,
1203  anElectron.polarP4(),
1204  miniIsoParamsE_[0],
1205  miniIsoParamsE_[1],
1206  miniIsoParamsE_[2],
1207  miniIsoParamsE_[3],
1208  miniIsoParamsE_[4],
1209  miniIsoParamsE_[5],
1210  miniIsoParamsE_[6],
1211  miniIsoParamsE_[7],
1212  miniIsoParamsE_[8]);
1213  else
1214  miniiso = pat::getMiniPFIsolation(pc,
1215  anElectron.polarP4(),
1216  miniIsoParamsB_[0],
1217  miniIsoParamsB_[1],
1218  miniIsoParamsB_[2],
1219  miniIsoParamsB_[3],
1220  miniIsoParamsB_[4],
1221  miniIsoParamsB_[5],
1222  miniIsoParamsB_[6],
1223  miniIsoParamsB_[7],
1224  miniIsoParamsB_[8]);
1225  anElectron.setMiniPFIsolation(miniiso);
1226 }
pat::PATElectronProducer::miniIsoParamsE_
std::vector< double > miniIsoParamsE_
Definition: PATElectronProducer.cc:97
pat::PATElectronProducer::miniIsoParamsB_
std::vector< double > miniIsoParamsB_
Definition: PATElectronProducer.cc:98
reco::LeafCandidate::polarP4
const PolarLorentzVector & polarP4() const final
four-momentum Lorentz vector
Definition: LeafCandidate.h:116
reco::GsfElectron::isEE
bool isEE() const
Definition: GsfElectron.h:329
pat::Lepton::setMiniPFIsolation
void setMiniPFIsolation(PFIsolation const &iso)
Definition: Lepton.h:217
pat::getMiniPFIsolation
PFIsolation getMiniPFIsolation(const pat::PackedCandidateCollection *pfcands, const reco::Candidate::PolarLorentzVector &p4, float mindr=0.05, float maxdr=0.2, float kt_scale=10.0, float ptthresh=0.5, float deadcone_ch=0.0001, float deadcone_pu=0.01, float deadcone_ph=0.01, float deadcone_nh=0.01, float dZ_cut=0.0)
Definition: MiniIsolation.cc:19

Member Data Documentation

◆ addEfficiencies_

const bool pat::PATElectronProducer::addEfficiencies_
private

Definition at line 193 of file PATElectronProducer.cc.

◆ addElecID_

const bool pat::PATElectronProducer::addElecID_
private

Definition at line 176 of file PATElectronProducer.cc.

Referenced by produce().

◆ addGenMatch_

bool pat::PATElectronProducer::addGenMatch_
private

Definition at line 91 of file PATElectronProducer.cc.

Referenced by fillElectron(), fillElectron2(), and produce().

◆ addMVAVariables_

const bool pat::PATElectronProducer::addMVAVariables_
private

mva input variables

Definition at line 113 of file PATElectronProducer.cc.

Referenced by produce().

◆ addPFClusterIso_

const bool pat::PATElectronProducer::addPFClusterIso_
private

Definition at line 120 of file PATElectronProducer.cc.

Referenced by produce().

◆ addPuppiIsolation_

const bool pat::PATElectronProducer::addPuppiIsolation_
private

Definition at line 121 of file PATElectronProducer.cc.

Referenced by produce().

◆ addResolutions_

const bool pat::PATElectronProducer::addResolutions_
private

Definition at line 196 of file PATElectronProducer.cc.

◆ beamLineToken_

const edm::EDGetTokenT<reco::BeamSpot> pat::PATElectronProducer::beamLineToken_
private

Definition at line 127 of file PATElectronProducer.cc.

Referenced by produce().

◆ computeMiniIso_

bool pat::PATElectronProducer::computeMiniIso_
private

Definition at line 96 of file PATElectronProducer.cc.

Referenced by produce().

◆ ecalClusterToolsESGetTokens_

const EcalClusterLazyTools::ESGetTokens pat::PATElectronProducer::ecalClusterToolsESGetTokens_
private

Definition at line 118 of file PATElectronProducer.cc.

Referenced by produce().

◆ ecalPFClusterIsoT_

const edm::EDGetTokenT<edm::ValueMap<float> > pat::PATElectronProducer::ecalPFClusterIsoT_
private

Definition at line 122 of file PATElectronProducer.cc.

Referenced by produce().

◆ ecalTopology_

const CaloTopology* pat::PATElectronProducer::ecalTopology_
private

Definition at line 213 of file PATElectronProducer.cc.

Referenced by produce().

◆ ecalTopologyToken_

const edm::ESGetToken<CaloTopology, CaloTopologyRecord> pat::PATElectronProducer::ecalTopologyToken_
private

Definition at line 210 of file PATElectronProducer.cc.

Referenced by produce().

◆ efficiencyLoader_

pat::helper::EfficiencyLoader pat::PATElectronProducer::efficiencyLoader_
private

Definition at line 194 of file PATElectronProducer.cc.

Referenced by fillElectron(), fillElectron2(), and produce().

◆ elecIDSrcs_

std::vector<NameTag> pat::PATElectronProducer::elecIDSrcs_
private

Definition at line 178 of file PATElectronProducer.cc.

Referenced by produce().

◆ elecIDTokens_

std::vector<edm::EDGetTokenT<edm::ValueMap<float> > > pat::PATElectronProducer::elecIDTokens_
private

Definition at line 179 of file PATElectronProducer.cc.

Referenced by produce().

◆ electronToken_

const edm::EDGetTokenT<edm::View<reco::GsfElectron> > pat::PATElectronProducer::electronToken_
private

Definition at line 79 of file PATElectronProducer.cc.

Referenced by produce().

◆ embedBasicClusters_

const bool pat::PATElectronProducer::embedBasicClusters_
private

Definition at line 86 of file PATElectronProducer.cc.

Referenced by fillElectron(), fillElectron2(), and produce().

◆ embedGenMatch_

bool pat::PATElectronProducer::embedGenMatch_
private

Definition at line 92 of file PATElectronProducer.cc.

Referenced by fillElectron(), fillElectron2(), and produce().

◆ embedGsfElectronCore_

const bool pat::PATElectronProducer::embedGsfElectronCore_
private

Definition at line 81 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedGsfTrack_

const bool pat::PATElectronProducer::embedGsfTrack_
private

Definition at line 82 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedHighLevelSelection_

const bool pat::PATElectronProducer::embedHighLevelSelection_
private

embed high level selection variables?

Definition at line 126 of file PATElectronProducer.cc.

Referenced by produce().

◆ embedPFCandidate_

const bool pat::PATElectronProducer::embedPFCandidate_
private

Definition at line 110 of file PATElectronProducer.cc.

Referenced by produce().

◆ embedPflowBasicClusters_

const bool pat::PATElectronProducer::embedPflowBasicClusters_
private

Definition at line 88 of file PATElectronProducer.cc.

Referenced by fillElectron(), fillElectron2(), and produce().

◆ embedPflowPreshowerClusters_

const bool pat::PATElectronProducer::embedPflowPreshowerClusters_
private

Definition at line 89 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedPflowSuperCluster_

const bool pat::PATElectronProducer::embedPflowSuperCluster_
private

Definition at line 84 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedPreshowerClusters_

const bool pat::PATElectronProducer::embedPreshowerClusters_
private

Definition at line 87 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedRecHits_

const bool pat::PATElectronProducer::embedRecHits_
private

Definition at line 93 of file PATElectronProducer.cc.

Referenced by produce().

◆ embedSeedCluster_

const bool pat::PATElectronProducer::embedSeedCluster_
private

Definition at line 85 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedSuperCluster_

const bool pat::PATElectronProducer::embedSuperCluster_
private

Definition at line 83 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedTrack_

const bool pat::PATElectronProducer::embedTrack_
private

Definition at line 90 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ genMatchTokens_

std::vector<edm::EDGetTokenT<edm::Association<reco::GenParticleCollection> > > pat::PATElectronProducer::genMatchTokens_
private

Definition at line 102 of file PATElectronProducer.cc.

Referenced by produce().

◆ hcalPFClusterIsoT_

const edm::EDGetTokenT<edm::ValueMap<float> > pat::PATElectronProducer::hcalPFClusterIsoT_
private

Definition at line 123 of file PATElectronProducer.cc.

Referenced by produce().

◆ hConversionsToken_

const edm::EDGetTokenT<reco::ConversionCollection> pat::PATElectronProducer::hConversionsToken_
private

Definition at line 80 of file PATElectronProducer.cc.

Referenced by produce().

◆ isoDepositLabels_

IsolationLabels pat::PATElectronProducer::isoDepositLabels_
private

Definition at line 186 of file PATElectronProducer.cc.

Referenced by fillElectron(), fillElectron2(), and produce().

◆ isoDepositTokens_

std::vector<edm::EDGetTokenT<edm::ValueMap<IsoDeposit> > > pat::PATElectronProducer::isoDepositTokens_
private

Definition at line 187 of file PATElectronProducer.cc.

Referenced by produce().

◆ isolationValueLabels_

IsolationLabels pat::PATElectronProducer::isolationValueLabels_
private

Definition at line 188 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ isolationValueLabelsNoPFId_

IsolationLabels pat::PATElectronProducer::isolationValueLabelsNoPFId_
private

Definition at line 190 of file PATElectronProducer.cc.

Referenced by fillElectron().

◆ isolationValueNoPFIdTokens_

std::vector<edm::EDGetTokenT<edm::ValueMap<double> > > pat::PATElectronProducer::isolationValueNoPFIdTokens_
private

Definition at line 191 of file PATElectronProducer.cc.

Referenced by produce().

◆ isolationValueTokens_

std::vector<edm::EDGetTokenT<edm::ValueMap<double> > > pat::PATElectronProducer::isolationValueTokens_
private

Definition at line 189 of file PATElectronProducer.cc.

Referenced by produce().

◆ isolator_

pat::helper::MultiIsolator pat::PATElectronProducer::isolator_
private

Definition at line 184 of file PATElectronProducer.cc.

Referenced by produce().

◆ isolatorTmpStorage_

pat::helper::MultiIsolator::IsolationValuePairs pat::PATElectronProducer::isolatorTmpStorage_
private

Definition at line 185 of file PATElectronProducer.cc.

Referenced by produce().

◆ miniIsoParamsB_

std::vector<double> pat::PATElectronProducer::miniIsoParamsB_
private

Definition at line 98 of file PATElectronProducer.cc.

Referenced by setElectronMiniIso().

◆ miniIsoParamsE_

std::vector<double> pat::PATElectronProducer::miniIsoParamsE_
private

Definition at line 97 of file PATElectronProducer.cc.

Referenced by setElectronMiniIso().

◆ pcToken_

edm::EDGetTokenT<pat::PackedCandidateCollection> pat::PATElectronProducer::pcToken_
private

Definition at line 95 of file PATElectronProducer.cc.

Referenced by produce().

◆ pfCandidateMapToken_

const edm::EDGetTokenT<edm::ValueMap<reco::PFCandidatePtr> > pat::PATElectronProducer::pfCandidateMapToken_
private

Definition at line 108 of file PATElectronProducer.cc.

Referenced by produce().

◆ pfCandidateMultiMapToken_

const edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef> > > pat::PATElectronProducer::pfCandidateMultiMapToken_
private

Definition at line 109 of file PATElectronProducer.cc.

Referenced by produce().

◆ pfElecToken_

const edm::EDGetTokenT<reco::PFCandidateCollection> pat::PATElectronProducer::pfElecToken_
private

Definition at line 107 of file PATElectronProducer.cc.

Referenced by produce().

◆ pTComparator_

const GreaterByPt<Electron> pat::PATElectronProducer::pTComparator_
private

Definition at line 182 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPIIsolation_charged_hadrons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATElectronProducer::PUPPIIsolation_charged_hadrons_
private

Definition at line 201 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPIIsolation_neutral_hadrons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATElectronProducer::PUPPIIsolation_neutral_hadrons_
private

Definition at line 202 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPIIsolation_photons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATElectronProducer::PUPPIIsolation_photons_
private

Definition at line 203 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPINoLeptonsIsolation_charged_hadrons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATElectronProducer::PUPPINoLeptonsIsolation_charged_hadrons_
private

Definition at line 205 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPINoLeptonsIsolation_neutral_hadrons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATElectronProducer::PUPPINoLeptonsIsolation_neutral_hadrons_
private

Definition at line 206 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPINoLeptonsIsolation_photons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATElectronProducer::PUPPINoLeptonsIsolation_photons_
private

Definition at line 207 of file PATElectronProducer.cc.

Referenced by produce().

◆ pvToken_

const edm::EDGetTokenT<std::vector<reco::Vertex> > pat::PATElectronProducer::pvToken_
private

Definition at line 128 of file PATElectronProducer.cc.

Referenced by produce().

◆ reducedBarrelRecHitCollection_

const edm::InputTag pat::PATElectronProducer::reducedBarrelRecHitCollection_
private

Definition at line 114 of file PATElectronProducer.cc.

◆ reducedBarrelRecHitCollectionToken_

const edm::EDGetTokenT<EcalRecHitCollection> pat::PATElectronProducer::reducedBarrelRecHitCollectionToken_
private

Definition at line 115 of file PATElectronProducer.cc.

Referenced by produce().

◆ reducedEndcapRecHitCollection_

const edm::InputTag pat::PATElectronProducer::reducedEndcapRecHitCollection_
private

Definition at line 116 of file PATElectronProducer.cc.

◆ reducedEndcapRecHitCollectionToken_

const edm::EDGetTokenT<EcalRecHitCollection> pat::PATElectronProducer::reducedEndcapRecHitCollectionToken_
private

Definition at line 117 of file PATElectronProducer.cc.

Referenced by produce().

◆ resolutionLoader_

pat::helper::KinResolutionsLoader pat::PATElectronProducer::resolutionLoader_
private

Definition at line 197 of file PATElectronProducer.cc.

Referenced by fillElectron(), fillElectron2(), and produce().

◆ trackBuilderToken_

const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> pat::PATElectronProducer::trackBuilderToken_
private

Definition at line 211 of file PATElectronProducer.cc.

Referenced by produce().

◆ useParticleFlow_

const bool pat::PATElectronProducer::useParticleFlow_
private

pflow specific

Definition at line 105 of file PATElectronProducer.cc.

Referenced by fillElectron(), and produce().

◆ usePfCandidateMultiMap_

const bool pat::PATElectronProducer::usePfCandidateMultiMap_
private

Definition at line 106 of file PATElectronProducer.cc.

Referenced by produce().

◆ userDataHelper_

pat::PATUserDataHelper<pat::Electron> pat::PATElectronProducer::userDataHelper_
private

Definition at line 208 of file PATElectronProducer.cc.

Referenced by produce().

◆ useUserData_

const bool pat::PATElectronProducer::useUserData_
private

Definition at line 199 of file PATElectronProducer.cc.

Referenced by produce().

Generated for CMSSW Reference Manual by doxygen 1.8.14