Inheritance diagram for GEMPadDigiClusterProducer:

Public Types
typedef std::map< GEMDetId, GEMPadDigiClusters >	GEMPadDigiClusterContainer

typedef std::vector< GEMPadDigiCluster >	GEMPadDigiClusters

typedef std::map< GEMDetId, std::vector< std::vector< std::pair< GEMDetId, GEMPadDigiClusters > > > >	GEMPadDigiClusterSortedContainer

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

Public Member Functions
void	beginRun (const edm::Run &, const edm::EventSetup &) override

	GEMPadDigiClusterProducer (const edm::ParameterSet &ps)

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

	~GEMPadDigiClusterProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	buildClusters (const GEMPadDigiCollection &pads, GEMPadDigiClusterContainer &out_clusters) const

void	selectClusters (const GEMPadDigiClusterSortedContainer &in, GEMPadDigiClusterCollection &out) const

void	sortClusters (const GEMPadDigiClusterContainer &in_clusters, GEMPadDigiClusterSortedContainer &out_clusters) const

Private Attributes
const GEMGeometry *	geometry_

unsigned int	maxClusterSize_

unsigned int	maxClustersOHGE11_

unsigned int	maxClustersOHGE21_

unsigned int	nOHGE11_

unsigned int	nOHGE21_

edm::EDGetTokenT< GEMPadDigiCollection >	pad_token_
	Name of input digi Collection. More...

edm::InputTag	pads_

Detailed Description

Produces GEM pad clusters from at most 8 adjacent GEM pads. Clusters are used downstream in the CSC local trigger to build GEM-CSC triggers and in the muon trigger to build EMTF tracks

Based on documentation provided by the GEM firmware architects

Author: Sven Dildick (TAMU)

Definition at line 38 of file GEMPadDigiClusterProducer.cc.

Member Typedef Documentation

typedef std::map<GEMDetId, GEMPadDigiClusters> GEMPadDigiClusterProducer::GEMPadDigiClusterContainer

Definition at line 42 of file GEMPadDigiClusterProducer.cc.

typedef std::vector<GEMPadDigiCluster> GEMPadDigiClusterProducer::GEMPadDigiClusters

Definition at line 41 of file GEMPadDigiClusterProducer.cc.

typedef std::map<GEMDetId, std::vector<std::vector<std::pair<GEMDetId, GEMPadDigiClusters> > > > GEMPadDigiClusterProducer::GEMPadDigiClusterSortedContainer

Definition at line 46 of file GEMPadDigiClusterProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 115 of file GEMPadDigiClusterProducer.cc.

References edm::ParameterSet::getParameter(), maxClusterSize_, maxClustersOHGE11_, maxClustersOHGE21_, nOHGE11_, nOHGE21_, pad_token_, and pads_.

                                                                               : geometry_(nullptr) {
   pads_ = ps.getParameter<edm::InputTag>("InputCollection");
   maxClustersOHGE11_ = ps.getParameter<unsigned int>("maxClustersOHGE11");
   maxClustersOHGE21_ = ps.getParameter<unsigned int>("maxClustersOHGE21");
   nOHGE11_ = ps.getParameter<unsigned int>("nOHGE11");
   nOHGE21_ = ps.getParameter<unsigned int>("nOHGE21");
   maxClusterSize_ = ps.getParameter<unsigned int>("maxClusterSize");
 
   pad_token_ = consumes<GEMPadDigiCollection>(pads_);
 
   produces<GEMPadDigiClusterCollection>();
   consumes<GEMPadDigiCollection>(pads_);
 }

GEMPadDigiClusterProducer::~GEMPadDigiClusterProducer ( )

override

Definition at line 129 of file GEMPadDigiClusterProducer.cc.

129 {}

Member Function Documentation

void GEMPadDigiClusterProducer::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	eventSetup
	)

override

Definition at line 143 of file GEMPadDigiClusterProducer.cc.

References geometry_, and edm::EventSetup::get().

                                                                                            {
   edm::ESHandle<GEMGeometry> hGeom;
   eventSetup.get<MuonGeometryRecord>().get(hGeom);
   geometry_ = &*hGeom;
 }

void GEMPadDigiClusterProducer::buildClusters	(	const GEMPadDigiCollection &	pads,
		GEMPadDigiClusterContainer &	out_clusters
	)		const

private

Light Cluster Packing Algorithm **

Based on: https://github.com/cms-gem-daq-project/OptoHybridv3/raw/master/doc/OH_modules.docx (Andrew Peck, Thomas Lenzi, Evaldas Juska)

In the current version of the algorithm, cluster finding is segmented into two separate halves of the GE1/1 chambers. Thus, each one of the trigger fibers can transmit clusters only from the half of the chamber that it corresponds to. For GE2/1, there are four separate quarts of the GE2/1 chamber.

This has the downside of being unable to transmit more than 4 clusters when they occur within that side of the chamber, so there will be a slightly higher rate of cluster overflow. For GE2/1 each OH can transmit up to 5 clusters.

The benefit, however, is in terms of (1) latency and (2) resource usage.

The burden of finding clusters on of the chamber is significantly less, and allows the cluster packer to operate in a simple, pipelined architecture which returns up to 4 (or 5) clusters per half-chamber per bunch crossing.

This faster architecture allows the mechanism to operate with only a single copy of the cluster finding priority encoder and cluster truncator (instead of two multiplexed copies), so the total resource usage of these stages is approximately half.

Further, a second step of cluster merging that is required in the full algorithm is avoided, which reduces latency by an additional bunch crossing and significantly reduces resource usage as well.

The sorting of the clusters favors lower eta partitions and lower pad numbers

Definition at line 171 of file GEMPadDigiClusterProducer.cc.

References GetRecoTauVFromDQM_MC_cff::cl, ztail::d, GEMGeometry::etaPartitions(), geometry_, and maxClusterSize_.

Referenced by produce().

                                                                                                 {
   // clear the container
   proto_clusters.clear();
 
   // construct clusters
   for (const auto& part : geometry_->etaPartitions()) {
     GEMPadDigiClusters all_pad_clusters;
 
     auto pads = det_pads.get(part->id());
     std::vector<uint16_t> cl;
     int startBX = 99;
 
     for (auto d = pads.first; d != pads.second; ++d) {
       if (cl.empty()) {
         cl.push_back((*d).pad());
       } else {
         if ((*d).bx() == startBX and            // same bunch crossing
             (*d).pad() == cl.back() + 1         // pad difference is 1
             and cl.size() < maxClusterSize_) {  // max 8 in cluster
           cl.push_back((*d).pad());
         } else {
           // put the current cluster in the proto collection
           GEMPadDigiCluster pad_cluster(cl, startBX);
 
           all_pad_clusters.emplace_back(pad_cluster);
 
           // start a new cluster
           cl.clear();
           cl.push_back((*d).pad());
         }
       }
       startBX = (*d).bx();
     }
 
     // put the last cluster in the proto collection
     if (pads.first != pads.second) {
       GEMPadDigiCluster pad_cluster(cl, startBX);
       all_pad_clusters.emplace_back(pad_cluster);
     }
     proto_clusters.emplace(part->id(), all_pad_clusters);
 
   }  // end of partition loop
 }

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

static

Definition at line 131 of file GEMPadDigiClusterProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and HLT_2018_cff::InputTag.

                                                                                            {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("InputCollection", edm::InputTag("simMuonGEMPadDigis"));
   desc.add<unsigned int>("maxClustersOHGE11", 4);
   desc.add<unsigned int>("maxClustersOHGE21", 5);
   desc.add<unsigned int>("nOHGE11", 2);
   desc.add<unsigned int>("nOHGE21", 4);
   desc.add<unsigned int>("maxClusterSize", 8);
 
   descriptions.add("simMuonGEMPadDigiClustersDef", desc);
 }

void GEMPadDigiClusterProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	eventSetup
	)

override

Definition at line 149 of file GEMPadDigiClusterProducer.cc.

References buildClusters(), edm::Event::getByToken(), eostools::move(), pad_token_, edm::Handle< T >::product(), edm::Event::put(), selectClusters(), and sortClusters().

                                                                                     {
   edm::Handle<GEMPadDigiCollection> hpads;
   e.getByToken(pad_token_, hpads);
 
   // Create empty output
   std::unique_ptr<GEMPadDigiClusterCollection> pClusters(new GEMPadDigiClusterCollection());
 
   // build the proto clusters (per partition)
   GEMPadDigiClusterContainer proto_clusters;
   buildClusters(*(hpads.product()), proto_clusters);
 
   // // sort clusters per chamber, per OH, per partition number and per pad number
   GEMPadDigiClusterSortedContainer sorted_clusters;
   sortClusters(proto_clusters, sorted_clusters);
 
   // select the clusters from sorted clusters
   selectClusters(sorted_clusters, *pClusters);
 
   // store them in the event
   e.put(std::move(pClusters));
 }

void GEMPadDigiClusterProducer::selectClusters	(	const GEMPadDigiClusterSortedContainer &	in,
		GEMPadDigiClusterCollection &	out
	)		const

private

Definition at line 252 of file GEMPadDigiClusterProducer.cc.

References GEMGeometry::chambers(), bsc_activity_cfg::clusters, DEFINE_FWK_MODULE, geometry_, maxClustersOHGE11_, maxClustersOHGE21_, heavyionUCCDQM_cfi::nClusters, and relativeConstraints::station.

Referenced by produce().

                                                                                                 {
   // loop over chambers
   for (const auto& ch : geometry_->chambers()) {
     const int station = ch->id().station();
     const bool isGE11 = (station == 1);
     const unsigned maxClustersOH = isGE11 ? maxClustersOHGE11_ : maxClustersOHGE21_;
 
     // loop over the optohybrids
     for (const auto& optohybrid : sorted_clusters.at(ch->id())) {
       // at most maxClustersOH per OH!
       unsigned nClusters = 0;
 
       // loop over the eta partitions for this OH
       for (const auto& etapart : optohybrid) {
         const auto& detid(etapart.first);
         const auto& clusters(etapart.second);
 
         // pick the clusters with lowest pad number
         for (const auto& clus : clusters) {
           if (nClusters < maxClustersOH) {
             out_clusters.insertDigi(detid, clus);
             nClusters++;
           }
         }  // end of cluster loop
       }    // end of eta partition loop
     }      // end of OH loop
   }        // end of chamber loop
 }

void GEMPadDigiClusterProducer::sortClusters	(	const GEMPadDigiClusterContainer &	in_clusters,
		GEMPadDigiClusterSortedContainer &	out_clusters
	)		const

private

Definition at line 216 of file GEMPadDigiClusterProducer.cc.

References GEMGeometry::chambers(), geometry_, nOHGE11_, nOHGE21_, and relativeConstraints::station.

Referenced by produce().

                                                                                                       {
   // The sorting of the clusters favors lower eta partitions and lower pad numbers
   // By default the eta partitions are sorted by Id
 
   sorted_clusters.clear();
 
   for (const auto& ch : geometry_->chambers()) {
     // check the station number
     const int station = ch->id().station();
     const bool isGE11 = (station == 1);
     const unsigned nOH = isGE11 ? nOHGE11_ : nOHGE21_;
     const unsigned nPartOH = ch->nEtaPartitions() / nOH;
 
     std::vector<std::vector<std::pair<GEMDetId, GEMPadDigiClusters> > > temp_clustersCH;
 
     for (unsigned int iOH = 0; iOH < nOH; iOH++) {
       // all clusters for a set of eta partitions
       std::vector<std::pair<GEMDetId, GEMPadDigiClusters> > temp_clustersOH;
 
       // loop over the 4 or 2 eta partitions for this optohybrid
       for (unsigned iPart = 1; iPart <= nPartOH; iPart++) {
         // get the clusters for this eta partition
         const GEMDetId& partId = ch->etaPartition(iPart + iOH * nPartOH)->id();
         if (proto_clusters.find(partId) != proto_clusters.end()) {
           temp_clustersOH.emplace_back(partId, proto_clusters.at(partId));
         }
       }  // end of eta partition loop
 
       temp_clustersCH.emplace_back(temp_clustersOH);
     }  // end of OH loop
 
     sorted_clusters.emplace(ch->id(), temp_clustersCH);
   }  // end of chamber loop
 }