#include <CSCDigiMatcher.h>

Public Member Functions
std::set< unsigned int >	chamberIdsComparator (int csc_type=MuonHitHelper::CSC_ALL) const

std::set< unsigned int >	chamberIdsStrip (int csc_type=MuonHitHelper::CSC_ALL) const

std::set< unsigned int >	chamberIdsWire (int csc_type=MuonHitHelper::CSC_ALL) const

const CSCComparatorDigiContainer &	comparatorDigisInChamber (unsigned int) const

const CSCComparatorDigiContainer &	comparatorDigisInDetId (unsigned int) const

std::set< int >	comparatorsInChamber (unsigned int, int max_gap_to_fill=0) const

std::set< int >	comparatorsInDetId (unsigned int) const

	CSCDigiMatcher (edm::ParameterSet const &iPS, edm::ConsumesCollector &&iC)

std::set< unsigned int >	detIdsComparator (int csc_type=MuonHitHelper::CSC_ALL) const

std::set< unsigned int >	detIdsStrip (int csc_type=MuonHitHelper::CSC_ALL) const

std::set< unsigned int >	detIdsWire (int csc_type=MuonHitHelper::CSC_ALL) const

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

void	match (const SimTrack &t, const SimVertex &v)
	do the matching More...

std::shared_ptr< CSCSimHitMatcher >	muonSimHitMatcher () const

int	nCoincidenceComparatorChambers (int min_n_layers=4) const

int	nCoincidenceStripChambers (int min_n_layers=4) const

int	nCoincidenceWireChambers (int min_n_layers=4) const

int	nLayersWithComparatorInChamber (unsigned int) const

int	nLayersWithStripInChamber (unsigned int) const

int	nLayersWithWireInChamber (unsigned int) const

const CSCStripDigiContainer &	stripDigisInChamber (unsigned int) const

const CSCStripDigiContainer &	stripDigisInDetId (unsigned int) const

std::set< int >	stripsInChamber (unsigned int, int max_gap_to_fill=0) const

std::set< int >	stripsInDetId (unsigned int) const

const CSCWireDigiContainer &	wireDigisInChamber (unsigned int) const

const CSCWireDigiContainer &	wireDigisInDetId (unsigned int) const

std::set< int >	wiregroupsInChamber (unsigned int, int max_gap_to_fill=0) const

std::set< int >	wiregroupsInDetId (unsigned int) const

	~CSCDigiMatcher ()

Private Member Functions
void	clear ()

void	matchComparatorsToSimTrack (const CSCComparatorDigiCollection &comparators)

void	matchStripsToSimTrack (const CSCStripDigiCollection &strips)

void	matchWiresToSimTrack (const CSCWireDigiCollection &wires)

template<class T >
std::set< unsigned int >	selectDetIds (const T &digis, int csc_type) const

Private Attributes
std::map< unsigned int, CSCComparatorDigiContainer >	chamber_to_comparators_

std::map< unsigned int, CSCStripDigiContainer >	chamber_to_strips_

std::map< unsigned int, CSCWireDigiContainer >	chamber_to_wires_

edm::EDGetTokenT < CSCComparatorDigiCollection >	comparatorDigiInput_

edm::Handle < CSCComparatorDigiCollection >	comparatorDigisH_

std::map< unsigned int, CSCComparatorDigiContainer >	detid_to_comparators_

std::map< unsigned int, CSCStripDigiContainer >	detid_to_strips_

std::map< unsigned int, CSCWireDigiContainer >	detid_to_wires_

int	matchDeltaComparator_

int	matchDeltaStrip_

int	matchDeltaWG_

int	maxBXComparator_

int	maxBXStrip_

int	maxBXWire_

int	minBXComparator_

int	minBXStrip_

int	minBXWire_

std::shared_ptr< CSCSimHitMatcher >	muonSimHitMatcher_

CSCComparatorDigiContainer	no_comparators_

CSCStripDigiContainer	no_strips_

CSCWireDigiContainer	no_wires_

edm::EDGetTokenT < CSCStripDigiCollection >	stripDigiInput_

edm::Handle < CSCStripDigiCollection >	stripDigisH_

int	verboseComparator_

int	verboseStrip_

int	verboseWG_

edm::EDGetTokenT < CSCWireDigiCollection >	wireDigiInput_

edm::Handle < CSCWireDigiCollection >	wireDigisH_

Detailed Description

Description: Matching of Digis to SimTrack in CSC

Author: Sven Dildick (TAMU), Tao Huang (TAMU)

Definition at line 25 of file CSCDigiMatcher.h.

Constructor & Destructor Documentation

CSCDigiMatcher::CSCDigiMatcher	(	edm::ParameterSet const &	iPS,
		edm::ConsumesCollector &&	iC
	)

Definition at line 5 of file CSCDigiMatcher.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), and eostools::move().

                                                                                      {
   const auto& wireDigi = pset.getParameterSet("cscWireDigi");
   verboseWG_ = wireDigi.getParameter<int>("verbose");
   minBXWire_ = wireDigi.getParameter<int>("minBX");
   maxBXWire_ = wireDigi.getParameter<int>("maxBX");
   matchDeltaWG_ = wireDigi.getParameter<int>("matchDeltaWG");
 
   const auto& comparatorDigi = pset.getParameterSet("cscComparatorDigi");
   verboseComparator_ = comparatorDigi.getParameter<int>("verbose");
   minBXComparator_ = comparatorDigi.getParameter<int>("minBX");
   maxBXComparator_ = comparatorDigi.getParameter<int>("maxBX");
   matchDeltaComparator_ = comparatorDigi.getParameter<int>("matchDeltaStrip");
 
   const auto& stripDigi = pset.getParameterSet("cscStripDigi");
   verboseStrip_ = stripDigi.getParameter<int>("verbose");
   minBXStrip_ = stripDigi.getParameter<int>("minBX");
   maxBXStrip_ = stripDigi.getParameter<int>("maxBX");
   matchDeltaStrip_ = stripDigi.getParameter<int>("matchDeltaStrip");
 
   // make a new simhits matcher
   muonSimHitMatcher_.reset(new CSCSimHitMatcher(pset, std::move(iC)));
 
   comparatorDigiInput_ =
       iC.consumes<CSCComparatorDigiCollection>(comparatorDigi.getParameter<edm::InputTag>("inputTag"));
   stripDigiInput_ = iC.consumes<CSCStripDigiCollection>(stripDigi.getParameter<edm::InputTag>("inputTag"));
   wireDigiInput_ = iC.consumes<CSCWireDigiCollection>(wireDigi.getParameter<edm::InputTag>("inputTag"));
 }

CSCDigiMatcher::~CSCDigiMatcher ( )

inline

Definition at line 31 of file CSCDigiMatcher.h.

31 {}

Member Function Documentation

std::set< unsigned int > CSCDigiMatcher::chamberIdsComparator ( int csc_type = MuonHitHelper::CSC_ALL ) const

Definition at line 179 of file CSCDigiMatcher.cc.

                                                                             {
   return selectDetIds(chamber_to_comparators_, csc_type);
 }

std::set< unsigned int > CSCDigiMatcher::chamberIdsStrip ( int csc_type = MuonHitHelper::CSC_ALL ) const

Definition at line 183 of file CSCDigiMatcher.cc.

                                                                        {
   return selectDetIds(chamber_to_strips_, csc_type);
 }

std::set< unsigned int > CSCDigiMatcher::chamberIdsWire ( int csc_type = MuonHitHelper::CSC_ALL ) const

Definition at line 187 of file CSCDigiMatcher.cc.

                                                                       {
   return selectDetIds(chamber_to_wires_, csc_type);
 }

void CSCDigiMatcher::clear ( void )

private

Definition at line 379 of file CSCDigiMatcher.cc.

                            {
   detid_to_comparators_.clear();
   chamber_to_comparators_.clear();
 
   detid_to_strips_.clear();
   chamber_to_strips_.clear();
 
   detid_to_wires_.clear();
   chamber_to_wires_.clear();
 }

const CSCComparatorDigiContainer & CSCDigiMatcher::comparatorDigisInChamber ( unsigned int detid ) const

Definition at line 197 of file CSCDigiMatcher.cc.

                                                                                                    {
   if (chamber_to_comparators_.find(detid) == chamber_to_comparators_.end())
     return no_comparators_;
   return chamber_to_comparators_.at(detid);
 }

const CSCComparatorDigiContainer & CSCDigiMatcher::comparatorDigisInDetId ( unsigned int detid ) const

Definition at line 191 of file CSCDigiMatcher.cc.

                                                                                                  {
   if (detid_to_comparators_.find(detid) == detid_to_comparators_.end())
     return no_comparators_;
   return detid_to_comparators_.at(detid);
 }

std::set< int > CSCDigiMatcher::comparatorsInChamber	(	unsigned int	detid,
		int	max_gap_to_fill = `0`
	)		const

Definition at line 320 of file CSCDigiMatcher.cc.

References ztail::d, mps_fire::result, and alignCSCRings::s.

                                                                                               {
   set<int> result;
   const auto& digis = comparatorDigisInChamber(detid);
   for (const auto& d : digis) {
     result.insert(d.getStrip());
   }
   if (max_gap_to_fill > 0) {
     int prev = -111;
     for (const auto& s : result) {
       if (s - prev > 1 && s - prev - 1 <= max_gap_to_fill) {
         for (int fill_s = prev + 1; fill_s < s; ++fill_s)
           result.insert(fill_s);
       }
       prev = s;
     }
   }
 
   return result;
 }

std::set< int > CSCDigiMatcher::comparatorsInDetId ( unsigned int detid ) const

Definition at line 293 of file CSCDigiMatcher.cc.

References ztail::d, and mps_fire::result.

                                                                        {
   set<int> result;
   const auto& digis = comparatorDigisInDetId(detid);
   for (const auto& d : digis) {
     result.insert(d.getHalfStrip());
   }
   return result;
 }

std::set< unsigned int > CSCDigiMatcher::detIdsComparator ( int csc_type = MuonHitHelper::CSC_ALL ) const

Definition at line 167 of file CSCDigiMatcher.cc.

                                                                         {
   return selectDetIds(detid_to_comparators_, csc_type);
 }

std::set< unsigned int > CSCDigiMatcher::detIdsStrip ( int csc_type = MuonHitHelper::CSC_ALL ) const

Definition at line 171 of file CSCDigiMatcher.cc.

                                                                    {
   return selectDetIds(detid_to_strips_, csc_type);
 }

std::set< unsigned int > CSCDigiMatcher::detIdsWire ( int csc_type = MuonHitHelper::CSC_ALL ) const

Definition at line 175 of file CSCDigiMatcher.cc.

                                                                   {
   return selectDetIds(detid_to_wires_, csc_type);
 }

void CSCDigiMatcher::init	(	const edm::Event &	e,
		const edm::EventSetup &	eventSetup
	)

Definition at line 33 of file CSCDigiMatcher.cc.

References edm::Event::getByToken().

                                                                              {
   muonSimHitMatcher_->init(iEvent, iSetup);
 
   iEvent.getByToken(comparatorDigiInput_, comparatorDigisH_);
   iEvent.getByToken(stripDigiInput_, stripDigisH_);
   iEvent.getByToken(wireDigiInput_, wireDigisH_);
 }

void CSCDigiMatcher::match	(	const SimTrack &	t,
		const SimVertex &	v
	)

do the matching

Definition at line 42 of file CSCDigiMatcher.cc.

References clear(), DigiDM_cff::strips, and DigiDM_cff::wires.

                                                                 {
   // match simhits first
   muonSimHitMatcher_->match(t, v);
 
   // get the digi collections
   const CSCComparatorDigiCollection& comparators = *comparatorDigisH_.product();
   const CSCStripDigiCollection& strips = *stripDigisH_.product();
   const CSCWireDigiCollection& wires = *wireDigisH_.product();
 
   clear();
 
   // now match the digis
   matchComparatorsToSimTrack(comparators);
   matchStripsToSimTrack(strips);
   matchWiresToSimTrack(wires);
 }

void CSCDigiMatcher::matchComparatorsToSimTrack ( const CSCComparatorDigiCollection & comparators )

private

Definition at line 59 of file CSCDigiMatcher.cc.

References c, CSCDetId::chamberId(), filterCSVwithJSON::copy, gather_cfg::cout, gpuClustering::id, and DetId::rawId().

                                                                                               {
   const auto& det_ids = muonSimHitMatcher_->detIds(0);
   for (const auto& id : det_ids) {
     CSCDetId layer_id(id);
 
     const auto& hit_comparators = muonSimHitMatcher_->hitStripsInDetId(id, matchDeltaStrip_);
     if (verboseComparator_) {
       cout << "hit_comparators_fat, CSCid " << layer_id << " ";
       copy(hit_comparators.begin(), hit_comparators.end(), ostream_iterator<int>(cout, " "));
       cout << endl;
     }
 
     const auto& comp_digis_in_det = comparators.get(layer_id);
     for (auto c = comp_digis_in_det.first; c != comp_digis_in_det.second; ++c) {
       if (verboseComparator_)
         edm::LogInfo("CSCDigiMatcher") << "sdigi " << layer_id << " (comparator, comparator, Tbin ) " << *c;
 
       // check that the first BX for this digi wasn't too early or too late
       if (c->getTimeBin() < minBXComparator_ || c->getTimeBin() > maxBXComparator_)
         continue;
 
       int comparator = c->getStrip();  // comparators are counted from 1
       // check that it matches a comparator that was hit by SimHits from our track
       if (hit_comparators.find(comparator) == hit_comparators.end())
         continue;
 
       if (verboseComparator_)
         edm::LogInfo("CSCDigiMatcher") << "Matched comparator " << *c;
       detid_to_comparators_[id].push_back(*c);
       chamber_to_comparators_[layer_id.chamberId().rawId()].push_back(*c);
     }
   }
 }

void CSCDigiMatcher::matchStripsToSimTrack ( const CSCStripDigiCollection & strips )

private

Definition at line 93 of file CSCDigiMatcher.cc.

References c, CSCDetId::chamberId(), filterCSVwithJSON::copy, gather_cfg::cout, gpuClustering::id, or, sistrip::SpyUtilities::range(), DetId::rawId(), relativeConstraints::ring, relativeConstraints::station, and digitizers_cfi::strip.

                                                                                {
   for (auto detUnitIt = strips.begin(); detUnitIt != strips.end(); ++detUnitIt) {
     const CSCDetId& id = (*detUnitIt).first;
     const auto& range = (*detUnitIt).second;
     for (auto digiIt = range.first; digiIt != range.second; ++digiIt) {
       if (id.station() == 1 and (id.ring() == 1 or id.ring() == 4))
         if (verboseStrip_)
           edm::LogInfo("CSCDigiMatcher") << "CSCid " << id << " Strip digi (strip, strip, Tbin ) " << (*digiIt);
     }
   }
 
   const auto& det_ids = muonSimHitMatcher_->detIds(0);
   for (const auto& id : det_ids) {
     CSCDetId layer_id(id);
 
     const auto& hit_strips = muonSimHitMatcher_->hitStripsInDetId(id, matchDeltaStrip_);
     if (verboseStrip_) {
       cout << "hit_strips_fat, CSCid " << layer_id << " ";
       copy(hit_strips.begin(), hit_strips.end(), ostream_iterator<int>(cout, " "));
       cout << endl;
     }
 
     const auto& strip_digis_in_det = strips.get(layer_id);
     for (auto c = strip_digis_in_det.first; c != strip_digis_in_det.second; ++c) {
       if (verboseStrip_)
         edm::LogInfo("CSCDigiMatcher") << "sdigi " << layer_id << " (strip, Tbin ) " << *c;
 
       int strip = c->getStrip();  // strips are counted from 1
       // check that it matches a strip that was hit by SimHits from our track
       if (hit_strips.find(strip) == hit_strips.end())
         continue;
 
       if (verboseStrip_)
         edm::LogInfo("CSCDigiMatcher") << "Matched strip " << *c;
       detid_to_strips_[id].push_back(*c);
       chamber_to_strips_[layer_id.chamberId().rawId()].push_back(*c);
     }
   }
 }

void CSCDigiMatcher::matchWiresToSimTrack ( const CSCWireDigiCollection & wires )

private

Definition at line 133 of file CSCDigiMatcher.cc.

References CSCDetId::chamberId(), filterCSVwithJSON::copy, gather_cfg::cout, gpuClustering::id, DetId::rawId(), and w.

                                                                             {
   const auto& det_ids = muonSimHitMatcher_->detIds(0);
   for (const auto& id : det_ids) {
     CSCDetId layer_id(id);
 
     const auto& hit_wires = muonSimHitMatcher_->hitWiregroupsInDetId(id, matchDeltaWG_);
     if (verboseWG_) {
       cout << "hit_wires ";
       copy(hit_wires.begin(), hit_wires.end(), ostream_iterator<int>(cout, " "));
       cout << endl;
     }
 
     const auto& wire_digis_in_det = wires.get(layer_id);
     for (auto w = wire_digis_in_det.first; w != wire_digis_in_det.second; ++w) {
       if (verboseStrip_)
         edm::LogInfo("CSCDigiMatcher") << "wdigi " << layer_id << " (wire, Tbin ) " << *w;
 
       // check that the first BX for this digi wasn't too early or too late
       if (w->getTimeBin() < minBXWire_ || w->getTimeBin() > maxBXWire_)
         continue;
 
       int wg = w->getWireGroup();  // wiregroups are counted from 1
       // check that it matches a strip that was hit by SimHits from our track
       if (hit_wires.find(wg) == hit_wires.end())
         continue;
 
       if (verboseStrip_)
         edm::LogInfo("CSCDigiMatcher") << "Matched wire digi " << *w << endl;
       detid_to_wires_[id].push_back(*w);
       chamber_to_wires_[layer_id.chamberId().rawId()].push_back(*w);
     }
   }
 }

std::shared_ptr<CSCSimHitMatcher> CSCDigiMatcher::muonSimHitMatcher ( ) const

inline

Definition at line 83 of file CSCDigiMatcher.h.

References muonSimHitMatcher_.

83 { return muonSimHitMatcher_; }

CSCDigiMatcher::muonSimHitMatcher_

std::shared_ptr< CSCSimHitMatcher > muonSimHitMatcher_

Definition: CSCDigiMatcher.h:104

int CSCDigiMatcher::nCoincidenceComparatorChambers ( int min_n_layers = 4 ) const

Definition at line 263 of file CSCDigiMatcher.cc.

References mps_fire::result.

                                                                          {
   int result = 0;
   const auto& chamber_ids = chamberIdsComparator();
   for (const auto& id : chamber_ids) {
     if (nLayersWithComparatorInChamber(id) >= min_n_layers)
       result += 1;
   }
   return result;
 }

int CSCDigiMatcher::nCoincidenceStripChambers ( int min_n_layers = 4 ) const

Definition at line 273 of file CSCDigiMatcher.cc.

References mps_fire::result.

                                                                     {
   int result = 0;
   const auto& chamber_ids = chamberIdsStrip();
   for (const auto& id : chamber_ids) {
     if (nLayersWithStripInChamber(id) >= min_n_layers)
       result += 1;
   }
   return result;
 }

int CSCDigiMatcher::nCoincidenceWireChambers ( int min_n_layers = 4 ) const

Definition at line 283 of file CSCDigiMatcher.cc.

References mps_fire::result.

                                                                    {
   int result = 0;
   const auto& chamber_ids = chamberIdsWire();
   for (const auto& id : chamber_ids) {
     if (nLayersWithWireInChamber(id) >= min_n_layers)
       result += 1;
   }
   return result;
 }

int CSCDigiMatcher::nLayersWithComparatorInChamber ( unsigned int detid ) const

Definition at line 227 of file CSCDigiMatcher.cc.

References CSCDetId::chamber(), relativeConstraints::empty, CSCDetId::endcap(), mps_fire::i, CSCDetId::ring(), and CSCDetId::station().

                                                                            {
   int nLayers = 0;
   CSCDetId chamberId(detid);
   for (int i = 1; i <= 6; ++i) {
     CSCDetId layerId(chamberId.endcap(), chamberId.station(), chamberId.ring(), chamberId.chamber(), i);
     if (!comparatorDigisInDetId(layerId.rawId()).empty()) {
       nLayers++;
     }
   }
   return nLayers;
 }

int CSCDigiMatcher::nLayersWithStripInChamber ( unsigned int detid ) const

Definition at line 239 of file CSCDigiMatcher.cc.

References CSCDetId::chamber(), relativeConstraints::empty, CSCDetId::endcap(), mps_fire::i, CSCDetId::ring(), and CSCDetId::station().

                                                                       {
   int nLayers = 0;
   CSCDetId chamberId(detid);
   for (int i = 1; i <= 6; ++i) {
     CSCDetId layerId(chamberId.endcap(), chamberId.station(), chamberId.ring(), chamberId.chamber(), i);
     if (!stripDigisInDetId(layerId.rawId()).empty()) {
       nLayers++;
     }
   }
   return nLayers;
 }

int CSCDigiMatcher::nLayersWithWireInChamber ( unsigned int detid ) const

Definition at line 251 of file CSCDigiMatcher.cc.

References CSCDetId::chamber(), relativeConstraints::empty, CSCDetId::endcap(), mps_fire::i, CSCDetId::ring(), and CSCDetId::station().

                                                                      {
   int nLayers = 0;
   CSCDetId chamberId(detid);
   for (int i = 1; i <= 6; ++i) {
     CSCDetId layerId(chamberId.endcap(), chamberId.station(), chamberId.ring(), chamberId.chamber(), i);
     if (!wireDigisInDetId(layerId.rawId()).empty()) {
       nLayers++;
     }
   }
   return nLayers;
 }

template<class T >

std::set< unsigned int > CSCDigiMatcher::selectDetIds	(	const T &	digis,
		int	csc_type
	)		const

private

Definition at line 133 of file CSCDigiMatcher.h.

References AlCaHLTBitMon_ParallelJobs::p, mps_fire::result, CSCDetId::ring(), CSCDetId::station(), and MuonHitHelper::toCSCType().

                                                                                     {
   std::set<unsigned int> result;
   for (const auto& p : digis) {
     const auto& id = p.first;
     if (csc_type > 0) {
       CSCDetId detId(id);
       if (MuonHitHelper::toCSCType(detId.station(), detId.ring()) != csc_type)
         continue;
     }
     result.insert(p.first);
   }
   return result;
 }

const CSCStripDigiContainer & CSCDigiMatcher::stripDigisInChamber ( unsigned int detid ) const

Definition at line 209 of file CSCDigiMatcher.cc.

                                                                                          {
   if (chamber_to_strips_.find(detid) == chamber_to_strips_.end())
     return no_strips_;
   return chamber_to_strips_.at(detid);
 }

const CSCStripDigiContainer & CSCDigiMatcher::stripDigisInDetId ( unsigned int detid ) const

Definition at line 203 of file CSCDigiMatcher.cc.

                                                                                        {
   if (detid_to_strips_.find(detid) == detid_to_strips_.end())
     return no_strips_;
   return detid_to_strips_.at(detid);
 }

std::set< int > CSCDigiMatcher::stripsInChamber	(	unsigned int	detid,
		int	max_gap_to_fill = `0`
	)		const

Definition at line 340 of file CSCDigiMatcher.cc.

References ztail::d, mps_fire::result, and alignCSCRings::s.

                                                                                          {
   set<int> result;
   const auto& digis = stripDigisInChamber(detid);
   for (const auto& d : digis) {
     result.insert(d.getStrip());
   }
   if (max_gap_to_fill > 0) {
     int prev = -111;
     for (const auto& s : result) {
       if (s - prev > 1 && s - prev - 1 <= max_gap_to_fill) {
         for (int fill_s = prev + 1; fill_s < s; ++fill_s)
           result.insert(fill_s);
       }
       prev = s;
     }
   }
 
   return result;
 }

std::set< int > CSCDigiMatcher::stripsInDetId ( unsigned int detid ) const

Definition at line 302 of file CSCDigiMatcher.cc.

References ztail::d, and mps_fire::result.

                                                                   {
   set<int> result;
   const auto& digis = stripDigisInDetId(detid);
   for (const auto& d : digis) {
     result.insert(d.getStrip());
   }
   return result;
 }

const CSCWireDigiContainer & CSCDigiMatcher::wireDigisInChamber ( unsigned int detid ) const

Definition at line 221 of file CSCDigiMatcher.cc.

                                                                                        {
   if (chamber_to_wires_.find(detid) == chamber_to_wires_.end())
     return no_wires_;
   return chamber_to_wires_.at(detid);
 }

const CSCWireDigiContainer & CSCDigiMatcher::wireDigisInDetId ( unsigned int detid ) const

Definition at line 215 of file CSCDigiMatcher.cc.

                                                                                      {
   if (detid_to_wires_.find(detid) == detid_to_wires_.end())
     return no_wires_;
   return detid_to_wires_.at(detid);
 }

std::set< int > CSCDigiMatcher::wiregroupsInChamber	(	unsigned int	detid,
		int	max_gap_to_fill = `0`
	)		const

Definition at line 360 of file CSCDigiMatcher.cc.

References ztail::d, mps_fire::result, and w.

                                                                                              {
   set<int> result;
   const auto& digis = wireDigisInChamber(detid);
   for (const auto& d : digis) {
     result.insert(d.getWireGroup());
   }
   if (max_gap_to_fill > 0) {
     int prev = -111;
     for (const auto& w : result) {
       if (w - prev > 1 && w - prev - 1 <= max_gap_to_fill) {
         for (int fill_w = prev + 1; fill_w < w; ++fill_w)
           result.insert(fill_w);
       }
       prev = w;
     }
   }
   return result;
 }

std::set< int > CSCDigiMatcher::wiregroupsInDetId ( unsigned int detid ) const

Definition at line 311 of file CSCDigiMatcher.cc.

References ztail::d, and mps_fire::result.

                                                                       {
   set<int> result;
   const auto& digis = wireDigisInDetId(detid);
   for (const auto& d : digis) {
     result.insert(d.getWireGroup());
   }
   return result;
 }

Member Data Documentation

std::map<unsigned int, CSCComparatorDigiContainer> CSCDigiMatcher::chamber_to_comparators_

private

Definition at line 119 of file CSCDigiMatcher.h.

std::map<unsigned int, CSCStripDigiContainer> CSCDigiMatcher::chamber_to_strips_

private

Definition at line 122 of file CSCDigiMatcher.h.

std::map<unsigned int, CSCWireDigiContainer> CSCDigiMatcher::chamber_to_wires_

private

Definition at line 125 of file CSCDigiMatcher.h.

edm::EDGetTokenT<CSCComparatorDigiCollection> CSCDigiMatcher::comparatorDigiInput_

private

Definition at line 96 of file CSCDigiMatcher.h.

edm::Handle<CSCComparatorDigiCollection> CSCDigiMatcher::comparatorDigisH_

private

Definition at line 100 of file CSCDigiMatcher.h.

std::map<unsigned int, CSCComparatorDigiContainer> CSCDigiMatcher::detid_to_comparators_

private

Definition at line 118 of file CSCDigiMatcher.h.

std::map<unsigned int, CSCStripDigiContainer> CSCDigiMatcher::detid_to_strips_

private

Definition at line 121 of file CSCDigiMatcher.h.

std::map<unsigned int, CSCWireDigiContainer> CSCDigiMatcher::detid_to_wires_

private

Definition at line 124 of file CSCDigiMatcher.h.

int CSCDigiMatcher::matchDeltaComparator_

private

Definition at line 110 of file CSCDigiMatcher.h.

int CSCDigiMatcher::matchDeltaStrip_

private

Definition at line 111 of file CSCDigiMatcher.h.

int CSCDigiMatcher::matchDeltaWG_

private

Definition at line 112 of file CSCDigiMatcher.h.

int CSCDigiMatcher::maxBXComparator_

private

Definition at line 106 of file CSCDigiMatcher.h.

int CSCDigiMatcher::maxBXStrip_

private

Definition at line 107 of file CSCDigiMatcher.h.

int CSCDigiMatcher::maxBXWire_

private

Definition at line 108 of file CSCDigiMatcher.h.

int CSCDigiMatcher::minBXComparator_

private

Definition at line 106 of file CSCDigiMatcher.h.

int CSCDigiMatcher::minBXStrip_

private

Definition at line 107 of file CSCDigiMatcher.h.

int CSCDigiMatcher::minBXWire_

private

Definition at line 108 of file CSCDigiMatcher.h.

std::shared_ptr<CSCSimHitMatcher> CSCDigiMatcher::muonSimHitMatcher_

private

Definition at line 104 of file CSCDigiMatcher.h.

Referenced by muonSimHitMatcher().

CSCComparatorDigiContainer CSCDigiMatcher::no_comparators_

private

Definition at line 127 of file CSCDigiMatcher.h.

CSCStripDigiContainer CSCDigiMatcher::no_strips_

private

Definition at line 128 of file CSCDigiMatcher.h.

CSCWireDigiContainer CSCDigiMatcher::no_wires_

private

Definition at line 129 of file CSCDigiMatcher.h.

edm::EDGetTokenT<CSCStripDigiCollection> CSCDigiMatcher::stripDigiInput_

private

Definition at line 97 of file CSCDigiMatcher.h.

edm::Handle<CSCStripDigiCollection> CSCDigiMatcher::stripDigisH_

private

Definition at line 101 of file CSCDigiMatcher.h.

int CSCDigiMatcher::verboseComparator_

private

Definition at line 114 of file CSCDigiMatcher.h.

int CSCDigiMatcher::verboseStrip_

private

Definition at line 115 of file CSCDigiMatcher.h.

int CSCDigiMatcher::verboseWG_

private

Definition at line 116 of file CSCDigiMatcher.h.

edm::EDGetTokenT<CSCWireDigiCollection> CSCDigiMatcher::wireDigiInput_

private

Definition at line 98 of file CSCDigiMatcher.h.

edm::Handle<CSCWireDigiCollection> CSCDigiMatcher::wireDigisH_

private

Definition at line 102 of file CSCDigiMatcher.h.

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation