#include <ME0SegmentsValidation.h>

Inheritance diagram for ME0SegmentsValidation:

Public Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &) override

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

std::pair< int, int >	isMatched (ME0DetId, LocalPoint, edm::Handle< ME0DigiPreRecoCollection >)

bool	isSimMatched (edm::SimTrackContainer::const_iterator, edm::PSimHitContainer::const_iterator)

bool	isSimTrackGood (edm::SimTrackContainer::const_iterator simTrack)

	ME0SegmentsValidation (const edm::ParameterSet &)

	~ME0SegmentsValidation () override

Public Member Functions inherited from ME0BaseValidation
MonitorElement *	BookHistXY (DQMStore::IBooker &, const char name, const char label, unsigned int region_num, unsigned int layer_num=99)

MonitorElement *	BookHistZR (DQMStore::IBooker &, const char name, const char label, unsigned int region_num, unsigned int layer_num=99)

	ME0BaseValidation (const edm::ParameterSet &ps)

	~ME0BaseValidation () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Types
typedef std::map < ME0SegmentCollection::const_iterator, std::vector< ME0RecHit > >	MapTypeSeg

typedef std::map < edm::SimTrackContainer::const_iterator, edm::PSimHitContainer >	MapTypeSim

Private Attributes
double	eta_max_

double	eta_min_

edm::EDGetToken	InputTagToken_

edm::EDGetToken	InputTagToken_Digis

edm::EDGetToken	InputTagToken_Segments

edm::EDGetToken	InputTagTokenST_

bool	isMuonGun_

MonitorElement *	me0_matchedsimsegment_eta

MonitorElement *	me0_matchedsimsegment_phi

MonitorElement *	me0_matchedsimsegment_pt

MonitorElement *	me0_rh_xy_Muon [2][6]

MonitorElement *	me0_segment_chi2

MonitorElement *	me0_segment_EtaRH

MonitorElement *	me0_segment_ndof

MonitorElement *	me0_segment_numRH

MonitorElement *	me0_segment_numRHBkg

MonitorElement *	me0_segment_numRHSig

MonitorElement *	me0_segment_PhiRH

MonitorElement *	me0_segment_redchi2

MonitorElement *	me0_segment_size

MonitorElement *	me0_segment_time

MonitorElement *	me0_segment_timeErr

MonitorElement *	me0_simsegment_eta

MonitorElement *	me0_simsegment_phi

MonitorElement *	me0_simsegment_pt

MonitorElement *	me0_specRH_DeltaX [2][6]

MonitorElement *	me0_specRH_DeltaY [2][6]

MonitorElement *	me0_specRH_PullX [2][6]

MonitorElement *	me0_specRH_PullY [2][6]

MonitorElement *	me0_specRH_xy [2][6]

MonitorElement *	me0_specRH_zr [2]

int	npart

double	pt_min_

double	sigma_x_

double	sigma_y_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

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 inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes inherited from ME0BaseValidation
edm::ESGetToken< ME0Geometry, MuonGeometryRecord >	geomToken_

edm::EDGetToken	InputTagToken_

std::vector< std::string >	layerLabel

int	nBinXY_

std::vector< double >	nBinZR_

std::vector< double >	RangeZR_

std::vector< std::string >	regionLabel

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 9 of file ME0SegmentsValidation.h.

Member Typedef Documentation

typedef std::map<ME0SegmentCollection::const_iterator, std::vector<ME0RecHit> > ME0SegmentsValidation::MapTypeSeg

private

Definition at line 49 of file ME0SegmentsValidation.h.

typedef std::map<edm::SimTrackContainer::const_iterator, edm::PSimHitContainer> ME0SegmentsValidation::MapTypeSim

private

Definition at line 48 of file ME0SegmentsValidation.h.

Constructor & Destructor Documentation

ME0SegmentsValidation::ME0SegmentsValidation ( const edm::ParameterSet & cfg )

explicit

Definition at line 5 of file ME0SegmentsValidation.cc.

References eta_max_, eta_min_, edm::ParameterSet::getParameter(), InputTagToken_, InputTagToken_Digis, InputTagToken_Segments, InputTagTokenST_, isMuonGun_, pt_min_, sigma_x_, and sigma_y_.

                                                                        : ME0BaseValidation(cfg) {
   InputTagToken_Segments = consumes<ME0SegmentCollection>(cfg.getParameter<edm::InputTag>("segmentInputLabel"));
   InputTagToken_Digis = consumes<ME0DigiPreRecoCollection>(cfg.getParameter<edm::InputTag>("digiInputLabel"));
   InputTagToken_ = consumes<edm::PSimHitContainer>(cfg.getParameter<edm::InputTag>("simInputLabel"));
   InputTagTokenST_ = consumes<edm::SimTrackContainer>(cfg.getParameter<edm::InputTag>("simInputLabelST"));
   sigma_x_ = cfg.getParameter<double>("sigma_x");
   sigma_y_ = cfg.getParameter<double>("sigma_y");
   eta_max_ = cfg.getParameter<double>("eta_max");
   eta_min_ = cfg.getParameter<double>("eta_min");
   pt_min_ = cfg.getParameter<double>("pt_min");
   isMuonGun_ = cfg.getParameter<bool>("isMuonGun");
 }

ME0SegmentsValidation::~ME0SegmentsValidation ( )

override

Definition at line 105 of file ME0SegmentsValidation.cc.

105 {}

Member Function Documentation

void ME0SegmentsValidation::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Implements ME0BaseValidation.

Definition at line 107 of file ME0SegmentsValidation.cc.

References funct::abs(), ME0Geometry::chamber(), HLT_FULL_cff::chi2, submitPVResolutionJobs::count, PV3DBase< T, PVType, FrameType >::eta(), ME0Geometry::etaPartition(), dqm::impl::MonitorElement::Fill(), ME0BaseValidation::geomToken_, edm::Event::getByToken(), edm::EventSetup::getData(), runTauDisplay::gp, gpuClustering::id, ME0Geometry::idToDet(), InputTagToken_, InputTagToken_Digis, InputTagToken_Segments, InputTagTokenST_, isMatched(), isSimMatched(), isSimTrackGood(), edm::HandleBase::isValid(), phase1PixelTopology::layer, me0_matchedsimsegment_eta, me0_matchedsimsegment_phi, me0_matchedsimsegment_pt, me0_segment_chi2, me0_segment_ndof, me0_segment_numRH, me0_segment_numRHBkg, me0_segment_numRHSig, me0_segment_redchi2, me0_segment_size, me0_segment_time, me0_segment_timeErr, me0_simsegment_eta, me0_simsegment_phi, me0_simsegment_pt, me0_specRH_DeltaX, me0_specRH_DeltaY, me0_specRH_PullX, me0_specRH_PullY, me0_specRH_xy, me0_specRH_zr, ndof, PV3DBase< T, PVType, FrameType >::phi(), quality, HLT_FULL_cff::region, mps_fire::result, sigma_x_, sigma_y_, cscDigiValidation_cfi::simTrack, mathSSE::sqrt(), GeomDet::surface(), Surface::toGlobal(), x, and y.

                                                                                   {
   const ME0Geometry *ME0Geometry_ = &iSetup.getData(geomToken_);
 
   edm::Handle<edm::PSimHitContainer> ME0Hits;
   e.getByToken(InputTagToken_, ME0Hits);
 
   edm::Handle<edm::SimTrackContainer> simTracks;
   e.getByToken(InputTagTokenST_, simTracks);
 
   edm::Handle<ME0SegmentCollection> ME0Segments;
   e.getByToken(InputTagToken_Segments, ME0Segments);
 
   edm::Handle<ME0DigiPreRecoCollection> ME0Digis;
   e.getByToken(InputTagToken_Digis, ME0Digis);
 
   if (!ME0Digis.isValid()) {
     edm::LogError("ME0SegmentsValidation") << "Cannot get ME0Digis by Token InputTagToken";
     return;
   }
 
   if (!ME0Segments.isValid()) {
     edm::LogError("ME0SegmentsValidation") << "Cannot get ME0RecHits/ME0Segments by Token InputTagToken";
     return;
   }
 
   if (!ME0Hits.isValid()) {
     edm::LogError("ME0HitsValidation") << "Cannot get ME0Hits by Token simInputTagToken";
     return;
   }
 
   MapTypeSim myMap;
   MapTypeSeg myMapSeg;
 
   int countST = 0;
 
   edm::SimTrackContainer::const_iterator simTrack;
   for (simTrack = simTracks->begin(); simTrack != simTracks->end(); ++simTrack) {
     edm::PSimHitContainer selectedME0Hits;
 
     if (!isSimTrackGood(simTrack))
       continue;
     int count = 0;
 
     for (edm::PSimHitContainer::const_iterator itHit = ME0Hits->begin(); itHit != ME0Hits->end(); ++itHit) {
       int particleType_sh = itHit->particleType();
       int evtId_sh = itHit->eventId().event();
       int bx_sh = itHit->eventId().bunchCrossing();
       int procType_sh = itHit->processType();
       if (!(abs(particleType_sh) == 13 && evtId_sh == 0 && bx_sh == 0 && procType_sh == 0))
         continue;
 
       if (isSimMatched(simTrack, itHit)) {
         ++count;
         selectedME0Hits.push_back(*itHit);
         ;
       }
 
     }  // End loop SHs
 
     if (selectedME0Hits.size() >= 3) {
       myMap.insert(MapTypeSim::value_type(simTrack, selectedME0Hits));
       me0_simsegment_eta->Fill(std::abs((*simTrack).momentum().eta()));
       me0_simsegment_pt->Fill((*simTrack).momentum().pt());
       me0_simsegment_phi->Fill((*simTrack).momentum().phi());
       ++countST;
     }
   }
 
   me0_segment_size->Fill(ME0Segments->size());
 
   for (auto me0s = ME0Segments->begin(); me0s != ME0Segments->end(); me0s++) {
     // The ME0 Ensamble DetId refers to layer = 1
     ME0DetId id = me0s->me0DetId();
     auto chamber = ME0Geometry_->chamber(id);
     auto segLP = me0s->localPosition();
     auto segLD = me0s->localDirection();
     auto me0rhs = me0s->specificRecHits();
 
     //   float localX = segLP.x();
     //   float localY = segLP.y();
     //   float dirTheta = segLD.theta();
     //   float dirPhi = segLD.phi();
     int numberRH = me0rhs.size();
     float chi2 = (float)me0s->chi2();
     float ndof = me0s->degreesOfFreedom();
     double time = me0s->time();
     double timeErr = me0s->timeErr();
 
     float reducedChi2 = chi2 / ndof;
 
     me0_segment_chi2->Fill(chi2);
     me0_segment_redchi2->Fill(reducedChi2);
     me0_segment_ndof->Fill(ndof);
     me0_segment_numRH->Fill(numberRH);
 
     me0_segment_time->Fill(time);
     me0_segment_timeErr->Fill(timeErr);
 
     int numberRHSig = 0;
     int numberRHBkg = 0;
     std::vector<ME0RecHit> selectedME0RecHits;
 
     for (auto rh = me0rhs.begin(); rh != me0rhs.end(); rh++) {
       auto me0id = rh->me0Id();
       auto rhr = ME0Geometry_->etaPartition(me0id);
       auto rhLP = rh->localPosition();
 
       auto result = isMatched(me0id, rhLP, ME0Digis);
       if (result.second == 1) {
         ++numberRHSig;
         selectedME0RecHits.push_back(*rh);
 
       } else
         ++numberRHBkg;
 
       auto erhLEP = rh->localPositionError();
       auto rhGP = rhr->toGlobal(rhLP);
       auto rhLPSegm = chamber->toLocal(rhGP);
       float xe = segLP.x() + segLD.x() * rhLPSegm.z() / segLD.z();
       float ye = segLP.y() + segLD.y() * rhLPSegm.z() / segLD.z();
       float ze = rhLPSegm.z();
       LocalPoint extrPoint(xe, ye, ze);                           // in segment rest frame
       auto extSegm = rhr->toLocal(chamber->toGlobal(extrPoint));  // in layer restframe
 
       int region = me0id.region();
       int layer = me0id.layer();
       //     int chamber = me0id.chamber();
 
       float x = rhLP.x();
       float xErr = erhLEP.xx();
       float y = rhLP.y();
       float yErr = erhLEP.yy();
 
       float globalR = rhGP.perp();
       float globalX = rhGP.x();
       float globalY = rhGP.y();
       float globalZ = rhGP.z();
 
       float xExt = extSegm.x();
       float yExt = extSegm.y();
 
       float pull_x = (x - xExt) / sqrt(xErr);
       float pull_y = (y - yExt) / sqrt(yErr);
 
       int region_num = 0;
       if (region == -1)
         region_num = 0;
       else if (region == 1)
         region_num = 1;
       int layer_num = layer - 1;
 
       me0_specRH_xy[region_num][layer_num]->Fill(globalX, globalY);
       me0_specRH_zr[region_num]->Fill(globalZ, globalR);
 
       me0_specRH_DeltaX[region_num][layer_num]->Fill(x - xExt);
       me0_specRH_DeltaY[region_num][layer_num]->Fill(y - yExt);
       me0_specRH_PullX[region_num][layer_num]->Fill(pull_x);
       me0_specRH_PullY[region_num][layer_num]->Fill(pull_y);
     }
 
     me0_segment_numRHSig->Fill(numberRHSig);
     me0_segment_numRHBkg->Fill(numberRHBkg);
     myMapSeg.insert(MapTypeSeg::value_type(me0s, selectedME0RecHits));
   }
 
   //------------------- SimToReco -------------------
 
   for (auto const &st : myMap) {  // loop over the signal simTracks
 
     int num_sh = st.second.size();
     bool isThereOneSegmentMatched = false;
 
     for (auto const &seg : myMapSeg) {  // loop over the reconstructed me0 segments
 
       int num_sh_matched = 0;
       if (seg.second.empty())
         continue;
 
       for (auto const &sh : st.second) {  // loop over the me0 simHits left by
                                           // the signal simTracks
 
         for (auto const &rh : seg.second) {  // loop over the tracking recHits
                                              // already matched to signal digis
 
           auto me0id = rh.me0Id();
           int region_rh = (int)me0id.region();
           int layer_rh = (int)me0id.layer();
           int chamber_rh = (int)me0id.chamber();
           int roll_rh = (int)me0id.roll();
 
           const ME0DetId id(sh.detUnitId());
           int region_sh = id.region();
           int layer_sh = id.layer();
           int chamber_sh = id.chamber();
           int roll_sh = id.roll();
 
           if (!(region_sh == region_rh && chamber_sh == chamber_rh && layer_sh == layer_rh && roll_sh == roll_rh))
             continue;
 
           LocalPoint lp_sh = sh.localPosition();
           LocalPoint lp_rh = rh.localPosition();
 
           GlobalPoint gp_sh = ME0Geometry_->idToDet(id)->surface().toGlobal(lp_sh);
           GlobalPoint gp = ME0Geometry_->idToDet((rh).me0Id())->surface().toGlobal(lp_rh);
           float dphi_glob = gp_sh.phi() - gp.phi();
           float deta_glob = gp_sh.eta() - gp.eta();
 
           if (fabs(dphi_glob) < 3 * sigma_x_ && fabs(deta_glob) < 3 * sigma_y_)
             ++num_sh_matched;
 
         }  // End loop over RHs
 
       }  // End loop over SHs
 
       float quality = 0;
       if (num_sh != 0)
         quality = num_sh_matched / (1.0 * num_sh);
       if (quality > 0)
         isThereOneSegmentMatched = true;
 
     }  // End loop over segments
 
     // Fill hsitograms
     if (isThereOneSegmentMatched) {
       me0_matchedsimsegment_eta->Fill(std::abs((*(st.first)).momentum().eta()));
       me0_matchedsimsegment_pt->Fill((*(st.first)).momentum().pt());
       me0_matchedsimsegment_phi->Fill((*(st.first)).momentum().phi());
     }
 
   }  // End loop over STs
 }

void ME0SegmentsValidation::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	Run,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 18 of file ME0SegmentsValidation.cc.

References dqm::implementation::IBooker::book1D(), ME0BaseValidation::BookHistXY(), ME0BaseValidation::BookHistZR(), ME0BaseValidation::layerLabel, LogDebug, M_PI, me0_matchedsimsegment_eta, me0_matchedsimsegment_phi, me0_matchedsimsegment_pt, me0_segment_chi2, me0_segment_ndof, me0_segment_numRH, me0_segment_numRHBkg, me0_segment_numRHSig, me0_segment_redchi2, me0_segment_size, me0_segment_time, me0_segment_timeErr, me0_simsegment_eta, me0_simsegment_phi, me0_simsegment_pt, me0_specRH_DeltaX, me0_specRH_DeltaY, me0_specRH_PullX, me0_specRH_PullY, me0_specRH_xy, me0_specRH_zr, ME0BaseValidation::regionLabel, dqm::implementation::NavigatorBase::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                         {
   LogDebug("MuonME0SegmentsValidation") << "Info : Loading Geometry information\n";
   ibooker.setCurrentFolder("MuonME0RecHitsV/ME0SegmentsTask");
 
   unsigned int nregion = 2;
 
   edm::LogInfo("MuonME0SegmentsValidation") << "+++ Info : # of region : " << nregion << std::endl;
 
   LogDebug("MuonME0SegmentsValidation") << "+++ Info : finish to get geometry information from ES.\n";
 
   me0_simsegment_eta = ibooker.book1D("me0_simsegment_eta", "SimSegment Eta Distribution; #eta; entries", 8, 2.0, 2.8);
   me0_simsegment_pt = ibooker.book1D("me0_simsegment_pt", "SimSegment pT Distribution; p_{T}; entries", 20, 0.0, 100.0);
   me0_simsegment_phi =
       ibooker.book1D("me0_simsegment_phi", "SimSegments phi Distribution; #phi; entries", 18, -M_PI, +M_PI);
 
   me0_matchedsimsegment_eta =
       ibooker.book1D("me0_matchedsimsegment_eta", "Matched SimSegment Eta Distribution; #eta; entries", 8, 2.0, 2.8);
   me0_matchedsimsegment_pt =
       ibooker.book1D("me0_matchedsimsegment_pt", "Matched SimSegment pT Distribution; p_{T}; entries", 20, 0.0, 100.0);
   me0_matchedsimsegment_phi = ibooker.book1D(
       "me0_matchedsimsegment_phi", "Matched SimSegments phi Distribution; #phi; entries", 18, -M_PI, +M_PI);
 
   me0_segment_chi2 = ibooker.book1D("me0_seg_Chi2", "#chi^{2}; #chi^{2}; # Segments", 100, 0, 100);
   me0_segment_redchi2 = ibooker.book1D("me0_seg_ReducedChi2", "#chi^{2}/ndof; #chi^{2}/ndof; # Segments", 100, 0, 5);
   me0_segment_ndof = ibooker.book1D("me0_seg_ndof", "ndof; ndof; #Segments", 50, 0, 50);
   me0_segment_numRH =
       ibooker.book1D("me0_seg_NumberRH", "Number of fitted RecHits; # RecHits; entries", 11, -0.5, 10.5);
   me0_segment_numRHSig =
       ibooker.book1D("me0_seg_NumberRHSig", "Number of fitted Signal RecHits; # RecHits; entries", 11, -0.5, 10.5);
   me0_segment_numRHBkg =
       ibooker.book1D("me0_seg_NumberRHBkg", "Number of fitted BKG RecHits; # RecHits; entries", 11, -0.5, 10.5);
   // me0_segment_EtaRH   = ibooker.book1D("me0_specRH_globalEta","Fitted RecHits
   // Eta Distribution; #eta; entries",200,-4.0,4.0); me0_segment_PhiRH   =
   // ibooker.book1D("me0_specRH_globalPhi","Fitted RecHits Phi Distribution;
   // #eta; entries",18,-3.14,3.14);
   me0_segment_time = ibooker.book1D("me0_seg_time", "Segment Timing; ns; entries", 300, -150, 150);
   me0_segment_timeErr = ibooker.book1D("me0_seg_timErr", "Segment Timing Error; ns; entries", 50, 0, 0.5);
   me0_segment_size =
       ibooker.book1D("me0_seg_size", "Segment Multiplicity; Number of ME0 segments; entries", 200, 0, 200);
 
   for (unsigned int region_num = 0; region_num < nregion; region_num++) {
     me0_specRH_zr[region_num] = BookHistZR(ibooker, "me0_specRH_tot", "Segment RecHits", region_num);
     for (unsigned int layer_num = 0; layer_num < 6; layer_num++) {
       // me0_strip_dg_zr[region_num][layer_num] =
       // BookHistZR(ibooker,"me0_strip_dg","SimHit",region_num,layer_num);
       me0_specRH_xy[region_num][layer_num] =
           BookHistXY(ibooker, "me0_specRH", "Segment RecHits", region_num, layer_num);
       // me0_rh_xy_Muon[region_num][layer_num] =
       // BookHistXY(ibooker,"me0_rh","RecHit Muon",region_num,layer_num);
 
       std::string histo_name_DeltaX =
           std::string("me0_specRH_DeltaX_r") + regionLabel[region_num] + "_l" + layerLabel[layer_num];
       std::string histo_name_DeltaY =
           std::string("me0_specRH_DeltaY_r") + regionLabel[region_num] + "_l" + layerLabel[layer_num];
       std::string histo_label_DeltaX = "Segment RecHits Delta X : region" + regionLabel[region_num] + " layer " +
                                        layerLabel[layer_num] + " " + " ; x_{SimHit} - x_{Segment RecHits} ; entries";
       std::string histo_label_DeltaY = "Segment RecHits Delta Y : region" + regionLabel[region_num] + " layer " +
                                        layerLabel[layer_num] + " " + " ; y_{SimHit} - y_{Segment RecHit} ; entries";
 
       me0_specRH_DeltaX[region_num][layer_num] =
           ibooker.book1D(histo_name_DeltaX.c_str(), histo_label_DeltaX.c_str(), 100, -10, 10);
       me0_specRH_DeltaY[region_num][layer_num] =
           ibooker.book1D(histo_name_DeltaY.c_str(), histo_label_DeltaY.c_str(), 100, -10, 10);
 
       std::string histo_name_PullX =
           std::string("me0_specRH_PullX_r") + regionLabel[region_num] + "_l" + layerLabel[layer_num];
       std::string histo_name_PullY =
           std::string("me0_specRH_PullY_r") + regionLabel[region_num] + "_l" + layerLabel[layer_num];
       std::string histo_label_PullX = "Segment RecHits Pull X : region" + regionLabel[region_num] + " layer " +
                                       layerLabel[layer_num] + " " +
                                       " ; #frac{x_{SimHit} - x_{Segment "
                                       "RecHit}}{#sigma_{x,RecHit}} ; entries";
       std::string histo_label_PullY = "Segment RecHits Pull Y : region" + regionLabel[region_num] + " layer " +
                                       layerLabel[layer_num] + " " +
                                       " ; #frac{y_{SimHit} - y_{Segment "
                                       "RecHit}}{#sigma_{y,RecHit}} ; entries";
 
       me0_specRH_PullX[region_num][layer_num] =
           ibooker.book1D(histo_name_PullX.c_str(), histo_label_DeltaX.c_str(), 100, -10, 10);
       me0_specRH_PullY[region_num][layer_num] =
           ibooker.book1D(histo_name_PullY.c_str(), histo_label_DeltaY.c_str(), 100, -10, 10);
     }
   }
 }

std::pair< int, int > ME0SegmentsValidation::isMatched	(	ME0DetId	me0id,
		LocalPoint	rhLP,
		edm::Handle< ME0DigiPreRecoCollection >	ME0Digis
	)

Definition at line 339 of file ME0SegmentsValidation.cc.

References ME0DetId::chamber(), ME0DetId::layer(), phase1PixelTopology::layer, HLT_FULL_cff::particleType, ME0DetId::region(), HLT_FULL_cff::region, mps_fire::result, ME0DetId::roll(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by analyze().

                                                                                                    {
   int region_rh = (int)me0id.region();
   int layer_rh = (int)me0id.layer();
   int roll_rh = (int)me0id.roll();
   int chamber_rh = (int)me0id.chamber();
 
   float l_x_rh = rhLP.x();
   float l_y_rh = rhLP.y();
 
   int particleType = 0;
   int isPrompt = -1;
 
   for (ME0DigiPreRecoCollection::DigiRangeIterator cItr = ME0Digis->begin(); cItr != ME0Digis->end(); cItr++) {
     ME0DetId id = (*cItr).first;
 
     int region_dg = (int)id.region();
     int layer_dg = (int)id.layer();
     int roll_dg = (int)id.roll();
     int chamber_dg = (int)id.chamber();
 
     if (region_rh != region_dg)
       continue;
     if (layer_rh != layer_dg)
       continue;
     if (chamber_rh != chamber_dg)
       continue;
     if (roll_rh != roll_dg)
       continue;
 
     ME0DigiPreRecoCollection::const_iterator digiItr;
     for (digiItr = (*cItr).second.first; digiItr != (*cItr).second.second; ++digiItr) {
       float l_x_dg = digiItr->x();
       float l_y_dg = digiItr->y();
 
       if (l_x_rh != l_x_dg)
         continue;
       if (l_y_rh != l_y_dg)
         continue;
 
       particleType = digiItr->pdgid();
       isPrompt = digiItr->prompt();
     }
   }
 
   std::pair<int, int> result;
   result = std::make_pair(particleType, isPrompt);
 
   return result;
 }

bool ME0SegmentsValidation::isSimMatched	(	edm::SimTrackContainer::const_iterator	simTrack,
		edm::PSimHitContainer::const_iterator	itHit
	)

Definition at line 406 of file ME0SegmentsValidation.cc.

References mps_fire::result.

Referenced by analyze().

                                                                                   {
   bool result = false;
   int trackId = simTrack->trackId();
   int trackId_sim = itHit->trackId();
   if (trackId == trackId_sim)
     result = true;
   return result;
 }

bool ME0SegmentsValidation::isSimTrackGood ( edm::SimTrackContainer::const_iterator simTrack )

Definition at line 391 of file ME0SegmentsValidation.cc.

References funct::abs(), PVValHelper::eta, eta_max_, isMuonGun_, and pt_min_.

Referenced by analyze().

                                                                                {
   if ((*t).noVertex() && !isMuonGun_)
     return false;
   if ((*t).noGenpart() && !isMuonGun_)
     return false;
   if (std::abs((*t).type()) != 13)
     return false;  // only interested in direct muon simtracks
   if ((*t).momentum().pt() < pt_min_)
     return false;
   const float eta(std::abs((*t).momentum().eta()));
   if (eta < eta_min_ || eta > eta_max_)
     return false;  // no GEMs could be in such eta
   return true;
 }