#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	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () 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_FULL_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_FULL_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;
 }