#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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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

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.

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

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

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 84 of file PFClusterMatchedToPhotonsSelector.cc.

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

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

◆ produce()

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

overrideprivate

Definition at line 97 of file PFClusterMatchedToPhotonsSelector.cc.

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