#include <HybridClusterProducer.h>

Inheritance diagram for HybridClusterProducer:

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

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

	~HybridClusterProducer () override

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

Private Attributes
std::string	basicclusterCollection_

edm::EDGetTokenT< EcalRecHitCollection >	hitsToken_

HybridClusterAlgo *	hybrid_p

int	nEvt_

PositionCalc	posCalculator_

std::string	superclusterCollection_

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

Definition at line 18 of file HybridClusterProducer.h.

Constructor & Destructor Documentation

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

Definition at line 38 of file HybridClusterProducer.cc.

References basicclusterCollection_, cosmicSuperClusters_cfi::bremRecoveryPset, cosmicSuperClusters_cfi::dynamicPhiRoad, edm::ParameterSet::getParameter(), hitsToken_, hybrid_p, nEvt_, MonitorAlCaEcalPi0_cfi::posCalcParameters, posCalculator_, AlCaHLTBitMon_QueryRunRegistry::string, and superclusterCollection_.

                                                                       {
   basicclusterCollection_ = ps.getParameter<std::string>("basicclusterCollection");
   superclusterCollection_ = ps.getParameter<std::string>("superclusterCollection");
   hitsToken_ = consumes<EcalRecHitCollection>(ps.getParameter<edm::InputTag>("recHitsCollection"));
 
   //Setup for core tools objects.
   edm::ParameterSet posCalcParameters = ps.getParameter<edm::ParameterSet>("posCalcParameters");
 
   posCalculator_ = PositionCalc(posCalcParameters);
 
   const std::vector<std::string> flagnames = ps.getParameter<std::vector<std::string> >("RecHitFlagToBeExcluded");
 
   const std::vector<int> flagsexcl = StringToEnumValue<EcalRecHit::Flags>(flagnames);
 
   const std::vector<std::string> severitynames =
       ps.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcluded");
 
   const std::vector<int> severitiesexcl = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynames);
 
   hybrid_p = new HybridClusterAlgo(ps.getParameter<double>("HybridBarrelSeedThr"),
                                    ps.getParameter<int>("step"),
                                    ps.getParameter<double>("ethresh"),
                                    ps.getParameter<double>("eseed"),
                                    ps.getParameter<double>("xi"),
                                    ps.getParameter<bool>("useEtForXi"),
                                    ps.getParameter<double>("ewing"),
                                    flagsexcl,
                                    posCalculator_,
                                    ps.getParameter<bool>("dynamicEThresh"),
                                    ps.getParameter<double>("eThreshA"),
                                    ps.getParameter<double>("eThreshB"),
                                    severitiesexcl,
                                    ps.getParameter<bool>("excludeFlagged"));
   //bremRecoveryPset,
 
   // get brem recovery parameters
   bool dynamicPhiRoad = ps.getParameter<bool>("dynamicPhiRoad");
   if (dynamicPhiRoad) {
     edm::ParameterSet bremRecoveryPset = ps.getParameter<edm::ParameterSet>("bremRecoveryPset");
     hybrid_p->setDynamicPhiRoad(bremRecoveryPset);
   }
 
   produces<reco::BasicClusterCollection>(basicclusterCollection_);
   produces<reco::SuperClusterCollection>(superclusterCollection_);
   nEvt_ = 0;
 }

HybridClusterProducer::~HybridClusterProducer ( )

override

Definition at line 85 of file HybridClusterProducer.cc.

References hybrid_p.

85 { delete hybrid_p; }

HybridClusterProducer::hybrid_p

HybridClusterAlgo * hybrid_p

Definition: HybridClusterProducer.h:34

Member Function Documentation

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

override

Definition at line 87 of file HybridClusterProducer.cc.

References basicclusterCollection_, DetId::Ecal, EcalBarrel, edm::EventSetup::get(), edm::Event::getByToken(), CaloGeometry::getSubdetectorGeometry(), hitsToken_, hybrid_p, mps_fire::i, edm::OrphanHandleBase::isValid(), edm::HandleBase::isValid(), LogTrace, HybridClusterAlgo::makeClusters(), HybridClusterAlgo::makeSuperClusters(), eostools::move(), nEvt_, edm::Handle< T >::product(), edm::ESHandle< T >::product(), edm::PtrVector< T >::push_back(), edm::Event::put(), superclusterCollection_, HLT_2018_cff::superClusters, and ecaldqm::topology().

                                                                           {
   // get the hit collection from the event:
   edm::Handle<EcalRecHitCollection> rhcHandle;
 
   evt.getByToken(hitsToken_, rhcHandle);
   if (!(rhcHandle.isValid())) {
     edm::LogError("MissingProduct") << "could not get a handle on the EcalRecHitCollection!";
     return;
   }
   const EcalRecHitCollection* hit_collection = rhcHandle.product();
 
   // get the collection geometry:
   edm::ESHandle<CaloGeometry> geoHandle;
   es.get<CaloGeometryRecord>().get(geoHandle);
   const CaloGeometry& geometry = *geoHandle;
   const CaloSubdetectorGeometry* geometry_p;
   std::unique_ptr<const CaloSubdetectorTopology> topology;
 
   edm::ESHandle<EcalSeverityLevelAlgo> sevLv;
   es.get<EcalSeverityLevelAlgoRcd>().get(sevLv);
 
   geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
   topology = std::make_unique<EcalBarrelTopology>(*geoHandle);
 
   // make the Basic clusters!
   reco::BasicClusterCollection basicClusters;
   hybrid_p->makeClusters(
       hit_collection, geometry_p, basicClusters, sevLv.product(), false, std::vector<RectangularEtaPhiRegion>());
 
   LogTrace("EcalClusters") << "Finished clustering - BasicClusterCollection returned to producer...";
 
   // create a unique_ptr to a BasicClusterCollection, copy the clusters into it and put in the Event:
   auto basicclusters_p = std::make_unique<reco::BasicClusterCollection>();
   basicclusters_p->assign(basicClusters.begin(), basicClusters.end());
   edm::OrphanHandle<reco::BasicClusterCollection> bccHandle =
       evt.put(std::move(basicclusters_p), basicclusterCollection_);
 
   //Basic clusters now in the event.
   LogTrace("EcalClusters") << "Basic Clusters now put into event.";
 
   //Weird though it is, get the BasicClusters back out of the event.  We need the
   //edm::Ref to these guys to make our superclusters for Hybrid.
 
   if (!(bccHandle.isValid())) {
     edm::LogError("Missing Product") << "could not get a handle on the BasicClusterCollection!";
     return;
   }
 
   reco::BasicClusterCollection clusterCollection = *bccHandle;
 
   LogTrace("EcalClusters") << "Got the BasicClusterCollection" << std::endl;
 
   reco::CaloClusterPtrVector clusterPtrVector;
   for (unsigned int i = 0; i < clusterCollection.size(); i++) {
     clusterPtrVector.push_back(reco::CaloClusterPtr(bccHandle, i));
   }
 
   reco::SuperClusterCollection superClusters = hybrid_p->makeSuperClusters(clusterPtrVector);
   LogTrace("EcalClusters") << "Found: " << superClusters.size() << " superclusters.";
 
   auto superclusters_p = std::make_unique<reco::SuperClusterCollection>();
   superclusters_p->assign(superClusters.begin(), superClusters.end());
 
   evt.put(std::move(superclusters_p), superclusterCollection_);
   LogTrace("EcalClusters") << "Hybrid Clusters (Basic/Super) added to the Event! :-)";
 
   nEvt_++;
 }