#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::HybridClusterProducer ( const edm::ParameterSet & ps )

Definition at line 38 of file HybridClusterProducer.cc.

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

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

◆ ~HybridClusterProducer()

HybridClusterProducer::~HybridClusterProducer ( )

override

Definition at line 85 of file HybridClusterProducer.cc.

85 { delete hybrid_p; }

References hybrid_p.

Member Function Documentation

◆ produce()

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

override

Definition at line 87 of file HybridClusterProducer.cc.

                                                                           {
   // 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_++;
 }