Inheritance diagram for HGCalBackendLayer1Processor2DClustering:

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

void	run (const edm::Handle< l1t::HGCalTriggerCellBxCollection > &collHandle, l1t::HGCalClusterBxCollection &collCluster2D, 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	ClusterType { dRC2d, NNC2d, dRNNC2d, dummyC2d }

Private Attributes
std::unique_ptr< HGCalClusteringImpl >	clustering_

ClusterType	clusteringAlgorithmType_

std::unique_ptr< HGCalClusteringDummyImpl >	clusteringDummy_

edm::ESHandle< HGCalTriggerGeometryBase >	triggerGeometry_

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

Detailed Description

Definition at line 10 of file HGCalBackendLayer1Processor2DClustering.cc.

Member Enumeration Documentation

◆ ClusterType

enum HGCalBackendLayer1Processor2DClustering::ClusterType

private

Enumerator
dRC2d
NNC2d
dRNNC2d
dummyC2d

Definition at line 74 of file HGCalBackendLayer1Processor2DClustering.cc.

74 { dRC2d, NNC2d, dRNNC2d, dummyC2d };

Constructor & Destructor Documentation

◆ HGCalBackendLayer1Processor2DClustering()

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

inline

Definition at line 12 of file HGCalBackendLayer1Processor2DClustering.cc.

                                                                        : HGCalBackendLayer1ProcessorBase(conf) {
     std::string typeCluster(conf.getParameterSet("C2d_parameters").getParameter<std::string>("clusterType"));
     if (typeCluster == "dRC2d") {
       clusteringAlgorithmType_ = dRC2d;
       clustering_ = std::make_unique<HGCalClusteringImpl>(conf.getParameterSet("C2d_parameters"));
     } else if (typeCluster == "NNC2d") {
       clusteringAlgorithmType_ = NNC2d;
       clustering_ = std::make_unique<HGCalClusteringImpl>(conf.getParameterSet("C2d_parameters"));
     } else if (typeCluster == "dRNNC2d") {
       clusteringAlgorithmType_ = dRNNC2d;
       clustering_ = std::make_unique<HGCalClusteringImpl>(conf.getParameterSet("C2d_parameters"));
     } else if (typeCluster == "dummyC2d") {
       clusteringAlgorithmType_ = dummyC2d;
       clusteringDummy_ = std::make_unique<HGCalClusteringDummyImpl>(conf.getParameterSet("C2d_parameters"));
     } else {
       throw cms::Exception("HGCTriggerParameterError") << "Unknown clustering type '" << typeCluster;
     }
   }

References clustering_, clusteringAlgorithmType_, clusteringDummy_, dRC2d, dRNNC2d, dummyC2d, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), NNC2d, and AlCaHLTBitMon_QueryRunRegistry::string.

Member Function Documentation

◆ run()

void HGCalBackendLayer1Processor2DClustering::run	(	const edm::Handle< l1t::HGCalTriggerCellBxCollection > &	collHandle,
		l1t::HGCalClusterBxCollection &	collCluster2D,
		const edm::EventSetup &	es
	)

inlineoverride

Definition at line 31 of file HGCalBackendLayer1Processor2DClustering.cc.

                                              {
     es.get<CaloGeometryRecord>().get("", triggerGeometry_);
     if (clustering_)
       clustering_->eventSetup(es);
     if (clusteringDummy_)
       clusteringDummy_->eventSetup(es);
  
     /* create a persistent vector of pointers to the trigger-cells */
     std::vector<edm::Ptr<l1t::HGCalTriggerCell>> triggerCellsPtrs;
     for (unsigned i = 0; i < collHandle->size(); ++i) {
       edm::Ptr<l1t::HGCalTriggerCell> ptr(collHandle, i);
       triggerCellsPtrs.push_back(ptr);
     }
  
     std::sort(triggerCellsPtrs.begin(),
               triggerCellsPtrs.end(),
               [](const edm::Ptr<l1t::HGCalTriggerCell>& a, const edm::Ptr<l1t::HGCalTriggerCell>& b) -> bool {
                 return a->mipPt() > b->mipPt();
               });
  
     /* call to C2d clustering */
     switch (clusteringAlgorithmType_) {
       case dRC2d:
         clustering_->clusterizeDR(triggerCellsPtrs, collCluster2D);
         break;
       case NNC2d:
         clustering_->clusterizeNN(triggerCellsPtrs, collCluster2D, *triggerGeometry_);
         break;
       case dRNNC2d:
         clustering_->clusterizeDRNN(triggerCellsPtrs, collCluster2D, *triggerGeometry_);
         break;
       case dummyC2d:
         clusteringDummy_->clusterizeDummy(triggerCellsPtrs, collCluster2D);
         break;
       default:
         // Should not happen, clustering type checked in constructor
         break;
     }
   }