Inheritance diagram for PFElectronTranslator:

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

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

Public Member Functions
	PFElectronTranslator (const edm::ParameterSet &)

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

	~PFElectronTranslator () 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 Member Functions
const reco::PFCandidate &	correspondingDaughterCandidate (const reco::PFCandidate &cand, const reco::PFBlockElement &pfbe) const

void	createBasicCluster (const reco::PFBlockElement &, reco::BasicClusterCollection &basicClusters, std::vector< const reco::PFCluster *> &, const reco::PFCandidate &coCandidate) const

void	createBasicClusterPtrs (const edm::OrphanHandle< reco::BasicClusterCollection > &basicClustersHandle)

void	createGsfElectronCoreRefs (const edm::OrphanHandle< reco::GsfElectronCoreCollection > &gsfElectronCoreHandle)

void	createGsfElectronCores (reco::GsfElectronCoreCollection &) const

void	createGsfElectrons (const reco::PFCandidateCollection &, const IsolationValueMaps &isolationValues, reco::GsfElectronCollection &)

void	createPreshowerCluster (const reco::PFBlockElement &PFBE, reco::PreshowerClusterCollection &preshowerClusters, unsigned plane) const

void	createPreshowerClusterPtrs (const edm::OrphanHandle< reco::PreshowerClusterCollection > &preshowerClustersHandle)

void	createSuperClusterGsfMapRefs (const edm::OrphanHandle< reco::SuperClusterCollection > &superClustersHandle)

void	createSuperClusters (const reco::PFCandidateCollection &, reco::SuperClusterCollection &superClusters) const

bool	fetchCandidateCollection (edm::Handle< reco::PFCandidateCollection > &c, const edm::EDGetTokenT< reco::PFCandidateCollection > &token, const edm::Event &iEvent) const

void	fetchGsfCollection (edm::Handle< reco::GsfTrackCollection > &c, const edm::EDGetTokenT< reco::GsfTrackCollection > &token, const edm::Event &iEvent) const

void	fillMVAValueMap (edm::Event &iEvent, edm::ValueMap< float >::Filler &filler)

void	fillSCRefValueMap (edm::Event &iEvent, edm::ValueMap< reco::SuperClusterRef >::Filler &filler) const

void	fillValueMap (edm::Event &iEvent, edm::ValueMap< float >::Filler &filler) const

void	getAmbiguousGsfTracks (const reco::PFBlockElement &PFBE, std::vector< reco::GsfTrackRef > &) const

Private Attributes
std::vector< std::vector< reco::GsfTrackRef > >	ambiguousGsfTracks_

std::vector< reco::CaloClusterPtrVector >	basicClusterPtr_

std::vector< reco::BasicClusterCollection >	basicClusters_

std::vector< reco::CandidatePtr >	CandidatePtr_

bool	checkStatusFlag_

edm::ESGetToken< EcalMustacheSCParameters, EcalMustacheSCParametersRcd >	ecalMustacheSCParametersToken_

bool	emptyIsOk_

std::string	GsfElectronCollection_

std::string	GsfElectronCoreCollection_

std::vector< reco::GsfElectronCoreRef >	gsfElectronCoreRefs_

std::map< reco::GsfTrackRef, float >	gsfMvaMap_

std::vector< int >	gsfPFCandidateIndex_

std::vector< reco::GsfTrackRef >	GsfTrackRef_

edm::EDGetTokenT< reco::GsfTrackCollection >	inputTokenGSFTracks_

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

edm::EDGetTokenT< reco::PFCandidateCollection >	inputTokenPFCandidateElectrons_

edm::EDGetTokenT< reco::PFCandidateCollection >	inputTokenPFCandidates_

std::vector< reco::TrackRef >	kfTrackRef_

const EcalMustacheSCParameters *	mustacheSCParams_

double	MVACut_

std::string	PFBasicClusterCollection_

std::vector< std::vector< const reco::PFCluster * > >	pfClusters_

std::string	PFMVAValueMap_

std::string	PFPreshowerClusterCollection_

std::string	PFSCValueMap_

std::string	PFSuperClusterCollection_

std::vector< reco::CaloClusterPtrVector >	preshowerClusterPtr_

std::vector< reco::PreshowerClusterCollection >	preshowerClusters_

std::map< reco::GsfTrackRef, reco::SuperClusterRef >	scMap_

std::vector< reco::SuperClusterCollection >	superClusters_

Detailed Description

Definition at line 28 of file PFElectronTranslator.cc.

Member Typedef Documentation

◆ IsolationValueMaps

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

Definition at line 36 of file PFElectronTranslator.cc.

Constructor & Destructor Documentation

◆ PFElectronTranslator()

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

explicit

Definition at line 171 of file PFElectronTranslator.cc.

References checkStatusFlag_, ecalMustacheSCParametersToken_, emptyIsOk_, edm::ParameterSet::getParameter(), GsfElectronCollection_, GsfElectronCoreCollection_, inputTokenGSFTracks_, inputTokenIsoVals_, inputTokenPFCandidateElectrons_, inputTokenPFCandidates_, MVACut_, PFBasicClusterCollection_, PFMVAValueMap_, PFPreshowerClusterCollection_, PFSCValueMap_, PFSuperClusterCollection_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                          {
   inputTokenPFCandidates_ = consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("PFCandidate"));
   inputTokenPFCandidateElectrons_ =
       consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("PFCandidateElectron"));
   inputTokenGSFTracks_ = consumes<reco::GsfTrackCollection>(iConfig.getParameter<edm::InputTag>("GSFTracks"));
 
   bool useIsolationValues = iConfig.getParameter<bool>("useIsolationValues");
   if (useIsolationValues) {
     const auto& isoVals = iConfig.getParameter<edm::ParameterSet>("isolationValues");
     if (isoVals.empty())
       throw cms::Exception("PFElectronTranslator|InternalError") << "Missing ParameterSet isolationValues";
     else {
       inputTokenIsoVals_.push_back(
           consumes<edm::ValueMap<double>>(isoVals.getParameter<edm::InputTag>("pfSumChargedHadronPt")));
       inputTokenIsoVals_.push_back(
           consumes<edm::ValueMap<double>>(isoVals.getParameter<edm::InputTag>("pfSumPhotonEt")));
       inputTokenIsoVals_.push_back(
           consumes<edm::ValueMap<double>>(isoVals.getParameter<edm::InputTag>("pfSumNeutralHadronEt")));
       inputTokenIsoVals_.push_back(consumes<edm::ValueMap<double>>(isoVals.getParameter<edm::InputTag>("pfSumPUPt")));
     }
   }
 
   PFBasicClusterCollection_ = iConfig.getParameter<std::string>("PFBasicClusters");
   PFPreshowerClusterCollection_ = iConfig.getParameter<std::string>("PFPreshowerClusters");
   PFSuperClusterCollection_ = iConfig.getParameter<std::string>("PFSuperClusters");
   GsfElectronCoreCollection_ = iConfig.getParameter<std::string>("PFGsfElectronCore");
   GsfElectronCollection_ = iConfig.getParameter<std::string>("PFGsfElectron");
 
   PFMVAValueMap_ = iConfig.getParameter<std::string>("ElectronMVA");
   PFSCValueMap_ = iConfig.getParameter<std::string>("ElectronSC");
   MVACut_ = (iConfig.getParameter<edm::ParameterSet>("MVACutBlock")).getParameter<double>("MVACut");
   checkStatusFlag_ = iConfig.getParameter<bool>("CheckStatusFlag");
   emptyIsOk_ = iConfig.getParameter<bool>("emptyIsOk");
 
   ecalMustacheSCParametersToken_ = esConsumes<EcalMustacheSCParameters, EcalMustacheSCParametersRcd>();
 
   produces<reco::BasicClusterCollection>(PFBasicClusterCollection_);
   produces<reco::PreshowerClusterCollection>(PFPreshowerClusterCollection_);
   produces<reco::SuperClusterCollection>(PFSuperClusterCollection_);
   produces<reco::GsfElectronCoreCollection>(GsfElectronCoreCollection_);
   produces<reco::GsfElectronCollection>(GsfElectronCollection_);
   produces<edm::ValueMap<float>>(PFMVAValueMap_);
   produces<edm::ValueMap<reco::SuperClusterRef>>(PFSCValueMap_);
 }

◆ ~PFElectronTranslator()

PFElectronTranslator::~PFElectronTranslator ( )

override

Definition at line 216 of file PFElectronTranslator.cc.

216 {}

Member Function Documentation

◆ correspondingDaughterCandidate()

const reco::PFCandidate & PFElectronTranslator::correspondingDaughterCandidate	(	const reco::PFCandidate &	cand,
		const reco::PFBlockElement &	pfbe
	)		const

private

Definition at line 626 of file PFElectronTranslator.cc.

References reco::PFCandidate::elementsInBlocks(), and reco::PFBlockElement::index().

Referenced by produce().

                                                                                                                     {
   unsigned refindex = pfbe.index();
   //  std::cout << " N daughters " << cand.numberOfDaughters() << std::endl;
   reco::PFCandidate::const_iterator myDaughterCandidate = cand.begin();
   reco::PFCandidate::const_iterator itend = cand.end();
 
   for (; myDaughterCandidate != itend; ++myDaughterCandidate) {
     const reco::PFCandidate* myPFCandidate = (const reco::PFCandidate*)&*myDaughterCandidate;
     if (myPFCandidate->elementsInBlocks().size() != 1) {
       //      std::cout << " Daughter with " << myPFCandidate.elementsInBlocks().size()<< " element in block " << std::endl;
       return cand;
     }
     if (myPFCandidate->elementsInBlocks()[0].second == refindex) {
       //      std::cout << " Found it " << cand << std::endl;
       return *myPFCandidate;
     }
   }
   return cand;
 }

◆ createBasicCluster()

void PFElectronTranslator::createBasicCluster	(	const reco::PFBlockElement &	PFBE,
		reco::BasicClusterCollection &	basicClusters,
		std::vector< const reco::PFCluster *> &	pfClusters,
		const reco::PFCandidate &	coCandidate
	)		const

private

Definition at line 415 of file PFElectronTranslator.cc.

References reco::CaloCluster::algo(), reco::CaloCluster::caloID(), reco::PFBlockElement::clusterRef(), reco::CaloCluster::hitsAndFractions(), edm::Ref< C, T, F >::isNull(), reco::CaloCluster::position(), reco::PFCandidate::rawEcalEnergy(), and reco::CaloCluster::seed().

Referenced by produce().

                                                                                         {
   const reco::PFClusterRef& myPFClusterRef = PFBE.clusterRef();
   if (myPFClusterRef.isNull())
     return;
 
   const reco::PFCluster& myPFCluster(*myPFClusterRef);
   pfClusters.push_back(&myPFCluster);
   //  std::cout << " Creating BC " << myPFCluster.energy() << " " << coCandidate.ecalEnergy() <<" "<<  coCandidate.rawEcalEnergy() <<std::endl;
   //  std::cout << " # hits " << myPFCluster.hitsAndFractions().size() << std::endl;
 
   //  basicClusters.push_back(reco::CaloCluster(myPFCluster.energy(),
   basicClusters.push_back(reco::CaloCluster(
       //        myPFCluster.energy(),
       coCandidate.rawEcalEnergy(),
       myPFCluster.position(),
       myPFCluster.caloID(),
       myPFCluster.hitsAndFractions(),
       myPFCluster.algo(),
       myPFCluster.seed()));
 }

◆ createBasicClusterPtrs()

void PFElectronTranslator::createBasicClusterPtrs ( const edm::OrphanHandle< reco::BasicClusterCollection > & basicClustersHandle )

private

Definition at line 447 of file PFElectronTranslator.cc.

References basicClusterPtr_, basicClusters_, GsfTrackRef_, and findQualityFiles::size.

Referenced by produce().

                                                                             {
   unsigned size = GsfTrackRef_.size();
   unsigned basicClusterCounter = 0;
   basicClusterPtr_.resize(size);
 
   for (unsigned iGSF = 0; iGSF < size; ++iGSF)  // loop on tracks
   {
     unsigned nbc = basicClusters_[iGSF].size();
     for (unsigned ibc = 0; ibc < nbc; ++ibc)  // loop on basic clusters
     {
       //      std::cout <<  "Track "<< iGSF << " ref " << basicClusterCounter << std::endl;
       reco::CaloClusterPtr bcPtr(basicClustersHandle, basicClusterCounter);
       basicClusterPtr_[iGSF].push_back(bcPtr);
       ++basicClusterCounter;
     }
   }
 }

◆ createGsfElectronCoreRefs()

void PFElectronTranslator::createGsfElectronCoreRefs ( const edm::OrphanHandle< reco::GsfElectronCoreCollection > & gsfElectronCoreHandle )

private

Definition at line 659 of file PFElectronTranslator.cc.

References gsfElectronCoreRefs_, GsfTrackRef_, and findQualityFiles::size.

Referenced by produce().

                                                                                  {
   unsigned size = GsfTrackRef_.size();
 
   for (unsigned iGSF = 0; iGSF < size; ++iGSF)  // loop on tracks
   {
     edm::Ref<reco::GsfElectronCoreCollection> elecCoreRef(gsfElectronCoreHandle, iGSF);
     gsfElectronCoreRefs_.push_back(elecCoreRef);
   }
 }

◆ createGsfElectronCores()

void PFElectronTranslator::createGsfElectronCores ( reco::GsfElectronCoreCollection & gsfElectronCores ) const

private

Definition at line 647 of file PFElectronTranslator.cc.

References GsfTrackRef_, kfTrackRef_, scMap_, reco::GsfElectronCore::setCtfTrack(), and reco::GsfElectronCore::setParentSuperCluster().

Referenced by produce().

                                                                                                        {
   unsigned nGSF = GsfTrackRef_.size();
   for (unsigned iGSF = 0; iGSF < nGSF; ++iGSF) {
     reco::GsfElectronCore myElectronCore(GsfTrackRef_[iGSF]);
     myElectronCore.setCtfTrack(kfTrackRef_[iGSF], -1.);
     std::map<reco::GsfTrackRef, reco::SuperClusterRef>::const_iterator itcheck = scMap_.find(GsfTrackRef_[iGSF]);
     if (itcheck != scMap_.end())
       myElectronCore.setParentSuperCluster(itcheck->second);
     gsfElectronCores.push_back(myElectronCore);
   }
 }

◆ createGsfElectrons()

void PFElectronTranslator::createGsfElectrons	(	const reco::PFCandidateCollection &	pfcand,
		const IsolationValueMaps &	isolationValues,
		reco::GsfElectronCollection &	gsfelectrons
	)

private

Definition at line 682 of file PFElectronTranslator.cc.

Referenced by produce().

                                                                                        {
   unsigned size = GsfTrackRef_.size();
 
   for (unsigned iGSF = 0; iGSF < size; ++iGSF)  // loop on tracks
   {
     const reco::PFCandidate& pfCandidate(pfcand[gsfPFCandidateIndex_[iGSF]]);
     // Electron
     reco::GsfElectron myElectron(gsfElectronCoreRefs_[iGSF]);
     // Warning set p4 error !
     myElectron.setP4(reco::GsfElectron::P4_PFLOW_COMBINATION, pfCandidate.p4(), pfCandidate.deltaP(), true);
 
     // MVA inputs
     reco::GsfElectron::MvaInput myMvaInput;
     myMvaInput.earlyBrem = pfCandidate.electronExtraRef()->mvaVariable(reco::PFCandidateElectronExtra::MVA_FirstBrem);
     myMvaInput.lateBrem = pfCandidate.electronExtraRef()->mvaVariable(reco::PFCandidateElectronExtra::MVA_LateBrem);
     myMvaInput.deltaEta =
         pfCandidate.electronExtraRef()->mvaVariable(reco::PFCandidateElectronExtra::MVA_DeltaEtaTrackCluster);
     myMvaInput.sigmaEtaEta = pfCandidate.electronExtraRef()->sigmaEtaEta();
     myMvaInput.hadEnergy = pfCandidate.electronExtraRef()->hadEnergy();
 
     // Mustache
     reco::Mustache myMustache(mustacheSCParams_);
     myMustache.MustacheID(
         *(myElectron.parentSuperCluster()), myMvaInput.nClusterOutsideMustache, myMvaInput.etOutsideMustache);
 
     myElectron.setMvaInput(myMvaInput);
 
     // MVA output
     reco::GsfElectron::MvaOutput myMvaOutput;
     myMvaOutput.status = pfCandidate.electronExtraRef()->electronStatus();
     myMvaOutput.mva_e_pi = pfCandidate.mva_e_pi();
     myElectron.setMvaOutput(myMvaOutput);
 
     // ambiguous tracks
     unsigned ntracks = ambiguousGsfTracks_[iGSF].size();
     for (unsigned it = 0; it < ntracks; ++it) {
       myElectron.addAmbiguousGsfTrack(ambiguousGsfTracks_[iGSF][it]);
     }
 
     // isolation
     if (!isolationValues.empty()) {
       reco::GsfElectron::PflowIsolationVariables myPFIso;
       myPFIso.sumChargedHadronPt = (*isolationValues[0])[CandidatePtr_[iGSF]];
       myPFIso.sumPhotonEt = (*isolationValues[1])[CandidatePtr_[iGSF]];
       myPFIso.sumNeutralHadronEt = (*isolationValues[2])[CandidatePtr_[iGSF]];
       myPFIso.sumPUPt = (*isolationValues[3])[CandidatePtr_[iGSF]];
       myElectron.setPfIsolationVariables(myPFIso);
     }
 
     gsfelectrons.push_back(myElectron);
   }
 }

◆ createPreshowerCluster()

void PFElectronTranslator::createPreshowerCluster	(	const reco::PFBlockElement &	PFBE,
		reco::PreshowerClusterCollection &	preshowerClusters,
		unsigned	plane
	)		const

private

Definition at line 439 of file PFElectronTranslator.cc.

References reco::PFBlockElement::clusterRef().

Referenced by produce().

                                                                         {
   const reco::PFClusterRef& myPFClusterRef = PFBE.clusterRef();
   preshowerClusters.push_back(reco::PreshowerCluster(
       myPFClusterRef->energy(), myPFClusterRef->position(), myPFClusterRef->hitsAndFractions(), plane));
 }

◆ createPreshowerClusterPtrs()

void PFElectronTranslator::createPreshowerClusterPtrs ( const edm::OrphanHandle< reco::PreshowerClusterCollection > & preshowerClustersHandle )

private

Definition at line 466 of file PFElectronTranslator.cc.

References GsfTrackRef_, preshowerClusterPtr_, preshowerClusters_, and findQualityFiles::size.

Referenced by produce().

                                                                                     {
   unsigned size = GsfTrackRef_.size();
   unsigned psClusterCounter = 0;
   preshowerClusterPtr_.resize(size);
 
   for (unsigned iGSF = 0; iGSF < size; ++iGSF)  // loop on tracks
   {
     unsigned nbc = preshowerClusters_[iGSF].size();
     for (unsigned ibc = 0; ibc < nbc; ++ibc)  // loop on basic clusters
     {
       //      std::cout <<  "Track "<< iGSF << " ref " << basicClusterCounter << std::endl;
       reco::CaloClusterPtr psPtr(preshowerClustersHandle, psClusterCounter);
       preshowerClusterPtr_[iGSF].push_back(psPtr);
       ++psClusterCounter;
     }
   }
 }

◆ createSuperClusterGsfMapRefs()

void PFElectronTranslator::createSuperClusterGsfMapRefs ( const edm::OrphanHandle< reco::SuperClusterCollection > & superClustersHandle )

private

Definition at line 485 of file PFElectronTranslator.cc.

References GsfTrackRef_, scMap_, and findQualityFiles::size.

Referenced by produce().

                                                                             {
   unsigned size = GsfTrackRef_.size();
 
   for (unsigned iGSF = 0; iGSF < size; ++iGSF)  // loop on tracks
   {
     edm::Ref<reco::SuperClusterCollection> scRef(superClustersHandle, iGSF);
     scMap_[GsfTrackRef_[iGSF]] = scRef;
   }
 }

◆ createSuperClusters()

void PFElectronTranslator::createSuperClusters	(	const reco::PFCandidateCollection &	pfCand,
		reco::SuperClusterCollection &	superClusters
	)		const

private

Definition at line 550 of file PFElectronTranslator.cc.

References reco::SuperCluster::addCluster(), reco::CaloCluster::addHitAndFraction(), reco::SuperCluster::addPreshowerCluster(), basicClusterPtr_, basicClusters_, MillePedeFileConverter_cfg::e, gsfPFCandidateIndex_, GsfTrackRef_, pfClusters_, PFClusterWidthAlgo::pflowEtaWidth(), PFClusterWidthAlgo::pflowPhiWidth(), RecoTauValidation_cfi::posX, RecoTauValidation_cfi::posY, preshowerClusterPtr_, reco::SuperCluster::rawEnergy(), reco::SuperCluster::setEtaWidth(), reco::SuperCluster::setPhiWidth(), reco::SuperCluster::setPreshowerEnergy(), reco::SuperCluster::setSeed(), HLT_2024v13_cff::superClusters, and trackerHitRTTI::vector.

Referenced by produce().

                                                                                                 {
   unsigned nGSF = GsfTrackRef_.size();
   for (unsigned iGSF = 0; iGSF < nGSF; ++iGSF) {
     // Computes energy position a la e/gamma
     double sclusterE = 0;
     double posX = 0.;
     double posY = 0.;
     double posZ = 0.;
 
     unsigned nbasics = basicClusters_[iGSF].size();
     for (unsigned ibc = 0; ibc < nbasics; ++ibc) {
       double e = basicClusters_[iGSF][ibc].energy();
       sclusterE += e;
       posX += e * basicClusters_[iGSF][ibc].position().X();
       posY += e * basicClusters_[iGSF][ibc].position().Y();
       posZ += e * basicClusters_[iGSF][ibc].position().Z();
     }
     posX /= sclusterE;
     posY /= sclusterE;
     posZ /= sclusterE;
 
     if (pfCand[gsfPFCandidateIndex_[iGSF]].gsfTrackRef() != GsfTrackRef_[iGSF]) {
       edm::LogError("PFElectronTranslator") << " Major problem in PFElectron Translator" << std::endl;
     }
 
     // compute the width
     PFClusterWidthAlgo pfwidth(pfClusters_[iGSF]);
 
     double correctedEnergy = pfCand[gsfPFCandidateIndex_[iGSF]].ecalEnergy();
     reco::SuperCluster mySuperCluster(correctedEnergy, math::XYZPoint(posX, posY, posZ));
     // protection against empty basic cluster collection ; the value is -2 in this case
     if (nbasics) {
       //      std::cout << "SuperCluster creation; energy " << pfCand[gsfPFCandidateIndex_[iGSF]].ecalEnergy();
       //      std::cout << " " <<   pfCand[gsfPFCandidateIndex_[iGSF]].rawEcalEnergy() << std::endl;
       //      std::cout << "Seed energy from basic " << basicClusters_[iGSF][0].energy() << std::endl;
       mySuperCluster.setSeed(basicClusterPtr_[iGSF][0]);
     } else {
       //      std::cout << "SuperCluster creation ; seed energy " << 0 << std::endl;
       //      std::cout << "SuperCluster creation ; energy " << pfCand[gsfPFCandidateIndex_[iGSF]].ecalEnergy();
       //      std::cout << " " <<   pfCand[gsfPFCandidateIndex_[iGSF]].rawEcalEnergy() << std::endl;
       //      std::cout << " No seed found " << 0 << std::endl;
       //      std::cout << " MVA " << pfCand[gsfPFCandidateIndex_[iGSF]].mva_e_pi() << std::endl;
       mySuperCluster.setSeed(reco::CaloClusterPtr());
     }
     // the seed should be the first basic cluster
 
     for (unsigned ibc = 0; ibc < nbasics; ++ibc) {
       mySuperCluster.addCluster(basicClusterPtr_[iGSF][ibc]);
       //      std::cout <<"Adding Ref to SC " << basicClusterPtr_[iGSF][ibc].index() << std::endl;
       const std::vector<std::pair<DetId, float>>& v1 = basicClusters_[iGSF][ibc].hitsAndFractions();
       //      std::cout << " Number of cells " << v1.size() << std::endl;
       for (std::vector<std::pair<DetId, float>>::const_iterator diIt = v1.begin(); diIt != v1.end(); ++diIt) {
         //      std::cout << " Adding DetId " << (diIt->first).rawId() << " " << diIt->second << std::endl;
         mySuperCluster.addHitAndFraction(diIt->first, diIt->second);
       }  // loop over rechits
     }
 
     unsigned nps = preshowerClusterPtr_[iGSF].size();
     for (unsigned ips = 0; ips < nps; ++ips) {
       mySuperCluster.addPreshowerCluster(preshowerClusterPtr_[iGSF][ips]);
     }
 
     // Set the preshower energy
     mySuperCluster.setPreshowerEnergy(pfCand[gsfPFCandidateIndex_[iGSF]].pS1Energy() +
                                       pfCand[gsfPFCandidateIndex_[iGSF]].pS2Energy());
 
     // Set the cluster width
     mySuperCluster.setEtaWidth(pfwidth.pflowEtaWidth());
     mySuperCluster.setPhiWidth(pfwidth.pflowPhiWidth());
     // Force the computation of rawEnergy_ of the reco::SuperCluster
     mySuperCluster.rawEnergy();
     superClusters.push_back(mySuperCluster);
   }
 }

◆ fetchCandidateCollection()

bool PFElectronTranslator::fetchCandidateCollection	(	edm::Handle< reco::PFCandidateCollection > &	c,
		const edm::EDGetTokenT< reco::PFCandidateCollection > &	token,
		const edm::Event &	iEvent
	)		const

private

Definition at line 386 of file PFElectronTranslator.cc.

References DummyCfis::c, emptyIsOk_, submitPVResolutionJobs::err, iEvent, and unpackBuffers-CaloStage2::token.

Referenced by fillMVAValueMap(), and produce().

                                                                                   {
   c = iEvent.getHandle(token);
 
   if (!c.isValid() && !emptyIsOk_) {
     std::ostringstream err;
     err << " cannot get PFCandidates " << std::endl;
     edm::LogError("PFElectronTranslator") << err.str();
   }
   return c.isValid();
 }

◆ fetchGsfCollection()

void PFElectronTranslator::fetchGsfCollection	(	edm::Handle< reco::GsfTrackCollection > &	c,
		const edm::EDGetTokenT< reco::GsfTrackCollection > &	token,
		const edm::Event &	iEvent
	)		const

private

Definition at line 399 of file PFElectronTranslator.cc.

References DummyCfis::c, submitPVResolutionJobs::err, Exception, iEvent, and unpackBuffers-CaloStage2::token.

Referenced by fillMVAValueMap(), and fillSCRefValueMap().

                                                                             {
   c = iEvent.getHandle(token);
 
   if (!c.isValid()) {
     std::ostringstream err;
     err << " cannot get GSFTracks " << std::endl;
     edm::LogError("PFElectronTranslator") << err.str();
     throw cms::Exception("MissingProduct", err.str());
   }
 }

◆ fillDescriptions()

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

static

Definition at line 144 of file PFElectronTranslator.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                       {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("PFCandidate", {"pfSelectedElectrons"});
   desc.add<edm::InputTag>("PFCandidateElectron", {"particleFlowTmp:electrons"});
   desc.add<edm::InputTag>("GSFTracks", {"electronGsfTracks"});
   desc.add<std::string>("PFBasicClusters", "pf");
   desc.add<std::string>("PFPreshowerClusters", "pf");
   desc.add<std::string>("PFSuperClusters", "pf");
   desc.add<std::string>("ElectronMVA", "pf");
   desc.add<std::string>("ElectronSC", "pf");
   desc.add<std::string>("PFGsfElectron", "pf");
   desc.add<std::string>("PFGsfElectronCore", "pf");
   desc.add<edm::ParameterSetDescription>("MVACutBlock", {});
   desc.add<bool>("CheckStatusFlag", true);
   desc.add<bool>("useIsolationValues", false);
   {
     edm::ParameterSetDescription pset;
     pset.add<edm::InputTag>("pfSumChargedHadronPt", {"elPFIsoValueCharged04PFId"});
     pset.add<edm::InputTag>("pfSumPhotonEt", {"elPFIsoValueGamma04PFId"});
     pset.add<edm::InputTag>("pfSumNeutralHadronEt", {"elPFIsoValueNeutral04PFId"});
     pset.add<edm::InputTag>("pfSumPUPt", {"elPFIsoValuePU04PFId"});
     desc.add<edm::ParameterSetDescription>("isolationValues", pset);
   }
   desc.add<bool>("emptyIsOk", false);
   descriptions.addWithDefaultLabel(desc);
 }

◆ fillMVAValueMap()

void PFElectronTranslator::fillMVAValueMap	(	edm::Event &	iEvent,
		edm::ValueMap< float >::Filler &	filler
	)

private

Definition at line 496 of file PFElectronTranslator.cc.

References reco::PFCandidate::e, fetchCandidateCollection(), fetchGsfCollection(), trigObjTnPSource_cfi::filler, gsfMvaMap_, ecalDrivenGsfElectronCoresHGC_cff::gsfTracks, mps_fire::i, iEvent, inputTokenGSFTracks_, inputTokenPFCandidateElectrons_, zmumugammaAnalyzer_cfi::pfCandidates, mps_update::status, and contentValuesCheck::values.

Referenced by produce().

                                                                                              {
   gsfMvaMap_.clear();
   edm::Handle<reco::PFCandidateCollection> pfCandidates;
   bool status = fetchCandidateCollection(pfCandidates, inputTokenPFCandidateElectrons_, iEvent);
 
   unsigned ncand = (status) ? pfCandidates->size() : 0;
   for (unsigned i = 0; i < ncand; ++i) {
     const reco::PFCandidate& cand = (*pfCandidates)[i];
     if (cand.particleId() != reco::PFCandidate::e)
       continue;
     if (cand.gsfTrackRef().isNull())
       continue;
     // Fill the MVA map
     gsfMvaMap_[cand.gsfTrackRef()] = cand.mva_e_pi();
   }
 
   edm::Handle<reco::GsfTrackCollection> gsfTracks;
   fetchGsfCollection(gsfTracks, inputTokenGSFTracks_, iEvent);
   unsigned ngsf = gsfTracks->size();
   std::vector<float> values;
   for (unsigned igsf = 0; igsf < ngsf; ++igsf) {
     reco::GsfTrackRef theTrackRef(gsfTracks, igsf);
     std::map<reco::GsfTrackRef, float>::const_iterator itcheck = gsfMvaMap_.find(theTrackRef);
     if (itcheck == gsfMvaMap_.end()) {
       //      edm::LogWarning("PFElectronTranslator") << "MVA Map, missing GSF track ref " << std::endl;
       values.push_back(-99.);
       //      std::cout << " Push_back -99. " << std::endl;
     } else {
       //      std::cout <<  " Value " << itcheck->second << std::endl;
       values.push_back(itcheck->second);
     }
   }
   filler.insert(gsfTracks, values.begin(), values.end());
 }

◆ fillSCRefValueMap()

void PFElectronTranslator::fillSCRefValueMap	(	edm::Event &	iEvent,
		edm::ValueMap< reco::SuperClusterRef >::Filler &	filler
	)		const

private

Definition at line 531 of file PFElectronTranslator.cc.

References fetchGsfCollection(), trigObjTnPSource_cfi::filler, ecalDrivenGsfElectronCoresHGC_cff::gsfTracks, iEvent, inputTokenGSFTracks_, scMap_, and contentValuesCheck::values.

Referenced by produce().

                                                                                                    {
   edm::Handle<reco::GsfTrackCollection> gsfTracks;
   fetchGsfCollection(gsfTracks, inputTokenGSFTracks_, iEvent);
   unsigned ngsf = gsfTracks->size();
   std::vector<reco::SuperClusterRef> values;
   for (unsigned igsf = 0; igsf < ngsf; ++igsf) {
     reco::GsfTrackRef theTrackRef(gsfTracks, igsf);
     std::map<reco::GsfTrackRef, reco::SuperClusterRef>::const_iterator itcheck = scMap_.find(theTrackRef);
     if (itcheck == scMap_.end()) {
       //      edm::LogWarning("PFElectronTranslator") << "SCRef Map, missing GSF track ref" << std::endl;
       values.push_back(reco::SuperClusterRef());
     } else {
       values.push_back(itcheck->second);
     }
   }
   filler.insert(gsfTracks, values.begin(), values.end());
 }

◆ fillValueMap()

void PFElectronTranslator::fillValueMap	(	edm::Event &	iEvent,
		edm::ValueMap< float >::Filler &	filler
	)		const

private

◆ getAmbiguousGsfTracks()

void PFElectronTranslator::getAmbiguousGsfTracks	(	const reco::PFBlockElement &	PFBE,
		std::vector< reco::GsfTrackRef > &	tracks
	)		const

private

Definition at line 670 of file PFElectronTranslator.cc.

References reco::PFBlockElementGsfTrack::GsftrackRefPF(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, vertices_cff::ntracks, and DiMuonV_cfg::tracks.

Referenced by produce().

                                                                                            {
   const reco::PFBlockElementGsfTrack* GsfEl = dynamic_cast<const reco::PFBlockElementGsfTrack*>(&PFBE);
   if (GsfEl == nullptr)
     return;
   const std::vector<reco::GsfPFRecTrackRef>& ambPFRecTracks(GsfEl->GsftrackRefPF()->convBremGsfPFRecTrackRef());
   unsigned ntracks = ambPFRecTracks.size();
   for (unsigned it = 0; it < ntracks; ++it) {
     tracks.push_back(ambPFRecTracks[it]->gsfTrackRef());
   }
 }

◆ produce()

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

override

Definition at line 218 of file PFElectronTranslator.cc.

References ambiguousGsfTracks_, basicClusterPtr_, basicClusters_, CandidatePtr_, checkStatusFlag_, correspondingDaughterCandidate(), createBasicCluster(), createBasicClusterPtrs(), createGsfElectronCoreRefs(), createGsfElectronCores(), createGsfElectrons(), createPreshowerCluster(), createPreshowerClusterPtrs(), createSuperClusterGsfMapRefs(), createSuperClusters(), reco::PFCandidate::e, reco::PFBlockElement::ECAL, ecalMustacheSCParametersToken_, bookConverter::elements, fetchCandidateCollection(), fillMVAValueMap(), fillSCRefValueMap(), getAmbiguousGsfTracks(), edm::EventSetup::getData(), reco::PFBlockElement::GSF, GsfElectronCollection_, GsfElectronCoreCollection_, gsfElectronCoreRefs_, gsfPFCandidateIndex_, GsfTrackRef_, mps_fire::i, iEvent, inputTokenIsoVals_, inputTokenPFCandidates_, edm::Ref< C, T, F >::isNull(), displacedMuonProducer_cff::isolationValues, dqmiolumiharvest::j, kfTrackRef_, eostools::move(), mustacheSCParams_, MVACut_, PFBasicClusterCollection_, zmumugammaAnalyzer_cfi::pfCandidates, pfClusters_, PFMVAValueMap_, PFPreshowerClusterCollection_, PFSCValueMap_, PFSuperClusterCollection_, preshowerClusterPtr_, preshowerClusters_, reco::PFBlockElement::PS1, reco::PFBlockElement::PS2, scMap_, reco::PFCandidateElectronExtra::Selected, mps_update::status, superClusters_, and reco::PFBlockElement::type().

                                                                                 {
   mustacheSCParams_ = &iSetup.getData(ecalMustacheSCParametersToken_);
 
   auto gsfElectronCores_p = std::make_unique<reco::GsfElectronCoreCollection>();
 
   auto gsfElectrons_p = std::make_unique<reco::GsfElectronCollection>();
 
   auto superClusters_p = std::make_unique<reco::SuperClusterCollection>();
 
   auto basicClusters_p = std::make_unique<reco::BasicClusterCollection>();
 
   auto psClusters_p = std::make_unique<reco::PreshowerClusterCollection>();
 
   auto mvaMap_p = std::make_unique<edm::ValueMap<float>>();
   edm::ValueMap<float>::Filler mvaFiller(*mvaMap_p);
 
   auto scMap_p = std::make_unique<edm::ValueMap<reco::SuperClusterRef>>();
   edm::ValueMap<reco::SuperClusterRef>::Filler scRefFiller(*scMap_p);
 
   edm::Handle<reco::PFCandidateCollection> pfCandidates;
   bool status = fetchCandidateCollection(pfCandidates, inputTokenPFCandidates_, iEvent);
 
   IsolationValueMaps isolationValues(inputTokenIsoVals_.size());
   for (size_t j = 0; j < inputTokenIsoVals_.size(); ++j) {
     isolationValues[j] = iEvent.getHandle(inputTokenIsoVals_[j]);
   }
 
   // clear the vectors
   GsfTrackRef_.clear();
   CandidatePtr_.clear();
   ambiguousGsfTracks_.clear();
   kfTrackRef_.clear();
   basicClusters_.clear();
   pfClusters_.clear();
   preshowerClusters_.clear();
   superClusters_.clear();
   basicClusterPtr_.clear();
   preshowerClusterPtr_.clear();
   gsfPFCandidateIndex_.clear();
   gsfElectronCoreRefs_.clear();
   scMap_.clear();
 
   // loop on the candidates
   //CC@@
   // we need first to create AND put the SuperCluster,
   // basic clusters and presh clusters collection
   // in order to get a working Handle
   unsigned ncand = (status) ? pfCandidates->size() : 0;
   unsigned iGSF = 0;
   for (unsigned i = 0; i < ncand; ++i) {
     const reco::PFCandidate& cand = (*pfCandidates)[i];
     if (cand.particleId() != reco::PFCandidate::e)
       continue;
     if (cand.gsfTrackRef().isNull())
       continue;
     // Note that -1 will still cut some total garbage candidates
     // Fill the MVA map
     if (cand.mva_e_pi() < MVACut_)
       continue;
 
     // Check the status flag
     if (checkStatusFlag_ && !cand.electronExtraRef()->electronStatus(reco::PFCandidateElectronExtra::Selected)) {
       continue;
     }
 
     GsfTrackRef_.push_back(cand.gsfTrackRef());
     kfTrackRef_.push_back(cand.trackRef());
     gsfPFCandidateIndex_.push_back(i);
 
     reco::PFCandidatePtr ptrToPFElectron(pfCandidates, i);
     //CandidatePtr_.push_back(ptrToPFElectron->sourceCandidatePtr(0));
     CandidatePtr_.push_back(ptrToPFElectron);
 
     basicClusters_.push_back(reco::BasicClusterCollection());
     pfClusters_.push_back(std::vector<const reco::PFCluster*>());
     preshowerClusters_.push_back(reco::PreshowerClusterCollection());
     ambiguousGsfTracks_.push_back(std::vector<reco::GsfTrackRef>());
 
     for (unsigned iele = 0; iele < cand.elementsInBlocks().size(); ++iele) {
       // first get the block
       reco::PFBlockRef blockRef = cand.elementsInBlocks()[iele].first;
       //
       unsigned elementIndex = cand.elementsInBlocks()[iele].second;
       // check it actually exists
       if (blockRef.isNull())
         continue;
 
       // then get the elements of the block
       const edm::OwnVector<reco::PFBlockElement>& elements = (*blockRef).elements();
 
       const reco::PFBlockElement& pfbe(elements[elementIndex]);
       // The first ECAL element should be the cluster associated to the GSF; defined as the seed
       if (pfbe.type() == reco::PFBlockElement::ECAL) {
         //    const reco::PFCandidate * coCandidate = &cand;
         // the Brem photons are saved as daughter PFCandidate; this
         // is convenient to access the corrected energy
         //    std::cout << " Found candidate "  << correspondingDaughterCandidate(coCandidate,pfbe) << " " << coCandidate << std::endl;
         createBasicCluster(pfbe, basicClusters_[iGSF], pfClusters_[iGSF], correspondingDaughterCandidate(cand, pfbe));
       }
       if (pfbe.type() == reco::PFBlockElement::PS1) {
         createPreshowerCluster(pfbe, preshowerClusters_[iGSF], 1);
       }
       if (pfbe.type() == reco::PFBlockElement::PS2) {
         createPreshowerCluster(pfbe, preshowerClusters_[iGSF], 2);
       }
       if (pfbe.type() == reco::PFBlockElement::GSF) {
         getAmbiguousGsfTracks(pfbe, ambiguousGsfTracks_[iGSF]);
       }
 
     }  // loop on the elements
 
     // save the basic clusters
     basicClusters_p->insert(basicClusters_p->end(), basicClusters_[iGSF].begin(), basicClusters_[iGSF].end());
     // save the preshower clusters
     psClusters_p->insert(psClusters_p->end(), preshowerClusters_[iGSF].begin(), preshowerClusters_[iGSF].end());
 
     ++iGSF;
   }  // loop on PFCandidates
 
   //Save the basic clusters and get an handle as to be able to create valid Refs (thanks to Claude)
   //  std::cout << " Number of basic clusters " << basicClusters_p->size() << std::endl;
   const edm::OrphanHandle<reco::BasicClusterCollection> bcRefProd =
       iEvent.put(std::move(basicClusters_p), PFBasicClusterCollection_);
 
   //preshower clusters
   const edm::OrphanHandle<reco::PreshowerClusterCollection> psRefProd =
       iEvent.put(std::move(psClusters_p), PFPreshowerClusterCollection_);
 
   // now that the Basic clusters are in the event, the Ref can be created
   createBasicClusterPtrs(bcRefProd);
   // now that the preshower clusters are in the event, the Ref can be created
   createPreshowerClusterPtrs(psRefProd);
 
   // and now the Super cluster can be created with valid references
   if (status)
     createSuperClusters(*pfCandidates, *superClusters_p);
 
   // Let's put the super clusters in the event
   const edm::OrphanHandle<reco::SuperClusterCollection> scRefProd =
       iEvent.put(std::move(superClusters_p), PFSuperClusterCollection_);
   // create the super cluster Ref
   createSuperClusterGsfMapRefs(scRefProd);
 
   // Now create the GsfElectronCoers
   createGsfElectronCores(*gsfElectronCores_p);
   // Put them in the as to get to be able to build a Ref
   const edm::OrphanHandle<reco::GsfElectronCoreCollection> gsfElectronCoreRefProd =
       iEvent.put(std::move(gsfElectronCores_p), GsfElectronCoreCollection_);
 
   // now create the Refs
   createGsfElectronCoreRefs(gsfElectronCoreRefProd);
 
   // now make the GsfElectron
   createGsfElectrons(*pfCandidates, isolationValues, *gsfElectrons_p);
   iEvent.put(std::move(gsfElectrons_p), GsfElectronCollection_);
 
   fillMVAValueMap(iEvent, mvaFiller);
   mvaFiller.fill();
 
   fillSCRefValueMap(iEvent, scRefFiller);
   scRefFiller.fill();
 
   // MVA map
   iEvent.put(std::move(mvaMap_p), PFMVAValueMap_);
   // Gsf-SC map
   iEvent.put(std::move(scMap_p), PFSCValueMap_);
 }

Member Data Documentation

◆ ambiguousGsfTracks_

std::vector<std::vector<reco::GsfTrackRef> > PFElectronTranslator::ambiguousGsfTracks_

private

Definition at line 114 of file PFElectronTranslator.cc.

Referenced by createGsfElectrons(), and produce().

◆ basicClusterPtr_

std::vector<reco::CaloClusterPtrVector> PFElectronTranslator::basicClusterPtr_

private

Definition at line 124 of file PFElectronTranslator.cc.

Referenced by createBasicClusterPtrs(), createSuperClusters(), and produce().

◆ basicClusters_

std::vector<reco::BasicClusterCollection> PFElectronTranslator::basicClusters_

private

Definition at line 116 of file PFElectronTranslator.cc.

Referenced by createBasicClusterPtrs(), createSuperClusters(), and produce().

◆ CandidatePtr_

std::vector<reco::CandidatePtr> PFElectronTranslator::CandidatePtr_

private

Definition at line 110 of file PFElectronTranslator.cc.

Referenced by createGsfElectrons(), and produce().

◆ checkStatusFlag_

bool PFElectronTranslator::checkStatusFlag_

private

Definition at line 104 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ ecalMustacheSCParametersToken_

edm::ESGetToken<EcalMustacheSCParameters, EcalMustacheSCParametersRcd> PFElectronTranslator::ecalMustacheSCParametersToken_

private

Definition at line 136 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ emptyIsOk_

bool PFElectronTranslator::emptyIsOk_

private

Definition at line 139 of file PFElectronTranslator.cc.

Referenced by fetchCandidateCollection(), and PFElectronTranslator().

◆ GsfElectronCollection_

std::string PFElectronTranslator::GsfElectronCollection_

private

Definition at line 102 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ GsfElectronCoreCollection_

std::string PFElectronTranslator::GsfElectronCoreCollection_

private

Definition at line 101 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ gsfElectronCoreRefs_

std::vector<reco::GsfElectronCoreRef> PFElectronTranslator::gsfElectronCoreRefs_

private

Definition at line 128 of file PFElectronTranslator.cc.

Referenced by createGsfElectronCoreRefs(), createGsfElectrons(), and produce().

◆ gsfMvaMap_

std::map<reco::GsfTrackRef, float> PFElectronTranslator::gsfMvaMap_

private

Definition at line 133 of file PFElectronTranslator.cc.

Referenced by fillMVAValueMap().

◆ gsfPFCandidateIndex_

std::vector<int> PFElectronTranslator::gsfPFCandidateIndex_

private

Definition at line 130 of file PFElectronTranslator.cc.

Referenced by createGsfElectrons(), createSuperClusters(), and produce().

◆ GsfTrackRef_

std::vector<reco::GsfTrackRef> PFElectronTranslator::GsfTrackRef_

private

Definition at line 108 of file PFElectronTranslator.cc.

Referenced by createBasicClusterPtrs(), createGsfElectronCoreRefs(), createGsfElectronCores(), createGsfElectrons(), createPreshowerClusterPtrs(), createSuperClusterGsfMapRefs(), createSuperClusters(), and produce().

◆ inputTokenGSFTracks_

edm::EDGetTokenT<reco::GsfTrackCollection> PFElectronTranslator::inputTokenGSFTracks_

private

Definition at line 94 of file PFElectronTranslator.cc.

Referenced by fillMVAValueMap(), fillSCRefValueMap(), and PFElectronTranslator().

◆ inputTokenIsoVals_

std::vector<edm::EDGetTokenT<edm::ValueMap<double> > > PFElectronTranslator::inputTokenIsoVals_

private

Definition at line 95 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ inputTokenPFCandidateElectrons_

edm::EDGetTokenT<reco::PFCandidateCollection> PFElectronTranslator::inputTokenPFCandidateElectrons_

private

Definition at line 93 of file PFElectronTranslator.cc.

Referenced by fillMVAValueMap(), and PFElectronTranslator().

◆ inputTokenPFCandidates_

edm::EDGetTokenT<reco::PFCandidateCollection> PFElectronTranslator::inputTokenPFCandidates_

private

Definition at line 92 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ kfTrackRef_

std::vector<reco::TrackRef> PFElectronTranslator::kfTrackRef_

private

Definition at line 112 of file PFElectronTranslator.cc.

Referenced by createGsfElectronCores(), and produce().

◆ mustacheSCParams_

const EcalMustacheSCParameters* PFElectronTranslator::mustacheSCParams_

private

Definition at line 137 of file PFElectronTranslator.cc.

Referenced by createGsfElectrons(), and produce().

◆ MVACut_

double PFElectronTranslator::MVACut_

private

Definition at line 103 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ PFBasicClusterCollection_

std::string PFElectronTranslator::PFBasicClusterCollection_

private

Definition at line 96 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ pfClusters_

std::vector<std::vector<const reco::PFCluster*> > PFElectronTranslator::pfClusters_

private

Definition at line 118 of file PFElectronTranslator.cc.

Referenced by createSuperClusters(), and produce().

◆ PFMVAValueMap_

std::string PFElectronTranslator::PFMVAValueMap_

private

Definition at line 99 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ PFPreshowerClusterCollection_

std::string PFElectronTranslator::PFPreshowerClusterCollection_

private

Definition at line 97 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ PFSCValueMap_

std::string PFElectronTranslator::PFSCValueMap_

private

Definition at line 100 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ PFSuperClusterCollection_

std::string PFElectronTranslator::PFSuperClusterCollection_

private

Definition at line 98 of file PFElectronTranslator.cc.

Referenced by PFElectronTranslator(), and produce().

◆ preshowerClusterPtr_

std::vector<reco::CaloClusterPtrVector> PFElectronTranslator::preshowerClusterPtr_

private

Definition at line 126 of file PFElectronTranslator.cc.

Referenced by createPreshowerClusterPtrs(), createSuperClusters(), and produce().

◆ preshowerClusters_

std::vector<reco::PreshowerClusterCollection> PFElectronTranslator::preshowerClusters_

private

Definition at line 120 of file PFElectronTranslator.cc.

Referenced by createPreshowerClusterPtrs(), and produce().

◆ scMap_

std::map<reco::GsfTrackRef, reco::SuperClusterRef> PFElectronTranslator::scMap_

private

Definition at line 132 of file PFElectronTranslator.cc.

Referenced by createGsfElectronCores(), createSuperClusterGsfMapRefs(), fillSCRefValueMap(), and produce().

◆ superClusters_

std::vector<reco::SuperClusterCollection> PFElectronTranslator::superClusters_

private

Definition at line 122 of file PFElectronTranslator.cc.

Referenced by produce().

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ IsolationValueMaps

Constructor & Destructor Documentation

◆ PFElectronTranslator()

◆ ~PFElectronTranslator()

Member Function Documentation

◆ correspondingDaughterCandidate()

◆ createBasicCluster()

◆ createBasicClusterPtrs()

◆ createGsfElectronCoreRefs()

◆ createGsfElectronCores()

◆ createGsfElectrons()

◆ createPreshowerCluster()

◆ createPreshowerClusterPtrs()

◆ createSuperClusterGsfMapRefs()

◆ createSuperClusters()

◆ fetchCandidateCollection()

◆ fetchGsfCollection()

◆ fillDescriptions()

◆ fillMVAValueMap()

◆ fillSCRefValueMap()

◆ fillValueMap()

◆ getAmbiguousGsfTracks()

◆ produce()

Member Data Documentation

◆ ambiguousGsfTracks_

◆ basicClusterPtr_

◆ basicClusters_

◆ CandidatePtr_

◆ checkStatusFlag_

◆ ecalMustacheSCParametersToken_

◆ emptyIsOk_

◆ GsfElectronCollection_

◆ GsfElectronCoreCollection_

◆ gsfElectronCoreRefs_

◆ gsfMvaMap_

◆ gsfPFCandidateIndex_

◆ GsfTrackRef_

◆ inputTokenGSFTracks_

◆ inputTokenIsoVals_

◆ inputTokenPFCandidateElectrons_

◆ inputTokenPFCandidates_

◆ kfTrackRef_

◆ mustacheSCParams_

◆ MVACut_

◆ PFBasicClusterCollection_

◆ pfClusters_

◆ PFMVAValueMap_

◆ PFPreshowerClusterCollection_

◆ PFSCValueMap_

◆ PFSuperClusterCollection_

◆ preshowerClusterPtr_

◆ preshowerClusters_

◆ scMap_

◆ superClusters_