#include <GEMEffByGEMCSCSegmentSource.h>

Inheritance diagram for GEMEffByGEMCSCSegmentSource:

Public Member Functions
	GEMEffByGEMCSCSegmentSource (const edm::ParameterSet &)

	~GEMEffByGEMCSCSegmentSource () override

Public Member Functions inherited from GEMOfflineDQMBase
template<typename T >
bool	checkRefs (const std::vector< T * > &)

void	fillME (MEMap &me_map, const GEMDetId &key, const float x)

void	fillME (MEMap &me_map, const GEMDetId &key, const float x, const float y)

	GEMOfflineDQMBase (const edm::ParameterSet &)

int	getDetOccXBin (const int, const int, const int)

int	getDetOccXBin (const GEMDetId &, const edm::ESHandle< GEMGeometry > &)

GEMDetId	getKey (const GEMDetId &)

int	getMaxVFAT (const int)

int	getNumEtaPartitions (const GEMStation *)

GEMDetId	getReStEtKey (const GEMDetId &)

GEMDetId	getReStKey (const int, const int)

GEMDetId	getReStKey (const GEMDetId &)

GEMDetId	getReStLaChKey (const GEMDetId &)

GEMDetId	getReStLaKey (const GEMDetId &)

int	getVFATNumber (const int, const int, const int)

int	getVFATNumberByStrip (const int, const int, const int)

void	setDetLabelsEta (MonitorElement , const GEMStation )

void	setDetLabelsVFAT (MonitorElement , const GEMStation )

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

void	beginStream (edm::StreamID id) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	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 &)

Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr < DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Private Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &eventSetup) override

void	analyzeME11GE11Segment (const GEMCSCSegment &)

void	bookEfficiencyChamber (DQMStore::IBooker &, const edm::ESHandle< GEMGeometry > &)

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

void	bookMisc (DQMStore::IBooker &, const edm::ESHandle< GEMGeometry > &)

MonitorElement *	bookNumerator1D (DQMStore::IBooker &, MonitorElement *)

void	checkCoincidenceGE11 (const GEMRecHit , const GEMRecHit , const GEMCSCSegment &)

void	findMatchedME11Segments (const reco::MuonCollection *)

bool	isME11SegmentMatched (const CSCSegment &)

Private Attributes
const std::string	kFolder_

const edm::EDGetTokenT < GEMCSCSegmentCollection >	kGEMCSCSegmentToken_

const edm::ESGetToken < GEMGeometry, MuonGeometryRecord >	kGEMTokenBeginRun_

const std::string	kLogCategory_

const uint32_t	kMinCSCRecHits_

const edm::EDGetTokenT < reco::MuonCollection >	kMuonToken_

const bool	kUseMuon_

std::vector< const CSCSegment * >	matched_me11_segment_vector_

MEMap	me_chamber_

MEMap	me_chamber_matched_

MEMap	me_csc_chamber_type_

MEMap	me_csc_chamber_type_matched_

MEMap	me_muon_chamber_

MEMap	me_muon_chamber_matched_

MEMap	me_num_csc_hits_

MEMap	me_num_csc_hits_matched_

MEMap	me_reduced_chi2_

MEMap	me_reduced_chi2_matched_

Additional Inherited Members
Public Types inherited from GEMOfflineDQMBase
using	MEMap = std::map< GEMDetId, dqm::impl::MonitorElement * >

Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
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 Attributes inherited from GEMOfflineDQMBase
std::string	log_category_

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

GEMEffByGEMCSCSegmentSource measures the efficiency of GE11-L1(2) using GE11-L2(1) and ME11 as trigger detectors. See https://github.com/cms-sw/cmssw/blob/CMSSW_12_3_0_pre5/RecoLocalMuon/GEMCSCSegment/plugins/GEMCSCSegAlgoRR.cc

Author: Seungjin Yang seung.nosp@m.jin..nosp@m.yang@.nosp@m.cern.nosp@m..ch

Definition at line 23 of file GEMEffByGEMCSCSegmentSource.h.

Constructor & Destructor Documentation

GEMEffByGEMCSCSegmentSource::GEMEffByGEMCSCSegmentSource ( const edm::ParameterSet & parameter_set )

explicit

Definition at line 5 of file GEMEffByGEMCSCSegmentSource.cc.

     : GEMOfflineDQMBase(parameter_set),
       kGEMTokenBeginRun_(esConsumes<edm::Transition::BeginRun>()),
       kGEMCSCSegmentToken_(
           consumes<GEMCSCSegmentCollection>(parameter_set.getParameter<edm::InputTag>("gemcscSegmentTag"))),
       kMuonToken_(consumes<reco::MuonCollection>(parameter_set.getParameter<edm::InputTag>("muonTag"))),
       kUseMuon_(parameter_set.getUntrackedParameter<bool>("useMuon")),
       kMinCSCRecHits_(parameter_set.getUntrackedParameter<uint32_t>("minCSCRecHits")),
       kFolder_(parameter_set.getUntrackedParameter<std::string>("folder")),
       kLogCategory_(parameter_set.getUntrackedParameter<std::string>("logCategory")) {}

GEMEffByGEMCSCSegmentSource::~GEMEffByGEMCSCSegmentSource ( )

override

Definition at line 16 of file GEMEffByGEMCSCSegmentSource.cc.

16 {}

Member Function Documentation

void GEMEffByGEMCSCSegmentSource::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

overrideprivatevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 152 of file GEMEffByGEMCSCSegmentSource.cc.

References analyzeME11GE11Segment(), GEMCSCSegment::cscDetId(), findMatchedME11Segments(), edm::Event::getHandle(), patZpeak::handle, CSCDetId::isME11(), kGEMCSCSegmentToken_, kLogCategory_, kMuonToken_, kUseMuon_, and LogDebug.

                                                                                            {
   // get data from Event & EventSetup
   const GEMCSCSegmentCollection* gemcsc_segment_collection = nullptr;
   if (const edm::Handle<GEMCSCSegmentCollection> handle = event.getHandle(kGEMCSCSegmentToken_)) {
     gemcsc_segment_collection = handle.product();
 
   } else {
     edm::LogError(kLogCategory_) << "invalid GEMCSCSegmentCollection";
     return;
   }
 
   const reco::MuonCollection* muon_collection = nullptr;
   if (kUseMuon_) {
     if (const edm::Handle<reco::MuonCollection> handle = event.getHandle(kMuonToken_)) {
       muon_collection = handle.product();
 
     } else {
       edm::LogError(kLogCategory_) << "invalid reco::MuonCollection";
       return;
     }
   }
 
   // quick check
   if (gemcsc_segment_collection->size() < 1) {
     LogDebug(kLogCategory_) << "empty GEMCSCSegment";
     return;
   }
 
   //
   if (kUseMuon_) {
     findMatchedME11Segments(muon_collection);
   }
 
   // main loop
   for (edm::OwnVector<GEMCSCSegment>::const_iterator iter = gemcsc_segment_collection->begin();
        iter != gemcsc_segment_collection->end();
        iter++) {
     const GEMCSCSegment& gemcsc_segment = *iter;
 
     const CSCDetId csc_id = gemcsc_segment.cscDetId();
     if (csc_id.isME11()) {
       analyzeME11GE11Segment(gemcsc_segment);
 
     } else {
       LogDebug(kLogCategory_) << "skip " << csc_id;
       continue;
     }
   }  // GEMCSCSegment
 }

void GEMEffByGEMCSCSegmentSource::analyzeME11GE11Segment ( const GEMCSCSegment & gemcsc_segment )

private

Definition at line 206 of file GEMEffByGEMCSCSegmentSource.cc.

References checkCoincidenceGE11(), GEMCSCSegment::cscDetId(), GEMCSCSegment::gemRecHits(), GEMDetId::isGE11(), kLogCategory_, phase1PixelTopology::layer, and GEMDetId::layer().

Referenced by analyze().

                                                                                             {
   const GEMRecHit* ge11_hit_layer1 = nullptr;
   const GEMRecHit* ge11_hit_layer2 = nullptr;
 
   const CSCDetId csc_id = gemcsc_segment.cscDetId();
   for (const GEMRecHit& gem_hit : gemcsc_segment.gemRecHits()) {
     const GEMDetId gem_id = gem_hit.gemId();
 
     if (not gem_id.isGE11()) {
       edm::LogWarning(kLogCategory_) << "CSCSegment is in " << csc_id << " but GEMRecHit is in " << gem_id
                                      << ". skip this GEMCSCSegment."
                                      << "check if RecoLocalMuon/GEMCSCSegment/plugins/GEMCSCSegAlgoRR.cc has changed.";
       return;
     }
 
     const int layer = gem_id.layer();
     if (layer == 1) {
       ge11_hit_layer1 = &gem_hit;
 
     } else if (layer == 2) {
       ge11_hit_layer2 = &gem_hit;
 
     } else {
       edm::LogError(kLogCategory_) << "isGE11 but got unexpected layer " << gem_id << ". skip this GEMCSCSegment.";
       return;
     }
   }  // GEMRecHit
 
   checkCoincidenceGE11(ge11_hit_layer1, ge11_hit_layer2, gemcsc_segment);
   checkCoincidenceGE11(ge11_hit_layer2, ge11_hit_layer1, gemcsc_segment);
 }

void GEMEffByGEMCSCSegmentSource::bookEfficiencyChamber	(	DQMStore::IBooker &	ibooker,
		const edm::ESHandle< GEMGeometry > &	gem
	)

private

Definition at line 42 of file GEMEffByGEMCSCSegmentSource.cc.

References dqm::implementation::IBooker::book1D(), bookNumerator1D(), GEMOfflineDQMBase::checkRefs(), GEMOfflineDQMBase::getReStLaKey(), GEMUtils::getSuffixName(), GEMUtils::getSuffixTitle(), submitPVResolutionJobs::key, kFolder_, kLogCategory_, kUseMuon_, LogDebug, me_chamber_, me_chamber_matched_, me_muon_chamber_, me_muon_chamber_matched_, dqm::impl::MonitorElement::setAxisTitle(), dqm::implementation::NavigatorBase::setCurrentFolder(), relativeConstraints::station, and cond::impl::to_string().

Referenced by bookHistograms().

                                                                                              {
   ibooker.setCurrentFolder(kFolder_ + "/Efficiency");
 
   for (const GEMStation* station : gem->stations()) {
     const int region_id = station->region();
     const int station_id = station->station();
 
     if (station_id == 1) {
       // GE11
       const std::vector<const GEMSuperChamber*> superchambers = station->superChambers();
       if (not checkRefs(superchambers)) {
         edm::LogError(kLogCategory_) << "failed to get a valid vector of GEMSuperChamber ptrs";
         return;
       }
 
       const int num_chambers = superchambers.size();
       for (const GEMChamber* chamber : superchambers.at(0)->chambers()) {
         const int layer_id = chamber->id().layer();
 
         const TString name_suffix = GEMUtils::getSuffixName(region_id, station_id, layer_id);
         const TString title_suffix = GEMUtils::getSuffixTitle(region_id, station_id, layer_id);
         const GEMDetId key = getReStLaKey(chamber->id());
 
         me_chamber_[key] = ibooker.book1D("chamber" + name_suffix, title_suffix, num_chambers, 0.5, num_chambers + 0.5);
         me_chamber_[key]->setAxisTitle("Chamber", 1);
         for (int binx = 1; binx <= num_chambers; binx++) {
           me_chamber_[key]->setBinLabel(binx, std::to_string(binx), 1);
         }
         me_chamber_matched_[key] = bookNumerator1D(ibooker, me_chamber_[key]);
 
         if (kUseMuon_) {
           me_muon_chamber_[key] =
               ibooker.book1D("muon_chamber" + name_suffix, title_suffix, num_chambers, 0.5, num_chambers + 0.5);
           me_muon_chamber_[key]->setAxisTitle("Chamber", 1);
           for (int binx = 1; binx <= num_chambers; binx++) {
             me_muon_chamber_[key]->setBinLabel(binx, std::to_string(binx), 1);
           }
           me_muon_chamber_matched_[key] = bookNumerator1D(ibooker, me_muon_chamber_[key]);
         }
       }  // layer
 
     } else {
       LogDebug(kLogCategory_) << "skip " << station->getName();
       continue;
     }
   }  // station
 }

void GEMEffByGEMCSCSegmentSource::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	,
		edm::EventSetup const &	setup
	)

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 29 of file GEMEffByGEMCSCSegmentSource.cc.

References bookEfficiencyChamber(), bookMisc(), edm::EventSetup::getHandle(), edm::ESHandleBase::isValid(), kGEMTokenBeginRun_, and kLogCategory_.

                                                                              {
   const edm::ESHandle<GEMGeometry>& gem = setup.getHandle(kGEMTokenBeginRun_);
   if (not gem.isValid()) {
     edm::LogError(kLogCategory_) << "invalid GEMGeometry";
     return;
   }
 
   bookEfficiencyChamber(ibooker, gem);
   bookMisc(ibooker, gem);
 }

void GEMEffByGEMCSCSegmentSource::bookMisc	(	DQMStore::IBooker &	ibooker,
		const edm::ESHandle< GEMGeometry > &	gem
	)

private

Definition at line 91 of file GEMEffByGEMCSCSegmentSource.cc.

References dqm::implementation::IBooker::book1D(), bookNumerator1D(), CSCDetId::chamberName(), GEMOfflineDQMBase::checkRefs(), GEMOfflineDQMBase::getReStLaKey(), GEMUtils::getSuffixName(), GEMUtils::getSuffixTitle(), submitPVResolutionJobs::key, kFolder_, kLogCategory_, label, LogDebug, me_csc_chamber_type_, me_csc_chamber_type_matched_, me_num_csc_hits_, me_num_csc_hits_matched_, me_reduced_chi2_, me_reduced_chi2_matched_, dqm::impl::MonitorElement::setAxisTitle(), dqm::implementation::NavigatorBase::setCurrentFolder(), relativeConstraints::station, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by bookHistograms().

                                                                                                         {
   ibooker.setCurrentFolder(kFolder_ + "/Misc");
 
   for (const GEMStation* station : gem->stations()) {
     const int region_id = station->region();
     const int station_id = station->station();
 
     if (station_id == 1) {
       // GE11
       const std::vector<const GEMSuperChamber*> superchambers = station->superChambers();
       if (not checkRefs(superchambers)) {
         edm::LogError(kLogCategory_) << "failed to get a valid vector of GEMSuperChamber ptrs";
         return;
       }
 
       for (const GEMChamber* chamber : superchambers.at(0)->chambers()) {
         const int layer_id = chamber->id().layer();
 
         const TString name_suffix = GEMUtils::getSuffixName(region_id, station_id, layer_id);
         const TString title_suffix = GEMUtils::getSuffixTitle(region_id, station_id, layer_id);
         const GEMDetId key = getReStLaKey(chamber->id());
 
         // num_csc_hits
         me_num_csc_hits_[key] = ibooker.book1D("num_csc_hits" + name_suffix, title_suffix, 4, 2.5, 6.5);
         me_num_csc_hits_[key]->setAxisTitle("Number of CSCRecHits", 1);
 
         me_num_csc_hits_matched_[key] = bookNumerator1D(ibooker, me_num_csc_hits_[key]);
 
         // reduced_chi2
         me_reduced_chi2_[key] = ibooker.book1D("reduced_chi2" + name_suffix, title_suffix, 30, 0, 3);
         me_reduced_chi2_[key]->setAxisTitle("#chi^{2} / dof", 1);
 
         me_reduced_chi2_matched_[key] = bookNumerator1D(ibooker, me_reduced_chi2_[key]);
 
         // CSC chamber type
         // https://github.com/cms-sw/cmssw/blob/CMSSW_12_3_0_pre5/DataFormats/MuonDetId/interface/CSCDetId.h#L187-L193
         me_csc_chamber_type_[key] = ibooker.book1D("csc_chamber_type" + name_suffix, title_suffix, 10, 0.5, 10.5);
         me_csc_chamber_type_[key]->setAxisTitle("CSC chamber type", 1);
         for (int chamber_type = 1; chamber_type <= 10; chamber_type++) {
           const std::string label = CSCDetId::chamberName(chamber_type);
           me_csc_chamber_type_[key]->setBinLabel(chamber_type, label, 1);
         }
 
         me_csc_chamber_type_matched_[key] = bookNumerator1D(ibooker, me_csc_chamber_type_[key]);
 
       }  // layer
 
     } else {
       LogDebug(kLogCategory_) << "skip " << station->getName();
       continue;
     }
   }  // region-station
 }

dqm::impl::MonitorElement * GEMEffByGEMCSCSegmentSource::bookNumerator1D	(	DQMStore::IBooker &	ibooker,
		MonitorElement *	me
	)

private

Definition at line 145 of file GEMEffByGEMCSCSegmentSource.cc.

References dqm::implementation::IBooker::book1D(), dqm::impl::MonitorElement::getName(), dqm::impl::MonitorElement::getTH1F(), gpuVertexFinder::hist, mergeVDriftHistosByStation::name, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by bookEfficiencyChamber(), and bookMisc().

                                                                                             {
   const std::string name = me->getName() + "_matched";
   TH1F* hist = dynamic_cast<TH1F*>(me->getTH1F()->Clone(name.c_str()));
   return ibooker.book1D(name, hist);
 }

void GEMEffByGEMCSCSegmentSource::checkCoincidenceGE11	(	const GEMRecHit *	trigger_layer_hit,
		const GEMRecHit *	detection_layer_hit,
		const GEMCSCSegment &	gemcsc_segment
	)

private

Definition at line 238 of file GEMEffByGEMCSCSegmentSource.cc.

References GEMDetId::chamber(), GEMCSCSegment::chi2(), GEMCSCSegment::cscDetId(), GEMCSCSegment::cscRecHits(), GEMCSCSegment::cscSegment(), GEMCSCSegment::degreesOfFreedom(), GEMOfflineDQMBase::fillME(), GEMRecHit::gemId(), CSCDetId::iChamberType(), isME11SegmentMatched(), submitPVResolutionJobs::key, kLogCategory_, kMinCSCRecHits_, kUseMuon_, GEMDetId::layer(), LogDebug, me_chamber_, me_chamber_matched_, me_csc_chamber_type_, me_csc_chamber_type_matched_, me_muon_chamber_, me_muon_chamber_matched_, me_num_csc_hits_, me_num_csc_hits_matched_, me_reduced_chi2_, me_reduced_chi2_matched_, SiStripPI::min, GEMDetId::region(), and GEMDetId::station().

Referenced by analyzeME11GE11Segment().

                                                                                             {
   if (trigger_layer_hit == nullptr) {
     LogDebug(kLogCategory_) << "trigger_layer_hit is nullptr";
     return;
   }
 
   const GEMDetId trigger_layer_id = trigger_layer_hit->gemId();
   const int detection_layer = trigger_layer_id.layer() == 1 ? 2 : 1;
   // detection layer key
   // GEMDetId(int region, int ring, int station, int layer, int chamber, int ieta)
   const GEMDetId key{trigger_layer_id.region(), 1, trigger_layer_id.station(), detection_layer, 0, 0};
 
   const int chamber = trigger_layer_id.chamber();
   const bool is_matched = kUseMuon_ ? isME11SegmentMatched(gemcsc_segment.cscSegment()) : false;
 
   const int num_csc_hits = gemcsc_segment.cscRecHits().size();
   // TODO fillMEWithinLimits
   const double reduced_chi2 = std::min(gemcsc_segment.chi2() / gemcsc_segment.degreesOfFreedom(), 2.9999);
   const int csc_chamber_type = gemcsc_segment.cscDetId().iChamberType();
 
   // TODO add a method
   const bool is_good = gemcsc_segment.cscRecHits().size() >= kMinCSCRecHits_;
 
   fillME(me_num_csc_hits_, key, num_csc_hits);
   fillME(me_reduced_chi2_, key, reduced_chi2);
   fillME(me_csc_chamber_type_, key, csc_chamber_type);
   if (detection_layer_hit) {
     fillME(me_num_csc_hits_matched_, key, num_csc_hits);
     fillME(me_reduced_chi2_matched_, key, reduced_chi2);
     fillME(me_csc_chamber_type_matched_, key, csc_chamber_type);
   }
 
   if (is_good) {
     // twofold coincidence rate
     fillME(me_chamber_, key, chamber);
     if (is_matched) {
       fillME(me_muon_chamber_, key, chamber);
     }
 
     // threefold coincidence rate
     if (detection_layer_hit) {
       fillME(me_chamber_matched_, key, chamber);
       if (is_matched) {
         fillME(me_muon_chamber_matched_, key, chamber);
       }
     }
   }
 }

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

static

Definition at line 18 of file GEMEffByGEMCSCSegmentSource.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                              {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("gemcscSegmentTag", edm::InputTag("gemcscSegments"));
   desc.add<edm::InputTag>("muonTag", edm::InputTag("muons"));
   desc.addUntracked<bool>("useMuon", false);
   desc.addUntracked<uint32_t>("minCSCRecHits", 6u);
   desc.addUntracked<std::string>("folder", "GEM/Efficiency/GEMCSCSegment");
   desc.addUntracked<std::string>("logCategory", "GEMEffByGEMCSCSegmentSource");
   descriptions.addWithDefaultLabel(desc);
 }

void GEMEffByGEMCSCSegmentSource::findMatchedME11Segments ( const reco::MuonCollection * muon_collection )

private

Definition at line 289 of file GEMEffByGEMCSCSegmentSource.cc.

References reco::MuonSegmentMatch::BestInStationByDR, MuonSubdetId::CSC, reco::MuonSegmentMatch::cscSegmentRef, edm::Ref< C, T, F >::get(), reco::MuonSegmentMatch::isMask(), matched_me11_segment_vector_, reco::Muon::matches(), and HLT_FULL_cff::muon.

Referenced by analyze().

                                                                                                    {
   matched_me11_segment_vector_.clear();
   for (unsigned int idx = 0; idx < muon_collection->size(); idx++) {
     const reco::Muon& muon = muon_collection->at(idx);
 
     for (const reco::MuonChamberMatch& chamber_match : muon.matches()) {
       if (chamber_match.detector() != MuonSubdetId::CSC) {
         continue;
       }
 
       const CSCDetId csc_id{chamber_match.id};
       if (not csc_id.isME11()) {
         continue;
       }
 
       for (const reco::MuonSegmentMatch& segment_match : chamber_match.segmentMatches) {
         if (not segment_match.isMask(reco::MuonSegmentMatch::BestInStationByDR)) {
           continue;
         }
         matched_me11_segment_vector_.push_back(segment_match.cscSegmentRef.get());
       }  // MuonSegmentMatch
     }    // MuonChamberMatch
   }      // MuonCollection
 }

bool GEMEffByGEMCSCSegmentSource::isME11SegmentMatched ( const CSCSegment & csc_segment )

private

Definition at line 315 of file GEMEffByGEMCSCSegmentSource.cc.

References CSCSegment::cscDetId(), newFWLiteAna::found, CSCDetId::isME11(), CSCSegment::localPosition(), matched_me11_segment_vector_, CSCSegment::time(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by checkCoincidenceGE11().

                                                                                     {
   bool found = false;
 
   const CSCDetId csc_id = csc_segment.cscDetId();
   if (not csc_id.isME11()) {
     return false;
   }
 
   for (const CSCSegment* matched_segment : matched_me11_segment_vector_) {
     if (csc_id != matched_segment->cscDetId())
       continue;
     if (csc_segment.localPosition().x() != matched_segment->localPosition().x())
       continue;
     if (csc_segment.localPosition().y() != matched_segment->localPosition().y())
       continue;
     if (csc_segment.localPosition().z() != matched_segment->localPosition().z())
       continue;
     if (csc_segment.time() != matched_segment->time())
       continue;
 
     found = true;
   }
 
   return found;
 }