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

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::InputTag &tag, const edm::Event &iEvent) const

void	fetchGsfCollection (edm::Handle< reco::GsfTrackCollection > &c, const edm::InputTag &tag, 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::InputTag	inputTagGSFTracks_

std::vector< edm::InputTag >	inputTagIsoVals_

edm::InputTag	inputTagPFCandidateElectrons_

edm::InputTag	inputTagPFCandidates_

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

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

Definition at line 35 of file PFElectronTranslator.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 143 of file PFElectronTranslator.cc.

References checkStatusFlag_, ecalMustacheSCParametersToken_, emptyIsOk_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), GsfElectronCollection_, GsfElectronCoreCollection_, inputTagGSFTracks_, inputTagIsoVals_, inputTagPFCandidateElectrons_, inputTagPFCandidates_, MVACut_, PFBasicClusterCollection_, PFMVAValueMap_, PFPreshowerClusterCollection_, PFSCValueMap_, PFSuperClusterCollection_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                          {
   inputTagPFCandidates_ = iConfig.getParameter<edm::InputTag>("PFCandidate");
   inputTagPFCandidateElectrons_ = iConfig.getParameter<edm::InputTag>("PFCandidateElectron");
   inputTagGSFTracks_ = iConfig.getParameter<edm::InputTag>("GSFTracks");
 
   bool useIsolationValues = iConfig.getParameter<bool>("useIsolationValues");
   if (useIsolationValues) {
     if (!iConfig.exists("isolationValues"))
       throw cms::Exception("PFElectronTranslator|InternalError") << "Missing ParameterSet isolationValues";
     else {
       edm::ParameterSet isoVals = iConfig.getParameter<edm::ParameterSet>("isolationValues");
       inputTagIsoVals_.push_back(isoVals.getParameter<edm::InputTag>("pfSumChargedHadronPt"));
       inputTagIsoVals_.push_back(isoVals.getParameter<edm::InputTag>("pfSumPhotonEt"));
       inputTagIsoVals_.push_back(isoVals.getParameter<edm::InputTag>("pfSumNeutralHadronEt"));
       inputTagIsoVals_.push_back(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");
 
   if (iConfig.exists("emptyIsOk"))
     emptyIsOk_ = iConfig.getParameter<bool>("emptyIsOk");
   else
     emptyIsOk_ = false;
 
   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 ( )

override

Definition at line 188 of file PFElectronTranslator.cc.

188 {}

Member Function Documentation

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

private

Definition at line 598 of file PFElectronTranslator.cc.

References reco::Candidate::begin(), reco::PFCandidate::elementsInBlocks(), reco::Candidate::end(), 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;
 }

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 387 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()));
 }

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

private

Definition at line 419 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;
     }
   }
 }

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

private

Definition at line 631 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);
   }
 }

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

private

Definition at line 619 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);
   }
 }

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

private

Definition at line 654 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);
   }
 }

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

private

Definition at line 411 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));
 }

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

private

Definition at line 438 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;
     }
   }
 }

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

private

Definition at line 457 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;
   }
 }

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

private

Definition at line 522 of file PFElectronTranslator.cc.

References reco::SuperCluster::addCluster(), reco::CaloCluster::addHitAndFraction(), reco::SuperCluster::addPreshowerCluster(), basicClusterPtr_, basicClusters_, alignCSCRings::e, gsfPFCandidateIndex_, GsfTrackRef_, pfClusters_, PFClusterWidthAlgo::pflowEtaWidth(), PFClusterWidthAlgo::pflowPhiWidth(), preshowerClusterPtr_, reco::SuperCluster::rawEnergy(), reco::SuperCluster::setEtaWidth(), reco::SuperCluster::setPhiWidth(), reco::SuperCluster::setPreshowerEnergy(), reco::SuperCluster::setSeed(), 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);
   }
 }

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

private

Definition at line 358 of file PFElectronTranslator.cc.

References emptyIsOk_, submitPVValidationJobs::err, newFWLiteAna::found, and edm::Event::getByLabel().

Referenced by fillMVAValueMap(), and produce().

                                                                                   {
   bool found = iEvent.getByLabel(tag, c);
 
   if (!found && !emptyIsOk_) {
     std::ostringstream err;
     err << " cannot get PFCandidates: " << tag << std::endl;
     edm::LogError("PFElectronTranslator") << err.str();
   }
   return found;
 }

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

private

Definition at line 371 of file PFElectronTranslator.cc.

References submitPVValidationJobs::err, Exception, newFWLiteAna::found, and edm::Event::getByLabel().

Referenced by fillMVAValueMap(), and fillSCRefValueMap().

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

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

private

Definition at line 468 of file PFElectronTranslator.cc.

References reco::PFCandidate::e, fetchCandidateCollection(), fetchGsfCollection(), gsfMvaMap_, reco::PFCandidate::gsfTrackRef(), mps_fire::i, inputTagGSFTracks_, inputTagPFCandidateElectrons_, edm::helper::Filler< Map >::insert(), edm::Ref< C, T, F >::isNull(), reco::PFCandidate::mva_e_pi(), reco::PFCandidate::particleId(), slimmedMuons_cfi::pfCandidates, mps_update::status, and makeHLTPrescaleTable::values.

Referenced by produce().

                                                                                              {
   gsfMvaMap_.clear();
   edm::Handle<reco::PFCandidateCollection> pfCandidates;
   bool status = fetchCandidateCollection(pfCandidates, inputTagPFCandidateElectrons_, 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, inputTagGSFTracks_, 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());
 }

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

private

Definition at line 503 of file PFElectronTranslator.cc.

References fetchGsfCollection(), inputTagGSFTracks_, edm::helper::Filler< Map >::insert(), scMap_, and makeHLTPrescaleTable::values.

Referenced by produce().

                                                                                                    {
   edm::Handle<reco::GsfTrackCollection> gsfTracks;
   fetchGsfCollection(gsfTracks, inputTagGSFTracks_, 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());
 }

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

private

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

private

Definition at line 642 of file PFElectronTranslator.cc.

References reco::PFBlockElementGsfTrack::GsftrackRefPF(), and ntracks.

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());
   }
 }

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

override

Definition at line 190 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_, reco::PFCandidate::electronExtraRef(), bookConverter::elements, reco::PFCandidate::elementsInBlocks(), fetchCandidateCollection(), fillMVAValueMap(), fillSCRefValueMap(), getAmbiguousGsfTracks(), edm::Event::getByLabel(), edm::EventSetup::getData(), reco::PFBlockElement::GSF, GsfElectronCollection_, GsfElectronCoreCollection_, gsfElectronCoreRefs_, gsfPFCandidateIndex_, reco::PFCandidate::gsfTrackRef(), GsfTrackRef_, mps_fire::i, inputTagIsoVals_, inputTagPFCandidates_, edm::Ref< C, T, F >::isNull(), dqmiolumiharvest::j, kfTrackRef_, eostools::move(), mustacheSCParams_, reco::PFCandidate::mva_e_pi(), MVACut_, reco::PFCandidate::particleId(), PFBasicClusterCollection_, slimmedMuons_cfi::pfCandidates, pfClusters_, PFMVAValueMap_, PFPreshowerClusterCollection_, PFSCValueMap_, PFSuperClusterCollection_, preshowerClusterPtr_, preshowerClusters_, reco::PFBlockElement::PS1, reco::PFBlockElement::PS2, edm::Event::put(), scMap_, reco::PFCandidateElectronExtra::Selected, mps_update::status, superClusters_, reco::PFCandidate::trackRef(), 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, inputTagPFCandidates_, iEvent);
 
   IsolationValueMaps isolationValues(inputTagIsoVals_.size());
   for (size_t j = 0; j < inputTagIsoVals_.size(); ++j) {
     iEvent.getByLabel(inputTagIsoVals_[j], isolationValues[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_);
 }