Inheritance diagram for PFPhotonTranslator:

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

Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

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

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

	~PFPhotonTranslator () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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	createOneLegConversions (const edm::OrphanHandle< reco::SuperClusterCollection > &superClustersHandle, reco::ConversionCollection &oneLegConversions)

void	createPhotonCores (const edm::OrphanHandle< reco::SuperClusterCollection > &superClustersHandle, const edm::OrphanHandle< reco::ConversionCollection > &oneLegConversionHandle, reco::PhotonCoreCollection &photonCores)

void	createPhotons (reco::VertexCollection &vertexCollection, edm::Handle< reco::PhotonCollection > &egPhotons, const edm::OrphanHandle< reco::PhotonCoreCollection > &photonCoresHandle, const IsolationValueMaps &isolationValues, reco::PhotonCollection &photons)

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

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

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

Private Attributes
edm::InputTag	barrelEcalHits_

std::vector< reco::CaloClusterPtrVector >	basicClusterPtr_

std::vector< reco::BasicClusterCollection >	basicClusters_

std::vector< reco::CandidatePtr >	CandidatePtr_

std::vector< int >	conv1legPFCandidateIndex_

std::vector< int >	conv2legPFCandidateIndex_

std::string	EGPhotonCollection_

std::vector< reco::PhotonRef >	egPhotonRef_

std::vector< reco::SuperClusterRef >	egSCRef_

bool	emptyIsOk_

edm::InputTag	endcapEcalHits_

std::vector< float >	energyRegression_

std::vector< float >	energyRegressionError_

edm::InputTag	hcalTowers_

double	hOverEConeSize_

std::vector< edm::InputTag >	inputTagIsoVals_

edm::InputTag	inputTagPFCandidates_

std::string	PFBasicClusterCollection_

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

std::vector< reco::ConversionRefVector >	pfConv_

std::string	PFConversionCollection_

std::string	PFPhotonCollection_

std::string	PFPhotonCoreCollection_

std::vector< float >	pfPhotonMva_

std::string	PFPreshowerClusterCollection_

std::vector< std::vector< reco::TrackRef > >	pfSingleLegConv_

std::vector< std::vector< float > >	pfSingleLegConvMva_

std::string	PFSuperClusterCollection_

std::vector< int >	photPFCandidateIndex_

std::vector< reco::CaloClusterPtrVector >	preshowerClusterPtr_

std::vector< reco::PreshowerClusterCollection >	preshowerClusters_

std::vector< reco::SuperClusterCollection >	superClusters_

edm::ESHandle< CaloGeometry >	theCaloGeom_

edm::ESHandle< CaloTopology >	theCaloTopo_

std::string	vertexProducer_

Detailed Description

Definition at line 32 of file PFPhotonTranslator.cc.

Member Typedef Documentation

◆ IsolationValueMaps

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

Definition at line 39 of file PFPhotonTranslator.cc.

Constructor & Destructor Documentation

◆ PFPhotonTranslator()

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

explicit

Definition at line 148 of file PFPhotonTranslator.cc.

                                                                      {
   //std::cout << "PFPhotonTranslator" << std::endl;
  
   inputTagPFCandidates_ = iConfig.getParameter<edm::InputTag>("PFCandidate");
  
   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");
   PFConversionCollection_ = iConfig.getParameter<std::string>("PFConversionCollection");
   PFPhotonCoreCollection_ = iConfig.getParameter<std::string>("PFPhotonCores");
   PFPhotonCollection_ = iConfig.getParameter<std::string>("PFPhotons");
  
   EGPhotonCollection_ = iConfig.getParameter<std::string>("EGPhotons");
  
   vertexProducer_ = iConfig.getParameter<std::string>("primaryVertexProducer");
  
   barrelEcalHits_ = iConfig.getParameter<edm::InputTag>("barrelEcalHits");
   endcapEcalHits_ = iConfig.getParameter<edm::InputTag>("endcapEcalHits");
  
   hcalTowers_ = iConfig.getParameter<edm::InputTag>("hcalTowers");
   hOverEConeSize_ = iConfig.getParameter<double>("hOverEConeSize");
  
   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::PhotonCoreCollection>(PFPhotonCoreCollection_);
   produces<reco::PhotonCollection>(PFPhotonCollection_);
   produces<reco::ConversionCollection>(PFConversionCollection_);
 }

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~PFPhotonTranslator()

PFPhotonTranslator::~PFPhotonTranslator ( )

override

Definition at line 188 of file PFPhotonTranslator.cc.

188 {}

Member Function Documentation

◆ correspondingDaughterCandidate()

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

private

Definition at line 1071 of file PFPhotonTranslator.cc.

                                                                                                                   {
   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;
 }

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

◆ createBasicCluster()

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

private

Definition at line 588 of file PFPhotonTranslator.cc.

                                                                                       {
   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(  //coCandidate.rawEcalEnergy(),
       myPFCluster.energy(),
       myPFCluster.position(),
       myPFCluster.caloID(),
       myPFCluster.hitsAndFractions(),
       myPFCluster.algo(),
       myPFCluster.seed()));
 }

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

◆ createBasicClusterPtrs()

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

private

Definition at line 619 of file PFPhotonTranslator.cc.

                                                                             {
   unsigned size = photPFCandidateIndex_.size();
   unsigned basicClusterCounter = 0;
   basicClusterPtr_.resize(size);
  
   for (unsigned iphot = 0; iphot < size; ++iphot)  // loop on tracks
   {
     unsigned nbc = basicClusters_[iphot].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_[iphot].push_back(bcPtr);
       ++basicClusterCounter;
     }
   }
 }

References findQualityFiles::size.

◆ createOneLegConversions()

void PFPhotonTranslator::createOneLegConversions	(	const edm::OrphanHandle< reco::SuperClusterCollection > &	superClustersHandle,
		reco::ConversionCollection &	oneLegConversions
	)

private

Definition at line 744 of file PFPhotonTranslator.cc.

                                                  {
   //std::cout << "createOneLegConversions" << std::endl;
  
   unsigned nphot = photPFCandidateIndex_.size();
   for (unsigned iphot = 0; iphot < nphot; ++iphot) {
     //if (conv1legPFCandidateIndex_[iphot]==-1) cout << "No OneLegConversions to add"<<endl;
     //else std::cout << "Phot "<<iphot<< " nOneLegConversions to add : "<<pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]].size()<<endl;
  
     if (conv1legPFCandidateIndex_[iphot] > -1) {
       for (unsigned iConv = 0; iConv < pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]].size(); iConv++) {
         reco::CaloClusterPtrVector scPtrVec;
         std::vector<reco::CaloClusterPtr> matchingBC;
         math::Error<3>::type error;
         const reco::Vertex *convVtx =
             new reco::Vertex(pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->innerPosition(), error);
  
         //cout << "Vtx x="<<convVtx->x() << " y="<< convVtx->y()<<" z="<<convVtx->z()<< endl;
         //cout << "VtxError x=" << convVtx->xError() << endl;
  
         std::vector<reco::TrackRef> OneLegConvVector;
         OneLegConvVector.push_back(pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]);
  
         std::vector<reco::TrackRef> tr = OneLegConvVector;
         std::vector<math::XYZPointF> trackPositionAtEcalVec;
         std::vector<math::XYZPointF> innPointVec;
         std::vector<math::XYZVectorF> trackPinVec;
         std::vector<math::XYZVectorF> trackPoutVec;
         math::XYZPointF trackPositionAtEcal(
             pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->outerPosition().X(),
             pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->outerPosition().Y(),
             pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->outerPosition().Z());
         math::XYZPointF innPoint(pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->innerPosition().X(),
                                  pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->innerPosition().Y(),
                                  pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->innerPosition().Z());
         math::XYZVectorF trackPin(pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->innerMomentum().X(),
                                   pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->innerMomentum().Y(),
                                   pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->innerMomentum().Z());
         math::XYZVectorF trackPout(pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->outerMomentum().X(),
                                    pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->outerMomentum().Y(),
                                    pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->outerMomentum().Z());
         float DCA = pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]][iConv]->d0();
         trackPositionAtEcalVec.push_back(trackPositionAtEcal);
         innPointVec.push_back(innPoint);
         trackPinVec.push_back(trackPin);
         trackPoutVec.push_back(trackPout);
         std::vector<float> OneLegMvaVector;
         reco::Conversion myOneLegConversion(scPtrVec,
                                             OneLegConvVector,
                                             trackPositionAtEcalVec,
                                             *convVtx,
                                             matchingBC,
                                             DCA,
                                             innPointVec,
                                             trackPinVec,
                                             trackPoutVec,
                                             pfSingleLegConvMva_[conv1legPFCandidateIndex_[iphot]][iConv],
                                             reco::Conversion::pflow);
         OneLegMvaVector.push_back(pfSingleLegConvMva_[conv1legPFCandidateIndex_[iphot]][iConv]);
         myOneLegConversion.setOneLegMVA(OneLegMvaVector);
         //reco::Conversion myOneLegConversion(scPtrVec,
         //OneLegConvVector, *convVtx, reco::Conversion::pflow);
  
         /*
         std::cout << "One leg conversion created" << endl;
         std::vector<edm::RefToBase<reco::Track> > convtracks = myOneLegConversion.tracks();
         const std::vector<float> mvalist = myOneLegConversion.oneLegMVA();
  
         cout << "nTracks="<< convtracks.size()<<endl;
         for (unsigned int itk=0; itk<convtracks.size(); itk++){
           //double convtrackpt = convtracks[itk]->pt();
           std::cout << "Track pt="<< convtracks[itk]->pt() << std::endl;
           std::cout << "Track mva="<< mvalist[itk] << std::endl;
         }   
         */
         oneLegConversions.push_back(myOneLegConversion);
  
         //cout << "OneLegConv added"<<endl;
       }
     }
   }
 }

References relativeConstraints::error, reco::Conversion::pflow, reco::Conversion::setOneLegMVA(), HltBtagValidation_cff::Vertex, X, DOFs::Y, and DOFs::Z.

◆ createPhotonCores()

void PFPhotonTranslator::createPhotonCores	(	const edm::OrphanHandle< reco::SuperClusterCollection > &	superClustersHandle,
		const edm::OrphanHandle< reco::ConversionCollection > &	oneLegConversionHandle,
		reco::PhotonCoreCollection &	photonCores
	)

private

Definition at line 828 of file PFPhotonTranslator.cc.

                                                                                   {
   //std::cout << "createPhotonCores" << std::endl;
  
   unsigned nphot = photPFCandidateIndex_.size();
  
   unsigned i1legtot = 0;
  
   for (unsigned iphot = 0; iphot < nphot; ++iphot) {
     //std::cout << "iphot="<<iphot<<std::endl;
  
     reco::PhotonCore myPhotonCore;
  
     reco::SuperClusterRef SCref(reco::SuperClusterRef(superClustersHandle, iphot));
  
     myPhotonCore.setPFlowPhoton(true);
     myPhotonCore.setStandardPhoton(false);
     myPhotonCore.setParentSuperCluster(SCref);
     myPhotonCore.setSuperCluster(egSCRef_[iphot]);
  
     reco::ElectronSeedRefVector pixelSeeds = egPhotonRef_[iphot]->electronPixelSeeds();
     for (unsigned iseed = 0; iseed < pixelSeeds.size(); iseed++) {
       myPhotonCore.addElectronPixelSeed(pixelSeeds[iseed]);
     }
  
     //cout << "PhotonCores : SC OK" << endl;
  
     //cout << "conv1legPFCandidateIndex_[iphot]="<<conv1legPFCandidateIndex_[iphot]<<endl;
     //cout << "conv2legPFCandidateIndex_[iphot]="<<conv2legPFCandidateIndex_[iphot]<<endl;
  
     if (conv1legPFCandidateIndex_[iphot] > -1) {
       for (unsigned int iConv = 0; iConv < pfSingleLegConv_[conv1legPFCandidateIndex_[iphot]].size(); iConv++) {
         const reco::ConversionRef &OneLegRef(reco::ConversionRef(oneLegConversionHandle, i1legtot));
         myPhotonCore.addOneLegConversion(OneLegRef);
  
         //cout << "PhotonCores : 1-leg OK" << endl;
         /*
       cout << "Testing 1-leg :"<<endl;
       const reco::ConversionRefVector & conv = myPhotonCore.conversionsOneLeg();
       for (unsigned int iconv=0; iconv<conv.size(); iconv++){
         cout << "Testing 1-leg : iconv="<<iconv<<endl;
         cout << "Testing 1-leg : nTracks="<<conv[iconv]->nTracks()<<endl;
         cout << "Testing 1-leg : EoverP="<<conv[iconv]->EoverP()<<endl;
         std::vector<edm::RefToBase<reco::Track> > convtracks = conv[iconv]->tracks();
         for (unsigned int itk=0; itk<convtracks.size(); itk++){
           //double convtrackpt = convtracks[itk]->pt();
           std::cout << "Testing 1-leg : Track pt="<< convtracks[itk]->pt() << std::endl;
           // std::cout << "Track mva="<< mvalist[itk] << std::endl;
         }  
       }
       */
  
         i1legtot++;
       }
     }
  
     if (conv2legPFCandidateIndex_[iphot] > -1) {
       for (unsigned int iConv = 0; iConv < pfConv_[conv2legPFCandidateIndex_[iphot]].size(); iConv++) {
         const reco::ConversionRef &TwoLegRef(pfConv_[conv2legPFCandidateIndex_[iphot]][iConv]);
         myPhotonCore.addConversion(TwoLegRef);
       }
       //cout << "PhotonCores : 2-leg OK" << endl;
  
       /*
     cout << "Testing 2-leg :"<<endl;
     const reco::ConversionRefVector & conv = myPhotonCore.conversions();
     for (unsigned int iconv=0; iconv<conv.size(); iconv++){
       cout << "Testing 2-leg : iconv="<<iconv<<endl;
       cout << "Testing 2-leg : nTracks="<<conv[iconv]->nTracks()<<endl;
       cout << "Testing 2-leg : EoverP="<<conv[iconv]->EoverP()<<endl;
       std::vector<edm::RefToBase<reco::Track> > convtracks = conv[iconv]->tracks();
       for (unsigned int itk=0; itk<convtracks.size(); itk++){
         //double convtrackpt = convtracks[itk]->pt();
         std::cout << "Testing 2-leg : Track pt="<< convtracks[itk]->pt() << std::endl;
         // std::cout << "Track mva="<< mvalist[itk] << std::endl;
       }  
     }
     */
     }
  
     photonCores.push_back(myPhotonCore);
   }
  
   //std::cout << "end of createPhotonCores"<<std::endl;
 }

References reco::PhotonCore::addConversion(), reco::PhotonCore::addElectronPixelSeed(), reco::PhotonCore::addOneLegConversion(), iseed, hltEgammaHLTExtra_cfi::pixelSeeds, reco::PhotonCore::setParentSuperCluster(), reco::PhotonCore::setPFlowPhoton(), reco::PhotonCore::setStandardPhoton(), and reco::PhotonCore::setSuperCluster().

◆ createPhotons()

void PFPhotonTranslator::createPhotons	(	reco::VertexCollection &	vertexCollection,
		edm::Handle< reco::PhotonCollection > &	egPhotons,
		const edm::OrphanHandle< reco::PhotonCoreCollection > &	photonCoresHandle,
		const IsolationValueMaps &	isolationValues,
		reco::PhotonCollection &	photons
	)

private

Definition at line 915 of file PFPhotonTranslator.cc.

                                                                       {
   //cout << "createPhotons" << endl;
  
   unsigned nphot = photPFCandidateIndex_.size();
  
   for (unsigned iphot = 0; iphot < nphot; ++iphot) {
     //std::cout << "iphot="<<iphot<<std::endl;
  
     reco::PhotonCoreRef PCref(reco::PhotonCoreRef(photonCoresHandle, iphot));
  
     math::XYZPoint vtx(0., 0., 0.);
     if (!vertexCollection.empty())
       vtx = vertexCollection.begin()->position();
     //std::cout << "vtx made" << std::endl;
  
     math::XYZVector direction = PCref->parentSuperCluster()->position() - vtx;
  
     //It could be that pfSC energy gives not the best resolution : use smaller agregates for some cases ?
     math::XYZVector P3 = direction.unit() * PCref->parentSuperCluster()->energy();
     LorentzVector P4(P3.x(), P3.y(), P3.z(), PCref->parentSuperCluster()->energy());
  
     reco::Photon myPhoton(P4, PCref->parentSuperCluster()->position(), PCref, vtx);
     //cout << "photon created"<<endl;
  
     reco::Photon::ShowerShape showerShape;
     reco::Photon::SaturationInfo saturationInfo;
     reco::Photon::FiducialFlags fiducialFlags;
     reco::Photon::IsolationVariables isolationVariables03;
     reco::Photon::IsolationVariables isolationVariables04;
  
     showerShape.e1x5 = egPhotonRef_[iphot]->e1x5();
     showerShape.e2x5 = egPhotonRef_[iphot]->e2x5();
     showerShape.e3x3 = egPhotonRef_[iphot]->e3x3();
     showerShape.e5x5 = egPhotonRef_[iphot]->e5x5();
     showerShape.maxEnergyXtal = egPhotonRef_[iphot]->maxEnergyXtal();
     showerShape.sigmaEtaEta = egPhotonRef_[iphot]->sigmaEtaEta();
     showerShape.sigmaIetaIeta = egPhotonRef_[iphot]->sigmaIetaIeta();
     showerShape.hcalDepth1OverEcal = egPhotonRef_[iphot]->hadronicDepth1OverEm();
     showerShape.hcalDepth2OverEcal = egPhotonRef_[iphot]->hadronicDepth2OverEm();
     myPhoton.setShowerShapeVariables(showerShape);
  
     saturationInfo.nSaturatedXtals = egPhotonRef_[iphot]->nSaturatedXtals();
     saturationInfo.isSeedSaturated = egPhotonRef_[iphot]->isSeedSaturated();
     myPhoton.setSaturationInfo(saturationInfo);
  
     fiducialFlags.isEB = egPhotonRef_[iphot]->isEB();
     fiducialFlags.isEE = egPhotonRef_[iphot]->isEE();
     fiducialFlags.isEBEtaGap = egPhotonRef_[iphot]->isEBEtaGap();
     fiducialFlags.isEBPhiGap = egPhotonRef_[iphot]->isEBPhiGap();
     fiducialFlags.isEERingGap = egPhotonRef_[iphot]->isEERingGap();
     fiducialFlags.isEEDeeGap = egPhotonRef_[iphot]->isEEDeeGap();
     fiducialFlags.isEBEEGap = egPhotonRef_[iphot]->isEBEEGap();
     myPhoton.setFiducialVolumeFlags(fiducialFlags);
  
     isolationVariables03.ecalRecHitSumEt = egPhotonRef_[iphot]->ecalRecHitSumEtConeDR03();
     isolationVariables03.hcalTowerSumEt = egPhotonRef_[iphot]->hcalTowerSumEtConeDR03();
     isolationVariables03.hcalDepth1TowerSumEt = egPhotonRef_[iphot]->hcalDepth1TowerSumEtConeDR03();
     isolationVariables03.hcalDepth2TowerSumEt = egPhotonRef_[iphot]->hcalDepth2TowerSumEtConeDR03();
     isolationVariables03.trkSumPtSolidCone = egPhotonRef_[iphot]->trkSumPtSolidConeDR03();
     isolationVariables03.trkSumPtHollowCone = egPhotonRef_[iphot]->trkSumPtHollowConeDR03();
     isolationVariables03.nTrkSolidCone = egPhotonRef_[iphot]->nTrkSolidConeDR03();
     isolationVariables03.nTrkHollowCone = egPhotonRef_[iphot]->nTrkHollowConeDR03();
     isolationVariables04.ecalRecHitSumEt = egPhotonRef_[iphot]->ecalRecHitSumEtConeDR04();
     isolationVariables04.hcalTowerSumEt = egPhotonRef_[iphot]->hcalTowerSumEtConeDR04();
     isolationVariables04.hcalDepth1TowerSumEt = egPhotonRef_[iphot]->hcalDepth1TowerSumEtConeDR04();
     isolationVariables04.hcalDepth2TowerSumEt = egPhotonRef_[iphot]->hcalDepth2TowerSumEtConeDR04();
     isolationVariables04.trkSumPtSolidCone = egPhotonRef_[iphot]->trkSumPtSolidConeDR04();
     isolationVariables04.trkSumPtHollowCone = egPhotonRef_[iphot]->trkSumPtHollowConeDR04();
     isolationVariables04.nTrkSolidCone = egPhotonRef_[iphot]->nTrkSolidConeDR04();
     isolationVariables04.nTrkHollowCone = egPhotonRef_[iphot]->nTrkHollowConeDR04();
     myPhoton.setIsolationVariables(isolationVariables04, isolationVariables03);
  
     reco::Photon::PflowIsolationVariables myPFIso;
     myPFIso.chargedHadronIso = (*isolationValues[0])[CandidatePtr_[iphot]];
     myPFIso.photonIso = (*isolationValues[1])[CandidatePtr_[iphot]];
     myPFIso.neutralHadronIso = (*isolationValues[2])[CandidatePtr_[iphot]];
     myPhoton.setPflowIsolationVariables(myPFIso);
  
     reco::Photon::PflowIDVariables myPFVariables;
  
     reco::Mustache myMustache;
     myMustache.MustacheID(
         *(myPhoton.parentSuperCluster()), myPFVariables.nClusterOutsideMustache, myPFVariables.etOutsideMustache);
     myPFVariables.mva = pfPhotonMva_[iphot];
     myPhoton.setPflowIDVariables(myPFVariables);
  
     //cout << "chargedHadronIso="<<myPhoton.chargedHadronIso()<<" photonIso="<<myPhoton.photonIso()<<" neutralHadronIso="<<myPhoton.neutralHadronIso()<<endl;
  
     // set PF-regression energy
     myPhoton.setCorrectedEnergy(
         reco::Photon::regression2, energyRegression_[iphot], energyRegressionError_[iphot], false);
  
     /*
       if (basicClusters_[iphot].size()>0){
       // Cluster shape variables
       //Algorithms from EcalClusterTools could be adapted to PF photons ? (not based on 5x5 BC)
       //It happens that energy computed in eg e5x5 is greater than pfSC energy (EcalClusterTools gathering energies from adjacent crystals even if not belonging to the SC)
       const EcalRecHitCollection* hits = 0 ;
       int subdet = PCref->parentSuperCluster()->seed()->hitsAndFractions()[0].first.subdetId();
       if (subdet==EcalBarrel) hits = barrelRecHits;
       else if  (subdet==EcalEndcap) hits = endcapRecHits;
       const CaloGeometry* geometry = theCaloGeom_.product();
  
       float maxXtal =   EcalClusterTools::eMax( *(PCref->parentSuperCluster()->seed()), &(*hits) );
       //cout << "maxXtal="<<maxXtal<<endl;
       float e1x5    =   EcalClusterTools::e1x5(  *(PCref->parentSuperCluster()->seed()), &(*hits), &(*topology)); 
       //cout << "e1x5="<<e1x5<<endl;
       float e2x5    =   EcalClusterTools::e2x5Max(  *(PCref->parentSuperCluster()->seed()), &(*hits), &(*topology)); 
       //cout << "e2x5="<<e2x5<<endl;
       float e3x3    =   EcalClusterTools::e3x3(  *(PCref->parentSuperCluster()->seed()), &(*hits), &(*topology)); 
       //cout << "e3x3="<<e3x3<<endl;
       float e5x5    =   EcalClusterTools::e5x5( *(PCref->parentSuperCluster()->seed()), &(*hits), &(*topology)); 
       //cout << "e5x5="<<e5x5<<endl;
       std::vector<float> cov =  EcalClusterTools::covariances( *(PCref->parentSuperCluster()->seed()), &(*hits), &(*topology), geometry); 
       float sigmaEtaEta = sqrt(cov[0]);
       //cout << "sigmaEtaEta="<<sigmaEtaEta<<endl;
       std::vector<float> locCov =  EcalClusterTools::localCovariances( *(PCref->parentSuperCluster()->seed()), &(*hits), &(*topology)); 
       float sigmaIetaIeta = sqrt(locCov[0]);
       //cout << "sigmaIetaIeta="<<sigmaIetaIeta<<endl;
       //float r9 =e3x3/(PCref->parentSuperCluster()->rawEnergy());
  
  
       // calculate HoE
       const CaloTowerCollection* hcalTowersColl = hcalTowersHandle.product();
       EgammaTowerIsolation towerIso1(hOverEConeSize_,0.,0.,1,hcalTowersColl) ;  
       EgammaTowerIsolation towerIso2(hOverEConeSize_,0.,0.,2,hcalTowersColl) ;  
       double HoE1=towerIso1.getTowerESum(&(*PCref->parentSuperCluster()))/PCref->pfSuperCluster()->energy();
       double HoE2=towerIso2.getTowerESum(&(*PCref->parentSuperCluster()))/PCref->pfSuperCluster()->energy(); 
       //cout << "HoE1="<<HoE1<<endl;
       //cout << "HoE2="<<HoE2<<endl;  
  
       reco::Photon::ShowerShape  showerShape;
       showerShape.e1x5= e1x5;
       showerShape.e2x5= e2x5;
       showerShape.e3x3= e3x3;
       showerShape.e5x5= e5x5;
       showerShape.maxEnergyXtal =  maxXtal;
       showerShape.sigmaEtaEta =    sigmaEtaEta;
       showerShape.sigmaIetaIeta =  sigmaIetaIeta;
       showerShape.hcalDepth1OverEcal = HoE1;
       showerShape.hcalDepth2OverEcal = HoE2;
       myPhoton.setShowerShapeVariables ( showerShape ); 
       //cout << "shower shape variables filled"<<endl;
       }
       */
  
     photons.push_back(myPhoton);
   }
  
   //std::cout << "end of createPhotons"<<std::endl;
 }

◆ createPreshowerCluster()

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

private

Definition at line 611 of file PFPhotonTranslator.cc.

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

References reco::PFBlockElement::clusterRef().

◆ createPreshowerClusterPtrs()

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

private

Definition at line 638 of file PFPhotonTranslator.cc.

                                                                                     {
   unsigned size = photPFCandidateIndex_.size();
   unsigned psClusterCounter = 0;
   preshowerClusterPtr_.resize(size);
  
   for (unsigned iphot = 0; iphot < size; ++iphot)  // loop on tracks
   {
     unsigned nbc = preshowerClusters_[iphot].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_[iphot].push_back(psPtr);
       ++psClusterCounter;
     }
   }
 }

References findQualityFiles::size.

◆ createSuperClusters()

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

private

Definition at line 657 of file PFPhotonTranslator.cc.

                                                                                               {
   unsigned nphot = photPFCandidateIndex_.size();
   for (unsigned iphot = 0; iphot < nphot; ++iphot) {
     //cout << "SC iphot=" << iphot << endl;
  
     // Computes energy position a la e/gamma
     double sclusterE = 0;
     double posX = 0.;
     double posY = 0.;
     double posZ = 0.;
  
     unsigned nbasics = basicClusters_[iphot].size();
     for (unsigned ibc = 0; ibc < nbasics; ++ibc) {
       //cout << "BC in SC : iphot="<<iphot<<endl;
  
       double e = basicClusters_[iphot][ibc].energy();
       sclusterE += e;
       posX += e * basicClusters_[iphot][ibc].position().X();
       posY += e * basicClusters_[iphot][ibc].position().Y();
       posZ += e * basicClusters_[iphot][ibc].position().Z();
     }
     posX /= sclusterE;
     posY /= sclusterE;
     posZ /= sclusterE;
  
     /*
       if(pfCand[gsfPFCandidateIndex_[iphot]].gsfTrackRef()!=GsfTrackRef_[iphot])
     {
       edm::LogError("PFElectronTranslator") << " Major problem in PFElectron Translator" << std::endl;
     }
       */
  
     // compute the width
     PFClusterWidthAlgo pfwidth(pfClusters_[iphot]);
  
     double correctedEnergy = pfCand[photPFCandidateIndex_[iphot]].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_[iphot]].ecalEnergy();
       //      std::cout << " " <<   pfCand[gsfPFCandidateIndex_[iphot]].rawEcalEnergy() << std::endl;
       //      std::cout << "Seed energy from basic " << basicClusters_[iphot][0].energy() << std::endl;
       mySuperCluster.setSeed(basicClusterPtr_[iphot][0]);
     } else {
       //      std::cout << "SuperCluster creation ; seed energy " << 0 << std::endl;
       //std::cout << "SuperCluster creation ; energy " << pfCand[photPFCandidateIndex_[iphot]].ecalEnergy();
       //std::cout << " " <<   pfCand[photPFCandidateIndex_[iphot]].rawEcalEnergy() << std::endl;
       //      std::cout << " No seed found " << 0 << std::endl;
       //      std::cout << " MVA " << pfCand[gsfPFCandidateIndex_[iphot]].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_[iphot][ibc]);
       //      std::cout <<"Adding Ref to SC " << basicClusterPtr_[iphot][ibc].index() << std::endl;
       const std::vector<std::pair<DetId, float> > &v1 = basicClusters_[iphot][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_[iphot].size();
     for (unsigned ips = 0; ips < nps; ++ips) {
       mySuperCluster.addPreshowerCluster(preshowerClusterPtr_[iphot][ips]);
     }
  
     // Set the preshower energy
     mySuperCluster.setPreshowerEnergy(pfCand[photPFCandidateIndex_[iphot]].pS1Energy() +
                                       pfCand[photPFCandidateIndex_[iphot]].pS2Energy());
  
     // Set the cluster width
     mySuperCluster.setEtaWidth(pfwidth.pflowEtaWidth());
     mySuperCluster.setPhiWidth(pfwidth.pflowPhiWidth());
     // Force the computation of rawEnergy_ of the reco::SuperCluster
     mySuperCluster.rawEnergy();
  
     //cout << "SC energy="<< mySuperCluster.energy()<<endl;
  
     superClusters.push_back(mySuperCluster);
     //std::cout << "nb super clusters in collection : "<<superClusters.size()<<std::endl;
   }
 }

References reco::SuperCluster::addCluster(), reco::CaloCluster::addHitAndFraction(), reco::SuperCluster::addPreshowerCluster(), MillePedeFileConverter_cfg::e, PFClusterWidthAlgo::pflowEtaWidth(), PFClusterWidthAlgo::pflowPhiWidth(), RecoTauValidation_cfi::posX, RecoTauValidation_cfi::posY, reco::SuperCluster::rawEnergy(), reco::SuperCluster::setEtaWidth(), reco::SuperCluster::setPhiWidth(), reco::SuperCluster::setPreshowerEnergy(), reco::SuperCluster::setSeed(), and HLT_2018_cff::superClusters.

◆ fetchCandidateCollection()

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

private

Definition at line 572 of file PFPhotonTranslator.cc.

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

References HltBtagPostValidation_cff::c, runTheMatrix::err, newFWLiteAna::found, iEvent, and GlobalPosition_Frontier_DevDB_cff::tag.

◆ produce()

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

override

Definition at line 190 of file PFPhotonTranslator.cc.

                                                                               {
   //cout << "NEW EVENT"<<endl;
  
   auto basicClusters_p = std::make_unique<reco::BasicClusterCollection>();
  
   auto psClusters_p = std::make_unique<reco::PreshowerClusterCollection>();
  
   /*
   auto SingleLeg_p = std::make_unique<reco::ConversionCollection>();
   */
  
   reco::SuperClusterCollection outputSuperClusterCollection;
   reco::ConversionCollection outputOneLegConversionCollection;
   reco::PhotonCoreCollection outputPhotonCoreCollection;
   reco::PhotonCollection outputPhotonCollection;
  
   outputSuperClusterCollection.clear();
   outputOneLegConversionCollection.clear();
   outputPhotonCoreCollection.clear();
   outputPhotonCollection.clear();
  
   edm::Handle<reco::PFCandidateCollection> pfCandidates;
   bool status = fetchCandidateCollection(pfCandidates, inputTagPFCandidates_, iEvent);
  
   edm::Handle<reco::PhotonCollection> egPhotons;
   iEvent.getByLabel(EGPhotonCollection_, egPhotons);
  
   Handle<reco::VertexCollection> vertexHandle;
  
   IsolationValueMaps isolationValues(inputTagIsoVals_.size());
   for (size_t j = 0; j < inputTagIsoVals_.size(); ++j) {
     iEvent.getByLabel(inputTagIsoVals_[j], isolationValues[j]);
   }
  
   // clear the vectors
   photPFCandidateIndex_.clear();
   basicClusters_.clear();
   pfClusters_.clear();
   preshowerClusters_.clear();
   superClusters_.clear();
   basicClusterPtr_.clear();
   preshowerClusterPtr_.clear();
   CandidatePtr_.clear();
   egSCRef_.clear();
   egPhotonRef_.clear();
   pfPhotonMva_.clear();
   energyRegression_.clear();
   energyRegressionError_.clear();
   pfConv_.clear();
   pfSingleLegConv_.clear();
   pfSingleLegConvMva_.clear();
   conv1legPFCandidateIndex_.clear();
   conv2legPFCandidateIndex_.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 iphot = 0;
   unsigned iconv1leg = 0;
   unsigned iconv2leg = 0;
  
   for (unsigned i = 0; i < ncand; ++i) {
     const reco::PFCandidate &cand = (*pfCandidates)[i];
     if (cand.particleId() != reco::PFCandidate::gamma)
       continue;
     //cout << "cand.mva_nothing_gamma()="<<cand. mva_nothing_gamma()<<endl;
     if (cand.mva_nothing_gamma() > 0.001)  //Found PFPhoton with PFPhoton Extras saved
     {
       //cout << "NEW PHOTON" << endl;
  
       //std::cout << "nDoubleLegConv="<<cand.photonExtraRef()->conversionRef().size()<<std::endl;
  
       if (!cand.photonExtraRef()->conversionRef().empty()) {
         pfConv_.push_back(reco::ConversionRefVector());
  
         const reco::ConversionRefVector &doubleLegConvColl = cand.photonExtraRef()->conversionRef();
         for (unsigned int iconv = 0; iconv < doubleLegConvColl.size(); iconv++) {
           pfConv_[iconv2leg].push_back(doubleLegConvColl[iconv]);
         }
  
         conv2legPFCandidateIndex_.push_back(iconv2leg);
         iconv2leg++;
       } else
         conv2legPFCandidateIndex_.push_back(-1);
  
       const std::vector<reco::TrackRef> &singleLegConvColl = cand.photonExtraRef()->singleLegConvTrackRef();
       const std::vector<float> &singleLegConvCollMva = cand.photonExtraRef()->singleLegConvMva();
  
       //std::cout << "nSingleLegConv=" <<singleLegConvColl.size() << std::endl;
  
       if (!singleLegConvColl.empty()) {
         pfSingleLegConv_.push_back(std::vector<reco::TrackRef>());
         pfSingleLegConvMva_.push_back(std::vector<float>());
  
         //cout << "nTracks="<< singleLegConvColl.size()<<endl;
         for (unsigned int itk = 0; itk < singleLegConvColl.size(); itk++) {
           //cout << "Track pt="<< singleLegConvColl[itk]->pt() <<endl;
  
           pfSingleLegConv_[iconv1leg].push_back(singleLegConvColl[itk]);
           pfSingleLegConvMva_[iconv1leg].push_back(singleLegConvCollMva[itk]);
         }
  
         conv1legPFCandidateIndex_.push_back(iconv1leg);
  
         iconv1leg++;
       } else
         conv1legPFCandidateIndex_.push_back(-1);
     }
  
     photPFCandidateIndex_.push_back(i);
     pfPhotonMva_.push_back(cand.mva_nothing_gamma());
     energyRegression_.push_back(cand.photonExtraRef()->MVAGlobalCorrE());
     energyRegressionError_.push_back(cand.photonExtraRef()->MVAGlobalCorrEError());
     basicClusters_.push_back(reco::BasicClusterCollection());
     pfClusters_.push_back(std::vector<const reco::PFCluster *>());
     preshowerClusters_.push_back(reco::PreshowerClusterCollection());
     superClusters_.push_back(reco::SuperClusterCollection());
  
     reco::PFCandidatePtr ptrToPFPhoton(pfCandidates, i);
     CandidatePtr_.push_back(ptrToPFPhoton);
     egSCRef_.push_back(cand.superClusterRef());
     //std::cout << "PFPhoton cand " << iphot << std::endl;
  
     int iegphot = 0;
     for (reco::PhotonCollection::const_iterator gamIter = egPhotons->begin(); gamIter != egPhotons->end(); ++gamIter) {
       if (cand.superClusterRef() == gamIter->superCluster()) {
         reco::PhotonRef PhotRef(reco::PhotonRef(egPhotons, iegphot));
         egPhotonRef_.push_back(PhotRef);
       }
       iegphot++;
     }
  
     //std::cout << "Cand elements in blocks : " << cand.elementsInBlocks().size() << std::endl;
  
     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) {
         //std::cout << "BlockElement ECAL" << std::endl;
         // 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_[iphot], pfClusters_[iphot], correspondingDaughterCandidate(cand, pfbe));
       }
       if (pfbe.type() == reco::PFBlockElement::PS1) {
         //std::cout << "BlockElement PS1" << std::endl;
         createPreshowerCluster(pfbe, preshowerClusters_[iphot], 1);
       }
       if (pfbe.type() == reco::PFBlockElement::PS2) {
         //std::cout << "BlockElement PS2" << std::endl;
         createPreshowerCluster(pfbe, preshowerClusters_[iphot], 2);
       }
  
     }  // loop on the elements
  
     // save the basic clusters
     basicClusters_p->insert(basicClusters_p->end(), basicClusters_[iphot].begin(), basicClusters_[iphot].end());
     // save the preshower clusters
     psClusters_p->insert(psClusters_p->end(), preshowerClusters_[iphot].begin(), preshowerClusters_[iphot].end());
  
     ++iphot;
  
   }  // 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);
   if (status)
     createSuperClusters(*pfCandidates, outputSuperClusterCollection);
  
   //std::cout << "nb superclusters in collection : "<<outputSuperClusterCollection.size()<<std::endl;
  
   // Let's put the super clusters in the event
   auto superClusters_p = std::make_unique<reco::SuperClusterCollection>(outputSuperClusterCollection);
   const edm::OrphanHandle<reco::SuperClusterCollection> scRefProd =
       iEvent.put(std::move(superClusters_p), PFSuperClusterCollection_);
  
   /*
   int ipho=0;
   for (reco::SuperClusterCollection::const_iterator gamIter = scRefProd->begin(); gamIter != scRefProd->end(); ++gamIter){
     std::cout << "SC i="<<ipho<<" energy="<<gamIter->energy()<<std::endl;
     ipho++;
   }
   */
  
   //1-leg conversions
  
   if (status)
     createOneLegConversions(scRefProd, outputOneLegConversionCollection);
  
   auto SingleLeg_p = std::make_unique<reco::ConversionCollection>(outputOneLegConversionCollection);
   const edm::OrphanHandle<reco::ConversionCollection> ConvRefProd =
       iEvent.put(std::move(SingleLeg_p), PFConversionCollection_);
   /*
   int iconv = 0;
   for (reco::ConversionCollection::const_iterator convIter = ConvRefProd->begin(); convIter != ConvRefProd->end(); ++convIter){
  
     std::cout << "OneLegConv i="<<iconv<<" nTracks="<<convIter->nTracks()<<" EoverP="<<convIter->EoverP() <<std::endl;
     std::vector<edm::RefToBase<reco::Track> > convtracks = convIter->tracks();
     for (unsigned int itk=0; itk<convtracks.size(); itk++){
       std::cout << "Track pt="<< convtracks[itk]->pt() << std::endl;
     }  
  
     iconv++;
   }
   */
  
   //create photon cores
   //if(status) createPhotonCores(pfCandidates, scRefProd, *photonCores_p);
   if (status)
     createPhotonCores(scRefProd, ConvRefProd, outputPhotonCoreCollection);
  
   //std::cout << "nb photoncores in collection : "<<outputPhotonCoreCollection.size()<<std::endl;
  
   // Put the photon cores in the event
   auto photonCores_p = std::make_unique<reco::PhotonCoreCollection>(outputPhotonCoreCollection);
   //std::cout << "photon core collection put in unique_ptr"<<std::endl;
   const edm::OrphanHandle<reco::PhotonCoreCollection> pcRefProd =
       iEvent.put(std::move(photonCores_p), PFPhotonCoreCollection_);
  
   //std::cout << "photon core have been put in the event"<<std::endl;
   /*
   int ipho=0;
   for (reco::PhotonCoreCollection::const_iterator gamIter = pcRefProd->begin(); gamIter != pcRefProd->end(); ++gamIter){
     std::cout << "PhotonCore i="<<ipho<<" energy="<<gamIter->parentSuperCluster()->energy()<<std::endl;
     //for (unsigned int i=0; i<)
  
     std::cout << "PhotonCore i="<<ipho<<" nconv2leg="<<gamIter->conversions().size()<<" nconv1leg="<<gamIter->conversionsOneLeg().size()<<std::endl;
  
     const reco::ConversionRefVector & conv = gamIter->conversions();
     for (unsigned int iconv=0; iconv<conv.size(); iconv++){
       cout << "2-leg iconv="<<iconv<<endl;
       cout << "2-leg nTracks="<<conv[iconv]->nTracks()<<endl;
       cout << "2-leg EoverP="<<conv[iconv]->EoverP()<<endl;
       cout << "2-leg ConvAlgorithm="<<conv[iconv]->algo()<<endl;
     }
  
     const reco::ConversionRefVector & convbis = gamIter->conversionsOneLeg();
     for (unsigned int iconv=0; iconv<convbis.size(); iconv++){
       cout << "1-leg iconv="<<iconv<<endl;
       cout << "1-leg nTracks="<<convbis[iconv]->nTracks()<<endl;
       cout << "1-leg EoverP="<<convbis[iconv]->EoverP()<<endl;
       cout << "1-leg ConvAlgorithm="<<convbis[iconv]->algo()<<endl;
     }
  
     ipho++;
   }
   */
  
   //load vertices
   reco::VertexCollection vertexCollection;
   bool validVertex = true;
   iEvent.getByLabel(vertexProducer_, vertexHandle);
   if (!vertexHandle.isValid()) {
     edm::LogWarning("PhotonProducer") << "Error! Can't get the product primary Vertex Collection "
                                       << "\n";
     validVertex = false;
   }
   if (validVertex)
     vertexCollection = *(vertexHandle.product());
  
   /*
   //load Ecal rechits
   bool validEcalRecHits=true;
   Handle<EcalRecHitCollection> barrelHitHandle;
   EcalRecHitCollection barrelRecHits;
   iEvent.getByLabel(barrelEcalHits_, barrelHitHandle);
   if (!barrelHitHandle.isValid()) {
     edm::LogError("PhotonProducer") << "Error! Can't get the product "<<barrelEcalHits_.label();
     validEcalRecHits=false; 
   }
   if (  validEcalRecHits)  barrelRecHits = *(barrelHitHandle.product());
   
   Handle<EcalRecHitCollection> endcapHitHandle;
   iEvent.getByLabel(endcapEcalHits_, endcapHitHandle);
   EcalRecHitCollection endcapRecHits;
   if (!endcapHitHandle.isValid()) {
     edm::LogError("PhotonProducer") << "Error! Can't get the product "<<endcapEcalHits_.label();
     validEcalRecHits=false; 
   }
   if( validEcalRecHits) endcapRecHits = *(endcapHitHandle.product());
  
   //load detector topology & geometry
   iSetup.get<CaloGeometryRecord>().get(theCaloGeom_);
  
   edm::ESHandle<CaloTopology> pTopology;
   iSetup.get<CaloTopologyRecord>().get(theCaloTopo_);
   const CaloTopology *topology = theCaloTopo_.product();
  
   // get Hcal towers collection 
   Handle<CaloTowerCollection> hcalTowersHandle;
   iEvent.getByLabel(hcalTowers_, hcalTowersHandle);
   */
  
   //create photon collection
   //if(status) createPhotons(vertexCollection, pcRefProd, topology, &barrelRecHits, &endcapRecHits, hcalTowersHandle, isolationValues, outputPhotonCollection);
   if (status)
     createPhotons(vertexCollection, egPhotons, pcRefProd, isolationValues, outputPhotonCollection);
  
   // Put the photons in the event
   auto photons_p = std::make_unique<reco::PhotonCollection>(outputPhotonCollection);
   //std::cout << "photon collection put in unique_ptr"<<std::endl;
   const edm::OrphanHandle<reco::PhotonCollection> photonRefProd = iEvent.put(std::move(photons_p), PFPhotonCollection_);
   //std::cout << "photons have been put in the event"<<std::endl;
  
   /*
   ipho=0;
   for (reco::PhotonCollection::const_iterator gamIter = photonRefProd->begin(); gamIter != photonRefProd->end(); ++gamIter){
     std::cout << "Photon i="<<ipho<<" pfEnergy="<<gamIter->parentSuperCluster()->energy()<<std::endl;
     
     const reco::ConversionRefVector & conv = gamIter->conversions();
     cout << "conversions obtained : conv.size()="<< conv.size()<<endl;
     for (unsigned int iconv=0; iconv<conv.size(); iconv++){
       cout << "iconv="<<iconv<<endl;
       cout << "nTracks="<<conv[iconv]->nTracks()<<endl;
       cout << "EoverP="<<conv[iconv]->EoverP()<<endl;
       
       cout << "Vtx x="<<conv[iconv]->conversionVertex().x() << " y="<< conv[iconv]->conversionVertex().y()<<" z="<<conv[iconv]->conversionVertex().z()<< endl;
       cout << "VtxError x=" << conv[iconv]->conversionVertex().xError() << endl;
       
       std::vector<edm::RefToBase<reco::Track> > convtracks = conv[iconv]->tracks();
       //cout << "nTracks="<< convtracks.size()<<endl;
       for (unsigned int itk=0; itk<convtracks.size(); itk++){
     double convtrackpt = convtracks[itk]->pt();
     const edm::RefToBase<reco::Track> & mytrack = convtracks[itk];
     cout << "Track pt="<< convtrackpt <<endl;
     cout << "Track origin="<<gamIter->conversionTrackOrigin(mytrack)<<endl;
       }
     }
     
     //1-leg
     const reco::ConversionRefVector & convbis = gamIter->conversionsOneLeg();
     cout << "conversions obtained : conv.size()="<< convbis.size()<<endl;
     for (unsigned int iconv=0; iconv<convbis.size(); iconv++){
       cout << "iconv="<<iconv<<endl;
       cout << "nTracks="<<convbis[iconv]->nTracks()<<endl;
       cout << "EoverP="<<convbis[iconv]->EoverP()<<endl;
       
       cout << "Vtx x="<<convbis[iconv]->conversionVertex().x() << " y="<< convbis[iconv]->conversionVertex().y()<<" z="<<convbis[iconv]->conversionVertex().z()<< endl;
       cout << "VtxError x=" << convbis[iconv]->conversionVertex().xError() << endl;
        
       std::vector<edm::RefToBase<reco::Track> > convtracks = convbis[iconv]->tracks();
       //cout << "nTracks="<< convtracks.size()<<endl;
       for (unsigned int itk=0; itk<convtracks.size(); itk++){
     double convtrackpt = convtracks[itk]->pt();
     cout << "Track pt="<< convtrackpt <<endl;
     cout << "Track origin="<<gamIter->conversionTrackOrigin((convtracks[itk]))<<endl;
       }
     }
     ipho++;
   }
   */
 }

References reco::PFBlockElement::ECAL, bookConverter::elements, reco::PFCandidate::gamma, mps_fire::i, iEvent, edm::Ref< C, T, F >::isNull(), electronProducer_cff::isolationValues, edm::HandleBase::isValid(), dqmiolumiharvest::j, eostools::move(), gedPhotons_cfi::outputPhotonCollection, zmumugammaAnalyzer_cfi::pfCandidates, edm::Handle< T >::product(), reco::PFBlockElement::PS1, reco::PFBlockElement::PS2, edm::RefVector< C, T, F >::size(), mps_update::status, reco::PFBlockElement::type(), and spclusmultinvestigator_cfi::vertexCollection.

Member Data Documentation

◆ barrelEcalHits_

edm::InputTag PFPhotonTranslator::barrelEcalHits_

private

Definition at line 94 of file PFPhotonTranslator.cc.

◆ basicClusterPtr_

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

private

Definition at line 108 of file PFPhotonTranslator.cc.

◆ basicClusters_

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

private

Definition at line 100 of file PFPhotonTranslator.cc.

◆ CandidatePtr_

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

private

Definition at line 114 of file PFPhotonTranslator.cc.

◆ conv1legPFCandidateIndex_

std::vector<int> PFPhotonTranslator::conv1legPFCandidateIndex_

private

Definition at line 129 of file PFPhotonTranslator.cc.

◆ conv2legPFCandidateIndex_

std::vector<int> PFPhotonTranslator::conv2legPFCandidateIndex_

private

Definition at line 130 of file PFPhotonTranslator.cc.

◆ EGPhotonCollection_

std::string PFPhotonTranslator::EGPhotonCollection_

private

Definition at line 92 of file PFPhotonTranslator.cc.

◆ egPhotonRef_

std::vector<reco::PhotonRef> PFPhotonTranslator::egPhotonRef_

private

Definition at line 118 of file PFPhotonTranslator.cc.

◆ egSCRef_

std::vector<reco::SuperClusterRef> PFPhotonTranslator::egSCRef_

private

Definition at line 116 of file PFPhotonTranslator.cc.

◆ emptyIsOk_

bool PFPhotonTranslator::emptyIsOk_

private

Definition at line 135 of file PFPhotonTranslator.cc.

◆ endcapEcalHits_

edm::InputTag PFPhotonTranslator::endcapEcalHits_

private

Definition at line 95 of file PFPhotonTranslator.cc.

◆ energyRegression_

std::vector<float> PFPhotonTranslator::energyRegression_

private

Definition at line 121 of file PFPhotonTranslator.cc.

◆ energyRegressionError_

std::vector<float> PFPhotonTranslator::energyRegressionError_

private

Definition at line 122 of file PFPhotonTranslator.cc.

◆ hcalTowers_

edm::InputTag PFPhotonTranslator::hcalTowers_

private

Definition at line 96 of file PFPhotonTranslator.cc.

◆ hOverEConeSize_

double PFPhotonTranslator::hOverEConeSize_

private

Definition at line 97 of file PFPhotonTranslator.cc.

◆ inputTagIsoVals_

std::vector<edm::InputTag> PFPhotonTranslator::inputTagIsoVals_

private

Definition at line 85 of file PFPhotonTranslator.cc.

◆ inputTagPFCandidates_

edm::InputTag PFPhotonTranslator::inputTagPFCandidates_

private

Definition at line 84 of file PFPhotonTranslator.cc.

◆ PFBasicClusterCollection_

std::string PFPhotonTranslator::PFBasicClusterCollection_

private

Definition at line 86 of file PFPhotonTranslator.cc.

◆ pfClusters_

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

private

Definition at line 102 of file PFPhotonTranslator.cc.

◆ pfConv_

std::vector<reco::ConversionRefVector> PFPhotonTranslator::pfConv_

private

Definition at line 125 of file PFPhotonTranslator.cc.

◆ PFConversionCollection_

std::string PFPhotonTranslator::PFConversionCollection_

private

Definition at line 91 of file PFPhotonTranslator.cc.

◆ PFPhotonCollection_

std::string PFPhotonTranslator::PFPhotonCollection_

private

Definition at line 90 of file PFPhotonTranslator.cc.

◆ PFPhotonCoreCollection_

std::string PFPhotonTranslator::PFPhotonCoreCollection_

private

Definition at line 89 of file PFPhotonTranslator.cc.

◆ pfPhotonMva_

std::vector<float> PFPhotonTranslator::pfPhotonMva_

private

Definition at line 120 of file PFPhotonTranslator.cc.

◆ PFPreshowerClusterCollection_

std::string PFPhotonTranslator::PFPreshowerClusterCollection_

private

Definition at line 87 of file PFPhotonTranslator.cc.

◆ pfSingleLegConv_

std::vector<std::vector<reco::TrackRef> > PFPhotonTranslator::pfSingleLegConv_

private

Definition at line 126 of file PFPhotonTranslator.cc.

◆ pfSingleLegConvMva_

std::vector<std::vector<float> > PFPhotonTranslator::pfSingleLegConvMva_

private

Definition at line 127 of file PFPhotonTranslator.cc.

◆ PFSuperClusterCollection_

std::string PFPhotonTranslator::PFSuperClusterCollection_

private

Definition at line 88 of file PFPhotonTranslator.cc.

◆ photPFCandidateIndex_

std::vector<int> PFPhotonTranslator::photPFCandidateIndex_

private

Definition at line 112 of file PFPhotonTranslator.cc.

◆ preshowerClusterPtr_

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

private

Definition at line 110 of file PFPhotonTranslator.cc.

◆ preshowerClusters_

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

private

Definition at line 104 of file PFPhotonTranslator.cc.

◆ superClusters_

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

private

Definition at line 106 of file PFPhotonTranslator.cc.

◆ theCaloGeom_

edm::ESHandle<CaloGeometry> PFPhotonTranslator::theCaloGeom_

private

Definition at line 133 of file PFPhotonTranslator.cc.

◆ theCaloTopo_

edm::ESHandle<CaloTopology> PFPhotonTranslator::theCaloTopo_

private

Definition at line 132 of file PFPhotonTranslator.cc.

◆ vertexProducer_

std::string PFPhotonTranslator::vertexProducer_

private

Definition at line 93 of file PFPhotonTranslator.cc.

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ IsolationValueMaps

Constructor & Destructor Documentation

◆ PFPhotonTranslator()

◆ ~PFPhotonTranslator()

Member Function Documentation

◆ correspondingDaughterCandidate()

◆ createBasicCluster()

◆ createBasicClusterPtrs()

◆ createOneLegConversions()

◆ createPhotonCores()

◆ createPhotons()

◆ createPreshowerCluster()

◆ createPreshowerClusterPtrs()

◆ createSuperClusters()

◆ fetchCandidateCollection()

◆ produce()

Member Data Documentation

◆ barrelEcalHits_

◆ basicClusterPtr_

◆ basicClusters_

◆ CandidatePtr_

◆ conv1legPFCandidateIndex_

◆ conv2legPFCandidateIndex_

◆ EGPhotonCollection_

◆ egPhotonRef_

◆ egSCRef_

◆ emptyIsOk_

◆ endcapEcalHits_

◆ energyRegression_

◆ energyRegressionError_

◆ hcalTowers_

◆ hOverEConeSize_

◆ inputTagIsoVals_

◆ inputTagPFCandidates_

◆ PFBasicClusterCollection_

◆ pfClusters_

◆ pfConv_

◆ PFConversionCollection_

◆ PFPhotonCollection_

◆ PFPhotonCoreCollection_

◆ pfPhotonMva_

◆ PFPreshowerClusterCollection_

◆ pfSingleLegConv_

◆ pfSingleLegConvMva_

◆ PFSuperClusterCollection_

◆ photPFCandidateIndex_

◆ preshowerClusterPtr_

◆ preshowerClusters_

◆ superClusters_

◆ theCaloGeom_

◆ theCaloTopo_

◆ vertexProducer_