Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-03-02 23:54:09 

0001 /*
0002 
0003   Class definition for ScoutingMuonTagProbeAnalyzer.cc. Declares each
0004   histogram (MonitorElement), numerator and denominator histogram structure
0005   (kProbeKinematicMuonHistos), and any functions used in
0006   ScoutingMuonTagProbeAnalyzer.cc. Also declares the token to read the
0007   scouting muon and scouting vertex collections.
0008 
0009   Author: Javier Garcia de Castro, email:javigdc@bu.edu
0010 */
0011 
0012 // system includes
0013 #include <cmath>
0014 #include <iostream>
0015 #include <iostream>
0016 #include <string>
0017 #include <vector>
0018 
0019 // user includes
0020 #include "DQMServices/Core/interface/DQMGlobalEDAnalyzer.h"
0021 #include "DataFormats/PatCandidates/interface/Muon.h"
0022 #include "DataFormats/Scouting/interface/Run3ScoutingMuon.h"
0023 #include "DataFormats/Scouting/interface/Run3ScoutingVertex.h"
0024 #include "FWCore/Framework/interface/Event.h"
0025 #include "FWCore/Framework/interface/Frameworkfwd.h"
0026 #include "FWCore/Framework/interface/MakerMacros.h"
0027 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0028 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0029 
0030 struct kProbeKinematicMuonHistos {
0031   dqm::reco::MonitorElement* hPt;
0032   dqm::reco::MonitorElement* hEta;
0033   dqm::reco::MonitorElement* hPhi;
0034   dqm::reco::MonitorElement* hInvMass;
0035   dqm::reco::MonitorElement* hNormChisq;
0036   dqm::reco::MonitorElement* hTrk_dxy;
0037   dqm::reco::MonitorElement* hTrk_dz;
0038   dqm::reco::MonitorElement* hnPixel;
0039   dqm::reco::MonitorElement* hnTracker;
0040   dqm::reco::MonitorElement* htrk_qoverp;
0041   dqm::reco::MonitorElement* htype;
0042   dqm::reco::MonitorElement* hcharge;
0043   dqm::reco::MonitorElement* hecalIso;
0044   dqm::reco::MonitorElement* hhcalIso;
0045   dqm::reco::MonitorElement* htrackIso;
0046   dqm::reco::MonitorElement* hnValidStandAloneMuonHits;
0047   dqm::reco::MonitorElement* hnStandAloneMuonMatchedStations;
0048   dqm::reco::MonitorElement* hnValidRecoMuonHits;
0049   dqm::reco::MonitorElement* hnRecoMuonChambers;
0050   dqm::reco::MonitorElement* hnRecoMuonChambersCSCorDT;
0051   dqm::reco::MonitorElement* hnRecoMuonMatches;
0052   dqm::reco::MonitorElement* hnRecoMuonMatchedStations;
0053   dqm::reco::MonitorElement* hnRecoMuonExpectedMatchedStations;
0054   dqm::reco::MonitorElement* hnValidPixelHits;
0055   dqm::reco::MonitorElement* hnValidStripHits;
0056   dqm::reco::MonitorElement* hnPixelLayersWithMeasurement;
0057   dqm::reco::MonitorElement* hnTrackerLayersWithMeasurement;
0058   dqm::reco::MonitorElement* htrk_chi2;
0059   dqm::reco::MonitorElement* htrk_ndof;
0060   dqm::reco::MonitorElement* htrk_lambda;
0061   dqm::reco::MonitorElement* htrk_pt;
0062   dqm::reco::MonitorElement* htrk_eta;
0063   dqm::reco::MonitorElement* htrk_dxyError;
0064   dqm::reco::MonitorElement* htrk_dzError;
0065   dqm::reco::MonitorElement* htrk_qoverpError;
0066   dqm::reco::MonitorElement* htrk_lambdaError;
0067   dqm::reco::MonitorElement* htrk_phiError;
0068   dqm::reco::MonitorElement* htrk_dsz;
0069   dqm::reco::MonitorElement* htrk_dszError;
0070   dqm::reco::MonitorElement* htrk_vx;
0071   dqm::reco::MonitorElement* htrk_vy;
0072   dqm::reco::MonitorElement* htrk_vz;
0073   dqm::reco::MonitorElement* hLxy;
0074   dqm::reco::MonitorElement* hXError;
0075   dqm::reco::MonitorElement* hYError;
0076   dqm::reco::MonitorElement* hChi2;
0077   dqm::reco::MonitorElement* hZ;
0078   dqm::reco::MonitorElement* hx;
0079   dqm::reco::MonitorElement* hy;
0080   dqm::reco::MonitorElement* hZerror;
0081   dqm::reco::MonitorElement* htracksSize;
0082 };
0083 
0084 struct kTagProbeMuonHistos {
0085   kProbeKinematicMuonHistos resonanceJ_numerator;
0086   kProbeKinematicMuonHistos resonanceJ_denominator;
0087 };
0088 
0089 class ScoutingMuonTagProbeAnalyzer : public DQMGlobalEDAnalyzer<kTagProbeMuonHistos> {
0090 public:
0091   explicit ScoutingMuonTagProbeAnalyzer(const edm::ParameterSet& conf);
0092   ~ScoutingMuonTagProbeAnalyzer() override = default;
0093   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0094 
0095 private:
0096   void dqmAnalyze(const edm::Event& e, const edm::EventSetup& c, kTagProbeMuonHistos const&) const override;
0097   void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&, kTagProbeMuonHistos&) const override;
0098   void bookHistograms_resonance(DQMStore::IBooker&,
0099                                 edm::Run const&,
0100                                 edm::EventSetup const&,
0101                                 kProbeKinematicMuonHistos&,
0102                                 const std::string&) const;
0103   void fillHistograms_resonance(const kProbeKinematicMuonHistos histos,
0104                                 const Run3ScoutingMuon& mu,
0105                                 const Run3ScoutingVertex& vertex,
0106                                 const float inv_mass,
0107                                 const float lxy) const;
0108   bool scoutingMuonID(const Run3ScoutingMuon mu) const;
0109 
0110   const std::string outputInternalPath_;
0111   const edm::EDGetTokenT<std::vector<Run3ScoutingMuon>> scoutingMuonCollection_;
0112   const edm::EDGetTokenT<std::vector<Run3ScoutingVertex>> scoutingVtxCollection_;
0113   const bool runWithoutVtx_;
0114 };
0115 
0116 /*
0117   This code does the following:
0118      1) Reads muon collection, scouting muon collection and scouting vertex
0119 collection 
0120      2) Tag and Probe method: For each event, check whether one of the
0121      muons passes a tight ID (tag), and pair it with another muon in the event
0122      (probe). If this dimuon system is within the mass range of the J/Psi, monitor
0123      distributions of the probe and the efficiency of the probe to pass certain IDs.
0124      For now we are measuring the efficiency of the probe passing the tag ID (If the
0125      dimuon system is within J/Psi, add it to the denominator distributions, and if
0126      the probe passes the tag ID, add it to the numerator distributions as well.) 
0127      3) Fills histograms
0128 */
0129 
0130 ScoutingMuonTagProbeAnalyzer::ScoutingMuonTagProbeAnalyzer(const edm::ParameterSet& iConfig)
0131     : outputInternalPath_(iConfig.getParameter<std::string>("OutputInternalPath")),
0132       scoutingMuonCollection_(
0133           consumes<std::vector<Run3ScoutingMuon>>(iConfig.getParameter<edm::InputTag>("ScoutingMuonCollection"))),
0134       scoutingVtxCollection_(
0135           consumes<std::vector<Run3ScoutingVertex>>(iConfig.getParameter<edm::InputTag>("ScoutingVtxCollection"))),
0136       runWithoutVtx_(iConfig.getParameter<bool>("runWithoutVertex")) {}
0137 
0138 void ScoutingMuonTagProbeAnalyzer::dqmAnalyze(edm::Event const& iEvent,
0139                                               edm::EventSetup const& iSetup,
0140                                               kTagProbeMuonHistos const& histos) const {
0141   // Read scouting muon collection
0142   edm::Handle<std::vector<Run3ScoutingMuon>> sctMuons;
0143   iEvent.getByToken(scoutingMuonCollection_, sctMuons);
0144   if (sctMuons.failedToGet()) {
0145     edm::LogWarning("ScoutingMonitoring") << "Run3ScoutingMuon collection not found.";
0146     return;
0147   }
0148 
0149   // Read scouting vertex collection
0150   edm::Handle<std::vector<Run3ScoutingVertex>> sctVertex;
0151   iEvent.getByToken(scoutingVtxCollection_, sctVertex);
0152   if (sctVertex.failedToGet()) {
0153     edm::LogWarning("ScoutingMonitoring") << "Run3ScoutingVertex collection not found.";
0154     return;
0155   }
0156 
0157   edm::LogInfo("ScoutingMonitoring") << "Process Run3ScoutingMuons: " << sctMuons->size();
0158 
0159   edm::LogInfo("ScoutingMonitoring") << "Process Run3ScoutingVertex: " << sctVertex->size();
0160 
0161   // Core of Tag and Probe implementation
0162   bool foundTag = false;
0163   // First find the tag
0164   for (const auto& sct_mu : *sctMuons) {
0165     if (!scoutingMuonID(sct_mu))
0166       continue;
0167     if (foundTag)
0168       continue;
0169     math::PtEtaPhiMLorentzVector tag_sct_mu(sct_mu.pt(), sct_mu.eta(), sct_mu.phi(), sct_mu.m());
0170     const std::vector<int> vtxIndx_tag = sct_mu.vtxIndx();
0171 
0172     // Then pair the tag with the probe
0173     for (const auto& sct_mu_second : *sctMuons) {
0174       if (&sct_mu_second == &sct_mu)
0175         continue;
0176       math::PtEtaPhiMLorentzVector probe_sct_mu(
0177           sct_mu_second.pt(), sct_mu_second.eta(), sct_mu_second.phi(), sct_mu_second.m());
0178       if (sct_mu_second.pt() < 1)
0179         continue;
0180       const std::vector<int> vtxIndx_probe = sct_mu_second.vtxIndx();
0181 
0182       float invMass = (tag_sct_mu + probe_sct_mu).mass();
0183       edm::LogInfo("ScoutingMonitoring") << "Inv Mass: " << invMass;
0184       // If dimuon system comes from J/Psi, process event
0185       if ((2.4 < invMass && invMass < 3.8)) {
0186         // Boolean added because hltScoutingMuonPackerVtx collection doesn't
0187         // have vertices for the moment
0188         if (runWithoutVtx_) {
0189           Run3ScoutingVertex vertex;
0190           // If probe passes tag ID, add it to the numerator
0191           if (scoutingMuonID(sct_mu_second)) {
0192             fillHistograms_resonance(histos.resonanceJ_numerator, sct_mu_second, vertex, invMass, -99.);
0193           }
0194           // Add all events to the denominator
0195           fillHistograms_resonance(histos.resonanceJ_denominator, sct_mu_second, vertex, invMass, -99.);
0196         } else {
0197           if (vtxIndx_tag.empty() || vtxIndx_probe.empty())
0198             continue;
0199           for (const auto& commonIdx : vtxIndx_tag) {
0200             if (std::find(vtxIndx_probe.begin(), vtxIndx_probe.end(), commonIdx) != vtxIndx_probe.end()) {
0201               const auto& vertex = (*sctVertex)[commonIdx];
0202               float lxy = sqrt(vertex.x() * vertex.x() + vertex.y() * vertex.y());
0203               if (scoutingMuonID(sct_mu_second)) {
0204                 fillHistograms_resonance(histos.resonanceJ_numerator, sct_mu_second, vertex, invMass, lxy);
0205               }
0206               fillHistograms_resonance(histos.resonanceJ_denominator, sct_mu_second, vertex, invMass, lxy);
0207             }
0208           }
0209         }
0210       }
0211     }
0212     foundTag = true;
0213   }
0214 }
0215 
0216 // Tag ID
0217 bool ScoutingMuonTagProbeAnalyzer::scoutingMuonID(const Run3ScoutingMuon mu) const {
0218   math::PtEtaPhiMLorentzVector particle(mu.pt(), mu.eta(), mu.phi(), 0.10566);
0219   double normchisq_threshold = 3.0;
0220   double pt_threshold = 3.0;
0221   double eta_threshold = 2.4;
0222   int layer_threshold = 4;
0223 
0224   if (mu.pt() > pt_threshold && fabs(mu.eta()) < eta_threshold && mu.normalizedChi2() < normchisq_threshold &&
0225       mu.isGlobalMuon() && mu.nTrackerLayersWithMeasurement() > layer_threshold) {
0226     return true;
0227   }
0228   return false;
0229 }
0230 
0231 // Fill histograms
0232 void ScoutingMuonTagProbeAnalyzer::fillHistograms_resonance(const kProbeKinematicMuonHistos histos,
0233                                                             const Run3ScoutingMuon& mu,
0234                                                             const Run3ScoutingVertex& vertex,
0235                                                             const float inv_mass,
0236                                                             const float lxy) const {
0237   histos.hPt->Fill(mu.pt());
0238   histos.hEta->Fill(mu.eta());
0239   histos.hPhi->Fill(mu.phi());
0240   histos.hInvMass->Fill(inv_mass);
0241   histos.hNormChisq->Fill(mu.normalizedChi2());
0242   histos.hTrk_dxy->Fill(mu.trk_dxy());
0243   histos.hTrk_dz->Fill(mu.trk_dz());
0244   histos.htype->Fill(mu.type());
0245   histos.hcharge->Fill(mu.charge());
0246   histos.hecalIso->Fill(mu.ecalIso());
0247   histos.hhcalIso->Fill(mu.hcalIso());
0248   histos.htrackIso->Fill(mu.trackIso());
0249   histos.hnValidStandAloneMuonHits->Fill(mu.nValidStandAloneMuonHits());
0250   histos.hnStandAloneMuonMatchedStations->Fill(mu.nStandAloneMuonMatchedStations());
0251   histos.hnValidRecoMuonHits->Fill(mu.nValidRecoMuonHits());
0252   histos.hnRecoMuonChambers->Fill(mu.nRecoMuonChambers());
0253   histos.hnRecoMuonChambersCSCorDT->Fill(mu.nRecoMuonChambersCSCorDT());
0254   histos.hnRecoMuonMatches->Fill(mu.nRecoMuonMatches());
0255   histos.hnRecoMuonMatchedStations->Fill(mu.nRecoMuonMatchedStations());
0256   histos.hnRecoMuonExpectedMatchedStations->Fill(mu.nRecoMuonExpectedMatchedStations());
0257   histos.hnValidPixelHits->Fill(mu.nValidPixelHits());
0258   histos.hnValidStripHits->Fill(mu.nValidStripHits());
0259   histos.htrk_chi2->Fill(mu.trk_chi2());
0260   histos.htrk_ndof->Fill(mu.trk_ndof());
0261   histos.htrk_lambda->Fill(mu.trk_lambda());
0262   histos.htrk_pt->Fill(mu.trk_pt());
0263   histos.htrk_eta->Fill(mu.trk_eta());
0264   histos.htrk_dxyError->Fill(mu.trk_dxyError());
0265   histos.htrk_dzError->Fill(mu.trk_dzError());
0266   histos.htrk_qoverpError->Fill(mu.trk_qoverpError());
0267   histos.htrk_lambdaError->Fill(mu.trk_lambdaError());
0268   histos.htrk_phiError->Fill(mu.trk_phiError());
0269   histos.htrk_dsz->Fill(mu.trk_dsz());
0270   histos.htrk_dszError->Fill(mu.trk_dszError());
0271   histos.htrk_dsz->Fill(mu.trk_dsz());
0272   histos.htrk_vx->Fill(mu.trk_vx());
0273   histos.htrk_vy->Fill(mu.trk_vy());
0274   histos.htrk_vz->Fill(mu.trk_vz());
0275   histos.hnPixel->Fill(mu.nPixelLayersWithMeasurement());
0276   histos.hnTracker->Fill(mu.nTrackerLayersWithMeasurement());
0277   histos.htrk_qoverp->Fill(mu.trk_qoverp());
0278 
0279   if (!runWithoutVtx_) {
0280     histos.hLxy->Fill(lxy);
0281     histos.hXError->Fill(vertex.xError());
0282     histos.hYError->Fill(vertex.yError());
0283     histos.hChi2->Fill(vertex.chi2());
0284     histos.hZ->Fill(vertex.z());
0285     histos.hx->Fill(vertex.x());
0286     histos.hy->Fill(vertex.y());
0287     histos.hZerror->Fill(vertex.zError());
0288     histos.htracksSize->Fill(vertex.tracksSize());
0289   }
0290 }
0291 
0292 // Save histograms
0293 void ScoutingMuonTagProbeAnalyzer::bookHistograms(DQMStore::IBooker& ibook,
0294                                                   edm::Run const& run,
0295                                                   edm::EventSetup const& iSetup,
0296                                                   kTagProbeMuonHistos& histos) const {
0297   ibook.setCurrentFolder(outputInternalPath_);
0298   bookHistograms_resonance(ibook, run, iSetup, histos.resonanceJ_numerator, "resonanceJ_numerator");
0299   bookHistograms_resonance(ibook, run, iSetup, histos.resonanceJ_denominator, "resonanceJ_denominator");
0300 }
0301 
0302 // Set axes labels and range
0303 void ScoutingMuonTagProbeAnalyzer::bookHistograms_resonance(DQMStore::IBooker& ibook,
0304                                                             edm::Run const& run,
0305                                                             edm::EventSetup const& iSetup,
0306                                                             kProbeKinematicMuonHistos& histos,
0307                                                             const std::string& name) const {
0308   ibook.setCurrentFolder(outputInternalPath_);
0309 
0310   histos.hPt = ibook.book1D(name + "_Probe_sctMuon_Pt", name + "_Probe_sctMuon_Pt;Muon pt (GeV); Muons", 60, 0, 50.0);
0311   histos.hEta = ibook.book1D(name + "_Probe_sctMuon_Eta", name + "_Probe_sctMuon_Eta; Muon eta; Muons", 60, -5.0, 5.0);
0312   histos.hPhi = ibook.book1D(name + "_Probe_sctMuon_Phi", name + "_Probe_sctMuon_Phi; Muon phi; Muons", 60, -3.3, 3.3);
0313   histos.hInvMass = ibook.book1D(
0314       name + "_sctMuon_Invariant_Mass", name + "_sctMuon_Invariant_Mass;Muon Inv mass (GeV); Muons", 100, 0, 5);
0315   histos.hNormChisq = ibook.book1D(
0316       name + "_Probe_sctMuon_NormChisq", name + "_Probe_sctMuon_NormChisq; Muon normChi2; Muons", 60, 0, 5.0);
0317   histos.hTrk_dxy =
0318       ibook.book1D(name + "_Probe_sctMuon_Trk_dxy", name + "_Probe_sctMuon_Trk_dxy; Track dxy; Muons", 60, 0, 5.0);
0319   histos.hTrk_dz =
0320       ibook.book1D(name + "_Probe_sctMuon_Trk_dz", name + "_Probe_sctMuon_Trk_dz; Track dz; Muons", 60, 0, 20.0);
0321   histos.htype = ibook.book1D(name + "_Probe_sctMuon_type", name + "_Probe_sctMuon_type;Muon type; Muons", 15, 0, 15);
0322   histos.hcharge =
0323       ibook.book1D(name + "_Probe_sctMuon_charge", name + "_Probe_sctMuon_charge; Muon charge; Muons", 3, -1, 2);
0324   histos.hecalIso = ibook.book1D(
0325       name + "_Probe_sctMuon_ecalIso", name + "_Probe_sctMuon_ecalIso; Muon ecalIso; Muons", 60, 0.0, 20.0);
0326   histos.hhcalIso = ibook.book1D(
0327       name + "_Probe_sctMuon_hcalIso", name + "_Probe_sctMuon_hcalIso; Muon hcalIso; Muons", 60, 0.0, 20.0);
0328   histos.htrackIso =
0329       ibook.book1D(name + "_sctMuon_trackIso", name + "_sctMuon_trackIso;Muon trackIso; Muons", 100, 0, 7);
0330   histos.hnValidStandAloneMuonHits = ibook.book1D(name + "_Probe_sctMuon_nValidStandAloneMuonHits",
0331                                                   name +
0332                                                       "_Probe_sctMuon_nValidStandAloneMuonHits;"
0333                                                       "nValidStandAloneMuonHits; Muons",
0334                                                   25,
0335                                                   0,
0336                                                   25);
0337   histos.hnValidRecoMuonHits = ibook.book1D(name + "_Probe_sctMuon_nValidRecoMuonHits",
0338                                             name + "_Probe_sctMuon_nValidRecoMuonHits;nValidRecoMuonHits; Muons",
0339                                             25,
0340                                             0,
0341                                             25);
0342   histos.hnRecoMuonChambers = ibook.book1D(name + "_Probe_sctMuon_nRecoMuonChambers",
0343                                            name + "_Probe_sctMuon_nRecoMuonChambers; nRecoMuonChambers; Muons",
0344                                            10,
0345                                            0,
0346                                            10.0);
0347   histos.hnStandAloneMuonMatchedStations = ibook.book1D(name + "_Probe_sctMuon_nStandAloneMuonMatchedStations",
0348                                                         name +
0349                                                             "_Probe_sctMuon_nStandAloneMuonMatchedStations; "
0350                                                             "nStandAloneMuonMatchedStations; Muons",
0351                                                         5,
0352                                                         0,
0353                                                         5.0);
0354   histos.hnRecoMuonChambersCSCorDT = ibook.book1D(name + "_Probe_sctMuon_nRecoMuonChambersCSCorDT",
0355                                                   name +
0356                                                       "_Probe_sctMuon_nRecoMuonChambersCSCorDT;"
0357                                                       "nRecoMuonChambersCSCorDT; Muons",
0358                                                   10,
0359                                                   0,
0360                                                   10.0);
0361   histos.hnRecoMuonMatches = ibook.book1D(name + "_Probe_sctMuon_nRecoMuonMatches",
0362                                           name + "_Probe_sctMuon_nRecoMuonMatches; nRecoMuonMatches; Muons",
0363                                           6,
0364                                           0,
0365                                           6);
0366   histos.hnRecoMuonMatchedStations = ibook.book1D(name + "_Probe_sctMuon_nRecoMuonMatchedStations",
0367                                                   name +
0368                                                       "_Probe_sctMuon_nRecoMuonMatchedStations; "
0369                                                       "nRecoMuonMatchedStations; Muons",
0370                                                   5,
0371                                                   0.0,
0372                                                   5.0);
0373   histos.hnRecoMuonExpectedMatchedStations = ibook.book1D(name + "_sctMuon_nRecoMuonExpectedMatchedStations",
0374                                                           name +
0375                                                               "_sctMuon_nRecoMuonExpectedMatchedStations;"
0376                                                               "nRecoMuonExpectedMatchedStations; Muons",
0377                                                           6,
0378                                                           0,
0379                                                           6.0);
0380   histos.hnValidPixelHits = ibook.book1D(name + "_Probe_sctMuon_nValidPixelHits",
0381                                          name + "_Probe_sctMuon_nValidPixelHits;nValidPixelHits; Muons",
0382                                          14,
0383                                          0,
0384                                          14.0);
0385   histos.hnValidStripHits = ibook.book1D(name + "_Probe_sctMuon_nValidStripHits",
0386                                          name + "_Probe_sctMuon_nValidStripHits; nValidStripHits; Muons",
0387                                          25,
0388                                          0,
0389                                          25);
0390   histos.htrk_chi2 =
0391       ibook.book1D(name + "_Probe_sctMuon_trk_chi2", name + "_Probe_sctMuon_trk_chi2; trk_chi2; Muons", 60, 0.0, 20);
0392   histos.htrk_ndof = ibook.book1D(name + "_sctMuon_trk_ndof", name + "_sctMuon_trk_ndof;trk_ndof; Muons", 100, 0, 50);
0393   histos.htrk_lambda = ibook.book1D(
0394       name + "_Probe_sctMuon_trk_lambda", name + "_Probe_sctMuon_trk_lambda; trk_lambda; Muons", 60, -5, 5);
0395   histos.htrk_pt =
0396       ibook.book1D(name + "_Probe_sctMuon_trk_pt", name + "_Probe_sctMuon_trk_pt; trk_pt; Muons", 60, 0, 50.0);
0397   histos.htrk_eta =
0398       ibook.book1D(name + "_Probe_sctMuon_trk_eta", name + "_Probe_sctMuon_trk_eta;trk_eta; Muons", 60, -3.3, 3.3);
0399   histos.htrk_dxyError = ibook.book1D(
0400       name + "_Probe_sctMuon_trk_dxyError", name + "_Probe_sctMuon_trk_dxyError; trk_dxyError; Muons", 60, 0.0, 0.8);
0401   histos.htrk_dzError = ibook.book1D(
0402       name + "_Probe_sctMuon_trk_dzError", name + "_Probe_sctMuon_trk_dzError; trk_dzError; Muons", 60, 0.0, 2);
0403   histos.htrk_qoverpError = ibook.book1D(
0404       name + "_sctMuon_trk_qoverpError", name + "_sctMuon_trk_qoverpError;trk_qoverpError; Muons", 100, 0, 0.05);
0405   histos.htrk_lambdaError = ibook.book1D(name + "_Probe_sctMuon_trk_lambdaError",
0406                                          name + "_Probe_sctMuon_trk_lambdaError; trk_lambdaError; Muons",
0407                                          60,
0408                                          0,
0409                                          0.2);
0410   histos.htrk_phiError = ibook.book1D(
0411       name + "_Probe_sctMuon_trk_phiError", name + "_Probe_sctMuon_trk_phiError; trk_phiError; Muons", 60, 0, 0.2);
0412   histos.htrk_dsz =
0413       ibook.book1D(name + "_Probe_sctMuon_trk_dsz", name + "_Probe_sctMuon_trk_dsz; trk_dsz; Muons", 60, -20.0, 20.0);
0414   histos.htrk_dszError = ibook.book1D(
0415       name + "_Probe_sctMuon_trk_dszError", name + "_Probe_sctMuon_trk_dszError; trk_dszError; Muons", 60, 0, 0.8);
0416   histos.htrk_vx =
0417       ibook.book1D(name + "_Probe_sctMuon_trk_vx", name + "_Probe_sctMuon_trk_vx; trk_vx; Muons", 60, -1, 1);
0418   histos.htrk_vy =
0419       ibook.book1D(name + "_Probe_sctMuon_trk_vy", name + "_Probe_sctMuon_trk_vy; trk_vy; Muons", 60, -1, 1);
0420   histos.htrk_vz =
0421       ibook.book1D(name + "_Probe_sctMuon_trk_vz", name + "_Probe_sctMuon_trk_vz; trk_vz; Muons", 60, -20, 20);
0422   histos.hnPixel =
0423       ibook.book1D(name + "_Probe_sctMuon_nPixel", name + "_Probe_sctMuon_nPixel; n Pixel Layers; Muons", 6, 0, 6);
0424   histos.hnTracker = ibook.book1D(
0425       name + "_Probe_sctMuon_nTracker", name + "_Probe_sctMuon_nTracker; n Tracker Layers; Muons", 14, 0, 25);
0426   histos.htrk_qoverp = ibook.book1D(
0427       name + "_Probe_sctMuon_trk_qoverp", name + "_Probe_sctMuon_trk_qoverp; n Track q/p; Muons", 40, -1, 1);
0428   histos.hLxy = ibook.book1D(name + "_Vertex_Lxy", name + "_Vertex_Lxy; lxy; Muons", 60, 0, 20);
0429   histos.hXError = ibook.book1D(name + "_Vertex_Xerror", name + "_Vertex_Xerror; vertex x error; Muons", 60, 0, 1);
0430   histos.hYError = ibook.book1D(name + "_Vertex_Yerror", name + "_Vertex_Yerror; vertex y error; Muons", 60, 0, 1);
0431   histos.hChi2 = ibook.book1D(name + "_Vertex_chi2", name + "_Vertex_chi2; vertex chi2; Muons", 60, 0, 15);
0432   histos.hZ = ibook.book1D(name + "_Vertex_z", name + "_Vertex_z; vertex z; Muons", 60, 0, 15);
0433   histos.hx = ibook.book1D(name + "_Vertex_x", name + "_Vertex_x; vertex x; Muons", 60, -1, 1);
0434   histos.hy = ibook.book1D(name + "_Vertex_y", name + "_Vertex_y; vertex y; Muons", 60, -1, 1);
0435   histos.hZerror = ibook.book1D(name + "_Vertex_z error", name + "_Vertex_z_error; vertex z error; Muons", 60, 0, 3);
0436   histos.htracksSize =
0437       ibook.book1D(name + "_Vertex_tracksSize", name + "_Vertex_tracksSize; vertex tracksSize; Muons", 60, 0, 10);
0438 }
0439 
0440 // Descriptions to read the collections
0441 void ScoutingMuonTagProbeAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0442   edm::ParameterSetDescription desc;
0443   desc.add<std::string>("OutputInternalPath", "MY_FOLDER");
0444   desc.add<edm::InputTag>("ScoutingMuonCollection", edm::InputTag("Run3ScoutingMuons"));
0445   desc.add<edm::InputTag>("ScoutingVtxCollection", edm::InputTag("hltScoutingMuonPackerNoVtx"));
0446   desc.add<bool>("runWithoutVertex", true);
0447   descriptions.addWithDefaultLabel(desc);
0448 }
0449 
0450 DEFINE_FWK_MODULE(ScoutingMuonTagProbeAnalyzer);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!