Inheritance diagram for HGCalLayerClusterProducer:

Public Member Functions
	HGCalLayerClusterProducer (const edm::ParameterSet &)
	Constructor with parameter settings - which can be changed in hgcalLayerCluster_cff.py. Constructor will set all variables by input param ps. algoID variables will be set accordingly to the detector type. More...

void	produce (edm::Event &, const edm::EventSetup &) override
	Method run the algoritm to get clusters. More...

	~HGCalLayerClusterProducer () 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)
	Method fill description which will be used in pyhton file. More...

Private Member Functions
math::XYZPoint	calculatePosition (std::unordered_map< uint32_t, const HGCRecHit *> &hitmap, const std::vector< std::pair< DetId, float >> &hitsAndFractions)
	Counts position for all points in the cluster. More...

std::pair< float, float >	calculateTime (std::unordered_map< uint32_t, const HGCRecHit *> &hitmap, const std::vector< std::pair< DetId, float >> &hitsAndFractions, size_t sizeCluster)
	Counts time for all points in the cluster. More...

void	setAlgoId ()
	Sets algoId accordingly to the detector type. More...

Private Attributes
std::unique_ptr< HGCalClusteringAlgoBase >	algo_

reco::CaloCluster::AlgoId	algoId_

const bool	calculatePositionInAlgo_

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	caloGeomToken_

std::string	detector_

edm::EDGetTokenT< HGCRecHitCollection >	hits_token_

unsigned int	hitsTime_

double	positionDeltaRho2_

hgcal::RecHitTools	rhtools_

std::vector< double >	thresholdW0_

std::string	timeClname_

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 41 of file HGCalLayerClusterProducer.cc.

Constructor & Destructor Documentation

◆ HGCalLayerClusterProducer()

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

Constructor with parameter settings - which can be changed in hgcalLayerCluster_cff.py. Constructor will set all variables by input param ps. algoID variables will be set accordingly to the detector type.

Parameters

[in] ps parametr set to set variables

Definition at line 115 of file HGCalLayerClusterProducer.cc.

References algo_, algoId_, detector_, get, edm::ParameterSet::getParameter(), hits_token_, positionDeltaRho2_, setAlgoId(), AlCaHLTBitMon_QueryRunRegistry::string, thresholdW0_, and timeClname_.

     : algoId_(reco::CaloCluster::undefined),
       detector_(ps.getParameter<std::string>("detector")),  // one of EE, FH, BH, HFNose
       timeClname_(ps.getParameter<std::string>("timeClname")),
       hitsTime_(ps.getParameter<unsigned int>("nHitsTime")),
       caloGeomToken_(consumesCollector().esConsumes<CaloGeometry, CaloGeometryRecord>()),
       calculatePositionInAlgo_(ps.getParameter<bool>("calculatePositionInAlgo")) {
 #if DEBUG_CLUSTERS_ALPAKA
   moduleLabel_ = ps.getParameter<std::string>("@module_label");
 #endif
   setAlgoId();  //sets algo id according to detector type
   hits_token_ = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("recHits"));
 
   auto pluginPSet = ps.getParameter<edm::ParameterSet>("plugin");
   if (detector_ == "HFNose") {
     algo_ = HGCalLayerClusterAlgoFactory::get()->create("HFNoseCLUE", pluginPSet);
     algo_->setAlgoId(algoId_, true);
   } else {
     algo_ = HGCalLayerClusterAlgoFactory::get()->create(pluginPSet.getParameter<std::string>("type"), pluginPSet);
     algo_->setAlgoId(algoId_);
   }
   thresholdW0_ = pluginPSet.getParameter<std::vector<double>>("thresholdW0");
   positionDeltaRho2_ = pluginPSet.getParameter<double>("positionDeltaRho2");
 
   produces<std::vector<float>>("InitialLayerClustersMask");
   produces<std::vector<reco::BasicCluster>>();
   //time for layer clusters
   produces<edm::ValueMap<std::pair<float, float>>>(timeClname_);
 }

◆ ~HGCalLayerClusterProducer()

HGCalLayerClusterProducer::~HGCalLayerClusterProducer ( )

inlineoverride

Definition at line 51 of file HGCalLayerClusterProducer.cc.

51 {}

Member Function Documentation

◆ calculatePosition()

math::XYZPoint HGCalLayerClusterProducer::calculatePosition	(	std::unordered_map< uint32_t, const HGCRecHit *> &	hitmap,
		const std::vector< std::pair< DetId, float >> &	hitsAndFractions
	)

private

Counts position for all points in the cluster.

Parameters

[in]	hitmap	hitmap to find correct RecHit
[in]	hitsAndFraction	all hits in the cluster

Returns: counted position

Definition at line 160 of file HGCalLayerClusterProducer.cc.

References d1, CaloRecHit::detid(), CaloRecHit::energy(), hgcal::RecHitTools::getPosition(), hgcal::RecHitTools::getSiThickIndex(), CrabHelper::log, WZElectronSkims53X_cff::max, position, positionDeltaRho2_, rhtools_, thresholdW0_, x, and y.

Referenced by produce().

                                                               {
   float total_weight = 0.f;
   float maxEnergyValue = 0.f;
   DetId maxEnergyIndex;
   float x = 0.f;
   float y = 0.f;
 
   for (auto const& hit : hitsAndFractions) {
     //time is computed wrt  0-25ns + offset and set to -1 if no time
     const HGCRecHit* rechit = hitmap[hit.first];
     total_weight += rechit->energy();
     if (rechit->energy() > maxEnergyValue) {
       maxEnergyValue = rechit->energy();
       maxEnergyIndex = rechit->detid();
     }
   }
   float total_weight_log = 0.f;
   auto thick = rhtools_.getSiThickIndex(maxEnergyIndex);
   const GlobalPoint positionMaxEnergy(rhtools_.getPosition(maxEnergyIndex));
   for (auto const& hit : hitsAndFractions) {
     //time is computed wrt  0-25ns + offset and set to -1 if no time
     const HGCRecHit* rechit = hitmap[hit.first];
 
     const GlobalPoint position(rhtools_.getPosition(rechit->detid()));
 
     if (thick != -1) {  //silicon
       //for silicon only just use 1+6 cells = 1.3cm for all thicknesses
       const float d1 = position.x() - positionMaxEnergy.x();
       const float d2 = position.y() - positionMaxEnergy.y();
       if ((d1 * d1 + d2 * d2) > positionDeltaRho2_)
         continue;
 
       float Wi = std::max(thresholdW0_[thick] + std::log(rechit->energy() / total_weight), 0.);
       x += position.x() * Wi;
       y += position.y() * Wi;
       total_weight_log += Wi;
     } else {  //scintillator
       x += position.x() * rechit->energy();
       y += position.y() * rechit->energy();
     }
   }
   if (thick != -1) {
     total_weight = total_weight_log;
   }
   if (total_weight != 0.) {
     float inv_tot_weight = 1.f / total_weight;
     return math::XYZPoint(x * inv_tot_weight, y * inv_tot_weight, positionMaxEnergy.z());
   } else {
     return {positionMaxEnergy.x(), positionMaxEnergy.y(), positionMaxEnergy.z()};
   }
 }

◆ calculateTime()

std::pair< float, float > HGCalLayerClusterProducer::calculateTime	(	std::unordered_map< uint32_t, const HGCRecHit *> &	hitmap,
		const std::vector< std::pair< DetId, float >> &	hitsAndFractions,
		size_t	sizeCluster
	)

private

Counts time for all points in the cluster.

Parameters

[in]	hitmap	hitmap to find correct RecHit only for silicon (not for BH-HSci)
[in]	hitsAndFraction	all hits in the cluster

Returns: counted time

Definition at line 214 of file HGCalLayerClusterProducer.cc.

References f, hgcalsimclustertime::ComputeClusterTime::fixSizeHighestDensity(), hitsTime_, CaloRecHit::time(), and HGCRecHit::timeError().

Referenced by produce().

                         {
   std::pair<float, float> timeCl(-99., -1.);
 
   if (sizeCluster >= hitsTime_) {
     std::vector<float> timeClhits;
     std::vector<float> timeErrorClhits;
 
     for (auto const& hit : hitsAndFractions) {
       //time is computed wrt  0-25ns + offset and set to -1 if no time
       const HGCRecHit* rechit = hitmap[hit.first];
 
       float rhTimeE = rechit->timeError();
       //check on timeError to exclude scintillator
       if (rhTimeE < 0.f)
         continue;
       timeClhits.push_back(rechit->time());
       timeErrorClhits.push_back(1.f / (rhTimeE * rhTimeE));
     }
     hgcalsimclustertime::ComputeClusterTime timeEstimator;
     timeCl = timeEstimator.fixSizeHighestDensity(timeClhits, timeErrorClhits, hitsTime_);
   }
   return timeCl;
 }

◆ fillDescriptions()

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

static

Method fill description which will be used in pyhton file.

Parameters

[out] description to be fill

Definition at line 145 of file HGCalLayerClusterProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addNode(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                            {
   // hgcalLayerClusters
   edm::ParameterSetDescription desc;
   edm::ParameterSetDescription pluginDesc;
   pluginDesc.addNode(edm::PluginDescription<HGCalLayerClusterAlgoFactory>("type", "SiCLUE", true));
 
   desc.add<edm::ParameterSetDescription>("plugin", pluginDesc);
   desc.add<std::string>("detector", "EE")->setComment("options EE, FH, BH,  HFNose; other value defaults to EE");
   desc.add<edm::InputTag>("recHits", edm::InputTag("HGCalRecHit", "HGCEERecHits"));
   desc.add<std::string>("timeClname", "timeLayerCluster");
   desc.add<unsigned int>("nHitsTime", 3);
   desc.add<bool>("calculatePositionInAlgo", true);
   descriptions.add("hgcalLayerClusters", desc);
 }

◆ produce()

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

override

Method run the algoritm to get clusters.

Parameters

[in,out]	evt	from get info and put result
[in]	es	to get event setup info

Definition at line 240 of file HGCalLayerClusterProducer.cc.

References algo_, calculatePosition(), calculatePositionInAlgo_, calculateTime(), caloGeomToken_, bsc_activity_cfg::clusters, detector_, hgcalUtils::DumpClusters::dumpInfos(), edm::EventID::event(), edm::Event::eventAuxiliary(), f, trigObjTnPSource_cfi::filler, relativeConstraints::geom, edm::Event::getByToken(), edm::EventSetup::getHandle(), hfClusterShapes_cfi::hits, hits_token_, reco::CaloCluster::hitsAndFractions(), mps_fire::i, edm::EventAuxiliary::id(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::EventAuxiliary::luminosityBlock(), eostools::move(), edm::Event::put(), rhtools_, edm::EventAuxiliary::run(), convertSQLiteXML::runNumber, hgcal::RecHitTools::setGeometry(), reco::CaloCluster::setPosition(), reco::CaloCluster::size(), and timeClname_.

                                                                               {
   edm::Handle<HGCRecHitCollection> hits;
 
   std::unique_ptr<std::vector<reco::BasicCluster>> clusters(new std::vector<reco::BasicCluster>);
 
   edm::ESHandle<CaloGeometry> geom = es.getHandle(caloGeomToken_);
   rhtools_.setGeometry(*geom);
   algo_->getEventSetup(es, rhtools_);
 
   //make a map detid-rechit
   // NB for the moment just host EE and FH hits
   // timing in digi for BH not implemented for now
   std::unordered_map<uint32_t, const HGCRecHit*> hitmap;
 
   evt.getByToken(hits_token_, hits);
   algo_->populate(*hits);
   for (auto const& it : *hits) {
     hitmap[it.detid().rawId()] = &(it);
   }
 
   algo_->makeClusters();
   *clusters = algo_->getClusters(false);
 
   std::vector<std::pair<float, float>> times;
   times.reserve(clusters->size());
 
   for (unsigned i = 0; i < clusters->size(); ++i) {
     reco::CaloCluster& sCl = (*clusters)[i];
     if (!calculatePositionInAlgo_) {
       sCl.setPosition(calculatePosition(hitmap, sCl.hitsAndFractions()));
     }
     if (detector_ != "BH") {
       times.push_back(calculateTime(hitmap, sCl.hitsAndFractions(), sCl.size()));
     } else {
       times.push_back(std::pair<float, float>(-99.f, -1.f));
     }
   }
 
 #if DEBUG_CLUSTERS_ALPAKA
   hgcalUtils::DumpClusters dumper;
   auto runNumber = evt.eventAuxiliary().run();
   auto lumiNumber = evt.eventAuxiliary().luminosityBlock();
   auto evtNumber = evt.eventAuxiliary().id().event();
 
   dumper.dumpInfos(*clusters, moduleLabel_, runNumber, lumiNumber, evtNumber, true);
 #endif
 
   auto clusterHandle = evt.put(std::move(clusters));
 
   if (detector_ == "HFNose") {
     std::unique_ptr<std::vector<float>> layerClustersMask(new std::vector<float>);
     layerClustersMask->resize(clusterHandle->size(), 1.0);
     evt.put(std::move(layerClustersMask), "InitialLayerClustersMask");
   }
 
   auto timeCl = std::make_unique<edm::ValueMap<std::pair<float, float>>>();
   edm::ValueMap<std::pair<float, float>>::Filler filler(*timeCl);
   filler.insert(clusterHandle, times.begin(), times.end());
   filler.fill();
   evt.put(std::move(timeCl), timeClname_);
 
   algo_->reset();
 }

◆ setAlgoId()

void HGCalLayerClusterProducer::setAlgoId ( )

private

Sets algoId accordingly to the detector type.

Definition at line 304 of file HGCalLayerClusterProducer.cc.

References algoId_, detector_, reco::CaloCluster::hfnose, reco::CaloCluster::hgcal_em, reco::CaloCluster::hgcal_had, and reco::CaloCluster::hgcal_scintillator.

Referenced by HGCalLayerClusterProducer().

                                           {
   if (detector_ == "EE") {
     algoId_ = reco::CaloCluster::hgcal_em;
   } else if (detector_ == "FH") {
     algoId_ = reco::CaloCluster::hgcal_had;
   } else if (detector_ == "BH") {
     algoId_ = reco::CaloCluster::hgcal_scintillator;
   } else if (detector_ == "HFNose") {
     algoId_ = reco::CaloCluster::hfnose;
   }
 }