GEMEfficiencyAnalyzer Class Reference

#include <GEMEfficiencyAnalyzer.h>

Inheritance diagram for GEMEfficiencyAnalyzer:

Classes
struct	GEMLayerData

Public Member Functions
	GEMEfficiencyAnalyzer (const edm::ParameterSet &)
	~GEMEfficiencyAnalyzer () 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 &)

Protected Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &eventSetup) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Private Member Functions
void	bookEfficiencyChamber (DQMStore::IBooker &, const edm::ESHandle< GEMGeometry > &)
void	bookEfficiencyDetector (DQMStore::IBooker &, const edm::ESHandle< GEMGeometry > &)
void	bookEfficiencyEtaPartition (DQMStore::IBooker &, const edm::ESHandle< GEMGeometry > &)
void	bookEfficiencyMomentum (DQMStore::IBooker &, const edm::ESHandle< GEMGeometry > &)
void	bookMisc (DQMStore::IBooker &, const edm::ESHandle< GEMGeometry > &)
MonitorElement *	bookNumerator1D (DQMStore::IBooker &, MonitorElement *)
MonitorElement *	bookNumerator2D (DQMStore::IBooker &, MonitorElement *)
void	bookResolution (DQMStore::IBooker &, const edm::ESHandle< GEMGeometry > &)
std::vector< GEMLayerData >	buildGEMLayers (const edm::ESHandle< GEMGeometry > &)
bool	checkBounds (const GlobalPoint &, const Plane &)
std::pair< const GEMRecHit *, float >	findClosetHit (const GlobalPoint &, const GEMRecHitCollection::range &, const GEMEtaPartition *)
const GEMEtaPartition *	findEtaPartition (const GlobalPoint &, const std::vector< const GEMChamber * > &)
std::pair < TrajectoryStateOnSurface, DetId >	findStartingState (const reco::TransientTrack &, const GEMLayerData &, const edm::ESHandle< GlobalTrackingGeometry > &)
std::pair < TrajectoryStateOnSurface, DetId >	getStartingState (const reco::TransientTrack &, const GEMLayerData &, const edm::ESHandle< GlobalTrackingGeometry > &)
const reco::Track *	getTrack (const reco::Muon &)
bool	isInsideOut (const reco::Track &)
bool	isME11 (const DetId &)
bool	skipGEMStation (const int)
bool	skipLayer (const reco::Track *, const GEMLayerData &)

Private Attributes
double	eta_clamp_max_
double	eta_low_
int	eta_nbins_
double	eta_up_
std::string	folder_
const edm::ESGetToken < GEMGeometry, MuonGeometryRecord >	gemToken1_
const edm::ESGetToken < GEMGeometry, MuonGeometryRecord >	gemToken2_
const edm::ESGetToken < GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	globalGeomToken_
bool	is_cosmics_
const std::string	kLogCategory_ = "GEMEfficiencyAnalyzer"
MonitorElement *	me_all_abs_residual_rphi_
MEMap	me_chamber_
MEMap	me_chamber_matched_
MEMap	me_detector_
MEMap	me_detector_matched_
MEMap	me_ieta_
MEMap	me_ieta_matched_
MEMap	me_muon_eta_
MEMap	me_muon_eta_matched_
MEMap	me_muon_phi_
MEMap	me_muon_phi_matched_
MEMap	me_muon_pt_
MEMap	me_muon_pt_matched_
MEMap	me_prop_chamber_
MonitorElement *	me_prop_phi_err_
MonitorElement *	me_prop_r_err_
MEMap	me_pull_y_
MEMap	me_residual_rphi_
MEMap	me_residual_y_
bool	monitor_ge0_
bool	monitor_ge11_
bool	monitor_ge21_
MuonServiceProxy *	muon_service_
edm::EDGetTokenT< edm::View < reco::Muon > >	muon_token_
std::string	name_
double	prop_phi_error_cut_
double	prop_r_error_cut_
std::vector< double >	pt_bins_
double	pt_clamp_max_
edm::EDGetTokenT < GEMRecHitCollection >	rechit_token_
float	residual_rphi_cut_
const edm::ESGetToken < TransientTrackBuilder, TransientTrackRecord >	trasientTrackToken_
bool	use_global_muon_
bool	use_only_me11_
bool	use_prop_phi_error_cut_
bool	use_prop_r_error_cut_
bool	use_skip_layer_

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 Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Detailed Description

DQM monitoring source for GEM efficiency and resolution based on https://github.com/CPLUOS/MuonPerformance/blob/master/MuonAnalyser/plugins/SliceTestEfficiencyAnalysis.cc

Author

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

DQM monitoring client for GEM efficiency and resolution based on Validation/MuonGEMHits/MuonGEMBaseHarvestor

Author

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

Definition at line 28 of file GEMEfficiencyAnalyzer.h.

Constructor & Destructor Documentation

GEMEfficiencyAnalyzer::GEMEfficiencyAnalyzer ( const edm::ParameterSet &  pset )

explicit

Definition at line 13 of file GEMEfficiencyAnalyzer.cc.

References gpuVertexFinder::eps, geometryDiff::epsilon, eta_clamp_max_, eta_low_, eta_nbins_, eta_up_, folder_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), is_cosmics_, monitor_ge0_, monitor_ge11_, monitor_ge21_, muon_service_, muon_token_, MuonServiceProxy_cff::MuonServiceProxy, name_, prop_phi_error_cut_, prop_r_error_cut_, pt_bins_, pt_clamp_max_, rechit_token_, residual_rphi_cut_, AlCaHLTBitMon_QueryRunRegistry::string, use_global_muon_, use_only_me11_, use_prop_phi_error_cut_, use_prop_r_error_cut_, and use_skip_layer_.

    : GEMOfflineDQMBase(pset),
      gemToken1_(esConsumes<edm::Transition::BeginRun>()),
      gemToken2_(esConsumes<GEMGeometry, MuonGeometryRecord>()),
      globalGeomToken_(esConsumes<GlobalTrackingGeometry, GlobalTrackingGeometryRecord>()),
      trasientTrackToken_(
          esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"))) {
  name_ = pset.getUntrackedParameter<std::string>("name");
  folder_ = pset.getUntrackedParameter<std::string>("folder");

  rechit_token_ = consumes<GEMRecHitCollection>(pset.getParameter<edm::InputTag>("recHitTag"));
  muon_token_ = consumes<edm::View<reco::Muon> >(pset.getParameter<edm::InputTag>("muonTag"));

  is_cosmics_ = pset.getUntrackedParameter<bool>("isCosmics");
  use_global_muon_ = pset.getUntrackedParameter<bool>("useGlobalMuon");
  use_skip_layer_ = pset.getParameter<bool>("useSkipLayer");
  use_only_me11_ = pset.getParameter<bool>("useOnlyME11");
  residual_rphi_cut_ = static_cast<float>(pset.getParameter<double>("residualRPhiCut"));
  use_prop_r_error_cut_ = pset.getParameter<bool>("usePropRErrorCut");
  prop_r_error_cut_ = pset.getParameter<double>("propRErrorCut");
  use_prop_phi_error_cut_ = pset.getParameter<bool>("usePropPhiErrorCut");
  prop_phi_error_cut_ = pset.getParameter<double>("propPhiErrorCut");
  pt_bins_ = pset.getUntrackedParameter<std::vector<double> >("ptBins");
  eta_nbins_ = pset.getUntrackedParameter<int>("etaNbins");
  eta_low_ = pset.getUntrackedParameter<double>("etaLow");
  eta_up_ = pset.getUntrackedParameter<double>("etaUp");
  monitor_ge11_ = pset.getUntrackedParameter<bool>("monitorGE11");
  monitor_ge21_ = pset.getUntrackedParameter<bool>("monitorGE21");
  monitor_ge0_ = pset.getUntrackedParameter<bool>("monitorGE0");

  const edm::ParameterSet&& muon_service_parameter = pset.getParameter<edm::ParameterSet>("ServiceParameters");
  muon_service_ = new MuonServiceProxy(muon_service_parameter, consumesCollector());

  const double eps = std::numeric_limits<double>::epsilon();
  pt_clamp_max_ = pt_bins_.back() - eps;
  eta_clamp_max_ = eta_up_ - eps;

  // TODO pt, eta, quality check for muons
}

GEMEfficiencyAnalyzer::~GEMEfficiencyAnalyzer ( )

override

Definition at line 53 of file GEMEfficiencyAnalyzer.cc.

{}

Member Function Documentation

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 386 of file GEMEfficiencyAnalyzer.cc.

References funct::abs(), buildGEMLayers(), GEMDetId::chamber(), checkBounds(), eta_clamp_max_, eta_low_, validate-o2o-wbm::f, dqm::impl::MonitorElement::Fill(), GEMOfflineDQMBase::fillME(), findClosetHit(), findEtaPartition(), gemToken2_, edm::EventSetup::getHandle(), GEMOfflineDQMBase::getReStEtKey(), GEMOfflineDQMBase::getReStKey(), GEMOfflineDQMBase::getReStLaKey(), getStartingState(), getTrack(), globalGeomToken_, TrajectoryStateOnSurface::globalPosition(), GEMEtaPartition::id(), GEMDetId::ieta(), isME11(), edm::ESHandleBase::isValid(), TrajectoryStateOnSurface::isValid(), edm::HandleBase::isValid(), reco::TransientTrack::isValid(), kLogCategory_, phase1PixelTopology::layer, TrajectoryStateOnSurface::localError(), M_PI, me_all_abs_residual_rphi_, me_chamber_, me_chamber_matched_, me_detector_, me_detector_matched_, me_ieta_, me_ieta_matched_, me_muon_eta_, me_muon_eta_matched_, me_muon_phi_, me_muon_phi_matched_, me_muon_pt_, me_muon_pt_matched_, me_prop_chamber_, me_prop_phi_err_, me_prop_r_err_, me_pull_y_, me_residual_rphi_, me_residual_y_, min(), HLT_FULL_cff::muon, muon_service_, muon_token_, GlobalErrorBase< T, ErrorWeightType >::phierr(), LocalTrajectoryError::positionError(), prop_phi_error_cut_, prop_r_error_cut_, MuonServiceProxy::propagator(), HLT_FULL_cff::propagator, pt_clamp_max_, rechit_token_, GlobalErrorBase< T, ErrorWeightType >::rerr(), residual_rphi_cut_, skipLayer(), mathSSE::sqrt(), GeomDet::surface(), GeomDet::toLocal(), HLT_FULL_cff::track, ErrorFrameTransformer::transform(), trasientTrackToken_, MuonServiceProxy::update(), use_only_me11_, use_prop_phi_error_cut_, use_prop_r_error_cut_, use_skip_layer_, PV3DBase< T, PVType, FrameType >::y(), and LocalError::yy().

                                                                                     {
  edm::Handle<GEMRecHitCollection> rechit_collection;
  event.getByToken(rechit_token_, rechit_collection);
  if (not rechit_collection.isValid()) {
    edm::LogError(kLogCategory_) << "GEMRecHitCollection is invalid" << std::endl;
    return;
  }

  edm::Handle<edm::View<reco::Muon> > muon_view;
  event.getByToken(muon_token_, muon_view);
  if (not muon_view.isValid()) {
    edm::LogError(kLogCategory_) << "View<Muon> is invalid" << std::endl;
    return;
  }

  edm::ESHandle<GEMGeometry> gem;
  gem = setup.getHandle(gemToken2_);

  if (not gem.isValid()) {
    edm::LogError(kLogCategory_) << "GEMGeometry is invalid" << std::endl;
    return;
  }

  edm::ESHandle<GlobalTrackingGeometry> global_tracking_geometry;

  global_tracking_geometry = setup.getHandle(globalGeomToken_);

  if (not global_tracking_geometry.isValid()) {
    edm::LogError(kLogCategory_) << "GlobalTrackingGeometry is invalid" << std::endl;
    return;
  }

  edm::ESHandle<TransientTrackBuilder> transient_track_builder;
  transient_track_builder = setup.getHandle(trasientTrackToken_);

  if (not transient_track_builder.isValid()) {
    edm::LogError(kLogCategory_) << "TransientTrackRecord is invalid" << std::endl;
    return;
  }

  muon_service_->update(setup);
  edm::ESHandle<Propagator>&& propagator = muon_service_->propagator("SteppingHelixPropagatorAny");
  if (not propagator.isValid()) {
    edm::LogError(kLogCategory_) << "Propagator is invalid" << std::endl;
    return;
  }

  if (muon_view->empty()) {
    edm::LogInfo(kLogCategory_) << "empty muon collection" << std::endl;
    return;
  }

  const std::vector<GEMLayerData>&& layer_vector = buildGEMLayers(gem);

  for (const reco::Muon& muon : *muon_view) {
    const reco::Track* track = getTrack(muon);
    if (track == nullptr) {
      edm::LogError(kLogCategory_) << "failed to get a muon track" << std::endl;
      continue;
    }

    const reco::TransientTrack&& transient_track = transient_track_builder->build(track);
    if (not transient_track.isValid()) {
      edm::LogError(kLogCategory_) << "failed to build TransientTrack" << std::endl;
      continue;
    }

    for (const GEMLayerData& layer : layer_vector) {
      if (use_skip_layer_ and skipLayer(track, layer)) {
        edm::LogInfo(kLogCategory_) << "skip GEM Layer" << std::endl;
        continue;
      }

      const auto&& [start_state, start_id] = getStartingState(transient_track, layer, global_tracking_geometry);

      if (not start_state.isValid()) {
        edm::LogInfo(kLogCategory_) << "failed to get a starting state" << std::endl;
        continue;
      }

      if (use_only_me11_ and (not isME11(start_id))) {
        edm::LogInfo(kLogCategory_) << "skip a starting state because it is not ME11" << std::endl;
        continue;
      }

      // the trajectory state on the destination surface
      const TrajectoryStateOnSurface&& dest_state = propagator->propagate(start_state, *(layer.disk));
      if (not dest_state.isValid()) {
        edm::LogInfo(kLogCategory_) << "failed to propagate a muon" << std::endl;
        continue;
      }

      const GlobalPoint&& dest_global_pos = dest_state.globalPosition();

      if (not checkBounds(dest_global_pos, (*layer.disk))) {
        edm::LogInfo(kLogCategory_) << "failed to pass checkBounds" << std::endl;
        continue;
      }

      const GEMEtaPartition* eta_partition = findEtaPartition(dest_global_pos, layer.chambers);
      if (eta_partition == nullptr) {
        edm::LogInfo(kLogCategory_) << "failed to find an eta partition" << std::endl;
        continue;
      }

      const BoundPlane& surface = eta_partition->surface();

      const LocalPoint&& dest_local_pos = eta_partition->toLocal(dest_global_pos);
      const LocalError&& dest_local_err = dest_state.localError().positionError();
      const GlobalError& dest_global_err = ErrorFrameTransformer().transform(dest_local_err, surface);

      const double dest_global_r_err = std::sqrt(dest_global_err.rerr(dest_global_pos));
      const double dest_global_phi_err = std::sqrt(dest_global_err.phierr(dest_global_pos));

      const GEMDetId&& gem_id = eta_partition->id();
      const GEMDetId&& rs_key = getReStKey(gem_id);
      const GEMDetId&& rsl_key = getReStLaKey(gem_id);
      const GEMDetId&& rse_key = getReStEtKey(gem_id);

      const int chamber_id = gem_id.chamber();
      const int ieta = gem_id.ieta();

      // FIXME clever way to clamp values?
      me_prop_r_err_->Fill(std::min(dest_global_r_err, 19.999));
      me_prop_phi_err_->Fill(std::min(dest_global_r_err, M_PI - 0.0001));
      me_prop_chamber_[rs_key]->Fill(gem_id.chamber());

      if (use_prop_r_error_cut_ and (dest_global_r_err > prop_r_error_cut_)) {
        edm::LogInfo(kLogCategory_) << "failed to pass a propagation global R error cut" << std::endl;
        continue;
      }

      if (use_prop_phi_error_cut_ and (dest_global_phi_err > prop_phi_error_cut_)) {
        edm::LogInfo(kLogCategory_) << "failed to pass a propagation global phi error cut" << std::endl;
        continue;
      }

      const double muon_pt = std::min(muon.pt(), pt_clamp_max_);
      const double muon_eta = std::clamp(std::fabs(muon.eta()), eta_low_, eta_clamp_max_);

      fillME(me_muon_pt_, rs_key, muon_pt);
      fillME(me_muon_eta_, rs_key, muon_eta);
      fillME(me_muon_phi_, rs_key, muon.phi());

      fillME(me_chamber_, rsl_key, chamber_id);
      fillME(me_ieta_, rsl_key, ieta);
      fillME(me_detector_, rsl_key, chamber_id, ieta);

      const auto&& [hit, residual_rphi] = findClosetHit(dest_global_pos, rechit_collection->get(gem_id), eta_partition);

      if (hit == nullptr) {
        edm::LogInfo(kLogCategory_) << "failed to find a hit" << std::endl;
        continue;
      }

      me_all_abs_residual_rphi_->Fill(std::min(std::abs(residual_rphi), 19.999f));
      if (std::abs(residual_rphi) > residual_rphi_cut_) {
        edm::LogInfo(kLogCategory_) << "failed to pass the residual rphi cut" << std::endl;
        continue;
      }

      fillME(me_muon_pt_matched_, rs_key, muon_pt);
      fillME(me_muon_eta_matched_, rs_key, muon_eta);
      fillME(me_muon_phi_matched_, rs_key, muon.phi());

      fillME(me_chamber_matched_, rsl_key, gem_id.chamber());
      fillME(me_ieta_matched_, rsl_key, gem_id.ieta());
      fillME(me_detector_matched_, rsl_key, gem_id.chamber(), ieta);

      const LocalPoint&& hit_local_pos = hit->localPosition();
      const LocalError&& hit_local_err = hit->localPositionError();

      const float residual_y = dest_local_pos.y() - hit_local_pos.y();
      const float pull_y = residual_y / std::sqrt(dest_local_err.yy() + hit_local_err.yy());

      fillME(me_residual_rphi_, rse_key, residual_rphi);
      fillME(me_residual_y_, rse_key, residual_y);
      fillME(me_pull_y_, rse_key, pull_y);
    }  // layer
  }    // Muon
}

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

private

Definition at line 189 of file GEMEfficiencyAnalyzer.cc.

References dqm::implementation::IBooker::book1D(), bookNumerator1D(), chambers, GEMOfflineDQMBase::checkRefs(), folder_, GEMOfflineDQMBase::getReStLaKey(), GEMUtils::getSuffixName(), GEMUtils::getSuffixTitle(), submitPVResolutionJobs::key, kLogCategory_, me_chamber_, me_chamber_matched_, name_, dqm::impl::MonitorElement::setAxisTitle(), dqm::implementation::NavigatorBase::setCurrentFolder(), skipGEMStation(), and relativeConstraints::station.

Referenced by bookHistograms().

                                                                                                               {
  // TODO Efficiency/Source
  ibooker.setCurrentFolder(folder_ + "/Efficiency");

  for (const GEMStation* station : gem->stations()) {
    const int region_id = station->region();
    const int station_id = station->station();

    if (skipGEMStation(station_id)) {
      continue;
    }

    const std::vector<const GEMSuperChamber*>&& superchambers = station->superChambers();
    if (not checkRefs(superchambers)) {
      edm::LogError(kLogCategory_) << "failed to get a valid vector of GEMSuperChamber ptrs" << std::endl;
      return;
    }

    const int num_chambers = superchambers.size();
    for (const GEMChamber* chamber : superchambers[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, name_.c_str() + title_suffix, num_chambers, 0.5, num_chambers + 0.5);
      me_chamber_[key]->setAxisTitle("Chamber");
      me_chamber_[key]->getTH1F()->SetNdivisions(-num_chambers, "Y");
      for (int binx = 1; binx <= num_chambers; binx++) {
        me_chamber_[key]->setBinLabel(binx, std::to_string(binx));
      }

      me_chamber_matched_[key] = bookNumerator1D(ibooker, me_chamber_[key]);
    }  // layer
  }    // station
}

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

private

Definition at line 267 of file GEMEfficiencyAnalyzer.cc.

References dqm::implementation::IBooker::book2D(), bookNumerator2D(), chambers, GEMOfflineDQMBase::checkRefs(), folder_, GEMOfflineDQMBase::getReStLaKey(), GEMUtils::getSuffixName(), GEMUtils::getSuffixTitle(), submitPVResolutionJobs::key, kLogCategory_, me_detector_, me_detector_matched_, name_, dqm::implementation::NavigatorBase::setCurrentFolder(), GEMOfflineDQMBase::setDetLabelsEta(), skipGEMStation(), and relativeConstraints::station.

Referenced by bookHistograms().

                                                                                                                {
  // TODO Efficiency/Source
  ibooker.setCurrentFolder(folder_ + "/Efficiency");

  for (const GEMStation* station : gem->stations()) {
    const int region_id = station->region();
    const int station_id = station->station();

    if (skipGEMStation(station_id)) {
      continue;
    }

    const std::vector<const GEMSuperChamber*>&& superchambers = station->superChambers();
    if (not checkRefs(superchambers)) {
      edm::LogError(kLogCategory_) << "failed to get a valid vector of GEMSuperChamber ptrs" << std::endl;
      return;
    }

    const int num_ch = superchambers.size();

    for (const GEMChamber* chamber : superchambers[0]->chambers()) {
      const int layer_id = chamber->id().layer();
      const int num_ieta = chamber->nEtaPartitions();

      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_detector_[key] = ibooker.book2D("detector" + name_suffix,
                                         name_.c_str() + title_suffix,
                                         num_ch,
                                         0.5,
                                         num_ch + 0.5,
                                         num_ieta,
                                         0.5,
                                         num_ieta + 0.5);
      setDetLabelsEta(me_detector_[key], station);

      me_detector_matched_[key] = bookNumerator2D(ibooker, me_detector_[key]);
    }  // layer
  }    // station
}

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

private

Definition at line 228 of file GEMEfficiencyAnalyzer.cc.

References dqm::implementation::IBooker::book1D(), bookNumerator1D(), chambers, GEMOfflineDQMBase::checkRefs(), folder_, GEMOfflineDQMBase::getReStLaKey(), GEMUtils::getSuffixName(), GEMUtils::getSuffixTitle(), submitPVResolutionJobs::key, kLogCategory_, me_ieta_, me_ieta_matched_, name_, dqm::impl::MonitorElement::setAxisTitle(), dqm::implementation::NavigatorBase::setCurrentFolder(), skipGEMStation(), and relativeConstraints::station.

Referenced by bookHistograms().

                                                                                            {
  // TODO Efficiency/Source
  ibooker.setCurrentFolder(folder_ + "/Efficiency");

  for (const GEMStation* station : gem->stations()) {
    const int region_id = station->region();
    const int station_id = station->station();

    if (skipGEMStation(station_id)) {
      continue;
    }

    const std::vector<const GEMSuperChamber*>&& superchambers = station->superChambers();
    if (not checkRefs(superchambers)) {
      edm::LogError(kLogCategory_) << "failed to get a valid vector of GEMSuperChamber ptrs" << std::endl;
      return;
    }

    for (const GEMChamber* chamber : superchambers[0]->chambers()) {
      const int layer_id = chamber->id().layer();
      const int num_ieta = chamber->nEtaPartitions();

      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_ieta_[key] = ibooker.book1D("ieta" + name_suffix, name_.c_str() + title_suffix, num_ieta, 0.5, num_ieta + 0.5);
      me_ieta_[key]->setAxisTitle("i#eta");
      me_ieta_[key]->getTH1F()->SetNdivisions(-num_ieta, "Y");
      for (int binx = 1; binx <= num_ieta; binx++) {
        me_ieta_[key]->setBinLabel(binx, std::to_string(binx));
      }

      me_ieta_matched_[key] = bookNumerator1D(ibooker, me_ieta_[key]);
    }  // layer
  }    // station
}

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

private

Definition at line 150 of file GEMEfficiencyAnalyzer.cc.

References dqm::implementation::IBooker::book1D(), bookNumerator1D(), eta_low_, eta_nbins_, eta_up_, folder_, GEMOfflineDQMBase::getReStKey(), GEMUtils::getSuffixName(), GEMUtils::getSuffixTitle(), submitPVResolutionJobs::key, M_PI, me_muon_eta_, me_muon_eta_matched_, me_muon_phi_, me_muon_phi_matched_, me_muon_pt_, me_muon_pt_matched_, name_, pt_bins_, dqm::implementation::NavigatorBase::setCurrentFolder(), skipGEMStation(), relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, and runGCPTkAlMap::title.

Referenced by bookHistograms().

                                                                                                                {
  // TODO Efficiency/Source
  ibooker.setCurrentFolder(folder_ + "/Efficiency");

  const TString pt_x_title = "Muon p_{T} [GeV]";
  const int pt_nbinsx = pt_bins_.size() - 1;

  const std::string eta_x_title = "Muon |#eta|";
  const std::string phi_x_title = "Muon #phi [rad]";

  for (const GEMStation* station : gem->stations()) {
    const int region_id = station->region();
    const int station_id = station->station();

    if (skipGEMStation(station_id)) {
      continue;
    }

    const GEMDetId&& key = getReStKey(region_id, station_id);
    const TString&& name_suffix = GEMUtils::getSuffixName(region_id, station_id);
    const TString&& title_suffix = GEMUtils::getSuffixTitle(region_id, station_id);

    const TString&& title = name_.c_str() + title_suffix;

    TH1F* h_muon_pt = new TH1F("muon_pt" + name_suffix, title, pt_nbinsx, &pt_bins_[0]);
    h_muon_pt->SetXTitle(pt_x_title);
    me_muon_pt_[key] = ibooker.book1D(h_muon_pt->GetName(), h_muon_pt);
    me_muon_pt_matched_[key] = bookNumerator1D(ibooker, me_muon_pt_[key]);

    me_muon_eta_[key] = ibooker.book1D("muon_eta" + name_suffix, title, eta_nbins_, eta_low_, eta_up_);
    me_muon_eta_[key]->setXTitle(eta_x_title);
    me_muon_eta_matched_[key] = bookNumerator1D(ibooker, me_muon_eta_[key]);

    me_muon_phi_[key] = ibooker.book1D("muon_phi" + name_suffix, title, 36, -M_PI, M_PI);
    me_muon_phi_[key]->setAxisTitle(phi_x_title);
    me_muon_phi_matched_[key] = bookNumerator1D(ibooker, me_muon_phi_[key]);
  }  // station
}

void GEMEfficiencyAnalyzer::bookHistograms ( DQMStore::IBooker &  ibooker, edm::Run const &  run, edm::EventSetup const &  isetup  )

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 119 of file GEMEfficiencyAnalyzer.cc.

References bookEfficiencyChamber(), bookEfficiencyDetector(), bookEfficiencyEtaPartition(), bookEfficiencyMomentum(), bookMisc(), bookResolution(), gemToken1_, edm::EventSetup::getHandle(), edm::ESHandleBase::isValid(), and kLogCategory_.

                                                                        {
  edm::ESHandle<GEMGeometry> gem;
  gem = isetup.getHandle(gemToken1_);

  if (not gem.isValid()) {
    edm::LogError(kLogCategory_) << "GEMGeometry is invalid" << std::endl;
    return;
  }

  bookEfficiencyMomentum(ibooker, gem);
  bookEfficiencyChamber(ibooker, gem);
  bookEfficiencyEtaPartition(ibooker, gem);
  bookEfficiencyDetector(ibooker, gem);
  bookResolution(ibooker, gem);
  bookMisc(ibooker, gem);
}

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

private

Definition at line 354 of file GEMEfficiencyAnalyzer.cc.

References dqm::implementation::IBooker::book1D(), GEMOfflineDQMBase::checkRefs(), folder_, GEMOfflineDQMBase::getReStKey(), GEMUtils::getSuffixName(), GEMUtils::getSuffixTitle(), submitPVResolutionJobs::key, kLogCategory_, M_PI, me_all_abs_residual_rphi_, me_prop_chamber_, me_prop_phi_err_, me_prop_r_err_, dqm::implementation::NavigatorBase::setCurrentFolder(), skipGEMStation(), and relativeConstraints::station.

Referenced by bookHistograms().

                                                                                                  {
  ibooker.setCurrentFolder(folder_ + "/Misc");
  // FIXME the range shoule be dependent on the scenario
  me_prop_r_err_ = ibooker.book1D("prop_r_err", ";Propagation Global R Error [cm];Entries", 20, 0.0, 20.0);
  me_prop_phi_err_ = ibooker.book1D("prop_phi_err", "Propagation Global Phi Error [rad];Entries", 20, 0.0, M_PI);
  me_all_abs_residual_rphi_ = ibooker.book1D("all_abs_residual_rphi", ";Residual in R#phi [cm];Entries", 20, 0.0, 20.0);

  for (const GEMStation* station : gem->stations()) {
    const int region_id = station->region();
    const int station_id = station->station();

    if (skipGEMStation(station_id)) {
      continue;
    }

    const std::vector<const GEMSuperChamber*>&& superchambers = station->superChambers();
    if (not checkRefs(superchambers)) {
      edm::LogError(kLogCategory_) << "failed to get a valid vector of GEMSuperChamber ptrs" << std::endl;
      return;
    }
    // ignore layer ids
    const int num_ch = superchambers.size();

    const GEMDetId&& key = getReStKey(region_id, station_id);
    const TString&& name_suffix = GEMUtils::getSuffixName(region_id, station_id);
    const TString&& title_suffix = GEMUtils::getSuffixTitle(region_id, station_id);
    me_prop_chamber_[key] = ibooker.book1D("prop_chamber" + name_suffix, title_suffix, num_ch, 0.5, num_ch + 0.5);
    me_prop_chamber_[key]->setAxisTitle("Destination Chamber Id", 1);
    me_prop_chamber_[key]->setAxisTitle("Entries", 2);
  }  // station
}

dqm::impl::MonitorElement * GEMEfficiencyAnalyzer::bookNumerator1D ( DQMStore::IBooker &  , MonitorElement *    )

private

Definition at line 138 of file GEMEfficiencyAnalyzer.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(), bookEfficiencyEtaPartition(), and bookEfficiencyMomentum().

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

dqm::impl::MonitorElement * GEMEfficiencyAnalyzer::bookNumerator2D ( DQMStore::IBooker &  , MonitorElement *    )

private

Definition at line 144 of file GEMEfficiencyAnalyzer.cc.

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

Referenced by bookEfficiencyDetector().

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

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

private

Definition at line 310 of file GEMEfficiencyAnalyzer.cc.

References dqm::implementation::IBooker::book1D(), chambers, GEMOfflineDQMBase::checkRefs(), folder_, GEMOfflineDQMBase::getReStEtKey(), submitPVResolutionJobs::key, kLogCategory_, me_pull_y_, me_residual_rphi_, me_residual_y_, name_, residual_rphi_cut_, dqm::implementation::NavigatorBase::setCurrentFolder(), skipGEMStation(), relativeConstraints::station, and runGCPTkAlMap::title.

Referenced by bookHistograms().

                                                                                                        {
  ibooker.setCurrentFolder(folder_ + "/Resolution");
  for (const GEMStation* station : gem->stations()) {
    const int region_id = station->region();
    const int station_id = station->station();

    if (skipGEMStation(station_id)) {
      continue;
    }

    const std::vector<const GEMSuperChamber*>&& superchambers = station->superChambers();
    if (not checkRefs(superchambers)) {
      edm::LogError(kLogCategory_) << "failed to get a valid vector of GEMSuperChamber ptrs" << std::endl;
      return;
    }

    const std::vector<const GEMChamber*>& chambers = superchambers[0]->chambers();
    if (not checkRefs(chambers)) {
      edm::LogError(kLogCategory_) << "failed to get a valid vector of GEMChamber ptrs" << std::endl;
      return;
    }

    for (const GEMEtaPartition* eta_partition : chambers[0]->etaPartitions()) {
      const int ieta = eta_partition->id().roll();

      const GEMDetId&& key = getReStEtKey(eta_partition->id());
      // TODO
      const TString&& name_suffix = TString::Format("_GE%+.2d_R%d", region_id * (station_id * 10 + 1), ieta);
      const TString&& title =
          name_.c_str() + TString::Format(" : GE%+.2d Roll %d", region_id * (station_id * 10 + 1), ieta);

      me_residual_rphi_[key] =
          ibooker.book1D("residual_rphi" + name_suffix, title, 50, -residual_rphi_cut_, residual_rphi_cut_);
      me_residual_rphi_[key]->setAxisTitle("Residual in R#phi [cm]");

      me_residual_y_[key] = ibooker.book1D("residual_y" + name_suffix, title, 60, -12.0, 12.0);
      me_residual_y_[key]->setAxisTitle("Residual in Local Y [cm]");

      me_pull_y_[key] = ibooker.book1D("pull_y" + name_suffix, title, 60, -3.0, 3.0);
      me_pull_y_[key]->setAxisTitle("Pull in Local Y");
    }  // ieta
  }    // station
}

std::vector< GEMEfficiencyAnalyzer::GEMLayerData > GEMEfficiencyAnalyzer::buildGEMLayers ( const edm::ESHandle< GEMGeometry > &  gem )

private

Definition at line 597 of file GEMEfficiencyAnalyzer.cc.

References Disk::build(), submitPVResolutionJobs::key, phase1PixelTopology::layer, position, idealTransformation::rotation, skipGEMStation(), and relativeConstraints::station.

Referenced by analyze().

                                         {
  std::vector<GEMLayerData> layer_vector;

  for (const GEMStation* station : gem->stations()) {
    const int region_id = station->region();
    const int station_id = station->station();
    const bool is_ge11 = station_id == 1;

    if (skipGEMStation(station_id)) {
      continue;
    }

    // (layer_id, is_odd) - chambers
    std::map<std::pair<int, bool>, std::vector<const GEMChamber*> > chambers_per_layer;

    for (const GEMSuperChamber* super_chamber : station->superChambers()) {
      // For GE0 and GE21, 'is_odd' is always set to 'false'
      const bool is_odd = is_ge11 ? super_chamber->id().chamber() % 2 == 1 : false;

      for (const GEMChamber* chamber : super_chamber->chambers()) {
        const int layer_id = chamber->id().layer();
        const std::pair<int, bool> key{layer_id, is_odd};

        if (chambers_per_layer.find(key) == chambers_per_layer.end())
          chambers_per_layer.insert({key, std::vector<const GEMChamber*>()});

        chambers_per_layer.at(key).push_back(chamber);
      }  // GEMChamber
    }    // GEMSuperChamber

    for (auto [key, chamber_vector] : chambers_per_layer) {
      const int layer_id = key.first;

      // chambers should have same R and Z spans.
      auto [rmin, rmax] = chamber_vector[0]->surface().rSpan();
      auto [zmin, zmax] = chamber_vector[0]->surface().zSpan();

      // layer position and rotation
      const float layer_z = chamber_vector[0]->position().z();
      Surface::PositionType position{0.f, 0.f, layer_z};
      Surface::RotationType rotation;

      zmin -= layer_z;
      zmax -= layer_z;

      // the bounds from min and max R and Z in the local coordinates.
      SimpleDiskBounds* bounds = new SimpleDiskBounds(rmin, rmax, zmin, zmax);
      const Disk::DiskPointer&& layer = Disk::build(position, rotation, bounds);

      layer_vector.emplace_back(layer, chamber_vector, region_id, station_id, layer_id);
    }  // layer
  }    // GEMStation

  return layer_vector;
}

bool GEMEfficiencyAnalyzer::checkBounds ( const GlobalPoint &  global_point, const Plane &  plane  )

private

Definition at line 767 of file GEMEfficiencyAnalyzer.cc.

References Surface::bounds(), Bounds::inside(), GloballyPositioned< T >::toLocal(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by analyze(), and findEtaPartition().

                                                                                           {
  const LocalPoint&& local_point = plane.toLocal(global_point);
  const LocalPoint local_point_2d(local_point.x(), local_point.y(), 0.0f);
  return plane.bounds().inside(local_point_2d);
}

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

static

Definition at line 55 of file GEMEfficiencyAnalyzer.cc.

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

                                                                                       {
  // beam scenario
  {
    edm::ParameterSetDescription desc;
    desc.addUntracked<std::string>("name", "GlobalMuon");
    desc.addUntracked<std::string>("folder", "GEM/Efficiency/type0");
    desc.add<edm::InputTag>("recHitTag", edm::InputTag("gemRecHits"));
    desc.add<edm::InputTag>("muonTag", edm::InputTag("muons"));
    desc.addUntracked<bool>("isCosmics", false);
    desc.addUntracked<bool>("useGlobalMuon", true);
    desc.add<bool>("useSkipLayer", true);
    desc.add<bool>("useOnlyME11", false);
    desc.add<double>("residualRPhiCut", 2.0);  // TODO need to be tuned
    desc.add<bool>("usePropRErrorCut", false);
    desc.add<double>("propRErrorCut", 1.0);
    desc.add<bool>("usePropPhiErrorCut", false);
    desc.add<double>("propPhiErrorCut", 0.01);
    desc.addUntracked<std::vector<double> >("ptBins", {20., 30., 40., 50., 60., 70., 80., 90., 100., 120.});
    desc.addUntracked<int>("etaNbins", 9);
    desc.addUntracked<double>("etaLow", 1.4);
    desc.addUntracked<double>("etaUp", 2.3);
    desc.addUntracked<bool>("monitorGE11", true);
    desc.addUntracked<bool>("monitorGE21", false);
    desc.addUntracked<bool>("monitorGE0", false);
    {
      edm::ParameterSetDescription psd0;
      psd0.setAllowAnything();
      desc.add<edm::ParameterSetDescription>("ServiceParameters", psd0);
    }
    descriptions.add("gemEfficiencyAnalyzerDefault", desc);
  }  // beam scenario

  // cosmic scenario
  {
    edm::ParameterSetDescription desc;
    desc.addUntracked<std::string>("name", "GlobalMuon");  // FIXME
    desc.addUntracked<std::string>("folder", "GEM/Efficiency/type0");
    desc.add<edm::InputTag>("recHitTag", edm::InputTag("gemRecHits"));
    desc.add<edm::InputTag>("muonTag", edm::InputTag("muons"));
    desc.addUntracked<bool>("isCosmics", true);
    desc.addUntracked<bool>("useGlobalMuon", false);
    desc.add<bool>("useSkipLayer", true);
    desc.add<bool>("useOnlyME11", true);
    desc.add<double>("residualRPhiCut", 5.0);  // TODO need to be tuned
    desc.add<bool>("usePropRErrorCut", true);
    desc.add<double>("propRErrorCut", 1.0);
    desc.add<bool>("usePropPhiErrorCut", true);
    desc.add<double>("propPhiErrorCut", 0.001);
    desc.addUntracked<std::vector<double> >("ptBins", {0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 120.});
    desc.addUntracked<int>("etaNbins", 9);
    desc.addUntracked<double>("etaLow", 1.4);
    desc.addUntracked<double>("etaUp", 2.3);
    desc.addUntracked<bool>("monitorGE11", true);
    desc.addUntracked<bool>("monitorGE21", false);
    desc.addUntracked<bool>("monitorGE0", false);
    {
      edm::ParameterSetDescription psd0;
      psd0.setAllowAnything();
      desc.add<edm::ParameterSetDescription>("ServiceParameters", psd0);
    }
    descriptions.add("gemEfficiencyAnalyzerCosmicsDefault", desc);
  }  // cosmics
}

std::pair< const GEMRecHit *, float > GEMEfficiencyAnalyzer::findClosetHit ( const GlobalPoint &  dest_global_pos, const GEMRecHitCollection::range &  range, const GEMEtaPartition *  eta_partition  )

private

Definition at line 791 of file GEMEfficiencyAnalyzer.cc.

References funct::abs(), funct::cos(), funct::sin(), GEMEtaPartition::specificTopology(), GEMEtaPartition::strip(), StripTopology::stripAngle(), GeomDet::toLocal(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by analyze().

                                                                                                              {
  const StripTopology& topology = eta_partition->specificTopology();
  const LocalPoint&& dest_local_pos = eta_partition->toLocal(dest_global_pos);
  const float dest_local_x = dest_local_pos.x();
  const float dest_local_y = dest_local_pos.y();

  const GEMRecHit* closest_hit = nullptr;
  float min_residual_rphi = 1e6;

  for (auto hit = range.first; hit != range.second; ++hit) {
    const LocalPoint&& hit_local_pos = hit->localPosition();
    const float hit_local_phi = topology.stripAngle(eta_partition->strip(hit_local_pos));

    const float residual_x = dest_local_x - hit_local_pos.x();
    const float residual_y = dest_local_y - hit_local_pos.y();
    const float residual_rphi = std::cos(hit_local_phi) * residual_x + std::sin(hit_local_phi) * residual_y;

    if (std::abs(residual_rphi) < std::abs(min_residual_rphi)) {
      min_residual_rphi = residual_rphi;
      closest_hit = &(*hit);
    }
  }

  return std::make_pair(closest_hit, min_residual_rphi);
}

const GEMEtaPartition * GEMEfficiencyAnalyzer::findEtaPartition ( const GlobalPoint &  global_point, const std::vector< const GEMChamber * > &  chamber_vector  )

private

Definition at line 773 of file GEMEfficiencyAnalyzer.cc.

References checkBounds().

Referenced by analyze().

                                                                                                                   {
  const GEMEtaPartition* bound = nullptr;
  for (const GEMChamber* chamber : chamber_vector) {
    if (not checkBounds(global_point, chamber->surface()))
      continue;

    for (const GEMEtaPartition* eta_partition : chamber->etaPartitions()) {
      if (checkBounds(global_point, eta_partition->surface())) {
        bound = eta_partition;
        break;
      }
    }  // GEMEtaPartition
  }    // GEMChamber

  return bound;
}

std::pair< TrajectoryStateOnSurface, DetId > GEMEfficiencyAnalyzer::findStartingState ( const reco::TransientTrack &  transient_track, const GEMLayerData &  layer, const edm::ESHandle< GlobalTrackingGeometry > &  geometry  )

private

Definition at line 704 of file GEMEfficiencyAnalyzer.cc.

References funct::abs(), GEMEfficiencyAnalyzer::GEMLayerData::disk, HLT_FULL_cff::distance, newFWLiteAna::found, MuonHitHelper::isGEM(), DetId::rawId(), reco::TransientTrack::recHitsBegin(), reco::TransientTrack::recHitsEnd(), reco::TransientTrack::stateOnSurface(), and GeomDet::toGlobal().

Referenced by getStartingState().

                                                         {
  GlobalPoint starting_point;
  DetId starting_id;
  float min_distance = 1e12;
  bool found = false;

  // TODO optimize this loop because hits should be ordered..
  for (auto rechit = transient_track.recHitsBegin(); rechit != transient_track.recHitsEnd(); rechit++) {
    const DetId&& det_id = (*rechit)->geographicalId();

    if (MuonHitHelper::isGEM(det_id.rawId())) {
      continue;
    }

    const GeomDet* det = geometry->idToDet(det_id);
    const GlobalPoint&& global_position = det->toGlobal((*rechit)->localPosition());
    const float distance = std::abs(layer.disk->localZclamped(global_position));
    if (distance < min_distance) {
      found = true;
      min_distance = distance;
      starting_point = global_position;
      starting_id = det_id;
    }
  }

  TrajectoryStateOnSurface starting_state;
  if (found) {
    starting_state = transient_track.stateOnSurface(starting_point);
  }
  return std::make_pair(starting_state, starting_id);
}

std::pair< TrajectoryStateOnSurface, DetId > GEMEfficiencyAnalyzer::getStartingState ( const reco::TransientTrack &  transient_track, const GEMLayerData &  layer, const edm::ESHandle< GlobalTrackingGeometry > &  geometry  )

private

Definition at line 673 of file GEMEfficiencyAnalyzer.cc.

References findStartingState(), reco::Track::innerDetId(), reco::TransientTrack::innermostMeasurementState(), MuonHitHelper::isGEM(), isInsideOut(), reco::Track::outerDetId(), reco::TransientTrack::outermostMeasurementState(), reco::TransientTrack::track(), HLT_FULL_cff::track, and use_global_muon_.

Referenced by analyze().

                                                         {
  TrajectoryStateOnSurface starting_state;
  DetId starting_id;

  if (use_global_muon_) {
    std::tie(starting_state, starting_id) = findStartingState(transient_track, layer, geometry);

  } else {
    // if outer track
    const reco::Track& track = transient_track.track();
    const bool is_insideout = isInsideOut(track);

    const DetId inner_id{(is_insideout ? track.outerDetId() : track.innerDetId())};
    if (MuonHitHelper::isGEM(inner_id.rawId())) {
      std::tie(starting_state, starting_id) = findStartingState(transient_track, layer, geometry);

    } else {
      starting_id = inner_id;
      if (is_insideout)
        starting_state = transient_track.outermostMeasurementState();
      else
        starting_state = transient_track.innermostMeasurementState();
    }
  }

  return std::make_pair(starting_state, starting_id);
}

const reco::Track * GEMEfficiencyAnalyzer::getTrack ( const reco::Muon &  muon )

private

Definition at line 654 of file GEMEfficiencyAnalyzer.cc.

References edm::Ref< C, T, F >::get(), reco::Muon::globalTrack(), is_cosmics_, edm::Ref< C, T, F >::isNonnull(), reco::Muon::outerTrack(), HLT_FULL_cff::track, and use_global_muon_.

Referenced by analyze().

                                                                     {
  const reco::Track* track = nullptr;

  if (is_cosmics_) {
    if (muon.outerTrack().isNonnull())
      track = muon.outerTrack().get();

  } else {
    // beams, i.e. pp or heavy ions
    if (use_global_muon_ and muon.globalTrack().isNonnull())
      track = muon.globalTrack().get();

    else if ((not use_global_muon_) and muon.outerTrack().isNonnull())
      track = muon.outerTrack().get();
  }

  return track;
}

bool GEMEfficiencyAnalyzer::isInsideOut ( const reco::Track &  track )

inlineprivate

Definition at line 138 of file GEMEfficiencyAnalyzer.h.

References reco::Track::innerPosition(), and reco::Track::outerPosition().

Referenced by getStartingState(), and skipLayer().

                                                                     {
  return track.innerPosition().mag2() > track.outerPosition().mag2();
}

bool GEMEfficiencyAnalyzer::isME11 ( const DetId &  det_id )

private

Definition at line 739 of file GEMEfficiencyAnalyzer.cc.

References MuonHitHelper::isCSC(), and or.

Referenced by analyze().

                                                      {
  if (not MuonHitHelper::isCSC(det_id))
    return false;
  const CSCDetId csc_id{det_id};
  return (csc_id.station() == 1) or ((csc_id.ring() == 1) or (csc_id.ring() == 4));
}

bool GEMEfficiencyAnalyzer::skipGEMStation ( const int  station )

private

Definition at line 568 of file GEMEfficiencyAnalyzer.cc.

References kLogCategory_, LogDebug, monitor_ge0_, monitor_ge11_, monitor_ge21_, and createPayload::skip.

Referenced by bookEfficiencyChamber(), bookEfficiencyDetector(), bookEfficiencyEtaPartition(), bookEfficiencyMomentum(), bookMisc(), bookResolution(), and buildGEMLayers().

                                                            {
  bool skip = false;

  if (station == 1) {
    if (not monitor_ge11_) {
      LogDebug(kLogCategory_) << "skip GE11 because monitorGE11 is " << std::boolalpha << monitor_ge11_;
      skip = true;
    }

  } else if (station == 2) {
    if (not monitor_ge21_) {
      LogDebug(kLogCategory_) << "skip GE21 because monitorGE21 is " << std::boolalpha << monitor_ge21_;
      skip = true;
    }

  } else if (station == 0) {
    if (not monitor_ge0_) {
      LogDebug(kLogCategory_) << "skip GE0 because monitorGE0 is " << std::boolalpha << monitor_ge0_;
      skip = true;
    }

  } else {
    edm::LogError(kLogCategory_) << "got an unexpected GEM station " << station << ". skip this station.";
    skip = true;
  }

  return skip;
}

bool GEMEfficiencyAnalyzer::skipLayer ( const reco::Track *  track, const GEMLayerData &  layer  )

private

Definition at line 746 of file GEMEfficiencyAnalyzer.cc.

References reco::TrackBase::eta(), reco::Track::innerMomentum(), is_cosmics_, isInsideOut(), reco::Track::outerMomentum(), GEMEfficiencyAnalyzer::GEMLayerData::region, createPayload::skip, and std::swap().

Referenced by analyze().

                                                                                       {
  const bool is_same_region = track->eta() * layer.region > 0;

  bool skip = false;
  if (is_cosmics_) {
    float p2_in = track->innerMomentum().mag2();
    float p2_out = track->outerMomentum().mag2();
    if (isInsideOut(*track))
      std::swap(p2_in, p2_out);
    const bool is_outgoing = p2_in > p2_out;

    skip = (is_outgoing xor is_same_region);

  } else {
    // beam scenario
    skip = not is_same_region;
  }

  return skip;
}

Member Data Documentation

double GEMEfficiencyAnalyzer::eta_clamp_max_

private

Definition at line 108 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().

double GEMEfficiencyAnalyzer::eta_low_

private

Definition at line 99 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), bookEfficiencyMomentum(), and GEMEfficiencyAnalyzer().

int GEMEfficiencyAnalyzer::eta_nbins_

private

Definition at line 98 of file GEMEfficiencyAnalyzer.h.

Referenced by bookEfficiencyMomentum(), and GEMEfficiencyAnalyzer().

double GEMEfficiencyAnalyzer::eta_up_

private

Definition at line 100 of file GEMEfficiencyAnalyzer.h.

Referenced by bookEfficiencyMomentum(), and GEMEfficiencyAnalyzer().

std::string GEMEfficiencyAnalyzer::folder_

private

Definition at line 85 of file GEMEfficiencyAnalyzer.h.

Referenced by bookEfficiencyChamber(), bookEfficiencyDetector(), bookEfficiencyEtaPartition(), bookEfficiencyMomentum(), bookMisc(), bookResolution(), and GEMEfficiencyAnalyzer().

const edm::ESGetToken<GEMGeometry, MuonGeometryRecord> GEMEfficiencyAnalyzer::gemToken1_

private

Definition at line 47 of file GEMEfficiencyAnalyzer.h.

Referenced by bookHistograms().

const edm::ESGetToken<GEMGeometry, MuonGeometryRecord> GEMEfficiencyAnalyzer::gemToken2_

private

Definition at line 48 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze().

const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> GEMEfficiencyAnalyzer::globalGeomToken_

private

Definition at line 49 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze().

bool GEMEfficiencyAnalyzer::is_cosmics_

private

Definition at line 88 of file GEMEfficiencyAnalyzer.h.

Referenced by GEMEfficiencyAnalyzer(), getTrack(), and skipLayer().

const std::string GEMEfficiencyAnalyzer::kLogCategory_ = "GEMEfficiencyAnalyzer"

private

Definition at line 135 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), bookEfficiencyChamber(), bookEfficiencyDetector(), bookEfficiencyEtaPartition(), bookHistograms(), bookMisc(), bookResolution(), and skipGEMStation().

MonitorElement* GEMEfficiencyAnalyzer::me_all_abs_residual_rphi_

private

Definition at line 131 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookMisc().

MEMap GEMEfficiencyAnalyzer::me_chamber_

private

Definition at line 118 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyChamber().

MEMap GEMEfficiencyAnalyzer::me_chamber_matched_

private

Definition at line 119 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyChamber().

MEMap GEMEfficiencyAnalyzer::me_detector_

private

Definition at line 122 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyDetector().

MEMap GEMEfficiencyAnalyzer::me_detector_matched_

private

Definition at line 123 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyDetector().

MEMap GEMEfficiencyAnalyzer::me_ieta_

private

Definition at line 120 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyEtaPartition().

MEMap GEMEfficiencyAnalyzer::me_ieta_matched_

private

Definition at line 121 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyEtaPartition().

MEMap GEMEfficiencyAnalyzer::me_muon_eta_

private

Definition at line 114 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyMomentum().

MEMap GEMEfficiencyAnalyzer::me_muon_eta_matched_

private

Definition at line 115 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyMomentum().

MEMap GEMEfficiencyAnalyzer::me_muon_phi_

private

Definition at line 116 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyMomentum().

MEMap GEMEfficiencyAnalyzer::me_muon_phi_matched_

private

Definition at line 117 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyMomentum().

MEMap GEMEfficiencyAnalyzer::me_muon_pt_

private

Definition at line 112 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyMomentum().

MEMap GEMEfficiencyAnalyzer::me_muon_pt_matched_

private

Definition at line 113 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookEfficiencyMomentum().

MEMap GEMEfficiencyAnalyzer::me_prop_chamber_

private

Definition at line 132 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookMisc().

MonitorElement* GEMEfficiencyAnalyzer::me_prop_phi_err_

private

Definition at line 130 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookMisc().

MonitorElement* GEMEfficiencyAnalyzer::me_prop_r_err_

private

Definition at line 129 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookMisc().

MEMap GEMEfficiencyAnalyzer::me_pull_y_

private

Definition at line 127 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookResolution().

MEMap GEMEfficiencyAnalyzer::me_residual_rphi_

private

Definition at line 125 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookResolution().

MEMap GEMEfficiencyAnalyzer::me_residual_y_

private

Definition at line 126 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookResolution().

bool GEMEfficiencyAnalyzer::monitor_ge0_

private

Definition at line 103 of file GEMEfficiencyAnalyzer.h.

Referenced by GEMEfficiencyAnalyzer(), and skipGEMStation().

bool GEMEfficiencyAnalyzer::monitor_ge11_

private

Definition at line 101 of file GEMEfficiencyAnalyzer.h.

Referenced by GEMEfficiencyAnalyzer(), and skipGEMStation().

bool GEMEfficiencyAnalyzer::monitor_ge21_

private

Definition at line 102 of file GEMEfficiencyAnalyzer.h.

Referenced by GEMEfficiencyAnalyzer(), and skipGEMStation().

MuonServiceProxy* GEMEfficiencyAnalyzer::muon_service_

private

Definition at line 106 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().

edm::EDGetTokenT<edm::View<reco::Muon> > GEMEfficiencyAnalyzer::muon_token_

private

Definition at line 87 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().

std::string GEMEfficiencyAnalyzer::name_

private

Definition at line 84 of file GEMEfficiencyAnalyzer.h.

Referenced by bookEfficiencyChamber(), bookEfficiencyDetector(), bookEfficiencyEtaPartition(), bookEfficiencyMomentum(), bookResolution(), and GEMEfficiencyAnalyzer().

double GEMEfficiencyAnalyzer::prop_phi_error_cut_

private

Definition at line 96 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().

double GEMEfficiencyAnalyzer::prop_r_error_cut_

private

Definition at line 94 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().

std::vector<double> GEMEfficiencyAnalyzer::pt_bins_

private

Definition at line 97 of file GEMEfficiencyAnalyzer.h.

Referenced by bookEfficiencyMomentum(), and GEMEfficiencyAnalyzer().

double GEMEfficiencyAnalyzer::pt_clamp_max_

private

Definition at line 107 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().

edm::EDGetTokenT<GEMRecHitCollection> GEMEfficiencyAnalyzer::rechit_token_

private

Definition at line 86 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().

float GEMEfficiencyAnalyzer::residual_rphi_cut_

private

Definition at line 92 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), bookResolution(), and GEMEfficiencyAnalyzer().

const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> GEMEfficiencyAnalyzer::trasientTrackToken_

private

Definition at line 50 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze().

bool GEMEfficiencyAnalyzer::use_global_muon_

private

Definition at line 89 of file GEMEfficiencyAnalyzer.h.

Referenced by GEMEfficiencyAnalyzer(), getStartingState(), and getTrack().

bool GEMEfficiencyAnalyzer::use_only_me11_

private

Definition at line 91 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().

bool GEMEfficiencyAnalyzer::use_prop_phi_error_cut_

private

Definition at line 95 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().

bool GEMEfficiencyAnalyzer::use_prop_r_error_cut_

private

Definition at line 93 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().

bool GEMEfficiencyAnalyzer::use_skip_layer_

private

Definition at line 90 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and GEMEfficiencyAnalyzer().