#include <CommonTools/RecoAlgos/plugins/PFClusterMatchedToPhotonsSelector.cc>

Inheritance diagram for PFClusterMatchedToPhotonsSelector:

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

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

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

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

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, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	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 &	itemsToGetFrom (BranchType iType) 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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

Private Attributes
edm::EDGetTokenT< reco::PFCluster::EEtoPSAssociation >	associationToken_

edm::EDGetTokenT< reco::GenParticleCollection >	genParticleToken_

double	matchMaxDEDR2_

double	matchMaxDR2_

edm::EDGetTokenT< reco::PFClusterCollection >	particleFlowClusterECALToken_

edm::EDGetTokenT< TrackingParticleCollection >	trackingParticleToken_

double	volumeRadius_EB_

double	volumeZ_EB_

double	volumeZ_EE_

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
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

Description: Matches ECAL PF clusters to photons that do not convert

Implementation:

Definition at line 46 of file PFClusterMatchedToPhotonsSelector.cc.

Constructor & Destructor Documentation

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

Definition at line 66 of file PFClusterMatchedToPhotonsSelector.cc.

References associationToken_, genParticleToken_, edm::ParameterSet::getParameter(), matchMaxDEDR2_, matchMaxDR2_, particleFlowClusterECALToken_, trackingParticleToken_, volumeRadius_EB_, volumeZ_EB_, and volumeZ_EE_.

                                                                                                    {
   //now do what ever initialization is needed
   particleFlowClusterECALToken_ = consumes<reco::PFClusterCollection>(iConfig.getParameter<edm::InputTag>("pfClustersTag"));
   associationToken_ = consumes<reco::PFCluster::EEtoPSAssociation>(iConfig.getParameter<edm::InputTag>("pfClustersTag"));
   trackingParticleToken_ = consumes<TrackingParticleCollection>(iConfig.getParameter<edm::InputTag>("trackingParticleTag"));
   genParticleToken_ = consumes<reco::GenParticleCollection>(iConfig.getParameter<edm::InputTag>("genParticleTag"));
 
   matchMaxDR2_     = iConfig.getParameter<double>("maxDR2");
   matchMaxDEDR2_   = iConfig.getParameter<double>("maxDEDR2");
   volumeZ_EB_      = iConfig.getParameter<double>("volumeZ_EB");
   volumeRadius_EB_ = iConfig.getParameter<double>("volumeRadius_EB");
   volumeZ_EE_      = iConfig.getParameter<double>("volumeZ_EE");
 
   produces<reco::PFClusterCollection>();
   produces<reco::PFCluster::EEtoPSAssociation>();
   produces<edm::ValueMap<reco::GenParticleRef> >();
 }

Member Function Documentation

void PFClusterMatchedToPhotonsSelector::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 85 of file PFClusterMatchedToPhotonsSelector.cc.

References edm::ConfigurationDescriptions::add(), and edm::ParameterSetDescription::add().

                                                                                                    {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("pfClustersTag", edm::InputTag("particleFlowClusterECAL"));
   desc.add<edm::InputTag>("trackingParticleTag", edm::InputTag("mix", "MergedTrackTruth"));
   desc.add<edm::InputTag>("genParticleTag", edm::InputTag("genParticles"));
   desc.add<double>("maxDR2", 0.1*0.1);
   desc.add<double>("maxDEDR2", 0.5*0.5);
   desc.add<double>("volumeZ_EB", 304.5);
   desc.add<double>("volumeRadius_EB", 123.8);
   desc.add<double>("volumeZ_EE", 317.0);
   descriptions.add("pfClusterMatchedToPhotonsSelector", desc);
 
 }

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

overrideprivate

Definition at line 99 of file PFClusterMatchedToPhotonsSelector.cc.

References funct::abs(), associationToken_, DEFINE_FWK_MODULE, reco::deltaR2(), edm::helper::Filler< Map >::fill(), genParticleToken_, edm::Event::getByToken(), mps_fire::i, edm::helper::Filler< Map >::insert(), trackerHitRTTI::isMatched(), matchMaxDEDR2_, matchMaxDR2_, eostools::move(), MillePedeFileConverter_cfg::out, particleFlowClusterECALToken_, edm::Handle< T >::product(), edm::Event::put(), sortByKey(), trackingParticleToken_, volumeRadius_EB_, volumeZ_EB_, and volumeZ_EE_.

                                                                                              {
 
   edm::Handle<reco::PFClusterCollection> particleFlowClusterECALHandle_;
   edm::Handle<reco::PFCluster::EEtoPSAssociation> associationHandle_;
   edm::Handle<TrackingParticleCollection> trackingParticleHandle_;
   edm::Handle<reco::GenParticleCollection> genParticleHandle_;
   iEvent.getByToken(particleFlowClusterECALToken_, particleFlowClusterECALHandle_);
   iEvent.getByToken(trackingParticleToken_, trackingParticleHandle_);  
   iEvent.getByToken(genParticleToken_, genParticleHandle_);  
   iEvent.getByToken(associationToken_, associationHandle_);  
 
   std::unique_ptr<reco::PFClusterCollection>                      out   = std::make_unique<reco::PFClusterCollection>();
   std::unique_ptr<reco::PFCluster::EEtoPSAssociation> association_out   = std::make_unique<reco::PFCluster::EEtoPSAssociation>();
   std::unique_ptr<edm::ValueMap<reco::GenParticleRef> > genmatching_out = std::make_unique<edm::ValueMap<reco::GenParticleRef> >();
 
   std::vector<reco::GenParticleRef> genmatching;
 
   size_t iN(0);  
   for (size_t iP = 0; iP < particleFlowClusterECALHandle_->size(); iP++) {
     
     auto&& pfCluster = particleFlowClusterECALHandle_->at(iP);
     bool isMatched = false;
     reco::GenParticleRef::key_type matchedKey;
 
     // Preselect PFclusters
     if (pfCluster.energy() <= 0) {
       continue;
     }
 
     for (auto&& trackingParticle : *trackingParticleHandle_) {
       if (trackingParticle.pdgId() != 22) continue;
       if (trackingParticle.status() != 1) continue;
       matchedKey = trackingParticle.genParticles().at(0).key();
       float dR2 = reco::deltaR2(trackingParticle, pfCluster.position());
       if (dR2 > matchMaxDR2_) continue; 
       float dE = 1. - trackingParticle.genParticles().at(0)->energy()/pfCluster.energy();
       if ((dR2 + dE*dE) > matchMaxDEDR2_) continue; 
 
       bool isConversion = false;
       for (auto&& vertRef : trackingParticle.decayVertices()) {
     if (vertRef->position().rho() > volumeRadius_EB_ && std::abs(vertRef->position().z()) < volumeZ_EB_) continue;
     if (std::abs(vertRef->position().z()) > volumeZ_EE_) continue;
     
     for(auto&& tpRef: vertRef->daughterTracks()) {
       if(std::abs(tpRef->pdgId()) == 11) isConversion = true;
       break;
     }
     if (isConversion) break;
       }      
       if (isConversion) continue;
 
       isMatched = true;           
       break;
     }
 
     if (isMatched) {
       out->push_back(pfCluster);
       for (size_t i=0; i<associationHandle_.product()->size(); i++) {
     if (associationHandle_.product()->at(i).first == iP) {
       association_out->push_back(std::make_pair(iN, associationHandle_.product()->at(i).second));
     }
       }
       genmatching.push_back(edm::Ref<reco::GenParticleCollection>(genParticleHandle_,matchedKey));
     }
   }
 
   std::sort(association_out->begin(),association_out->end(),sortByKey);  
   edm::OrphanHandle<reco::PFClusterCollection> pfClusterHandle= iEvent.put(std::move(out));
   iEvent.put(std::move(association_out));
 
   edm::ValueMap<reco::GenParticleRef>::Filler mapFiller(*genmatching_out);
   mapFiller.insert(pfClusterHandle, genmatching.begin(), genmatching.end());
   mapFiller.fill();
   iEvent.put(std::move(genmatching_out));
 }