#include <GEMEfficiencyAnalyzer.h>

Inheritance diagram for GEMEfficiencyAnalyzer:

Classes
struct	GEMLayer

Public Types
enum	MatchingMetric { MatchingMetric::kDeltaPhi = 0, MatchingMetric::kRdPhi }

enum	ScenarioOption { ScenarioOption::kPP = 0, ScenarioOption::kCosmics, ScenarioOption::kHeavyIons }

using	StartingState = std::tuple< bool, TrajectoryStateOnSurface, DetId >

enum	StartingStateType { StartingStateType::kOutermostMeasurementState = 0, StartingStateType::kInnermostMeasurementState, StartingStateType::kStateOnSurfaceWithCSCSegment, StartingStateType::kAlignmentStyle }

Public Types inherited from GEMDQMEfficiencySourceBase
using	MEMap = std::map< GEMDetId, 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 Member Functions
	GEMEfficiencyAnalyzer (const edm::ParameterSet &)

	~GEMEfficiencyAnalyzer () override

Public Member Functions inherited from GEMDQMEfficiencySourceBase
MonitorElement *	bookChamber (DQMStore::IBooker &, const TString &, const TString &, const GEMStation *)

MonitorElement *	bookChamberEtaPartition (DQMStore::IBooker &, const TString &, const TString &, const GEMStation *)

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

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

template<typename T >
bool	checkRefs (const std::vector< T *> &)

double	clampWithAxis (const double, const TAxis *axis)

void	fillME (MEMap &, const GEMDetId &, const double)

void	fillME (MEMap &, const GEMDetId &, const double, const double)

void	fillMEWithinLimits (MonitorElement *, const double)

void	fillMEWithinLimits (MonitorElement *, const double, const double)

void	fillMEWithinLimits (MEMap &, const GEMDetId &, const double)

void	fillMEWithinLimits (MEMap &, const GEMDetId &, const double, const double)

	GEMDQMEfficiencySourceBase (const edm::ParameterSet &)

std::tuple< bool, int, int >	getChamberRange (const GEMStation *)

std::tuple< bool, int, int >	getEtaPartitionRange (const GEMStation *)

GEMDetId	getKey (const GEMDetId &)

GEMDetId	getReStEtKey (const GEMDetId &)

GEMDetId	getReStKey (const int, const int)

GEMDetId	getReStKey (const GEMDetId &)

GEMDetId	getReStLaChKey (const GEMDetId &)

GEMDetId	getReStLaKey (const GEMDetId &)

bool	hasMEKey (const MEMap &, const GEMDetId &)

bool	maskChamberWithError (const GEMDetId &chamber_id, const GEMOHStatusCollection , const GEMVFATStatusCollection )

std::string	nameNumerator (const std::string &)

bool	skipGEMStation (const int)

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

	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

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

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Private Member Functions
void	buildGEMLayers (const GEMGeometry *)

StartingState	buildStartingState (const reco::Muon &, const reco::TransientTrack &, const GEMLayer &)

StartingState	buildStartingStateAlignmentStyle (const reco::Muon &, const reco::TransientTrack &, const GEMLayer &)

StartingState	buildStateOnSurfaceWithCSCSegment (const reco::Muon &, const reco::TransientTrack &, const GEMLayer &)

bool	checkBounds (const Plane &, const GlobalPoint &)

bool	checkBounds (const Plane &, const GlobalPoint &, const GlobalError &, float)

bool	checkPropagationDirection (const reco::Track *, const GEMLayer &)

float	computeDeltaPhi (const GlobalPoint &, const LocalPoint &, const GEMEtaPartition *)

float	computeMatchingMetric (const GlobalPoint &, const LocalPoint &, const GEMEtaPartition *)

float	computeRdPhi (const GlobalPoint &, const LocalPoint &, const GEMEtaPartition *)

std::pair< const GEMRecHit *, float >	findClosestHit (const GlobalPoint &, const GEMRecHitCollection::range &, const GEMEtaPartition *)

const CSCSegment *	findCSCSegment (const reco::Muon &, const reco::TransientTrack &, const GEMLayer &)

const CSCSegment *	findCSCSegmentBeam (const reco::TransientTrack &, const GEMLayer &)

const CSCSegment *	findCSCSegmentCosmics (const reco::Muon &, const GEMLayer &)

const GEMEtaPartition *	findEtaPartition (const GlobalPoint &, const GlobalError &, const std::vector< const GEMChamber *> &)

StartingState	getInnermostMeasurementState (const reco::TransientTrack &)

MatchingMetric	getMatchingMetric (const std::string)

reco::Muon::MuonTrackType	getMuonTrackType (const std::string)

StartingState	getOutermostMeasurementState (const reco::TransientTrack &)

ScenarioOption	getScenarioOption (const std::string)

StartingStateType	getStartingStateType (const std::string)

bool	isCSCAllowed (const CSCDetId &, const int)

bool	isInsideOut (const reco::Track &)

bool	isMuonSubdetAllowed (const DetId &, const int)

Private Attributes
std::vector< GEMLayer >	gem_layers_

const float	kBoundsErrorScale_

const std::vector< std::vector< int > >	kCSCForGEM_

const int	kCSCSegmentDimension_ = 4

const std::string	kFolder_

const edm::ESGetToken< GEMGeometry, MuonGeometryRecord >	kGEMGeometryTokenBeginRun_

const edm::EDGetTokenT< GEMRecHitCollection >	kGEMRecHitCollectionToken_

const float	kMatchingCut_

const MatchingMetric	kMatchingMetric_

const bool	kModeDev_

const std::vector< double >	kMuonEtaLow_

const std::vector< double >	kMuonEtaMaxCuts_

const std::vector< double >	kMuonEtaMinCuts_

const std::vector< int >	kMuonEtaNbins_

const std::vector< double >	kMuonEtaUp_

const TString	kMuonName_

const std::vector< double >	kMuonPtBins_

const std::vector< double >	kMuonPtMinCuts_

const float	kMuonSegmentMatchDRCut_

const std::vector< std::vector< int > >	kMuonSubdetForGEM_

const reco::Muon::MuonTrackType	kMuonTrackType_

const std::string	kMuonTrackTypeName_

const edm::EDGetTokenT< edm::View< reco::Muon > >	kMuonViewToken_

const float	kPropagationErrorPhiCut_

const float	kPropagationErrorRCut_

const ScenarioOption	kScenario_

const StartingStateType	kStartingStateType_

const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	kTransientTrackBuilderToken_

MEMap	me_chamber_ieta_

MEMap	me_chamber_ieta_matched_

MEMap	me_cutflow_

MEMap	me_cutflow_matched_

MEMap	me_matching_metric_

MEMap	me_matching_metric_all_

MEMap	me_muon_charge_

MEMap	me_muon_charge_matched_

MEMap	me_muon_eta_

MEMap	me_muon_eta_all_

MEMap	me_muon_eta_all_matched_

MEMap	me_muon_eta_matched_

MEMap	me_muon_phi_

MEMap	me_muon_phi_matched_

MEMap	me_muon_pt_

MEMap	me_muon_pt_all_

MEMap	me_muon_pt_all_matched_

MEMap	me_muon_pt_matched_

MEMap	me_prop_err_phi_

MEMap	me_prop_err_phi_matched_

MEMap	me_prop_err_r_

MEMap	me_prop_err_r_matched_

MEMap	me_prop_path_length_

MEMap	me_prop_path_length_matched_

MEMap	me_residual_phi_

MEMap	me_residual_phi_antimuon_

MEMap	me_residual_phi_muon_

MEMap	me_residual_strip_

MEMap	me_residual_x_

MEMap	me_residual_y_

std::unique_ptr< MuonServiceProxy >	muon_service_

Additional Inherited Members
Public Attributes inherited from GEMDQMEfficiencySourceBase
const edm::EDGetTokenT< GEMOHStatusCollection >	kGEMOHStatusCollectionToken_

const edm::EDGetTokenT< GEMVFATStatusCollection >	kGEMVFATStatusCollectionToken_

const std::string	kLogCategory_

const bool	kMaskChamberWithError_

const bool	kMonitorGE0_

const bool	kMonitorGE11_

const bool	kMonitorGE21_

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

TODO muonEta{Min,Max}Cut{GE11,GE21,GE0} depending on a magnetic field for a cosmic scenario TODO cscForGE21, cscForGE0 TODO use "StraightLinePropagator" if B=0 for a cosmic scenario

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

Definition at line 31 of file GEMEfficiencyAnalyzer.h.

Member Typedef Documentation

◆ StartingState

using GEMEfficiencyAnalyzer::StartingState = std::tuple<bool, TrajectoryStateOnSurface, DetId>

Definition at line 66 of file GEMEfficiencyAnalyzer.h.

Member Enumeration Documentation

◆ MatchingMetric

enum GEMEfficiencyAnalyzer::MatchingMetric

strong

Enumerator
kDeltaPhi
kRdPhi

Definition at line 46 of file GEMEfficiencyAnalyzer.h.

                             {
     kDeltaPhi = 0,  // computeDeltaPhi
     kRdPhi,         // computeRdPhi
   };

◆ ScenarioOption

enum GEMEfficiencyAnalyzer::ScenarioOption

strong

Enumerator
kPP
kCosmics
kHeavyIons

Definition at line 52 of file GEMEfficiencyAnalyzer.h.

                             {
     kPP = 0,
     kCosmics,
     kHeavyIons,
   };

◆ StartingStateType

enum GEMEfficiencyAnalyzer::StartingStateType

strong

Enumerator
kOutermostMeasurementState
kInnermostMeasurementState
kStateOnSurfaceWithCSCSegment
kAlignmentStyle

Definition at line 38 of file GEMEfficiencyAnalyzer.h.

                                {
     kOutermostMeasurementState = 0,
     kInnermostMeasurementState,
     kStateOnSurfaceWithCSCSegment,
     kAlignmentStyle,
   };

Constructor & Destructor Documentation

◆ GEMEfficiencyAnalyzer()

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

explicit

Definition at line 13 of file GEMEfficiencyAnalyzer.cc.

References edm::ParameterSet::getUntrackedParameter().

     : GEMDQMEfficiencySourceBase(ps),
       kGEMGeometryTokenBeginRun_(esConsumes<edm::Transition::BeginRun>()),
       kTransientTrackBuilderToken_(
           esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"))),
       kGEMRecHitCollectionToken_(consumes<GEMRecHitCollection>(ps.getUntrackedParameter<edm::InputTag>("recHitTag"))),
       kMuonViewToken_(consumes<edm::View<reco::Muon> >(ps.getUntrackedParameter<edm::InputTag>("muonTag"))),
       kMuonTrackTypeName_(ps.getUntrackedParameter<std::string>("muonTrackType")),
       kMuonTrackType_(getMuonTrackType(kMuonTrackTypeName_)),
       kMuonName_(TString(ps.getUntrackedParameter<std::string>("muonName"))),
       kFolder_(ps.getUntrackedParameter<std::string>("folder")),
       kScenario_(getScenarioOption(ps.getUntrackedParameter<std::string>("scenario"))),
       kStartingStateType_(getStartingStateType(ps.getUntrackedParameter<std::string>("startingStateType"))),
       kMuonSubdetForGEM_({
           ps.getUntrackedParameter<std::vector<int> >("muonSubdetForGE0"),
           ps.getUntrackedParameter<std::vector<int> >("muonSubdetForGE11"),
           ps.getUntrackedParameter<std::vector<int> >("muonSubdetForGE21"),
       }),
       kCSCForGEM_({
           ps.getUntrackedParameter<std::vector<int> >("cscForGE0"),
           ps.getUntrackedParameter<std::vector<int> >("cscForGE11"),
           ps.getUntrackedParameter<std::vector<int> >("cscForGE21"),
       }),
       kMuonSegmentMatchDRCut_(static_cast<float>(ps.getUntrackedParameter<double>("muonSegmentMatchDRCut"))),
       kMuonPtMinCuts_({
           ps.getUntrackedParameter<double>("muonPtMinCutGE0"),
           ps.getUntrackedParameter<double>("muonPtMinCutGE11"),
           ps.getUntrackedParameter<double>("muonPtMinCutGE21"),
       }),
       kMuonEtaMinCuts_({
           ps.getUntrackedParameter<double>("muonEtaMinCutGE0"),
           ps.getUntrackedParameter<double>("muonEtaMinCutGE11"),
           ps.getUntrackedParameter<double>("muonEtaMinCutGE21"),
       }),
       kMuonEtaMaxCuts_({
           ps.getUntrackedParameter<double>("muonEtaMaxCutGE0"),
           ps.getUntrackedParameter<double>("muonEtaMaxCutGE11"),
           ps.getUntrackedParameter<double>("muonEtaMaxCutGE21"),
       }),
       kPropagationErrorRCut_(static_cast<float>(ps.getUntrackedParameter<double>("propagationErrorRCut"))),
       kPropagationErrorPhiCut_(static_cast<float>(ps.getUntrackedParameter<double>("propagationErrorPhiCut"))),
       kBoundsErrorScale_(static_cast<float>(ps.getUntrackedParameter<double>("boundsErrorScale"))),
       kMatchingMetric_(getMatchingMetric(ps.getUntrackedParameter<std::string>("matchingMetric"))),
       kMatchingCut_(static_cast<float>(ps.getUntrackedParameter<double>("matchingCut"))),
       kMuonPtBins_(ps.getUntrackedParameter<std::vector<double> >("muonPtBins")),
       kMuonEtaNbins_({
           ps.getUntrackedParameter<int>("muonEtaNbinsGE0"),
           ps.getUntrackedParameter<int>("muonEtaNbinsGE11"),
           ps.getUntrackedParameter<int>("muonEtaNbinsGE21"),
       }),
       kMuonEtaLow_({
           ps.getUntrackedParameter<double>("muonEtaLowGE0"),
           ps.getUntrackedParameter<double>("muonEtaLowGE11"),
           ps.getUntrackedParameter<double>("muonEtaLowGE21"),
       }),
       kMuonEtaUp_({
           ps.getUntrackedParameter<double>("muonEtaUpGE0"),
           ps.getUntrackedParameter<double>("muonEtaUpGE11"),
           ps.getUntrackedParameter<double>("muonEtaUpGE21"),
       }),
       kModeDev_(ps.getUntrackedParameter<bool>("modeDev")) {
   muon_service_ =
       std::make_unique<MuonServiceProxy>(ps.getParameter<edm::ParameterSet>("ServiceParameters"), consumesCollector());
 }

◆ ~GEMEfficiencyAnalyzer()

GEMEfficiencyAnalyzer::~GEMEfficiencyAnalyzer ( )

override

Definition at line 78 of file GEMEfficiencyAnalyzer.cc.

78 {}

Member Function Documentation

◆ analyze()

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 960 of file GEMEfficiencyAnalyzer.cc.

                                                                                      {
   // get data from Event
   const GEMRecHitCollection* rechit_collection = nullptr;
   if (auto handle = event.getHandle(kGEMRecHitCollectionToken_)) {
     rechit_collection = handle.product();
   } else {
     edm::LogError(kLogCategory_) << "failed to get GEMRecHitCollection";
     return;
   }
 
   const edm::View<reco::Muon>* muon_view = nullptr;
   if (auto handle = event.getHandle(kMuonViewToken_)) {
     muon_view = handle.product();
   } else {
     edm::LogError(kLogCategory_) << "failed to get View<Muon>";
     return;
   }
 
   const GEMOHStatusCollection* oh_status_collection = nullptr;
   const GEMVFATStatusCollection* vfat_status_collection = nullptr;
   if (kMaskChamberWithError_) {
     if (auto handle = event.getHandle(kGEMOHStatusCollectionToken_)) {
       oh_status_collection = handle.product();
     } else {
       edm::LogError(kLogCategory_) << "failed to get OHVFATStatusCollection";
       return;
     }
 
     if (auto handle = event.getHandle(kGEMVFATStatusCollectionToken_)) {
       vfat_status_collection = handle.product();
     } else {
       edm::LogError(kLogCategory_) << "failed to get GEMVFATStatusCollection";
       return;
     }
   }
 
   // get data from EventSetup
   const TransientTrackBuilder* transient_track_builder = nullptr;
   if (auto handle = setup.getHandle(kTransientTrackBuilderToken_)) {
     transient_track_builder = handle.product();
   } else {
     edm::LogError(kLogCategory_) << "failed to get TransientTrackBuilder";
     return;
   }
 
   // get more data from EventSetup using MuonServiceProxy
   muon_service_->update(setup);
 
   // TODO StraightLinePropagator if B < epsilon else SteppingHelixPropagatorAny
   const Propagator* propagator = nullptr;
   if (auto handle = muon_service_->propagator("SteppingHelixPropagatorAny")) {
     propagator = handle.product();
   } else {
     edm::LogError(kLogCategory_) << "failed to get Propagator";
     return;
   }
 
   //  Main loop
 
   for (const reco::Muon& muon : *muon_view) {
     const reco::Track* track = muon.muonTrack(kMuonTrackType_).get();
     if (track == nullptr) {
       LogDebug(kLogCategory_) << "failed to get a " << kMuonTrackTypeName_;
       continue;
     }
 
     const reco::TransientTrack transient_track = transient_track_builder->build(track);
     if (not transient_track.isValid()) {
       edm::LogError(kLogCategory_) << "failed to build TransientTrack";
       continue;
     }
 
     for (const GEMLayer& layer : gem_layers_) {
       if (checkPropagationDirection(track, layer)) {
         LogDebug(kLogCategory_) << "bad flight path. skip this propagation.";
         continue;
       }
 
       const auto [found_start_state, start_state, start_id] = buildStartingState(muon, transient_track, layer);
       if (not found_start_state) {
         LogDebug(kLogCategory_) << "propagation starting state not found";
         continue;
       }
 
       // the trajectory state on the destination surface
       const auto [propagated_state, prop_path_length] = propagator->propagateWithPath(start_state, *(layer.disk));
       if (not propagated_state.isValid()) {
         LogDebug(kLogCategory_) << "failed to propagate a muon from "
                                 << Form("(Detector, Subdetector) = (%d, %d)",
                                         static_cast<int>(start_id.det()),
                                         start_id.subdetId())
                                 << " to " << layer.id << ". The path length is " << prop_path_length;
         continue;
       }
 
       const GlobalPoint prop_global_pos = propagated_state.globalPosition();
       const GlobalError& prop_global_err =
           ErrorFrameTransformer::transform(propagated_state.localError().positionError(), *layer.disk);
 
       if (not checkBounds(*layer.disk, prop_global_pos, prop_global_err, kBoundsErrorScale_)) {
         LogDebug(kLogCategory_) << "failed to pass checkBounds";
         continue;
       }
 
       const GEMEtaPartition* eta_partition = findEtaPartition(prop_global_pos, prop_global_err, layer.chambers);
       if (eta_partition == nullptr) {
         LogDebug(kLogCategory_) << "failed to find an eta partition";
         continue;
       }
 
       const GEMDetId gem_id = eta_partition->id();
 
       if (kMaskChamberWithError_) {
         const bool has_error = maskChamberWithError(gem_id.chamberId(), oh_status_collection, vfat_status_collection);
         if (has_error) {
           LogDebug(kLogCategory_) << gem_id.chamberId() << " has an erorr. Skip this propagation.";
           continue;
         }
       }
 
       //
       const GEMDetId rs_key = getReStKey(gem_id);     // region-station
       const GEMDetId rsl_key = getReStLaKey(gem_id);  // region-station-layer
       const GEMDetId rse_key = getReStEtKey(gem_id);  // region-station-ieta
 
       const int station_id = gem_id.station();
       const int chamber_id = gem_id.chamber();
       const int ieta = gem_id.ieta();
 
       const double muon_pt = muon.pt();
       const double muon_eta = std::fabs(muon.eta());
       const double muon_phi = Geom::convertRadToDeg(muon.phi());
 
       const double prop_global_err_r = std::sqrt(prop_global_err.rerr(prop_global_pos));
       const double prop_global_err_phi = Geom::convertRadToDeg(std::sqrt(prop_global_err.phierr(prop_global_pos)));
 
       // cuts
       const bool passed_prop_err_r_cut = (prop_global_err_r < kPropagationErrorRCut_);
       const bool passed_prop_err_phi_cut = (prop_global_err_phi < kPropagationErrorPhiCut_);
       const bool passed_pt_cut = muon_pt > kMuonPtMinCuts_.at(station_id);
       const bool passed_eta_cut =
           (muon_eta > kMuonEtaMinCuts_.at(station_id)) and (muon_eta < kMuonEtaMaxCuts_.at(station_id));
 
       const bool passed_prop_err_cuts = passed_prop_err_r_cut and passed_prop_err_phi_cut;
       const bool passed_all_cuts = passed_prop_err_cuts and passed_pt_cut and passed_eta_cut;
 
       const int cutflow_last = not kModeDev_                 ? 0
                                : not passed_prop_err_r_cut   ? 1
                                : not passed_prop_err_phi_cut ? 2
                                : not passed_pt_cut           ? 3
                                : not passed_eta_cut          ? 4
                                                              : 5;
 
       // Fill denominators
       if (passed_eta_cut and passed_prop_err_cuts) {
         fillMEWithinLimits(me_muon_pt_, rs_key, muon_pt);
       }
 
       if (passed_pt_cut and passed_prop_err_cuts) {
         fillMEWithinLimits(me_muon_eta_, rs_key, muon_eta);
       }
 
       if (passed_all_cuts) {
         fillME(me_chamber_ieta_, rsl_key, chamber_id, ieta);
         fillME(me_muon_phi_, rs_key, muon_phi);
       }
 
       if (kModeDev_) {
         fillMEWithinLimits(me_prop_path_length_, rsl_key, prop_path_length);
         fillMEWithinLimits(me_prop_err_r_, rsl_key, prop_global_err_r);
         fillMEWithinLimits(me_prop_err_phi_, rsl_key, prop_global_err_phi);
 
         fillMEWithinLimits(me_muon_pt_all_, rs_key, muon_pt);
         fillMEWithinLimits(me_muon_eta_all_, rs_key, muon_eta);
 
         fillME(me_muon_charge_, rs_key, muon.charge());
 
         for (int bin = 1; bin <= cutflow_last; bin++) {
           fillME(me_cutflow_, rsl_key, bin);
         }
 
       }  // dev mode
 
       // Find a closet hit
       const auto [hit, matching_metric] =
           findClosestHit(prop_global_pos, rechit_collection->get(gem_id), eta_partition);
 
       if (hit == nullptr) {
         LogDebug(kLogCategory_) << "hit not found";
         continue;
       }
 
       if (kModeDev_) {
         fillMEWithinLimits(me_matching_metric_all_, rse_key, matching_metric);
       }
 
       if (std::abs(matching_metric) > kMatchingCut_) {
         LogDebug(kLogCategory_) << "failed to pass the residual rphi cut";
         continue;
       }
 
       // Fill numerators
       if (passed_eta_cut and passed_prop_err_cuts) {
         fillMEWithinLimits(me_muon_pt_matched_, rs_key, muon_pt);
       }
 
       if (passed_pt_cut and passed_prop_err_cuts) {
         fillMEWithinLimits(me_muon_eta_matched_, rs_key, muon_eta);
       }
 
       if (passed_all_cuts) {
         fillME(me_chamber_ieta_matched_, rsl_key, chamber_id, ieta);
         fillME(me_muon_phi_matched_, rs_key, muon_phi);
       }
 
       if (kModeDev_) {
         fillMEWithinLimits(me_prop_path_length_matched_, rsl_key, prop_path_length);
 
         fillMEWithinLimits(me_prop_err_r_matched_, rsl_key, prop_global_err_r);
         fillMEWithinLimits(me_prop_err_phi_matched_, rsl_key, prop_global_err_phi);
 
         fillMEWithinLimits(me_muon_pt_all_matched_, rs_key, muon_pt);
         fillMEWithinLimits(me_muon_eta_all_matched_, rs_key, muon_eta);
 
         fillME(me_muon_charge_matched_, rs_key, muon.charge());
 
         if (passed_all_cuts) {
           for (int bin = 1; bin <= cutflow_last; bin++) {
             fillME(me_cutflow_matched_, rsl_key, bin);
           }
         }
       }
 
       // Fill resolutions
       if (passed_all_cuts) {
         const LocalPoint hit_local_pos = hit->localPosition();
         const GlobalPoint& hit_global_pos = eta_partition->toGlobal(hit_local_pos);
         const float residual_phi = Geom::convertRadToDeg(prop_global_pos.phi() - hit_global_pos.phi());
 
         fillMEWithinLimits(me_residual_phi_, rse_key, residual_phi);
 
         if (kModeDev_) {
           const LocalPoint prop_local_pos = eta_partition->toLocal(prop_global_pos);
           const StripTopology& topology = eta_partition->specificTopology();
 
           const float residual_x = prop_local_pos.x() - hit_local_pos.x();
           const float residual_y = prop_local_pos.y() - hit_local_pos.y();
           const float residual_strip = topology.strip(prop_local_pos) - topology.strip(hit_local_pos);
 
           fillMEWithinLimits(me_matching_metric_, rse_key, matching_metric);
           fillMEWithinLimits(me_residual_x_, rse_key, residual_x);
           fillMEWithinLimits(me_residual_y_, rse_key, residual_y);
           fillMEWithinLimits(me_residual_strip_, rse_key, residual_strip);
 
           if (muon.charge() < 0) {
             fillMEWithinLimits(me_residual_phi_muon_, rse_key, residual_phi);
           } else {
             fillMEWithinLimits(me_residual_phi_antimuon_, rse_key, residual_phi);
           }
         }  // kModeDev_
       }    // passed_all_cuts
     }      // destination
   }        // Muon
 }  // analyze

◆ bookHistograms()

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 255 of file GEMEfficiencyAnalyzer.cc.

                                                                                                               {
   ibooker.setCurrentFolder(kFolder_);
 
   const GEMGeometry* gem = nullptr;
   if (auto handle = setup.getHandle(kGEMGeometryTokenBeginRun_)) {
     gem = handle.product();
   } else {
     edm::LogError(kLogCategory_ + "|bookHistograms") << "failed to get GEMGeometry";
     return;
   }
 
   for (const GEMStation* station : gem->stations()) {
     const int region_id = station->region();
     const int station_id = station->station();
 
     if (skipGEMStation(station_id)) {
       continue;
     }
 
     // Region-Station
     {  // shadowing to reuse short variable names
       const GEMDetId key = getReStKey(region_id, station_id);
       const TString suffix = GEMUtils::getSuffixName(region_id, station_id);
       const TString title = kMuonName_ + GEMUtils::getSuffixTitle(region_id, station_id);
 
       // sources for eff. vs muon pt
       TH1F* h_muon_pt = new TH1F("muon_pt" + suffix, title, kMuonPtBins_.size() - 1, &kMuonPtBins_[0]);
       me_muon_pt_[key] = ibooker.book1D(h_muon_pt->GetName(), h_muon_pt);
       me_muon_pt_[key]->setAxisTitle("Muon p_{T} [GeV]", 1);
       me_muon_pt_matched_[key] = bookNumerator1D(ibooker, me_muon_pt_[key]);
 
       // sources for eff. vs muon eta
       me_muon_eta_[key] = ibooker.book1D("muon_eta" + suffix,
                                          title,
                                          kMuonEtaNbins_.at(station_id),
                                          kMuonEtaLow_.at(station_id),
                                          kMuonEtaUp_.at(station_id));
       me_muon_eta_[key]->setAxisTitle("Muon |#eta|", 1);
       me_muon_eta_matched_[key] = bookNumerator1D(ibooker, me_muon_eta_[key]);
 
       // sources for eff. vs muon phi
       me_muon_phi_[key] = ibooker.book1D("muon_phi" + suffix, title, 36, -180, 180);
       me_muon_phi_[key]->setAxisTitle("Muon #phi [deg]");
       me_muon_phi_matched_[key] = bookNumerator1D(ibooker, me_muon_phi_[key]);
 
       if (kModeDev_) {
         // without cuts except the fiducial cut
         TH1F* h_muon_pt_all = new TH1F("muon_pt_all" + suffix, title, kMuonPtBins_.size() - 1, &kMuonPtBins_[0]);
         me_muon_pt_all_[key] = ibooker.book1D(h_muon_pt_all->GetName(), h_muon_pt_all);
         me_muon_pt_all_[key]->setAxisTitle("Muon p_{T} [GeV]", 1);
         me_muon_pt_all_matched_[key] = bookNumerator1D(ibooker, me_muon_pt_all_[key]);
 
         me_muon_eta_all_[key] = ibooker.book1D("muon_eta_all" + suffix,
                                                title,
                                                kMuonEtaNbins_.at(station_id),
                                                kMuonEtaLow_.at(station_id),
                                                kMuonEtaUp_.at(station_id));
         me_muon_eta_all_[key]->setAxisTitle("Muon |#eta|", 1);
         me_muon_eta_all_matched_[key] = bookNumerator1D(ibooker, me_muon_eta_all_[key]);
 
         me_muon_charge_[key] = ibooker.book1D("muon_charge" + suffix, title, 3, -1.5, 1.5);
         me_muon_charge_[key]->setAxisTitle("Muon charge", 1);
         me_muon_charge_matched_[key] = bookNumerator1D(ibooker, me_muon_charge_[key]);
       }
     }  // shadowing
 
     // Region - Station - Layer
     const std::vector<const GEMSuperChamber*> superchamber_vec = station->superChambers();
     if (not checkRefs(superchamber_vec)) {
       edm::LogError(kLogCategory_) << "got an invalid ptr from GEMStation::superChambers";
       return;
     }
 
     const std::vector<const GEMChamber*> chamber_vec = superchamber_vec.front()->chambers();
     if (not checkRefs(chamber_vec)) {
       edm::LogError(kLogCategory_) << "got an invalid ptr from GEMSuperChamber::chambers";
       return;
     }
 
     // we actually loop over layers
     for (const GEMChamber* chamber : chamber_vec) {
       const int layer_id = chamber->id().layer();
 
       {  // shadowing
         const GEMDetId key = getReStLaKey(chamber->id());
         const TString suffix = GEMUtils::getSuffixName(region_id, station_id, layer_id);
         const TString title = kMuonName_ + GEMUtils::getSuffixTitle(region_id, station_id, layer_id);
 
         me_chamber_ieta_[key] = bookChamberEtaPartition(ibooker, "chamber_ieta" + suffix, title, station);
         me_chamber_ieta_matched_[key] = bookNumerator2D(ibooker, me_chamber_ieta_[key]);
 
         if (kModeDev_) {
           me_prop_path_length_[key] = ibooker.book1D("prop_path_length" + suffix, title, 50, 0.0, 5.0);
           me_prop_path_length_[key]->setAxisTitle("Propagation path length [cm]", 1);
           me_prop_path_length_matched_[key] = bookNumerator1D(ibooker, me_prop_path_length_[key]);
 
           // prop. r error in the global coordinates
           me_prop_err_r_[key] = ibooker.book1D("prop_err_r" + suffix, title, 60, 0.0, 3.0);
           me_prop_err_r_[key]->setAxisTitle("Propagation global #sigma_{R} [cm]", 1);
           me_prop_err_r_matched_[key] = bookNumerator1D(ibooker, me_prop_err_r_[key]);
 
           // prop. r error in the global coordinates
           me_prop_err_phi_[key] = ibooker.book1D("prop_err_phi" + suffix, title, 50, 0.0, 1.0);
           me_prop_err_phi_[key]->setAxisTitle("Propagation's global #sigma_{#phi} [deg]", 1);
           me_prop_err_phi_matched_[key] = bookNumerator1D(ibooker, me_prop_err_phi_[key]);
 
           // cutflow
           me_cutflow_[key] = ibooker.book1D("cutflow" + suffix, title, 5, 0.5, 5.5);
           me_cutflow_[key]->setBinLabel(1, "All");
           me_cutflow_[key]->setBinLabel(2, Form("#sigma_{R} < %.3f cm", kPropagationErrorRCut_));
           me_cutflow_[key]->setBinLabel(3, Form("#sigma_{phi} < %.3f deg", kPropagationErrorPhiCut_));
           me_cutflow_[key]->setBinLabel(4, Form("p_{T} > %.1f GeV", kMuonPtMinCuts_.at(station_id)));
           me_cutflow_[key]->setBinLabel(
               5, Form("%.2f < |#eta| < %.2f", kMuonEtaMinCuts_.at(station_id), kMuonEtaMaxCuts_.at(station_id)));
 
           me_cutflow_matched_[key] = bookNumerator1D(ibooker, me_cutflow_.at(key));
         }
       }  // shadowing
     }    // GEMChamber
 
     // Region - Station - iEta
     const std::vector<const GEMEtaPartition*> eta_partition_vec = chamber_vec.front()->etaPartitions();
     if (not checkRefs(eta_partition_vec)) {
       edm::LogError(kLogCategory_) << "got an invalid ptr from GEMChamber::etaPartitions";
       continue;
     }
 
     for (const GEMEtaPartition* eta_partition : eta_partition_vec) {
       const int ieta = eta_partition->id().ieta();
 
       {  // shadowing
         const GEMDetId key = getReStEtKey(eta_partition->id());
         const TString gem_label = TString::Format("GE%d1-%c-E%d", station_id, (region_id > 0 ? 'P' : 'M'), ieta);
         const TString suffix = "_" + gem_label;
         const TString title = kMuonName_ + " " + gem_label;
 
         // FIXME
         const float dphi_up = (kMatchingMetric_ == MatchingMetric::kDeltaPhi) ? kMatchingCut_
                               : (kScenario_ == ScenarioOption::kCosmics)      ? 1.0
                                                                               : 0.2;
         me_residual_phi_[key] = ibooker.book1D("residual_phi" + suffix, title, 41, -dphi_up, dphi_up);
         me_residual_phi_[key]->setAxisTitle("Residual in global #phi [deg]", 1);
 
         if (kModeDev_) {
           // matching metric
           std::string matching_metric_x_title;
           if (kMatchingMetric_ == MatchingMetric::kDeltaPhi) {
             matching_metric_x_title = "#Delta#phi [deg]";
 
           } else if (kMatchingMetric_ == MatchingMetric::kRdPhi) {
             matching_metric_x_title = "R#Delta#phi [cm]";
 
           } else {
             matching_metric_x_title = "UNKNOWN METRIC";
           }
 
           // matching metrics without any cuts
           me_matching_metric_all_[key] =
               ibooker.book1D("matching_metric_all" + suffix, title, 101, -3 * kMatchingCut_, 3 * kMatchingCut_);
           me_matching_metric_all_[key]->setAxisTitle(matching_metric_x_title, 1);
 
           // matching metrics after cuts
           me_matching_metric_[key] =
               ibooker.book1D("matching_metric" + suffix, title, 101, -kMatchingCut_, kMatchingCut_);
           me_matching_metric_[key]->setAxisTitle(matching_metric_x_title, 1);
 
           // residuals in the global phi for muons (q < 0)
           me_residual_phi_muon_[key] =
               ibooker.book1D("residual_phi_muon" + suffix, title + " (#mu, q < 0)", 50, -0.5, 0.5);
           me_residual_phi_muon_[key]->setAxisTitle("Residual in global #phi [deg]", 1);
           me_residual_phi_muon_[key]->setAxisTitle("Number of muons", 2);
 
           // residuals in the global phi for anti-muons (q > 0)
           me_residual_phi_antimuon_[key] =
               ibooker.book1D("residual_phi_antimuon" + suffix, title + " (#tilde{#mu}, q > 0)", 50, -0.5, 0.5);
           me_residual_phi_antimuon_[key]->setAxisTitle("Residual in global #phi [deg]", 1);
           me_residual_phi_antimuon_[key]->setAxisTitle("Number of anti-muons", 2);
 
           // residuals in the local x
           me_residual_x_[key] = ibooker.book1D("residual_x" + suffix, title, 60, -1.5, 1.5);
           me_residual_x_[key]->setAxisTitle("Residual in local X [cm]", 1);
 
           // residuals in the local y
           me_residual_y_[key] = ibooker.book1D("residual_y" + suffix, title, 48, -12.0, 12.0);
           me_residual_y_[key]->setAxisTitle("Residual in local Y [cm]", 1);
 
           // the strip difference
           me_residual_strip_[key] = ibooker.book1D("residual_strip" + suffix, title, 21, -10.0, 10.0);
           me_residual_strip_[key]->setAxisTitle("propagation strip - hit strip", 1);
         }
       }  // shadowing
     }    // GEMEtaPartition
   }      // GEMStataion
 }

◆ buildGEMLayers()

void GEMEfficiencyAnalyzer::buildGEMLayers ( const GEMGeometry * gem )

private

Definition at line 462 of file GEMEfficiencyAnalyzer.cc.

References Disk::build(), relativeConstraints::chamber, chambers, mixOne_premix_on_sim_cfi::gem, gem_layers_, crabWrapper::key, GEMDQMEfficiencySourceBase::kLogCategory_, phase1PixelTopology::layer, LogDebug, position, idealTransformation::rotation, GEMDQMEfficiencySourceBase::skipGEMStation(), and relativeConstraints::station.

Referenced by dqmBeginRun().

                                                                  {
   std::map<GEMDetId, std::vector<const GEMChamber*> > chambers_per_layer;
 
   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;
     }
 
     for (const GEMSuperChamber* superchamber : station->superChambers()) {
       // GE11: chamber == 0 for even chambers, chamber == 1 for odd chambers
       // GE21 and GE0: chamber == 0 for all chambers
       const int chamber_id = is_ge11 ? superchamber->id().chamber() % 2 : 0;
 
       for (const GEMChamber* chamber : superchamber->chambers()) {
         const int layer_id = chamber->id().layer();
 
         const GEMDetId key{region_id, 1, station_id, layer_id, chamber_id, 0};
 
         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 => iterate over layer ids
     }    // GEMSuperChamber => iterate over chamber ids
   }      // GEMStation
 
   gem_layers_.reserve(chambers_per_layer.size());
   for (auto [gem_id, chambers] : chambers_per_layer) {
     // layer position and rotation
     const float z_origin = chambers.front()->position().z();
     Surface::PositionType position{0.f, 0.f, z_origin};
     Surface::RotationType rotation;
 
     // eta partitions should have same R and Z spans.
     // XXX is it true?
     auto [r_min, r_max] = chambers.front()->surface().rSpan();
     auto [z_min, z_max] = chambers.front()->surface().zSpan();
 
     z_min -= z_origin;
     z_max -= z_origin;
 
     // the bounds from min and max R and Z in the local coordinates.
     SimpleDiskBounds* bounds = new SimpleDiskBounds(r_min, r_max, z_min, z_max);
     const Disk::DiskPointer layer = Disk::build(position, rotation, bounds);
 
     gem_layers_.emplace_back(layer, chambers, gem_id);
 
     LogDebug(kLogCategory_) << gem_id
                             << Form(" ==> (z_origin, z_min, z_max) = (%.2f, %.2f, %.2f)", z_origin, z_min, z_max);
   }  // ring
 }

◆ buildStartingState()

GEMEfficiencyAnalyzer::StartingState GEMEfficiencyAnalyzer::buildStartingState	(	const reco::Muon &	muon,
		const reco::TransientTrack &	transient_track,
		const GEMLayer &	gem_layer
	)

private

Definition at line 541 of file GEMEfficiencyAnalyzer.cc.

References buildStartingStateAlignmentStyle(), buildStateOnSurfaceWithCSCSegment(), DetId::det(), newFWLiteAna::found, getInnermostMeasurementState(), getOutermostMeasurementState(), GEMEfficiencyAnalyzer::GEMLayer::id, MuonHitHelper::isGEM(), isMuonSubdetAllowed(), kAlignmentStyle, kInnermostMeasurementState, GEMDQMEfficiencySourceBase::kLogCategory_, kOutermostMeasurementState, kStartingStateType_, kStateOnSurfaceWithCSCSegment, GEMDetId::layer(), LogDebug, dumpRecoGeometry_cfg::Muon, GEMDetId::region(), and GEMDetId::station().

Referenced by analyze().

                                                                                                 {
   bool found = false;
   TrajectoryStateOnSurface state;
   DetId det_id;
 
   switch (kStartingStateType_) {
     case StartingStateType::kOutermostMeasurementState: {
       std::tie(found, state, det_id) = getOutermostMeasurementState(transient_track);
       break;
     }
     case StartingStateType::kInnermostMeasurementState: {
       std::tie(found, state, det_id) = getInnermostMeasurementState(transient_track);
       break;
     }
     case StartingStateType::kStateOnSurfaceWithCSCSegment: {
       std::tie(found, state, det_id) = buildStateOnSurfaceWithCSCSegment(muon, transient_track, gem_layer);
       break;
     }
     case StartingStateType::kAlignmentStyle: {
       std::tie(found, state, det_id) = buildStartingStateAlignmentStyle(muon, transient_track, gem_layer);
       break;
     }
     default: {
       edm::LogError(kLogCategory_) << "got an unexpected StartingStateType";
       break;
     }
   }
 
   found &= state.isValid();
 
   if (found and (det_id.det() == DetId::Detector::Muon)) {
     found &= isMuonSubdetAllowed(det_id, gem_layer.id.station());
   }
 
   if (found) {
     if (MuonHitHelper::isGEM(det_id)) {
       const GEMDetId start_id{det_id};
 
       const bool are_same_region = gem_layer.id.region() == start_id.region();
       const bool are_same_station = gem_layer.id.station() == start_id.station();
       const bool are_same_layer = gem_layer.id.layer() == start_id.layer();
       if (are_same_region and are_same_station and are_same_layer) {
         LogDebug(kLogCategory_)
             << "The starting detector of the muon propagation is same with the destination. Skip this propagation.";
         found = false;
       }
     }  // isGEM
   }    // found
 
   return std::make_tuple(found, state, det_id);
 }

◆ buildStartingStateAlignmentStyle()

GEMEfficiencyAnalyzer::StartingState GEMEfficiencyAnalyzer::buildStartingStateAlignmentStyle	(	const reco::Muon &	muon,
		const reco::TransientTrack &	transient_track,
		const GEMLayer &	gem_layer
	)

private

Definition at line 667 of file GEMEfficiencyAnalyzer.cc.

References findCSCSegment(), newFWLiteAna::found, edm::Ref< C, T, F >::get(), edm::Ref< C, T, F >::isNonnull(), muon_service_, and position.

Referenced by buildStartingState().

                                                                                                 {
   bool found = false;
   TrajectoryStateOnSurface state;
   DetId det_id;
 
   if (const CSCSegment* csc_segment = findCSCSegment(muon, transient_track, gem_layer)) {
     found = true;
     det_id = csc_segment->geographicalId();
 
     // position
     const LocalPoint position = csc_segment->localPosition();
     // momentum
     const reco::TrackRef inner_track = muon.innerTrack();
     const float momentum_magnitude = inner_track.isNonnull() ? inner_track.get()->outerP() : 1.0f;
     const LocalVector momentum = momentum_magnitude * csc_segment->localDirection();
 
     // trajectory parameter
     const LocalTrajectoryParameters trajectory_parameters{position, momentum, muon.charge()};
 
     // trajectory error
     const LocalTrajectoryError trajectory_error =
         asSMatrix<5>(csc_segment->parametersError().similarityT(csc_segment->projectionMatrix()));
 
     // surface
     const Plane& surface = muon_service_->trackingGeometry()->idToDet(det_id)->surface();
 
     state =
         TrajectoryStateOnSurface{trajectory_parameters, trajectory_error, surface, &*muon_service_->magneticField()};
   }
 
   return std::make_tuple(found, state, det_id);
 }

◆ buildStateOnSurfaceWithCSCSegment()

GEMEfficiencyAnalyzer::StartingState GEMEfficiencyAnalyzer::buildStateOnSurfaceWithCSCSegment	(	const reco::Muon &	muon,
		const reco::TransientTrack &	transient_track,
		const GEMLayer &	gem_layer
	)

private

Definition at line 644 of file GEMEfficiencyAnalyzer.cc.

References findCSCSegment(), newFWLiteAna::found, muon_service_, reco::TransientTrack::stateOnSurface(), and GeomDet::toGlobal().

Referenced by buildStartingState().

                                                                                                 {
   bool found = false;
   TrajectoryStateOnSurface state;
   DetId det_id;
 
   if (const CSCSegment* csc_segment = findCSCSegment(muon, transient_track, gem_layer)) {
     const GeomDet* det = muon_service_->trackingGeometry()->idToDet(csc_segment->cscDetId());
     const GlobalPoint global_position = det->toGlobal(csc_segment->localPosition());
 
     found = true;
     state = transient_track.stateOnSurface(global_position);
     det_id = csc_segment->geographicalId();
   }
 
   return std::make_tuple(found, state, det_id);
 }

◆ checkBounds() [1/2]

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

private

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

◆ checkBounds() [2/2]

bool GEMEfficiencyAnalyzer::checkBounds	(	const Plane &	plane,
		const GlobalPoint &	global_point,
		const GlobalError &	global_error,
		float	scale
	)

private

Definition at line 846 of file GEMEfficiencyAnalyzer.cc.

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

                                                            {
   const LocalPoint local_point = plane.toLocal(global_point);
   const LocalError local_error = ErrorFrameTransformer::transform(global_error, plane);
 
   const LocalPoint local_point_2d{local_point.x(), local_point.y(), 0.0f};
   return plane.bounds().inside(local_point_2d, local_error, scale);
 }

◆ checkPropagationDirection()

bool GEMEfficiencyAnalyzer::checkPropagationDirection	(	const reco::Track *	track,
		const GEMLayer &	layer
	)

private

Definition at line 520 of file GEMEfficiencyAnalyzer.cc.

References isInsideOut(), kCosmics, kScenario_, phase1PixelTopology::layer, optionsL1T::skip, std::swap(), and HLT_2022v15_cff::track.

Referenced by analyze().

                                                                                                    {
   const bool is_same_region = track->eta() * layer.id.region() > 0;
 
   bool skip = false;
   if (kScenario_ == ScenarioOption::kCosmics) {
     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;
 }

◆ computeDeltaPhi()

float GEMEfficiencyAnalyzer::computeDeltaPhi	(	const GlobalPoint &	prop_global_pos,
		const LocalPoint &	hit_local_pos,
		const GEMEtaPartition *	eta_partition
	)

private

Definition at line 893 of file GEMEfficiencyAnalyzer.cc.

References angle_units::operators::convertRadToDeg(), PV3DBase< T, PVType, FrameType >::phi(), and GeomDet::toGlobal().

Referenced by computeMatchingMetric().

                                                                                    {
   const GlobalPoint hit_global_pos = eta_partition->toGlobal(hit_local_pos);
   const float dphi = Geom::convertRadToDeg(prop_global_pos.phi() - hit_global_pos.phi());
   return dphi;
 }

◆ computeMatchingMetric()

float GEMEfficiencyAnalyzer::computeMatchingMetric	(	const GlobalPoint &	prop_global_pos,
		const LocalPoint &	hit_local_pos,
		const GEMEtaPartition *	eta_partition
	)

private

Definition at line 902 of file GEMEfficiencyAnalyzer.cc.

References computeDeltaPhi(), computeRdPhi(), infinity, kDeltaPhi, GEMDQMEfficiencySourceBase::kLogCategory_, kMatchingMetric_, and kRdPhi.

Referenced by findClosestHit().

                                                                                          {
   float metric;
   switch (kMatchingMetric_) {
     case MatchingMetric::kDeltaPhi: {
       metric = computeDeltaPhi(prop_global_pos, hit_local_pos, eta_partition);
       break;
     }
     case MatchingMetric::kRdPhi: {
       metric = computeRdPhi(prop_global_pos, hit_local_pos, eta_partition);
       break;
     }
     default: {
       edm::LogError(kLogCategory_) << "unknown MatchingMetric.";  // TODO
       metric = std::numeric_limits<float>::infinity();
     }
   }
 
   return metric;
 }

◆ computeRdPhi()

float GEMEfficiencyAnalyzer::computeRdPhi	(	const GlobalPoint &	prop_global_pos,
		const LocalPoint &	hit_local_pos,
		const GEMEtaPartition *	eta_partition
	)

private

Definition at line 878 of file GEMEfficiencyAnalyzer.cc.

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

Referenced by computeMatchingMetric().

                                                                                 {
   const StripTopology& topology = eta_partition->specificTopology();
   const LocalPoint prop_local_pos = eta_partition->toLocal(prop_global_pos);
 
   const float dx = prop_local_pos.x() - hit_local_pos.x();
   const float dy = prop_local_pos.y() - hit_local_pos.y();
   const float hit_strip = eta_partition->strip(hit_local_pos);
   const float hit_phi = topology.stripAngle(hit_strip);
   const float rdphi = std::cos(hit_phi) * dx - std::sin(hit_phi) * dy;
   return rdphi;
 }

◆ dqmBeginRun()

void GEMEfficiencyAnalyzer::dqmBeginRun	(	edm::Run const &	,
		edm::EventSetup const &	setup
	)

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 948 of file GEMEfficiencyAnalyzer.cc.

References buildGEMLayers(), mixOne_premix_on_sim_cfi::gem, patZpeak::handle, kGEMGeometryTokenBeginRun_, GEMDQMEfficiencySourceBase::kLogCategory_, and singleTopDQM_cfi::setup.

                                                                                  {
   const GEMGeometry* gem = nullptr;
   if (auto handle = setup.getHandle(kGEMGeometryTokenBeginRun_)) {
     gem = handle.product();
   } else {
     edm::LogError(kLogCategory_ + "|dqmBeginRun") << "failed to get GEMGeometry";
     return;
   }
 
   buildGEMLayers(gem);
 }

◆ fillDescriptions()

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

static

Definition at line 80 of file GEMEfficiencyAnalyzer.cc.

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

                                                                                        {
   edm::ParameterSetDescription desc;
   // GEMDQMEfficiencySourceBase
   desc.addUntracked<edm::InputTag>("ohStatusTag", edm::InputTag("muonGEMDigis", "OHStatus"));
   desc.addUntracked<edm::InputTag>("vfatStatusTag", edm::InputTag("muonGEMDigis", "VFATStatus"));
   desc.addUntracked<bool>("monitorGE11", true);
   desc.addUntracked<bool>("monitorGE21", false);
   desc.addUntracked<bool>("monitorGE0", false);
   desc.addUntracked<bool>("maskChamberWithError", false);
   desc.addUntracked<std::string>("logCategory", "GEMEfficiencyAnalyzer");
 
   // GEMEfficiencyAnalyzer
   desc.addUntracked<edm::InputTag>("recHitTag", edm::InputTag("gemRecHits"));
   desc.addUntracked<edm::InputTag>("muonTag", edm::InputTag("muons"));
   desc.addUntracked<bool>("modeDev", false);
   desc.addUntracked<std::string>("muonTrackType", "OuterTrack");
   desc.addUntracked<std::string>("muonName", "STA Muon");
   desc.addUntracked<std::string>("folder", "GEM/Efficiency/muonSTA");
   desc.addUntracked<std::string>("scenario", "pp");
   //
   desc.addUntracked<std::string>("startingStateType", "OutermostMeasurementState");
   desc.addUntracked<double>("muonSegmentMatchDRCut", 5.0f);  // for cosmics, in cm,  TODO tune
   // muon pt cut
   desc.addUntracked<double>("muonPtMinCutGE0", 20.0f);
   desc.addUntracked<double>("muonPtMinCutGE11", 20.0f);
   desc.addUntracked<double>("muonPtMinCutGE21", 20.0f);
   // muon abs eta cut for GE11
   desc.addUntracked<double>("muonEtaMinCutGE11", 1.5);
   desc.addUntracked<double>("muonEtaMaxCutGE11", 2.2);
   // muon abs eta cut for GE21
   desc.addUntracked<double>("muonEtaMinCutGE21", 1.5);
   desc.addUntracked<double>("muonEtaMaxCutGE21", 2.5);
   // muon abs eta cut for GE0
   desc.addUntracked<double>("muonEtaMinCutGE0", 2.0);
   desc.addUntracked<double>("muonEtaMaxCutGE0", 3.0);
   // propagation error cuts
   desc.addUntracked<double>("propagationErrorRCut", 0.5);    // cm
   desc.addUntracked<double>("propagationErrorPhiCut", 0.2);  // degree
   //
   desc.addUntracked<double>("boundsErrorScale", -2.0);  // TODO tune
   // matching
   desc.addUntracked<std::string>("matchingMetric", "DeltaPhi");
   desc.addUntracked<double>("matchingCut", 0.2);  // DeltaPhi for pp, in degree TODO tune
   // for MinotorElement
   const std::vector<double> default_pt_bins{
       0, 5, 10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110.};  // actually edges
   desc.addUntracked<std::vector<double> >("muonPtBins", default_pt_bins);
   // GE11
   desc.addUntracked<int>("muonEtaNbinsGE11", 9);  // bin width = 0.1
   desc.addUntracked<double>("muonEtaLowGE11", 1.4);
   desc.addUntracked<double>("muonEtaUpGE11", 2.3);
   // GE21
   desc.addUntracked<int>("muonEtaNbinsGE21", 12);  // bin width = 0.1
   desc.addUntracked<double>("muonEtaLowGE21", 1.4);
   desc.addUntracked<double>("muonEtaUpGE21", 2.6);
   // GE0
   desc.addUntracked<int>("muonEtaNbinsGE0", 12);  // bin width = 0.1
   desc.addUntracked<double>("muonEtaLowGE0", 1.9);
   desc.addUntracked<double>("muonEtaUpGE0", 3.1);
 
   // MuonSubdetId's are listed in DataFormats/MuonDetId/interface/MuonSubdetId.h
   desc.addUntracked<std::vector<int> >("muonSubdetForGE0", {});  // allow all muon subdetectors. TODO optimzie.
   desc.addUntracked<std::vector<int> >("muonSubdetForGE11", {});
   desc.addUntracked<std::vector<int> >("muonSubdetForGE21", {});
   // INFO when muonTrackType is "CombinedTrack" or "OuterTrack"
   // https://github.com/cms-sw/cmssw/blob/CMSSW_12_4_0_pre3/DataFormats/MuonDetId/interface/CSCDetId.h#L187-L193
   // assumed to be the same area.
   desc.addUntracked<std::vector<int> >("cscForGE11", {1, 2});  // ME1a, ME1b
   desc.addUntracked<std::vector<int> >("cscForGE21", {});      // all CSCSegments allowed
   desc.addUntracked<std::vector<int> >("cscForGE0", {});       // all CSCSegments allowed
 
   // ServiceParameters for MuonServiceProxy
   // This will be initialized in the cfi file
   edm::ParameterSetDescription service_parameters;
   service_parameters.setAllowAnything();
   desc.add<edm::ParameterSetDescription>("ServiceParameters", service_parameters);
 
   descriptions.add("gemEfficiencyAnalyzerDefault", desc);
 }

◆ findClosestHit()

std::pair< const GEMRecHit *, float > GEMEfficiencyAnalyzer::findClosestHit	(	const GlobalPoint &	prop_global_pos,
		const GEMRecHitCollection::range &	rechit_range,
		const GEMEtaPartition *	eta_partition
	)

private

Definition at line 928 of file GEMEfficiencyAnalyzer.cc.

References funct::abs(), computeMatchingMetric(), and infinity.

Referenced by analyze().

                                                                                                                {
   const GEMRecHit* closest_hit = nullptr;
   float min_metric = std::numeric_limits<float>::infinity();
 
   for (auto hit = rechit_range.first; hit != rechit_range.second; ++hit) {
     const LocalPoint hit_local_pos = hit->localPosition();
 
     const float metric = computeMatchingMetric(prop_global_pos, hit_local_pos, eta_partition);
 
     if (std::abs(metric) < std::abs(min_metric)) {
       min_metric = metric;
       closest_hit = &(*hit);
     }
   }
 
   return std::make_pair(closest_hit, min_metric);
 }

◆ findCSCSegment()

const CSCSegment * GEMEfficiencyAnalyzer::findCSCSegment	(	const reco::Muon &	muon,
		const reco::TransientTrack &	transient_track,
		const GEMLayer &	gem_layer
	)

private

Definition at line 793 of file GEMEfficiencyAnalyzer.cc.

References findCSCSegmentBeam(), findCSCSegmentCosmics(), kCosmics, and kScenario_.

Referenced by buildStartingStateAlignmentStyle(), and buildStateOnSurfaceWithCSCSegment().

                                                                                    {
   if (kScenario_ == ScenarioOption::kCosmics) {
     return findCSCSegmentCosmics(muon, gem_layer);
   } else {
     // pp or HI
     return findCSCSegmentBeam(transient_track, gem_layer);
   }
 }

◆ findCSCSegmentBeam()

const CSCSegment * GEMEfficiencyAnalyzer::findCSCSegmentBeam	(	const reco::TransientTrack &	transient_track,
		const GEMLayer &	gem_layer
	)

private

Definition at line 703 of file GEMEfficiencyAnalyzer.cc.

References funct::abs(), TrackingRecHit::dimension(), GEMEfficiencyAnalyzer::GEMLayer::disk, TrackingRecHit::geographicalId(), GEMEfficiencyAnalyzer::GEMLayer::id, infinity, MuonHitHelper::isCSC(), isCSCAllowed(), TrackingRecHit::isValid(), kCSCSegmentDimension_, GEMDQMEfficiencySourceBase::kLogCategory_, LogDebug, muon_service_, reco::TransientTrack::recHitsBegin(), reco::TransientTrack::recHitsEnd(), GEMDetId::station(), and GeomDet::toGlobal().

Referenced by findCSCSegment().

                                                                                        {
   const CSCSegment* best_csc_segment = nullptr;
   double min_z_distance = std::numeric_limits<double>::infinity();  // in cm
 
   for (trackingRecHit_iterator tracking_rechit_iter = transient_track.recHitsBegin();
        tracking_rechit_iter != transient_track.recHitsEnd();
        tracking_rechit_iter++) {
     const TrackingRecHit* tracking_rechit = *tracking_rechit_iter;
     if (not tracking_rechit->isValid()) {
       LogDebug(kLogCategory_) << "got an invalid trackingRecHit_iterator from transient_track. skip it.";
       continue;
     }
 
     const DetId det_id = tracking_rechit->geographicalId();
     if (not MuonHitHelper::isCSC(det_id)) {
       continue;
     }
 
     if (tracking_rechit->dimension() != kCSCSegmentDimension_) {
       continue;
     }
 
     const CSCDetId csc_id{det_id};
     if (not isCSCAllowed(csc_id, gem_layer.id.station())) {
       continue;
     }
 
     if (auto csc_segment = dynamic_cast<const CSCSegment*>(tracking_rechit)) {
       const GeomDet* det = muon_service_->trackingGeometry()->idToDet(csc_id);
       if (det == nullptr) {
         edm::LogError(kLogCategory_) << "GlobalTrackingGeometry::idToDet returns nullptr; CSCDetId=" << csc_id;
         continue;
       }
       const GlobalPoint global_position = det->toGlobal(csc_segment->localPosition());
       const float z_distance = std::abs(gem_layer.disk->localZclamped(global_position));
 
       if (z_distance < min_z_distance) {
         best_csc_segment = csc_segment;
         min_z_distance = z_distance;
       }
 
     } else {
       edm::LogError(kLogCategory_)
           << "failed to perform the conversion from `const TrackingRechit*` to `const CSCSegment*`";
     }
   }  // trackingRecHit_iterator
 
   return best_csc_segment;
 }

◆ findCSCSegmentCosmics()

const CSCSegment * GEMEfficiencyAnalyzer::findCSCSegmentCosmics	(	const reco::Muon &	muon,
		const GEMLayer &	gem_layer
	)

private

Definition at line 754 of file GEMEfficiencyAnalyzer.cc.

References reco::MuonSegmentMatch::BestInStationByDR, gather_cfg::cout, reco::MuonSegmentMatch::cscSegmentRef, l1ctLayer1_cff::dr, edm::Ref< C, T, F >::get(), GEMEfficiencyAnalyzer::GEMLayer::id, MuonHitHelper::isCSC(), isCSCAllowed(), reco::MuonSegmentMatch::isMask(), edm::Ref< C, T, F >::isNonnull(), GEMDQMEfficiencySourceBase::kLogCategory_, kMuonSegmentMatchDRCut_, LogDebug, GEMDetId::station(), reco::MuonSegmentMatch::x, and reco::MuonSegmentMatch::y.

Referenced by findCSCSegment().

                                                                                                               {
   const CSCSegment* best_csc_segment = nullptr;
 
   for (const reco::MuonChamberMatch& chamber_match : muon.matches()) {
     if (not MuonHitHelper::isCSC(chamber_match.id)) {
       continue;
     }
 
     const CSCDetId csc_id{chamber_match.id};
     if (not isCSCAllowed(csc_id, gem_layer.id.station())) {
       continue;
     }
 
     const float x_track = chamber_match.x;
     const float y_track = chamber_match.y;
 
     for (const reco::MuonSegmentMatch& segment_match : chamber_match.segmentMatches) {
       if (not segment_match.isMask(reco::MuonSegmentMatch::BestInStationByDR)) {
         continue;
       }
 
       const float dr = std::hypot(x_track - segment_match.x, y_track - segment_match.y);
       std::cout << kLogCategory_ << ": dr=" << dr << std::endl;
 
       if (dr > kMuonSegmentMatchDRCut_) {
         LogDebug(kLogCategory_) << "too large dR(muon, segment)";
         break;
       }
 
       if (segment_match.cscSegmentRef.isNonnull()) {
         best_csc_segment = segment_match.cscSegmentRef.get();
       }
     }  // MuonSegmentMatch
   }    // MuonChamberMatch
 
   return best_csc_segment;
 }

◆ findEtaPartition()

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

private

Definition at line 857 of file GEMEfficiencyAnalyzer.cc.

References relativeConstraints::chamber, checkBounds(), and kBoundsErrorScale_.

Referenced by analyze().

                                                                                                                    {
   const GEMEtaPartition* bound = nullptr;
   for (const GEMChamber* chamber : chamber_vector) {
     if (not checkBounds(chamber->surface(), global_point, global_error, kBoundsErrorScale_)) {
       continue;
     }
 
     for (const GEMEtaPartition* eta_partition : chamber->etaPartitions()) {
       if (checkBounds(eta_partition->surface(), global_point, global_error, kBoundsErrorScale_)) {
         bound = eta_partition;
         break;
       }
     }  // GEMEtaPartition
   }    // GEMChamber
 
   return bound;
 }

◆ getInnermostMeasurementState()

GEMEfficiencyAnalyzer::StartingState GEMEfficiencyAnalyzer::getInnermostMeasurementState ( const reco::TransientTrack & transient_track )

private

Definition at line 600 of file GEMEfficiencyAnalyzer.cc.

References reco::TransientTrack::innermostMeasurementState(), isInsideOut(), reco::TransientTrack::outermostMeasurementState(), reco::TransientTrack::track(), and HLT_2022v15_cff::track.

Referenced by buildStartingState().

                                                {
   TrajectoryStateOnSurface state;
   DetId det_id;
 
   const reco::Track& track = transient_track.track();
   // get real innermost state
   if (isInsideOut(track)) {
     state = transient_track.outermostMeasurementState();
     det_id = track.outerDetId();
 
   } else {
     state = transient_track.innermostMeasurementState();
     det_id = track.innerDetId();
   }
 
   return std::make_tuple(true, state, det_id);
 }

◆ getMatchingMetric()

GEMEfficiencyAnalyzer::MatchingMetric GEMEfficiencyAnalyzer::getMatchingMetric ( const std::string name )

private

Definition at line 161 of file GEMEfficiencyAnalyzer.cc.

References kDeltaPhi, GEMDQMEfficiencySourceBase::kLogCategory_, kRdPhi, AlcaSiPixelAliHarvester0T_cff::method, and Skims_PA_cff::name.

                                                                                                  {
   MatchingMetric method;
 
   if (name == "DeltaPhi") {
     method = MatchingMetric::kDeltaPhi;
 
   } else if (name == "RdPhi") {
     method = MatchingMetric::kRdPhi;
 
   } else {
     edm::LogError(kLogCategory_) << "received an unexpected MatchingMetric: " << name
                                  << " -> MatchingMetric::kDeltaPhi will be used instead.";
     method = MatchingMetric::kDeltaPhi;
   }
 
   return method;
 }

◆ getMuonTrackType()

reco::Muon::MuonTrackType GEMEfficiencyAnalyzer::getMuonTrackType ( const std::string name )

private

Definition at line 205 of file GEMEfficiencyAnalyzer.cc.

References GEMDQMEfficiencySourceBase::kLogCategory_, and Skims_PA_cff::name.

                                                                                   {
   reco::Muon::MuonTrackType muon_track_type;
 
   // DO NOT ALLOW TYPO
   if (name == "InnerTrack") {
     muon_track_type = reco::Muon::MuonTrackType::InnerTrack;
 
   } else if (name == "OuterTrack") {
     muon_track_type = reco::Muon::MuonTrackType::OuterTrack;
 
   } else if (name == "CombinedTrack") {
     muon_track_type = reco::Muon::MuonTrackType::CombinedTrack;
 
   } else {
     edm::LogError(kLogCategory_) << "received an unexpected reco::Muon::MuonTrackType: " << name
                                  << " --> OuterTrack will be used instead.";
 
     muon_track_type = reco::Muon::MuonTrackType::OuterTrack;
   }
 
   return muon_track_type;
 }

◆ getOutermostMeasurementState()

GEMEfficiencyAnalyzer::StartingState GEMEfficiencyAnalyzer::getOutermostMeasurementState ( const reco::TransientTrack & transient_track )

private

Definition at line 620 of file GEMEfficiencyAnalyzer.cc.

References reco::TransientTrack::innermostMeasurementState(), isInsideOut(), reco::TransientTrack::outermostMeasurementState(), reco::TransientTrack::track(), and HLT_2022v15_cff::track.

Referenced by buildStartingState().

                                                {
   const reco::Track& track = transient_track.track();
 
   TrajectoryStateOnSurface state;
   DetId det_id;
 
   // get real innermost state
   if (isInsideOut(track)) {
     state = transient_track.innermostMeasurementState();
     det_id = track.innerDetId();
 
   } else {
     state = transient_track.outermostMeasurementState();
     det_id = track.outerDetId();
   }
 
   return std::make_tuple(true, state, det_id);
 }

◆ getScenarioOption()

GEMEfficiencyAnalyzer::ScenarioOption GEMEfficiencyAnalyzer::getScenarioOption ( const std::string name )

private

Definition at line 228 of file GEMEfficiencyAnalyzer.cc.

References kCosmics, kHeavyIons, GEMDQMEfficiencySourceBase::kLogCategory_, kPP, and Skims_PA_cff::name.

                                                                                                  {
   ScenarioOption scenario;
   if (name == "pp") {
     scenario = ScenarioOption::kPP;
 
   } else if (name == "cosmics") {
     scenario = ScenarioOption::kCosmics;
 
   } else if (name == "HeavyIons") {
     scenario = ScenarioOption::kHeavyIons;
 
     edm::LogInfo(kLogCategory_) << "The scenario is set to \"HeavyIons\""
                                 << " but there is no strategy dedicated to"
                                 << "\"HeavyIons\" scenario. The strategy for "
                                 << "the \"pp\" scenario will be used insteqad.";
 
   } else {
     scenario = ScenarioOption::kPP;
 
     edm::LogError(kLogCategory_) << "received an unexpected ScenarioOption: " << name
                                  << ". Choose from (\"pp\", \"cosmics\", \"HeavyIons\")"
                                  << " --> pp will be used instead.";
   }
 
   return scenario;
 }

◆ getStartingStateType()

GEMEfficiencyAnalyzer::StartingStateType GEMEfficiencyAnalyzer::getStartingStateType ( const std::string name )

private

Definition at line 180 of file GEMEfficiencyAnalyzer.cc.

References kAlignmentStyle, kInnermostMeasurementState, GEMDQMEfficiencySourceBase::kLogCategory_, kOutermostMeasurementState, kStateOnSurfaceWithCSCSegment, and Skims_PA_cff::name.

                                                                                                        {
   StartingStateType type;
 
   if (name == "InnermostMeasurementState") {
     type = StartingStateType::kInnermostMeasurementState;
 
   } else if (name == "OutermostMeasurementState") {
     type = StartingStateType::kOutermostMeasurementState;
 
   } else if (name == "StateOnSurfaceWithCSCSegment") {
     type = StartingStateType::kStateOnSurfaceWithCSCSegment;
 
   } else if (name == "AlignmentStyle") {
     type = StartingStateType::kAlignmentStyle;
 
   } else {
     edm::LogError(kLogCategory_) << "received an unexpected StartingStateType: " << name
                                  << " -> StartingStateType::kOutermostMeasurementState will be used instead.";
     type = StartingStateType::kOutermostMeasurementState;
   }
 
   return type;
 }

◆ isCSCAllowed()

bool GEMEfficiencyAnalyzer::isCSCAllowed	(	const CSCDetId &	csc_id,
		const int	gem_station
	)

private

Definition at line 825 of file GEMEfficiencyAnalyzer.cc.

References spr::find(), CSCDetId::iChamberType(), kCSCForGEM_, GEMDQMEfficiencySourceBase::kLogCategory_, and or.

Referenced by findCSCSegmentBeam(), and findCSCSegmentCosmics().

                                                                                       {
   if ((gem_station < 0) or (gem_station > 2)) {
     edm::LogError(kLogCategory_) << "got unexpected gem station " << gem_station;
     return false;
   }
 
   // unsigned short to int
   const int csc_chamber_type = static_cast<int>(csc_id.iChamberType());
 
   const std::vector<int> allowed = kCSCForGEM_.at(gem_station);
   return allowed.empty() or (std::find(allowed.begin(), allowed.end(), csc_chamber_type) != allowed.end());
 }

◆ isInsideOut()

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

inlineprivate

Definition at line 457 of file GEMEfficiencyAnalyzer.cc.

References HLT_2022v15_cff::track.

Referenced by checkPropagationDirection(), getInnermostMeasurementState(), and getOutermostMeasurementState().

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

◆ isMuonSubdetAllowed()

bool GEMEfficiencyAnalyzer::isMuonSubdetAllowed	(	const DetId &	det_id,
		const int	gem_station
	)

private

Definition at line 804 of file GEMEfficiencyAnalyzer.cc.

References DetId::det(), spr::find(), GEMDQMEfficiencySourceBase::kLogCategory_, kMuonSubdetForGEM_, dumpRecoGeometry_cfg::Muon, or, and DetId::subdetId().

Referenced by buildStartingState().

                                                                                           {
   if ((gem_station < 0) or (gem_station > 2)) {
     edm::LogError(kLogCategory_) << "got unexpected gem station " << gem_station;
     return false;
   }
 
   if (det_id.det() != DetId::Detector::Muon) {
     edm::LogError(kLogCategory_) << Form(
         "(Detector, Subdetector) = (%d, %d)", static_cast<int>(det_id.det()), det_id.subdetId());
     return false;
   }
 
   const std::vector<int> allowed = kMuonSubdetForGEM_.at(gem_station);
   return allowed.empty() or (std::find(allowed.begin(), allowed.end(), det_id.subdetId()) != allowed.end());
 }

Member Data Documentation

◆ gem_layers_

std::vector<GEMLayer> GEMEfficiencyAnalyzer::gem_layers_

private

Definition at line 164 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and buildGEMLayers().

◆ kBoundsErrorScale_

const float GEMEfficiencyAnalyzer::kBoundsErrorScale_

private

Definition at line 140 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and findEtaPartition().

◆ kCSCForGEM_

const std::vector<std::vector<int> > GEMEfficiencyAnalyzer::kCSCForGEM_

private

Definition at line 132 of file GEMEfficiencyAnalyzer.h.

Referenced by isCSCAllowed().

◆ kCSCSegmentDimension_

const int GEMEfficiencyAnalyzer::kCSCSegmentDimension_ = 4

private

Definition at line 158 of file GEMEfficiencyAnalyzer.h.

Referenced by findCSCSegmentBeam().

◆ kFolder_

const std::string GEMEfficiencyAnalyzer::kFolder_

private

Definition at line 127 of file GEMEfficiencyAnalyzer.h.

Referenced by bookHistograms().

◆ kGEMGeometryTokenBeginRun_

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

private

Definition at line 118 of file GEMEfficiencyAnalyzer.h.

Referenced by bookHistograms(), and dqmBeginRun().

◆ kGEMRecHitCollectionToken_

const edm::EDGetTokenT<GEMRecHitCollection> GEMEfficiencyAnalyzer::kGEMRecHitCollectionToken_

private

Definition at line 121 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze().

◆ kMatchingCut_

const float GEMEfficiencyAnalyzer::kMatchingCut_

private

Definition at line 143 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ kMatchingMetric_

const MatchingMetric GEMEfficiencyAnalyzer::kMatchingMetric_

private

Definition at line 142 of file GEMEfficiencyAnalyzer.h.

Referenced by bookHistograms(), and computeMatchingMetric().

◆ kModeDev_

const bool GEMEfficiencyAnalyzer::kModeDev_

private

Definition at line 151 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ kMuonEtaLow_

const std::vector<double> GEMEfficiencyAnalyzer::kMuonEtaLow_

private

Definition at line 147 of file GEMEfficiencyAnalyzer.h.

Referenced by bookHistograms().

◆ kMuonEtaMaxCuts_

const std::vector<double> GEMEfficiencyAnalyzer::kMuonEtaMaxCuts_

private

Definition at line 137 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ kMuonEtaMinCuts_

const std::vector<double> GEMEfficiencyAnalyzer::kMuonEtaMinCuts_

private

Definition at line 136 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ kMuonEtaNbins_

const std::vector<int> GEMEfficiencyAnalyzer::kMuonEtaNbins_

private

Definition at line 146 of file GEMEfficiencyAnalyzer.h.

Referenced by bookHistograms().

◆ kMuonEtaUp_

const std::vector<double> GEMEfficiencyAnalyzer::kMuonEtaUp_

private

Definition at line 148 of file GEMEfficiencyAnalyzer.h.

Referenced by bookHistograms().

◆ kMuonName_

const TString GEMEfficiencyAnalyzer::kMuonName_

private

Definition at line 126 of file GEMEfficiencyAnalyzer.h.

Referenced by bookHistograms().

◆ kMuonPtBins_

const std::vector<double> GEMEfficiencyAnalyzer::kMuonPtBins_

private

Definition at line 145 of file GEMEfficiencyAnalyzer.h.

Referenced by bookHistograms().

◆ kMuonPtMinCuts_

const std::vector<double> GEMEfficiencyAnalyzer::kMuonPtMinCuts_

private

Definition at line 135 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ kMuonSegmentMatchDRCut_

const float GEMEfficiencyAnalyzer::kMuonSegmentMatchDRCut_

private

Definition at line 133 of file GEMEfficiencyAnalyzer.h.

Referenced by findCSCSegmentCosmics().

◆ kMuonSubdetForGEM_

const std::vector<std::vector<int> > GEMEfficiencyAnalyzer::kMuonSubdetForGEM_

private

Definition at line 131 of file GEMEfficiencyAnalyzer.h.

Referenced by isMuonSubdetAllowed().

◆ kMuonTrackType_

const reco::Muon::MuonTrackType GEMEfficiencyAnalyzer::kMuonTrackType_

private

Definition at line 125 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze().

◆ kMuonTrackTypeName_

const std::string GEMEfficiencyAnalyzer::kMuonTrackTypeName_

private

Definition at line 124 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze().

◆ kMuonViewToken_

const edm::EDGetTokenT<edm::View<reco::Muon> > GEMEfficiencyAnalyzer::kMuonViewToken_

private

Definition at line 122 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze().

◆ kPropagationErrorPhiCut_

const float GEMEfficiencyAnalyzer::kPropagationErrorPhiCut_

private

Definition at line 139 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ kPropagationErrorRCut_

const float GEMEfficiencyAnalyzer::kPropagationErrorRCut_

private

Definition at line 138 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ kScenario_

const ScenarioOption GEMEfficiencyAnalyzer::kScenario_

private

Definition at line 128 of file GEMEfficiencyAnalyzer.h.

Referenced by bookHistograms(), checkPropagationDirection(), and findCSCSegment().

◆ kStartingStateType_

const StartingStateType GEMEfficiencyAnalyzer::kStartingStateType_

private

Definition at line 130 of file GEMEfficiencyAnalyzer.h.

Referenced by buildStartingState().

◆ kTransientTrackBuilderToken_

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

private

Definition at line 119 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze().

◆ me_chamber_ieta_

MEMap GEMEfficiencyAnalyzer::me_chamber_ieta_

private

Definition at line 168 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_chamber_ieta_matched_

MEMap GEMEfficiencyAnalyzer::me_chamber_ieta_matched_

private

Definition at line 168 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_cutflow_

MEMap GEMEfficiencyAnalyzer::me_cutflow_

private

Definition at line 187 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_cutflow_matched_

MEMap GEMEfficiencyAnalyzer::me_cutflow_matched_

private

Definition at line 187 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_matching_metric_

MEMap GEMEfficiencyAnalyzer::me_matching_metric_

private

Definition at line 175 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_matching_metric_all_

MEMap GEMEfficiencyAnalyzer::me_matching_metric_all_

private

Definition at line 174 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_charge_

MEMap GEMEfficiencyAnalyzer::me_muon_charge_

private

Definition at line 186 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_charge_matched_

MEMap GEMEfficiencyAnalyzer::me_muon_charge_matched_

private

Definition at line 186 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_eta_

MEMap GEMEfficiencyAnalyzer::me_muon_eta_

private

Definition at line 170 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_eta_all_

MEMap GEMEfficiencyAnalyzer::me_muon_eta_all_

private

Definition at line 185 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_eta_all_matched_

MEMap GEMEfficiencyAnalyzer::me_muon_eta_all_matched_

private

Definition at line 185 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_eta_matched_

MEMap GEMEfficiencyAnalyzer::me_muon_eta_matched_

private

Definition at line 170 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_phi_

MEMap GEMEfficiencyAnalyzer::me_muon_phi_

private

Definition at line 171 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_phi_matched_

MEMap GEMEfficiencyAnalyzer::me_muon_phi_matched_

private

Definition at line 171 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_pt_

MEMap GEMEfficiencyAnalyzer::me_muon_pt_

private

Definition at line 169 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_pt_all_

MEMap GEMEfficiencyAnalyzer::me_muon_pt_all_

private

Definition at line 184 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_pt_all_matched_

MEMap GEMEfficiencyAnalyzer::me_muon_pt_all_matched_

private

Definition at line 184 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_muon_pt_matched_

MEMap GEMEfficiencyAnalyzer::me_muon_pt_matched_

private

Definition at line 169 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_prop_err_phi_

MEMap GEMEfficiencyAnalyzer::me_prop_err_phi_

private

Definition at line 183 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_prop_err_phi_matched_

MEMap GEMEfficiencyAnalyzer::me_prop_err_phi_matched_

private

Definition at line 183 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_prop_err_r_

MEMap GEMEfficiencyAnalyzer::me_prop_err_r_

private

Definition at line 182 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_prop_err_r_matched_

MEMap GEMEfficiencyAnalyzer::me_prop_err_r_matched_

private

Definition at line 182 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_prop_path_length_

MEMap GEMEfficiencyAnalyzer::me_prop_path_length_

private

Definition at line 181 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_prop_path_length_matched_

MEMap GEMEfficiencyAnalyzer::me_prop_path_length_matched_

private

Definition at line 181 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_residual_phi_

MEMap GEMEfficiencyAnalyzer::me_residual_phi_

private

Definition at line 172 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_residual_phi_antimuon_

MEMap GEMEfficiencyAnalyzer::me_residual_phi_antimuon_

private

Definition at line 177 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_residual_phi_muon_

MEMap GEMEfficiencyAnalyzer::me_residual_phi_muon_

private

Definition at line 176 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_residual_strip_

MEMap GEMEfficiencyAnalyzer::me_residual_strip_

private

Definition at line 180 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_residual_x_

MEMap GEMEfficiencyAnalyzer::me_residual_x_

private

Definition at line 178 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ me_residual_y_

MEMap GEMEfficiencyAnalyzer::me_residual_y_

private

Definition at line 179 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), and bookHistograms().

◆ muon_service_

std::unique_ptr<MuonServiceProxy> GEMEfficiencyAnalyzer::muon_service_

private

Definition at line 163 of file GEMEfficiencyAnalyzer.h.

Referenced by analyze(), buildStartingStateAlignmentStyle(), buildStateOnSurfaceWithCSCSegment(), and findCSCSegmentBeam().

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ StartingState

Member Enumeration Documentation

◆ MatchingMetric

◆ ScenarioOption

◆ StartingStateType

Constructor & Destructor Documentation

◆ GEMEfficiencyAnalyzer()

◆ ~GEMEfficiencyAnalyzer()

Member Function Documentation

◆ analyze()

◆ bookHistograms()

◆ buildGEMLayers()

◆ buildStartingState()

◆ buildStartingStateAlignmentStyle()

◆ buildStateOnSurfaceWithCSCSegment()

◆ checkBounds() [1/2]

◆ checkBounds() [2/2]

◆ checkPropagationDirection()

◆ computeDeltaPhi()

◆ computeMatchingMetric()

◆ computeRdPhi()

◆ dqmBeginRun()

◆ fillDescriptions()

◆ findClosestHit()

◆ findCSCSegment()

◆ findCSCSegmentBeam()

◆ findCSCSegmentCosmics()

◆ findEtaPartition()

◆ getInnermostMeasurementState()

◆ getMatchingMetric()

◆ getMuonTrackType()

◆ getOutermostMeasurementState()

◆ getScenarioOption()

◆ getStartingStateType()

◆ isCSCAllowed()

◆ isInsideOut()

◆ isMuonSubdetAllowed()

Member Data Documentation

◆ gem_layers_

◆ kBoundsErrorScale_

◆ kCSCForGEM_

◆ kCSCSegmentDimension_

◆ kFolder_

◆ kGEMGeometryTokenBeginRun_

◆ kGEMRecHitCollectionToken_

◆ kMatchingCut_

◆ kMatchingMetric_

◆ kModeDev_

◆ kMuonEtaLow_

◆ kMuonEtaMaxCuts_

◆ kMuonEtaMinCuts_

◆ kMuonEtaNbins_

◆ kMuonEtaUp_

◆ kMuonName_

◆ kMuonPtBins_

◆ kMuonPtMinCuts_

◆ kMuonSegmentMatchDRCut_

◆ kMuonSubdetForGEM_

◆ kMuonTrackType_

◆ kMuonTrackTypeName_

◆ kMuonViewToken_

◆ kPropagationErrorPhiCut_

◆ kPropagationErrorRCut_

◆ kScenario_

◆ kStartingStateType_

◆ kTransientTrackBuilderToken_

◆ me_chamber_ieta_

◆ me_chamber_ieta_matched_

◆ me_cutflow_

◆ me_cutflow_matched_