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...

#include "PhysicsTools/PatAlgos/interface/PATElectronProducer.h"

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
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

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 edm::EDGetTokenT< edm::ValueMap< float > > ecalPFClusterIsoT_
 
const CaloTopology * ecalTopology_
 
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 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<>
typedef CacheContexts< T... > CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T... > HasAbility
 
typedef CacheTypes::LuminosityBlockCache LuminosityBlockCache
 
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache > LuminosityBlockContext
 
typedef CacheTypes::LuminosityBlockSummaryCache LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache, GlobalCache > RunContext
 
typedef CacheTypes::RunSummaryCache RunSummaryCache
 

Detailed Description

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 50 of file PATElectronProducer.h.

Member Typedef Documentation

◆ ElectronBaseRef

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

Definition at line 111 of file PATElectronProducer.h.

◆ GenAssociations

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

Definition at line 82 of file PATElectronProducer.h.

◆ IsoDepositMaps

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

Definition at line 112 of file PATElectronProducer.h.

◆ IsolationLabel

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

Definition at line 146 of file PATElectronProducer.h.

◆ IsolationLabels

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

Definition at line 147 of file PATElectronProducer.h.

◆ IsolationValueMaps

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

Definition at line 113 of file PATElectronProducer.h.

◆ NameTag

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

Definition at line 158 of file PATElectronProducer.h.

Constructor & Destructor Documentation

◆ PATElectronProducer()

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

Definition at line 52 of file PATElectronProducer.cc.

53  : // general configurables
54  electronToken_(consumes<edm::View<reco::GsfElectron>>(iConfig.getParameter<edm::InputTag>("electronSource"))),
55  hConversionsToken_(consumes<reco::ConversionCollection>(edm::InputTag("allConversions"))),
56  embedGsfElectronCore_(iConfig.getParameter<bool>("embedGsfElectronCore")),
57  embedGsfTrack_(iConfig.getParameter<bool>("embedGsfTrack")),
58  embedSuperCluster_(iConfig.getParameter<bool>("embedSuperCluster")),
59  embedPflowSuperCluster_(iConfig.getParameter<bool>("embedPflowSuperCluster")),
60  embedSeedCluster_(iConfig.getParameter<bool>("embedSeedCluster")),
61  embedBasicClusters_(iConfig.getParameter<bool>("embedBasicClusters")),
62  embedPreshowerClusters_(iConfig.getParameter<bool>("embedPreshowerClusters")),
63  embedPflowBasicClusters_(iConfig.getParameter<bool>("embedPflowBasicClusters")),
64  embedPflowPreshowerClusters_(iConfig.getParameter<bool>("embedPflowPreshowerClusters")),
65  embedTrack_(iConfig.getParameter<bool>("embedTrack")),
66  addGenMatch_(iConfig.getParameter<bool>("addGenMatch")),
67  embedGenMatch_(addGenMatch_ ? iConfig.getParameter<bool>("embedGenMatch") : false),
68  embedRecHits_(iConfig.getParameter<bool>("embedRecHits")),
69  // pflow configurables
70  useParticleFlow_(iConfig.getParameter<bool>("useParticleFlow")),
71  usePfCandidateMultiMap_(iConfig.getParameter<bool>("usePfCandidateMultiMap")),
72  pfElecToken_(!usePfCandidateMultiMap_
73  ? consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfElectronSource"))
74  : edm::EDGetTokenT<reco::PFCandidateCollection>()),
75  pfCandidateMapToken_(!usePfCandidateMultiMap_ ? mayConsume<edm::ValueMap<reco::PFCandidatePtr>>(
76  iConfig.getParameter<edm::InputTag>("pfCandidateMap"))
77  : edm::EDGetTokenT<edm::ValueMap<reco::PFCandidatePtr>>()),
78  pfCandidateMultiMapToken_(usePfCandidateMultiMap_
79  ? consumes<edm::ValueMap<std::vector<reco::PFCandidateRef>>>(
80  iConfig.getParameter<edm::InputTag>("pfCandidateMultiMap"))
81  : edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef>>>()),
82  embedPFCandidate_(iConfig.getParameter<bool>("embedPFCandidate")),
83  // mva input variables
84  addMVAVariables_(iConfig.getParameter<bool>("addMVAVariables")),
85  reducedBarrelRecHitCollection_(iConfig.getParameter<edm::InputTag>("reducedBarrelRecHitCollection")),
86  reducedBarrelRecHitCollectionToken_(mayConsume<EcalRecHitCollection>(reducedBarrelRecHitCollection_)),
87  reducedEndcapRecHitCollection_(iConfig.getParameter<edm::InputTag>("reducedEndcapRecHitCollection")),
88  reducedEndcapRecHitCollectionToken_(mayConsume<EcalRecHitCollection>(reducedEndcapRecHitCollection_)),
89  // PFCluster Isolation maps
90  addPFClusterIso_(iConfig.getParameter<bool>("addPFClusterIso")),
91  addPuppiIsolation_(iConfig.getParameter<bool>("addPuppiIsolation")),
92  ecalPFClusterIsoT_(consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("ecalPFClusterIsoMap"))),
93  hcalPFClusterIsoT_(consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("hcalPFClusterIsoMap"))),
94  // embed high level selection variables?
95  embedHighLevelSelection_(iConfig.getParameter<bool>("embedHighLevelSelection")),
96  beamLineToken_(consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamLineSrc"))),
97  pvToken_(mayConsume<std::vector<reco::Vertex>>(iConfig.getParameter<edm::InputTag>("pvSrc"))),
98  addElecID_(iConfig.getParameter<bool>("addElectronID")),
99  pTComparator_(),
100  isolator_(iConfig.exists("userIsolation") ? iConfig.getParameter<edm::ParameterSet>("userIsolation")
101  : edm::ParameterSet(),
102  consumesCollector(),
103  false),
104  addEfficiencies_(iConfig.getParameter<bool>("addEfficiencies")),
105  addResolutions_(iConfig.getParameter<bool>("addResolutions")),
106  useUserData_(iConfig.exists("userData"))
107 
108 {
109  // MC matching configurables (scheduled mode)
110 
111  if (addGenMatch_) {
112  if (iConfig.existsAs<edm::InputTag>("genParticleMatch")) {
113  genMatchTokens_.push_back(consumes<edm::Association<reco::GenParticleCollection>>(
114  iConfig.getParameter<edm::InputTag>("genParticleMatch")));
115  } else {
116  genMatchTokens_ = edm::vector_transform(
117  iConfig.getParameter<std::vector<edm::InputTag>>("genParticleMatch"),
118  [this](edm::InputTag const& tag) { return consumes<edm::Association<reco::GenParticleCollection>>(tag); });
119  }
120  }
121  // resolution configurables
122  if (addResolutions_) {
123  resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
124  }
125  if (addPuppiIsolation_) {
126  //puppi
127  PUPPIIsolation_charged_hadrons_ =
128  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationChargedHadrons"));
129  PUPPIIsolation_neutral_hadrons_ =
130  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationNeutralHadrons"));
131  PUPPIIsolation_photons_ =
132  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationPhotons"));
133  //puppiNoLeptons
134  PUPPINoLeptonsIsolation_charged_hadrons_ =
135  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationChargedHadrons"));
136  PUPPINoLeptonsIsolation_neutral_hadrons_ =
137  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationNeutralHadrons"));
138  PUPPINoLeptonsIsolation_photons_ =
139  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationPhotons"));
140  }
141  // electron ID configurables
142  if (addElecID_) {
143  // it might be a single electron ID
144  if (iConfig.existsAs<edm::InputTag>("electronIDSource")) {
145  elecIDSrcs_.push_back(NameTag("", iConfig.getParameter<edm::InputTag>("electronIDSource")));
146  }
147  // or there might be many of them
148  if (iConfig.existsAs<edm::ParameterSet>("electronIDSources")) {
149  // please don't configure me twice
150  if (!elecIDSrcs_.empty()) {
151  throw cms::Exception("Configuration")
152  << "PATElectronProducer: you can't specify both 'electronIDSource' and 'electronIDSources'\n";
153  }
154  // read the different electron ID names
155  edm::ParameterSet idps = iConfig.getParameter<edm::ParameterSet>("electronIDSources");
156  std::vector<std::string> names = idps.getParameterNamesForType<edm::InputTag>();
157  for (std::vector<std::string>::const_iterator it = names.begin(), ed = names.end(); it != ed; ++it) {
158  elecIDSrcs_.push_back(NameTag(*it, idps.getParameter<edm::InputTag>(*it)));
159  }
160  }
161  // but in any case at least once
162  if (elecIDSrcs_.empty()) {
163  throw cms::Exception("Configuration")
164  << "PATElectronProducer: id addElectronID is true, you must specify either:\n"
165  << "\tInputTag electronIDSource = <someTag>\n"
166  << "or\n"
167  << "\tPSet electronIDSources = { \n"
168  << "\t\tInputTag <someName> = <someTag> // as many as you want \n "
169  << "\t}\n";
170  }
171  }
172  elecIDTokens_ = edm::vector_transform(
173  elecIDSrcs_, [this](NameTag const& tag) { return mayConsume<edm::ValueMap<float>>(tag.second); });
174  // construct resolution calculator
175 
176  // // IsoDeposit configurables
177  // if (iConfig.exists("isoDeposits")) {
178  // edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>("isoDeposits");
179  // if (depconf.exists("tracker")) isoDepositLabels_.push_back(std::make_pair(TrackerIso, depconf.getParameter<edm::InputTag>("tracker")));
180  // if (depconf.exists("ecal")) isoDepositLabels_.push_back(std::make_pair(ECalIso, depconf.getParameter<edm::InputTag>("ecal")));
181  // if (depconf.exists("hcal")) isoDepositLabels_.push_back(std::make_pair(HCalIso, depconf.getParameter<edm::InputTag>("hcal")));
182 
183  // if (depconf.exists("user")) {
184  // std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
185  // std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
186  // int key = UserBaseIso;
187  // for ( ; it != ed; ++it, ++key) {
188  // isoDepositLabels_.push_back(std::make_pair(IsolationKeys(key), *it));
189  // }
190  // }
191  // }
192  // isoDepositTokens_ = edm::vector_transform(isoDepositLabels_, [this](std::pair<IsolationKeys,edm::InputTag> const & label){return consumes<edm::ValueMap<IsoDeposit> >(label.second);});
193 
194  // for mini-iso
195  computeMiniIso_ = iConfig.getParameter<bool>("computeMiniIso");
196  miniIsoParamsE_ = iConfig.getParameter<std::vector<double>>("miniIsoParamsE");
197  miniIsoParamsB_ = iConfig.getParameter<std::vector<double>>("miniIsoParamsB");
198  if (computeMiniIso_ && (miniIsoParamsE_.size() != 9 || miniIsoParamsB_.size() != 9)) {
199  throw cms::Exception("ParameterError") << "miniIsoParams must have exactly 9 elements.\n";
200  }
201  if (computeMiniIso_)
202  pcToken_ = consumes<pat::PackedCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfCandsForMiniIso"));
203 
204  // read isoDeposit labels, for direct embedding
205  readIsolationLabels(iConfig, "isoDeposits", isoDepositLabels_, isoDepositTokens_);
206  // read isolation value labels, for direct embedding
207  readIsolationLabels(iConfig, "isolationValues", isolationValueLabels_, isolationValueTokens_);
208  // read isolation value labels for non PF identified electron, for direct embedding
209  readIsolationLabels(iConfig, "isolationValuesNoPFId", isolationValueLabelsNoPFId_, isolationValueNoPFIdTokens_);
210  // Efficiency configurables
211  if (addEfficiencies_) {
212  efficiencyLoader_ =
213  pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"), consumesCollector());
214  }
215  // Check to see if the user wants to add user data
216  if (useUserData_) {
217  userDataHelper_ =
218  PATUserDataHelper<Electron>(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector());
219  }
220 
221  // consistency check
222  if (useParticleFlow_ && usePfCandidateMultiMap_)
223  throw cms::Exception("Configuration", "usePfCandidateMultiMap not supported when useParticleFlow is set to true");
224 
225  // produces vector of muons
226  produces<std::vector<Electron>>();
227 }

References addEfficiencies_, addElecID_, addGenMatch_, addPuppiIsolation_, addResolutions_, computeMiniIso_, efficiencyLoader_, elecIDSrcs_, elecIDTokens_, Exception, edm::ParameterSet::existsAs(), genMatchTokens_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), isoDepositLabels_, isoDepositTokens_, isolationValueLabels_, isolationValueLabelsNoPFId_, isolationValueNoPFIdTokens_, isolationValueTokens_, miniIsoParamsB_, miniIsoParamsE_, names, pcToken_, PUPPIIsolation_charged_hadrons_, PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_photons_, PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_photons_, readIsolationLabels(), resolutionLoader_, GlobalPosition_Frontier_DevDB_cff::tag, useParticleFlow_, usePfCandidateMultiMap_, userDataHelper_, useUserData_, and edm::vector_transform().

◆ ~PATElectronProducer()

PATElectronProducer::~PATElectronProducer ( )
override

Definition at line 229 of file PATElectronProducer.cc.

229 {}

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 1196 of file PATElectronProducer.cc.

1202  {
1203  // Correct to PV
1204 
1205  // PV2D
1206  std::pair<bool, Measurement1D> result =
1207  IPTools::signedTransverseImpactParameter(tt, GlobalVector(track->px(), track->py(), track->pz()), primaryVertex);
1208  double d0_corr = result.second.value();
1209  double d0_err = primaryVertexIsValid ? result.second.error() : -1.0;
1210  anElectron.setDB(d0_corr, d0_err, pat::Electron::PV2D);
1211 
1212  // PV3D
1213  result = IPTools::signedImpactParameter3D(tt, GlobalVector(track->px(), track->py(), track->pz()), primaryVertex);
1214  d0_corr = result.second.value();
1215  d0_err = primaryVertexIsValid ? result.second.error() : -1.0;
1216  anElectron.setDB(d0_corr, d0_err, pat::Electron::PV3D);
1217 
1218  // Correct to beam spot
1219  // make a fake vertex out of beam spot
1220  reco::Vertex vBeamspot(beamspot.position(), beamspot.covariance3D());
1221 
1222  // BS2D
1223  result = IPTools::signedTransverseImpactParameter(tt, GlobalVector(track->px(), track->py(), track->pz()), vBeamspot);
1224  d0_corr = result.second.value();
1225  d0_err = beamspotIsValid ? result.second.error() : -1.0;
1226  anElectron.setDB(d0_corr, d0_err, pat::Electron::BS2D);
1227 
1228  // BS3D
1229  result = IPTools::signedImpactParameter3D(tt, GlobalVector(track->px(), track->py(), track->pz()), vBeamspot);
1230  d0_corr = result.second.value();
1231  d0_err = beamspotIsValid ? result.second.error() : -1.0;
1232  anElectron.setDB(d0_corr, d0_err, pat::Electron::BS3D);
1233 
1234  // PVDZ
1235  anElectron.setDB(
1236  track->dz(primaryVertex.position()), std::hypot(track->dzError(), primaryVertex.zError()), pat::Electron::PVDZ);
1237 }

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(), IPTools::signedTransverseImpactParameter(), HLT_2018_cff::track, and groupFilesInBlocks::tt.

Referenced by produce().

◆ fillDescriptions()

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

Definition at line 1020 of file PATElectronProducer.cc.

1020  {
1021  edm::ParameterSetDescription iDesc;
1022  iDesc.setComment("PAT electron producer module");
1023 
1024  // input source
1025  iDesc.add<edm::InputTag>("pfCandidateMap", edm::InputTag("no default"))->setComment("input collection");
1026  iDesc.add<edm::InputTag>("electronSource", edm::InputTag("no default"))->setComment("input collection");
1027 
1028  iDesc.ifValue(
1029  edm::ParameterDescription<bool>("addPFClusterIso", false, true),
1030  true >> (edm::ParameterDescription<edm::InputTag>(
1031  "ecalPFClusterIsoMap", edm::InputTag("electronEcalPFClusterIsolationProducer"), true) and
1032  edm::ParameterDescription<edm::InputTag>(
1033  "hcalPFClusterIsoMap", edm::InputTag("electronHcalPFClusterIsolationProducer"), true)) or
1034  false >> (edm::ParameterDescription<edm::InputTag>("ecalPFClusterIsoMap", edm::InputTag(""), true) and
1035  edm::ParameterDescription<edm::InputTag>("hcalPFClusterIsoMap", edm::InputTag(""), true)));
1036 
1037  iDesc.ifValue(edm::ParameterDescription<bool>("addPuppiIsolation", false, true),
1038  true >> (edm::ParameterDescription<edm::InputTag>(
1039  "puppiIsolationChargedHadrons",
1040  edm::InputTag("egmElectronPUPPIIsolation", "h+-DR030-BarVeto000-EndVeto001"),
1041  true) and
1042  edm::ParameterDescription<edm::InputTag>(
1043  "puppiIsolationNeutralHadrons",
1044  edm::InputTag("egmElectronPUPPIIsolation", "h0-DR030-BarVeto000-EndVeto000"),
1045  true) and
1046  edm::ParameterDescription<edm::InputTag>(
1047  "puppiIsolationPhotons",
1048  edm::InputTag("egmElectronPUPPIIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
1049  true) and
1050  edm::ParameterDescription<edm::InputTag>(
1051  "puppiNoLeptonsIsolationChargedHadrons",
1052  edm::InputTag("egmElectronPUPPINoLeptonsIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
1053  true) and
1054  edm::ParameterDescription<edm::InputTag>(
1055  "puppiNoLeptonsIsolationNeutralHadrons",
1056  edm::InputTag("egmElectronPUPPINoLeptonsIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
1057  true) and
1058  edm::ParameterDescription<edm::InputTag>(
1059  "puppiNoLeptonsIsolationPhotons",
1060  edm::InputTag("egmElectronPUPPINoLeptonsIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
1061  true)) or
1062  false >> edm::EmptyGroupDescription());
1063 
1064  // embedding
1065  iDesc.add<bool>("embedGsfElectronCore", true)->setComment("embed external gsf electron core");
1066  iDesc.add<bool>("embedGsfTrack", true)->setComment("embed external gsf track");
1067  iDesc.add<bool>("embedSuperCluster", true)->setComment("embed external super cluster");
1068  iDesc.add<bool>("embedPflowSuperCluster", true)->setComment("embed external super cluster");
1069  iDesc.add<bool>("embedSeedCluster", true)->setComment("embed external seed cluster");
1070  iDesc.add<bool>("embedBasicClusters", true)->setComment("embed external basic clusters");
1071  iDesc.add<bool>("embedPreshowerClusters", true)->setComment("embed external preshower clusters");
1072  iDesc.add<bool>("embedPflowBasicClusters", true)->setComment("embed external pflow basic clusters");
1073  iDesc.add<bool>("embedPflowPreshowerClusters", true)->setComment("embed external pflow preshower clusters");
1074  iDesc.add<bool>("embedTrack", false)->setComment("embed external track");
1075  iDesc.add<bool>("embedRecHits", true)->setComment("embed external RecHits");
1076 
1077  // pf specific parameters
1078  iDesc.add<edm::InputTag>("pfElectronSource", edm::InputTag("pfElectrons"))
1079  ->setComment("particle flow input collection");
1080  auto&& usePfCandidateMultiMap = edm::ParameterDescription<bool>("usePfCandidateMultiMap", false, true);
1081  usePfCandidateMultiMap.setComment(
1082  "take ParticleFlow candidates from pfCandidateMultiMap instead of matching to pfElectrons by Gsf track "
1083  "reference");
1084  iDesc.ifValue(usePfCandidateMultiMap,
1085  true >> edm::ParameterDescription<edm::InputTag>("pfCandidateMultiMap", true) or
1086  false >> edm::EmptyGroupDescription());
1087  iDesc.add<bool>("useParticleFlow", false)->setComment("whether to use particle flow or not");
1088  iDesc.add<bool>("embedPFCandidate", false)->setComment("embed external particle flow object");
1089 
1090  // MC matching configurables
1091  iDesc.add<bool>("addGenMatch", true)->setComment("add MC matching");
1092  iDesc.add<bool>("embedGenMatch", false)->setComment("embed MC matched MC information");
1093  std::vector<edm::InputTag> emptySourceVector;
1094  iDesc
1095  .addNode(edm::ParameterDescription<edm::InputTag>("genParticleMatch", edm::InputTag(), true) xor
1096  edm::ParameterDescription<std::vector<edm::InputTag>>("genParticleMatch", emptySourceVector, true))
1097  ->setComment("input with MC match information");
1098 
1099  // electron ID configurables
1100  iDesc.add<bool>("addElectronID", true)->setComment("add electron ID variables");
1101  edm::ParameterSetDescription electronIDSourcesPSet;
1102  electronIDSourcesPSet.setAllowAnything();
1103  iDesc
1104  .addNode(
1105  edm::ParameterDescription<edm::InputTag>("electronIDSource", edm::InputTag(), true) xor
1106  edm::ParameterDescription<edm::ParameterSetDescription>("electronIDSources", electronIDSourcesPSet, true))
1107  ->setComment("input with electron ID variables");
1108 
1109  // mini-iso
1110  iDesc.add<bool>("computeMiniIso", false)->setComment("whether or not to compute and store electron mini-isolation");
1111  iDesc.add<edm::InputTag>("pfCandsForMiniIso", edm::InputTag("packedPFCandidates"))
1112  ->setComment("collection to use to compute mini-iso");
1113  iDesc.add<std::vector<double>>("miniIsoParamsE", std::vector<double>())
1114  ->setComment("mini-iso parameters to use for endcap electrons");
1115  iDesc.add<std::vector<double>>("miniIsoParamsB", std::vector<double>())
1116  ->setComment("mini-iso parameters to use for barrel electrons");
1117 
1118  // IsoDeposit configurables
1119  edm::ParameterSetDescription isoDepositsPSet;
1120  isoDepositsPSet.addOptional<edm::InputTag>("tracker");
1121  isoDepositsPSet.addOptional<edm::InputTag>("ecal");
1122  isoDepositsPSet.addOptional<edm::InputTag>("hcal");
1123  isoDepositsPSet.addOptional<edm::InputTag>("pfAllParticles");
1124  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedHadrons");
1125  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedAll");
1126  isoDepositsPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
1127  isoDepositsPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
1128  isoDepositsPSet.addOptional<edm::InputTag>("pfPhotons");
1129  isoDepositsPSet.addOptional<std::vector<edm::InputTag>>("user");
1130  iDesc.addOptional("isoDeposits", isoDepositsPSet);
1131 
1132  // isolation values configurables
1133  edm::ParameterSetDescription isolationValuesPSet;
1134  isolationValuesPSet.addOptional<edm::InputTag>("tracker");
1135  isolationValuesPSet.addOptional<edm::InputTag>("ecal");
1136  isolationValuesPSet.addOptional<edm::InputTag>("hcal");
1137  isolationValuesPSet.addOptional<edm::InputTag>("pfAllParticles");
1138  isolationValuesPSet.addOptional<edm::InputTag>("pfChargedHadrons");
1139  isolationValuesPSet.addOptional<edm::InputTag>("pfChargedAll");
1140  isolationValuesPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
1141  isolationValuesPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
1142  isolationValuesPSet.addOptional<edm::InputTag>("pfPhotons");
1143  isolationValuesPSet.addOptional<std::vector<edm::InputTag>>("user");
1144  iDesc.addOptional("isolationValues", isolationValuesPSet);
1145 
1146  // isolation values configurables
1147  edm::ParameterSetDescription isolationValuesNoPFIdPSet;
1148  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("tracker");
1149  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("ecal");
1150  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("hcal");
1151  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfAllParticles");
1152  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfChargedHadrons");
1153  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfChargedAll");
1154  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
1155  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
1156  isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfPhotons");
1157  isolationValuesNoPFIdPSet.addOptional<std::vector<edm::InputTag>>("user");
1158  iDesc.addOptional("isolationValuesNoPFId", isolationValuesNoPFIdPSet);
1159 
1160  // Efficiency configurables
1161  edm::ParameterSetDescription efficienciesPSet;
1162  efficienciesPSet.setAllowAnything(); // TODO: the pat helper needs to implement a description.
1163  iDesc.add("efficiencies", efficienciesPSet);
1164  iDesc.add<bool>("addEfficiencies", false);
1165 
1166  // Check to see if the user wants to add user data
1167  edm::ParameterSetDescription userDataPSet;
1168  PATUserDataHelper<Electron>::fillDescription(userDataPSet);
1169  iDesc.addOptional("userData", userDataPSet);
1170 
1171  // electron shapes
1172  iDesc.add<bool>("addMVAVariables", true)->setComment("embed extra variables in pat::Electron : sip3d, sigmaIEtaIPhi");
1173  iDesc.add<edm::InputTag>("reducedBarrelRecHitCollection", edm::InputTag("reducedEcalRecHitsEB"));
1174  iDesc.add<edm::InputTag>("reducedEndcapRecHitCollection", edm::InputTag("reducedEcalRecHitsEE"));
1175 
1176  edm::ParameterSetDescription isolationPSet;
1177  isolationPSet.setAllowAnything(); // TODO: the pat helper needs to implement a description.
1178  iDesc.add("userIsolation", isolationPSet);
1179 
1180  // Resolution configurables
1181  pat::helper::KinResolutionsLoader::fillDescription(iDesc);
1182 
1183  iDesc.add<bool>("embedHighLevelSelection", true)->setComment("embed high level selection");
1184  edm::ParameterSetDescription highLevelPSet;
1185  highLevelPSet.setAllowAnything();
1186  iDesc.addNode(edm::ParameterDescription<edm::InputTag>("beamLineSrc", edm::InputTag(), true))
1187  ->setComment("input with high level selection");
1188  iDesc.addNode(edm::ParameterDescription<edm::InputTag>("pvSrc", edm::InputTag(), true))
1189  ->setComment("input with high level selection");
1190 
1191  descriptions.add("PATElectronProducer", iDesc);
1192 }

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

◆ 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 815 of file PATElectronProducer.cc.

822  {
823  //COLIN: might want to use the PFCandidate 4-mom. Which one is in use now?
824  // if (useParticleFlow_)
825  // aMuon.setP4( aMuon.pfCandidateRef()->p4() );
826 
827  //COLIN:
828  //In the embedding case, the reference cannot be used to look into a value map.
829  //therefore, one has to had the PFCandidateRef to this function, which becomes a bit
830  //too much specific.
831 
832  // in fact, this function needs a baseref or ptr for genmatch
833  // and a baseref or ptr for isodeposits and isolationvalues.
834  // baseref is not needed
835  // the ptrForIsolation and ptrForMatching should be defined upstream.
836 
837  // is the concrete elecRef needed for the efficiency loader? what is this loader?
838  // how can we make it compatible with the particle flow electrons?
839 
840  if (embedGsfElectronCore_)
841  anElectron.embedGsfElectronCore();
842  if (embedGsfTrack_)
843  anElectron.embedGsfTrack();
844  if (embedSuperCluster_)
845  anElectron.embedSuperCluster();
846  if (embedPflowSuperCluster_)
847  anElectron.embedPflowSuperCluster();
848  if (embedSeedCluster_)
849  anElectron.embedSeedCluster();
850  if (embedBasicClusters_)
851  anElectron.embedBasicClusters();
852  if (embedPreshowerClusters_)
853  anElectron.embedPreshowerClusters();
854  if (embedPflowBasicClusters_)
855  anElectron.embedPflowBasicClusters();
856  if (embedPflowPreshowerClusters_)
857  anElectron.embedPflowPreshowerClusters();
858  if (embedTrack_)
859  anElectron.embedTrack();
860 
861  // store the match to the generated final state muons
862  if (addGenMatch_) {
863  for (size_t i = 0, n = genMatches.size(); i < n; ++i) {
864  if (useParticleFlow_) {
865  reco::GenParticleRef genElectron = (*genMatches[i])[anElectron.pfCandidateRef()];
866  anElectron.addGenParticleRef(genElectron);
867  } else {
868  reco::GenParticleRef genElectron = (*genMatches[i])[elecRef];
869  anElectron.addGenParticleRef(genElectron);
870  }
871  }
872  if (embedGenMatch_)
873  anElectron.embedGenParticle();
874  }
875 
876  if (efficiencyLoader_.enabled()) {
877  efficiencyLoader_.setEfficiencies(anElectron, elecRef);
878  }
879 
880  if (resolutionLoader_.enabled()) {
881  resolutionLoader_.setResolutions(anElectron);
882  }
883 
884  for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
885  if (useParticleFlow_) {
886  reco::PFCandidateRef pfcandref = anElectron.pfCandidateRef();
887  assert(!pfcandref.isNull());
888  reco::CandidatePtr source = pfcandref->sourceCandidatePtr(0);
889  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[source]);
890  } else
891  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[elecRef]);
892  }
893 
894  for (size_t j = 0; j < isolationValues.size(); ++j) {
895  if (useParticleFlow_) {
896  reco::CandidatePtr source = anElectron.pfCandidateRef()->sourceCandidatePtr(0);
897  anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[source]);
898  } else if (pfId) {
899  anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[elecRef]);
900  }
901  }
902 
903  //for electrons not identified as PF electrons
904  for (size_t j = 0; j < isolationValuesNoPFId.size(); ++j) {
905  if (!pfId) {
906  anElectron.setIsolation(isolationValueLabelsNoPFId_[j].first, (*isolationValuesNoPFId[j])[elecRef]);
907  }
908  }
909 }

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_, electronProducer_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().

◆ 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 911 of file PATElectronProducer.cc.

917  {
918  //COLIN/Florian: use the PFCandidate 4-mom.
919  anElectron.setEcalDrivenMomentum(anElectron.p4());
920  anElectron.setP4(anElectron.pfCandidateRef()->p4());
921 
922  // is the concrete elecRef needed for the efficiency loader? what is this loader?
923  // how can we make it compatible with the particle flow electrons?
924 
925  if (embedGsfElectronCore_)
926  anElectron.embedGsfElectronCore();
927  if (embedGsfTrack_)
928  anElectron.embedGsfTrack();
929  if (embedSuperCluster_)
930  anElectron.embedSuperCluster();
931  if (embedPflowSuperCluster_)
932  anElectron.embedPflowSuperCluster();
933  if (embedSeedCluster_)
934  anElectron.embedSeedCluster();
935  if (embedBasicClusters_)
936  anElectron.embedBasicClusters();
937  if (embedPreshowerClusters_)
938  anElectron.embedPreshowerClusters();
939  if (embedPflowBasicClusters_)
940  anElectron.embedPflowBasicClusters();
941  if (embedPflowPreshowerClusters_)
942  anElectron.embedPflowPreshowerClusters();
943  if (embedTrack_)
944  anElectron.embedTrack();
945 
946  // store the match to the generated final state muons
947 
948  if (addGenMatch_) {
949  for (size_t i = 0, n = genMatches.size(); i < n; ++i) {
950  reco::GenParticleRef genElectron = (*genMatches[i])[candPtrForGenMatch];
951  anElectron.addGenParticleRef(genElectron);
952  }
953  if (embedGenMatch_)
954  anElectron.embedGenParticle();
955  }
956 
957  //COLIN what's this? does it have to be GsfElectron specific?
958  if (efficiencyLoader_.enabled()) {
959  efficiencyLoader_.setEfficiencies(anElectron, candPtrForLoader);
960  }
961 
962  if (resolutionLoader_.enabled()) {
963  resolutionLoader_.setResolutions(anElectron);
964  }
965 
966  for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
967  if (isoDepositLabels_[j].first == pat::TrackIso || isoDepositLabels_[j].first == pat::EcalIso ||
968  isoDepositLabels_[j].first == pat::HcalIso || deposits[j]->contains(candPtrForGenMatch.id())) {
969  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[candPtrForGenMatch]);
970  } else if (deposits[j]->contains(candPtrForIsolation.id())) {
971  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[candPtrForIsolation]);
972  } else {
973  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[candPtrForIsolation->sourceCandidatePtr(0)]);
974  }
975  }
976 
977  for (size_t j = 0; j < isolationValues.size(); ++j) {
978  if (isolationValueLabels_[j].first == pat::TrackIso || isolationValueLabels_[j].first == pat::EcalIso ||
979  isolationValueLabels_[j].first == pat::HcalIso || isolationValues[j]->contains(candPtrForGenMatch.id())) {
980  anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[candPtrForGenMatch]);
981  } else if (isolationValues[j]->contains(candPtrForIsolation.id())) {
982  anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[candPtrForIsolation]);
983  } else {
984  anElectron.setIsolation(isolationValueLabels_[j].first,
985  (*isolationValues[j])[candPtrForIsolation->sourceCandidatePtr(0)]);
986  }
987  }
988 }

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_, electronProducer_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().

◆ produce()

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

Definition at line 231 of file PATElectronProducer.cc.

231  {
232  // switch off embedding (in unschedules mode)
233  if (iEvent.isRealData()) {
234  addGenMatch_ = false;
235  embedGenMatch_ = false;
236  }
237 
238  edm::ESHandle<CaloTopology> theCaloTopology;
239  iSetup.get<CaloTopologyRecord>().get(theCaloTopology);
240  ecalTopology_ = &(*theCaloTopology);
241 
242  // Get the collection of electrons from the event
243  edm::Handle<edm::View<reco::GsfElectron>> electrons;
244  iEvent.getByToken(electronToken_, electrons);
245 
246  edm::Handle<PackedCandidateCollection> pc;
247  if (computeMiniIso_)
248  iEvent.getByToken(pcToken_, pc);
249 
250  // for additional mva variables
251  edm::InputTag reducedEBRecHitCollection(string("reducedEcalRecHitsEB"));
252  edm::InputTag reducedEERecHitCollection(string("reducedEcalRecHitsEE"));
253  //EcalClusterLazyTools lazyTools(iEvent, iSetup, reducedEBRecHitCollection, reducedEERecHitCollection);
254  EcalClusterLazyTools lazyTools(
255  iEvent, iSetup, reducedBarrelRecHitCollectionToken_, reducedEndcapRecHitCollectionToken_);
256 
257  // for conversion veto selection
258  edm::Handle<reco::ConversionCollection> hConversions;
259  iEvent.getByToken(hConversionsToken_, hConversions);
260 
261  // Get the ESHandle for the transient track builder, if needed for
262  // high level selection embedding
263  edm::ESHandle<TransientTrackBuilder> trackBuilder;
264 
265  if (isolator_.enabled())
266  isolator_.beginEvent(iEvent, iSetup);
267 
268  if (efficiencyLoader_.enabled())
269  efficiencyLoader_.newEvent(iEvent);
270  if (resolutionLoader_.enabled())
271  resolutionLoader_.newEvent(iEvent, iSetup);
272 
273  IsoDepositMaps deposits(isoDepositTokens_.size());
274  for (size_t j = 0, nd = isoDepositTokens_.size(); j < nd; ++j) {
275  iEvent.getByToken(isoDepositTokens_[j], deposits[j]);
276  }
277 
278  IsolationValueMaps isolationValues(isolationValueTokens_.size());
279  for (size_t j = 0; j < isolationValueTokens_.size(); ++j) {
280  iEvent.getByToken(isolationValueTokens_[j], isolationValues[j]);
281  }
282 
283  IsolationValueMaps isolationValuesNoPFId(isolationValueNoPFIdTokens_.size());
284  for (size_t j = 0; j < isolationValueNoPFIdTokens_.size(); ++j) {
285  iEvent.getByToken(isolationValueNoPFIdTokens_[j], isolationValuesNoPFId[j]);
286  }
287 
288  // prepare the MC matching
289  GenAssociations genMatches(genMatchTokens_.size());
290  if (addGenMatch_) {
291  for (size_t j = 0, nd = genMatchTokens_.size(); j < nd; ++j) {
292  iEvent.getByToken(genMatchTokens_[j], genMatches[j]);
293  }
294  }
295 
296  // prepare ID extraction
297  std::vector<edm::Handle<edm::ValueMap<float>>> idhandles;
298  std::vector<pat::Electron::IdPair> ids;
299  if (addElecID_) {
300  idhandles.resize(elecIDSrcs_.size());
301  ids.resize(elecIDSrcs_.size());
302  for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
303  iEvent.getByToken(elecIDTokens_[i], idhandles[i]);
304  ids[i].first = elecIDSrcs_[i].first;
305  }
306  }
307 
308  // prepare the high level selection:
309  // needs beamline
310  reco::TrackBase::Point beamPoint(0, 0, 0);
311  reco::Vertex primaryVertex;
312  reco::BeamSpot beamSpot;
313  bool beamSpotIsValid = false;
314  bool primaryVertexIsValid = false;
315 
316  // Get the beamspot
317  edm::Handle<reco::BeamSpot> beamSpotHandle;
318  iEvent.getByToken(beamLineToken_, beamSpotHandle);
319 
320  if (embedHighLevelSelection_) {
321  // Get the primary vertex
322  edm::Handle<std::vector<reco::Vertex>> pvHandle;
323  iEvent.getByToken(pvToken_, pvHandle);
324 
325  // This is needed by the IPTools methods from the tracking group
326  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", trackBuilder);
327 
328  if (pvHandle.isValid() && !pvHandle->empty()) {
329  primaryVertex = pvHandle->at(0);
330  primaryVertexIsValid = true;
331  } else {
332  edm::LogError("DataNotAvailable")
333  << "No primary vertex available from EventSetup, not adding high level selection \n";
334  }
335  }
336  //value maps for puppi isolation
337  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_charged_hadrons;
338  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_neutral_hadrons;
339  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_photons;
340  //value maps for puppiNoLeptons isolation
341  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_charged_hadrons;
342  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_neutral_hadrons;
343  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_photons;
344  if (addPuppiIsolation_) {
345  //puppi
346  iEvent.getByToken(PUPPIIsolation_charged_hadrons_, PUPPIIsolation_charged_hadrons);
347  iEvent.getByToken(PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_neutral_hadrons);
348  iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons);
349  //puppiNoLeptons
350  iEvent.getByToken(PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_charged_hadrons);
351  iEvent.getByToken(PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons);
352  iEvent.getByToken(PUPPINoLeptonsIsolation_photons_, PUPPINoLeptonsIsolation_photons);
353  }
354 
355  std::vector<Electron>* patElectrons = new std::vector<Electron>();
356 
357  if (useParticleFlow_) {
358  edm::Handle<reco::PFCandidateCollection> pfElectrons;
359  iEvent.getByToken(pfElecToken_, pfElectrons);
360  unsigned index = 0;
361 
362  for (reco::PFCandidateConstIterator i = pfElectrons->begin(); i != pfElectrons->end(); ++i, ++index) {
363  reco::PFCandidateRef pfRef(pfElectrons, index);
364  reco::PFCandidatePtr ptrToPFElectron(pfElectrons, index);
365  // reco::CandidateBaseRef pfBaseRef( pfRef );
366 
367  reco::GsfTrackRef PfTk = i->gsfTrackRef();
368 
369  bool Matched = false;
370  bool MatchedToAmbiguousGsfTrack = false;
371  for (edm::View<reco::GsfElectron>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end();
372  ++itElectron) {
373  unsigned int idx = itElectron - electrons->begin();
374  auto elePtr = electrons->ptrAt(idx);
375  if (Matched || MatchedToAmbiguousGsfTrack)
376  continue;
377 
378  reco::GsfTrackRef EgTk = itElectron->gsfTrack();
379 
380  if (itElectron->gsfTrack() == i->gsfTrackRef()) {
381  Matched = true;
382  } else {
383  for (reco::GsfTrackRefVector::const_iterator it = itElectron->ambiguousGsfTracksBegin();
384  it != itElectron->ambiguousGsfTracksEnd();
385  it++) {
386  MatchedToAmbiguousGsfTrack |= (bool)(i->gsfTrackRef() == (*it));
387  }
388  }
389 
390  if (Matched || MatchedToAmbiguousGsfTrack) {
391  // ptr needed for finding the matched gen particle
392  reco::CandidatePtr ptrToGsfElectron(electrons, idx);
393 
394  // ref to base needed for the construction of the pat object
395  const edm::RefToBase<reco::GsfElectron>& elecsRef = electrons->refAt(idx);
396  Electron anElectron(elecsRef);
397  anElectron.setPFCandidateRef(pfRef);
398  if (addPuppiIsolation_) {
399  anElectron.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[elePtr],
400  (*PUPPIIsolation_neutral_hadrons)[elePtr],
401  (*PUPPIIsolation_photons)[elePtr]);
402  anElectron.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[elePtr],
403  (*PUPPINoLeptonsIsolation_neutral_hadrons)[elePtr],
404  (*PUPPINoLeptonsIsolation_photons)[elePtr]);
405  } else {
406  anElectron.setIsolationPUPPI(-999., -999., -999.);
407  anElectron.setIsolationPUPPINoLeptons(-999., -999., -999.);
408  }
409 
410  //it should be always true when particleFlow electrons are used.
411  anElectron.setIsPF(true);
412 
413  if (embedPFCandidate_)
414  anElectron.embedPFCandidate();
415 
416  if (useUserData_) {
417  userDataHelper_.add(anElectron, iEvent, iSetup);
418  }
419 
420  double ip3d = -999; // for mva variable
421 
422  // embed high level selection
423  if (embedHighLevelSelection_) {
424  // get the global track
425  const reco::GsfTrackRef& track = PfTk;
426 
427  // Make sure the collection it points to is there
428  if (track.isNonnull() && track.isAvailable()) {
429  reco::TransientTrack tt = trackBuilder->build(track);
430  embedHighLevel(anElectron, track, tt, primaryVertex, primaryVertexIsValid, beamSpot, beamSpotIsValid);
431 
432  std::pair<bool, Measurement1D> ip3dpv = IPTools::absoluteImpactParameter3D(tt, primaryVertex);
433  ip3d = ip3dpv.second.value(); // for mva variable
434  }
435  }
436 
437  //Electron Id
438 
439  if (addElecID_) {
440  //STANDARD EL ID
441  for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
442  ids[i].second = (*idhandles[i])[elecsRef];
443  }
444  //SPECIFIC PF ID
445  ids.push_back(std::make_pair("pf_evspi", pfRef->mva_e_pi()));
446  ids.push_back(std::make_pair("pf_evsmu", pfRef->mva_e_mu()));
447  anElectron.setElectronIDs(ids);
448  }
449 
450  if (addMVAVariables_) {
451  // add missing mva variables
452  std::vector<float> vCov = lazyTools.localCovariances(*(itElectron->superCluster()->seed()));
453  anElectron.setMvaVariables(vCov[1], ip3d);
454  }
455  // PFClusterIso
456  if (addPFClusterIso_) {
457  // Get PFCluster Isolation
458  edm::Handle<edm::ValueMap<float>> ecalPFClusterIsoMapH;
459  iEvent.getByToken(ecalPFClusterIsoT_, ecalPFClusterIsoMapH);
460  edm::Handle<edm::ValueMap<float>> hcalPFClusterIsoMapH;
461  iEvent.getByToken(hcalPFClusterIsoT_, hcalPFClusterIsoMapH);
462  reco::GsfElectron::PflowIsolationVariables newPFIsol = anElectron.pfIsolationVariables();
463  newPFIsol.sumEcalClusterEt = (*ecalPFClusterIsoMapH)[elecsRef];
464  newPFIsol.sumHcalClusterEt = (*hcalPFClusterIsoMapH)[elecsRef];
465  anElectron.setPfIsolationVariables(newPFIsol);
466  }
467 
468  std::vector<DetId> selectedCells;
469  bool barrel = itElectron->isEB();
470  //loop over sub clusters
471  if (embedBasicClusters_) {
472  for (reco::CaloCluster_iterator clusIt = itElectron->superCluster()->clustersBegin();
473  clusIt != itElectron->superCluster()->clustersEnd();
474  ++clusIt) {
475  //get seed (max energy xtal)
476  DetId seed = lazyTools.getMaximum(**clusIt).first;
477  //get all xtals in 5x5 window around the seed
478  std::vector<DetId> dets5x5 =
479  (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
480  : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
481  selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
482 
483  //get all xtals belonging to cluster
484  for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
485  selectedCells.push_back(hit.first);
486  }
487  }
488  }
489 
490  if (embedPflowBasicClusters_ && itElectron->parentSuperCluster().isNonnull()) {
491  for (reco::CaloCluster_iterator clusIt = itElectron->parentSuperCluster()->clustersBegin();
492  clusIt != itElectron->parentSuperCluster()->clustersEnd();
493  ++clusIt) {
494  //get seed (max energy xtal)
495  DetId seed = lazyTools.getMaximum(**clusIt).first;
496  //get all xtals in 5x5 window around the seed
497  std::vector<DetId> dets5x5 =
498  (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
499  : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
500  selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
501 
502  //get all xtals belonging to cluster
503  for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
504  selectedCells.push_back(hit.first);
505  }
506  }
507  }
508 
509  //remove duplicates
510  std::sort(selectedCells.begin(), selectedCells.end());
511  std::unique(selectedCells.begin(), selectedCells.end());
512 
513  // Retrieve the corresponding RecHits
514 
515  edm::Handle<EcalRecHitCollection> rechitsH;
516  if (barrel)
517  iEvent.getByToken(reducedBarrelRecHitCollectionToken_, rechitsH);
518  else
519  iEvent.getByToken(reducedEndcapRecHitCollectionToken_, rechitsH);
520 
521  EcalRecHitCollection selectedRecHits;
522  const EcalRecHitCollection* recHits = rechitsH.product();
523 
524  unsigned nSelectedCells = selectedCells.size();
525  for (unsigned icell = 0; icell < nSelectedCells; ++icell) {
526  EcalRecHitCollection::const_iterator it = recHits->find(selectedCells[icell]);
527  if (it != recHits->end()) {
528  selectedRecHits.push_back(*it);
529  }
530  }
531  selectedRecHits.sort();
532  if (embedRecHits_)
533  anElectron.embedRecHits(&selectedRecHits);
534 
535  // set conversion veto selection
536  bool passconversionveto = false;
537  if (hConversions.isValid()) {
538  // this is recommended method
539  passconversionveto =
540  !ConversionTools::hasMatchedConversion(*itElectron, *hConversions, beamSpotHandle->position());
541  } else {
542  // use missing hits without vertex fit method
543  passconversionveto =
544  itElectron->gsfTrack()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) < 1;
545  }
546 
547  anElectron.setPassConversionVeto(passconversionveto);
548 
549  // fillElectron(anElectron,elecsRef,pfBaseRef,
550  // genMatches, deposits, isolationValues);
551 
552  //COLIN small warning !
553  // we are currently choosing to take the 4-momentum of the PFCandidate;
554  // the momentum of the GsfElectron is saved though
555  // we must therefore match the GsfElectron.
556  // because of this, we should not change the source of the electron matcher
557  // to the collection of PFElectrons in the python configuration
558  // I don't know what to do with the efficiencyLoader, since I don't know
559  // what this class is for.
560  fillElectron2(
561  anElectron, ptrToPFElectron, ptrToGsfElectron, ptrToGsfElectron, genMatches, deposits, isolationValues);
562 
563  //COLIN need to use fillElectron2 in the non-pflow case as well, and to test it.
564 
565  if (computeMiniIso_)
566  setElectronMiniIso(anElectron, pc.product());
567 
568  patElectrons->push_back(anElectron);
569  }
570  }
571  //if( !Matched && !MatchedToAmbiguousGsfTrack) std::cout << "!!!!A pf electron could not be matched to a gsf!!!!" << std::endl;
572  }
573  }
574 
575  else {
576  edm::Handle<reco::PFCandidateCollection> pfElectrons;
577  edm::Handle<edm::ValueMap<reco::PFCandidatePtr>> ValMapH;
578  edm::Handle<edm::ValueMap<std::vector<reco::PFCandidateRef>>> ValMultiMapH;
579  bool pfCandsPresent = false, valMapPresent = false;
580  if (usePfCandidateMultiMap_) {
581  iEvent.getByToken(pfCandidateMultiMapToken_, ValMultiMapH);
582  } else {
583  pfCandsPresent = iEvent.getByToken(pfElecToken_, pfElectrons);
584  valMapPresent = iEvent.getByToken(pfCandidateMapToken_, ValMapH);
585  }
586 
587  for (edm::View<reco::GsfElectron>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end();
588  ++itElectron) {
589  // construct the Electron from the ref -> save ref to original object
590  //FIXME: looks like a lot of instances could be turned into const refs
591  unsigned int idx = itElectron - electrons->begin();
592  edm::RefToBase<reco::GsfElectron> elecsRef = electrons->refAt(idx);
593  reco::CandidateBaseRef elecBaseRef(elecsRef);
594  Electron anElectron(elecsRef);
595  auto elePtr = electrons->ptrAt(idx);
596 
597  // Is this GsfElectron also identified as an e- in the particle flow?
598  bool pfId = false;
599 
600  if (usePfCandidateMultiMap_) {
601  for (const reco::PFCandidateRef& pf : (*ValMultiMapH)[elePtr]) {
602  if (pf->particleId() == reco::PFCandidate::e) {
603  pfId = true;
604  anElectron.setPFCandidateRef(pf);
605  break;
606  }
607  }
608  } else if (pfCandsPresent) {
609  // PF electron collection not available.
610  const reco::GsfTrackRef& trkRef = itElectron->gsfTrack();
611  int index = 0;
612  for (reco::PFCandidateConstIterator ie = pfElectrons->begin(); ie != pfElectrons->end(); ++ie, ++index) {
613  if (ie->particleId() != reco::PFCandidate::e)
614  continue;
615  const reco::GsfTrackRef& pfTrkRef = ie->gsfTrackRef();
616  if (trkRef == pfTrkRef) {
617  pfId = true;
618  reco::PFCandidateRef pfRef(pfElectrons, index);
619  anElectron.setPFCandidateRef(pfRef);
620  break;
621  }
622  }
623  } else if (valMapPresent) {
624  // use value map if PF collection not available
625  const edm::ValueMap<reco::PFCandidatePtr>& myValMap(*ValMapH);
626  // Get the PFCandidate
627  const reco::PFCandidatePtr& pfElePtr(myValMap[elecsRef]);
628  pfId = pfElePtr.isNonnull();
629  }
630  // set PFId function
631  anElectron.setIsPF(pfId);
632 
633  // add resolution info
634 
635  // Isolation
636  if (isolator_.enabled()) {
637  isolator_.fill(*electrons, idx, isolatorTmpStorage_);
638  typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
639  // better to loop backwards, so the vector is resized less times
640  for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(),
641  ed = isolatorTmpStorage_.rend();
642  it != ed;
643  ++it) {
644  anElectron.setIsolation(it->first, it->second);
645  }
646  }
647 
648  for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
649  anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[elecsRef]);
650  }
651 
652  // add electron ID info
653  if (addElecID_) {
654  for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
655  ids[i].second = (*idhandles[i])[elecsRef];
656  }
657  anElectron.setElectronIDs(ids);
658  }
659 
660  if (useUserData_) {
661  userDataHelper_.add(anElectron, iEvent, iSetup);
662  }
663 
664  double ip3d = -999; //for mva variable
665 
666  // embed high level selection
667  if (embedHighLevelSelection_) {
668  // get the global track
669  reco::GsfTrackRef track = itElectron->gsfTrack();
670 
671  // Make sure the collection it points to is there
672  if (track.isNonnull() && track.isAvailable()) {
673  reco::TransientTrack tt = trackBuilder->build(track);
674  embedHighLevel(anElectron, track, tt, primaryVertex, primaryVertexIsValid, beamSpot, beamSpotIsValid);
675 
676  std::pair<bool, Measurement1D> ip3dpv = IPTools::absoluteImpactParameter3D(tt, primaryVertex);
677  ip3d = ip3dpv.second.value(); // for mva variable
678  }
679  }
680 
681  if (addMVAVariables_) {
682  // add mva variables
683  std::vector<float> vCov = lazyTools.localCovariances(*(itElectron->superCluster()->seed()));
684  anElectron.setMvaVariables(vCov[1], ip3d);
685  }
686 
687  // PFCluster Isolation
688  if (addPFClusterIso_) {
689  // Get PFCluster Isolation
690  edm::Handle<edm::ValueMap<float>> ecalPFClusterIsoMapH;
691  iEvent.getByToken(ecalPFClusterIsoT_, ecalPFClusterIsoMapH);
692  edm::Handle<edm::ValueMap<float>> hcalPFClusterIsoMapH;
693  iEvent.getByToken(hcalPFClusterIsoT_, hcalPFClusterIsoMapH);
694  reco::GsfElectron::PflowIsolationVariables newPFIsol = anElectron.pfIsolationVariables();
695  newPFIsol.sumEcalClusterEt = (*ecalPFClusterIsoMapH)[elecsRef];
696  newPFIsol.sumHcalClusterEt = (*hcalPFClusterIsoMapH)[elecsRef];
697  anElectron.setPfIsolationVariables(newPFIsol);
698  }
699 
700  if (addPuppiIsolation_) {
701  anElectron.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[elePtr],
702  (*PUPPIIsolation_neutral_hadrons)[elePtr],
703  (*PUPPIIsolation_photons)[elePtr]);
704  anElectron.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[elePtr],
705  (*PUPPINoLeptonsIsolation_neutral_hadrons)[elePtr],
706  (*PUPPINoLeptonsIsolation_photons)[elePtr]);
707  } else {
708  anElectron.setIsolationPUPPI(-999., -999., -999.);
709  anElectron.setIsolationPUPPINoLeptons(-999., -999., -999.);
710  }
711 
712  std::vector<DetId> selectedCells;
713  bool barrel = itElectron->isEB();
714  //loop over sub clusters
715  if (embedBasicClusters_) {
716  for (reco::CaloCluster_iterator clusIt = itElectron->superCluster()->clustersBegin();
717  clusIt != itElectron->superCluster()->clustersEnd();
718  ++clusIt) {
719  //get seed (max energy xtal)
720  DetId seed = lazyTools.getMaximum(**clusIt).first;
721  //get all xtals in 5x5 window around the seed
722  std::vector<DetId> dets5x5 =
723  (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
724  : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
725  selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
726 
727  //get all xtals belonging to cluster
728  for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
729  selectedCells.push_back(hit.first);
730  }
731  }
732  }
733 
734  if (embedPflowBasicClusters_ && itElectron->parentSuperCluster().isNonnull()) {
735  for (reco::CaloCluster_iterator clusIt = itElectron->parentSuperCluster()->clustersBegin();
736  clusIt != itElectron->parentSuperCluster()->clustersEnd();
737  ++clusIt) {
738  //get seed (max energy xtal)
739  DetId seed = lazyTools.getMaximum(**clusIt).first;
740  //get all xtals in 5x5 window around the seed
741  std::vector<DetId> dets5x5 =
742  (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
743  : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
744  selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
745 
746  //get all xtals belonging to cluster
747  for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
748  selectedCells.push_back(hit.first);
749  }
750  }
751  }
752 
753  //remove duplicates
754  std::sort(selectedCells.begin(), selectedCells.end());
755  std::unique(selectedCells.begin(), selectedCells.end());
756 
757  // Retrieve the corresponding RecHits
758 
759  edm::Handle<EcalRecHitCollection> rechitsH;
760  if (barrel)
761  iEvent.getByToken(reducedBarrelRecHitCollectionToken_, rechitsH);
762  else
763  iEvent.getByToken(reducedEndcapRecHitCollectionToken_, rechitsH);
764 
765  EcalRecHitCollection selectedRecHits;
766  const EcalRecHitCollection* recHits = rechitsH.product();
767 
768  unsigned nSelectedCells = selectedCells.size();
769  for (unsigned icell = 0; icell < nSelectedCells; ++icell) {
770  EcalRecHitCollection::const_iterator it = recHits->find(selectedCells[icell]);
771  if (it != recHits->end()) {
772  selectedRecHits.push_back(*it);
773  }
774  }
775  selectedRecHits.sort();
776  if (embedRecHits_)
777  anElectron.embedRecHits(&selectedRecHits);
778 
779  // set conversion veto selection
780  bool passconversionveto = false;
781  if (hConversions.isValid()) {
782  // this is recommended method
783  passconversionveto =
784  !ConversionTools::hasMatchedConversion(*itElectron, *hConversions, beamSpotHandle->position());
785  } else {
786  // use missing hits without vertex fit method
787  passconversionveto =
788  itElectron->gsfTrack()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) < 1;
789  }
790  anElectron.setPassConversionVeto(passconversionveto);
791 
792  // add sel to selected
793  fillElectron(
794  anElectron, elecsRef, elecBaseRef, genMatches, deposits, pfId, isolationValues, isolationValuesNoPFId);
795 
796  if (computeMiniIso_)
797  setElectronMiniIso(anElectron, pc.product());
798 
799  patElectrons->push_back(anElectron);
800  }
801  }
802 
803  // sort electrons in pt
804  std::sort(patElectrons->begin(), patElectrons->end(), pTComparator_);
805 
806  // add the electrons to the event output
807  std::unique_ptr<std::vector<Electron>> ptr(patElectrons);
808  iEvent.put(std::move(ptr));
809 
810  // clean up
811  if (isolator_.enabled())
812  isolator_.endEvent();
813 }

References IPTools::absoluteImpactParameter3D(), pat::PATUserDataHelper< ObjectType >::add(), addElecID_, addGenMatch_, addMVAVariables_, addPFClusterIso_, addPuppiIsolation_, Reference_intrackfit_cff::barrel, beamLineToken_, pwdgSkimBPark_cfi::beamSpot, pat::helper::MultiIsolator::beginEvent(), electrons_cff::bool, TransientTrackBuilder::build(), computeMiniIso_, CandIsolatorFromDeposits_cfi::deposits, reco::PFCandidate::e, DetId::Ecal, EcalBarrel, EcalEndcap, ecalPFClusterIsoT_, ecalTopology_, 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_, edm::EventSetup::get(), get, CaloTopology::getSubdetectorTopology(), CaloSubdetectorTopology::getWindow(), ConversionTools::hasMatchedConversion(), hcalPFClusterIsoT_, hConversionsToken_, mps_fire::i, training_settings::idx, iEvent, electrons_cff::ip3d, edm::Ptr< T >::isNonnull(), isoDepositLabels_, isoDepositTokens_, isolationValueNoPFIdTokens_, electronProducer_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_, SurveyInfoScenario_cff::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(), edm::SortedCollection< T, SORT >::sort(), reco::GsfElectron::PflowIsolationVariables::sumEcalClusterEt, reco::GsfElectron::PflowIsolationVariables::sumHcalClusterEt, HLT_2018_cff::track, groupFilesInBlocks::tt, tier0::unique(), useParticleFlow_, usePfCandidateMultiMap_, userDataHelper_, and useUserData_.

◆ 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 196 of file PATElectronProducer.h.

199  {
200  labels.clear();
201 
202  if (iConfig.exists(psetName)) {
203  edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>(psetName);
204 
205  if (depconf.exists("tracker"))
206  labels.push_back(std::make_pair(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker")));
207  if (depconf.exists("ecal"))
208  labels.push_back(std::make_pair(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal")));
209  if (depconf.exists("hcal"))
210  labels.push_back(std::make_pair(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal")));
211  if (depconf.exists("pfAllParticles")) {
212  labels.push_back(std::make_pair(pat::PfAllParticleIso, depconf.getParameter<edm::InputTag>("pfAllParticles")));
213  }
214  if (depconf.exists("pfChargedHadrons")) {
215  labels.push_back(
216  std::make_pair(pat::PfChargedHadronIso, depconf.getParameter<edm::InputTag>("pfChargedHadrons")));
217  }
218  if (depconf.exists("pfChargedAll")) {
219  labels.push_back(std::make_pair(pat::PfChargedAllIso, depconf.getParameter<edm::InputTag>("pfChargedAll")));
220  }
221  if (depconf.exists("pfPUChargedHadrons")) {
222  labels.push_back(
223  std::make_pair(pat::PfPUChargedHadronIso, depconf.getParameter<edm::InputTag>("pfPUChargedHadrons")));
224  }
225  if (depconf.exists("pfNeutralHadrons")) {
226  labels.push_back(
227  std::make_pair(pat::PfNeutralHadronIso, depconf.getParameter<edm::InputTag>("pfNeutralHadrons")));
228  }
229  if (depconf.exists("pfPhotons")) {
230  labels.push_back(std::make_pair(pat::PfGammaIso, depconf.getParameter<edm::InputTag>("pfPhotons")));
231  }
232  if (depconf.exists("user")) {
233  std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
234  std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
235  int key = pat::IsolationKeys::UserBaseIso;
236  for (; it != ed; ++it, ++key) {
237  labels.push_back(std::make_pair(pat::IsolationKeys(key), *it));
238  }
239  }
240  }
241  tokens = edm::vector_transform(
242  labels, [this](IsolationLabel const& label) { return consumes<edm::ValueMap<T> >(label.second); });
243 }

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, pat::TrackIso, pat::UserBaseIso, and edm::vector_transform().

Referenced by PATElectronProducer().

◆ setElectronMiniIso()

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

Definition at line 990 of file PATElectronProducer.cc.

990  {
991  pat::PFIsolation miniiso;
992  if (anElectron.isEE())
993  miniiso = pat::getMiniPFIsolation(pc,
994  anElectron.polarP4(),
995  miniIsoParamsE_[0],
996  miniIsoParamsE_[1],
997  miniIsoParamsE_[2],
998  miniIsoParamsE_[3],
999  miniIsoParamsE_[4],
1000  miniIsoParamsE_[5],
1001  miniIsoParamsE_[6],
1002  miniIsoParamsE_[7],
1003  miniIsoParamsE_[8]);
1004  else
1005  miniiso = pat::getMiniPFIsolation(pc,
1006  anElectron.polarP4(),
1007  miniIsoParamsB_[0],
1008  miniIsoParamsB_[1],
1009  miniIsoParamsB_[2],
1010  miniIsoParamsB_[3],
1011  miniIsoParamsB_[4],
1012  miniIsoParamsB_[5],
1013  miniIsoParamsB_[6],
1014  miniIsoParamsB_[7],
1015  miniIsoParamsB_[8]);
1016  anElectron.setMiniPFIsolation(miniiso);
1017 }

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

Referenced by produce().

Member Data Documentation

◆ addEfficiencies_

const bool pat::PATElectronProducer::addEfficiencies_
private

Definition at line 174 of file PATElectronProducer.h.

Referenced by PATElectronProducer().

◆ addElecID_

const bool pat::PATElectronProducer::addElecID_
private

Definition at line 157 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ addGenMatch_

bool pat::PATElectronProducer::addGenMatch_
private

Definition at line 73 of file PATElectronProducer.h.

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

◆ addMVAVariables_

const bool pat::PATElectronProducer::addMVAVariables_
private

mva input variables

Definition at line 95 of file PATElectronProducer.h.

Referenced by produce().

◆ addPFClusterIso_

const bool pat::PATElectronProducer::addPFClusterIso_
private

Definition at line 101 of file PATElectronProducer.h.

Referenced by produce().

◆ addPuppiIsolation_

const bool pat::PATElectronProducer::addPuppiIsolation_
private

Definition at line 102 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ addResolutions_

const bool pat::PATElectronProducer::addResolutions_
private

Definition at line 177 of file PATElectronProducer.h.

Referenced by PATElectronProducer().

◆ beamLineToken_

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

Definition at line 108 of file PATElectronProducer.h.

Referenced by produce().

◆ computeMiniIso_

bool pat::PATElectronProducer::computeMiniIso_
private

Definition at line 78 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ ecalPFClusterIsoT_

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

Definition at line 103 of file PATElectronProducer.h.

Referenced by produce().

◆ ecalTopology_

const CaloTopology* pat::PATElectronProducer::ecalTopology_
private

Definition at line 191 of file PATElectronProducer.h.

Referenced by produce().

◆ efficiencyLoader_

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

Definition at line 175 of file PATElectronProducer.h.

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

◆ elecIDSrcs_

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

Definition at line 159 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ elecIDTokens_

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

Definition at line 160 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ electronToken_

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

Definition at line 61 of file PATElectronProducer.h.

Referenced by produce().

◆ embedBasicClusters_

const bool pat::PATElectronProducer::embedBasicClusters_
private

Definition at line 68 of file PATElectronProducer.h.

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

◆ embedGenMatch_

bool pat::PATElectronProducer::embedGenMatch_
private

Definition at line 74 of file PATElectronProducer.h.

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

◆ embedGsfElectronCore_

const bool pat::PATElectronProducer::embedGsfElectronCore_
private

Definition at line 63 of file PATElectronProducer.h.

Referenced by fillElectron(), and fillElectron2().

◆ embedGsfTrack_

const bool pat::PATElectronProducer::embedGsfTrack_
private

Definition at line 64 of file PATElectronProducer.h.

Referenced by fillElectron(), and fillElectron2().

◆ embedHighLevelSelection_

const bool pat::PATElectronProducer::embedHighLevelSelection_
private

embed high level selection variables?

Definition at line 107 of file PATElectronProducer.h.

Referenced by produce().

◆ embedPFCandidate_

const bool pat::PATElectronProducer::embedPFCandidate_
private

Definition at line 92 of file PATElectronProducer.h.

Referenced by produce().

◆ embedPflowBasicClusters_

const bool pat::PATElectronProducer::embedPflowBasicClusters_
private

Definition at line 70 of file PATElectronProducer.h.

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

◆ embedPflowPreshowerClusters_

const bool pat::PATElectronProducer::embedPflowPreshowerClusters_
private

Definition at line 71 of file PATElectronProducer.h.

Referenced by fillElectron(), and fillElectron2().

◆ embedPflowSuperCluster_

const bool pat::PATElectronProducer::embedPflowSuperCluster_
private

Definition at line 66 of file PATElectronProducer.h.

Referenced by fillElectron(), and fillElectron2().

◆ embedPreshowerClusters_

const bool pat::PATElectronProducer::embedPreshowerClusters_
private

Definition at line 69 of file PATElectronProducer.h.

Referenced by fillElectron(), and fillElectron2().

◆ embedRecHits_

const bool pat::PATElectronProducer::embedRecHits_
private

Definition at line 75 of file PATElectronProducer.h.

Referenced by produce().

◆ embedSeedCluster_

const bool pat::PATElectronProducer::embedSeedCluster_
private

Definition at line 67 of file PATElectronProducer.h.

Referenced by fillElectron(), and fillElectron2().

◆ embedSuperCluster_

const bool pat::PATElectronProducer::embedSuperCluster_
private

Definition at line 65 of file PATElectronProducer.h.

Referenced by fillElectron(), and fillElectron2().

◆ embedTrack_

const bool pat::PATElectronProducer::embedTrack_
private

Definition at line 72 of file PATElectronProducer.h.

Referenced by fillElectron(), and fillElectron2().

◆ genMatchTokens_

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

Definition at line 84 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ hcalPFClusterIsoT_

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

Definition at line 104 of file PATElectronProducer.h.

Referenced by produce().

◆ hConversionsToken_

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

Definition at line 62 of file PATElectronProducer.h.

Referenced by produce().

◆ isoDepositLabels_

IsolationLabels pat::PATElectronProducer::isoDepositLabels_
private

Definition at line 167 of file PATElectronProducer.h.

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

◆ isoDepositTokens_

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

Definition at line 168 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ isolationValueLabels_

IsolationLabels pat::PATElectronProducer::isolationValueLabels_
private

Definition at line 169 of file PATElectronProducer.h.

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

◆ isolationValueLabelsNoPFId_

IsolationLabels pat::PATElectronProducer::isolationValueLabelsNoPFId_
private

Definition at line 171 of file PATElectronProducer.h.

Referenced by fillElectron(), and PATElectronProducer().

◆ isolationValueNoPFIdTokens_

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

Definition at line 172 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ isolationValueTokens_

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

Definition at line 170 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ isolator_

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

Definition at line 165 of file PATElectronProducer.h.

Referenced by produce().

◆ isolatorTmpStorage_

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

Definition at line 166 of file PATElectronProducer.h.

Referenced by produce().

◆ miniIsoParamsB_

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

Definition at line 80 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and setElectronMiniIso().

◆ miniIsoParamsE_

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

Definition at line 79 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and setElectronMiniIso().

◆ pcToken_

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

Definition at line 77 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ pfCandidateMapToken_

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

Definition at line 90 of file PATElectronProducer.h.

Referenced by produce().

◆ pfCandidateMultiMapToken_

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

Definition at line 91 of file PATElectronProducer.h.

Referenced by produce().

◆ pfElecToken_

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

Definition at line 89 of file PATElectronProducer.h.

Referenced by produce().

◆ pTComparator_

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

Definition at line 163 of file PATElectronProducer.h.

Referenced by produce().

◆ PUPPIIsolation_charged_hadrons_

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

Definition at line 182 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ PUPPIIsolation_neutral_hadrons_

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

Definition at line 183 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ PUPPIIsolation_photons_

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

Definition at line 184 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ PUPPINoLeptonsIsolation_charged_hadrons_

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

Definition at line 186 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ PUPPINoLeptonsIsolation_neutral_hadrons_

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

Definition at line 187 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ PUPPINoLeptonsIsolation_photons_

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

Definition at line 188 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ pvToken_

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

Definition at line 109 of file PATElectronProducer.h.

Referenced by produce().

◆ reducedBarrelRecHitCollection_

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

Definition at line 96 of file PATElectronProducer.h.

◆ reducedBarrelRecHitCollectionToken_

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

Definition at line 97 of file PATElectronProducer.h.

Referenced by produce().

◆ reducedEndcapRecHitCollection_

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

Definition at line 98 of file PATElectronProducer.h.

◆ reducedEndcapRecHitCollectionToken_

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

Definition at line 99 of file PATElectronProducer.h.

Referenced by produce().

◆ resolutionLoader_

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

Definition at line 178 of file PATElectronProducer.h.

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

◆ useParticleFlow_

const bool pat::PATElectronProducer::useParticleFlow_
private

pflow specific

Definition at line 87 of file PATElectronProducer.h.

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

◆ usePfCandidateMultiMap_

const bool pat::PATElectronProducer::usePfCandidateMultiMap_
private

Definition at line 88 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ userDataHelper_

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

Definition at line 189 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

◆ useUserData_

const bool pat::PATElectronProducer::useUserData_
private

Definition at line 180 of file PATElectronProducer.h.

Referenced by PATElectronProducer(), and produce().

SummaryClient_cfi.labels
labels
Definition: SummaryClient_cfi.py:61
reco::GsfElectron::isEE
bool isEE() const
Definition: GsfElectron.h:337
pat::PATElectronProducer::isolatorTmpStorage_
pat::helper::MultiIsolator::IsolationValuePairs isolatorTmpStorage_
Definition: PATElectronProducer.h:166
pat::Electron::embedTrack
void embedTrack()
method to store the electron's Track internally
pat::PATElectronProducer::isolationValueNoPFIdTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< double > > > isolationValueNoPFIdTokens_
Definition: PATElectronProducer.h:172
electrons_cff.bool
bool
Definition: electrons_cff.py:372
pat::PATUserDataHelper
Assists in assimilating all pat::UserData into pat objects.
Definition: PATUserDataHelper.h:49
edm::SortedCollection::sort
void sort()
Definition: SortedCollection.h:302
mps_fire.i
i
Definition: mps_fire.py:355
pat::EcalIso
Definition: Isolation.h:11
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
pat::PATElectronProducer::embedGsfTrack_
const bool embedGsfTrack_
Definition: PATElectronProducer.h:64
edm::SortedCollection< EcalRecHit >::const_iterator
std::vector< EcalRecHit >::const_iterator const_iterator
Definition: SortedCollection.h:80
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
pat::PATElectronProducer::elecIDSrcs_
std::vector< NameTag > elecIDSrcs_
Definition: PATElectronProducer.h:159
pat::PATElectronProducer::genMatchTokens_
std::vector< edm::EDGetTokenT< edm::Association< reco::GenParticleCollection > > > genMatchTokens_
Definition: PATElectronProducer.h:84
Reference_intrackfit_cff.barrel
list barrel
Definition: Reference_intrackfit_cff.py:37
pat::PATElectronProducer::addPFClusterIso_
const bool addPFClusterIso_
Definition: PATElectronProducer.h:101
pat::Electron::PV2D
Definition: Electron.h:190
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
edm::Handle::product
T const * product() const
Definition: Handle.h:70
electronProducer_cff.isolationValues
isolationValues
Definition: electronProducer_cff.py:26
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:1196
pat::PATElectronProducer::IsolationLabel
std::pair< pat::IsolationKeys, edm::InputTag > IsolationLabel
Definition: PATElectronProducer.h:146
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:911
pat::PATElectronProducer::PUPPINoLeptonsIsolation_photons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_photons_
Definition: PATElectronProducer.h:188
reco::PFCandidate::e
Definition: PFCandidate.h:46
groupFilesInBlocks.tt
int tt
Definition: groupFilesInBlocks.py:144
pat::Electron::embedSeedCluster
void embedSeedCluster()
method to store the electron's seedcluster internally
pat::Electron::embedPreshowerClusters
void embedPreshowerClusters()
method to store the electron's preshower clusters
pat::helper::EfficiencyLoader
Definition: EfficiencyLoader.h:16
pat::PATElectronProducer::setElectronMiniIso
void setElectronMiniIso(pat::Electron &anElectron, const pat::PackedCandidateCollection *pc)
Definition: PATElectronProducer.cc:990
pat::PATElectronProducer::resolutionLoader_
pat::helper::KinResolutionsLoader resolutionLoader_
Definition: PATElectronProducer.h:178
pat::PATElectronProducer::isolationValueLabels_
IsolationLabels isolationValueLabels_
Definition: PATElectronProducer.h:169
edm::EDGetTokenT< reco::PFCandidateCollection >
Electron
Definition: Electron.py:1
edm::Ref::isNull
bool isNull() const
Checks for null.
Definition: Ref.h:235
pat::helper::MultiIsolator::fill
void fill(const edm::View< T > &coll, int idx, IsolationValuePairs &isolations) const
Definition: MultiIsolator.h:84
pat::PATElectronProducer::embedRecHits_
const bool embedRecHits_
Definition: PATElectronProducer.h:75
IPTools::absoluteImpactParameter3D
std::pair< bool, Measurement1D > absoluteImpactParameter3D(const reco::TransientTrack &transientTrack, const reco::Vertex &vertex)
Definition: IPTools.cc:38
pat::PATUserDataHelper::fillDescription
static void fillDescription(edm::ParameterSetDescription &iDesc)
Definition: PATUserDataHelper.h:135
pat::PATElectronProducer::pvToken_
const edm::EDGetTokenT< std::vector< reco::Vertex > > pvToken_
Definition: PATElectronProducer.h:109
reco::GsfElectron::PflowIsolationVariables
Definition: GsfElectron.h:606
pat::Electron::embedGsfElectronCore
void embedGsfElectronCore()
method to store the electron's core internally
pat::Electron::setEcalDrivenMomentum
void setEcalDrivenMomentum(const Candidate::LorentzVector &mom)
Definition: Electron.h:204
reco::PFCandidateConstIterator
PFCandidateCollection::const_iterator PFCandidateConstIterator
iterator
Definition: PFCandidateFwd.h:18
pat::PATElectronProducer::elecIDTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< float > > > elecIDTokens_
Definition: PATElectronProducer.h:160
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
pat::Lepton::setIsolation
void setIsolation(IsolationKeys key, float value)
Definition: Lepton.h:115
pat::helper::EfficiencyLoader::enabled
bool enabled() const
'true' if this there is at least one efficiency configured
Definition: EfficiencyLoader.h:25
pat::Electron::BS2D
Definition: Electron.h:190
cms::cuda::assert
assert(be >=bs)
edm::PtrVectorItr
Definition: PtrVector.h:51
edm::SortedCollection< EcalRecHit >
pat::PATElectronProducer::embedPflowBasicClusters_
const bool embedPflowBasicClusters_
Definition: PATElectronProducer.h:70
electronProducer_cff.isolationValuesNoPFId
isolationValuesNoPFId
Definition: electronProducer_cff.py:34
pat::PATObject::addGenParticleRef
void addGenParticleRef(const reco::GenParticleRef &ref)
Definition: PATObject.h:756
pat::PfAllParticleIso
Definition: Isolation.h:13
pat::PATElectronProducer::embedHighLevelSelection_
const bool embedHighLevelSelection_
embed high level selection variables?
Definition: PATElectronProducer.h:107
pat::PATElectronProducer::IsoDepositMaps
std::vector< edm::Handle< edm::ValueMap< IsoDeposit > > > IsoDepositMaps
Definition: PATElectronProducer.h:112
CaloTopologyRecord
Definition: CaloTopologyRecord.h:10
pat::PATElectronProducer::userDataHelper_
pat::PATUserDataHelper< pat::Electron > userDataHelper_
Definition: PATElectronProducer.h:189
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:160
pat::PATElectronProducer::PUPPINoLeptonsIsolation_charged_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_charged_hadrons_
Definition: PATElectronProducer.h:186
pat::PATElectronProducer::addEfficiencies_
const bool addEfficiencies_
Definition: PATElectronProducer.h:174
GlobalVector
Global3DVector GlobalVector
Definition: GlobalVector.h:10
pat::PATElectronProducer::isolationValueLabelsNoPFId_
IsolationLabels isolationValueLabelsNoPFId_
Definition: PATElectronProducer.h:171
IPTools::signedTransverseImpactParameter
std::pair< bool, Measurement1D > signedTransverseImpactParameter(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:57
pat::Electron::embedPflowBasicClusters
void embedPflowBasicClusters()
method to store the electron's pflow basic clusters
pat::PATElectronProducer::embedGenMatch_
bool embedGenMatch_
Definition: PATElectronProducer.h:74
pat::PATElectronProducer::NameTag
std::pair< std::string, edm::InputTag > NameTag
Definition: PATElectronProducer.h:158
edm::Handle
Definition: AssociativeIterator.h:50
training_settings.idx
idx
Definition: training_settings.py:16
edm::ParameterSetDescription::addOptional
ParameterDescriptionBase * addOptional(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:105
pat::Electron::pfCandidateRef
reco::PFCandidateRef pfCandidateRef() const
reference to the source PFCandidates; null if this has been built from a standard electron
edm::SortedCollection::push_back
void push_back(T const &t)
Definition: SortedCollection.h:188
dqmdumpme.first
first
Definition: dqmdumpme.py:55
pat::Electron::embedPflowSuperCluster
void embedPflowSuperCluster()
method to store the electron's PflowSuperCluster internally
pat::helper::MultiIsolator::IsolationValuePairs
std::vector< std::pair< pat::IsolationKeys, float > > IsolationValuePairs
Definition: MultiIsolator.h:17
EcalBarrel
Definition: EcalSubdetector.h:10
pat::helper::KinResolutionsLoader::enabled
bool enabled() const
'true' if this there is at least one efficiency configured
Definition: KinResolutionsLoader.h:27
pat::Electron::embedGsfTrack
void embedGsfTrack()
method to store the electron's GsfTrack internally
pat::PATElectronProducer::useUserData_
const bool useUserData_
Definition: PATElectronProducer.h:180
pat::PATElectronProducer::embedPreshowerClusters_
const bool embedPreshowerClusters_
Definition: PATElectronProducer.h:69
pat::PATElectronProducer::pTComparator_
const GreaterByPt< Electron > pTComparator_
Definition: PATElectronProducer.h:163
pat::Electron::BS3D
Definition: Electron.h:190
pat::PATElectronProducer::pfCandidateMapToken_
const edm::EDGetTokenT< edm::ValueMap< reco::PFCandidatePtr > > pfCandidateMapToken_
Definition: PATElectronProducer.h:90
pat::helper::MultiIsolator::enabled
bool enabled() const
True if it has a non null configuration.
Definition: MultiIsolator.h:55
edm::Ref< GenParticleCollection >
pat::PATElectronProducer::pfElecToken_
const edm::EDGetTokenT< reco::PFCandidateCollection > pfElecToken_
Definition: PATElectronProducer.h:89
pat::PATElectronProducer::embedPflowSuperCluster_
const bool embedPflowSuperCluster_
Definition: PATElectronProducer.h:66
pat::helper::MultiIsolator::endEvent
void endEvent()
Definition: MultiIsolator.cc:85
pat::PATElectronProducer::embedSeedCluster_
const bool embedSeedCluster_
Definition: PATElectronProducer.h:67
pat::Electron::setDB
void setDB(double dB, double edB, IPTYPE type)
Set impact parameter of a certain type and its uncertainty.
BeamMonitor_cff.primaryVertex
primaryVertex
hltOfflineBeamSpot for HLTMON
Definition: BeamMonitor_cff.py:7
DetId
Definition: DetId.h:17
electronIdMVAProducer_cfi.reducedEBRecHitCollection
reducedEBRecHitCollection
Definition: electronIdMVAProducer_cfi.py:7
reco::GsfElectron::setP4
void setP4(P4Kind kind, const LorentzVector &p4, float p4Error, bool setCandidate)
Definition: GsfElectron.cc:188
pat::PATElectronProducer::usePfCandidateMultiMap_
const bool usePfCandidateMultiMap_
Definition: PATElectronProducer.h:88
edm::EventSetup::get
T get() const
Definition: EventSetup.h:73
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
pat::PATElectronProducer::pfCandidateMultiMapToken_
const edm::EDGetTokenT< edm::ValueMap< std::vector< reco::PFCandidateRef > > > pfCandidateMultiMapToken_
Definition: PATElectronProducer.h:91
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
pat::PATElectronProducer::isoDepositTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > > isoDepositTokens_
Definition: PATElectronProducer.h:168
pat::PATElectronProducer::isolationValueTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< double > > > isolationValueTokens_
Definition: PATElectronProducer.h:170
pat::Electron::embedPflowPreshowerClusters
void embedPflowPreshowerClusters()
method to store the electron's pflow preshower clusters
names
const std::string names[nVars_]
Definition: PhotonIDValueMapProducer.cc:122
GlobalPosition_Frontier_DevDB_cff.tag
tag
Definition: GlobalPosition_Frontier_DevDB_cff.py:11
pat::PfChargedHadronIso
Definition: Isolation.h:14
IPTools::signedImpactParameter3D
std::pair< bool, Measurement1D > signedImpactParameter3D(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:81
pat::PATUserDataHelper::add
void add(ObjectType &patObject, edm::Event const &iEvent, edm::EventSetup const &iSetup)
Definition: PATUserDataHelper.h:114
electronIdMVAProducer_cfi.reducedEERecHitCollection
reducedEERecHitCollection
Definition: electronIdMVAProducer_cfi.py:8
pat::PATElectronProducer::embedBasicClusters_
const bool embedBasicClusters_
Definition: PATElectronProducer.h:68
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
pat::PATElectronProducer::embedGsfElectronCore_
const bool embedGsfElectronCore_
Definition: PATElectronProducer.h:63
pat::Electron::PV3D
Definition: Electron.h:190
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:184
reco::BeamSpot
Definition: BeamSpot.h:21
TransientTrackRecord
Definition: TransientTrackRecord.h:11
source
static const std::string source
Definition: EdmProvDump.cc:47
pat::helper::KinResolutionsLoader
Definition: KinResolutionsLoader.h:18
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
edm::ESHandle< CaloTopology >
pat::PATElectronProducer::reducedEndcapRecHitCollection_
const edm::InputTag reducedEndcapRecHitCollection_
Definition: PATElectronProducer.h:98
beamspot
Definition: BeamSpotWrite2Txt.h:8
pat::Electron::embedBasicClusters
void embedBasicClusters()
method to store the electron's basic clusters
reco::BeamSpot::position
const Point & position() const
position
Definition: BeamSpot.h:59
EcalClusterLazyTools
pat::Electron::embedSuperCluster
void embedSuperCluster()
method to store the electron's SuperCluster internally
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
EcalEndcap
Definition: EcalSubdetector.h:10
FastTrackerRecHitMaskProducer_cfi.recHits
recHits
Definition: FastTrackerRecHitMaskProducer_cfi.py:8
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:49
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:674
edm::View
Definition: CaloClusterFwd.h:14
pat::PATElectronProducer::PUPPIIsolation_charged_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_charged_hadrons_
Definition: PATElectronProducer.h:182
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
pat::PATElectronProducer::hcalPFClusterIsoT_
const edm::EDGetTokenT< edm::ValueMap< float > > hcalPFClusterIsoT_
Definition: PATElectronProducer.h:104
edm::ParameterSet
Definition: ParameterSet.h:36
edm::ParameterSetDescription::setComment
void setComment(std::string const &value)
Definition: ParameterSetDescription.cc:33
edm::LogError
Definition: MessageLogger.h:183
edm::Ptr::id
ProductID id() const
Accessor for product ID.
Definition: Ptr.h:158
pat::PfGammaIso
Definition: Isolation.h:16
electronIsolatorFromEffectiveArea_cfi.pfElectrons
pfElectrons
Definition: electronIsolatorFromEffectiveArea_cfi.py:5
pat::helper::KinResolutionsLoader::fillDescription
static void fillDescription(edm::ParameterSetDescription &iDesc)
Method for documentation and validation of PSet.
Definition: KinResolutionsLoader.cc:34
CaloTopology::getSubdetectorTopology
const CaloSubdetectorTopology * getSubdetectorTopology(const DetId &id) const
access the subdetector Topology for the given subdetector directly
Definition: CaloTopology.cc:17
pat::UserBaseIso
Definition: Isolation.h:22
pat::PATElectronProducer::embedSuperCluster_
const bool embedSuperCluster_
Definition: PATElectronProducer.h:65
pat::PATElectronProducer::reducedBarrelRecHitCollection_
const edm::InputTag reducedBarrelRecHitCollection_
Definition: PATElectronProducer.h:96
edm::ParameterSetDescription::ifValue
ParameterDescriptionNode * ifValue(ParameterDescription< T > const &switchParameter, std::unique_ptr< ParameterDescriptionCases< T >> cases)
Definition: ParameterSetDescription.h:220
pat::TrackIso
Definition: Isolation.h:10
electrons_cff.ip3d
ip3d
Definition: electrons_cff.py:363
pat::PATElectronProducer::reducedEndcapRecHitCollectionToken_
const edm::EDGetTokenT< EcalRecHitCollection > reducedEndcapRecHitCollectionToken_
Definition: PATElectronProducer.h:99
pat::PATElectronProducer::embedPflowPreshowerClusters_
const bool embedPflowPreshowerClusters_
Definition: PATElectronProducer.h:71
edm::ParameterSet::getParameterNamesForType
std::vector< std::string > getParameterNamesForType(bool trackiness=true) const
Definition: ParameterSet.h:168
iEvent
int iEvent
Definition: GenABIO.cc:224
pat::HcalIso
Definition: Isolation.h:12
pat::PATElectronProducer::addElecID_
const bool addElecID_
Definition: PATElectronProducer.h:157
pat::PATElectronProducer::electronToken_
const edm::EDGetTokenT< edm::View< reco::GsfElectron > > electronToken_
Definition: PATElectronProducer.h:61
pat::PfNeutralHadronIso
Definition: Isolation.h:15
pat::Lepton::setMiniPFIsolation
void setMiniPFIsolation(PFIsolation const &iso)
Definition: Lepton.h:217
pat::PfChargedAllIso
Definition: Isolation.h:25
pat::PATElectronProducer::ecalTopology_
const CaloTopology * ecalTopology_
Definition: PATElectronProducer.h:191
edm::Association
Definition: Association.h:18
edm::ParameterSetDescription::addNode
ParameterDescriptionNode * addNode(ParameterDescriptionNode const &node)
Definition: ParameterSetDescription.cc:41
pat::PATElectronProducer::embedPFCandidate_
const bool embedPFCandidate_
Definition: PATElectronProducer.h:92
edm::contains
bool contains(EventRange const &lh, EventID const &rh)
Definition: EventRange.cc:37
edm::ParameterSetDescription::setAllowAnything
void setAllowAnything()
allow any parameter label/value pairs
Definition: ParameterSetDescription.cc:37
DetId::Ecal
Definition: DetId.h:27
pat::PATElectronProducer::hConversionsToken_
const edm::EDGetTokenT< reco::ConversionCollection > hConversionsToken_
Definition: PATElectronProducer.h:62
get
#define get
pat::PfPUChargedHadronIso
Definition: Isolation.h:24
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
reco::GsfElectron::p4
const LorentzVector & p4(P4Kind kind) const
Definition: GsfElectron.cc:211
pat::PATElectronProducer::PUPPIIsolation_photons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_photons_
Definition: PATElectronProducer.h:184
pat::PATElectronProducer::addMVAVariables_
const bool addMVAVariables_
mva input variables
Definition: PATElectronProducer.h:95
pat::PATElectronProducer::useParticleFlow_
const bool useParticleFlow_
pflow specific
Definition: PATElectronProducer.h:87
edm::Ptr< Candidate >
pat::PATElectronProducer::addPuppiIsolation_
const bool addPuppiIsolation_
Definition: PATElectronProducer.h:102
pat::PATElectronProducer::isolator_
pat::helper::MultiIsolator isolator_
Definition: PATElectronProducer.h:165
pat::PATElectronProducer::IsolationValueMaps
std::vector< edm::Handle< edm::ValueMap< double > > > IsolationValueMaps
Definition: PATElectronProducer.h:113
reco::TrackBase::Point
math::XYZPoint Point
point in the space
Definition: TrackBase.h:80
CaloSubdetectorTopology::getWindow
virtual std::vector< DetId > getWindow(const DetId &id, const int &northSouthSize, const int &eastWestSize) const
Definition: CaloSubdetectorTopology.cc:4
pat::PFIsolation
Definition: PFIsolation.h:12
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
pat::PATElectronProducer::embedTrack_
const bool embedTrack_
Definition: PATElectronProducer.h:72
reco::Matched
Definition: TrackInfoEnum.h:16
eostools.move
def move(src, dest)
Definition: eostools.py:511
pat::PATElectronProducer::pcToken_
edm::EDGetTokenT< pat::PackedCandidateCollection > pcToken_
Definition: PATElectronProducer.h:77
pat::IsolationKeys
IsolationKeys
Enum defining isolation keys.
Definition: Isolation.h:9
reco::TransientTrack
Definition: TransientTrack.h:19
pat::helper::MultiIsolator::beginEvent
void beginEvent(const edm::Event &event, const edm::EventSetup &eventSetup)
Definition: MultiIsolator.cc:79
tier0.unique
def unique(seq, keepstr=True)
Definition: tier0.py:24
pat::PATElectronProducer::miniIsoParamsB_
std::vector< double > miniIsoParamsB_
Definition: PATElectronProducer.h:80
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
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::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:815
packedPFCandidateRefMixer_cfi.pf
pf
Definition: packedPFCandidateRefMixer_cfi.py:4
pat::PATElectronProducer::addGenMatch_
bool addGenMatch_
Definition: PATElectronProducer.h:73
edm::ValueMap
Definition: ValueMap.h:107
reco::GsfElectron::PflowIsolationVariables::sumHcalClusterEt
float sumHcalClusterEt
Definition: GsfElectron.h:618
Exception
Definition: hltDiff.cc:246
edm::RefVectorIterator
Definition: EDProductfwd.h:33
pat::PATElectronProducer::ecalPFClusterIsoT_
const edm::EDGetTokenT< edm::ValueMap< float > > ecalPFClusterIsoT_
Definition: PATElectronProducer.h:103
reco::HitPattern::MISSING_INNER_HITS
Definition: HitPattern.h:155
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
pat::PATElectronProducer::beamLineToken_
const edm::EDGetTokenT< reco::BeamSpot > beamLineToken_
Definition: PATElectronProducer.h:108
pat::Electron::PVDZ
Definition: Electron.h:190
edm::RefToBase
Definition: AssociativeIterator.h:54
pat::PATElectronProducer::PUPPINoLeptonsIsolation_neutral_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_neutral_hadrons_
Definition: PATElectronProducer.h:187
AlignmentPI::index
index
Definition: AlignmentPayloadInspectorHelper.h:46
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
patElectronEAIsoCorrectionProducer_cfi.patElectrons
patElectrons
Definition: patElectronEAIsoCorrectionProducer_cfi.py:4
TransientTrackBuilder::build
reco::TransientTrack build(const reco::Track *p) const
Definition: TransientTrackBuilder.cc:20
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
pat::PATElectronProducer::GenAssociations
std::vector< edm::Handle< edm::Association< reco::GenParticleCollection > > > GenAssociations
Definition: PATElectronProducer.h:82
electronProducer_cfi.usePfCandidateMultiMap
usePfCandidateMultiMap
Definition: electronProducer_cfi.py:11
mps_fire.result
result
Definition: mps_fire.py:303
reco::LeafCandidate::polarP4
const PolarLorentzVector & polarP4() const final
four-momentum Lorentz vector
Definition: LeafCandidate.h:116
edm::ParameterDescriptionNode::setComment
void setComment(std::string const &value)
Definition: ParameterDescriptionNode.cc:106
pat::PATElectronProducer::isoDepositLabels_
IsolationLabels isoDepositLabels_
Definition: PATElectronProducer.h:167
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
pat::PATObject::embedGenParticle
void embedGenParticle()
Definition: PATObject.h:773
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
crabWrapper.key
key
Definition: crabWrapper.py:19
pat::PATElectronProducer::miniIsoParamsE_
std::vector< double > miniIsoParamsE_
Definition: PATElectronProducer.h:79
edm::EmptyGroupDescription
Definition: EmptyGroupDescription.h:15
edm::ParameterDescription
Definition: ParameterDescription.h:110
CandIsolatorFromDeposits_cfi.deposits
deposits
Definition: CandIsolatorFromDeposits_cfi.py:4
reco::GsfElectron::PflowIsolationVariables::sumEcalClusterEt
float sumEcalClusterEt
Definition: GsfElectron.h:617
pat::PATElectronProducer::addResolutions_
const bool addResolutions_
Definition: PATElectronProducer.h:177
edm::InputTag
Definition: InputTag.h:15
label
const char * label
Definition: PFTauDecayModeTools.cc:11
pat::PATElectronProducer::efficiencyLoader_
pat::helper::EfficiencyLoader efficiencyLoader_
Definition: PATElectronProducer.h:175
reco::Vertex
Definition: Vertex.h:35
SurveyInfoScenario_cff.seed
seed
Definition: SurveyInfoScenario_cff.py:295
hit
Definition: SiStripHitEffFromCalibTree.cc:88
pat::PATElectronProducer::computeMiniIso_
bool computeMiniIso_
Definition: PATElectronProducer.h:78
pat::PATElectronProducer::readIsolationLabels
void readIsolationLabels(const edm::ParameterSet &iConfig, const char *psetName, IsolationLabels &labels, std::vector< edm::EDGetTokenT< edm::ValueMap< T > > > &tokens)
Definition: PATElectronProducer.h:196
pat::PATElectronProducer::reducedBarrelRecHitCollectionToken_
const edm::EDGetTokenT< EcalRecHitCollection > reducedBarrelRecHitCollectionToken_
Definition: PATElectronProducer.h:97
pat::PATElectronProducer::PUPPIIsolation_neutral_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_neutral_hadrons_
Definition: PATElectronProducer.h:183
Generated for CMSSW Reference Manual by doxygen 1.8.16