#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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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 19 of file HybridClusterProducer.h.

Constructor & Destructor Documentation

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

Definition at line 40 of file HybridClusterProducer.cc.

References basicclusterCollection_, cosmicSuperClusters_cfi::bremRecoveryPset, cosmicSuperClusters_cfi::dynamicPhiRoad, edm::ParameterSet::getParameter(), hitsToken_, hybrid_p, nEvt_, cleanAndMergeSuperClusters_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 97 of file HybridClusterProducer.cc.

References hybrid_p.

 {
   delete hybrid_p;
 }

Member Function Documentation

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

override

Definition at line 103 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_, 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_++;
 }