Inheritance diagram for HGCalBackendLayer2Processor3DClustering:

Public Member Functions
	HGCalBackendLayer2Processor3DClustering (const edm::ParameterSet &conf)

void	run (const edm::Handle< l1t::HGCalClusterBxCollection > &collHandle, std::pair< l1t::HGCalMulticlusterBxCollection, l1t::HGCalClusterBxCollection > &be_output, const edm::EventSetup &es) override

Public Member Functions inherited from HGCalProcessorBaseT< InputCollection, OutputCollection >
virtual void	eventSetup (const edm::EventSetup &es)

	HGCalProcessorBaseT (const edm::ParameterSet &conf)

const std::string &	name () const

virtual void	run (const InputCollection &inputColl, OutputCollection &outColl, const edm::EventSetup &es)=0

void	setGeometry (const HGCalTriggerGeometryBase *const geom)

virtual	~HGCalProcessorBaseT ()

Private Types
enum	MulticlusterType { dRC3d, DBSCANC3d, HistoC3d }

Private Attributes
std::vector< std::unique_ptr< HGCalTriggerClusterInterpreterBase > >	energy_interpreters_

std::unique_ptr< HGCalMulticlusteringImpl >	multiclustering_

MulticlusterType	multiclusteringAlgoType_

std::unique_ptr< HGCalHistoClusteringImpl >	multiclusteringHistoClustering_

std::unique_ptr< HGCalHistoSeedingImpl >	multiclusteringHistoSeeding_

edm::ESHandle< HGCalTriggerGeometryBase >	triggerGeometry_

Additional Inherited Members
Protected Attributes inherited from HGCalProcessorBaseT< InputCollection, OutputCollection >
const HGCalTriggerGeometryBase *	geometry_

Detailed Description

Definition at line 15 of file HGCalBackendLayer2Processor3DClustering.cc.

Member Enumeration Documentation

◆ MulticlusterType

enum HGCalBackendLayer2Processor3DClustering::MulticlusterType

private

Enumerator
dRC3d
DBSCANC3d
HistoC3d

Definition at line 93 of file HGCalBackendLayer2Processor3DClustering.cc.

93 { dRC3d, DBSCANC3d, HistoC3d };

Constructor & Destructor Documentation

◆ HGCalBackendLayer2Processor3DClustering()

HGCalBackendLayer2Processor3DClustering::HGCalBackendLayer2Processor3DClustering ( const edm::ParameterSet & conf )

inline

Definition at line 17 of file HGCalBackendLayer2Processor3DClustering.cc.

                                                                        : HGCalBackendLayer2ProcessorBase(conf) {
     std::string typeMulticluster(conf.getParameterSet("C3d_parameters").getParameter<std::string>("type_multicluster"));
     if (typeMulticluster == "dRC3d") {
       multiclusteringAlgoType_ = dRC3d;
       multiclustering_ = std::make_unique<HGCalMulticlusteringImpl>(conf.getParameterSet("C3d_parameters"));
     } else if (typeMulticluster == "DBSCANC3d") {
       multiclusteringAlgoType_ = DBSCANC3d;
       multiclustering_ = std::make_unique<HGCalMulticlusteringImpl>(conf.getParameterSet("C3d_parameters"));
     } else if (typeMulticluster == "Histo") {
       multiclusteringAlgoType_ = HistoC3d;
       multiclusteringHistoSeeding_ = std::make_unique<HGCalHistoSeedingImpl>(
           conf.getParameterSet("C3d_parameters").getParameterSet("histoMax_C3d_seeding_parameters"));
       multiclusteringHistoClustering_ = std::make_unique<HGCalHistoClusteringImpl>(
           conf.getParameterSet("C3d_parameters").getParameterSet("histoMax_C3d_clustering_parameters"));
     } else {
       throw cms::Exception("HGCTriggerParameterError") << "Unknown Multiclustering type '" << typeMulticluster << "'";
     }
  
     for (const auto& interpretationPset : conf.getParameter<std::vector<edm::ParameterSet>>("energy_interpretations")) {
       std::unique_ptr<HGCalTriggerClusterInterpreterBase> interpreter{
           HGCalTriggerClusterInterpreterFactory::get()->create(interpretationPset.getParameter<std::string>("type"))};
       interpreter->initialize(interpretationPset);
       energy_interpreters_.push_back(std::move(interpreter));
     }
   }

References DBSCANC3d, dRC3d, energy_interpreters_, Exception, get, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), HistoC3d, eostools::move(), multiclustering_, multiclusteringAlgoType_, multiclusteringHistoClustering_, multiclusteringHistoSeeding_, and AlCaHLTBitMon_QueryRunRegistry::string.

Member Function Documentation

◆ run()

void HGCalBackendLayer2Processor3DClustering::run	(	const edm::Handle< l1t::HGCalClusterBxCollection > &	collHandle,
		std::pair< l1t::HGCalMulticlusterBxCollection, l1t::HGCalClusterBxCollection > &	be_output,
		const edm::EventSetup &	es
	)

inlineoverride

Definition at line 43 of file HGCalBackendLayer2Processor3DClustering.cc.

                                              {
     es.get<CaloGeometryRecord>().get("", triggerGeometry_);
     if (multiclustering_)
       multiclustering_->eventSetup(es);
     if (multiclusteringHistoSeeding_)
       multiclusteringHistoSeeding_->eventSetup(es);
     if (multiclusteringHistoClustering_)
       multiclusteringHistoClustering_->eventSetup(es);
  
     auto& collCluster3D = be_output.first;
     auto& rejectedClusters = be_output.second;
  
     /* create a persistent vector of pointers to the trigger-cells */
     std::vector<edm::Ptr<l1t::HGCalCluster>> clustersPtrs;
     for (unsigned i = 0; i < collHandle->size(); ++i) {
       edm::Ptr<l1t::HGCalCluster> ptr(collHandle, i);
       clustersPtrs.push_back(ptr);
     }
  
     /* create a vector of seed positions and their energy*/
     std::vector<std::pair<GlobalPoint, double>> seedPositionsEnergy;
  
     /* call to multiclustering and compute shower shape*/
     switch (multiclusteringAlgoType_) {
       case dRC3d:
         multiclustering_->clusterizeDR(clustersPtrs, collCluster3D, *triggerGeometry_);
         break;
       case DBSCANC3d:
         multiclustering_->clusterizeDBSCAN(clustersPtrs, collCluster3D, *triggerGeometry_);
         break;
       case HistoC3d:
         multiclusteringHistoSeeding_->findHistoSeeds(clustersPtrs, seedPositionsEnergy);
         multiclusteringHistoClustering_->clusterizeHisto(
             clustersPtrs, seedPositionsEnergy, *triggerGeometry_, collCluster3D, rejectedClusters);
         break;
       default:
         // Should not happen, clustering type checked in constructor
         break;
     }
  
     // Call all the energy interpretation modules on the cluster collection
     for (const auto& interpreter : energy_interpreters_) {
       interpreter->eventSetup(es);
       interpreter->interpret(collCluster3D);
     }
   }