#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

	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

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

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

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

Implementation:

Definition at line 43 of file PFClusterMatchedToPhotonsSelector.cc.

Constructor & Destructor Documentation

◆ PFClusterMatchedToPhotonsSelector()

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

Definition at line 63 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

◆ fillDescriptions()

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

static

Definition at line 84 of file PFClusterMatchedToPhotonsSelector.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and HLT_2022v15_cff::InputTag.

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

◆ produce()

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

overrideprivate

Definition at line 97 of file PFClusterMatchedToPhotonsSelector.cc.

References funct::abs(), associationToken_, reco::deltaR2(), edm::helper::Filler< Map >::fill(), genParticleToken_, mps_fire::i, iEvent, edm::helper::Filler< Map >::insert(), trackerHitRTTI::isMatched(), matchMaxDEDR2_, matchMaxDR2_, eostools::move(), MillePedeFileConverter_cfg::out, particleFlowClusterECALToken_, edm::Handle< T >::product(), jetsAK4_CHS_cff::sort, 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));
 }