#include <IslandClusterProducer.h>

Inheritance diagram for IslandClusterProducer:

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

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

	~IslandClusterProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Private Member Functions
void	clusterizeECALPart (edm::Event &evt, const edm::EventSetup &es, const edm::EDGetTokenT< EcalRecHitCollection > &token, const std::string &clusterCollection, const std::string &clusterShapeAssociation, const IslandClusterAlgo::EcalPart &ecalPart)

bool	counterExceeded () const

const EcalRecHitCollection *	getCollection (edm::Event &evt, const edm::EDGetTokenT< EcalRecHitCollection > &token)

void	outputValidationInfo (reco::CaloClusterPtrVector &clusterPtrVector)

Private Attributes
std::string	barrelClusterCollection_

std::string	barrelClusterShapeAssociation_

edm::EDGetTokenT< EcalRecHitCollection >	barrelRecHits_

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	caloGeometryToken_

std::string	clustershapecollectionEB_

std::string	clustershapecollectionEE_

std::string	endcapClusterCollection_

std::string	endcapClusterShapeAssociation_

edm::EDGetTokenT< EcalRecHitCollection >	endcapRecHits_

IslandClusterAlgo *	island_p

int	nEvt_

int	nMaxPrintout_

PositionCalc	posCalculator_

ClusterShapeAlgo	shapeAlgo_

IslandClusterAlgo::VerbosityLevel	verbosity

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 29 of file IslandClusterProducer.h.

Constructor & Destructor Documentation

◆ IslandClusterProducer()

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

Definition at line 38 of file IslandClusterProducer.cc.

                                                                       {
   // The verbosity level
   std::string verbosityString = ps.getParameter<std::string>("VerbosityLevel");
   if (verbosityString == "DEBUG")
     verbosity = IslandClusterAlgo::pDEBUG;
   else if (verbosityString == "WARNING")
     verbosity = IslandClusterAlgo::pWARNING;
   else if (verbosityString == "INFO")
     verbosity = IslandClusterAlgo::pINFO;
   else
     verbosity = IslandClusterAlgo::pERROR;
  
   // Parameters to identify the hit collections
   barrelRecHits_ = consumes<EcalRecHitCollection>(ps.getParameter<edm::InputTag>("barrelHits"));
   endcapRecHits_ = consumes<EcalRecHitCollection>(ps.getParameter<edm::InputTag>("endcapHits"));
  
   //EventSetup Token for CaloGeometry
   caloGeometryToken_ = esConsumes<CaloGeometry, CaloGeometryRecord>();
  
   // The names of the produced cluster collections
   barrelClusterCollection_ = ps.getParameter<std::string>("barrelClusterCollection");
   endcapClusterCollection_ = ps.getParameter<std::string>("endcapClusterCollection");
  
   // Island algorithm parameters
   double barrelSeedThreshold = ps.getParameter<double>("IslandBarrelSeedThr");
   double endcapSeedThreshold = ps.getParameter<double>("IslandEndcapSeedThr");
  
   // Parameters for the position calculation:
   edm::ParameterSet posCalcParameters = ps.getParameter<edm::ParameterSet>("posCalcParameters");
   posCalculator_ = PositionCalc(posCalcParameters);
   shapeAlgo_ = ClusterShapeAlgo(posCalcParameters);
  
   clustershapecollectionEB_ = ps.getParameter<std::string>("clustershapecollectionEB");
   clustershapecollectionEE_ = ps.getParameter<std::string>("clustershapecollectionEE");
  
   //AssociationMap
   barrelClusterShapeAssociation_ = ps.getParameter<std::string>("barrelShapeAssociation");
   endcapClusterShapeAssociation_ = ps.getParameter<std::string>("endcapShapeAssociation");
  
   const std::vector<std::string> seedflagnamesEB =
       ps.getParameter<std::vector<std::string>>("SeedRecHitFlagToBeExcludedEB");
   const std::vector<int> seedflagsexclEB = StringToEnumValue<EcalRecHit::Flags>(seedflagnamesEB);
  
   const std::vector<std::string> seedflagnamesEE =
       ps.getParameter<std::vector<std::string>>("SeedRecHitFlagToBeExcludedEE");
   const std::vector<int> seedflagsexclEE = StringToEnumValue<EcalRecHit::Flags>(seedflagnamesEE);
  
   const std::vector<std::string> flagnamesEB = ps.getParameter<std::vector<std::string>>("RecHitFlagToBeExcludedEB");
   const std::vector<int> flagsexclEB = StringToEnumValue<EcalRecHit::Flags>(flagnamesEB);
  
   const std::vector<std::string> flagnamesEE = ps.getParameter<std::vector<std::string>>("RecHitFlagToBeExcludedEE");
   const std::vector<int> flagsexclEE = StringToEnumValue<EcalRecHit::Flags>(flagnamesEE);
  
   // Produces a collection of barrel and a collection of endcap clusters
  
   produces<reco::ClusterShapeCollection>(clustershapecollectionEE_);
   produces<reco::BasicClusterCollection>(endcapClusterCollection_);
   produces<reco::ClusterShapeCollection>(clustershapecollectionEB_);
   produces<reco::BasicClusterCollection>(barrelClusterCollection_);
   produces<reco::BasicClusterShapeAssociationCollection>(barrelClusterShapeAssociation_);
   produces<reco::BasicClusterShapeAssociationCollection>(endcapClusterShapeAssociation_);
  
   island_p = new IslandClusterAlgo(barrelSeedThreshold,
                                    endcapSeedThreshold,
                                    posCalculator_,
                                    seedflagsexclEB,
                                    seedflagsexclEE,
                                    flagsexclEB,
                                    flagsexclEE,
                                    verbosity);
  
   nEvt_ = 0;
 }

References barrelClusterCollection_, barrelClusterShapeAssociation_, barrelRecHits_, caloGeometryToken_, clustershapecollectionEB_, clustershapecollectionEE_, endcapClusterCollection_, endcapClusterShapeAssociation_, endcapRecHits_, edm::ParameterSet::getParameter(), island_p, nEvt_, IslandClusterAlgo::pDEBUG, IslandClusterAlgo::pERROR, IslandClusterAlgo::pINFO, MonitorAlCaEcalPi0_cfi::posCalcParameters, posCalculator_, IslandClusterAlgo::pWARNING, shapeAlgo_, AlCaHLTBitMon_QueryRunRegistry::string, and verbosity.

◆ ~IslandClusterProducer()

IslandClusterProducer::~IslandClusterProducer ( )

override

Definition at line 112 of file IslandClusterProducer.cc.

112 { delete island_p; }

References island_p.

Member Function Documentation

◆ clusterizeECALPart()

void IslandClusterProducer::clusterizeECALPart	(	edm::Event &	evt,
		const edm::EventSetup &	es,
		const edm::EDGetTokenT< EcalRecHitCollection > &	token,
		const std::string &	clusterCollection,
		const std::string &	clusterShapeAssociation,
		const IslandClusterAlgo::EcalPart &	ecalPart
	)

private

Definition at line 159 of file IslandClusterProducer.cc.

                                                                                           {
   // get the hit collection from the event:
   const EcalRecHitCollection* hitCollection_p = getCollection(evt, token);
  
   // get the geometry and topology from the event setup:
   edm::ESHandle<CaloGeometry> geoHandle = es.getHandle(caloGeometryToken_);
  
   const CaloSubdetectorGeometry* geometry_p;
   std::unique_ptr<CaloSubdetectorTopology> topology_p;
  
   std::string clustershapetag;
   if (ecalPart == IslandClusterAlgo::barrel) {
     geometry_p = geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
     topology_p = std::make_unique<EcalBarrelTopology>(*geoHandle);
   } else {
     geometry_p = geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
     topology_p = std::make_unique<EcalEndcapTopology>(*geoHandle);
   }
  
   const CaloSubdetectorGeometry* geometryES_p;
   geometryES_p = geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
  
   // Run the clusterization algorithm:
   reco::BasicClusterCollection clusters;
   clusters = island_p->makeClusters(hitCollection_p, geometry_p, topology_p.get(), geometryES_p, ecalPart);
  
   //Create associated ClusterShape objects.
   std::vector<reco::ClusterShape> ClusVec;
   for (int erg = 0; erg < int(clusters.size()); ++erg) {
     reco::ClusterShape TestShape = shapeAlgo_.Calculate(clusters[erg], hitCollection_p, geometry_p, topology_p.get());
     ClusVec.push_back(TestShape);
   }
  
   //Put clustershapes in event, but retain a Handle on them.
   auto clustersshapes_p = std::make_unique<reco::ClusterShapeCollection>();
   clustersshapes_p->assign(ClusVec.begin(), ClusVec.end());
   edm::OrphanHandle<reco::ClusterShapeCollection> clusHandle;
   if (ecalPart == IslandClusterAlgo::barrel)
     clusHandle = evt.put(std::move(clustersshapes_p), clustershapecollectionEB_);
   else
     clusHandle = evt.put(std::move(clustersshapes_p), clustershapecollectionEE_);
  
   // create a unique_ptr to a BasicClusterCollection, copy the barrel clusters into it and put in the Event:
   auto clusters_p = std::make_unique<reco::BasicClusterCollection>();
   clusters_p->assign(clusters.begin(), clusters.end());
   edm::OrphanHandle<reco::BasicClusterCollection> bccHandle;
   if (ecalPart == IslandClusterAlgo::barrel)
     bccHandle = evt.put(std::move(clusters_p), barrelClusterCollection_);
   else
     bccHandle = evt.put(std::move(clusters_p), endcapClusterCollection_);
  
   // BasicClusterShapeAssociationMap
   auto shapeAssocs_p = std::make_unique<reco::BasicClusterShapeAssociationCollection>(bccHandle, clusHandle);
   for (unsigned int i = 0; i < clusHandle->size(); i++) {
     shapeAssocs_p->insert(edm::Ref<reco::BasicClusterCollection>(bccHandle, i),
                           edm::Ref<reco::ClusterShapeCollection>(clusHandle, i));
   }
   evt.put(std::move(shapeAssocs_p), clusterShapeAssociation);
 }

References IslandClusterAlgo::barrel, barrelClusterCollection_, ClusterShapeAlgo::Calculate(), caloGeometryToken_, bsc_activity_cfg::clusters, clustershapecollectionEB_, clustershapecollectionEE_, DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, endcapClusterCollection_, getCollection(), edm::EventSetup::getHandle(), CaloGeometry::getSubdetectorGeometry(), mps_fire::i, createfilelist::int, island_p, IslandClusterAlgo::makeClusters(), eostools::move(), edm::Event::put(), shapeAlgo_, AlCaHLTBitMon_QueryRunRegistry::string, and unpackBuffers-CaloStage2::token.

Referenced by produce().

◆ counterExceeded()

bool IslandClusterProducer::counterExceeded ( ) const

inlineprivate

Definition at line 61 of file IslandClusterProducer.h.

61 { return ((nEvt_ > nMaxPrintout_) || (nMaxPrintout_ < 0)); }

References nEvt_, and nMaxPrintout_.

◆ fillDescriptions()

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

static

Definition at line 114 of file IslandClusterProducer.cc.

                                                                                        {
   edm::ParameterSetDescription desc;
   desc.add<std::string>("VerbosityLevel", "ERROR");
   desc.add<edm::InputTag>("barrelHits", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
   desc.add<edm::InputTag>("endcapHits", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
   desc.add<std::string>("barrelClusterCollection", "islandBarrelBasicClusters");
   desc.add<std::string>("endcapClusterCollection", "islandEndcapBasicClusters");
   desc.add<double>("IslandBarrelSeedThr", 0.5);
   desc.add<double>("IslandEndcapSeedThr", 0.18);
  
   edm::ParameterSetDescription posCalcParameters;
   posCalcParameters.add<bool>("LogWeighted", true);
   posCalcParameters.add<double>("T0_barl", 7.4);
   posCalcParameters.add<double>("T0_endc", 3.1);
   posCalcParameters.add<double>("T0_endcPresh", 1.2);
   posCalcParameters.add<double>("W0", 4.2);
   posCalcParameters.add<double>("X0", 0.89);
   desc.add<edm::ParameterSetDescription>("posCalcParameters", posCalcParameters);
  
   desc.add<std::string>("clustershapecollectionEE", "islandEndcapShape");
   desc.add<std::string>("clustershapecollectionEB", "islandBarrelShape");
   desc.add<std::string>("barrelShapeAssociation", "islandBarrelShapeAssoc");
   desc.add<std::string>("endcapShapeAssociation", "islandEndcapShapeAssoc");
   desc.add<std::vector<std::string>>("SeedRecHitFlagToBeExcludedEB", {});
   desc.add<std::vector<std::string>>("SeedRecHitFlagToBeExcludedEE", {});
   desc.add<std::vector<std::string>>("RecHitFlagToBeExcludedEB", {});
   desc.add<std::vector<std::string>>("RecHitFlagToBeExcludedEE", {});
   descriptions.add("IslandClusterProducer", desc);
 }

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, MonitorAlCaEcalPi0_cfi::posCalcParameters, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ getCollection()

const EcalRecHitCollection * IslandClusterProducer::getCollection	(	edm::Event &	evt,
		const edm::EDGetTokenT< EcalRecHitCollection > &	token
	)

private

Definition at line 152 of file IslandClusterProducer.cc.

                                                                                                                     {
   edm::Handle<EcalRecHitCollection> rhcHandle;
   evt.getByToken(token, rhcHandle);
   return rhcHandle.product();
 }

References edm::Event::getByToken(), edm::Handle< T >::product(), and unpackBuffers-CaloStage2::token.

Referenced by clusterizeECALPart().

◆ outputValidationInfo()

void IslandClusterProducer::outputValidationInfo ( reco::CaloClusterPtrVector & clusterPtrVector )

private

◆ produce()

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

override

Definition at line 144 of file IslandClusterProducer.cc.

                                                                           {
   clusterizeECALPart(
       evt, es, endcapRecHits_, endcapClusterCollection_, endcapClusterShapeAssociation_, IslandClusterAlgo::endcap);
   clusterizeECALPart(
       evt, es, barrelRecHits_, barrelClusterCollection_, barrelClusterShapeAssociation_, IslandClusterAlgo::barrel);
   nEvt_++;
 }