Inheritance diagram for HGCalMultiClusterProducer:

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

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

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

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

Private Attributes
edm::EDGetTokenT< std::vector< reco::BasicCluster > >	clusters_sharing_token

edm::EDGetTokenT< std::vector< reco::BasicCluster > >	clusters_token

bool	doSharing

edm::EDGetTokenT< HGCRecHitCollection >	hits_bh_token

edm::EDGetTokenT< HGCRecHitCollection >	hits_ee_token

edm::EDGetTokenT< HGCRecHitCollection >	hits_fh_token

std::unique_ptr< HGCal3DClustering >	multicluster_algo

HGCalClusteringAlgoBase::VerbosityLevel	verbosity

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

Definition at line 22 of file HGCalMultiClusterProducer.cc.

Constructor & Destructor Documentation

◆ HGCalMultiClusterProducer()

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

Definition at line 41 of file HGCalMultiClusterProducer.cc.

References clusters_sharing_token, clusters_token, edm::ParameterSet::getParameter(), hits_bh_token, hits_ee_token, hits_fh_token, PbPb_UPC_Monopole_cff::minClusters, and multicluster_algo.

     : doSharing(ps.getParameter<bool>("doSharing")),
       verbosity((HGCalClusteringAlgoBase::VerbosityLevel)ps.getUntrackedParameter<unsigned int>("verbosity", 3)) {
   std::vector<double> multicluster_radii = ps.getParameter<std::vector<double>>("multiclusterRadii");
   double minClusters = ps.getParameter<unsigned>("minClusters");
   clusters_token = consumes<std::vector<reco::BasicCluster>>(ps.getParameter<edm::InputTag>("HGCLayerClusters"));
   clusters_sharing_token =
       consumes<std::vector<reco::BasicCluster>>(ps.getParameter<edm::InputTag>("HGCLayerClustersSharing"));
   hits_ee_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCEEInput"));
   hits_fh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCFHInput"));
   hits_bh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCBHInput"));
   auto sumes = consumesCollector();
 
   multicluster_algo = std::make_unique<HGCal3DClustering>(ps, sumes, multicluster_radii, minClusters);
 
   produces<std::vector<reco::HGCalMultiCluster>>();
   produces<std::vector<reco::HGCalMultiCluster>>("sharing");
 }

◆ ~HGCalMultiClusterProducer()

HGCalMultiClusterProducer::~HGCalMultiClusterProducer ( )

inlineoverride

Definition at line 25 of file HGCalMultiClusterProducer.cc.

25 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 60 of file HGCalMultiClusterProducer.cc.

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

                                                                                            {
   // hgcalMultiClusters
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("HGCLayerClusters", edm::InputTag("hgcalMergeLayerClusters"));
   desc.addUntracked<unsigned int>("verbosity", 3);
   desc.add<bool>("doSharing", false);
   desc.add<edm::InputTag>("HGCEEInput", edm::InputTag("HGCalRecHit", "HGCEERecHits"));
   desc.add<edm::InputTag>("HGCFHInput", edm::InputTag("HGCalRecHit", "HGCHEFRecHits"));
   desc.add<std::vector<double>>("multiclusterRadii",
                                 {
                                     2.0,
                                     5.0,
                                     5.0,
                                 });
   desc.add<edm::InputTag>("HGCBHInput", edm::InputTag("HGCalRecHit", "HGCHEBRecHits"));
   desc.add<edm::InputTag>("hgcalHitMap", {"recHitMapProducer", "hgcalRecHitMap"});
   desc.add<edm::InputTag>("HGCLayerClustersSharing", edm::InputTag("hgcalMergeLayerClusters", "sharing"));
   desc.add<unsigned int>("minClusters", 3);
   descriptions.add("hgcalMultiClusters", desc);
 }

◆ produce()

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

override

Definition at line 81 of file HGCalMultiClusterProducer.cc.

References clusters_sharing_token, clusters_token, doSharing, edm::Event::getByToken(), mps_fire::i, eostools::move(), multicluster_algo, edm::PtrVector< T >::push_back(), and edm::Event::put().

                                                                               {
   edm::Handle<std::vector<reco::BasicCluster>> clusterHandle;
   edm::Handle<std::vector<reco::BasicCluster>> clusterSharingHandle;
 
   evt.getByToken(clusters_token, clusterHandle);
   if (doSharing)
     evt.getByToken(clusters_sharing_token, clusterSharingHandle);
 
   edm::PtrVector<reco::BasicCluster> clusterPtrs, clusterPtrsSharing;
   for (unsigned i = 0; i < clusterHandle->size(); ++i) {
     edm::Ptr<reco::BasicCluster> ptr(clusterHandle, i);
     clusterPtrs.push_back(ptr);
   }
 
   if (doSharing) {
     for (unsigned i = 0; i < clusterSharingHandle->size(); ++i) {
       edm::Ptr<reco::BasicCluster> ptr(clusterSharingHandle, i);
       clusterPtrsSharing.push_back(ptr);
     }
   }
 
   auto multiclusters = std::make_unique<std::vector<reco::HGCalMultiCluster>>();
   auto multiclusters_sharing = std::make_unique<std::vector<reco::HGCalMultiCluster>>();
 
   multicluster_algo->getEvent(evt);
   multicluster_algo->getEventSetup(es);
 
   *multiclusters = multicluster_algo->makeClusters(clusterPtrs);
   if (doSharing)
     *multiclusters_sharing = multicluster_algo->makeClusters(clusterPtrsSharing);
   evt.put(std::move(multiclusters));
   if (doSharing)
     evt.put(std::move(multiclusters_sharing), "sharing");
 }