Inheritance diagram for HGCalLayerClusterProducer:

Public Member Functions
	HGCalLayerClusterProducer (const edm::ParameterSet &)

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

	~HGCalLayerClusterProducer () 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 Attributes
std::unique_ptr< HGCalClusteringAlgoBase >	algo

reco::CaloCluster::AlgoId	algoId

std::string	detector

bool	doSharing

edm::EDGetTokenT< HGCRecHitCollection >	hits_bh_token

edm::EDGetTokenT< HGCRecHitCollection >	hits_ee_token

edm::EDGetTokenT< HGCRecHitCollection >	hits_fh_token

edm::EDGetTokenT< HGCRecHitCollection >	hits_hfnose_token

unsigned int	nHitsTime

std::string	timeClname

double	timeOffset

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

Constructor & Destructor Documentation

◆ HGCalLayerClusterProducer()

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

Definition at line 62 of file HGCalLayerClusterProducer.cc.

     : algoId(reco::CaloCluster::undefined),
       doSharing(ps.getParameter<bool>("doSharing")),
       detector(ps.getParameter<std::string>("detector")),  // one of EE, FH, BH or "all"
       timeClname(ps.getParameter<std::string>("timeClname")),
       timeOffset(ps.getParameter<double>("timeOffset")),
       nHitsTime(ps.getParameter<unsigned int>("nHitsTime")) {
   if (detector == "HFNose") {
     hits_hfnose_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HFNoseInput"));
     algoId = reco::CaloCluster::hfnose;
   } else if (detector == "all") {
     hits_ee_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCEEInput"));
     hits_fh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCFHInput"));
     hits_bh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCBHInput"));
     algoId = reco::CaloCluster::hgcal_mixed;
   } else if (detector == "EE") {
     hits_ee_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCEEInput"));
     algoId = reco::CaloCluster::hgcal_em;
   } else if (detector == "FH") {
     hits_fh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCFHInput"));
     algoId = reco::CaloCluster::hgcal_had;
   } else {
     hits_bh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCBHInput"));
     algoId = reco::CaloCluster::hgcal_had;
   }
  
   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);
   }
  
   produces<std::vector<float>>("InitialLayerClustersMask");
   produces<std::vector<reco::BasicCluster>>();
   produces<std::vector<reco::BasicCluster>>("sharing");
   //density
   produces<Density>();
   //time for layer clusters
   produces<edm::ValueMap<std::pair<float, float>>>(timeClname);
 }

References algo, algoId, detector, get, edm::ParameterSet::getParameter(), reco::CaloCluster::hfnose, reco::CaloCluster::hgcal_em, reco::CaloCluster::hgcal_had, reco::CaloCluster::hgcal_mixed, hits_bh_token, hits_ee_token, hits_fh_token, hits_hfnose_token, AlCaHLTBitMon_QueryRunRegistry::string, timeClname, and undefined.

◆ ~HGCalLayerClusterProducer()

HGCalLayerClusterProducer::~HGCalLayerClusterProducer ( )

inlineoverride

Definition at line 38 of file HGCalLayerClusterProducer.cc.

38 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 106 of file HGCalLayerClusterProducer.cc.

                                                                                            {
   // hgcalLayerClusters
   edm::ParameterSetDescription desc;
   edm::ParameterSetDescription pluginDesc;
   pluginDesc.addNode(edm::PluginDescription<HGCalLayerClusterAlgoFactory>("type", "CLUE", true));
  
   desc.add<edm::ParameterSetDescription>("plugin", pluginDesc);
   desc.add<std::string>("detector", "all")
       ->setComment("all (does not include HFNose); other options: EE, FH, HFNose; other value defaults to BH");
   desc.add<bool>("doSharing", false);
   desc.add<edm::InputTag>("HFNoseInput", edm::InputTag("HGCalRecHit", "HGCHFNoseRecHits"));
   desc.add<edm::InputTag>("HGCEEInput", edm::InputTag("HGCalRecHit", "HGCEERecHits"));
   desc.add<edm::InputTag>("HGCFHInput", edm::InputTag("HGCalRecHit", "HGCHEFRecHits"));
   desc.add<edm::InputTag>("HGCBHInput", edm::InputTag("HGCalRecHit", "HGCHEBRecHits"));
   desc.add<std::string>("timeClname", "timeLayerCluster");
   desc.add<double>("timeOffset", 0.0);
   desc.add<unsigned int>("nHitsTime", 3);
   descriptions.add("hgcalLayerClusters", desc);
 }

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

◆ produce()

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

override

Definition at line 126 of file HGCalLayerClusterProducer.cc.

                                                                               {
   edm::Handle<HGCRecHitCollection> hfnose_hits;
   edm::Handle<HGCRecHitCollection> ee_hits;
   edm::Handle<HGCRecHitCollection> fh_hits;
   edm::Handle<HGCRecHitCollection> bh_hits;
  
   std::unique_ptr<std::vector<reco::BasicCluster>> clusters(new std::vector<reco::BasicCluster>),
       clusters_sharing(new std::vector<reco::BasicCluster>);
   auto density = std::make_unique<Density>();
  
   algo->getEventSetup(es);
  
   //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;
  
   switch (algoId) {
     case reco::CaloCluster::hfnose:
       evt.getByToken(hits_hfnose_token, hfnose_hits);
       algo->populate(*hfnose_hits);
       for (auto const& it : *hfnose_hits)
         hitmap[it.detid().rawId()] = &(it);
       break;
     case reco::CaloCluster::hgcal_em:
       evt.getByToken(hits_ee_token, ee_hits);
       algo->populate(*ee_hits);
       for (auto const& it : *ee_hits)
         hitmap[it.detid().rawId()] = &(it);
       break;
     case reco::CaloCluster::hgcal_had:
       evt.getByToken(hits_fh_token, fh_hits);
       evt.getByToken(hits_bh_token, bh_hits);
       if (fh_hits.isValid()) {
         algo->populate(*fh_hits);
         for (auto const& it : *fh_hits)
           hitmap[it.detid().rawId()] = &(it);
       } else if (bh_hits.isValid()) {
         algo->populate(*bh_hits);
       }
       break;
     case reco::CaloCluster::hgcal_mixed:
       evt.getByToken(hits_ee_token, ee_hits);
       algo->populate(*ee_hits);
       for (auto const& it : *ee_hits) {
         hitmap[it.detid().rawId()] = &(it);
       }
       evt.getByToken(hits_fh_token, fh_hits);
       algo->populate(*fh_hits);
       for (auto const& it : *fh_hits) {
         hitmap[it.detid().rawId()] = &(it);
       }
       evt.getByToken(hits_bh_token, bh_hits);
       algo->populate(*bh_hits);
       break;
     default:
       break;
   }
   algo->makeClusters();
   *clusters = algo->getClusters(false);
   if (doSharing)
     *clusters_sharing = algo->getClusters(true);
  
   auto clusterHandle = evt.put(std::move(clusters));
   auto clusterHandleSharing = evt.put(std::move(clusters_sharing), "sharing");
  
   //Keep the density
   *density = algo->getDensity();
   evt.put(std::move(density));
  
   edm::PtrVector<reco::BasicCluster> clusterPtrs, clusterPtrsSharing;
  
   std::vector<std::pair<float, float>> times;
   times.reserve(clusterHandle->size());
  
   for (unsigned i = 0; i < clusterHandle->size(); ++i) {
     edm::Ptr<reco::BasicCluster> ptr(clusterHandle, i);
     clusterPtrs.push_back(ptr);
  
     std::pair<float, float> timeCl(-99., -1.);
  
     const reco::CaloCluster& sCl = (*clusterHandle)[i];
     if (sCl.size() >= nHitsTime) {
       std::vector<float> timeClhits;
       std::vector<float> timeErrorClhits;
  
       for (auto const& hit : sCl.hitsAndFractions()) {
         auto finder = hitmap.find(hit.first);
         if (finder == hitmap.end())
           continue;
  
         //time is computed wrt  0-25ns + offset and set to -1 if no time
         const HGCRecHit* rechit = finder->second;
         float rhTimeE = rechit->timeError();
         //check on timeError to exclude scintillator
         if (rhTimeE < 0.)
           continue;
         timeClhits.push_back(rechit->time() - timeOffset);
         timeErrorClhits.push_back(1. / (rhTimeE * rhTimeE));
       }
       hgcalsimclustertime::ComputeClusterTime timeEstimator;
       timeCl = timeEstimator.fixSizeHighestDensity(timeClhits, timeErrorClhits, nHitsTime);
     }
     times.push_back(timeCl);
   }
   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);
  
   if (doSharing) {
     for (unsigned i = 0; i < clusterHandleSharing->size(); ++i) {
       edm::Ptr<reco::BasicCluster> ptr(clusterHandleSharing, i);
       clusterPtrsSharing.push_back(ptr);
     }
   }
   algo->reset();
 }