#include <PFElectronTranslator.h>

Inheritance diagram for PFElectronTranslator:

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

Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

typedef WorkerT< EDProducer >	WorkerType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Member Functions
virtual void	beginRun (edm::Run &run, const edm::EventSetup &c)

	PFElectronTranslator (const edm::ParameterSet &)

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

	~PFElectronTranslator ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

boost::function< void(const BranchDescription &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

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

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_

Additional Inherited Members
Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)

Detailed Description

Definition at line 23 of file PFElectronTranslator.h.

Member Typedef Documentation

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

Definition at line 32 of file PFElectronTranslator.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 21 of file PFElectronTranslator.cc.

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

                                                                           {
   inputTagPFCandidates_ 
     = iConfig.getParameter<edm::InputTag>("PFCandidate");
   inputTagPFCandidateElectrons_ 
     = iConfig.getParameter<edm::InputTag>("PFCandidateElectron");
   inputTagGSFTracks_
     = iConfig.getParameter<edm::InputTag>("GSFTracks");
 
   edm::ParameterSet isoVals  = iConfig.getParameter<edm::ParameterSet> ("isolationValues");
   inputTagIsoVals_.push_back(isoVals.getParameter<edm::InputTag>("pfChargedHadrons"));
   inputTagIsoVals_.push_back(isoVals.getParameter<edm::InputTag>("pfPhotons"));
   inputTagIsoVals_.push_back(isoVals.getParameter<edm::InputTag>("pfNeutralHadrons"));
 
   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");
 
   if (iConfig.exists("emptyIsOk")) emptyIsOk_ = iConfig.getParameter<bool>("emptyIsOk");
   else emptyIsOk_=false;
 
   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 ( )

Definition at line 56 of file PFElectronTranslator.cc.

56 {}

Member Function Documentation

void PFElectronTranslator::beginRun	(	edm::Run &	run,
		const edm::EventSetup &	c
	)

virtual

Reimplemented from edm::EDProducer.

Definition at line 58 of file PFElectronTranslator.cc.

58 {}

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

private

Definition at line 513 of file PFElectronTranslator.cc.

References reco::CompositeCandidate::begin(), reco::PFCandidate::elementsInBlocks(), reco::CompositeCandidate::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 272 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().

 {
   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(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 302 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 551 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 537 of file PFElectronTranslator.cc.

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

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.setPflowSuperCluster(itcheck->second);
       gsfElectronCores.push_back(myElectronCore);
     }
 }

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

private

Definition at line 572 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();
       myElectron.setMvaInput(myMvaInput);
 
       // MVA output
       reco::GsfElectron::MvaOutput myMvaOutput;
       myMvaOutput.status = pfCandidate.electronExtraRef()->electronStatus();
       myMvaOutput.mva = 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
       reco::GsfElectron::PflowIsolationVariables myPFIso;
       myPFIso.chargedHadronIso=(*isolationValues[0])[CandidatePtr_[iGSF]];
       myPFIso.photonIso=(*isolationValues[1])[CandidatePtr_[iGSF]];
       myPFIso.neutralHadronIso=(*isolationValues[2])[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 295 of file PFElectronTranslator.cc.

References reco::PFBlockElement::clusterRef().

Referenced by produce().

 {
   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 321 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 340 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 423 of file PFElectronTranslator.cc.

References reco::SuperCluster::addCluster(), reco::CaloCluster::addHitAndFraction(), reco::SuperCluster::addPreshowerCluster(), basicClusterPtr_, basicClusters_, gsfPFCandidateIndex_, GsfTrackRef_, pfClusters_, PFClusterWidthAlgo::pflowEtaWidth(), PFClusterWidthAlgo::pflowPhiWidth(), preshowerClusterPtr_, reco::SuperCluster::rawEnergy(), reco::SuperCluster::setEtaWidth(), reco::SuperCluster::setPhiWidth(), reco::SuperCluster::setPreshowerEnergy(), and reco::SuperCluster::setSeed().

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 239 of file PFElectronTranslator.cc.

References emptyIsOk_, 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 255 of file PFElectronTranslator.cc.

References edm::hlt::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 352 of file PFElectronTranslator.cc.

References reco::PFCandidate::e, fetchCandidateCollection(), fetchGsfCollection(), gsfMvaMap_, reco::PFCandidate::gsfTrackRef(), i, inputTagGSFTracks_, inputTagPFCandidateElectrons_, edm::helper::Filler< Map >::insert(), edm::Ref< C, T, F >::isNull(), reco::PFCandidate::mva_e_pi(), reco::PFCandidate::particleId(), reco::tau::pfCandidates(), ntuplemaker::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 396 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 561 of file PFElectronTranslator.cc.

References reco::PFBlockElementGsfTrack::GsftrackRefPF().

Referenced by produce().

                                                                                                                           {
   const reco::PFBlockElementGsfTrack *  GsfEl =  dynamic_cast<const reco::PFBlockElementGsfTrack*>(&PFBE);
   if(GsfEl==0) 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
	)

virtual

Implements edm::EDProducer.

Definition at line 60 of file PFElectronTranslator.cc.

References ambiguousGsfTracks_, basicClusterPtr_, basicClusters_, CandidatePtr_, correspondingDaughterCandidate(), createBasicCluster(), createBasicClusterPtrs(), createGsfElectronCoreRefs(), createGsfElectronCores(), createGsfElectrons(), createPreshowerCluster(), createPreshowerClusterPtrs(), createSuperClusterGsfMapRefs(), createSuperClusters(), reco::PFCandidate::e, reco::PFBlockElement::ECAL, asciidump::elements, reco::PFCandidate::elementsInBlocks(), fetchCandidateCollection(), edm::helper::Filler< Map >::fill(), fillMVAValueMap(), fillSCRefValueMap(), getAmbiguousGsfTracks(), edm::Event::getByLabel(), reco::PFBlockElement::GSF, GsfElectronCollection_, GsfElectronCoreCollection_, gsfElectronCoreRefs_, gsfPFCandidateIndex_, reco::PFCandidate::gsfTrackRef(), GsfTrackRef_, i, inputTagIsoVals_, inputTagPFCandidates_, edm::Ref< C, T, F >::isNull(), j, kfTrackRef_, reco::PFCandidate::mva_e_pi(), MVACut_, reco::PFCandidate::particleId(), PFBasicClusterCollection_, reco::tau::pfCandidates(), pfClusters_, PFMVAValueMap_, PFPreshowerClusterCollection_, PFSCValueMap_, PFSuperClusterCollection_, preshowerClusterPtr_, preshowerClusters_, reco::PFBlockElement::PS1, reco::PFBlockElement::PS2, edm::Event::put(), scMap_, ntuplemaker::status, superClusters_, reco::PFCandidate::trackRef(), and reco::PFBlockElement::type().

                                                  { 
   
   std::auto_ptr<reco::GsfElectronCoreCollection>
     gsfElectronCores_p(new reco::GsfElectronCoreCollection);
 
   std::auto_ptr<reco::GsfElectronCollection>
     gsfElectrons_p(new reco::GsfElectronCollection);
 
   std::auto_ptr<reco::SuperClusterCollection> 
     superClusters_p(new reco::SuperClusterCollection);
 
   std::auto_ptr<reco::BasicClusterCollection> 
     basicClusters_p(new reco::BasicClusterCollection);
 
   std::auto_ptr<reco::PreshowerClusterCollection>
     psClusters_p(new reco::PreshowerClusterCollection);
   
   std::auto_ptr<edm::ValueMap<float> > mvaMap_p(new edm::ValueMap<float>());
   edm::ValueMap<float>::Filler mvaFiller(*mvaMap_p);
 
   std::auto_ptr<edm::ValueMap<reco::SuperClusterRef> > 
     scMap_p(new 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;
 
     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(basicClusters_p,PFBasicClusterCollection_);
 
   //preshower clusters
   const edm::OrphanHandle<reco::PreshowerClusterCollection> psRefProd = 
     iEvent.put(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(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(gsfElectronCores_p,GsfElectronCoreCollection_);
 
   // now create the Refs 
   createGsfElectronCoreRefs(gsfElectronCoreRefProd);
 
   // now make the GsfElectron
   createGsfElectrons(*pfCandidates,isolationValues,*gsfElectrons_p);
   iEvent.put(gsfElectrons_p,GsfElectronCollection_);
 
   fillMVAValueMap(iEvent,mvaFiller);
   mvaFiller.fill();
 
   fillSCRefValueMap(iEvent,scRefFiller);
   scRefFiller.fill();
 
   // MVA map
   iEvent.put(mvaMap_p,PFMVAValueMap_);
   // Gsf-SC map
   iEvent.put(scMap_p,PFSCValueMap_);
 
 
   
 }