GEMEffByGEMCSCSegmentSource Class Reference

#include <GEMEffByGEMCSCSegmentSource.h>

Inheritance diagram for GEMEffByGEMCSCSegmentSource:

Public Member Functions
	GEMEffByGEMCSCSegmentSource (const edm::ParameterSet &)
	~GEMEffByGEMCSCSegmentSource () override
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 Types
using	MEMap = std::map< GEMDetId, dqm::impl::MonitorElement * >

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 &)
template<typename T >
bool	checkRefs (const std::vector< T * > &)
void	fillME (dqm::impl::MonitorElement *, const double)
void	fillME (MEMap &me_map, const GEMDetId &key, const double)
void	fillMEWithinLimits (dqm::impl::MonitorElement *, const double)
void	fillMEWithinLimits (MEMap &, const GEMDetId &, const double)
void	findMatchedME11Segments (const reco::MuonCollection *)
GEMDetId	getReStLaKey (const GEMDetId &)
bool	hasMEKey (const MEMap &, const GEMDetId &)
bool	isME11SegmentMatched (const CSCSegment &)

Private Attributes
const double	kEps_ = std::numeric_limits<double>::epsilon()
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 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
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 27 of file GEMEffByGEMCSCSegmentSource.h.

Member Typedef Documentation

using GEMEffByGEMCSCSegmentSource::MEMap = std::map<GEMDetId, dqm::impl::MonitorElement*>

private

Definition at line 35 of file GEMEffByGEMCSCSegmentSource.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 6 of file GEMEffByGEMCSCSegmentSource.cc.

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

{}

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(), checkRefs(), 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(), and relativeConstraints::station.

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(), checkRefs(), 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(), fillME(), fillMEWithinLimits(), 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_, 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();
  const double reduced_chi2 = gemcsc_segment.chi2() / gemcsc_segment.degreesOfFreedom();
  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);
  fillMEWithinLimits(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);
    fillMEWithinLimits(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);
      }
    }
  }
}

template<typename T >

bool GEMEffByGEMCSCSegmentSource::checkRefs ( const std::vector< T * > &  refs )

inlineprivate

Definition at line 86 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookEfficiencyChamber(), and bookMisc().

                                                                            {
  if (refs.empty())
    return false;
  if (refs.front() == nullptr)
    return false;
  return true;
}

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::fillME ( dqm::impl::MonitorElement *  me, const double  x  )

private

Definition at line 353 of file GEMEffByGEMCSCSegmentSource.cc.

References dqm::impl::MonitorElement::Fill(), and kLogCategory_.

Referenced by checkCoincidenceGE11().

                                                                                  {
  if (me) {
    me->Fill(x);

  } else {
    edm::LogError(kLogCategory_) << "MonitorElement is nullptr";

  }
}

void GEMEffByGEMCSCSegmentSource::fillME ( MEMap &  me_map, const GEMDetId &  key, const double  x  )

private

Definition at line 363 of file GEMEffByGEMCSCSegmentSource.cc.

References hasMEKey(), and submitPVResolutionJobs::key.

                                                                                           {
  if (hasMEKey(me_map, key)) {
    me_map[key]->Fill(x);
  }
}

void GEMEffByGEMCSCSegmentSource::fillMEWithinLimits ( dqm::impl::MonitorElement *  me, const double  x  )

private

Definition at line 370 of file GEMEffByGEMCSCSegmentSource.cc.

References dqm::impl::MonitorElement::Fill(), dqm::impl::MonitorElement::getAxisMax(), dqm::impl::MonitorElement::getAxisMin(), kEps_, and kLogCategory_.

Referenced by checkCoincidenceGE11(), and fillMEWithinLimits().

                                                                                              {
  if (me) {
    const double xlow = me->getAxisMin(1);
    const double xup = me->getAxisMax(1) - kEps_;
    me->Fill(std::clamp(x, xlow, xup));

  } else {
    edm::LogError(kLogCategory_) << "MonitorElement is nullptr";

  }
}

void GEMEffByGEMCSCSegmentSource::fillMEWithinLimits ( MEMap &  me_map, const GEMDetId &  key, const double  x  )

private

Definition at line 382 of file GEMEffByGEMCSCSegmentSource.cc.

References fillMEWithinLimits(), and hasMEKey().

                                                                                                       {
  if (hasMEKey(me_map, key)) {
    fillMEWithinLimits(me_map[key], x);
  }
}

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

private

Definition at line 288 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
}

GEMDetId GEMEffByGEMCSCSegmentSource::getReStLaKey ( const GEMDetId &  id )

inlineprivate

Definition at line 94 of file GEMEffByGEMCSCSegmentSource.h.

References GEMDetId::region().

Referenced by bookEfficiencyChamber(), and bookMisc().

                                                                            {
  return GEMDetId{id.region(), 1, id.station(), id.layer(), 0, 0};
}

bool GEMEffByGEMCSCSegmentSource::hasMEKey ( const MEMap &  me_map, const GEMDetId &  key  )

private

Definition at line 340 of file GEMEffByGEMCSCSegmentSource.cc.

References kLogCategory_, AlCaHLTBitMon_QueryRunRegistry::string, and UNLIKELY.

Referenced by fillME(), and fillMEWithinLimits().

                                                                                   {
  bool has_key = true;

  if UNLIKELY (me_map.find(key) == me_map.end()) {
    const std::string hint = me_map.empty() ? "empty" : me_map.begin()->second->getName();
    edm::LogError(kLogCategory_) << "got an invalid key: " << key << ", hint=" << hint;
    has_key = false;

  }

  return has_key;
}

bool GEMEffByGEMCSCSegmentSource::isME11SegmentMatched ( const CSCSegment &  csc_segment )

private

Definition at line 314 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;
}

Member Data Documentation

const double GEMEffByGEMCSCSegmentSource::kEps_ = std::numeric_limits<double>::epsilon()

private

Definition at line 44 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by fillMEWithinLimits().

const std::string GEMEffByGEMCSCSegmentSource::kFolder_

private

Definition at line 65 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookEfficiencyChamber(), and bookMisc().

const edm::EDGetTokenT<GEMCSCSegmentCollection> GEMEffByGEMCSCSegmentSource::kGEMCSCSegmentToken_

private

Definition at line 61 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by analyze().

const edm::ESGetToken<GEMGeometry, MuonGeometryRecord> GEMEffByGEMCSCSegmentSource::kGEMTokenBeginRun_

private

Definition at line 60 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookHistograms().

const std::string GEMEffByGEMCSCSegmentSource::kLogCategory_

private

Definition at line 66 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by analyze(), analyzeME11GE11Segment(), bookEfficiencyChamber(), bookHistograms(), bookMisc(), checkCoincidenceGE11(), fillME(), fillMEWithinLimits(), and hasMEKey().

const uint32_t GEMEffByGEMCSCSegmentSource::kMinCSCRecHits_

private

Definition at line 64 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by checkCoincidenceGE11().

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

private

Definition at line 62 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by analyze().

const bool GEMEffByGEMCSCSegmentSource::kUseMuon_

private

Definition at line 63 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by analyze(), bookEfficiencyChamber(), and checkCoincidenceGE11().

std::vector<const CSCSegment *> GEMEffByGEMCSCSegmentSource::matched_me11_segment_vector_

private

Definition at line 69 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by findMatchedME11Segments(), and isME11SegmentMatched().

MEMap GEMEffByGEMCSCSegmentSource::me_chamber_

private

Definition at line 72 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookEfficiencyChamber(), and checkCoincidenceGE11().

MEMap GEMEffByGEMCSCSegmentSource::me_chamber_matched_

private

Definition at line 73 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookEfficiencyChamber(), and checkCoincidenceGE11().

MEMap GEMEffByGEMCSCSegmentSource::me_csc_chamber_type_

private

Definition at line 81 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookMisc(), and checkCoincidenceGE11().

MEMap GEMEffByGEMCSCSegmentSource::me_csc_chamber_type_matched_

private

Definition at line 82 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookMisc(), and checkCoincidenceGE11().

MEMap GEMEffByGEMCSCSegmentSource::me_muon_chamber_

private

Definition at line 74 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookEfficiencyChamber(), and checkCoincidenceGE11().

MEMap GEMEffByGEMCSCSegmentSource::me_muon_chamber_matched_

private

Definition at line 75 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookEfficiencyChamber(), and checkCoincidenceGE11().

MEMap GEMEffByGEMCSCSegmentSource::me_num_csc_hits_

private

Definition at line 77 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookMisc(), and checkCoincidenceGE11().

MEMap GEMEffByGEMCSCSegmentSource::me_num_csc_hits_matched_

private

Definition at line 78 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookMisc(), and checkCoincidenceGE11().

MEMap GEMEffByGEMCSCSegmentSource::me_reduced_chi2_

private

Definition at line 79 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookMisc(), and checkCoincidenceGE11().

MEMap GEMEffByGEMCSCSegmentSource::me_reduced_chi2_matched_

private

Definition at line 80 of file GEMEffByGEMCSCSegmentSource.h.

Referenced by bookMisc(), and checkCoincidenceGE11().