#include <PhotonCoreProducer.h>

Inheritance diagram for PhotonCoreProducer:

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

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

	~PhotonCoreProducer ()

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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<>
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 Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

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

Definition at line 30 of file PhotonCoreProducer.h.

Constructor & Destructor Documentation

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

Definition at line 20 of file PhotonCoreProducer.cc.

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

                                                                     : 
   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_);
 
 }

PhotonCoreProducer::~PhotonCoreProducer ( )

Definition at line 43 of file PhotonCoreProducer.cc.

43 {}

Member Function Documentation

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 127 of file PhotonCoreProducer.cc.

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

Referenced by produce().

                                                                                            {
   
 
   
   reco::ElectronSeedCollection::const_iterator pixelSeedItr;
   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);
     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().size()) 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);
    
   }    
   
 
 }

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

virtual

Definition at line 48 of file PhotonCoreProducer.cc.

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

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

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 189 of file PhotonCoreProducer.cc.

References edm::Ref< C, T, F >::id(), edm::Ref< C, T, F >::key(), AlCaHLTBitMon_ParallelJobs::p, mathSSE::sqrt(), and l1t::tracks.

Referenced by fillPhotonCollection().

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