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<>
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

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

	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 Member Functions
void	buildClusters (const GEMPadDigiCollection &pads, GEMPadDigiClusterContainer &out_clusters) const

template<class T >
void	checkValid (const T &cluster, const GEMDetId &id) const

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

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

Private Attributes
edm::ESGetToken< GEMGeometry, MuonGeometryRecord >	geom_token_

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_

bool	sendOverflowClusters_

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 39 of file GEMPadDigiClusterProducer.cc.

Member Typedef Documentation

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

Definition at line 43 of file GEMPadDigiClusterProducer.cc.

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

Definition at line 42 of file GEMPadDigiClusterProducer.cc.

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

Definition at line 47 of file GEMPadDigiClusterProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 120 of file GEMPadDigiClusterProducer.cc.

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

                                                                               : 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");
   sendOverflowClusters_ = ps.getParameter<bool>("sendOverflowClusters");
 
   if (sendOverflowClusters_) {
     maxClustersOHGE11_ *= 2;
     maxClustersOHGE21_ *= 2;
   }
 
   pad_token_ = consumes<GEMPadDigiCollection>(pads_);
   geom_token_ = esConsumes<GEMGeometry, MuonGeometryRecord, edm::Transition::BeginRun>();
 
   produces<GEMPadDigiClusterCollection>();
   consumes<GEMPadDigiCollection>(pads_);
 }

GEMPadDigiClusterProducer::~GEMPadDigiClusterProducer ( )

override

Definition at line 141 of file GEMPadDigiClusterProducer.cc.

141 {}

Member Function Documentation

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

override

Definition at line 156 of file GEMPadDigiClusterProducer.cc.

References geom_token_, geometry_, and edm::EventSetup::getHandle().

                                                                                            {
   edm::ESHandle<GEMGeometry> hGeom = eventSetup.getHandle(geom_token_);
   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 183 of file GEMPadDigiClusterProducer.cc.

References checkValid(), haddnano::cl, ztail::d, GEMGeometry::etaPartitions(), geometry_, maxClusterSize_, and nPart().

Referenced by produce().

                                                                                                 {
   // clear the container
   proto_clusters.clear();
 
   // construct clusters
   for (const auto& part : geometry_->etaPartitions()) {
     // clusters are not build for ME0
     // -> ignore hits from station 0
     if (part->isME0())
       continue;
 
     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) {
       // check if the input pad is valid
       checkValid(*d, part->id());
 
       // number of eta partitions
       unsigned nPart = d->nPartitions();
 
       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, part->subsystem(), nPart);
 
           // check if the output cluster is valid
           checkValid(pad_cluster, part->id());
 
           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) {
       // number of eta partitions
       unsigned nPart = (pads.first)->nPartitions();
 
       GEMPadDigiCluster pad_cluster(cl, startBX, part->subsystem(), nPart);
 
       // check if the output cluster is valid
       checkValid(pad_cluster, part->id());
 
       all_pad_clusters.emplace_back(pad_cluster);
     }
     proto_clusters.emplace(part->id(), all_pad_clusters);
 
   }  // end of partition loop
 }

template<class T >

void GEMPadDigiClusterProducer::checkValid	(	const T &	cluster,
		const GEMDetId &	id
	)		const

private

Definition at line 315 of file GEMPadDigiClusterProducer.cc.

References gpuClustering::id.

Referenced by buildClusters(), and selectClusters().

                                                                                 {
   // check if the pad/cluster is valid
   // in principle, invalid pads/clusters can appear in the CMS raw data
   if (!tp.isValid()) {
     edm::LogWarning("GEMPadDigiClusterProducer") << "Invalid " << tp << " in " << id;
   }
 }

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

static

Definition at line 143 of file GEMPadDigiClusterProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, and HLT_FULL_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);
   desc.add<bool>("sendOverflowClusters", false);
 
   descriptions.add("simMuonGEMPadDigiClustersDef", desc);
 }

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

override

Definition at line 161 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 283 of file GEMPadDigiClusterProducer.cc.

References GEMGeometry::chambers(), checkValid(), HLT_FULL_cff::clusters, geometry_, maxClustersOHGE11_, and maxClustersOHGE21_.

Referenced by produce().

                                                                                                 {
   // loop over chambers
   for (const auto& ch : geometry_->chambers()) {
     const unsigned maxClustersOH = ch->id().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) {
             // check if the output cluster is valid
             checkValid(clus, detid);
 
             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 249 of file GEMPadDigiClusterProducer.cc.

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

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 unsigned nOH = ch->id().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
 }