Inheritance diagram for pat::PATElectronProducer:

Public Member Functions
	PATElectronProducer (const edm::ParameterSet &iConfig)

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

	~PATElectronProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Types
typedef edm::RefToBase< reco::GsfElectron >	ElectronBaseRef

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

typedef std::vector< edm::Handle< edm::ValueMap< IsoDeposit > > >	IsoDepositMaps

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

typedef std::vector< IsolationLabel >	IsolationLabels

typedef std::vector< edm::Handle< edm::ValueMap< double > > >	IsolationValueMaps

typedef std::pair< std::string, edm::InputTag >	NameTag

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

void	fillElectron (Electron &aElectron, const ElectronBaseRef &electronRef, const reco::CandidateBaseRef &baseRef, const GenAssociations &genMatches, const IsoDepositMaps &deposits, const bool pfId, const IsolationValueMaps &isolationValues, const IsolationValueMaps &isolationValuesNoPFId) const
	common electron filling, for both the standard and PF2PAT case More...

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

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

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

Private Attributes
const bool	addEfficiencies_

const bool	addElecID_

bool	addGenMatch_

const bool	addMVAVariables_
	mva input variables More...

const bool	addPFClusterIso_

const bool	addPuppiIsolation_

const bool	addResolutions_

const edm::EDGetTokenT< reco::BeamSpot >	beamLineToken_

bool	computeMiniIso_

const EcalClusterLazyTools::ESGetTokens	ecalClusterToolsESGetTokens_

const edm::EDGetTokenT< edm::ValueMap< float > >	ecalPFClusterIsoT_

const CaloTopology *	ecalTopology_

const edm::ESGetToken< CaloTopology, CaloTopologyRecord >	ecalTopologyToken_

pat::helper::EfficiencyLoader	efficiencyLoader_

std::vector< NameTag >	elecIDSrcs_

std::vector< edm::EDGetTokenT< edm::ValueMap< float > > >	elecIDTokens_

const edm::EDGetTokenT< edm::View< reco::GsfElectron > >	electronToken_

const bool	embedBasicClusters_

bool	embedGenMatch_

const bool	embedGsfElectronCore_

const bool	embedGsfTrack_

const bool	embedHighLevelSelection_
	embed high level selection variables? More...

const bool	embedPFCandidate_

const bool	embedPflowBasicClusters_

const bool	embedPflowPreshowerClusters_

const bool	embedPflowSuperCluster_

const bool	embedPreshowerClusters_

const bool	embedRecHits_

const bool	embedSeedCluster_

const bool	embedSuperCluster_

const bool	embedTrack_

std::vector< edm::EDGetTokenT< edm::Association< reco::GenParticleCollection > > >	genMatchTokens_

const edm::EDGetTokenT< edm::ValueMap< float > >	hcalPFClusterIsoT_

const edm::EDGetTokenT< reco::ConversionCollection >	hConversionsToken_

IsolationLabels	isoDepositLabels_

std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > >	isoDepositTokens_

IsolationLabels	isolationValueLabels_

IsolationLabels	isolationValueLabelsNoPFId_

std::vector< edm::EDGetTokenT< edm::ValueMap< double > > >	isolationValueNoPFIdTokens_

std::vector< edm::EDGetTokenT< edm::ValueMap< double > > >	isolationValueTokens_

pat::helper::MultiIsolator	isolator_

pat::helper::MultiIsolator::IsolationValuePairs	isolatorTmpStorage_

std::vector< double >	miniIsoParamsB_

std::vector< double >	miniIsoParamsE_

edm::EDGetTokenT< pat::PackedCandidateCollection >	pcToken_

const edm::EDGetTokenT< edm::ValueMap< reco::PFCandidatePtr > >	pfCandidateMapToken_

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

const edm::EDGetTokenT< reco::PFCandidateCollection >	pfElecToken_

const GreaterByPt< Electron >	pTComparator_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPIIsolation_charged_hadrons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPIIsolation_neutral_hadrons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPIIsolation_photons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPINoLeptonsIsolation_charged_hadrons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPINoLeptonsIsolation_neutral_hadrons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPINoLeptonsIsolation_photons_

const edm::EDGetTokenT< std::vector< reco::Vertex > >	pvToken_

const edm::InputTag	reducedBarrelRecHitCollection_

const edm::EDGetTokenT< EcalRecHitCollection >	reducedBarrelRecHitCollectionToken_

const edm::InputTag	reducedEndcapRecHitCollection_

const edm::EDGetTokenT< EcalRecHitCollection >	reducedEndcapRecHitCollectionToken_

pat::helper::KinResolutionsLoader	resolutionLoader_

const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	trackBuilderToken_

const bool	useParticleFlow_
	pflow specific More...

const bool	usePfCandidateMultiMap_

pat::PATUserDataHelper< pat::Electron >	userDataHelper_

const bool	useUserData_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Produces pat::Electron's.

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

Author: Steven Lowette, James Lamb\

Version

Id: PATElectronProducer.h,v 1.31 2013/02/27 23:26:56 wmtan Exp

Definition at line 68 of file PATElectronProducer.cc.

Member Typedef Documentation

◆ ElectronBaseRef

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

private

Definition at line 130 of file PATElectronProducer.cc.

◆ GenAssociations

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

private

Definition at line 100 of file PATElectronProducer.cc.

◆ IsoDepositMaps

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

private

Definition at line 131 of file PATElectronProducer.cc.

◆ IsolationLabel

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

private

Definition at line 165 of file PATElectronProducer.cc.

◆ IsolationLabels

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

private

Definition at line 166 of file PATElectronProducer.cc.

◆ IsolationValueMaps

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

private

Definition at line 132 of file PATElectronProducer.cc.

◆ NameTag

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

private

Definition at line 177 of file PATElectronProducer.cc.

Constructor & Destructor Documentation

◆ PATElectronProducer()

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

explicit

Definition at line 270 of file PATElectronProducer.cc.

     :  // general configurables
       electronToken_(consumes<edm::View<reco::GsfElectron>>(iConfig.getParameter<edm::InputTag>("electronSource"))),
       hConversionsToken_(consumes<reco::ConversionCollection>(edm::InputTag("allConversions"))),
       embedGsfElectronCore_(iConfig.getParameter<bool>("embedGsfElectronCore")),
       embedGsfTrack_(iConfig.getParameter<bool>("embedGsfTrack")),
       embedSuperCluster_(iConfig.getParameter<bool>("embedSuperCluster")),
       embedPflowSuperCluster_(iConfig.getParameter<bool>("embedPflowSuperCluster")),
       embedSeedCluster_(iConfig.getParameter<bool>("embedSeedCluster")),
       embedBasicClusters_(iConfig.getParameter<bool>("embedBasicClusters")),
       embedPreshowerClusters_(iConfig.getParameter<bool>("embedPreshowerClusters")),
       embedPflowBasicClusters_(iConfig.getParameter<bool>("embedPflowBasicClusters")),
       embedPflowPreshowerClusters_(iConfig.getParameter<bool>("embedPflowPreshowerClusters")),
       embedTrack_(iConfig.getParameter<bool>("embedTrack")),
       addGenMatch_(iConfig.getParameter<bool>("addGenMatch")),
       embedGenMatch_(addGenMatch_ ? iConfig.getParameter<bool>("embedGenMatch") : false),
       embedRecHits_(iConfig.getParameter<bool>("embedRecHits")),
       // pflow configurables
       useParticleFlow_(iConfig.getParameter<bool>("useParticleFlow")),
       usePfCandidateMultiMap_(iConfig.getParameter<bool>("usePfCandidateMultiMap")),
       pfElecToken_(!usePfCandidateMultiMap_
                        ? consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfElectronSource"))
                        : edm::EDGetTokenT<reco::PFCandidateCollection>()),
       pfCandidateMapToken_(!usePfCandidateMultiMap_ ? mayConsume<edm::ValueMap<reco::PFCandidatePtr>>(
                                                           iConfig.getParameter<edm::InputTag>("pfCandidateMap"))
                                                     : edm::EDGetTokenT<edm::ValueMap<reco::PFCandidatePtr>>()),
       pfCandidateMultiMapToken_(usePfCandidateMultiMap_
                                     ? consumes<edm::ValueMap<std::vector<reco::PFCandidateRef>>>(
                                           iConfig.getParameter<edm::InputTag>("pfCandidateMultiMap"))
                                     : edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef>>>()),
       embedPFCandidate_(iConfig.getParameter<bool>("embedPFCandidate")),
       // mva input variables
       addMVAVariables_(iConfig.getParameter<bool>("addMVAVariables")),
       reducedBarrelRecHitCollection_(iConfig.getParameter<edm::InputTag>("reducedBarrelRecHitCollection")),
       reducedBarrelRecHitCollectionToken_(mayConsume<EcalRecHitCollection>(reducedBarrelRecHitCollection_)),
       reducedEndcapRecHitCollection_(iConfig.getParameter<edm::InputTag>("reducedEndcapRecHitCollection")),
       reducedEndcapRecHitCollectionToken_(mayConsume<EcalRecHitCollection>(reducedEndcapRecHitCollection_)),
       ecalClusterToolsESGetTokens_{consumesCollector()},
       // PFCluster Isolation maps
       addPFClusterIso_(iConfig.getParameter<bool>("addPFClusterIso")),
       addPuppiIsolation_(iConfig.getParameter<bool>("addPuppiIsolation")),
       ecalPFClusterIsoT_(consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("ecalPFClusterIsoMap"))),
       hcalPFClusterIsoT_(consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("hcalPFClusterIsoMap"))),
       // embed high level selection variables?
       embedHighLevelSelection_(iConfig.getParameter<bool>("embedHighLevelSelection")),
       beamLineToken_(consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamLineSrc"))),
       pvToken_(mayConsume<std::vector<reco::Vertex>>(iConfig.getParameter<edm::InputTag>("pvSrc"))),
       addElecID_(iConfig.getParameter<bool>("addElectronID")),
       pTComparator_(),
       isolator_(iConfig.getParameter<edm::ParameterSet>("userIsolation"), consumesCollector(), false),
       addEfficiencies_(iConfig.getParameter<bool>("addEfficiencies")),
       addResolutions_(iConfig.getParameter<bool>("addResolutions")),
       useUserData_(iConfig.exists("userData")),
       ecalTopologyToken_{esConsumes()},
       trackBuilderToken_{esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))} {
   // MC matching configurables (scheduled mode)
 
   if (addGenMatch_) {
     genMatchTokens_.push_back(consumes<edm::Association<reco::GenParticleCollection>>(
         iConfig.getParameter<edm::InputTag>("genParticleMatch")));
   }
   // resolution configurables
   if (addResolutions_) {
     resolutionLoader_ =
         pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
   if (addPuppiIsolation_) {
     //puppi
     PUPPIIsolation_charged_hadrons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationChargedHadrons"));
     PUPPIIsolation_neutral_hadrons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationNeutralHadrons"));
     PUPPIIsolation_photons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationPhotons"));
     //puppiNoLeptons
     PUPPINoLeptonsIsolation_charged_hadrons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationChargedHadrons"));
     PUPPINoLeptonsIsolation_neutral_hadrons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationNeutralHadrons"));
     PUPPINoLeptonsIsolation_photons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationPhotons"));
   }
   // electron ID configurables
   if (addElecID_) {
     // it might be a single electron ID
     if (iConfig.existsAs<edm::InputTag>("electronIDSource")) {
       elecIDSrcs_.push_back(NameTag("", iConfig.getParameter<edm::InputTag>("electronIDSource")));
     }
     // or there might be many of them
     if (iConfig.existsAs<edm::ParameterSet>("electronIDSources")) {
       // please don't configure me twice
       if (!elecIDSrcs_.empty()) {
         throw cms::Exception("Configuration")
             << "PATElectronProducer: you can't specify both 'electronIDSource' and 'electronIDSources'\n";
       }
       // read the different electron ID names
       edm::ParameterSet idps = iConfig.getParameter<edm::ParameterSet>("electronIDSources");
       std::vector<std::string> names = idps.getParameterNamesForType<edm::InputTag>();
       for (std::vector<std::string>::const_iterator it = names.begin(), ed = names.end(); it != ed; ++it) {
         elecIDSrcs_.push_back(NameTag(*it, idps.getParameter<edm::InputTag>(*it)));
       }
     }
     // but in any case at least once
     if (elecIDSrcs_.empty()) {
       throw cms::Exception("Configuration")
           << "PATElectronProducer: id addElectronID is true, you must specify either:\n"
           << "\tInputTag electronIDSource = <someTag>\n"
           << "or\n"
           << "\tPSet electronIDSources = { \n"
           << "\t\tInputTag <someName> = <someTag>   // as many as you want \n "
           << "\t}\n";
     }
   }
   elecIDTokens_ = edm::vector_transform(
       elecIDSrcs_, [this](NameTag const& tag) { return mayConsume<edm::ValueMap<float>>(tag.second); });
   // construct resolution calculator
 
   //   // IsoDeposit configurables
   //   if (iConfig.exists("isoDeposits")) {
   //      edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>("isoDeposits");
   //      if (depconf.exists("tracker")) isoDepositLabels_.push_back(std::make_pair(TrackerIso, depconf.getParameter<edm::InputTag>("tracker")));
   //      if (depconf.exists("ecal"))    isoDepositLabels_.push_back(std::make_pair(ECalIso, depconf.getParameter<edm::InputTag>("ecal")));
   //      if (depconf.exists("hcal"))    isoDepositLabels_.push_back(std::make_pair(HCalIso, depconf.getParameter<edm::InputTag>("hcal")));
 
   //      if (depconf.exists("user")) {
   //         std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
   //         std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
   //         int key = UserBaseIso;
   //         for ( ; it != ed; ++it, ++key) {
   //             isoDepositLabels_.push_back(std::make_pair(IsolationKeys(key), *it));
   //         }
   //      }
   //   }
   //   isoDepositTokens_ = edm::vector_transform(isoDepositLabels_, [this](std::pair<IsolationKeys,edm::InputTag> const & label){return consumes<edm::ValueMap<IsoDeposit> >(label.second);});
 
   // for mini-iso
   computeMiniIso_ = iConfig.getParameter<bool>("computeMiniIso");
   miniIsoParamsE_ = iConfig.getParameter<std::vector<double>>("miniIsoParamsE");
   miniIsoParamsB_ = iConfig.getParameter<std::vector<double>>("miniIsoParamsB");
   if (computeMiniIso_ && (miniIsoParamsE_.size() != 9 || miniIsoParamsB_.size() != 9)) {
     throw cms::Exception("ParameterError") << "miniIsoParams must have exactly 9 elements.\n";
   }
   if (computeMiniIso_)
     pcToken_ = consumes<pat::PackedCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfCandsForMiniIso"));
 
   // read isoDeposit labels, for direct embedding
   readIsolationLabels(iConfig, "isoDeposits", isoDepositLabels_, isoDepositTokens_);
   // read isolation value labels, for direct embedding
   readIsolationLabels(iConfig, "isolationValues", isolationValueLabels_, isolationValueTokens_);
   // read isolation value labels for non PF identified electron, for direct embedding
   readIsolationLabels(iConfig, "isolationValuesNoPFId", isolationValueLabelsNoPFId_, isolationValueNoPFIdTokens_);
   // Efficiency configurables
   if (addEfficiencies_) {
     efficiencyLoader_ =
         pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"), consumesCollector());
   }
   // Check to see if the user wants to add user data
   if (useUserData_) {
     userDataHelper_ =
         PATUserDataHelper<Electron>(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector());
   }
 
   // consistency check
   if (useParticleFlow_ && usePfCandidateMultiMap_)
     throw cms::Exception("Configuration", "usePfCandidateMultiMap not supported when useParticleFlow is set to true");
 
   // produces vector of muons
   produces<std::vector<Electron>>();
 }

◆ ~PATElectronProducer()

PATElectronProducer::~PATElectronProducer ( )

override

Definition at line 440 of file PATElectronProducer.cc.

440 {}

Member Function Documentation

◆ embedHighLevel()

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

private

Definition at line 1405 of file PATElectronProducer.cc.

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

Referenced by produce().

                                                                {
   // Correct to PV
   // PV2D
   anElectron.setDB(track->dxy(primaryVertex.position()),
                    track->dxyError(primaryVertex.position(), primaryVertex.covariance()),
                    pat::Electron::PV2D);
 
   // PV3D
   std::pair<bool, Measurement1D> result =
       IPTools::signedImpactParameter3D(tt, GlobalVector(track->px(), track->py(), track->pz()), primaryVertex);
   double d0_corr = result.second.value();
   double d0_err = primaryVertexIsValid ? result.second.error() : -1.0;
   anElectron.setDB(d0_corr, d0_err, pat::Electron::PV3D);
 
   // Correct to beam spot
   // BS2D
   anElectron.setDB(track->dxy(beamspot), track->dxyError(beamspot), pat::Electron::BS2D);
 
   // make a fake vertex out of beam spot
   reco::Vertex vBeamspot(beamspot.position(), beamspot.covariance3D());
 
   // BS3D
   result = IPTools::signedImpactParameter3D(tt, GlobalVector(track->px(), track->py(), track->pz()), vBeamspot);
   d0_corr = result.second.value();
   d0_err = beamspotIsValid ? result.second.error() : -1.0;
   anElectron.setDB(d0_corr, d0_err, pat::Electron::BS3D);
 
   // PVDZ
   anElectron.setDB(
       track->dz(primaryVertex.position()), std::hypot(track->dzError(), primaryVertex.zError()), pat::Electron::PVDZ);
 }

◆ fillDescriptions()

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

static

Definition at line 1229 of file PATElectronProducer.cc.

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

                                                                                      {
   edm::ParameterSetDescription iDesc;
   iDesc.setComment("PAT electron producer module");
 
   // input source
   iDesc.add<edm::InputTag>("pfCandidateMap", edm::InputTag("no default"))->setComment("input collection");
   iDesc.add<edm::InputTag>("electronSource", edm::InputTag("no default"))->setComment("input collection");
 
   iDesc.ifValue(
       edm::ParameterDescription<bool>("addPFClusterIso", false, true),
       true >> (edm::ParameterDescription<edm::InputTag>(
                    "ecalPFClusterIsoMap", edm::InputTag("electronEcalPFClusterIsolationProducer"), true) and
                edm::ParameterDescription<edm::InputTag>(
                    "hcalPFClusterIsoMap", edm::InputTag("electronHcalPFClusterIsolationProducer"), true)) or
           false >> (edm::ParameterDescription<edm::InputTag>("ecalPFClusterIsoMap", edm::InputTag(""), true) and
                     edm::ParameterDescription<edm::InputTag>("hcalPFClusterIsoMap", edm::InputTag(""), true)));
 
   iDesc.ifValue(edm::ParameterDescription<bool>("addPuppiIsolation", false, true),
                 true >> (edm::ParameterDescription<edm::InputTag>(
                              "puppiIsolationChargedHadrons",
                              edm::InputTag("egmElectronPUPPIIsolation", "h+-DR030-BarVeto000-EndVeto001"),
                              true) and
                          edm::ParameterDescription<edm::InputTag>(
                              "puppiIsolationNeutralHadrons",
                              edm::InputTag("egmElectronPUPPIIsolation", "h0-DR030-BarVeto000-EndVeto000"),
                              true) and
                          edm::ParameterDescription<edm::InputTag>(
                              "puppiIsolationPhotons",
                              edm::InputTag("egmElectronPUPPIIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
                              true) and
                          edm::ParameterDescription<edm::InputTag>(
                              "puppiNoLeptonsIsolationChargedHadrons",
                              edm::InputTag("egmElectronPUPPINoLeptonsIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
                              true) and
                          edm::ParameterDescription<edm::InputTag>(
                              "puppiNoLeptonsIsolationNeutralHadrons",
                              edm::InputTag("egmElectronPUPPINoLeptonsIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
                              true) and
                          edm::ParameterDescription<edm::InputTag>(
                              "puppiNoLeptonsIsolationPhotons",
                              edm::InputTag("egmElectronPUPPINoLeptonsIsolation", "gamma-DR030-BarVeto000-EndVeto008"),
                              true)) or
                     false >> edm::EmptyGroupDescription());
 
   // embedding
   iDesc.add<bool>("embedGsfElectronCore", true)->setComment("embed external gsf electron core");
   iDesc.add<bool>("embedGsfTrack", true)->setComment("embed external gsf track");
   iDesc.add<bool>("embedSuperCluster", true)->setComment("embed external super cluster");
   iDesc.add<bool>("embedPflowSuperCluster", true)->setComment("embed external super cluster");
   iDesc.add<bool>("embedSeedCluster", true)->setComment("embed external seed cluster");
   iDesc.add<bool>("embedBasicClusters", true)->setComment("embed external basic clusters");
   iDesc.add<bool>("embedPreshowerClusters", true)->setComment("embed external preshower clusters");
   iDesc.add<bool>("embedPflowBasicClusters", true)->setComment("embed external pflow basic clusters");
   iDesc.add<bool>("embedPflowPreshowerClusters", true)->setComment("embed external pflow preshower clusters");
   iDesc.add<bool>("embedTrack", false)->setComment("embed external track");
   iDesc.add<bool>("embedRecHits", true)->setComment("embed external RecHits");
 
   // pf specific parameters
   iDesc.add<edm::InputTag>("pfElectronSource", edm::InputTag("pfElectrons"))
       ->setComment("particle flow input collection");
   auto&& usePfCandidateMultiMap = edm::ParameterDescription<bool>("usePfCandidateMultiMap", false, true);
   usePfCandidateMultiMap.setComment(
       "take ParticleFlow candidates from pfCandidateMultiMap instead of matching to pfElectrons by Gsf track "
       "reference");
   iDesc.ifValue(usePfCandidateMultiMap,
                 true >> edm::ParameterDescription<edm::InputTag>("pfCandidateMultiMap", true) or
                     false >> edm::EmptyGroupDescription());
   iDesc.add<bool>("useParticleFlow", false)->setComment("whether to use particle flow or not");
   iDesc.add<bool>("embedPFCandidate", false)->setComment("embed external particle flow object");
 
   // MC matching configurables
   iDesc.add<bool>("addGenMatch", true)->setComment("add MC matching");
   iDesc.add<bool>("embedGenMatch", false)->setComment("embed MC matched MC information");
   std::vector<edm::InputTag> emptySourceVector;
   iDesc
       .addNode(edm::ParameterDescription<edm::InputTag>("genParticleMatch", edm::InputTag(), true) xor
                edm::ParameterDescription<std::vector<edm::InputTag>>("genParticleMatch", emptySourceVector, true))
       ->setComment("input with MC match information");
 
   // electron ID configurables
   iDesc.add<bool>("addElectronID", true)->setComment("add electron ID variables");
   edm::ParameterSetDescription electronIDSourcesPSet;
   electronIDSourcesPSet.setAllowAnything();
   iDesc
       .addNode(
           edm::ParameterDescription<edm::InputTag>("electronIDSource", edm::InputTag(), true) xor
           edm::ParameterDescription<edm::ParameterSetDescription>("electronIDSources", electronIDSourcesPSet, true))
       ->setComment("input with electron ID variables");
 
   // mini-iso
   iDesc.add<bool>("computeMiniIso", false)->setComment("whether or not to compute and store electron mini-isolation");
   iDesc.add<edm::InputTag>("pfCandsForMiniIso", edm::InputTag("packedPFCandidates"))
       ->setComment("collection to use to compute mini-iso");
   iDesc.add<std::vector<double>>("miniIsoParamsE", std::vector<double>())
       ->setComment("mini-iso parameters to use for endcap electrons");
   iDesc.add<std::vector<double>>("miniIsoParamsB", std::vector<double>())
       ->setComment("mini-iso parameters to use for barrel electrons");
 
   // IsoDeposit configurables
   edm::ParameterSetDescription isoDepositsPSet;
   isoDepositsPSet.addOptional<edm::InputTag>("tracker");
   isoDepositsPSet.addOptional<edm::InputTag>("ecal");
   isoDepositsPSet.addOptional<edm::InputTag>("hcal");
   isoDepositsPSet.addOptional<edm::InputTag>("pfAllParticles");
   isoDepositsPSet.addOptional<edm::InputTag>("pfChargedHadrons");
   isoDepositsPSet.addOptional<edm::InputTag>("pfChargedAll");
   isoDepositsPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
   isoDepositsPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
   isoDepositsPSet.addOptional<edm::InputTag>("pfPhotons");
   isoDepositsPSet.addOptional<std::vector<edm::InputTag>>("user");
   iDesc.addOptional("isoDeposits", isoDepositsPSet);
 
   // isolation values configurables
   edm::ParameterSetDescription isolationValuesPSet;
   isolationValuesPSet.addOptional<edm::InputTag>("tracker");
   isolationValuesPSet.addOptional<edm::InputTag>("ecal");
   isolationValuesPSet.addOptional<edm::InputTag>("hcal");
   isolationValuesPSet.addOptional<edm::InputTag>("pfAllParticles");
   isolationValuesPSet.addOptional<edm::InputTag>("pfChargedHadrons");
   isolationValuesPSet.addOptional<edm::InputTag>("pfChargedAll");
   isolationValuesPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
   isolationValuesPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
   isolationValuesPSet.addOptional<edm::InputTag>("pfPhotons");
   isolationValuesPSet.addOptional<std::vector<edm::InputTag>>("user");
   iDesc.addOptional("isolationValues", isolationValuesPSet);
 
   // isolation values configurables
   edm::ParameterSetDescription isolationValuesNoPFIdPSet;
   isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("tracker");
   isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("ecal");
   isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("hcal");
   isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfAllParticles");
   isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfChargedHadrons");
   isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfChargedAll");
   isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
   isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
   isolationValuesNoPFIdPSet.addOptional<edm::InputTag>("pfPhotons");
   isolationValuesNoPFIdPSet.addOptional<std::vector<edm::InputTag>>("user");
   iDesc.addOptional("isolationValuesNoPFId", isolationValuesNoPFIdPSet);
 
   // Efficiency configurables
   edm::ParameterSetDescription efficienciesPSet;
   efficienciesPSet.setAllowAnything();  // TODO: the pat helper needs to implement a description.
   iDesc.add("efficiencies", efficienciesPSet);
   iDesc.add<bool>("addEfficiencies", false);
 
   // Check to see if the user wants to add user data
   edm::ParameterSetDescription userDataPSet;
   PATUserDataHelper<Electron>::fillDescription(userDataPSet);
   iDesc.addOptional("userData", userDataPSet);
 
   // electron shapes
   iDesc.add<bool>("addMVAVariables", true)->setComment("embed extra variables in pat::Electron : sip3d, sigmaIEtaIPhi");
   iDesc.add<edm::InputTag>("reducedBarrelRecHitCollection", edm::InputTag("reducedEcalRecHitsEB"));
   iDesc.add<edm::InputTag>("reducedEndcapRecHitCollection", edm::InputTag("reducedEcalRecHitsEE"));
 
   edm::ParameterSetDescription isolationPSet;
   isolationPSet.setAllowAnything();  // TODO: the pat helper needs to implement a description.
   iDesc.add("userIsolation", isolationPSet);
 
   // Resolution configurables
   pat::helper::KinResolutionsLoader::fillDescription(iDesc);
 
   iDesc.add<bool>("embedHighLevelSelection", true)->setComment("embed high level selection");
   edm::ParameterSetDescription highLevelPSet;
   highLevelPSet.setAllowAnything();
   iDesc.addNode(edm::ParameterDescription<edm::InputTag>("beamLineSrc", edm::InputTag(), true))
       ->setComment("input with high level selection");
   iDesc.addNode(edm::ParameterDescription<edm::InputTag>("pvSrc", edm::InputTag(), true))
       ->setComment("input with high level selection");
 
   descriptions.add("PATElectronProducer", iDesc);
 }

◆ fillElectron()

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

private

common electron filling, for both the standard and PF2PAT case

Definition at line 1024 of file PATElectronProducer.cc.

Referenced by produce().

                                                                                               {
   //COLIN: might want to use the PFCandidate 4-mom. Which one is in use now?
   //   if (useParticleFlow_)
   //     aMuon.setP4( aMuon.pfCandidateRef()->p4() );
 
   //COLIN:
   //In the embedding case, the reference cannot be used to look into a value map.
   //therefore, one has to had the PFCandidateRef to this function, which becomes a bit
   //too much specific.
 
   // in fact, this function needs a baseref or ptr for genmatch
   // and a baseref or ptr for isodeposits and isolationvalues.
   // baseref is not needed
   // the ptrForIsolation and ptrForMatching should be defined upstream.
 
   // is the concrete elecRef needed for the efficiency loader? what is this loader?
   // how can we make it compatible with the particle flow electrons?
 
   if (embedGsfElectronCore_)
     anElectron.embedGsfElectronCore();
   if (embedGsfTrack_)
     anElectron.embedGsfTrack();
   if (embedSuperCluster_)
     anElectron.embedSuperCluster();
   if (embedPflowSuperCluster_)
     anElectron.embedPflowSuperCluster();
   if (embedSeedCluster_)
     anElectron.embedSeedCluster();
   if (embedBasicClusters_)
     anElectron.embedBasicClusters();
   if (embedPreshowerClusters_)
     anElectron.embedPreshowerClusters();
   if (embedPflowBasicClusters_)
     anElectron.embedPflowBasicClusters();
   if (embedPflowPreshowerClusters_)
     anElectron.embedPflowPreshowerClusters();
   if (embedTrack_)
     anElectron.embedTrack();
 
   // store the match to the generated final state muons
   if (addGenMatch_) {
     for (size_t i = 0, n = genMatches.size(); i < n; ++i) {
       if (useParticleFlow_) {
         reco::GenParticleRef genElectron = (*genMatches[i])[anElectron.pfCandidateRef()];
         anElectron.addGenParticleRef(genElectron);
       } else {
         reco::GenParticleRef genElectron = (*genMatches[i])[elecRef];
         anElectron.addGenParticleRef(genElectron);
       }
     }
     if (embedGenMatch_)
       anElectron.embedGenParticle();
   }
 
   if (efficiencyLoader_.enabled()) {
     efficiencyLoader_.setEfficiencies(anElectron, elecRef);
   }
 
   if (resolutionLoader_.enabled()) {
     resolutionLoader_.setResolutions(anElectron);
   }
 
   for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
     if (useParticleFlow_) {
       reco::PFCandidateRef pfcandref = anElectron.pfCandidateRef();
       assert(!pfcandref.isNull());
       reco::CandidatePtr source = pfcandref->sourceCandidatePtr(0);
       anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[source]);
     } else
       anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[elecRef]);
   }
 
   for (size_t j = 0; j < isolationValues.size(); ++j) {
     if (useParticleFlow_) {
       reco::CandidatePtr source = anElectron.pfCandidateRef()->sourceCandidatePtr(0);
       anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[source]);
     } else if (pfId) {
       anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[elecRef]);
     }
   }
 
   //for electrons not identified as PF electrons
   for (size_t j = 0; j < isolationValuesNoPFId.size(); ++j) {
     if (!pfId) {
       anElectron.setIsolation(isolationValueLabelsNoPFId_[j].first, (*isolationValuesNoPFId[j])[elecRef]);
     }
   }
 }

◆ fillElectron2()

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

private

Definition at line 1120 of file PATElectronProducer.cc.

Referenced by produce().

                                                                                          {
   //COLIN/Florian: use the PFCandidate 4-mom.
   anElectron.setEcalDrivenMomentum(anElectron.p4());
   anElectron.setP4(anElectron.pfCandidateRef()->p4());
 
   // is the concrete elecRef needed for the efficiency loader? what is this loader?
   // how can we make it compatible with the particle flow electrons?
 
   if (embedGsfElectronCore_)
     anElectron.embedGsfElectronCore();
   if (embedGsfTrack_)
     anElectron.embedGsfTrack();
   if (embedSuperCluster_)
     anElectron.embedSuperCluster();
   if (embedPflowSuperCluster_)
     anElectron.embedPflowSuperCluster();
   if (embedSeedCluster_)
     anElectron.embedSeedCluster();
   if (embedBasicClusters_)
     anElectron.embedBasicClusters();
   if (embedPreshowerClusters_)
     anElectron.embedPreshowerClusters();
   if (embedPflowBasicClusters_)
     anElectron.embedPflowBasicClusters();
   if (embedPflowPreshowerClusters_)
     anElectron.embedPflowPreshowerClusters();
   if (embedTrack_)
     anElectron.embedTrack();
 
   // store the match to the generated final state muons
 
   if (addGenMatch_) {
     for (size_t i = 0, n = genMatches.size(); i < n; ++i) {
       reco::GenParticleRef genElectron = (*genMatches[i])[candPtrForGenMatch];
       anElectron.addGenParticleRef(genElectron);
     }
     if (embedGenMatch_)
       anElectron.embedGenParticle();
   }
 
   //COLIN what's this? does it have to be GsfElectron specific?
   if (efficiencyLoader_.enabled()) {
     efficiencyLoader_.setEfficiencies(anElectron, candPtrForLoader);
   }
 
   if (resolutionLoader_.enabled()) {
     resolutionLoader_.setResolutions(anElectron);
   }
 
   for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
     if (isoDepositLabels_[j].first == pat::TrackIso || isoDepositLabels_[j].first == pat::EcalIso ||
         isoDepositLabels_[j].first == pat::HcalIso || deposits[j]->contains(candPtrForGenMatch.id())) {
       anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[candPtrForGenMatch]);
     } else if (deposits[j]->contains(candPtrForIsolation.id())) {
       anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[candPtrForIsolation]);
     } else {
       anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[candPtrForIsolation->sourceCandidatePtr(0)]);
     }
   }
 
   for (size_t j = 0; j < isolationValues.size(); ++j) {
     if (isolationValueLabels_[j].first == pat::TrackIso || isolationValueLabels_[j].first == pat::EcalIso ||
         isolationValueLabels_[j].first == pat::HcalIso || isolationValues[j]->contains(candPtrForGenMatch.id())) {
       anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[candPtrForGenMatch]);
     } else if (isolationValues[j]->contains(candPtrForIsolation.id())) {
       anElectron.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[candPtrForIsolation]);
     } else {
       anElectron.setIsolation(isolationValueLabels_[j].first,
                               (*isolationValues[j])[candPtrForIsolation->sourceCandidatePtr(0)]);
     }
   }
 }

◆ produce()

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

override

Definition at line 442 of file PATElectronProducer.cc.

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

                                                                                {
   // switch off embedding (in unschedules mode)
   if (iEvent.isRealData()) {
     addGenMatch_ = false;
     embedGenMatch_ = false;
   }
 
   ecalTopology_ = &iSetup.getData(ecalTopologyToken_);
 
   // Get the collection of electrons from the event
   edm::Handle<edm::View<reco::GsfElectron>> electrons;
   iEvent.getByToken(electronToken_, electrons);
 
   edm::Handle<PackedCandidateCollection> pc;
   if (computeMiniIso_)
     iEvent.getByToken(pcToken_, pc);
 
   // for additional mva variables
   edm::InputTag reducedEBRecHitCollection(string("reducedEcalRecHitsEB"));
   edm::InputTag reducedEERecHitCollection(string("reducedEcalRecHitsEE"));
   //EcalClusterLazyTools lazyTools(iEvent, iSetup, reducedEBRecHitCollection, reducedEERecHitCollection);
   EcalClusterLazyTools lazyTools(iEvent,
                                  ecalClusterToolsESGetTokens_.get(iSetup),
                                  reducedBarrelRecHitCollectionToken_,
                                  reducedEndcapRecHitCollectionToken_);
 
   // for conversion veto selection
   edm::Handle<reco::ConversionCollection> hConversions;
   iEvent.getByToken(hConversionsToken_, hConversions);
 
   // Get the ESHandle for the transient track builder, if needed for
   // high level selection embedding
   edm::ESHandle<TransientTrackBuilder> trackBuilder;
 
   if (isolator_.enabled())
     isolator_.beginEvent(iEvent, iSetup);
 
   if (efficiencyLoader_.enabled())
     efficiencyLoader_.newEvent(iEvent);
   if (resolutionLoader_.enabled())
     resolutionLoader_.newEvent(iEvent, iSetup);
 
   IsoDepositMaps deposits(isoDepositTokens_.size());
   for (size_t j = 0, nd = isoDepositTokens_.size(); j < nd; ++j) {
     iEvent.getByToken(isoDepositTokens_[j], deposits[j]);
   }
 
   IsolationValueMaps isolationValues(isolationValueTokens_.size());
   for (size_t j = 0; j < isolationValueTokens_.size(); ++j) {
     iEvent.getByToken(isolationValueTokens_[j], isolationValues[j]);
   }
 
   IsolationValueMaps isolationValuesNoPFId(isolationValueNoPFIdTokens_.size());
   for (size_t j = 0; j < isolationValueNoPFIdTokens_.size(); ++j) {
     iEvent.getByToken(isolationValueNoPFIdTokens_[j], isolationValuesNoPFId[j]);
   }
 
   // prepare the MC matching
   GenAssociations genMatches(genMatchTokens_.size());
   if (addGenMatch_) {
     for (size_t j = 0, nd = genMatchTokens_.size(); j < nd; ++j) {
       iEvent.getByToken(genMatchTokens_[j], genMatches[j]);
     }
   }
 
   // prepare ID extraction
   std::vector<edm::Handle<edm::ValueMap<float>>> idhandles;
   std::vector<pat::Electron::IdPair> ids;
   if (addElecID_) {
     idhandles.resize(elecIDSrcs_.size());
     ids.resize(elecIDSrcs_.size());
     for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
       iEvent.getByToken(elecIDTokens_[i], idhandles[i]);
       ids[i].first = elecIDSrcs_[i].first;
     }
   }
 
   // prepare the high level selection:
   // needs beamline
   reco::TrackBase::Point beamPoint(0, 0, 0);
   reco::Vertex primaryVertex;
   reco::BeamSpot beamSpot;
   bool beamSpotIsValid = false;
   bool primaryVertexIsValid = false;
 
   // Get the beamspot
   edm::Handle<reco::BeamSpot> beamSpotHandle;
   iEvent.getByToken(beamLineToken_, beamSpotHandle);
 
   if (embedHighLevelSelection_) {
     // Get the primary vertex
     edm::Handle<std::vector<reco::Vertex>> pvHandle;
     iEvent.getByToken(pvToken_, pvHandle);
 
     // This is needed by the IPTools methods from the tracking group
     trackBuilder = iSetup.getHandle(trackBuilderToken_);
 
     if (pvHandle.isValid() && !pvHandle->empty()) {
       primaryVertex = pvHandle->at(0);
       primaryVertexIsValid = true;
     } else {
       edm::LogError("DataNotAvailable")
           << "No primary vertex available from EventSetup, not adding high level selection \n";
     }
   }
   //value maps for puppi isolation
   edm::Handle<edm::ValueMap<float>> PUPPIIsolation_charged_hadrons;
   edm::Handle<edm::ValueMap<float>> PUPPIIsolation_neutral_hadrons;
   edm::Handle<edm::ValueMap<float>> PUPPIIsolation_photons;
   //value maps for puppiNoLeptons isolation
   edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_charged_hadrons;
   edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_neutral_hadrons;
   edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_photons;
   if (addPuppiIsolation_) {
     //puppi
     iEvent.getByToken(PUPPIIsolation_charged_hadrons_, PUPPIIsolation_charged_hadrons);
     iEvent.getByToken(PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_neutral_hadrons);
     iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons);
     //puppiNoLeptons
     iEvent.getByToken(PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_charged_hadrons);
     iEvent.getByToken(PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons);
     iEvent.getByToken(PUPPINoLeptonsIsolation_photons_, PUPPINoLeptonsIsolation_photons);
   }
 
   std::vector<Electron>* patElectrons = new std::vector<Electron>();
 
   if (useParticleFlow_) {
     edm::Handle<reco::PFCandidateCollection> pfElectrons;
     iEvent.getByToken(pfElecToken_, pfElectrons);
     unsigned index = 0;
 
     for (reco::PFCandidateConstIterator i = pfElectrons->begin(); i != pfElectrons->end(); ++i, ++index) {
       reco::PFCandidateRef pfRef(pfElectrons, index);
       reco::PFCandidatePtr ptrToPFElectron(pfElectrons, index);
       //       reco::CandidateBaseRef pfBaseRef( pfRef );
 
       reco::GsfTrackRef PfTk = i->gsfTrackRef();
 
       bool Matched = false;
       bool MatchedToAmbiguousGsfTrack = false;
       for (edm::View<reco::GsfElectron>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end();
            ++itElectron) {
         unsigned int idx = itElectron - electrons->begin();
         auto elePtr = electrons->ptrAt(idx);
         if (Matched || MatchedToAmbiguousGsfTrack)
           continue;
 
         reco::GsfTrackRef EgTk = itElectron->gsfTrack();
 
         if (itElectron->gsfTrack() == i->gsfTrackRef()) {
           Matched = true;
         } else {
           for (auto const& it : itElectron->ambiguousGsfTracks()) {
             MatchedToAmbiguousGsfTrack |= (bool)(i->gsfTrackRef() == it);
           }
         }
 
         if (Matched || MatchedToAmbiguousGsfTrack) {
           // ptr needed for finding the matched gen particle
           reco::CandidatePtr ptrToGsfElectron(electrons, idx);
 
           // ref to base needed for the construction of the pat object
           const edm::RefToBase<reco::GsfElectron>& elecsRef = electrons->refAt(idx);
           Electron anElectron(elecsRef);
           anElectron.setPFCandidateRef(pfRef);
           if (addPuppiIsolation_) {
             anElectron.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[elePtr],
                                          (*PUPPIIsolation_neutral_hadrons)[elePtr],
                                          (*PUPPIIsolation_photons)[elePtr]);
             anElectron.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[elePtr],
                                                   (*PUPPINoLeptonsIsolation_neutral_hadrons)[elePtr],
                                                   (*PUPPINoLeptonsIsolation_photons)[elePtr]);
           } else {
             anElectron.setIsolationPUPPI(-999., -999., -999.);
             anElectron.setIsolationPUPPINoLeptons(-999., -999., -999.);
           }
 
           //it should be always true when particleFlow electrons are used.
           anElectron.setIsPF(true);
 
           if (embedPFCandidate_)
             anElectron.embedPFCandidate();
 
           if (useUserData_) {
             userDataHelper_.add(anElectron, iEvent, iSetup);
           }
 
           double ip3d = -999;  // for mva variable
 
           // embed high level selection
           if (embedHighLevelSelection_) {
             // get the global track
             const reco::GsfTrackRef& track = PfTk;
 
             // Make sure the collection it points to is there
             if (track.isNonnull() && track.isAvailable()) {
               reco::TransientTrack tt = trackBuilder->build(track);
               embedHighLevel(anElectron, track, tt, primaryVertex, primaryVertexIsValid, beamSpot, beamSpotIsValid);
 
               std::pair<bool, Measurement1D> ip3dpv = IPTools::absoluteImpactParameter3D(tt, primaryVertex);
               ip3d = ip3dpv.second.value();  // for mva variable
             }
           }
 
           //Electron Id
 
           if (addElecID_) {
             //STANDARD EL ID
             for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
               ids[i].second = (*idhandles[i])[elecsRef];
             }
             //SPECIFIC PF ID
             ids.push_back(std::make_pair("pf_evspi", pfRef->mva_e_pi()));
             ids.push_back(std::make_pair("pf_evsmu", pfRef->mva_e_mu()));
             anElectron.setElectronIDs(ids);
           }
 
           if (addMVAVariables_) {
             // add missing mva variables
             const auto& vCov = lazyTools.localCovariances(*(itElectron->superCluster()->seed()));
             anElectron.setMvaVariables(vCov[1], ip3d);
           }
           // PFClusterIso
           if (addPFClusterIso_) {
             // Get PFCluster Isolation
             edm::Handle<edm::ValueMap<float>> ecalPFClusterIsoMapH;
             iEvent.getByToken(ecalPFClusterIsoT_, ecalPFClusterIsoMapH);
             edm::Handle<edm::ValueMap<float>> hcalPFClusterIsoMapH;
             iEvent.getByToken(hcalPFClusterIsoT_, hcalPFClusterIsoMapH);
             reco::GsfElectron::PflowIsolationVariables newPFIsol = anElectron.pfIsolationVariables();
             newPFIsol.sumEcalClusterEt = (*ecalPFClusterIsoMapH)[elecsRef];
             newPFIsol.sumHcalClusterEt = (*hcalPFClusterIsoMapH)[elecsRef];
             anElectron.setPfIsolationVariables(newPFIsol);
           }
 
           std::vector<DetId> selectedCells;
           bool barrel = itElectron->isEB();
           //loop over sub clusters
           if (embedBasicClusters_) {
             for (reco::CaloCluster_iterator clusIt = itElectron->superCluster()->clustersBegin();
                  clusIt != itElectron->superCluster()->clustersEnd();
                  ++clusIt) {
               //get seed (max energy xtal)
               DetId seed = lazyTools.getMaximum(**clusIt).first;
               //get all xtals in 5x5 window around the seed
               std::vector<DetId> dets5x5 =
                   (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
                            : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
               selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
 
               //get all xtals belonging to cluster
               for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
                 selectedCells.push_back(hit.first);
               }
             }
           }
 
           if (embedPflowBasicClusters_ && itElectron->parentSuperCluster().isNonnull()) {
             for (reco::CaloCluster_iterator clusIt = itElectron->parentSuperCluster()->clustersBegin();
                  clusIt != itElectron->parentSuperCluster()->clustersEnd();
                  ++clusIt) {
               //get seed (max energy xtal)
               DetId seed = lazyTools.getMaximum(**clusIt).first;
               //get all xtals in 5x5 window around the seed
               std::vector<DetId> dets5x5 =
                   (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
                            : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
               selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
 
               //get all xtals belonging to cluster
               for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
                 selectedCells.push_back(hit.first);
               }
             }
           }
 
           //remove duplicates
           std::sort(selectedCells.begin(), selectedCells.end());
           std::unique(selectedCells.begin(), selectedCells.end());
 
           // Retrieve the corresponding RecHits
 
           edm::Handle<EcalRecHitCollection> rechitsH;
           if (barrel)
             iEvent.getByToken(reducedBarrelRecHitCollectionToken_, rechitsH);
           else
             iEvent.getByToken(reducedEndcapRecHitCollectionToken_, rechitsH);
 
           EcalRecHitCollection selectedRecHits;
           const EcalRecHitCollection* recHits = rechitsH.product();
 
           unsigned nSelectedCells = selectedCells.size();
           for (unsigned icell = 0; icell < nSelectedCells; ++icell) {
             EcalRecHitCollection::const_iterator it = recHits->find(selectedCells[icell]);
             if (it != recHits->end()) {
               selectedRecHits.push_back(*it);
             }
           }
           selectedRecHits.sort();
           if (embedRecHits_)
             anElectron.embedRecHits(&selectedRecHits);
 
           // set conversion veto selection
           bool passconversionveto = false;
           if (hConversions.isValid()) {
             // this is recommended method
             passconversionveto =
                 !ConversionTools::hasMatchedConversion(*itElectron, *hConversions, beamSpotHandle->position());
           } else {
             // use missing hits without vertex fit method
             passconversionveto =
                 itElectron->gsfTrack()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) < 1;
           }
 
           anElectron.setPassConversionVeto(passconversionveto);
 
           //      fillElectron(anElectron,elecsRef,pfBaseRef,
           //               genMatches, deposits, isolationValues);
 
           //COLIN small warning !
           // we are currently choosing to take the 4-momentum of the PFCandidate;
           // the momentum of the GsfElectron is saved though
           // we must therefore match the GsfElectron.
           // because of this, we should not change the source of the electron matcher
           // to the collection of PFElectrons in the python configuration
           // I don't know what to do with the efficiencyLoader, since I don't know
           // what this class is for.
           fillElectron2(
               anElectron, ptrToPFElectron, ptrToGsfElectron, ptrToGsfElectron, genMatches, deposits, isolationValues);
 
           //COLIN need to use fillElectron2 in the non-pflow case as well, and to test it.
 
           if (computeMiniIso_)
             setElectronMiniIso(anElectron, pc.product());
 
           patElectrons->push_back(anElectron);
         }
       }
       //if( !Matched && !MatchedToAmbiguousGsfTrack) std::cout << "!!!!A pf electron could not be matched to a gsf!!!!"  << std::endl;
     }
   }
 
   else {
     edm::Handle<reco::PFCandidateCollection> pfElectrons;
     edm::Handle<edm::ValueMap<reco::PFCandidatePtr>> ValMapH;
     edm::Handle<edm::ValueMap<std::vector<reco::PFCandidateRef>>> ValMultiMapH;
     bool pfCandsPresent = false, valMapPresent = false;
     if (usePfCandidateMultiMap_) {
       iEvent.getByToken(pfCandidateMultiMapToken_, ValMultiMapH);
     } else {
       pfCandsPresent = iEvent.getByToken(pfElecToken_, pfElectrons);
       valMapPresent = iEvent.getByToken(pfCandidateMapToken_, ValMapH);
     }
 
     for (edm::View<reco::GsfElectron>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end();
          ++itElectron) {
       // construct the Electron from the ref -> save ref to original object
       //FIXME: looks like a lot of instances could be turned into const refs
       unsigned int idx = itElectron - electrons->begin();
       edm::RefToBase<reco::GsfElectron> elecsRef = electrons->refAt(idx);
       reco::CandidateBaseRef elecBaseRef(elecsRef);
       Electron anElectron(elecsRef);
       auto elePtr = electrons->ptrAt(idx);
 
       // Is this GsfElectron also identified as an e- in the particle flow?
       bool pfId = false;
 
       if (usePfCandidateMultiMap_) {
         for (const reco::PFCandidateRef& pf : (*ValMultiMapH)[elePtr]) {
           if (pf->particleId() == reco::PFCandidate::e) {
             pfId = true;
             anElectron.setPFCandidateRef(pf);
             break;
           }
         }
       } else if (pfCandsPresent) {
         // PF electron collection not available.
         const reco::GsfTrackRef& trkRef = itElectron->gsfTrack();
         int index = 0;
         for (reco::PFCandidateConstIterator ie = pfElectrons->begin(); ie != pfElectrons->end(); ++ie, ++index) {
           if (ie->particleId() != reco::PFCandidate::e)
             continue;
           const reco::GsfTrackRef& pfTrkRef = ie->gsfTrackRef();
           if (trkRef == pfTrkRef) {
             pfId = true;
             reco::PFCandidateRef pfRef(pfElectrons, index);
             anElectron.setPFCandidateRef(pfRef);
             break;
           }
         }
       } else if (valMapPresent) {
         // use value map if PF collection not available
         const edm::ValueMap<reco::PFCandidatePtr>& myValMap(*ValMapH);
         // Get the PFCandidate
         const reco::PFCandidatePtr& pfElePtr(myValMap[elecsRef]);
         pfId = pfElePtr.isNonnull();
       }
       // set PFId function
       anElectron.setIsPF(pfId);
 
       // add resolution info
 
       // Isolation
       if (isolator_.enabled()) {
         isolator_.fill(*electrons, idx, isolatorTmpStorage_);
         typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
         // better to loop backwards, so the vector is resized less times
         for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(),
                                                          ed = isolatorTmpStorage_.rend();
              it != ed;
              ++it) {
           anElectron.setIsolation(it->first, it->second);
         }
       }
 
       for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
         anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[elecsRef]);
       }
 
       // add electron ID info
       if (addElecID_) {
         for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
           ids[i].second = (*idhandles[i])[elecsRef];
         }
         anElectron.setElectronIDs(ids);
       }
 
       if (useUserData_) {
         userDataHelper_.add(anElectron, iEvent, iSetup);
       }
 
       double ip3d = -999;  //for mva variable
 
       // embed high level selection
       if (embedHighLevelSelection_) {
         // get the global track
         reco::GsfTrackRef track = itElectron->gsfTrack();
 
         // Make sure the collection it points to is there
         if (track.isNonnull() && track.isAvailable()) {
           reco::TransientTrack tt = trackBuilder->build(track);
           embedHighLevel(anElectron, track, tt, primaryVertex, primaryVertexIsValid, beamSpot, beamSpotIsValid);
 
           std::pair<bool, Measurement1D> ip3dpv = IPTools::absoluteImpactParameter3D(tt, primaryVertex);
           ip3d = ip3dpv.second.value();  // for mva variable
         }
       }
 
       if (addMVAVariables_) {
         // add mva variables
         const auto& vCov = lazyTools.localCovariances(*(itElectron->superCluster()->seed()));
         anElectron.setMvaVariables(vCov[1], ip3d);
       }
 
       // PFCluster Isolation
       if (addPFClusterIso_) {
         // Get PFCluster Isolation
         edm::Handle<edm::ValueMap<float>> ecalPFClusterIsoMapH;
         iEvent.getByToken(ecalPFClusterIsoT_, ecalPFClusterIsoMapH);
         edm::Handle<edm::ValueMap<float>> hcalPFClusterIsoMapH;
         iEvent.getByToken(hcalPFClusterIsoT_, hcalPFClusterIsoMapH);
         reco::GsfElectron::PflowIsolationVariables newPFIsol = anElectron.pfIsolationVariables();
         newPFIsol.sumEcalClusterEt = (*ecalPFClusterIsoMapH)[elecsRef];
         newPFIsol.sumHcalClusterEt = (*hcalPFClusterIsoMapH)[elecsRef];
         anElectron.setPfIsolationVariables(newPFIsol);
       }
 
       if (addPuppiIsolation_) {
         anElectron.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[elePtr],
                                      (*PUPPIIsolation_neutral_hadrons)[elePtr],
                                      (*PUPPIIsolation_photons)[elePtr]);
         anElectron.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[elePtr],
                                               (*PUPPINoLeptonsIsolation_neutral_hadrons)[elePtr],
                                               (*PUPPINoLeptonsIsolation_photons)[elePtr]);
       } else {
         anElectron.setIsolationPUPPI(-999., -999., -999.);
         anElectron.setIsolationPUPPINoLeptons(-999., -999., -999.);
       }
 
       std::vector<DetId> selectedCells;
       bool barrel = itElectron->isEB();
       //loop over sub clusters
       if (embedBasicClusters_) {
         for (reco::CaloCluster_iterator clusIt = itElectron->superCluster()->clustersBegin();
              clusIt != itElectron->superCluster()->clustersEnd();
              ++clusIt) {
           //get seed (max energy xtal)
           DetId seed = lazyTools.getMaximum(**clusIt).first;
           //get all xtals in 5x5 window around the seed
           std::vector<DetId> dets5x5 =
               (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
                        : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
           selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
 
           //get all xtals belonging to cluster
           for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
             selectedCells.push_back(hit.first);
           }
         }
       }
 
       if (embedPflowBasicClusters_ && itElectron->parentSuperCluster().isNonnull()) {
         for (reco::CaloCluster_iterator clusIt = itElectron->parentSuperCluster()->clustersBegin();
              clusIt != itElectron->parentSuperCluster()->clustersEnd();
              ++clusIt) {
           //get seed (max energy xtal)
           DetId seed = lazyTools.getMaximum(**clusIt).first;
           //get all xtals in 5x5 window around the seed
           std::vector<DetId> dets5x5 =
               (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
                        : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
           selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
 
           //get all xtals belonging to cluster
           for (const std::pair<DetId, float>& hit : (*clusIt)->hitsAndFractions()) {
             selectedCells.push_back(hit.first);
           }
         }
       }
 
       //remove duplicates
       std::sort(selectedCells.begin(), selectedCells.end());
       std::unique(selectedCells.begin(), selectedCells.end());
 
       // Retrieve the corresponding RecHits
 
       edm::Handle<EcalRecHitCollection> rechitsH;
       if (barrel)
         iEvent.getByToken(reducedBarrelRecHitCollectionToken_, rechitsH);
       else
         iEvent.getByToken(reducedEndcapRecHitCollectionToken_, rechitsH);
 
       EcalRecHitCollection selectedRecHits;
       const EcalRecHitCollection* recHits = rechitsH.product();
 
       unsigned nSelectedCells = selectedCells.size();
       for (unsigned icell = 0; icell < nSelectedCells; ++icell) {
         EcalRecHitCollection::const_iterator it = recHits->find(selectedCells[icell]);
         if (it != recHits->end()) {
           selectedRecHits.push_back(*it);
         }
       }
       selectedRecHits.sort();
       if (embedRecHits_)
         anElectron.embedRecHits(&selectedRecHits);
 
       // set conversion veto selection
       bool passconversionveto = false;
       if (hConversions.isValid()) {
         // this is recommended method
         passconversionveto =
             !ConversionTools::hasMatchedConversion(*itElectron, *hConversions, beamSpotHandle->position());
       } else {
         // use missing hits without vertex fit method
         passconversionveto =
             itElectron->gsfTrack()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) < 1;
       }
       anElectron.setPassConversionVeto(passconversionveto);
 
       // add sel to selected
       fillElectron(
           anElectron, elecsRef, elecBaseRef, genMatches, deposits, pfId, isolationValues, isolationValuesNoPFId);
 
       if (computeMiniIso_)
         setElectronMiniIso(anElectron, pc.product());
 
       patElectrons->push_back(anElectron);
     }
   }
 
   // sort electrons in pt
   std::sort(patElectrons->begin(), patElectrons->end(), pTComparator_);
 
   // add the electrons to the event output
   std::unique_ptr<std::vector<Electron>> ptr(patElectrons);
   iEvent.put(std::move(ptr));
 
   // clean up
   if (isolator_.enabled())
     isolator_.endEvent();
 }

◆ readIsolationLabels()

template<typename T >

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

private

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

Definition at line 218 of file PATElectronProducer.cc.

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

                                                                                                       {
   labels.clear();
 
   if (iConfig.exists(psetName)) {
     edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>(psetName);
 
     if (depconf.exists("tracker"))
       labels.push_back(std::make_pair(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker")));
     if (depconf.exists("ecal"))
       labels.push_back(std::make_pair(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal")));
     if (depconf.exists("hcal"))
       labels.push_back(std::make_pair(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal")));
     if (depconf.exists("pfAllParticles")) {
       labels.push_back(std::make_pair(pat::PfAllParticleIso, depconf.getParameter<edm::InputTag>("pfAllParticles")));
     }
     if (depconf.exists("pfChargedHadrons")) {
       labels.push_back(
           std::make_pair(pat::PfChargedHadronIso, depconf.getParameter<edm::InputTag>("pfChargedHadrons")));
     }
     if (depconf.exists("pfChargedAll")) {
       labels.push_back(std::make_pair(pat::PfChargedAllIso, depconf.getParameter<edm::InputTag>("pfChargedAll")));
     }
     if (depconf.exists("pfPUChargedHadrons")) {
       labels.push_back(
           std::make_pair(pat::PfPUChargedHadronIso, depconf.getParameter<edm::InputTag>("pfPUChargedHadrons")));
     }
     if (depconf.exists("pfNeutralHadrons")) {
       labels.push_back(
           std::make_pair(pat::PfNeutralHadronIso, depconf.getParameter<edm::InputTag>("pfNeutralHadrons")));
     }
     if (depconf.exists("pfPhotons")) {
       labels.push_back(std::make_pair(pat::PfGammaIso, depconf.getParameter<edm::InputTag>("pfPhotons")));
     }
     if (depconf.exists("user")) {
       std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag>>("user");
       std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
       int key = pat::IsolationKeys::UserBaseIso;
       for (; it != ed; ++it, ++key) {
         labels.push_back(std::make_pair(pat::IsolationKeys(key), *it));
       }
     }
   }
   tokens = edm::vector_transform(
       labels, [this](IsolationLabel const& label) { return consumes<edm::ValueMap<T>>(label.second); });
 }

◆ setElectronMiniIso()

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

private

Definition at line 1199 of file PATElectronProducer.cc.

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

Referenced by produce().

                                                                                                       {
   pat::PFIsolation miniiso;
   if (anElectron.isEE())
     miniiso = pat::getMiniPFIsolation(pc,
                                       anElectron.polarP4(),
                                       miniIsoParamsE_[0],
                                       miniIsoParamsE_[1],
                                       miniIsoParamsE_[2],
                                       miniIsoParamsE_[3],
                                       miniIsoParamsE_[4],
                                       miniIsoParamsE_[5],
                                       miniIsoParamsE_[6],
                                       miniIsoParamsE_[7],
                                       miniIsoParamsE_[8]);
   else
     miniiso = pat::getMiniPFIsolation(pc,
                                       anElectron.polarP4(),
                                       miniIsoParamsB_[0],
                                       miniIsoParamsB_[1],
                                       miniIsoParamsB_[2],
                                       miniIsoParamsB_[3],
                                       miniIsoParamsB_[4],
                                       miniIsoParamsB_[5],
                                       miniIsoParamsB_[6],
                                       miniIsoParamsB_[7],
                                       miniIsoParamsB_[8]);
   anElectron.setMiniPFIsolation(miniiso);
 }

Member Data Documentation

◆ addEfficiencies_

const bool pat::PATElectronProducer::addEfficiencies_

private

Definition at line 193 of file PATElectronProducer.cc.

◆ addElecID_

const bool pat::PATElectronProducer::addElecID_

private

Definition at line 176 of file PATElectronProducer.cc.

Referenced by produce().

◆ addGenMatch_

bool pat::PATElectronProducer::addGenMatch_

private

Definition at line 91 of file PATElectronProducer.cc.

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

◆ addMVAVariables_

const bool pat::PATElectronProducer::addMVAVariables_

private

mva input variables

Definition at line 113 of file PATElectronProducer.cc.

Referenced by produce().

◆ addPFClusterIso_

const bool pat::PATElectronProducer::addPFClusterIso_

private

Definition at line 120 of file PATElectronProducer.cc.

Referenced by produce().

◆ addPuppiIsolation_

const bool pat::PATElectronProducer::addPuppiIsolation_

private

Definition at line 121 of file PATElectronProducer.cc.

Referenced by produce().

◆ addResolutions_

const bool pat::PATElectronProducer::addResolutions_

private

Definition at line 196 of file PATElectronProducer.cc.

◆ beamLineToken_

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

private

Definition at line 127 of file PATElectronProducer.cc.

Referenced by produce().

◆ computeMiniIso_

bool pat::PATElectronProducer::computeMiniIso_

private

Definition at line 96 of file PATElectronProducer.cc.

Referenced by produce().

◆ ecalClusterToolsESGetTokens_

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

private

Definition at line 118 of file PATElectronProducer.cc.

Referenced by produce().

◆ ecalPFClusterIsoT_

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

private

Definition at line 122 of file PATElectronProducer.cc.

Referenced by produce().

◆ ecalTopology_

const CaloTopology* pat::PATElectronProducer::ecalTopology_

private

Definition at line 213 of file PATElectronProducer.cc.

Referenced by produce().

◆ ecalTopologyToken_

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

private

Definition at line 210 of file PATElectronProducer.cc.

Referenced by produce().

◆ efficiencyLoader_

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

private

Definition at line 194 of file PATElectronProducer.cc.

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

◆ elecIDSrcs_

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

private

Definition at line 178 of file PATElectronProducer.cc.

Referenced by produce().

◆ elecIDTokens_

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

private

Definition at line 179 of file PATElectronProducer.cc.

Referenced by produce().

◆ electronToken_

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

private

Definition at line 79 of file PATElectronProducer.cc.

Referenced by produce().

◆ embedBasicClusters_

const bool pat::PATElectronProducer::embedBasicClusters_

private

Definition at line 86 of file PATElectronProducer.cc.

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

◆ embedGenMatch_

bool pat::PATElectronProducer::embedGenMatch_

private

Definition at line 92 of file PATElectronProducer.cc.

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

◆ embedGsfElectronCore_

const bool pat::PATElectronProducer::embedGsfElectronCore_

private

Definition at line 81 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedGsfTrack_

const bool pat::PATElectronProducer::embedGsfTrack_

private

Definition at line 82 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedHighLevelSelection_

const bool pat::PATElectronProducer::embedHighLevelSelection_

private

embed high level selection variables?

Definition at line 126 of file PATElectronProducer.cc.

Referenced by produce().

◆ embedPFCandidate_

const bool pat::PATElectronProducer::embedPFCandidate_

private

Definition at line 110 of file PATElectronProducer.cc.

Referenced by produce().

◆ embedPflowBasicClusters_

const bool pat::PATElectronProducer::embedPflowBasicClusters_

private

Definition at line 88 of file PATElectronProducer.cc.

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

◆ embedPflowPreshowerClusters_

const bool pat::PATElectronProducer::embedPflowPreshowerClusters_

private

Definition at line 89 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedPflowSuperCluster_

const bool pat::PATElectronProducer::embedPflowSuperCluster_

private

Definition at line 84 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedPreshowerClusters_

const bool pat::PATElectronProducer::embedPreshowerClusters_

private

Definition at line 87 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedRecHits_

const bool pat::PATElectronProducer::embedRecHits_

private

Definition at line 93 of file PATElectronProducer.cc.

Referenced by produce().

◆ embedSeedCluster_

const bool pat::PATElectronProducer::embedSeedCluster_

private

Definition at line 85 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedSuperCluster_

const bool pat::PATElectronProducer::embedSuperCluster_

private

Definition at line 83 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ embedTrack_

const bool pat::PATElectronProducer::embedTrack_

private

Definition at line 90 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ genMatchTokens_

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

private

Definition at line 102 of file PATElectronProducer.cc.

Referenced by produce().

◆ hcalPFClusterIsoT_

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

private

Definition at line 123 of file PATElectronProducer.cc.

Referenced by produce().

◆ hConversionsToken_

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

private

Definition at line 80 of file PATElectronProducer.cc.

Referenced by produce().

◆ isoDepositLabels_

IsolationLabels pat::PATElectronProducer::isoDepositLabels_

private

Definition at line 186 of file PATElectronProducer.cc.

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

◆ isoDepositTokens_

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

private

Definition at line 187 of file PATElectronProducer.cc.

Referenced by produce().

◆ isolationValueLabels_

IsolationLabels pat::PATElectronProducer::isolationValueLabels_

private

Definition at line 188 of file PATElectronProducer.cc.

Referenced by fillElectron(), and fillElectron2().

◆ isolationValueLabelsNoPFId_

IsolationLabels pat::PATElectronProducer::isolationValueLabelsNoPFId_

private

Definition at line 190 of file PATElectronProducer.cc.

Referenced by fillElectron().

◆ isolationValueNoPFIdTokens_

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

private

Definition at line 191 of file PATElectronProducer.cc.

Referenced by produce().

◆ isolationValueTokens_

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

private

Definition at line 189 of file PATElectronProducer.cc.

Referenced by produce().

◆ isolator_

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

private

Definition at line 184 of file PATElectronProducer.cc.

Referenced by produce().

◆ isolatorTmpStorage_

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

private

Definition at line 185 of file PATElectronProducer.cc.

Referenced by produce().

◆ miniIsoParamsB_

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

private

Definition at line 98 of file PATElectronProducer.cc.

Referenced by setElectronMiniIso().

◆ miniIsoParamsE_

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

private

Definition at line 97 of file PATElectronProducer.cc.

Referenced by setElectronMiniIso().

◆ pcToken_

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

private

Definition at line 95 of file PATElectronProducer.cc.

Referenced by produce().

◆ pfCandidateMapToken_

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

private

Definition at line 108 of file PATElectronProducer.cc.

Referenced by produce().

◆ pfCandidateMultiMapToken_

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

private

Definition at line 109 of file PATElectronProducer.cc.

Referenced by produce().

◆ pfElecToken_

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

private

Definition at line 107 of file PATElectronProducer.cc.

Referenced by produce().

◆ pTComparator_

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

private

Definition at line 182 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPIIsolation_charged_hadrons_

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

private

Definition at line 201 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPIIsolation_neutral_hadrons_

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

private

Definition at line 202 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPIIsolation_photons_

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

private

Definition at line 203 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPINoLeptonsIsolation_charged_hadrons_

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

private

Definition at line 205 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPINoLeptonsIsolation_neutral_hadrons_

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

private

Definition at line 206 of file PATElectronProducer.cc.

Referenced by produce().

◆ PUPPINoLeptonsIsolation_photons_

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

private

Definition at line 207 of file PATElectronProducer.cc.

Referenced by produce().

◆ pvToken_

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

private

Definition at line 128 of file PATElectronProducer.cc.

Referenced by produce().

◆ reducedBarrelRecHitCollection_

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

private

Definition at line 114 of file PATElectronProducer.cc.

◆ reducedBarrelRecHitCollectionToken_

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

private

Definition at line 115 of file PATElectronProducer.cc.

Referenced by produce().

◆ reducedEndcapRecHitCollection_

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

private

Definition at line 116 of file PATElectronProducer.cc.

◆ reducedEndcapRecHitCollectionToken_

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

private

Definition at line 117 of file PATElectronProducer.cc.

Referenced by produce().

◆ resolutionLoader_

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

private

Definition at line 197 of file PATElectronProducer.cc.

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

◆ trackBuilderToken_

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

private

Definition at line 211 of file PATElectronProducer.cc.

Referenced by produce().

◆ useParticleFlow_

const bool pat::PATElectronProducer::useParticleFlow_

private

pflow specific

Definition at line 105 of file PATElectronProducer.cc.

Referenced by fillElectron(), and produce().

◆ usePfCandidateMultiMap_

const bool pat::PATElectronProducer::usePfCandidateMultiMap_

private

Definition at line 106 of file PATElectronProducer.cc.

Referenced by produce().

◆ userDataHelper_

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

private

Definition at line 208 of file PATElectronProducer.cc.

Referenced by produce().

◆ useUserData_

const bool pat::PATElectronProducer::useUserData_

private

Definition at line 199 of file PATElectronProducer.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ElectronBaseRef

◆ GenAssociations

◆ IsoDepositMaps

◆ IsolationLabel

◆ IsolationLabels

◆ IsolationValueMaps

◆ NameTag

Constructor & Destructor Documentation

◆ PATElectronProducer()

◆ ~PATElectronProducer()

Member Function Documentation

◆ embedHighLevel()

◆ fillDescriptions()

◆ fillElectron()

◆ fillElectron2()

◆ produce()

◆ readIsolationLabels()

◆ setElectronMiniIso()

Member Data Documentation

◆ addEfficiencies_

◆ addElecID_

◆ addGenMatch_

◆ addMVAVariables_

◆ addPFClusterIso_

◆ addPuppiIsolation_

◆ addResolutions_

◆ beamLineToken_

◆ computeMiniIso_

◆ ecalClusterToolsESGetTokens_

◆ ecalPFClusterIsoT_

◆ ecalTopology_

◆ ecalTopologyToken_

◆ efficiencyLoader_

◆ elecIDSrcs_

◆ elecIDTokens_

◆ electronToken_

◆ embedBasicClusters_

◆ embedGenMatch_

◆ embedGsfElectronCore_

◆ embedGsfTrack_

◆ embedHighLevelSelection_

◆ embedPFCandidate_

◆ embedPflowBasicClusters_

◆ embedPflowPreshowerClusters_

◆ embedPflowSuperCluster_

◆ embedPreshowerClusters_

◆ embedRecHits_

◆ embedSeedCluster_

◆ embedSuperCluster_

◆ embedTrack_

◆ genMatchTokens_

◆ hcalPFClusterIsoT_

◆ hConversionsToken_

◆ isoDepositLabels_

◆ isoDepositTokens_

◆ isolationValueLabels_

◆ isolationValueLabelsNoPFId_

◆ isolationValueNoPFIdTokens_

◆ isolationValueTokens_

◆ isolator_

◆ isolatorTmpStorage_

◆ miniIsoParamsB_

◆ miniIsoParamsE_

◆ pcToken_

◆ pfCandidateMapToken_

◆ pfCandidateMultiMapToken_

◆ pfElecToken_

◆ pTComparator_

◆ PUPPIIsolation_charged_hadrons_

◆ PUPPIIsolation_neutral_hadrons_

◆ PUPPIIsolation_photons_

◆ PUPPINoLeptonsIsolation_charged_hadrons_