#include <GEMEfficiencyAnalyzer.h>

Inheritance diagram for GEMEfficiencyAnalyzer:

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

	~GEMEfficiencyAnalyzer () override

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

template<typename AnyKey >
TString	convertKeyToStr (const AnyKey &key)

template<typename AnyKey >
void	fillME (std::map< AnyKey, MonitorElement * > &, const AnyKey &, const float)

template<typename AnyKey >
void	fillME (std::map< AnyKey, MonitorElement * > &, const AnyKey &, const float, const float y)

	GEMOfflineDQMBase (const edm::ParameterSet &)

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

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

int	getMaxVFAT (const int)

int	getNumEtaPartitions (const GEMStation *)

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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	bookDetectorOccupancy (DQMStore::IBooker &, const GEMStation *, const MEMapKey1 &, const TString &, const TString &)

void	bookOccupancy (DQMStore::IBooker &, const MEMapKey2 &, const TString &, const TString &)

void	bookResolution (DQMStore::IBooker &, const MEMapKey3 &, const TString &, const TString &)

const GEMRecHit *	findMatchedHit (const float, const GEMRecHitCollection::range &)

Private Attributes
double	eta_low_

int	eta_nbins_

double	eta_up_

std::string	folder_

TString	matched_title_

MEMap1	me_detector_

MEMap1	me_detector_matched_

MEMap2	me_muon_eta_

MEMap2	me_muon_eta_matched_

MEMap2	me_muon_pt_

MEMap2	me_muon_pt_matched_

MEMap3	me_pull_x_

MEMap3	me_pull_y_

MEMap3	me_residual_phi_

MEMap3	me_residual_x_

MEMap3	me_residual_y_

MuonServiceProxy *	muon_service_

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

std::vector< double >	pt_binning_

edm::EDGetTokenT< GEMRecHitCollection >	rechit_token_

float	residual_x_cut_

TString	title_

bool	use_global_muon_

Additional Inherited Members
Public Types inherited from GEMOfflineDQMBase
typedef std::map< MEMapKey1, MonitorElement * >	MEMap1

typedef std::map< MEMapKey2, MonitorElement * >	MEMap2

typedef std::map< MEMapKey3, MonitorElement * >	MEMap3

typedef std::tuple< int, int >	MEMapKey1

typedef std::tuple< int, int, bool >	MEMapKey2

typedef std::tuple< int, int, bool, int >	MEMapKey3

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 >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

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 &)

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

Definition at line 13 of file GEMEfficiencyAnalyzer.h.

Constructor & Destructor Documentation

◆ GEMEfficiencyAnalyzer()

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

explicit

Definition at line 8 of file GEMEfficiencyAnalyzer.cc.

                                                                         : GEMOfflineDQMBase(pset) {
   rechit_token_ = consumes<GEMRecHitCollection>(pset.getParameter<edm::InputTag>("recHitTag"));
   muon_token_ = consumes<edm::View<reco::Muon> >(pset.getParameter<edm::InputTag>("muonTag"));
  
   auto muon_service_parameter = pset.getParameter<edm::ParameterSet>("ServiceParameters");
   muon_service_ = new MuonServiceProxy(muon_service_parameter, consumesCollector());
  
   use_global_muon_ = pset.getUntrackedParameter<bool>("useGlobalMuon");
  
   residual_x_cut_ = static_cast<float>(pset.getParameter<double>("residualXCut"));
  
   pt_binning_ = pset.getUntrackedParameter<std::vector<double> >("ptBinning");
   eta_nbins_ = pset.getUntrackedParameter<int>("etaNbins");
   eta_low_ = pset.getUntrackedParameter<double>("etaLow");
   eta_up_ = pset.getUntrackedParameter<double>("etaUp");
  
   folder_ = pset.getUntrackedParameter<std::string>("folder");
  
   title_ = (use_global_muon_ ? "Global Muon" : "Standalone Muon");
   matched_title_ = title_ + TString::Format(" (|x_{Muon} - x_{Hit}| < %.1f)", residual_x_cut_);
 }

References eta_low_, eta_nbins_, eta_up_, folder_, matched_title_, muon_service_, muon_token_, MuonServiceProxy_cff::MuonServiceProxy, muonDTDigis_cfi::pset, pt_binning_, rechit_token_, residual_x_cut_, AlCaHLTBitMon_QueryRunRegistry::string, title_, and use_global_muon_.

◆ ~GEMEfficiencyAnalyzer()

GEMEfficiencyAnalyzer::~GEMEfficiencyAnalyzer ( )

override

Definition at line 30 of file GEMEfficiencyAnalyzer.cc.

30 {}

Member Function Documentation

◆ analyze()

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 146 of file GEMEfficiencyAnalyzer.cc.

                                                                                      {
   edm::Handle<GEMRecHitCollection> rechit_collection;
   event.getByToken(rechit_token_, rechit_collection);
   if (not rechit_collection.isValid()) {
     edm::LogError(log_category_) << "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(log_category_) << "View<Muon> is invalid" << std::endl;
   }
  
   edm::ESHandle<GEMGeometry> gem;
   setup.get<MuonGeometryRecord>().get(gem);
   if (not gem.isValid()) {
     edm::LogError(log_category_) << "GEMGeometry is invalid" << std::endl;
     return;
   }
  
   edm::ESHandle<TransientTrackBuilder> transient_track_builder;
   setup.get<TransientTrackRecord>().get("TransientTrackBuilder", transient_track_builder);
   if (not transient_track_builder.isValid()) {
     edm::LogError(log_category_) << "TransientTrackRecord is invalid" << std::endl;
     return;
   }
  
   muon_service_->update(setup);
   edm::ESHandle<Propagator>&& propagator = muon_service_->propagator("SteppingHelixPropagatorAny");
   if (not propagator.isValid()) {
     edm::LogError(log_category_) << "Propagator is invalid" << std::endl;
     return;
   }
  
   for (const reco::Muon& muon : *muon_view) {
     const reco::Track* track = nullptr;
  
     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();
     }
  
     if (track == nullptr) {
       edm::LogError(log_category_) << "failed to get muon track" << std::endl;
       continue;
     }
  
     const reco::TransientTrack&& transient_track = transient_track_builder->build(track);
     if (not transient_track.isValid()) {
       edm::LogInfo(log_category_) << "failed to build TransientTrack" << std::endl;
       continue;
     }
  
     for (const GEMEtaPartition* eta_partition : gem->etaPartitions()) {
       // Skip propagation inn the opposite direction.
       if (muon.eta() * eta_partition->id().region() < 0)
         continue;
  
       const BoundPlane& bound_plane = eta_partition->surface();
  
       const TrajectoryStateOnSurface&& tsos =
           propagator->propagate(transient_track.outermostMeasurementState(), bound_plane);
       if (not tsos.isValid()) {
         continue;
       }
  
       const LocalPoint&& tsos_local_pos = tsos.localPosition();
       const LocalPoint tsos_local_pos_2d(tsos_local_pos.x(), tsos_local_pos.y(), 0.0f);
       if (not bound_plane.bounds().inside(tsos_local_pos_2d)) {
         continue;
       }
  
       const GEMDetId&& gem_id = eta_partition->id();
  
       bool is_odd = gem_id.station() == 1 ? (gem_id.chamber() % 2 == 1) : false;
       const std::tuple<int, int> key1{gem_id.region(), gem_id.station()};
       const std::tuple<int, int, bool> key2{gem_id.region(), gem_id.station(), is_odd};
       const std::tuple<int, int, bool, int> key3{gem_id.region(), gem_id.station(), is_odd, gem_id.roll()};
  
       const int chamber_bin = getDetOccXBin(gem_id, gem);
  
       fillME(me_detector_, key1, chamber_bin, gem_id.roll());
       fillME(me_muon_pt_, key2, muon.pt());
       fillME(me_muon_eta_, key2, std::fabs(muon.eta()));
  
       const GEMRecHit* matched_hit = findMatchedHit(tsos_local_pos.x(), rechit_collection->get(gem_id));
       if (matched_hit == nullptr) {
         continue;
       }
  
       fillME(me_detector_matched_, key1, chamber_bin, gem_id.roll());
       fillME(me_muon_pt_matched_, key2, muon.pt());
       fillME(me_muon_eta_matched_, key2, std::fabs(muon.eta()));
  
       const LocalPoint&& hit_local_pos = matched_hit->localPosition();
       const GlobalPoint&& hit_global_pos = eta_partition->toGlobal(hit_local_pos);
       const GlobalPoint&& tsos_global_pos = tsos.globalPosition();
  
       const float residual_x = tsos_local_pos.x() - hit_local_pos.x();
       const float residual_y = tsos_local_pos.y() - hit_local_pos.y();
       const float residual_phi = reco::deltaPhi(tsos_global_pos.barePhi(), hit_global_pos.barePhi());
  
       const LocalError&& tsos_err = tsos.localError().positionError();
       const LocalError&& hit_err = matched_hit->localPositionError();
  
       const float pull_x = residual_x / std::sqrt(tsos_err.xx() + hit_err.xx());
       const float pull_y = residual_y / std::sqrt(tsos_err.yy() + hit_err.yy());
  
       fillME(me_residual_x_, key3, residual_x);
       fillME(me_residual_y_, key3, residual_y);
       fillME(me_residual_phi_, key3, residual_phi);
  
       fillME(me_pull_x_, key3, pull_x);
       fillME(me_pull_y_, key3, pull_y);
     }  // GEMChamber
   }    // Muon
 }

References PV3DBase< T, PVType, FrameType >::barePhi(), TransientTrackBuilder::build(), GEMDetId::chamber(), chamber_bin(), reco::deltaPhi(), GEMOfflineDQMBase::fillME(), findMatchedHit(), mixOne_premix_on_sim_cfi::gem, get, GEMOfflineDQMBase::getDetOccXBin(), TrajectoryStateOnSurface::globalPosition(), edm::ESHandleBase::isValid(), TrajectoryStateOnSurface::isValid(), edm::HandleBase::isValid(), reco::TransientTrack::isValid(), TrajectoryStateOnSurface::localError(), GEMRecHit::localPosition(), TrajectoryStateOnSurface::localPosition(), GEMRecHit::localPositionError(), GEMOfflineDQMBase::log_category_, me_detector_, me_detector_matched_, me_muon_eta_, me_muon_eta_matched_, me_muon_pt_, me_muon_pt_matched_, me_pull_x_, me_pull_y_, me_residual_phi_, me_residual_x_, me_residual_y_, muon_service_, muon_token_, reco::TransientTrack::outermostMeasurementState(), LocalTrajectoryError::positionError(), TrackCandidateProducer_cfi::propagator, MuonServiceProxy::propagator(), rechit_token_, GEMDetId::region(), GEMDetId::roll(), singleTopDQM_cfi::setup, mathSSE::sqrt(), GEMDetId::station(), HLT_2018_cff::track, MuonServiceProxy::update(), use_global_muon_, PV3DBase< T, PVType, FrameType >::x(), LocalError::xx(), PV3DBase< T, PVType, FrameType >::y(), and LocalError::yy().

◆ bookDetectorOccupancy()

void GEMEfficiencyAnalyzer::bookDetectorOccupancy	(	DQMStore::IBooker &	ibooker,
		const GEMStation *	station,
		const MEMapKey1 &	key,
		const TString &	name_suffix,
		const TString &	title_suffix
	)

private

Definition at line 87 of file GEMEfficiencyAnalyzer.cc.

                                                                                {
   ibooker.setCurrentFolder(folder_ + "/Efficiency");
   BookingHelper helper(ibooker, name_suffix, title_suffix);
  
   const auto&& superchambers = station->superChambers();
   if (not checkRefs(superchambers)) {
     edm::LogError(log_category_) << "failed to get a valid vector of GEMSuperChamber ptrs" << std::endl;
     return;
   }
  
   // the number of GEMChambers per GEMStation
   const int num_ch = superchambers.size() * superchambers.front()->nChambers();
   // the number of eta partitions per GEMChamber
   const int num_etas = getNumEtaPartitions(station);
  
   me_detector_[key] = helper.book2D("detector", title_, num_ch, 0.5, num_ch + 0.5, num_etas, 0.5, num_etas + 0.5);
  
   me_detector_matched_[key] =
       helper.book2D("detector_matched", matched_title_, num_ch, 0.5, num_ch + 0.5, num_etas, 0.5, num_etas + 0.5);
  
   setDetLabelsEta(me_detector_[key], station);
   setDetLabelsEta(me_detector_matched_[key], station);
 }

References GEMOfflineDQMBase::checkRefs(), folder_, GEMOfflineDQMBase::getNumEtaPartitions(), crabWrapper::key, GEMOfflineDQMBase::log_category_, matched_title_, me_detector_, me_detector_matched_, dqm::implementation::NavigatorBase::setCurrentFolder(), GEMOfflineDQMBase::setDetLabelsEta(), relativeConstraints::station, and title_.

Referenced by bookHistograms().

◆ bookHistograms()

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 32 of file GEMEfficiencyAnalyzer.cc.

                                                                         {
   edm::ESHandle<GEMGeometry> gem;
   isetup.get<MuonGeometryRecord>().get(gem);
   if (not gem.isValid()) {
     edm::LogError(log_category_) << "GEMGeometry is invalid" << std::endl;
     return;
   }
  
   for (const GEMRegion* region : gem->regions()) {
     const int region_number = region->region();
     const char* region_sign = region_number > 0 ? "+" : "-";
  
     for (const GEMStation* station : region->stations()) {
       const int station_number = station->station();
  
       const MEMapKey1 key1{region_number, station_number};
       const auto&& station_name_suffix = TString::Format("_ge%s%d1", region_sign, station_number);
       const auto&& station_title_suffix = TString::Format(" : GE %s%d/1", region_sign, station_number);
       bookDetectorOccupancy(ibooker, station, key1, station_name_suffix, station_title_suffix);
  
       const int num_etas = getNumEtaPartitions(station);
  
       if (station_number == 1) {
         for (const bool is_odd : {true, false}) {
           std::tuple<int, int, bool> key2{region_number, station_number, is_odd};
           const TString&& parity_name_suffix = station_name_suffix + (is_odd ? "_odd" : "_even");
           const TString&& parity_title_suffix =
               station_title_suffix + (is_odd ? ", Odd Superchamber" : ", Even Superchamber");
           bookOccupancy(ibooker, key2, parity_name_suffix, parity_title_suffix);
  
           for (int ieta = 1; ieta <= num_etas; ieta++) {
             const TString&& ieta_name_suffix = parity_name_suffix + Form("_ieta%d", ieta);
             const TString&& ieta_title_suffix = parity_title_suffix + Form(", i#eta = %d", ieta);
             const MEMapKey3 key3{region_number, station_number, is_odd, ieta};
             bookResolution(ibooker, key3, ieta_name_suffix, ieta_title_suffix);
           }  // ieta
         }    // is_odd
  
       } else {
         std::tuple<int, int, bool> key2{region_number, station_number, false};
         bookOccupancy(ibooker, key2, station_name_suffix, station_title_suffix);
  
         for (int ieta = 1; ieta <= num_etas; ieta++) {
           const MEMapKey3 key3{region_number, station_number, false, ieta};
           const TString&& ieta_name_suffix = station_name_suffix + Form("_ieta%d", ieta);
           const TString&& ieta_title_suffix = station_title_suffix + Form(", i#eta = %d", ieta);
           bookResolution(ibooker, key3, ieta_name_suffix, ieta_title_suffix);
         }  // ieta
       }
     }  // station
   }    // region
 }

References bookDetectorOccupancy(), bookOccupancy(), bookResolution(), mixOne_premix_on_sim_cfi::gem, edm::EventSetup::get(), get, GEMOfflineDQMBase::getNumEtaPartitions(), LEDCalibrationChannels::ieta, GEMOfflineDQMBase::log_category_, HLT_2018_cff::region, and relativeConstraints::station.

◆ bookOccupancy()

void GEMEfficiencyAnalyzer::bookOccupancy	(	DQMStore::IBooker &	ibooker,
		const MEMapKey2 &	key,
		const TString &	name_suffix,
		const TString &	title_suffix
	)

private

Definition at line 115 of file GEMEfficiencyAnalyzer.cc.

                                                                        {
   ibooker.setCurrentFolder(folder_ + "/Efficiency");
   BookingHelper helper(ibooker, name_suffix, title_suffix);
  
   me_muon_pt_[key] = helper.book1D("muon_pt", title_, pt_binning_, "Muon p_{T} [GeV]");
   me_muon_eta_[key] = helper.book1D("muon_eta", title_, eta_nbins_, eta_low_, eta_up_, "Muon |#eta|");
  
   me_muon_pt_matched_[key] = helper.book1D("muon_pt_matched", matched_title_, pt_binning_, "Muon p_{T} [GeV]");
   me_muon_eta_matched_[key] =
       helper.book1D("muon_eta_matched", matched_title_, eta_nbins_, eta_low_, eta_up_, "Muon |#eta|");
 }

References eta_low_, eta_nbins_, eta_up_, folder_, crabWrapper::key, matched_title_, me_muon_eta_, me_muon_eta_matched_, me_muon_pt_, me_muon_pt_matched_, pt_binning_, dqm::implementation::NavigatorBase::setCurrentFolder(), and title_.

Referenced by bookHistograms().

◆ bookResolution()

void GEMEfficiencyAnalyzer::bookResolution	(	DQMStore::IBooker &	ibooker,
		const MEMapKey3 &	key,
		const TString &	name_suffix,
		const TString &	title_suffix
	)

private

Definition at line 130 of file GEMEfficiencyAnalyzer.cc.

                                                                         {
   ibooker.setCurrentFolder(folder_ + "/Resolution");
   BookingHelper helper(ibooker, name_suffix, title_suffix);
  
   // NOTE Residual & Pull
   me_residual_x_[key] = helper.book1D("residual_x", title_, 50, -5.0, 5.0, "Residual in Local X [cm]");
   me_residual_y_[key] = helper.book1D("residual_y", title_, 60, -12.0, 12.0, "Residual in Local Y [cm]");
   me_residual_phi_[key] = helper.book1D("residual_phi", title_, 80, -0.008, 0.008, "Residual in Global #phi [rad]");
  
   me_pull_x_[key] = helper.book1D("pull_x", title_, 60, -3.0, 3.0, "Pull in Local X");
   me_pull_y_[key] = helper.book1D("pull_y", title_, 60, -3.0, 3.0, "Pull in Local Y");
 }

References folder_, crabWrapper::key, me_pull_x_, me_pull_y_, me_residual_phi_, me_residual_x_, me_residual_y_, dqm::implementation::NavigatorBase::setCurrentFolder(), and title_.

Referenced by bookHistograms().

◆ findMatchedHit()

const GEMRecHit * GEMEfficiencyAnalyzer::findMatchedHit	(	const float	track_local_x,
		const GEMRecHitCollection::range &	range
	)

private

Definition at line 267 of file GEMEfficiencyAnalyzer.cc.

                                                                                               {
   float min_residual_x{residual_x_cut_};
   const GEMRecHit* closest_hit = nullptr;
  
   for (auto hit = range.first; hit != range.second; ++hit) {
     float residual_x = std::fabs(track_local_x - hit->localPosition().x());
     if (residual_x <= min_residual_x) {
       min_residual_x = residual_x;
       closest_hit = &(*hit);
     }
   }
  
   return closest_hit;
 }