Inheritance diagram for PhotonCoreProducer:

Public Member Functions
	PhotonCoreProducer (const edm::ParameterSet &ps)

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

	~PhotonCoreProducer () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Private Member Functions
void	fillPhotonCollection (edm::Event &evt, edm::EventSetup const &es, const edm::Handle< reco::SuperClusterCollection > &scHandle, const edm::Handle< reco::ConversionCollection > &conversionHandle, const edm::Handle< reco::ElectronSeedCollection > &pixelSeeds, reco::PhotonCoreCollection &outputCollection, int &iSC)

reco::ConversionRef	solveAmbiguity (const edm::Handle< reco::ConversionCollection > &conversionHandle, reco::SuperClusterRef &sc)

Private Attributes
edm::ParameterSet	conf_

edm::EDGetTokenT< reco::ConversionCollection >	conversionProducer_

double	minSCEt_

std::string	PhotonCoreCollection_

edm::EDGetTokenT< reco::ElectronSeedCollection >	pixelSeedProducer_

bool	risolveAmbiguity_

edm::EDGetTokenT< reco::SuperClusterCollection >	scHybridBarrelProducer_

edm::EDGetTokenT< reco::SuperClusterCollection >	scIslandEndcapProducer_

bool	validConversions_

bool	validPixelSeeds_

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

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Author: Nancy Marinelli, U. of Notre Dame, US

Definition at line 28 of file PhotonCoreProducer.cc.

Constructor & Destructor Documentation

◆ PhotonCoreProducer()

PhotonCoreProducer::PhotonCoreProducer ( const edm::ParameterSet & ps )

Definition at line 63 of file PhotonCoreProducer.cc.

     : conf_(config)
  
 {
   // use onfiguration file to setup input/output collection names
   scHybridBarrelProducer_ =
       consumes<reco::SuperClusterCollection>(conf_.getParameter<edm::InputTag>("scHybridBarrelProducer"));
   scIslandEndcapProducer_ =
       consumes<reco::SuperClusterCollection>(conf_.getParameter<edm::InputTag>("scIslandEndcapProducer"));
   conversionProducer_ = consumes<reco::ConversionCollection>(conf_.getParameter<edm::InputTag>("conversionProducer"));
   PhotonCoreCollection_ = conf_.getParameter<std::string>("photonCoreCollection");
   pixelSeedProducer_ = consumes<reco::ElectronSeedCollection>(conf_.getParameter<edm::InputTag>("pixelSeedProducer"));
   minSCEt_ = conf_.getParameter<double>("minSCEt");
   risolveAmbiguity_ = conf_.getParameter<bool>("risolveConversionAmbiguity");
  
   // Register the product
   produces<reco::PhotonCoreCollection>(PhotonCoreCollection_);
 }

References conf_, conversionProducer_, edm::ParameterSet::getParameter(), minSCEt_, PhotonCoreCollection_, pixelSeedProducer_, risolveAmbiguity_, scHybridBarrelProducer_, scIslandEndcapProducer_, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~PhotonCoreProducer()

PhotonCoreProducer::~PhotonCoreProducer ( )

override

Definition at line 82 of file PhotonCoreProducer.cc.

82 {}

Member Function Documentation

◆ fillPhotonCollection()

void PhotonCoreProducer::fillPhotonCollection	(	edm::Event &	evt,
		edm::EventSetup const &	es,
		const edm::Handle< reco::SuperClusterCollection > &	scHandle,
		const edm::Handle< reco::ConversionCollection > &	conversionHandle,
		const edm::Handle< reco::ElectronSeedCollection > &	pixelSeeds,
		reco::PhotonCoreCollection &	outputCollection,
		int &	iSC
	)

private

Definition at line 143 of file PhotonCoreProducer.cc.

                                                         {
   for (unsigned int lSC = 0; lSC < scHandle->size(); lSC++) {
     // get SuperClusterRef
     reco::SuperClusterRef scRef(reco::SuperClusterRef(scHandle, lSC));
     iSC++;
     //const reco::SuperCluster* pClus=&(*scRef);
  
     // SC energy preselection
     if (scRef->energy() / cosh(scRef->eta()) <= minSCEt_)
       continue;
  
     reco::PhotonCore newCandidate(scRef);
     newCandidate.setParentSuperCluster(scRef);
     if (validConversions_) {
       if (risolveAmbiguity_) {
         reco::ConversionRef bestRef = solveAmbiguity(conversionHandle, scRef);
         if (bestRef.isNonnull())
           newCandidate.addConversion(bestRef);
  
       } else {
         for (unsigned int icp = 0; icp < conversionHandle->size(); icp++) {
           reco::ConversionRef cpRef(reco::ConversionRef(conversionHandle, icp));
           if (cpRef->caloCluster().empty())
             continue;
           if (!(scRef.id() == cpRef->caloCluster()[0].id() && scRef.key() == cpRef->caloCluster()[0].key()))
             continue;
           if (!cpRef->isConverted())
             continue;
           newCandidate.addConversion(cpRef);
         }
  
       }  // solve or not the ambiguity of many conversion candidates
     }
  
     if (validPixelSeeds_) {
       for (unsigned int icp = 0; icp < pixelSeedHandle->size(); icp++) {
         reco::ElectronSeedRef cpRef(reco::ElectronSeedRef(pixelSeedHandle, icp));
         if (!cpRef->isEcalDriven())
           continue;
         if (!(scRef.id() == cpRef->caloCluster().id() && scRef.key() == cpRef->caloCluster().key()))
           continue;
         newCandidate.addElectronPixelSeed(cpRef);
       }
     }
  
     outputPhotonCoreCollection.push_back(newCandidate);
   }
 }

References reco::PhotonCore::addConversion(), reco::PhotonCore::addElectronPixelSeed(), printConversionInfo::conversionHandle, edm::Ref< C, T, F >::id(), edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), minSCEt_, risolveAmbiguity_, reco::PhotonCore::setParentSuperCluster(), solveAmbiguity(), validConversions_, and validPixelSeeds_.

Referenced by produce().

◆ produce()

void PhotonCoreProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

override

Definition at line 84 of file PhotonCoreProducer.cc.

                                                                                        {
   using namespace edm;
   //  nEvt_++;
  
   reco::PhotonCoreCollection outputPhotonCoreCollection;
   auto outputPhotonCoreCollection_p = std::make_unique<reco::PhotonCoreCollection>();
  
   // Get the  Barrel Super Cluster collection
   bool validBarrelSCHandle = true;
   Handle<reco::SuperClusterCollection> scBarrelHandle;
   theEvent.getByToken(scHybridBarrelProducer_, scBarrelHandle);
   if (!scBarrelHandle.isValid()) {
     edm::LogError("PhotonCoreProducer") << "Error! Can't get the scHybridBarrelProducer";
     validBarrelSCHandle = false;
   }
  
   // Get the  Endcap Super Cluster collection
   bool validEndcapSCHandle = true;
   Handle<reco::SuperClusterCollection> scEndcapHandle;
   theEvent.getByToken(scIslandEndcapProducer_, scEndcapHandle);
   if (!scEndcapHandle.isValid()) {
     edm::LogError("PhotonCoreProducer") << "Error! Can't get the scIslandEndcapProducer";
     validEndcapSCHandle = false;
   }
  
   validConversions_ = true;
   edm::Handle<reco::ConversionCollection> conversionHandle;
   theEvent.getByToken(conversionProducer_, conversionHandle);
   if (!conversionHandle.isValid()) {
     //edm::LogError("PhotonCoreProducer") << "Error! Can't get the product "<< conversionProducer_.label() << "\n" ;
     validConversions_ = false;
   }
  
   // Get ElectronPixelSeeds
   validPixelSeeds_ = true;
   Handle<reco::ElectronSeedCollection> pixelSeedHandle;
   reco::ElectronSeedCollection pixelSeeds;
   theEvent.getByToken(pixelSeedProducer_, pixelSeedHandle);
   if (!pixelSeedHandle.isValid()) {
     validPixelSeeds_ = false;
   }
   //  if ( validPixelSeeds_) pixelSeeds = *(pixelSeedHandle.product());
  
   int iSC = 0;  // index in photon collection
   // Loop over barrel and endcap SC collections and fill the  photon collection
   if (validBarrelSCHandle)
     fillPhotonCollection(
         theEvent, theEventSetup, scBarrelHandle, conversionHandle, pixelSeedHandle, outputPhotonCoreCollection, iSC);
   if (validEndcapSCHandle)
     fillPhotonCollection(
         theEvent, theEventSetup, scEndcapHandle, conversionHandle, pixelSeedHandle, outputPhotonCoreCollection, iSC);
  
   // put the product in the event
   edm::LogInfo("PhotonCoreProducer") << " Put in the event " << iSC << " Photon Candidates \n";
   outputPhotonCoreCollection_p->assign(outputPhotonCoreCollection.begin(), outputPhotonCoreCollection.end());
   theEvent.put(std::move(outputPhotonCoreCollection_p), PhotonCoreCollection_);
 }

References printConversionInfo::conversionHandle, conversionProducer_, fillPhotonCollection(), edm::Event::getByToken(), edm::HandleBase::isValid(), eostools::move(), PhotonCoreCollection_, pixelSeedProducer_, hltEgammaHLTExtra_cfi::pixelSeeds, edm::Event::put(), scHybridBarrelProducer_, scIslandEndcapProducer_, validConversions_, and validPixelSeeds_.

◆ solveAmbiguity()

reco::ConversionRef PhotonCoreProducer::solveAmbiguity	(	const edm::Handle< reco::ConversionCollection > &	conversionHandle,
		reco::SuperClusterRef &	sc
	)

private

only one track reconstructed. Pick the one with best E/P

Definition at line 198 of file PhotonCoreProducer.cc.

                                                                                    {
   std::multimap<reco::ConversionRef, double> convMap;
   for (unsigned int icp = 0; icp < conversionHandle->size(); icp++) {
     reco::ConversionRef cpRef(reco::ConversionRef(conversionHandle, icp));
  
     if (!(scRef.id() == cpRef->caloCluster()[0].id() && scRef.key() == cpRef->caloCluster()[0].key()))
       continue;
     if (!cpRef->isConverted())
       continue;
     double like = cpRef->MVAout();
     convMap.insert(std::make_pair(cpRef, like));
   }
  
   std::multimap<reco::ConversionRef, double>::iterator iMap;
   double max_lh = -1.;
   reco::ConversionRef bestRef;
   //  std::cout << " Pick up the best conv " << std::endl;
   for (iMap = convMap.begin(); iMap != convMap.end(); iMap++) {
     double like = iMap->second;
     if (like > max_lh) {
       max_lh = like;
       bestRef = iMap->first;
     }
   }
  
   //std::cout << " Best conv like " << max_lh << std::endl;
  
   float ep = 0;
   if (max_lh < 0) {
     //    std::cout << " Candidates with only one track " << std::endl;
     float epMin = 999;
  
     for (iMap = convMap.begin(); iMap != convMap.end(); iMap++) {
       reco::ConversionRef convRef = iMap->first;
       // std::vector<reco::TrackRef> tracks = convRef->tracks();
       const std::vector<edm::RefToBase<reco::Track> > tracks = convRef->tracks();
       float px = tracks[0]->innerMomentum().x();
       float py = tracks[0]->innerMomentum().y();
       float pz = tracks[0]->innerMomentum().z();
       float p = sqrt(px * px + py * py + pz * pz);
       ep = fabs(1. - convRef->caloCluster()[0]->energy() / p);
       //    std::cout << " 1-E/P = " << ep << std::endl;
       if (ep < epMin) {
         epMin = ep;
         bestRef = iMap->first;
       }
     }
     //  std::cout << " Best conv 1-E/P " << ep << std::endl;
   }
  
   return bestRef;
 }