Inheritance diagram for HGCalLayerClustersFromSoAProducer:

Public Member Functions
	HGCalLayerClustersFromSoAProducer (edm::ParameterSet const &config)

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

	~HGCalLayerClustersFromSoAProducer () override=default

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 Attributes
reco::CaloCluster::AlgoId	algoId_

std::string	detector_

edm::EDGetTokenT< HGCalSoARecHitsHostCollection > const	getTokenSoACells_

edm::EDGetTokenT< HGCalSoAClustersHostCollection > const	getTokenSoAClusters_

edm::EDGetTokenT< HGCalSoARecHitsExtraHostCollection > const	getTokenSoARecHitsExtra_

unsigned int	hitsTime_

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 28 of file HGCalLayerClustersFromSoAProducer.cc.

Constructor & Destructor Documentation

◆ HGCalLayerClustersFromSoAProducer()

HGCalLayerClustersFromSoAProducer::HGCalLayerClustersFromSoAProducer ( edm::ParameterSet const & config )

inline

Definition at line 30 of file HGCalLayerClustersFromSoAProducer.cc.

References algoId_, detector_, reco::CaloCluster::hfnose, reco::CaloCluster::hgcal_em, reco::CaloCluster::hgcal_had, AlCaHLTBitMon_QueryRunRegistry::string, and timeClname_.

       : getTokenSoAClusters_(consumes(config.getParameter<edm::InputTag>("src"))),
         getTokenSoACells_(consumes(config.getParameter<edm::InputTag>("hgcalRecHitsSoA"))),
         getTokenSoARecHitsExtra_(consumes(config.getParameter<edm::InputTag>("hgcalRecHitsLayerClustersSoA"))),
         detector_(config.getParameter<std::string>("detector")),
         hitsTime_(config.getParameter<unsigned int>("nHitsTime")),
         timeClname_(config.getParameter<std::string>("timeClname")) {
 #if DEBUG_CLUSTERS_ALPAKA
     moduleLabel_ = config.getParameter<std::string>("@module_label");
 #endif
     if (detector_ == "HFNose") {
       algoId_ = reco::CaloCluster::hfnose;
     } else if (detector_ == "EE") {
       algoId_ = reco::CaloCluster::hgcal_em;
     } else {  //for FH or BH
       algoId_ = reco::CaloCluster::hgcal_had;
     }
 
     produces<std::vector<float>>("InitialLayerClustersMask");
     produces<std::vector<reco::BasicCluster>>();
     produces<edm::ValueMap<std::pair<float, float>>>(timeClname_);
   }

◆ ~HGCalLayerClustersFromSoAProducer()

HGCalLayerClustersFromSoAProducer::~HGCalLayerClustersFromSoAProducer ( )

overridedefault

Member Function Documentation

◆ fillDescriptions()

static void HGCalLayerClustersFromSoAProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inlinestatic

Definition at line 153 of file HGCalLayerClustersFromSoAProducer.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                            {
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("src", edm::InputTag("hltHgcalSoALayerClustersProducer"));
     desc.add<edm::InputTag>("hgcalRecHitsLayerClustersSoA", edm::InputTag("hltHgcalSoARecHitsLayerClustersProducer"));
     desc.add<edm::InputTag>("hgcalRecHitsSoA", edm::InputTag("hltHgcalSoARecHitsProducer"));
     desc.add<unsigned int>("nHitsTime", 3);
     desc.add<std::string>("timeClname", "timeLayerCluster");
     desc.ifValue(edm::ParameterDescription<std::string>(
                      "detector", "EE", true, edm::Comment("the HGCAL component used to create clusters.")),
                  edm::allowedValues<std::string>("EE", "FH"));
     descriptions.addWithDefaultLabel(desc);
   }

◆ produce()

void HGCalLayerClustersFromSoAProducer::produce	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup
	)

inlineoverride

Definition at line 55 of file HGCalLayerClustersFromSoAProducer.cc.

References algoId_, cms::cuda::assert(), bsc_activity_cfg::clusters, reco::CaloID::DET_HGCAL_ENDCAP, detector_, ALCARECOPPSCalTrackBasedSel_cff::detid, hgcalUtils::DumpClusters::dumpInfos(), hgcalUtils::DumpClustersSoA::dumpInfos(), hgcalUtils::DumpCellsSoA::dumpInfos(), f, trigObjTnPSource_cfi::filler, hgcalsimclustertime::ComputeClusterTime::fixSizeHighestDensity(), getTokenSoACells_, getTokenSoAClusters_, getTokenSoARecHitsExtra_, hitsTime_, mps_fire::i, iEvent, eostools::move(), convertSQLiteXML::runNumber, hcalRecHitTable_cff::time, and timeClname_.

                                                                        {
     auto const& deviceData = iEvent.get(getTokenSoAClusters_);
 
     auto const& deviceSoARecHitsExtra = iEvent.get(getTokenSoARecHitsExtra_);
     auto const soaRecHitsExtra_v = deviceSoARecHitsExtra.view();
 
     auto const& deviceSoACells = iEvent.get(getTokenSoACells_);
     auto const soaCells_v = deviceSoACells.view();
 
     auto const deviceView = deviceData.view();
 
     std::unique_ptr<std::vector<reco::BasicCluster>> clusters(new std::vector<reco::BasicCluster>);
     clusters->reserve(deviceData->metadata().size());
 
     // Create a vector of <clusters> locations, where each location holds a
     // vector of <nCells> floats. These vectors are used to compute the time for
     // each cluster.
     std::vector<std::vector<float>> times(deviceData->metadata().size());
     std::vector<std::vector<float>> timeErrors(deviceData->metadata().size());
 
     for (int i = 0; i < deviceData->metadata().size(); ++i) {
       std::vector<std::pair<DetId, float>> thisCluster;
       thisCluster.reserve(deviceView.cells(i));
       clusters->emplace_back(deviceView.energy(i),
                              math::XYZPoint(deviceView.x(i), deviceView.y(i), deviceView.z(i)),
                              reco::CaloID::DET_HGCAL_ENDCAP,
                              std::move(thisCluster),
                              algoId_);
       clusters->back().setSeed(deviceView.seed(i));
       times[i].reserve(deviceView.cells(i));
       timeErrors[i].reserve(deviceView.cells(i));
     }
 
     // Populate hits and fractions required to compute the cluster's time.
     // This procedure is complex and involves two SoAs: the original RecHits
     // SoA and the clustering algorithm's output SoA. Both SoAs have the same
     // cardinality, and crucially, the output SoA includes the cluster index.
     for (int32_t i = 0; i < soaRecHitsExtra_v.metadata().size(); ++i) {
       if (soaRecHitsExtra_v[i].clusterIndex() == -1) {
         continue;
       }
       assert(soaRecHitsExtra_v[i].clusterIndex() < (int)clusters->size());
       (*clusters)[soaRecHitsExtra_v[i].clusterIndex()].addHitAndFraction(soaCells_v[i].detid(), 1.f);
       if (soaCells_v[i].timeError() < 0.f) {
         continue;
       }
       times[soaRecHitsExtra_v[i].clusterIndex()].push_back(soaCells_v[i].time());
       timeErrors[soaRecHitsExtra_v[i].clusterIndex()].push_back(
           1.f / (soaCells_v[i].timeError() * soaCells_v[i].timeError()));
     }
 
     // Finally, compute and assign the time to each cluster.
     std::vector<std::pair<float, float>> cluster_times;
     cluster_times.reserve(clusters->size());
     hgcalsimclustertime::ComputeClusterTime timeEstimator;
     for (unsigned i = 0; i < clusters->size(); ++i) {
       if (detector_ != "BH") {
         cluster_times.push_back(timeEstimator.fixSizeHighestDensity(times[i], timeErrors[i], hitsTime_));
       } else {
         cluster_times.push_back(std::pair<float, float>(-99.f, -1.f));
       }
     }
 
 #if DEBUG_CLUSTERS_ALPAKA
     auto runNumber = iEvent.eventAuxiliary().run();
     auto lumiNumber = iEvent.eventAuxiliary().luminosityBlock();
     auto evtNumber = iEvent.eventAuxiliary().id().event();
 
     hgcalUtils::DumpCellsSoA dumperCellsSoA;
     dumperCellsSoA.dumpInfos(deviceSoACells, moduleLabel_, runNumber, lumiNumber, evtNumber);
 
     hgcalUtils::DumpClusters dumper;
     dumper.dumpInfos(*clusters, moduleLabel_, runNumber, lumiNumber, evtNumber, true);
 
     hgcalUtils::DumpClustersSoA dumperSoA;
     dumperSoA.dumpInfos(deviceSoARecHitsExtra, moduleLabel_, runNumber, lumiNumber, evtNumber);
 #endif
 
     auto clusterHandle = iEvent.put(std::move(clusters));
 
     auto timeCl = std::make_unique<edm::ValueMap<std::pair<float, float>>>();
     edm::ValueMap<std::pair<float, float>>::Filler filler(*timeCl);
     filler.insert(clusterHandle, cluster_times.begin(), cluster_times.end());
     filler.fill();
     iEvent.put(std::move(timeCl), timeClname_);
 
     // The layerClusterMask for the HGCAL detector is created at a later
     // stage, when the layer clusters from the different components of HGCAL
     // are merged together into a unique collection. For the case of HFNose,
     // since there is no further merging step needed, we create the
     // layerClustersMask directly here.
     if (detector_ == "HFNose") {
       std::unique_ptr<std::vector<float>> layerClustersMask(new std::vector<float>);
       layerClustersMask->resize(clusterHandle->size(), 1.0);
       iEvent.put(std::move(layerClustersMask), "InitialLayerClustersMask");
     }
   }