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

	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 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<>
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 37 of file IslandClusterProducer.cc.

Constructor & Destructor Documentation

◆ IslandClusterProducer()

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

Definition at line 86 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 160 of file IslandClusterProducer.cc.

160 { 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 207 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 69 of file IslandClusterProducer.cc.

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

References nEvt_, and nMaxPrintout_.

◆ fillDescriptions()

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

static

Definition at line 162 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 200 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 192 of file IslandClusterProducer.cc.

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