From 6c9be1c6f2c681bfdb5d77bdb48d198cf67d8da4 Mon Sep 17 00:00:00 2001 From: Raffaele Delli Gatti Date: Fri, 16 Feb 2024 15:32:07 +0100 Subject: [PATCH 1/7] Pileup contribution characterization in 4D vertex validation --- .../MtdValidation/plugins/BuildFile.xml | 1 + .../plugins/Primary4DVertexValidation.cc | 503 +++++++++++++++--- 2 files changed, 440 insertions(+), 64 deletions(-) diff --git a/Validation/MtdValidation/plugins/BuildFile.xml b/Validation/MtdValidation/plugins/BuildFile.xml index ee1c67c8440b9..44c1d4bf136bc 100644 --- a/Validation/MtdValidation/plugins/BuildFile.xml +++ b/Validation/MtdValidation/plugins/BuildFile.xml @@ -28,4 +28,5 @@ + diff --git a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc index 3cd9cebc1b8cf..419be1408d55f 100644 --- a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc +++ b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc @@ -6,6 +6,7 @@ #include "FWCore/Framework/interface/Frameworkfwd.h" #include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Utilities/interface/isFinite.h" #include "DataFormats/Common/interface/ValidHandle.h" #include "FWCore/Framework/interface/Event.h" @@ -31,6 +32,16 @@ #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h" #include "SimDataFormats/TrackingAnalysis/interface/TrackingVertexContainer.h" +// Fastjet +#include +#include "fastjet/PseudoJet.hh" +#include "fastjet/JetDefinition.hh" +#include "fastjet/ClusterSequence.hh" +#include "fastjet/Selector.hh" + +// HepPDTRecord +#include "SimGeneral/HepPDTRecord/interface/ParticleDataTable.h" + // pile-up #include "SimDataFormats/PileupSummaryInfo/interface/PileupSummaryInfo.h" @@ -51,7 +62,7 @@ #include "DataFormats/Math/interface/GeantUnits.h" #include "CLHEP/Units/PhysicalConstants.h" -//class declaration +// class declaration class Primary4DVertexValidation : public DQMEDAnalyzer { typedef math::XYZTLorentzVector LorentzVector; @@ -199,9 +210,17 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { const edm::ValueMap&, const edm::Handle&); bool matchRecoTrack2SimSignal(const reco::TrackBaseRef&); - const edm::Ref>* getMatchedTP(const reco::TrackBaseRef&, const TrackingVertexRef&); + std::pair>*,bool> getMatchedTP(const reco::TrackBaseRef&, const TrackingVertexRef&); double timeFromTrueMass(double, double, double, double); bool select(const reco::Vertex&, int level = 0); + void observablesFromJets(const std::vector&, const std::vector&, + const std::vector&, const bool&, + unsigned int&, double&, double&, double&, + double&, double&, double&); + void isParticle(const reco::TrackBaseRef&, const double&, + const edm::ValueMap&, const edm::ValueMap&, + const edm::ValueMap&, unsigned int&, bool&, + bool&, bool&, bool&); std::vector getSimPVs(const edm::Handle&); std::vector getRecoPVs(const edm::Handle>&); @@ -212,9 +231,9 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { const std::string folder_; static constexpr unsigned int NOT_MATCHED = 66666; - static constexpr double simUnit_ = 1e9; //sim time in s while reco time in ns - static constexpr double c_ = 2.99792458e1; //c in cm/ns - static constexpr double mvaL_ = 0.5; //MVA cuts for MVA categories + static constexpr double simUnit_ = 1e9; // sim time in s while reco time in ns + static constexpr double c_ = 2.99792458e1; // c in cm/ns + static constexpr double mvaL_ = 0.5; // MVA cuts for MVA categories static constexpr double mvaH_ = 0.8; static constexpr double selNdof_ = 4.; static constexpr double maxRank_ = 8.; @@ -270,8 +289,9 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { edm::EDGetTokenT> probPiToken_; edm::EDGetTokenT> probKToken_; edm::EDGetTokenT> probPToken_; + edm::ESGetToken pdtToken_; - //histogram declaration + // histogram declaration MonitorElement* meMVATrackEffPtTot_; MonitorElement* meMVATrackMatchedEffPtTot_; MonitorElement* meMVATrackMatchedEffPtMtd_; @@ -315,7 +335,69 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* meRecPVT_; MonitorElement* meSimPVZ_; - //some tests + MonitorElement* mePUTrackMult_; + MonitorElement* mePUTrackRelMult_; + MonitorElement* mePUTrackSumW_; + MonitorElement* mePUTrackRelSumW_; + MonitorElement* mePUTrackWnt_; + MonitorElement* mePUTrackSumPt_; + MonitorElement* mePUTrackRelSumPt_; + MonitorElement* mePUTrackSumPt2_; + MonitorElement* mePUTrackRelSumPt2_; + MonitorElement* mePUTrackSumPx_; + MonitorElement* mePUTrackSumPy_; + MonitorElement* mePUTrackSumPz_; + MonitorElement* mePUTrackRelSumPx_; + MonitorElement* mePUTrackRelSumPy_; + MonitorElement* mePUTrackRelSumPz_; + + MonitorElement* mePUTrackRecLVMult_; + MonitorElement* mePUTrackRecLVRelMult_; + MonitorElement* mePUTrackRecLVSumW_; + MonitorElement* mePUTrackRecLVRelSumW_; + MonitorElement* mePUTrackRecLVWnt_; + MonitorElement* mePUTrackRecLVSumPt_; + MonitorElement* mePUTrackRecLVRelSumPt_; + MonitorElement* mePUTrackRecLVSumPt2_; + MonitorElement* mePUTrackRecLVRelSumPt2_; + MonitorElement* mePUTrackRecLVSumPx_; + MonitorElement* mePUTrackRecLVSumPy_; + MonitorElement* mePUTrackRecLVSumPz_; + MonitorElement* mePUTrackRecLVRelSumPx_; + MonitorElement* mePUTrackRecLVRelSumPy_; + MonitorElement* mePUTrackRecLVRelSumPz_; + + MonitorElement* meJetsPUMult_; + MonitorElement* meJetsPUHt_; + MonitorElement* meJetsPUSumPt2_; + MonitorElement* meJetsPUMetPt_; + MonitorElement* meJetsPUSumPx_; + MonitorElement* meJetsPUSumPy_; + MonitorElement* meJetsPUSumPz_; + MonitorElement* meJetsPURelMult_; + MonitorElement* meJetsPURelHt_; + MonitorElement* meJetsPURelSumPt2_; + MonitorElement* meJetsPURelMetPt_; + MonitorElement* meJetsPURelSumPx_; + MonitorElement* meJetsPURelSumPy_; + MonitorElement* meJetsPURelSumPz_; + + MonitorElement* meJetsRecLVPUMult_; + MonitorElement* meJetsRecLVPUHt_; + MonitorElement* meJetsRecLVPUSumPt2_; + MonitorElement* meJetsRecLVPUMetPt_; + MonitorElement* meJetsRecLVPUSumPx_; + MonitorElement* meJetsRecLVPUSumPy_; + MonitorElement* meJetsRecLVPUSumPz_; + MonitorElement* meJetsRecLVPURelMult_; + MonitorElement* meJetsRecLVPURelHt_; + MonitorElement* meJetsRecLVPURelSumPt2_; + MonitorElement* meJetsRecLVPURelMetPt_; + MonitorElement* meJetsRecLVPURelSumPx_; + MonitorElement* meJetsRecLVPURelSumPy_; + MonitorElement* meJetsRecLVPURelSumPz_; + + // some tests MonitorElement* meTrackResLowPTot_; MonitorElement* meTrackResHighPTot_; MonitorElement* meTrackPullLowPTot_; @@ -375,7 +457,8 @@ Primary4DVertexValidation::Primary4DVertexValidation(const edm::ParameterSet& iC minProbHeavy_(iConfig.getParameter("minProbHeavy")), trackweightTh_(iConfig.getParameter("trackweightTh")), mvaTh_(iConfig.getParameter("mvaTh")), - lineDensityPar_(iConfig.getParameter>("lineDensityPar")) { + lineDensityPar_(iConfig.getParameter>("lineDensityPar")), + pdtToken_(esConsumes()) { vecPileupSummaryInfoToken_ = consumes>(edm::InputTag(std::string("addPileupInfo"))); trackingParticleCollectionToken_ = consumes(iConfig.getParameter("SimTag")); @@ -415,15 +498,15 @@ void Primary4DVertexValidation::bookHistograms(DQMStore::IBooker& ibook, ibook.setCurrentFolder(folder_); // --- histograms booking meMVATrackEffPtTot_ = ibook.book1D("MVAEffPtTot", "Pt of tracks associated to LV; track pt [GeV] ", 110, 0., 11.); - meMVATrackEffEtaTot_ = ibook.book1D("MVAEffEtaTot", "Pt of tracks associated to LV; track eta ", 66, 0., 3.3); + meMVATrackEffEtaTot_ = ibook.book1D("MVAEffEtaTot", "Eta of tracks associated to LV; track eta ", 66, 0., 3.3); meMVATrackMatchedEffPtTot_ = ibook.book1D("MVAMatchedEffPtTot", "Pt of tracks associated to LV matched to TP; track pt [GeV] ", 110, 0., 11.); meMVATrackMatchedEffPtMtd_ = ibook.book1D( "MVAMatchedEffPtMtd", "Pt of tracks associated to LV matched to TP with time; track pt [GeV] ", 110, 0., 11.); meMVATrackMatchedEffEtaTot_ = - ibook.book1D("MVAMatchedEffEtaTot", "Pt of tracks associated to LV matched to TP; track eta ", 66, 0., 3.3); + ibook.book1D("MVAMatchedEffEtaTot", "Eta of tracks associated to LV matched to TP; track eta ", 66, 0., 3.3); meMVATrackMatchedEffEtaMtd_ = ibook.book1D( - "MVAMatchedEffEtaMtd", "Pt of tracks associated to LV matched to TP with time; track eta ", 66, 0., 3.3); + "MVAMatchedEffEtaMtd", "Eta of tracks associated to LV matched to TP with time; track eta ", 66, 0., 3.3); meMVATrackResTot_ = ibook.book1D( "MVATrackRes", "t_{rec} - t_{sim} for tracks from LV MVA sel.; t_{rec} - t_{sim} [ns] ", 120, -0.15, 0.15); meTrackResTot_ = ibook.book1D("TrackRes", "t_{rec} - t_{sim} for tracks; t_{rec} - t_{sim} [ns] ", 120, -0.15, 0.15); @@ -524,13 +607,13 @@ void Primary4DVertexValidation::bookHistograms(DQMStore::IBooker& ibook, ibook.book1D("SimPosInSimOrigCollection", "Sim signal index in OrigCollection; Sim index", 200, 0, 200); } meRecoPVPosSignal_ = - ibook.book1D("RecoPVPosSignal", "Position in reco collection of PV associated to sim signal", 200, 0, 200); + ibook.book1D("RecoPVPosSignal", "Position in reco collection of PV associated to sim signal", 20, 0, 20); meRecoPVPosSignalNotHighestPt_ = ibook.book1D("RecoPVPosSignalNotHighestPt", "Position in reco collection of PV associated to sim signal not highest Pt", - 200, + 20, 0, - 200); + 20); meRecoVtxVsLineDensity_ = ibook.book1D("RecoVtxVsLineDensity", "#Reco vertices/mm/event; line density [#vtx/mm/event]", 160, 0., 4.); meRecVerNumber_ = ibook.book1D("RecVerNumber", "RECO Vertex Number: Number of vertices", 50, 0, 250); @@ -538,7 +621,77 @@ void Primary4DVertexValidation::bookHistograms(DQMStore::IBooker& ibook, meRecPVT_ = ibook.book1D("recPVT", "#Rec vertices/10 ps", 200, -1., 1.); meSimPVZ_ = ibook.book1D("simPVZ", "Weighted #Sim vertices/mm", 400, -20., 20.); - //some tests + mePUTrackRelMult_ = ibook.book1D("PUTrackRelMult", "Relative number of PU tracks for matched vertices; #PUTrks/#TrksTot", 50, 0., 1.); + mePUTrackRelSumW_ = ibook.book1D("PUTrackRelSumW", "Relative Sum of Weights of PU tracks for matched vertices; PUSumW*min(Pt, 1.)/SumWTot*min(Pt, 1.)", 50, 0., 1.); + mePUTrackRelSumPt_ = ibook.book1D("PUTrackRelSumPt", "Relative Sum of Pt of PU tracks for matched vertices; PUSumPt/SumPtTot", 50, 0., 1.); + mePUTrackRelSumPt2_ = ibook.book1D("PUTrackRelSumPt2", "Relative Sum of Pt2 for PU tracks for matched vertices; PUSumPt2/SumPt2Tot", 50, 0., 1.); + mePUTrackRelSumPx_ = ibook.book1D("PUTrackRelSumPx", "Relative Sum of Px of PU tracks for matched vertices; PUSumPx/SumPxTot", 50, 0., 1.); + mePUTrackRelSumPy_ = ibook.book1D("PUTrackRelSumPy", "Relative Sum of Py of PU tracks for matched vertices; PUSumPy/SumPyTot", 50, 0., 1.); + mePUTrackRelSumPz_ = ibook.book1D("PUTrackRelSumPz", "Relative Sum of Pz of PU tracks for matched vertices; PUSumPz/SumPzTot", 50, 0., 1.); + + mePUTrackRecLVRelMult_ = ibook.book1D("PUTrackRecLVRelMult", "Relative number of PU tracks for matched LV; #PUTrks/#TrksTot", 50, 0., 1.); + mePUTrackRecLVRelSumW_ = ibook.book1D("PUTrackRecLVRelSumW", "Relative Sum of Weights of PU tracks for matched LV; PUSumW*min(Pt, 1.)/SumWTot*min(Pt, 1.)", 50, 0., 1.); + mePUTrackRecLVRelSumPt_ = ibook.book1D("PUTrackRecLVRelSumPt", "Relative Sum of Pt of PU tracks for matched LV; PUSumPt/SumPtTot", 50, 0., 1.); + mePUTrackRecLVRelSumPt2_ = ibook.book1D("PUTrackRecLVRelSumPt2", "Relative Sum of Pt2 of PU tracks for matched LV; PUSumPt2/SumPt2Tot", 50, 0., 1.); + mePUTrackRecLVRelSumPx_ = ibook.book1D("PUTrackRecLVRelSumPx", "Relative Sum of Px of PU tracks for matched LV; SumPx/SumPx", 50, 0., 1.); + mePUTrackRecLVRelSumPy_ = ibook.book1D("PUTrackRecLVRelSumPy", "Relative Sum of Py of PU tracks for matched LV; SumPy/SumPy", 50, 0., 1.); + mePUTrackRecLVRelSumPz_ = ibook.book1D("PUTrackRecLVRelSumPz", "Relative Sum of Pz of PU tracks for matched LV; SumPz/SumPz", 50, 0., 1.); + + if (optionalPlots_) { + mePUTrackMult_ = ibook.book1D("PUTrackMult", "Number of PU tracks for matched vertices; #PUTrks", 50, 0., 50.); + mePUTrackWnt_ = ibook.book1D("PUTrackWnt", "Weight of PU tracks for matched vertices; TrkW*min(Pt, 1.)", 50, 0., 1.); + mePUTrackSumW_ = ibook.book1D("PUTrackSumW", "Sum of Weights of PU tracks for matched vertices; SumW*min(Pt, 1.)", 40, 0., 40.); + mePUTrackSumPt_ = ibook.book1D("PUTrackSumPt", "Sum of Pt of PU tracks for matched vertices; SumPt [GeV]", 50, 0., 50.); + mePUTrackSumPt2_ = ibook.book1D("PUTrackSumPt2", "Sum of Pt2 for PU tracks for matched vertices; SumPt2 [GeV2]", 50, 0., 50.); + mePUTrackSumPx_ = ibook.book1D("PUTrackSumPx", "Sum of Px of PU tracks for matched vertices; SumPx [GeV]", 40, 0., 20.); + mePUTrackSumPy_ = ibook.book1D("PUTrackSumPy", "Sum of Py of PU tracks for matched vertices; SumPy [GeV]", 40, 0., 20.); + mePUTrackSumPz_ = ibook.book1D("PUTrackSumPz", "Sum of Pz of PU tracks for matched vertices; SumPz [GeV]", 50, 0., 50.); + + mePUTrackRecLVMult_ = ibook.book1D("PUTrackRecLVMult", "Number of PU tracks for matched LV; #PUTrks", 50, 0., 100.); + mePUTrackRecLVWnt_ = ibook.book1D("PUTrackRecLVWnt", "Weight of PU tracks for matched LV; TrkW*min(Pt, 1.)", 50, 0., 1.); + mePUTrackRecLVSumW_ = ibook.book1D("PUTrackRecLVSumW", "Sum of Weights of PU tracks for matched LV; SumW*min(Pt, 1.)", 40, 0., 40.); + mePUTrackRecLVSumPt_ = ibook.book1D("PUTrackRecLVSumPt", "Sum of Pt of PU tracks for matched LV; SumPt [GeV]", 50, 0., 100.); + mePUTrackRecLVSumPt2_ = ibook.book1D("PUTrackRecLVSumPt2", "Sum of Pt2 for PU tracks for matched LV; SumPt2 [GeV2]", 50, 0., 100.); + mePUTrackRecLVSumPx_ = ibook.book1D("PUTrackRecLVSumPx", "Sum of Px of PU tracks for matched LV; SumPx [GeV]", 40, 0., 20.); + mePUTrackRecLVSumPy_ = ibook.book1D("PUTrackRecLVSumPy", "Sum of Py of PU tracks for matched LV; SumPy [GeV]", 40, 0., 20.); + mePUTrackRecLVSumPz_ = ibook.book1D("PUTrackRecLVSumPz", "Sum of Pz of PU tracks for matched LV; SumPz [GeV]", 50, 0., 50.); + } + + meJetsPURelMult_ = ibook.book1D("JetsPURelMult", "Relative multiplicity of PU jets for matched vertices; #PUJets/#JetsTot", 50, 0., 1.); + meJetsPURelHt_ = ibook.book1D("JetsPURelHt", "Relative scalar sum of Et of PU jets for matched vertices; PUHt/HTTot", 50, 0., 1.); + meJetsPURelSumPt2_ = ibook.book1D("JetsPURelSumPt2", "Relative sum of Pt2 of PU jets for matched vertices; PUSumPt2/SumPt2Tot", 50, 0., 1.); + meJetsPURelMetPt_ = ibook.book1D("JetsPURelMetPt", "Relative Missing Transverse Energy of PU jets for matched vertices; PUMet/MetTot", 50, 0., 1.); + meJetsPURelSumPx_ = ibook.book1D("JetsPURelSumPx", "Relative Sum of Px of PU jets for matched vertices; PUSumPx/SumPxTot", 50, 0., 1.); + meJetsPURelSumPy_ = ibook.book1D("JetsPURelSumPy", "Relative Sum of Py of PU jets for matched vertices; PUSumPy/SumPyTot", 50, 0., 1.); + meJetsPURelSumPz_ = ibook.book1D("JetsPURelSumPz", "Relative Sum of Pz of PU jets for matched vertices; PUSumPz/SumPzTot", 50, 0., 1.); + + meJetsRecLVPURelMult_ = ibook.book1D("JetsRecLVPURelMult", "Relative multiplicity of PU jets for matched LV; #PUJets/#JetsTot", 50, 0., 1.); + meJetsRecLVPURelHt_ = ibook.book1D("JetsRecLVPURelHt", "Relative scalar sum of Et of PU jets for matched LV; PUHt/HTTot", 50, 0., 1.); + meJetsRecLVPURelSumPt2_ = ibook.book1D("JetsRecLVPURelSumPt2", "Relative sum of Pt2 of PU jets for matched LV; PUSumPt2/SumPt2Tot", 50, 0., 1.); + meJetsRecLVPURelMetPt_ = ibook.book1D("JetsRecLVPURelMetPt", "Relative Missing Transverse Energy of PU jets for matched LV; PUMet/MetTot", 50, 0., 1.); + meJetsRecLVPURelSumPx_ = ibook.book1D("JetsRecLVPURelSumPx", "Relative Sum of Px of PU jets for matched LV; SumPx/SumPxTot", 50, 0., 1.); + meJetsRecLVPURelSumPy_ = ibook.book1D("JetsRecLVPURelSumPy", "Relative Sum of Py of PU jets for matched LV; SumPy/SumPyTot", 50, 0., 1.); + meJetsRecLVPURelSumPz_ = ibook.book1D("JetsRecLVPURelSumPz", "Relative Sum of Pz of PU jets for matched LV; SumPz/SumPzTot", 50, 0., 1.); + + if (optionalPlots_) { + meJetsPUMult_ = ibook.book1D("JetsPUMult", "Number of PU jets for matched vertices; #Jets", 50, 0., 50.); + meJetsPUHt_ = ibook.book1D("JetsPUHt", "Scalar sum of Et of PU jets for matched vertices; Ht [GeV]", 50, 0., 100.); + meJetsPUSumPt2_ = ibook.book1D("JetsPUSumPt2", "Sum of Pt2 of PU jets for matched vertices; SumPt2 [GeV2]", 50, 0., 100.); + meJetsPUMetPt_ = ibook.book1D("JetsPUMetPt", "Missing Transverse Energy of PU jets for matched vertices; Met [GeV]", 40, 0., 40.); + meJetsPUSumPx_ = ibook.book1D("JetsPUSumPx", "Sum of Px of PU jets for matched vertices; SumPx [GeV]", 40, 0., 20.); + meJetsPUSumPy_ = ibook.book1D("JetsPUSumPy", "Sum of Py of PU jets for matched vertices; SumPy [GeV]", 40, 0., 20.); + meJetsPUSumPz_ = ibook.book1D("JetsPUSumPz", "Sum of Pz of PU jets for matched vertices; SumPz [GeV]", 50, 0., 50.); + + meJetsRecLVPUMult_ = ibook.book1D("JetsRecLVPUMult", "Number of PU jets for matched LV; #Jets", 50, 0., 50.); + meJetsRecLVPUHt_ = ibook.book1D("JetsRecLVPUHt", "Scalar sum of Et of PU jets for matched LV; Ht [GeV]", 50, 0., 100.); + meJetsRecLVPUSumPt2_ = ibook.book1D("JetsRecLVPUSumPt2", "Sum of Pt2 of PU jets for matched LV; SumPt2 [GeV2]", 50, 0., 2000.); + meJetsRecLVPUMetPt_ = ibook.book1D("JetsRecLVPUMetPt", "Missing Transverse Energy of PU jets for matched LV; Met [GeV]", 40, 0., 40.); + meJetsRecLVPUSumPx_ = ibook.book1D("JetsRecLVPUSumPx", "Sum of Px of PU jets for matched LV; SumPx [GeV]", 40, 0., 40.); + meJetsRecLVPUSumPy_ = ibook.book1D("JetsRecLVPUSumPy", "Sum of Py of PU jets for matched LV; SumPy [GeV]", 40, 0., 40.); + meJetsRecLVPUSumPz_ = ibook.book1D("JetsRecLVPUSumPz", "Sum of Pz of PU jets for matched LV; SumPz [GeV]", 50, 0., 100.); + } + + // some tests meTrackResLowPTot_ = ibook.book1D( "TrackResLowP", "t_{rec} - t_{sim} for tracks with p < 2 GeV; t_{rec} - t_{sim} [ns] ", 70, -0.15, 0.15); meTrackResLowP_[0] = @@ -694,9 +847,6 @@ void Primary4DVertexValidation::bookHistograms(DQMStore::IBooker& ibook, meBarrelNoPIDtype_ = ibook.book1D("BarrelNoPIDtype", "Barrel PID failure category", 4, 0., 4.); meEndcapNoPIDtype_ = ibook.book1D("EndcapNoPIDtype", "Endcap PID failure category", 4, 0., 4.); - meBarrelNoPIDtype_ = ibook.book1D("BarrelNoPIDtype", "Barrel PID failure category", 4, 0., 4.); - meEndcapNoPIDtype_ = ibook.book1D("EndcapNoPIDtype", "Endcap PID failure category", 4, 0., 4.); - meBarrelTruePiNoPID_ = ibook.book1D("BarrelTruePiNoPID", "True pi NoPID momentum spectrum, |eta| < 1.5;p [GeV]", 25, 0., 10.); meBarrelTrueKNoPID_ = @@ -704,7 +854,7 @@ void Primary4DVertexValidation::bookHistograms(DQMStore::IBooker& ibook, meBarrelTruePNoPID_ = ibook.book1D("BarrelTruePNoPID", "True p NoPID momentum spectrum, |eta| < 1.5;p [GeV]", 25, 0., 10.); meEndcapTruePiNoPID_ = - ibook.book1D("EndcapTruePiNoPID", "True NoPIDpi momentum spectrum, |eta| > 1.6;p [GeV]", 25, 0., 10.); + ibook.book1D("EndcapTruePiNoPID", "True pi NoPID momentum spectrum, |eta| > 1.6;p [GeV]", 25, 0., 10.); meEndcapTrueKNoPID_ = ibook.book1D("EndcapTrueKNoPID", "True k NoPID momentum spectrum, |eta| > 1.6;p [GeV]", 25, 0., 10.); meEndcapTruePNoPID_ = @@ -759,24 +909,26 @@ bool Primary4DVertexValidation::matchRecoTrack2SimSignal(const reco::TrackBaseRe return false; } -const edm::Ref>* Primary4DVertexValidation::getMatchedTP( +std::pair>*,bool> Primary4DVertexValidation::getMatchedTP( const reco::TrackBaseRef& recoTrack, const TrackingVertexRef& vsim) { auto found = r2s_->find(recoTrack); // reco track not matched to any TP if (found == r2s_->end()) - return nullptr; + return std::make_pair (nullptr,false); - //matched TP equal to any TP of sim vertex + // matched TP equal to any TP of sim vertex for (const auto& tp : found->val) { if (std::find_if(vsim->daughterTracks_begin(), vsim->daughterTracks_end(), [&](const TrackingParticleRef& vtp) { return tp.first == vtp; }) != vsim->daughterTracks_end()) - return &tp.first; + return std::make_pair (&tp.first,true); + // matched TP not associated to sim vertex (PU track) + else return std::make_pair (&tp.first,false); } // reco track not matched to any TP from vertex - return nullptr; + return std::make_pair (nullptr,false); } double Primary4DVertexValidation::timeFromTrueMass(double mass, double pathlength, double momentum, double time) { @@ -810,6 +962,94 @@ bool Primary4DVertexValidation::select(const reco::Vertex& v, int level) { return false; } +void Primary4DVertexValidation::observablesFromJets(const std::vector& reco_Tracks, const std::vector& mass_Tracks, + const std::vector& is_PUtrack, const bool& use_AllTracks, + unsigned int& n_Jets, double& sum_EtJets, double& sum_Pt2Jets, double& met_Pt, + double& sum_PxJets, double& sum_PyJets, double& sum_PzJets) { + double sum_PtJets = 0; + n_Jets = 0; + sum_EtJets = 0; + sum_Pt2Jets = 0; + met_Pt = 0; + sum_PxJets = 0; + sum_PyJets = 0; + sum_PzJets = 0; + auto met = LorentzVector(0, 0, 0, 0); + std::vector fjInputs_; + fjInputs_.clear(); + size_t countScale0 = 0; + for (size_t i = 0; i < reco_Tracks.size(); i++) { + const auto recotr = reco_Tracks[i]; + const auto mass = mass_Tracks[i]; + float scale = 1.; + if (recotr.charge() == 0) { + continue; + } + // skip PU tracks in jet definition if use_AllTracks flag is false + if (!use_AllTracks && is_PUtrack[i]) { + continue; + } + if (recotr.pt() != 0) { + scale = (recotr.pt()-recotr.ptError())/recotr.pt(); + } + if (edm::isNotFinite(scale)) { + edm::LogWarning("Primary4DVertexValidation") << "Scaling is NAN ignoring this recotrack" << std::endl; + scale = 0; + } + if (scale < 0) { + scale = 0; + countScale0++; + } + if (scale != 0) { + fjInputs_.push_back(fastjet::PseudoJet(recotr.px() * scale, recotr.py() * scale, recotr.pz() * scale, std::sqrt(recotr.p() * recotr.p() + mass * mass) * scale)); + } + } + fastjet::ClusterSequence sequence(fjInputs_, fastjet::JetDefinition(fastjet::antikt_algorithm, 0.4)); + auto jets = fastjet::sorted_by_pt(sequence.inclusive_jets(0)); + for (const auto &pj : jets) { + auto p4 = LorentzVector(pj.px(), pj.py(), pj.pz(), pj.e()); + sum_EtJets += std::sqrt(p4.e() * p4.e() - p4.P() * p4.P() + p4.pt() * p4.pt()); + sum_PtJets += p4.pt(); + sum_Pt2Jets += p4.pt() * p4.pt() * 0.8 * 0.8; + met += p4; + sum_PxJets += p4.px(); + sum_PyJets += p4.py(); + sum_PzJets += p4.pz(); + n_Jets++; + } + met_Pt = met.pt(); + double metAbove = met_Pt - 2 * std::sqrt(sum_PtJets); + if (metAbove > 0) { + sum_Pt2Jets += metAbove * metAbove; + } + if (countScale0 == reco_Tracks.size()) { + sum_Pt2Jets = countScale0 * 0.01; //leave some epsilon value to sort vertices with unknown pt + } +} + +void Primary4DVertexValidation::isParticle(const reco::TrackBaseRef& recoTrack, const double& minProbHeavy_, + const edm::ValueMap& probPi, const edm::ValueMap& probK, + const edm::ValueMap& probP, unsigned int& no_PIDtype, bool& no_PID, + bool& is_Pi, bool& is_K, bool& is_P) { + no_PIDtype = 0; + no_PID = false; + is_Pi = false; + is_K = false; + is_P = false; + if (probPi[recoTrack] == -1) { + no_PIDtype = 1; + } else if (std::isnan(probPi[recoTrack])) { + no_PIDtype = 2; + } else if (probPi[ +recoTrack] == 1 && probK[recoTrack] == 0 && probP[recoTrack] == 0) { + no_PIDtype = 3; + } + no_PID = no_PIDtype > 0; + is_Pi = !no_PID && 1. - probPi[recoTrack] < minProbHeavy_; + is_K = !no_PID && !is_Pi && probK[recoTrack] > probP[recoTrack]; + is_P = !no_PID && !is_Pi && !is_K; +} + /* Extract information form TrackingParticles/TrackingVertex and fill * the helper class simPrimaryVertex with proper generation-level * information */ @@ -819,7 +1059,7 @@ std::vector Primary4DVertexValidati int current_event = -1; int s = -1; for (TrackingVertexCollection::const_iterator v = tVC->begin(); v != tVC->end(); ++v) { - //We keep only the first vertex from all the events at BX=0. + // We keep only the first vertex from all the events at BX=0. if (v->eventId().bunchCrossing() != 0) continue; if (v->eventId().event() != current_event) { @@ -1010,8 +1250,10 @@ void Primary4DVertexValidation::matchReco2Sim(std::vector& re if (MVA[(*iTrack)] < mvaTh_) continue; - auto tp_info = getMatchedTP(*iTrack, simpv.at(iev).sim_vertex); - if (tp_info != nullptr) { + auto tp_pair = getMatchedTP(*iTrack, simpv.at(iev).sim_vertex); + auto tp_info = tp_pair.first; + bool isMatchedTP = tp_pair.second; + if (tp_info != nullptr && isMatchedTP) { double dz2_beam = pow((*BS).BeamWidthX() * cos((*iTrack)->phi()) / tan((*iTrack)->theta()), 2) + pow((*BS).BeamWidthY() * sin((*iTrack)->phi()) / tan((*iTrack)->theta()), 2); double dz2 = pow((*iTrack)->dzError(), 2) + dz2_beam + @@ -1030,7 +1272,7 @@ void Primary4DVertexValidation::matchReco2Sim(std::vector& re evwnt += wnt; evnt++; } - } //RecoTracks loop + } // RecoTracks loop // require 2 tracks for a wos-match if ((evwos > 0) && (evwos > recopv.at(iv).maxwos) && (evnt > 1)) { @@ -1047,11 +1289,11 @@ void Primary4DVertexValidation::matchReco2Sim(std::vector& re recopv.at(iv).wntmatch = iev; recopv.at(iv).maxwnt = evwnt; } - } //TrackingVertex loop + } // TrackingVertex loop - } //RecoPrimaryVertex + } // RecoPrimaryVertex - //after filling infos, goes for the sim-reco match + // after filling infos, goes for the sim-reco match for (auto& vrec : recopv) { vrec.sim = NOT_MATCHED; vrec.matchQuality = 0; @@ -1073,7 +1315,7 @@ void Primary4DVertexValidation::matchReco2Sim(std::vector& re vv.matchQuality = 0; iev++; } - //this tries a one-to-one match, taking simPV with highest wos if there are > 1 simPV candidates + // this tries a one-to-one match, taking simPV with highest wos if there are > 1 simPV candidates for (unsigned int rank = 1; rank < maxRank_; rank++) { for (unsigned int iev = 0; iev < simpv.size(); iev++) { //loop on SimPV if (simpv.at(iev).rec != NOT_MATCHED) @@ -1095,7 +1337,7 @@ void Primary4DVertexValidation::matchReco2Sim(std::vector& re } } if (iv != - NOT_MATCHED) { //if the rec vertex has already been associated is possible that iv remains NOT_MATCHED at this point + NOT_MATCHED) { // if the rec vertex has already been associated is possible that iv remains NOT_MATCHED at this point recopv.at(iv).sim = iev; simpv.at(iev).rec = iv; recopv.at(iv).matchQuality = rank; @@ -1120,7 +1362,7 @@ void Primary4DVertexValidation::matchReco2Sim(std::vector& re } } - if (rec == NOT_MATCHED) { //try with wnt match + if (rec == NOT_MATCHED) { // try with wnt match for (auto rv : simpv.at(iev).wnt) { if ((rec == NOT_MATCHED) || (rv.second > simpv.at(iev).wnt.at(rec))) { rec = rv.first; @@ -1150,7 +1392,7 @@ void Primary4DVertexValidation::matchReco2Sim(std::vector& re simpv.at(iev).matchQuality = maxRank_; nmatch++; } - } //sim loop + } // sim loop if (nmatch == 0) { break; } @@ -1209,7 +1451,7 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve std::vector simpv; // a list of simulated primary MC vertices simpv = getSimPVs(TVCollectionH); - //this bool check if first vertex in that with highest pT + // this bool check if first vertex in that with highest pT bool signal_is_highest_pt = std::max_element(simpv.begin(), simpv.end(), [](const simPrimaryVertex& lhs, const simPrimaryVertex& rhs) { return lhs.ptsq < rhs.ptsq; @@ -1237,22 +1479,23 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve const auto& probPi = iEvent.get(probPiToken_); const auto& probK = iEvent.get(probKToken_); const auto& probP = iEvent.get(probPToken_); + const auto& fPDGTable = iSetup.getHandle(pdtToken_); - //I have simPV and recoPV collections + // I have simPV and recoPV collections matchReco2Sim(recopv, simpv, sigmat0Safe, mtdQualMVA, BeamSpotH); - //Loop on tracks + // Loop on tracks for (unsigned int iv = 0; iv < recopv.size(); iv++) { if (recopv.at(iv).ndof > selNdof_) { const reco::Vertex* vertex = recopv.at(iv).recVtx; for (unsigned int iev = 0; iev < simpv.size(); iev++) { auto vsim = simpv.at(iev).sim_vertex; - - bool selectedVtxMatching = recopv.at(iv).sim == iev && simpv.at(iev).rec == iv && - simpv.at(iev).eventId.bunchCrossing() == 0 && simpv.at(iev).eventId.event() == 0 && + bool selectedVtxMatching = recopv.at(iv).sim == iev && simpv.at(iev).rec == iv; + bool selectedLV = simpv.at(iev).eventId.bunchCrossing() == 0 && simpv.at(iev).eventId.event() == 0 && recopv.at(iv).OriginalIndex == 0; - if (selectedVtxMatching && !recopv.at(iv).is_signal()) { + bool selectedLVMatching = selectedVtxMatching && selectedLV; + if (selectedLVMatching && !recopv.at(iv).is_signal()) { edm::LogWarning("Primary4DVertexValidation") << "Reco vtx leading match inconsistent: BX/ID " << simpv.at(iev).eventId.bunchCrossing() << " " << simpv.at(iev).eventId.event(); @@ -1260,6 +1503,16 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve double vzsim = simpv.at(iev).z; double vtsim = simpv.at(iev).t * simUnit_; + double sumW = 0, sumPt = 0, sumPt2 = 0, sumPx = 0, sumPy = 0, sumPz = 0; + double sumWTot = 0, sumPtTot = 0, sumPt2Tot = 0, sumPxTot = 0, sumPyTot = 0, sumPzTot = 0; + unsigned int nt = 0, PUnt = 0; + + std::vector massVector; + std::vector recotracks; + std::vector isPUtrack; + double sumEtJets = 0, sumPt2Jets = 0, metPt = 0, sumPxJets = 0, sumPyJets = 0, sumPzJets = 0; + double sumEtJetsnoPU = 0, sumPt2JetsnoPU = 0, metPtnoPU = 0, sumPxJetsnoPU = 0, sumPyJetsnoPU = 0, sumPzJetsnoPU = 0; + unsigned int nJets = 0, nJetsnoPU = 0; for (auto iTrack = vertex->tracks_begin(); iTrack != vertex->tracks_end(); ++iTrack) { if (trackAssoc[*iTrack] == -1) { LogTrace("mtdTracks") << "Extended track not associated"; @@ -1272,15 +1525,74 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve bool noCrack = std::abs((*iTrack)->eta()) < trackMaxBtlEta_ || std::abs((*iTrack)->eta()) > trackMinEtlEta_; bool selectRecoTrk = mvaRecSel(**iTrack, *vertex, t0Safe[*iTrack], sigmat0Safe[*iTrack]); - if (selectedVtxMatching && selectRecoTrk) { + if (selectedLVMatching && selectRecoTrk) { if (noCrack) { meMVATrackEffPtTot_->Fill((*iTrack)->pt()); } meMVATrackEffEtaTot_->Fill(std::abs((*iTrack)->eta())); } - auto tp_info = getMatchedTP(*iTrack, vsim); - if (tp_info != nullptr) { + auto tp_pair = getMatchedTP(*iTrack, vsim); + auto tp_info = tp_pair.first; + bool isMatchedTP = tp_pair.second; + + // matched TP not associated to sim vertex (PU track) + if (selectedVtxMatching) { + unsigned int no_PIDtype = 0; + bool no_PID, is_Pi, is_K, is_P; + int PartID = 211; // pion + isParticle(*iTrack, minProbHeavy_, probPi, probK, probP, no_PIDtype, no_PID, is_Pi, is_K, is_P); + if (no_PID || is_Pi) { + PartID = 211; + } + else if (is_K) { + PartID = 321; + } + else if (is_P) { + PartID = 2212; + } + const HepPDT::ParticleData* PData = fPDGTable->particle(HepPDT::ParticleID(abs(PartID))); + double mass = PData->mass().value(); + massVector.push_back(mass); + recotracks.push_back(**iTrack); + if (tp_info != nullptr) { + if (!isMatchedTP) { + if (optionalPlots_){ + mePUTrackWnt_->Fill(vertex->trackWeight(*iTrack) * std::min((*iTrack)->pt(), 1.0)); + } + sumW += vertex->trackWeight(*iTrack) * std::min((*iTrack)->pt(), 1.0); + sumPt += (*iTrack)->pt(); + sumPt2 += (*iTrack)->pt() * (*iTrack)->pt(); + sumPx += (*iTrack)->px(); + sumPy += (*iTrack)->py(); + sumPz += (*iTrack)->pz(); + PUnt++; + isPUtrack.push_back(true); + } + else { + isPUtrack.push_back(false); + } + nt++; + sumWTot += vertex->trackWeight(*iTrack) * std::min((*iTrack)->pt(), 1.0); + sumPtTot += (*iTrack)->pt(); + sumPt2Tot += (*iTrack)->pt() * (*iTrack)->pt(); + sumPxTot += (*iTrack)->px(); + sumPyTot += (*iTrack)->py(); + sumPzTot += (*iTrack)->pz(); + } + // Primary Vertex + if (selectedLV) { + if (tp_info != nullptr && !isMatchedTP) { + if (optionalPlots_){ + mePUTrackRecLVWnt_->Fill(vertex->trackWeight(*iTrack) * std::min((*iTrack)->pt(), 1.0)); + } + } + } + } + + + // matched TP equal to any TP of sim vertex + if (tp_info != nullptr && isMatchedTP) { double mass = (*tp_info)->mass(); double tsim = (*tp_info)->parentVertex()->position().t() * simUnit_; double tEst = timeFromTrueMass(mass, pathLength[*iTrack], momentum[*iTrack], time[*iTrack]); @@ -1302,7 +1614,7 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve bool selectTP = mvaTPSel(**tp_info); - if (selectedVtxMatching && selectRecoTrk && selectTP) { + if (selectedLVMatching && selectRecoTrk && selectTP) { meMVATrackZposResTot_->Fill((*iTrack)->vz() - vzsim); if (noCrack) { meMVATrackMatchedEffPtTot_->Fill((*iTrack)->pt()); @@ -1313,7 +1625,7 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve if (sigmat0Safe[*iTrack] == -1) continue; - if (selectedVtxMatching && selectRecoTrk && selectTP) { + if (selectedLVMatching && selectRecoTrk && selectTP) { meMVATrackResTot_->Fill(t0Safe[*iTrack] - vtsim); meMVATrackPullTot_->Fill((t0Safe[*iTrack] - vtsim) / sigmat0Safe[*iTrack]); if (noCrack) { @@ -1322,17 +1634,8 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve meMVATrackMatchedEffEtaMtd_->Fill(std::abs((*iTrack)->eta())); unsigned int noPIDtype = 0; - if (probPi[*iTrack] == -1) { - noPIDtype = 1; - } else if (edm::isNotFinite(probPi[*iTrack])) { - noPIDtype = 2; - } else if (probPi[*iTrack] == 1 && probK[*iTrack] == 0 && probP[*iTrack] == 0) { - noPIDtype = 3; - } - bool noPID = noPIDtype > 0; - bool isPi = !noPID && 1. - probPi[*iTrack] < minProbHeavy_; - bool isK = !noPID && !isPi && probK[*iTrack] > probP[*iTrack]; - bool isP = !noPID && !isPi && !isK; + bool noPID = false, isPi = false, isK = false, isP = false; + isParticle(*iTrack, minProbHeavy_, probPi, probK, probP, noPIDtype, noPID, isPi, isK, isP); if ((isPi && std::abs(tMtd[*iTrack] - tofPi[*iTrack] - t0Pid[*iTrack]) > tol_) || (isK && std::abs(tMtd[*iTrack] - tofK[*iTrack] - t0Pid[*iTrack]) > tol_) || @@ -1543,7 +1846,80 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve } } } - } //if tp_info != nullptr + } // if tp_info != nullptr && isMatchedTP + } // loop on tracks + if (selectedVtxMatching) { + mePUTrackRelMult_->Fill(static_cast(PUnt)/nt); + mePUTrackRelSumW_->Fill(sumW/sumWTot); + mePUTrackRelSumPt_->Fill(sumPt/sumPtTot); + mePUTrackRelSumPt2_->Fill(sumPt2/sumPt2Tot); + mePUTrackRelSumPx_->Fill(std::abs(sumPx)/std::abs(sumPxTot)); + mePUTrackRelSumPy_->Fill(std::abs(sumPy)/std::abs(sumPyTot)); + mePUTrackRelSumPz_->Fill(std::abs(sumPz)/std::abs(sumPzTot)); + + observablesFromJets(recotracks, massVector, isPUtrack, true, nJets, sumEtJets, sumPt2Jets, metPt, sumPxJets, sumPyJets, sumPzJets); + observablesFromJets(recotracks, massVector, isPUtrack, false, nJetsnoPU, sumEtJetsnoPU, sumPt2JetsnoPU, metPtnoPU, sumPxJetsnoPU, sumPyJetsnoPU, sumPzJetsnoPU); + meJetsPURelMult_->Fill(static_cast(nJets-nJetsnoPU)/nJets); + meJetsPURelHt_->Fill((sumEtJets-sumEtJetsnoPU)/sumEtJets); + meJetsPURelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); + meJetsPURelMetPt_->Fill((metPt-metPtnoPU)/metPt); + meJetsPURelSumPx_->Fill(std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); + meJetsPURelSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); + meJetsPURelSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); + + if (optionalPlots_) { + mePUTrackMult_->Fill(PUnt); + mePUTrackSumW_->Fill(sumW); + mePUTrackSumPt_->Fill(sumPt); + mePUTrackSumPt2_->Fill(sumPt2); + mePUTrackSumPx_->Fill(std::abs(sumPx)); + mePUTrackSumPy_->Fill(std::abs(sumPy)); + mePUTrackSumPz_->Fill(std::abs(sumPz)); + + meJetsPUMult_->Fill(nJets-nJetsnoPU); + meJetsPUHt_->Fill(sumEtJets-sumEtJetsnoPU); + meJetsPUSumPt2_->Fill(sumPt2Jets-sumPt2JetsnoPU); + meJetsPUMetPt_->Fill(metPt-metPtnoPU); + meJetsPUSumPx_->Fill(std::abs(sumPxJets-sumPxJetsnoPU)); + meJetsPUSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)); + meJetsPUSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)); + } + + if (selectedLV) { + mePUTrackRecLVRelMult_->Fill(static_cast(PUnt)/nt); + mePUTrackRecLVRelSumW_->Fill(sumW/sumWTot); + mePUTrackRecLVRelSumPt_->Fill(sumPt/sumPtTot); + mePUTrackRecLVRelSumPt2_->Fill(sumPt2/sumPt2Tot); + mePUTrackRecLVRelSumPx_->Fill(std::abs(sumPx)/std::abs(sumPxTot)); + mePUTrackRecLVRelSumPy_->Fill(std::abs(sumPy)/std::abs(sumPyTot)); + mePUTrackRecLVRelSumPz_->Fill(std::abs(sumPz)/std::abs(sumPzTot)); + + meJetsRecLVPURelMult_->Fill(static_cast(nJets-nJetsnoPU)/nJets); + meJetsRecLVPURelHt_->Fill((sumEtJets-sumEtJetsnoPU)/sumEtJets); + meJetsRecLVPURelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); + meJetsRecLVPURelMetPt_->Fill((metPt-metPtnoPU)/metPt); + meJetsRecLVPURelSumPx_->Fill(std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); + meJetsRecLVPURelSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); + meJetsRecLVPURelSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); + + if (optionalPlots_) { + mePUTrackRecLVMult_->Fill(PUnt); + mePUTrackRecLVSumW_->Fill(sumW); + mePUTrackRecLVSumPt_->Fill(sumPt); + mePUTrackRecLVSumPt2_->Fill(sumPt2); + mePUTrackRecLVSumPx_->Fill(std::abs(sumPx)); + mePUTrackRecLVSumPy_->Fill(std::abs(sumPy)); + mePUTrackRecLVSumPz_->Fill(std::abs(sumPz)); + + meJetsRecLVPUMult_->Fill(nJets-nJetsnoPU); + meJetsRecLVPUHt_->Fill(sumEtJets-sumEtJetsnoPU); + meJetsRecLVPUSumPt2_->Fill(sumPt2Jets-sumPt2JetsnoPU); + meJetsRecLVPUMetPt_->Fill(metPt-metPtnoPU); + meJetsRecLVPUSumPx_->Fill(std::abs(sumPxJets-sumPxJetsnoPU)); + meJetsRecLVPUSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)); + meJetsRecLVPUSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)); + } + } } } } // ndof @@ -1600,7 +1976,7 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve mePUvsOtherFakeV_->Fill(simpv.size(), other_fake); mePUvsSplitV_->Fill(simpv.size(), split); - //fill vertices histograms here in a new loop + // fill vertices histograms here in a new loop for (unsigned int is = 0; is < simpv.size(); is++) { // protect against particle guns with very displaced vertices if (edm::isNotFinite(1. / puLineDensity(simpv.at(is).z))) { @@ -1624,7 +2000,7 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve meTimeRes_->Fill(recopv.at(ir).recVtx->t() - simpv.at(is).t * simUnit_); meTimePull_->Fill((recopv.at(ir).recVtx->t() - simpv.at(is).t * simUnit_) / recopv.at(ir).recVtx->tError()); meMatchQual_->Fill(recopv.at(ir).matchQuality - 0.5); - if (ir == 0) { //signal vertex plots + if (ir == 0) { // signal vertex plots meTimeSignalRes_->Fill(recopv.at(ir).recVtx->t() - simpv.at(is).t * simUnit_); meTimeSignalPull_->Fill((recopv.at(ir).recVtx->t() - simpv.at(is).t * simUnit_) / recopv.at(ir).recVtx->tError()); @@ -1646,7 +2022,6 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve recopv.at(ir).OriginalIndex); // position in reco vtx correction associated to sim signal } } - if (debug_) { edm::LogPrint("Primary4DVertexValidation") << "*** Matching RECO: " << ir << "with SIM: " << is << " ***"; edm::LogPrint("Primary4DVertexValidation") << "Match Quality is " << recopv.at(ir).matchQuality; @@ -1657,7 +2032,7 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve } } - //dz histos + // dz histos for (unsigned int iv = 0; iv < recVtxs->size() - 1; iv++) { if (recVtxs->at(iv).ndof() > selNdof_) { double mindistance_realreal = 1e10; @@ -1710,7 +2085,7 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve } } } - } //ndof + } // ndof } } // end of analyze From be1233d20dca41f163f81ac123d903744eb0a10d Mon Sep 17 00:00:00 2001 From: Raffaele Delli Gatti Date: Mon, 19 Feb 2024 16:15:54 +0100 Subject: [PATCH 2/7] Added use3dNoTime flag to Primary4DVertexValidation.cc --- .../plugins/Primary4DVertexValidation.cc | 23 +++++++++++-------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc index 419be1408d55f..ac672fc15d2b2 100644 --- a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc +++ b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc @@ -253,6 +253,7 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { bool use_only_charged_tracks_; bool debug_; bool optionalPlots_; + bool use3dNoTime_; const double minProbHeavy_; const double trackweightTh_; @@ -454,6 +455,7 @@ Primary4DVertexValidation::Primary4DVertexValidation(const edm::ParameterSet& iC use_only_charged_tracks_(iConfig.getParameter("useOnlyChargedTracks")), debug_(iConfig.getUntrackedParameter("debug")), optionalPlots_(iConfig.getUntrackedParameter("optionalPlots")), + use3dNoTime_(iConfig.getUntrackedParameter("use3dNoTime")), minProbHeavy_(iConfig.getParameter("minProbHeavy")), trackweightTh_(iConfig.getParameter("trackweightTh")), mvaTh_(iConfig.getParameter("mvaTh")), @@ -1001,7 +1003,7 @@ void Primary4DVertexValidation::observablesFromJets(const std::vectorparticle(HepPDT::ParticleID(abs(PartID))); double mass = PData->mass().value(); @@ -2119,6 +2123,7 @@ void Primary4DVertexValidation::fillDescriptions(edm::ConfigurationDescriptions& desc.add("useOnlyChargedTracks", true); desc.addUntracked("debug", false); desc.addUntracked("optionalPlots", false); + desc.addUntracked("use3dNoTime", false); desc.add("trackweightTh", 0.5); desc.add("mvaTh", 0.01); desc.add("minProbHeavy", 0.75); From 80dac5d4fe0a9f7ccb1409334d8e9a6e8a9b8119 Mon Sep 17 00:00:00 2001 From: Raffaele Delli Gatti Date: Wed, 21 Feb 2024 18:10:21 +0100 Subject: [PATCH 3/7] Correction of PU track definition, wos added, study of fake tracks, LogPrint for debugging, mePUTrackRecLVWnt_->fill() moved --- .../plugins/Primary4DVertexValidation.cc | 546 +++++++++++++----- 1 file changed, 404 insertions(+), 142 deletions(-) diff --git a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc index ac672fc15d2b2..1688a57f803d7 100644 --- a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc +++ b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc @@ -73,6 +73,7 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { y(y1), z(z1), t(t1), + pt(0), ptsq(0), closest_vertex_distance_z(-1.), nGenTrk(0), @@ -88,6 +89,7 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { double x, y, z, r, t; HepMC::FourVector ptot; LorentzVector p4; + double pt; double ptsq; double closest_vertex_distance_z; int nGenTrk; @@ -105,7 +107,7 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { std::map wos; // sum of wos in recvtx (by index) // oops -> this was int before 04-22 double sumwos = 0; // sum of wos in any recvtx double sumwnt = 0; // sum of weighted tracks - unsigned int rec = NOT_MATCHED; // best match (NO_MATCH if not matched) + unsigned int rec = NOT_MATCHED; // best match (NO_MATCH if not matched) unsigned int matchQuality = 0; // quality flag void addTrack(unsigned int irecv, double twos, double twt) { @@ -158,9 +160,9 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { double sumwos = 0; // total sum of wos of all truth matched tracks double sumwnt = 0; // total weighted number of truth matchted tracks double maxwos = 0; // largest wos sum from one sim event (wosmatch) - double maxwnt = 0; // largest weighted number of tracks from one sim event (ntmatch) + double maxwnt = 0; // largest weighted number of tracks from one sim event (ntmatch) int maxwosnt = 0; // number of tracks from the simevt with highest wos - unsigned int sim = NOT_MATCHED; // best match (NO_MATCH if not matched) + unsigned int sim = NOT_MATCHED; // best match (NO_MATCH if not matched) unsigned int matchQuality = 0; // quality flag bool is_real() { return (matchQuality > 0) && (matchQuality < 99); } @@ -210,17 +212,19 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { const edm::ValueMap&, const edm::Handle&); bool matchRecoTrack2SimSignal(const reco::TrackBaseRef&); - std::pair>*,bool> getMatchedTP(const reco::TrackBaseRef&, const TrackingVertexRef&); + std::pair>*,int> getMatchedTP(const reco::TrackBaseRef&, const TrackingVertexRef&); double timeFromTrueMass(double, double, double, double); bool select(const reco::Vertex&, int level = 0); void observablesFromJets(const std::vector&, const std::vector&, - const std::vector&, const bool&, + const std::vector&, const std::string&, unsigned int&, double&, double&, double&, double&, double&, double&); void isParticle(const reco::TrackBaseRef&, const double&, const edm::ValueMap&, const edm::ValueMap&, const edm::ValueMap&, unsigned int&, bool&, bool&, bool&, bool&); + void printMatchedRecoTrackInfo(const reco::Vertex&, const reco::TrackBaseRef&, const TrackingParticleRef&, const unsigned int&); + void printSimVtxRecoVtxInfo(const struct Primary4DVertexValidation::simPrimaryVertex&, const struct Primary4DVertexValidation::recoPrimaryVertex&); std::vector getSimPVs(const edm::Handle&); std::vector getRecoPVs(const edm::Handle>&); @@ -338,8 +342,14 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* mePUTrackMult_; MonitorElement* mePUTrackRelMult_; - MonitorElement* mePUTrackSumW_; - MonitorElement* mePUTrackRelSumW_; + MonitorElement* meFakeTrackRelMult_; + MonitorElement* mePUTrackSumWnt_; + MonitorElement* mePUTrackRelSumWnt_; + MonitorElement* mePUTrackSumWos_; + MonitorElement* mePUTrackRelSumWos_; + MonitorElement* meSecTrackSumWos_; + MonitorElement* meSecTrackRelSumWos_; + MonitorElement* meFakeTrackRelSumWos_; MonitorElement* mePUTrackWnt_; MonitorElement* mePUTrackSumPt_; MonitorElement* mePUTrackRelSumPt_; @@ -352,10 +362,28 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* mePUTrackRelSumPy_; MonitorElement* mePUTrackRelSumPz_; + MonitorElement* mePUTrackRelMultvsMult_; + MonitorElement* meFakeTrackRelMultvsMult_; + MonitorElement* mePUTrackRelSumWntvsSumWnt_; + MonitorElement* mePUTrackRelSumWosvsSumWos_; + MonitorElement* meFakeTrackRelSumWosvsSumWos_; + MonitorElement* meSecTrackRelSumWosvsSumWos_; + MonitorElement* mePUTrackRelSumPtvsSumPt_; + MonitorElement* mePUTrackRelSumPt2vsSumPt2_; + MonitorElement* mePUTrackRelSumPxvsSumPx_; + MonitorElement* mePUTrackRelSumPyvsSumPy_; + MonitorElement* mePUTrackRelSumPzvsSumPz_; + MonitorElement* mePUTrackRecLVMult_; MonitorElement* mePUTrackRecLVRelMult_; - MonitorElement* mePUTrackRecLVSumW_; - MonitorElement* mePUTrackRecLVRelSumW_; + MonitorElement* meFakeTrackRecLVRelMult_; + MonitorElement* mePUTrackRecLVSumWnt_; + MonitorElement* mePUTrackRecLVRelSumWnt_; + MonitorElement* mePUTrackRecLVSumWos_; + MonitorElement* mePUTrackRecLVRelSumWos_; + MonitorElement* meSecTrackRecLVSumWos_; + MonitorElement* meSecTrackRecLVRelSumWos_; + MonitorElement* meFakeTrackRecLVRelSumWos_; MonitorElement* mePUTrackRecLVWnt_; MonitorElement* mePUTrackRecLVSumPt_; MonitorElement* mePUTrackRecLVRelSumPt_; @@ -368,6 +396,18 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* mePUTrackRecLVRelSumPy_; MonitorElement* mePUTrackRecLVRelSumPz_; + MonitorElement* mePUTrackRecLVRelMultvsMult_; + MonitorElement* meFakeTrackRecLVRelMultvsMult_; + MonitorElement* mePUTrackRecLVRelSumWntvsSumWnt_; + MonitorElement* mePUTrackRecLVRelSumWosvsSumWos_; + MonitorElement* meSecTrackRecLVRelSumWosvsSumWos_; + MonitorElement* meFakeTrackRecLVRelSumWosvsSumWos_; + MonitorElement* mePUTrackRecLVRelSumPtvsSumPt_; + MonitorElement* mePUTrackRecLVRelSumPt2vsSumPt2_; + MonitorElement* mePUTrackRecLVRelSumPxvsSumPx_; + MonitorElement* mePUTrackRecLVRelSumPyvsSumPy_; + MonitorElement* mePUTrackRecLVRelSumPzvsSumPz_; + MonitorElement* meJetsPUMult_; MonitorElement* meJetsPUHt_; MonitorElement* meJetsPUSumPt2_; @@ -378,11 +418,21 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* meJetsPURelMult_; MonitorElement* meJetsPURelHt_; MonitorElement* meJetsPURelSumPt2_; + MonitorElement* meJetsFakeRelSumPt2_; MonitorElement* meJetsPURelMetPt_; MonitorElement* meJetsPURelSumPx_; MonitorElement* meJetsPURelSumPy_; MonitorElement* meJetsPURelSumPz_; + MonitorElement* meJetsPURelMultvsMult_; + MonitorElement* meJetsPURelHtvsHt_; + MonitorElement* meJetsPURelSumPt2vsSumPt2_; + MonitorElement* meJetsFakeRelSumPt2vsSumPt2_; + MonitorElement* meJetsPURelMetPtvsMetPt_; + MonitorElement* meJetsPURelSumPxvsSumPx_; + MonitorElement* meJetsPURelSumPyvsSumPy_; + MonitorElement* meJetsPURelSumPzvsSumPz_; + MonitorElement* meJetsRecLVPUMult_; MonitorElement* meJetsRecLVPUHt_; MonitorElement* meJetsRecLVPUSumPt2_; @@ -393,11 +443,21 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* meJetsRecLVPURelMult_; MonitorElement* meJetsRecLVPURelHt_; MonitorElement* meJetsRecLVPURelSumPt2_; + MonitorElement* meJetsRecLVFakeRelSumPt2_; MonitorElement* meJetsRecLVPURelMetPt_; MonitorElement* meJetsRecLVPURelSumPx_; MonitorElement* meJetsRecLVPURelSumPy_; MonitorElement* meJetsRecLVPURelSumPz_; + MonitorElement* meJetsRecLVPURelMultvsMult_; + MonitorElement* meJetsRecLVPURelHtvsHt_; + MonitorElement* meJetsRecLVPURelSumPt2vsSumPt2_; + MonitorElement* meJetsRecLVFakeRelSumPt2vsSumPt2_; + MonitorElement* meJetsRecLVPURelMetPtvsMetPt_; + MonitorElement* meJetsRecLVPURelSumPxvsSumPx_; + MonitorElement* meJetsRecLVPURelSumPyvsSumPy_; + MonitorElement* meJetsRecLVPURelSumPzvsSumPz_; + // some tests MonitorElement* meTrackResLowPTot_; MonitorElement* meTrackResHighPTot_; @@ -623,74 +683,130 @@ void Primary4DVertexValidation::bookHistograms(DQMStore::IBooker& ibook, meRecPVT_ = ibook.book1D("recPVT", "#Rec vertices/10 ps", 200, -1., 1.); meSimPVZ_ = ibook.book1D("simPVZ", "Weighted #Sim vertices/mm", 400, -20., 20.); - mePUTrackRelMult_ = ibook.book1D("PUTrackRelMult", "Relative number of PU tracks for matched vertices; #PUTrks/#TrksTot", 50, 0., 1.); - mePUTrackRelSumW_ = ibook.book1D("PUTrackRelSumW", "Relative Sum of Weights of PU tracks for matched vertices; PUSumW*min(Pt, 1.)/SumWTot*min(Pt, 1.)", 50, 0., 1.); - mePUTrackRelSumPt_ = ibook.book1D("PUTrackRelSumPt", "Relative Sum of Pt of PU tracks for matched vertices; PUSumPt/SumPtTot", 50, 0., 1.); - mePUTrackRelSumPt2_ = ibook.book1D("PUTrackRelSumPt2", "Relative Sum of Pt2 for PU tracks for matched vertices; PUSumPt2/SumPt2Tot", 50, 0., 1.); - mePUTrackRelSumPx_ = ibook.book1D("PUTrackRelSumPx", "Relative Sum of Px of PU tracks for matched vertices; PUSumPx/SumPxTot", 50, 0., 1.); - mePUTrackRelSumPy_ = ibook.book1D("PUTrackRelSumPy", "Relative Sum of Py of PU tracks for matched vertices; PUSumPy/SumPyTot", 50, 0., 1.); - mePUTrackRelSumPz_ = ibook.book1D("PUTrackRelSumPz", "Relative Sum of Pz of PU tracks for matched vertices; PUSumPz/SumPzTot", 50, 0., 1.); - - mePUTrackRecLVRelMult_ = ibook.book1D("PUTrackRecLVRelMult", "Relative number of PU tracks for matched LV; #PUTrks/#TrksTot", 50, 0., 1.); - mePUTrackRecLVRelSumW_ = ibook.book1D("PUTrackRecLVRelSumW", "Relative Sum of Weights of PU tracks for matched LV; PUSumW*min(Pt, 1.)/SumWTot*min(Pt, 1.)", 50, 0., 1.); - mePUTrackRecLVRelSumPt_ = ibook.book1D("PUTrackRecLVRelSumPt", "Relative Sum of Pt of PU tracks for matched LV; PUSumPt/SumPtTot", 50, 0., 1.); - mePUTrackRecLVRelSumPt2_ = ibook.book1D("PUTrackRecLVRelSumPt2", "Relative Sum of Pt2 of PU tracks for matched LV; PUSumPt2/SumPt2Tot", 50, 0., 1.); - mePUTrackRecLVRelSumPx_ = ibook.book1D("PUTrackRecLVRelSumPx", "Relative Sum of Px of PU tracks for matched LV; SumPx/SumPx", 50, 0., 1.); - mePUTrackRecLVRelSumPy_ = ibook.book1D("PUTrackRecLVRelSumPy", "Relative Sum of Py of PU tracks for matched LV; SumPy/SumPy", 50, 0., 1.); - mePUTrackRecLVRelSumPz_ = ibook.book1D("PUTrackRecLVRelSumPz", "Relative Sum of Pz of PU tracks for matched LV; SumPz/SumPz", 50, 0., 1.); + mePUTrackRelMult_ = ibook.book1D("PUTrackRelMult", "Relative multiplicity of PU tracks for matched vertices; #PUTrks/#Trks", 50, 0., 1.); + meFakeTrackRelMult_ = ibook.book1D("FakeTrackRelMult", "Relative multiplicity of fake tracks for matched vertices; #fakeTrks/#Trks", 50, 0., 1.); + mePUTrackRelSumWnt_ = ibook.book1D("PUTrackRelSumWnt", "Relative Sum of wnt of PU tracks for matched vertices; PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 1.); + mePUTrackRelSumWos_ = ibook.book1D("PUTrackRelSumWos", "Relative Sum of wos of PU tracks for matched vertices; PUSumWos/SumWos", 50, 0., 1.); + meSecTrackRelSumWos_ = ibook.book1D("SecTrackRelSumWos", "Relative Sum of wos of secondary tracks for matched vertices; SecSumWos/SumWos", 50, 0., 1.); + meFakeTrackRelSumWos_ = ibook.book1D("FakeTrackRelSumWos", "Relative Sum of wos of fake tracks for matched vertices; FakeSumWos/SumWos", 50, 0., 1.); + mePUTrackRelSumPt_ = ibook.book1D("PUTrackRelSumPt", "Relative Sum of Pt of PU tracks for matched vertices; PUSumPt/SumPt", 50, 0., 1.); + mePUTrackRelSumPt2_ = ibook.book1D("PUTrackRelSumPt2", "Relative Sum of Pt2 for PU tracks for matched vertices; PUSumPt2/SumPt2", 50, 0., 1.); + mePUTrackRelSumPx_ = ibook.book1D("PUTrackRelSumPx", "Relative Sum of Px of PU tracks for matched vertices; PUSumPx/SumPx", 50, 0., 1.); + mePUTrackRelSumPy_ = ibook.book1D("PUTrackRelSumPy", "Relative Sum of Py of PU tracks for matched vertices; PUSumPy/SumPy", 50, 0., 1.); + mePUTrackRelSumPz_ = ibook.book1D("PUTrackRelSumPz", "Relative Sum of Pz of PU tracks for matched vertices; PUSumPz/SumPz", 50, 0., 1.); + + mePUTrackRelMultvsMult_ = ibook.bookProfile("PUTrackRelMultvsMult", "Relative PU multiplicity vs Number of tracks for matched vertices; #Trks; #PUTrks/#Trks", 50, 0., 50., 0., 1.,"s"); + meFakeTrackRelMultvsMult_ = ibook.bookProfile("FakeTrackRelMultvsMult", "Relative multiplicity of fake tracks vs Number of tracks for matched vertices; #Trks; #FakeTrks/#Trks", 50, 0., 50., 0., 1.,"s"); + mePUTrackRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched vertices; SumW*min(Pt, 1.); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 40., 0., 1.,"s"); + mePUTrackRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; SumWos; PUSumWos/SumWos", 50, 0., 10000., 0., 1.,"s"); + meSecTrackRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRelSumWosvsSumWos", "Relative Sum of Wos of secondary tracks vs Sum of Wos of tracks for matched vertices; SumWos; SecSumWos/SumWos", 50, 0., 10000., 0., 1.,"s"); + meFakeTrackRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; SumWos; FakeSumWos/SumWos", 50, 0., 10000., 0., 1.,"s"); + mePUTrackRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched vertices; SumPt [GeV]; PUSumPt/SumPt", 50, 0., 50., 0., 1.,"s"); + mePUTrackRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of Pt2 of tracks for matched vertices; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 0., 50., 0., 1.,"s"); + mePUTrackRelSumPxvsSumPx_ = ibook.bookProfile("PUTrackRelSumPxvsSumPx", "Relative PU Sum of Px vs Sum of Px of tracks for matched vertices; SumPx [GeV]; PUSumPx/SumPx", 50, 0., 10, 0., 1.,"s"); + mePUTrackRelSumPyvsSumPy_ = ibook.bookProfile("PUTrackRelSumPyvsSumPy", "Relative PU Sum of Py vs Sum of Py of tracks for matched vertices; SumPy [GeV]; PUSumPy/SumPy", 50, 0., 10, 0., 1.,"s"); + mePUTrackRelSumPzvsSumPz_ = ibook.bookProfile("PUTrackRelSumPzvsSumPz", "Relative PU Sum of Pz vs Sum of Pz of tracks for matched vertices; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 50., 0., 1.,"s"); + + mePUTrackRecLVRelMult_ = ibook.book1D("PUTrackRecLVRelMult", "Relative multiplicity of PU tracks for matched LV; #PUTrks/#Trks", 50, 0., 1.); + meFakeTrackRecLVRelMult_ = ibook.book1D("FakeTrackRecLVRelMult", "Relative multiplicity of fake tracks for matched LV; #FakeTrks/#Trks", 50, 0., 1.); + mePUTrackRecLVRelSumWnt_ = ibook.book1D("PUTrackRecLVRelSumWnt", "Relative Sum of Wnt of PU tracks for matched LV; PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 1.); + mePUTrackRecLVRelSumWos_ = ibook.book1D("PUTrackRecLVRelSumWos", "Relative Sum of Wos of PU tracks for matched LV; PUSumWos/SumWos", 50, 0., 1.); + meSecTrackRecLVRelSumWos_ = ibook.book1D("SecTrackRecLVRelSumWos", "Relative Sum of wos of secondary tracks for matched LV; SecSumWos/SumWos", 50, 0., 1.); + meFakeTrackRecLVRelSumWos_ = ibook.book1D("FakeTrackRecLVRelSumWos", "Relative Sum of wos of fake tracks for matched LV; FakeSumWos/SumWos", 50, 0., 1.); + mePUTrackRecLVRelSumPt_ = ibook.book1D("PUTrackRecLVRelSumPt", "Relative Sum of Pt of PU tracks for matched LV; PUSumPt/SumPt", 50, 0., 1.); + mePUTrackRecLVRelSumPt2_ = ibook.book1D("PUTrackRecLVRelSumPt2", "Relative Sum of Pt2 of PU tracks for matched LV; PUSumPt2/SumPt2", 50, 0., 1.); + mePUTrackRecLVRelSumPx_ = ibook.book1D("PUTrackRecLVRelSumPx", "Relative Sum of Px of PU tracks for matched LV; PUSumPx/SumPx", 50, 0., 1.); + mePUTrackRecLVRelSumPy_ = ibook.book1D("PUTrackRecLVRelSumPy", "Relative Sum of Py of PU tracks for matched LV; PUSumPy/SumPy", 50, 0., 1.); + mePUTrackRecLVRelSumPz_ = ibook.book1D("PUTrackRecLVRelSumPz", "Relative Sum of Pz of PU tracks for matched LV; PUSumPz/SumPz", 50, 0., 1.); + + mePUTrackRecLVRelMultvsMult_ = ibook.bookProfile("PUTrackRecLVRelMultvsMult", "Relative PU multiplicity vs Number of tracks for matched LV; #Trks; #PUTrks/#Trks", 50, 0., 300., 0., 1.,"s"); + meFakeTrackRecLVRelMultvsMult_ = ibook.bookProfile("FakeTrackRecLVRelMultvsMult", "Relative multiplicity of fake tracks vs Number of tracks for matched LV; #Trks; #FakeTrks/#Trks", 50, 0., 300., 0., 1.,"s"); + mePUTrackRecLVRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRecLVRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched LV; SumW*min(Pt, 1.); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 100., 0., 1.,"s"); + mePUTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRecLVRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; SumWos; PUSumWos/SumWos", 50, 0., 4000000., 0., 1.,"s"); + meSecTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of secondary tracks vs Sum of Wos of tracks for matched vertices; SumWos; SecSumWos/SumWos", 50, 0., 4000000., 0., 1.,"s"); + meFakeTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; SumWos; FakeSumWos/SumWos", 50, 0., 4000000., 0., 1.,"s"); + mePUTrackRecLVRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRecLVRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched LV; SumPt [GeV]; PUSumPt/SumPt", 50, 0., 500., 0., 1.,"s"); + mePUTrackRecLVRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRecLVRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of tracks for matched LV; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 0., 2000., 0., 1.,"s"); + mePUTrackRecLVRelSumPxvsSumPx_ = ibook.bookProfile("PUTrackRecLVRelSumPxvsSumPx", "Relative PU Sum of Px vs Sum of Px of tracks for matched LV; SumPx [GeV]; PUSumPx/SumPx", 50, 0., 100, 0., 1.,"s"); + mePUTrackRecLVRelSumPyvsSumPy_ = ibook.bookProfile("PUTrackRecLVRelSumPyvsSumPy", "Relative PU Sum of Py vs Sum of Py of tracks for matched LV; SumPy [GeV]; PUSumPy/SumPy", 50, 0., 100, 0., 1.,"s"); + mePUTrackRecLVRelSumPzvsSumPz_ = ibook.bookProfile("PUTrackRecLVRelSumPzvsSumPz", "Relative PU Sum of Pz vs Sum of Pz of tracks for matched LV; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 500., 0., 1.,"s"); if (optionalPlots_) { mePUTrackMult_ = ibook.book1D("PUTrackMult", "Number of PU tracks for matched vertices; #PUTrks", 50, 0., 50.); - mePUTrackWnt_ = ibook.book1D("PUTrackWnt", "Weight of PU tracks for matched vertices; TrkW*min(Pt, 1.)", 50, 0., 1.); - mePUTrackSumW_ = ibook.book1D("PUTrackSumW", "Sum of Weights of PU tracks for matched vertices; SumW*min(Pt, 1.)", 40, 0., 40.); - mePUTrackSumPt_ = ibook.book1D("PUTrackSumPt", "Sum of Pt of PU tracks for matched vertices; SumPt [GeV]", 50, 0., 50.); - mePUTrackSumPt2_ = ibook.book1D("PUTrackSumPt2", "Sum of Pt2 for PU tracks for matched vertices; SumPt2 [GeV2]", 50, 0., 50.); - mePUTrackSumPx_ = ibook.book1D("PUTrackSumPx", "Sum of Px of PU tracks for matched vertices; SumPx [GeV]", 40, 0., 20.); - mePUTrackSumPy_ = ibook.book1D("PUTrackSumPy", "Sum of Py of PU tracks for matched vertices; SumPy [GeV]", 40, 0., 20.); - mePUTrackSumPz_ = ibook.book1D("PUTrackSumPz", "Sum of Pz of PU tracks for matched vertices; SumPz [GeV]", 50, 0., 50.); + mePUTrackWnt_ = ibook.book1D("PUTrackWnt", "Wnt of PU tracks for matched vertices; PUTrkW*min(Pt, 1.)", 50, 0., 1.); + mePUTrackSumWnt_ = ibook.book1D("PUTrackSumWnt", "Sum of wnt of PU tracks for matched vertices; PUSumW*min(Pt, 1.)", 50, 0., 40.); + mePUTrackSumWos_ = ibook.book1D("PUTrackSumWos", "Sum of wos of PU tracks for matched vertices; PUSumWos", 50, 0., 10000.); + meSecTrackSumWos_ = ibook.book1D("SecTrackSumWos", "Sum of wos of secondary tracks for matched vertices; SecSumWos", 50, 0., 10000.); + mePUTrackSumPt_ = ibook.book1D("PUTrackSumPt", "Sum of Pt of PU tracks for matched vertices; PUSumPt [GeV]", 50, 0., 50.); + mePUTrackSumPt2_ = ibook.book1D("PUTrackSumPt2", "Sum of Pt2 of PU tracks for matched vertices; PUSumPt2 [GeV2]", 50, 0., 50.); + mePUTrackSumPx_ = ibook.book1D("PUTrackSumPx", "Sum of Px of PU tracks for matched vertices; PUSumPx [GeV]", 50, 0., 10.); + mePUTrackSumPy_ = ibook.book1D("PUTrackSumPy", "Sum of Py of PU tracks for matched vertices; PUSumPy [GeV]", 50, 0., 10.); + mePUTrackSumPz_ = ibook.book1D("PUTrackSumPz", "Sum of Pz of PU tracks for matched vertices; PUSumPz [GeV]", 50, 0., 50.); mePUTrackRecLVMult_ = ibook.book1D("PUTrackRecLVMult", "Number of PU tracks for matched LV; #PUTrks", 50, 0., 100.); - mePUTrackRecLVWnt_ = ibook.book1D("PUTrackRecLVWnt", "Weight of PU tracks for matched LV; TrkW*min(Pt, 1.)", 50, 0., 1.); - mePUTrackRecLVSumW_ = ibook.book1D("PUTrackRecLVSumW", "Sum of Weights of PU tracks for matched LV; SumW*min(Pt, 1.)", 40, 0., 40.); - mePUTrackRecLVSumPt_ = ibook.book1D("PUTrackRecLVSumPt", "Sum of Pt of PU tracks for matched LV; SumPt [GeV]", 50, 0., 100.); - mePUTrackRecLVSumPt2_ = ibook.book1D("PUTrackRecLVSumPt2", "Sum of Pt2 for PU tracks for matched LV; SumPt2 [GeV2]", 50, 0., 100.); - mePUTrackRecLVSumPx_ = ibook.book1D("PUTrackRecLVSumPx", "Sum of Px of PU tracks for matched LV; SumPx [GeV]", 40, 0., 20.); - mePUTrackRecLVSumPy_ = ibook.book1D("PUTrackRecLVSumPy", "Sum of Py of PU tracks for matched LV; SumPy [GeV]", 40, 0., 20.); - mePUTrackRecLVSumPz_ = ibook.book1D("PUTrackRecLVSumPz", "Sum of Pz of PU tracks for matched LV; SumPz [GeV]", 50, 0., 50.); + mePUTrackRecLVWnt_ = ibook.book1D("PUTrackRecLVWnt", "Wnt of PU tracks for matched LV; PUTrkW*min(Pt, 1.)", 50, 0., 1.); + mePUTrackRecLVSumWnt_ = ibook.book1D("PUTrackRecLVSumWnt", "Sum of wnt of PU tracks for matched LV; PUSumW*min(Pt, 1.)", 50, 0., 40.); + mePUTrackRecLVSumWos_ = ibook.book1D("PUTrackRecLVSumWos", "Sum of wos of PU tracks for matched LV; PUSumWos", 50, 0., 10000.); + meSecTrackRecLVSumWos_ = ibook.book1D("SecTrackRecLVSumWos", "Sum of wos of secondary tracks for matched LV; SecSumWos", 50, 0., 10000); + mePUTrackRecLVSumPt_ = ibook.book1D("PUTrackRecLVSumPt", "Sum of Pt of PU tracks for matched LV; PUSumPt [GeV]", 50, 0., 100.); + mePUTrackRecLVSumPt2_ = ibook.book1D("PUTrackRecLVSumPt2", "Sum of Pt2 of PU tracks for matched LV; PUSumPt2 [GeV2]", 50, 0., 100.); + mePUTrackRecLVSumPx_ = ibook.book1D("PUTrackRecLVSumPx", "Sum of Px of PU tracks for matched LV; PUSumPx [GeV]", 50, 0., 10.); + mePUTrackRecLVSumPy_ = ibook.book1D("PUTrackRecLVSumPy", "Sum of Py of PU tracks for matched LV; PUSumPy [GeV]", 50, 0., 10.); + mePUTrackRecLVSumPz_ = ibook.book1D("PUTrackRecLVSumPz", "Sum of Pz of PU tracks for matched LV; PUSumPz [GeV]", 50, 0., 50.); } meJetsPURelMult_ = ibook.book1D("JetsPURelMult", "Relative multiplicity of PU jets for matched vertices; #PUJets/#JetsTot", 50, 0., 1.); meJetsPURelHt_ = ibook.book1D("JetsPURelHt", "Relative scalar sum of Et of PU jets for matched vertices; PUHt/HTTot", 50, 0., 1.); meJetsPURelSumPt2_ = ibook.book1D("JetsPURelSumPt2", "Relative sum of Pt2 of PU jets for matched vertices; PUSumPt2/SumPt2Tot", 50, 0., 1.); + meJetsFakeRelSumPt2_ = ibook.book1D("JetsFakeRelSumPt2", "Relative sum of Pt2 of fake jets for matched vertices; FakeSumPt2/SumPt2Tot", 50, 0., 1.); meJetsPURelMetPt_ = ibook.book1D("JetsPURelMetPt", "Relative Missing Transverse Energy of PU jets for matched vertices; PUMet/MetTot", 50, 0., 1.); meJetsPURelSumPx_ = ibook.book1D("JetsPURelSumPx", "Relative Sum of Px of PU jets for matched vertices; PUSumPx/SumPxTot", 50, 0., 1.); meJetsPURelSumPy_ = ibook.book1D("JetsPURelSumPy", "Relative Sum of Py of PU jets for matched vertices; PUSumPy/SumPyTot", 50, 0., 1.); meJetsPURelSumPz_ = ibook.book1D("JetsPURelSumPz", "Relative Sum of Pz of PU jets for matched vertices; PUSumPz/SumPzTot", 50, 0., 1.); + meJetsPURelMultvsMult_ = ibook.bookProfile("JetsPURelMultvsMult", "Relative multiplicity of PU jets vs Number of jets for matched verticess; #Jets; #PUJets/#Jets", 50, 0., 50., 0., 1.,"s"); + meJetsPURelHtvsHt_ = ibook.bookProfile("JetsPURelHtvsHt", "Relative scalar sum of Et of PU jets vs scalar sum of Et for matched vertices; Ht [GeV]; PUHt/HT", 50, 0., 100., 0., 1.,"s"); + meJetsPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsPURelSumPt2vsSumPt2", "Relative sum of Pt2 of PU jets vs sum of Pt2 for matched vertices; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 0., 100., 0., 1.,"s"); + meJetsFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsFakeRelSumPt2vsSumPt2", "Relative sum of Pt2 of fake jets vs sum of Pt2 for matched vertices; SumPt2 [GeV2]; FakeSumPt2/SumPt2", 50, 0., 100., 0., 1.,"s"); + meJetsPURelMetPtvsMetPt_ = ibook.bookProfile("JetsPURelMetPtvsMetPt", "Relative Missing Transverse Energy of PU jets vs MET for matched vertices; Met [GeV]; PUMet/Met", 50, 0., 40., 0., 1.,"s"); + meJetsPURelSumPxvsSumPx_ = ibook.bookProfile("JetsPURelSumPxvsSumPx", "Relative Sum of Px of PU jets vs Sum of Px for matched vertices; SumPx [GeV]; PUSumPx/SumPx", 50, 0., 10., 0., 1.,"s"); + meJetsPURelSumPyvsSumPy_ = ibook.bookProfile("JetsPURelSumPyvsSumPy", "Relative Sum of Py of PU jets vs Sum of Py for matched vertices; SumPy [GeV]; PUSumPy/SumPy", 50, 0., 10., 0., 1.,"s"); + meJetsPURelSumPzvsSumPz_ = ibook.bookProfile("JetsPURelSumPzvsSumPz", "Relative Sum of Pz of PU jets vs Sum of Pz for matched vertices; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 50., 0., 1.,"s"); + meJetsRecLVPURelMult_ = ibook.book1D("JetsRecLVPURelMult", "Relative multiplicity of PU jets for matched LV; #PUJets/#JetsTot", 50, 0., 1.); meJetsRecLVPURelHt_ = ibook.book1D("JetsRecLVPURelHt", "Relative scalar sum of Et of PU jets for matched LV; PUHt/HTTot", 50, 0., 1.); meJetsRecLVPURelSumPt2_ = ibook.book1D("JetsRecLVPURelSumPt2", "Relative sum of Pt2 of PU jets for matched LV; PUSumPt2/SumPt2Tot", 50, 0., 1.); + meJetsRecLVFakeRelSumPt2_ = ibook.book1D("JetsRecLVFakeRelSumPt2", "Relative sum of Pt2 of fake jets for matched LV; FakeSumPt2/SumPt2Tot", 50, 0., 1.); meJetsRecLVPURelMetPt_ = ibook.book1D("JetsRecLVPURelMetPt", "Relative Missing Transverse Energy of PU jets for matched LV; PUMet/MetTot", 50, 0., 1.); meJetsRecLVPURelSumPx_ = ibook.book1D("JetsRecLVPURelSumPx", "Relative Sum of Px of PU jets for matched LV; SumPx/SumPxTot", 50, 0., 1.); meJetsRecLVPURelSumPy_ = ibook.book1D("JetsRecLVPURelSumPy", "Relative Sum of Py of PU jets for matched LV; SumPy/SumPyTot", 50, 0., 1.); meJetsRecLVPURelSumPz_ = ibook.book1D("JetsRecLVPURelSumPz", "Relative Sum of Pz of PU jets for matched LV; SumPz/SumPzTot", 50, 0., 1.); + meJetsRecLVPURelMultvsMult_ = ibook.bookProfile("JetsRecLVPURelMultvsMult", "Relative multiplicity of PU jets vs Number of jets for matched LV; #Jets; #PUJets/#Jets", 50, 0., 200., 0., 1.,"s"); + meJetsRecLVPURelHtvsHt_ = ibook.bookProfile("JetsRecLVPURelHtvsHt", "Relative scalar sum of Et of PU jets vs scalar sum of Et for matched LV; Ht [GeV]; PUHt/HT", 50, 0., 500., 0., 1.,"s"); + meJetsRecLVPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVPURelSumPt2vsSumPt2", "Relative sum of Pt2 of PU jets vs sum of Pt2 for matched LV; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 0., 2000., 0., 1.,"s"); + meJetsRecLVFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVFakeRelSumPt2vsSumPt2", "Relative sum of Pt2 of fake jets vs sum of Pt2 for matched LV; SumPt2 [GeV2]; FakeSumPt2/SumPt2", 50, 0., 2000., 0., 1.,"s"); + meJetsRecLVPURelMetPtvsMetPt_ = ibook.bookProfile("JetsRecLVPURelMetPtvsMetPt", "Relative Missing Transverse Energy of PU jets vs MET for LV vertices; Met [GeV]; PUMet/Met", 50, 0., 200., 0., 1.,"s"); + meJetsRecLVPURelSumPxvsSumPx_ = ibook.bookProfile("JetsRecLVPURelSumPxvsSumPx", "Relative Sum of Px of PU jets vs Sum of Px for matched LV; SumPx [GeV]; PUSumPx/SumPx", 50, 0., 100., 0., 1.,"s"); + meJetsRecLVPURelSumPyvsSumPy_ = ibook.bookProfile("JetsRecLVPURelSumPyvsSumPy", "Relative Sum of Py of PU jets vs Sum of Py for matched LV; SumPy [GeV]; PUSumPy/SumPy", 50, 0., 100., 0., 1.,"s"); + meJetsRecLVPURelSumPzvsSumPz_ = ibook.bookProfile("JetsRecLVPURelSumPzvsSumPz", "Relative Sum of Pz of PU jets vs Sum of Pz for matched LV; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 400., 0., 1.,"s"); + if (optionalPlots_) { - meJetsPUMult_ = ibook.book1D("JetsPUMult", "Number of PU jets for matched vertices; #Jets", 50, 0., 50.); - meJetsPUHt_ = ibook.book1D("JetsPUHt", "Scalar sum of Et of PU jets for matched vertices; Ht [GeV]", 50, 0., 100.); - meJetsPUSumPt2_ = ibook.book1D("JetsPUSumPt2", "Sum of Pt2 of PU jets for matched vertices; SumPt2 [GeV2]", 50, 0., 100.); - meJetsPUMetPt_ = ibook.book1D("JetsPUMetPt", "Missing Transverse Energy of PU jets for matched vertices; Met [GeV]", 40, 0., 40.); - meJetsPUSumPx_ = ibook.book1D("JetsPUSumPx", "Sum of Px of PU jets for matched vertices; SumPx [GeV]", 40, 0., 20.); - meJetsPUSumPy_ = ibook.book1D("JetsPUSumPy", "Sum of Py of PU jets for matched vertices; SumPy [GeV]", 40, 0., 20.); - meJetsPUSumPz_ = ibook.book1D("JetsPUSumPz", "Sum of Pz of PU jets for matched vertices; SumPz [GeV]", 50, 0., 50.); - - meJetsRecLVPUMult_ = ibook.book1D("JetsRecLVPUMult", "Number of PU jets for matched LV; #Jets", 50, 0., 50.); - meJetsRecLVPUHt_ = ibook.book1D("JetsRecLVPUHt", "Scalar sum of Et of PU jets for matched LV; Ht [GeV]", 50, 0., 100.); - meJetsRecLVPUSumPt2_ = ibook.book1D("JetsRecLVPUSumPt2", "Sum of Pt2 of PU jets for matched LV; SumPt2 [GeV2]", 50, 0., 2000.); - meJetsRecLVPUMetPt_ = ibook.book1D("JetsRecLVPUMetPt", "Missing Transverse Energy of PU jets for matched LV; Met [GeV]", 40, 0., 40.); - meJetsRecLVPUSumPx_ = ibook.book1D("JetsRecLVPUSumPx", "Sum of Px of PU jets for matched LV; SumPx [GeV]", 40, 0., 40.); - meJetsRecLVPUSumPy_ = ibook.book1D("JetsRecLVPUSumPy", "Sum of Py of PU jets for matched LV; SumPy [GeV]", 40, 0., 40.); - meJetsRecLVPUSumPz_ = ibook.book1D("JetsRecLVPUSumPz", "Sum of Pz of PU jets for matched LV; SumPz [GeV]", 50, 0., 100.); + meJetsPUMult_ = ibook.book1D("JetsPUMult", "Number of PU jets for matched vertices; #PUJets", 50, 0., 50.); + meJetsPUHt_ = ibook.book1D("JetsPUHt", "Scalar sum of Et of PU jets for matched vertices; PUHt [GeV]", 50, 0., 100.); + meJetsPUSumPt2_ = ibook.book1D("JetsPUSumPt2", "Sum of Pt2 of PU jets for matched vertices; PUSumPt2 [GeV2]", 50, 0., 100.); + meJetsPUMetPt_ = ibook.book1D("JetsPUMetPt", "Missing Transverse Energy of PU jets for matched vertices; PUMet [GeV]", 50, 0., 40.); + meJetsPUSumPx_ = ibook.book1D("JetsPUSumPx", "Sum of Px of PU jets for matched vertices; PUSumPx [GeV]", 50, 0., 10.); + meJetsPUSumPy_ = ibook.book1D("JetsPUSumPy", "Sum of Py of PU jets for matched vertices; PUSumPy [GeV]", 50, 0., 10.); + meJetsPUSumPz_ = ibook.book1D("JetsPUSumPz", "Sum of Pz of PU jets for matched vertices; PUSumPz [GeV]", 50, 0., 50.); + + meJetsRecLVPUMult_ = ibook.book1D("JetsRecLVPUMult", "Number of PU jets for matched LV; #PUJets", 50, 0., 50.); + meJetsRecLVPUHt_ = ibook.book1D("JetsRecLVPUHt", "Scalar sum of Et of PU jets for matched LV; PUHt [GeV]", 50, 0., 100.); + meJetsRecLVPUSumPt2_ = ibook.book1D("JetsRecLVPUSumPt2", "Sum of Pt2 of PU jets for matched LV; PUSumPt2 [GeV2]", 50, 0., 2000.); + meJetsRecLVPUMetPt_ = ibook.book1D("JetsRecLVPUMetPt", "Missing Transverse Energy of PU jets for matched LV; PUMet [GeV]", 50, 0., 40.); + meJetsRecLVPUSumPx_ = ibook.book1D("JetsRecLVPUSumPx", "Sum of Px of PU jets for matched LV; PUSumPx [GeV]", 50, 0., 20.); + meJetsRecLVPUSumPy_ = ibook.book1D("JetsRecLVPUSumPy", "Sum of Py of PU jets for matched LV; PUSumPy [GeV]", 50, 0., 20.); + meJetsRecLVPUSumPz_ = ibook.book1D("JetsRecLVPUSumPz", "Sum of Pz of PU jets for matched LV; PUSumPz [GeV]", 50, 0., 100.); } // some tests @@ -911,26 +1027,30 @@ bool Primary4DVertexValidation::matchRecoTrack2SimSignal(const reco::TrackBaseRe return false; } -std::pair>*,bool> Primary4DVertexValidation::getMatchedTP( +std::pair>*,int> Primary4DVertexValidation::getMatchedTP( const reco::TrackBaseRef& recoTrack, const TrackingVertexRef& vsim) { auto found = r2s_->find(recoTrack); - // reco track not matched to any TP + // reco track not matched to any TP (fake tracks) if (found == r2s_->end()) - return std::make_pair (nullptr,false); + return std::make_pair (nullptr,-1); // matched TP equal to any TP of sim vertex for (const auto& tp : found->val) { if (std::find_if(vsim->daughterTracks_begin(), vsim->daughterTracks_end(), [&](const TrackingParticleRef& vtp) { return tp.first == vtp; }) != vsim->daughterTracks_end()) - return std::make_pair (&tp.first,true); - // matched TP not associated to sim vertex (PU track) - else return std::make_pair (&tp.first,false); + return std::make_pair (&tp.first,0); + // matched TP not associated to any daughter track of the sim vertex but having the same eventID (secondary track) + else if (tp.first->eventId().bunchCrossing() == vsim->eventId().bunchCrossing() && tp.first->eventId().event() == vsim->eventId().event()) { + return std::make_pair (&tp.first,1); + } + // matched TP not associated to the sim vertex (PU track) + else return std::make_pair (&tp.first,2); } // reco track not matched to any TP from vertex - return std::make_pair (nullptr,false); + return std::make_pair (nullptr,-1); } double Primary4DVertexValidation::timeFromTrueMass(double mass, double pathlength, double momentum, double time) { @@ -948,7 +1068,7 @@ double Primary4DVertexValidation::timeFromTrueMass(double mass, double pathlengt bool Primary4DVertexValidation::select(const reco::Vertex& v, int level) { /* level 0 !isFake && ndof>4 (default) - 1 !isFake && ndof>4 && prob > 0.01 + 1 !isFake && ndof>4 && prob > 0.01 2 !isFake && ndof>4 && prob > 0.01 && ptmax2 > 0.4 */ if (v.isFake()) @@ -965,8 +1085,8 @@ bool Primary4DVertexValidation::select(const reco::Vertex& v, int level) { } void Primary4DVertexValidation::observablesFromJets(const std::vector& reco_Tracks, const std::vector& mass_Tracks, - const std::vector& is_PUtrack, const bool& use_AllTracks, - unsigned int& n_Jets, double& sum_EtJets, double& sum_Pt2Jets, double& met_Pt, + const std::vector& category_Tracks, const std::string& skip_Tracks, + unsigned int& n_Jets, double& sum_EtJets, double& sum_Pt2Jets, double& met_Pt, double& sum_PxJets, double& sum_PyJets, double& sum_PzJets) { double sum_PtJets = 0; n_Jets = 0; @@ -987,8 +1107,12 @@ void Primary4DVertexValidation::observablesFromJets(const std::vector 0) { - sum_Pt2Jets += metAbove * metAbove; + sum_Pt2Jets += (metAbove * metAbove); } if (countScale0 == reco_Tracks.size()) { sum_Pt2Jets = countScale0 * 0.01; //leave some epsilon value to sort vertices with unknown pt @@ -1113,7 +1237,9 @@ std::vector Primary4DVertexValidati vp->ptot.setPy(vp->ptot.y() + momentum.y()); vp->ptot.setPz(vp->ptot.z() + momentum.z()); vp->ptot.setE(vp->ptot.e() + (**iTP).energy()); + vp->pt += (**iTP).pt(); vp->ptsq += ((**iTP).pt() * (**iTP).pt()); + vp->nGenTrk++; if (matched_best_reco_track) { vp->num_matched_reco_tracks++; @@ -1252,10 +1378,10 @@ void Primary4DVertexValidation::matchReco2Sim(std::vector& re if (MVA[(*iTrack)] < mvaTh_) continue; - auto tp_pair = getMatchedTP(*iTrack, simpv.at(iev).sim_vertex); - auto tp_info = tp_pair.first; - bool isMatchedTP = tp_pair.second; - if (tp_info != nullptr && isMatchedTP) { + auto tp_info = getMatchedTP(*iTrack, simpv.at(iev).sim_vertex).first; + int matchCategory = getMatchedTP(*iTrack, simpv.at(iev).sim_vertex).second; + // matched TP equal to any TP of sim vertex + if (tp_info != nullptr && matchCategory == 0) { double dz2_beam = pow((*BS).BeamWidthX() * cos((*iTrack)->phi()) / tan((*iTrack)->theta()), 2) + pow((*BS).BeamWidthY() * sin((*iTrack)->phi()) / tan((*iTrack)->theta()), 2); double dz2 = pow((*iTrack)->dzError(), 2) + dz2_beam + @@ -1493,28 +1619,34 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve for (unsigned int iev = 0; iev < simpv.size(); iev++) { auto vsim = simpv.at(iev).sim_vertex; + bool selectedVtxMatching = recopv.at(iv).sim == iev && simpv.at(iev).rec == iv; bool selectedLV = simpv.at(iev).eventId.bunchCrossing() == 0 && simpv.at(iev).eventId.event() == 0 && recopv.at(iv).OriginalIndex == 0; - bool selectedLVMatching = selectedVtxMatching && selectedLV; + bool selectedLVMatching = selectedVtxMatching && selectedLV; // bool for reco vtx leading match if (selectedLVMatching && !recopv.at(iv).is_signal()) { edm::LogWarning("Primary4DVertexValidation") << "Reco vtx leading match inconsistent: BX/ID " << simpv.at(iev).eventId.bunchCrossing() << " " << simpv.at(iev).eventId.event(); } + if (selectedLVMatching && debug_) { + printSimVtxRecoVtxInfo(simpv.at(iev), recopv.at(iv)); + } double vzsim = simpv.at(iev).z; double vtsim = simpv.at(iev).t * simUnit_; - double sumW = 0, sumPt = 0, sumPt2 = 0, sumPx = 0, sumPy = 0, sumPz = 0; - double sumWTot = 0, sumPtTot = 0, sumPt2Tot = 0, sumPxTot = 0, sumPyTot = 0, sumPzTot = 0; - unsigned int nt = 0, PUnt = 0; + double wnt = 0, wos = 0; + double PUsumWnt = 0, PUsumWos = 0, SecsumWos = 0, FakesumWos = 0, PUsumPt = 0, PUsumPt2 = 0, PUsumPx = 0, PUsumPy = 0, PUsumPz = 0; + double sumWnt = 0, sumWos = 0, sumPt = 0, sumPt2 = 0, sumPx = 0, sumPy = 0, sumPz = 0; + unsigned int nt = 0, PUnt = 0, Fakent = 0; std::vector massVector; std::vector recotracks; - std::vector isPUtrack; + std::vector categoryVector; double sumEtJets = 0, sumPt2Jets = 0, metPt = 0, sumPxJets = 0, sumPyJets = 0, sumPzJets = 0; double sumEtJetsnoPU = 0, sumPt2JetsnoPU = 0, metPtnoPU = 0, sumPxJetsnoPU = 0, sumPyJetsnoPU = 0, sumPzJetsnoPU = 0; - unsigned int nJets = 0, nJetsnoPU = 0; + double sumEtJetsnoFake = 0, sumPt2JetsnoFake = 0, metPtnoFake = 0, sumPxJetsnoFake = 0, sumPyJetsnoFake = 0, sumPzJetsnoFake = 0; + unsigned int nJets = 0, nJetsnoPU = 0, nJetsnoFake = 0; for (auto iTrack = vertex->tracks_begin(); iTrack != vertex->tracks_end(); ++iTrack) { if (trackAssoc[*iTrack] == -1) { LogTrace("mtdTracks") << "Extended track not associated"; @@ -1523,7 +1655,6 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve if (vertex->trackWeight(*iTrack) < trackweightTh_) continue; - bool noCrack = std::abs((*iTrack)->eta()) < trackMaxBtlEta_ || std::abs((*iTrack)->eta()) > trackMinEtlEta_; bool selectRecoTrk = mvaRecSel(**iTrack, *vertex, t0Safe[*iTrack], sigmat0Safe[*iTrack]); @@ -1534,11 +1665,10 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve meMVATrackEffEtaTot_->Fill(std::abs((*iTrack)->eta())); } - auto tp_pair = getMatchedTP(*iTrack, vsim); - auto tp_info = tp_pair.first; - bool isMatchedTP = tp_pair.second; + auto tp_info = getMatchedTP(*iTrack, vsim).first; + int matchCategory = getMatchedTP(*iTrack, vsim).second; - // matched TP not associated to sim vertex (PU track) + // PU, fake and secondary tracks if (selectedVtxMatching) { unsigned int no_PIDtype = 0; bool no_PID, is_Pi, is_K, is_P; @@ -1559,44 +1689,65 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve double mass = PData->mass().value(); massVector.push_back(mass); recotracks.push_back(**iTrack); + double dz2_beam = pow((*BeamSpotH).BeamWidthX() * cos((*iTrack)->phi()) / tan((*iTrack)->theta()), 2) + + pow((*BeamSpotH).BeamWidthY() * sin((*iTrack)->phi()) / tan((*iTrack)->theta()), 2); + double dz2 = pow((*iTrack)->dzError(), 2) + dz2_beam + + pow(0.0020, 2); // added 20 um, some tracks have crazy small resolutions + wnt = vertex->trackWeight(*iTrack) * std::min((*iTrack)->pt(), 1.0); + wos = vertex->trackWeight(*iTrack) / dz2; + if (sigmat0Safe[(*iTrack)] > 0) { + double sigmaZ = (*BeamSpotH).sigmaZ(); + double sigmaT = sigmaZ / c_; // c in cm/ns + wos = wos / erf(sigmat0Safe[(*iTrack)] / sigmaT); + } + // reco track matched to some TP if (tp_info != nullptr) { - if (!isMatchedTP) { - if (optionalPlots_){ - mePUTrackWnt_->Fill(vertex->trackWeight(*iTrack) * std::min((*iTrack)->pt(), 1.0)); - } - sumW += vertex->trackWeight(*iTrack) * std::min((*iTrack)->pt(), 1.0); - sumPt += (*iTrack)->pt(); - sumPt2 += (*iTrack)->pt() * (*iTrack)->pt(); - sumPx += (*iTrack)->px(); - sumPy += (*iTrack)->py(); - sumPz += (*iTrack)->pz(); - PUnt++; - isPUtrack.push_back(true); + if (debug_ && selectedLV) { + printMatchedRecoTrackInfo(*vertex, *iTrack, *tp_info, matchCategory); } - else { - isPUtrack.push_back(false); + // matched TP not associated to any daughter track of the sim vertex but having the same eventID (secondary track) + if (matchCategory == 1) { + categoryVector.push_back(matchCategory); + SecsumWos += wos; } - nt++; - sumWTot += vertex->trackWeight(*iTrack) * std::min((*iTrack)->pt(), 1.0); - sumPtTot += (*iTrack)->pt(); - sumPt2Tot += (*iTrack)->pt() * (*iTrack)->pt(); - sumPxTot += (*iTrack)->px(); - sumPyTot += (*iTrack)->py(); - sumPzTot += (*iTrack)->pz(); - } - // Primary Vertex - if (selectedLV) { - if (tp_info != nullptr && !isMatchedTP) { + // matched TP not associated to the sim vertex (PU track) + if (matchCategory == 2) { if (optionalPlots_){ - mePUTrackRecLVWnt_->Fill(vertex->trackWeight(*iTrack) * std::min((*iTrack)->pt(), 1.0)); + mePUTrackWnt_->Fill(wnt); + if (selectedLV) { + mePUTrackRecLVWnt_->Fill(wnt); + } } + PUsumWnt += wnt; + PUsumWos += wos; + PUsumPt += (*iTrack)->pt(); + PUsumPt2 += ((*iTrack)->pt() * (*iTrack)->pt()); + PUsumPx += (*iTrack)->px(); + PUsumPy += (*iTrack)->py(); + PUsumPz += (*iTrack)->pz(); + PUnt++; + categoryVector.push_back(2); } } + // reco track not matched to any TP (fake tracks) + else { + categoryVector.push_back(matchCategory); + FakesumWos += wos; + Fakent++; + } + nt++; + sumWnt += wnt; + sumWos += wos; + sumPt += (*iTrack)->pt(); + sumPt2 += ((*iTrack)->pt() * (*iTrack)->pt()); + sumPx += (*iTrack)->px(); + sumPy += (*iTrack)->py(); + sumPz += (*iTrack)->pz(); } - // matched TP equal to any TP of sim vertex - if (tp_info != nullptr && isMatchedTP) { + if (tp_info != nullptr && matchCategory == 0) { + categoryVector.push_back(matchCategory); double mass = (*tp_info)->mass(); double tsim = (*tp_info)->parentVertex()->position().t() * simUnit_; double tEst = timeFromTrueMass(mass, pathLength[*iTrack], momentum[*iTrack], time[*iTrack]); @@ -1850,35 +2001,64 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve } } } - } // if tp_info != nullptr && isMatchedTP - } // loop on tracks + } // if tp_info != nullptr && MatchCategory == 0 + } // loop on reco tracks if (selectedVtxMatching) { mePUTrackRelMult_->Fill(static_cast(PUnt)/nt); - mePUTrackRelSumW_->Fill(sumW/sumWTot); - mePUTrackRelSumPt_->Fill(sumPt/sumPtTot); - mePUTrackRelSumPt2_->Fill(sumPt2/sumPt2Tot); - mePUTrackRelSumPx_->Fill(std::abs(sumPx)/std::abs(sumPxTot)); - mePUTrackRelSumPy_->Fill(std::abs(sumPy)/std::abs(sumPyTot)); - mePUTrackRelSumPz_->Fill(std::abs(sumPz)/std::abs(sumPzTot)); - - observablesFromJets(recotracks, massVector, isPUtrack, true, nJets, sumEtJets, sumPt2Jets, metPt, sumPxJets, sumPyJets, sumPzJets); - observablesFromJets(recotracks, massVector, isPUtrack, false, nJetsnoPU, sumEtJetsnoPU, sumPt2JetsnoPU, metPtnoPU, sumPxJetsnoPU, sumPyJetsnoPU, sumPzJetsnoPU); + meFakeTrackRelMult_->Fill(static_cast(Fakent)/nt); + mePUTrackRelSumWnt_->Fill(PUsumWnt/sumWnt); + mePUTrackRelSumWos_->Fill(PUsumWos/sumWos); + meSecTrackRelSumWos_->Fill(SecsumWos/sumWos); + meFakeTrackRelSumWos_->Fill(FakesumWos/sumWos); + mePUTrackRelSumPt_->Fill(PUsumPt/sumPt); + mePUTrackRelSumPt2_->Fill(PUsumPt2/sumPt2); + mePUTrackRelSumPx_->Fill(std::abs(PUsumPx)/std::abs(sumPx)); + mePUTrackRelSumPy_->Fill(std::abs(PUsumPy)/std::abs(sumPy)); + mePUTrackRelSumPz_->Fill(std::abs(PUsumPz)/std::abs(sumPz)); + + mePUTrackRelMultvsMult_->Fill(nt, static_cast(PUnt)/nt); + meFakeTrackRelMultvsMult_->Fill(nt, static_cast(Fakent)/nt); + mePUTrackRelSumWntvsSumWnt_->Fill(sumWnt, PUsumWnt/sumWnt); + mePUTrackRelSumWosvsSumWos_->Fill(sumWos, PUsumWos/sumWos); + meSecTrackRelSumWosvsSumWos_->Fill(sumWos, SecsumWos/sumWos); + meFakeTrackRelSumWosvsSumWos_->Fill(sumWos, FakesumWos/sumWos); + mePUTrackRelSumPtvsSumPt_->Fill(sumPt, PUsumPt/sumPt); + mePUTrackRelSumPt2vsSumPt2_->Fill(sumPt2, PUsumPt2/sumPt2); + mePUTrackRelSumPxvsSumPx_->Fill(std::abs(sumPx), std::abs(PUsumPx)/std::abs(sumPx)); + mePUTrackRelSumPyvsSumPy_->Fill(std::abs(sumPy), std::abs(PUsumPy)/std::abs(sumPy)); + mePUTrackRelSumPzvsSumPz_->Fill(std::abs(sumPz), std::abs(PUsumPz)/std::abs(sumPz)); + + observablesFromJets(recotracks, massVector, categoryVector, "use_allTracks", nJets, sumEtJets, sumPt2Jets, metPt, sumPxJets, sumPyJets, sumPzJets); + observablesFromJets(recotracks, massVector, categoryVector, "skip_Fake", nJetsnoFake, sumEtJetsnoFake, sumPt2JetsnoFake, metPtnoFake, sumPxJetsnoFake, sumPyJetsnoFake, sumPzJetsnoFake); + observablesFromJets(recotracks, massVector, categoryVector, "skip_PU", nJetsnoPU, sumEtJetsnoPU, sumPt2JetsnoPU, metPtnoPU, sumPxJetsnoPU, sumPyJetsnoPU, sumPzJetsnoPU); + meJetsPURelMult_->Fill(static_cast(nJets-nJetsnoPU)/nJets); meJetsPURelHt_->Fill((sumEtJets-sumEtJetsnoPU)/sumEtJets); meJetsPURelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); + meJetsFakeRelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); meJetsPURelMetPt_->Fill((metPt-metPtnoPU)/metPt); meJetsPURelSumPx_->Fill(std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); meJetsPURelSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); meJetsPURelSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); + meJetsPURelMultvsMult_->Fill(nJets, static_cast(nJets-nJetsnoPU)/nJets); + meJetsPURelHtvsHt_->Fill(sumEtJets, (sumEtJets-sumEtJetsnoPU)/sumEtJets); + meJetsPURelSumPt2vsSumPt2_->Fill(sumPt2Jets, (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); + meJetsFakeRelSumPt2vsSumPt2_->Fill(sumPt2Jets, (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); + meJetsPURelMetPtvsMetPt_->Fill(metPt, (metPt-metPtnoPU)/metPt); + meJetsPURelSumPxvsSumPx_->Fill(std::abs(sumPxJets), std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); + meJetsPURelSumPyvsSumPy_->Fill(std::abs(sumPyJets), std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); + meJetsPURelSumPzvsSumPz_->Fill(std::abs(sumPzJets), std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); if (optionalPlots_) { mePUTrackMult_->Fill(PUnt); - mePUTrackSumW_->Fill(sumW); - mePUTrackSumPt_->Fill(sumPt); - mePUTrackSumPt2_->Fill(sumPt2); - mePUTrackSumPx_->Fill(std::abs(sumPx)); - mePUTrackSumPy_->Fill(std::abs(sumPy)); - mePUTrackSumPz_->Fill(std::abs(sumPz)); + mePUTrackSumWnt_->Fill(PUsumWnt); + mePUTrackSumWos_->Fill(PUsumWos); + meSecTrackSumWos_->Fill(SecsumWos); + mePUTrackSumPt_->Fill(PUsumPt); + mePUTrackSumPt2_->Fill(PUsumPt2); + mePUTrackSumPx_->Fill(std::abs(PUsumPx)); + mePUTrackSumPy_->Fill(std::abs(PUsumPy)); + mePUTrackSumPz_->Fill(std::abs(PUsumPz)); meJetsPUMult_->Fill(nJets-nJetsnoPU); meJetsPUHt_->Fill(sumEtJets-sumEtJetsnoPU); @@ -1888,32 +2068,68 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve meJetsPUSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)); meJetsPUSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)); } - if (selectedLV) { mePUTrackRecLVRelMult_->Fill(static_cast(PUnt)/nt); - mePUTrackRecLVRelSumW_->Fill(sumW/sumWTot); - mePUTrackRecLVRelSumPt_->Fill(sumPt/sumPtTot); - mePUTrackRecLVRelSumPt2_->Fill(sumPt2/sumPt2Tot); - mePUTrackRecLVRelSumPx_->Fill(std::abs(sumPx)/std::abs(sumPxTot)); - mePUTrackRecLVRelSumPy_->Fill(std::abs(sumPy)/std::abs(sumPyTot)); - mePUTrackRecLVRelSumPz_->Fill(std::abs(sumPz)/std::abs(sumPzTot)); + meFakeTrackRecLVRelMult_->Fill(static_cast(Fakent)/nt); + mePUTrackRecLVRelSumWnt_->Fill(PUsumWnt/sumWnt); + mePUTrackRecLVRelSumWos_->Fill(PUsumWos/sumWos); + meSecTrackRecLVRelSumWos_->Fill(SecsumWos/sumWos); + meFakeTrackRecLVRelSumWos_->Fill(FakesumWos/sumWos); + mePUTrackRecLVRelSumPt_->Fill(PUsumPt/sumPt); + mePUTrackRecLVRelSumPt2_->Fill(PUsumPt2/sumPt2); + mePUTrackRecLVRelSumPx_->Fill(std::abs(PUsumPx)/std::abs(sumPx)); + mePUTrackRecLVRelSumPy_->Fill(std::abs(PUsumPy)/std::abs(sumPy)); + mePUTrackRecLVRelSumPz_->Fill(std::abs(PUsumPz)/std::abs(sumPz)); + + mePUTrackRecLVRelMultvsMult_->Fill(nt, static_cast(PUnt)/nt); + meFakeTrackRecLVRelMultvsMult_->Fill(nt, static_cast(Fakent)/nt); + mePUTrackRecLVRelSumWntvsSumWnt_->Fill(sumWnt, PUsumWnt/sumWnt); + mePUTrackRecLVRelSumWosvsSumWos_->Fill(sumWos, PUsumWos/sumWos); + meSecTrackRecLVRelSumWosvsSumWos_->Fill(sumWos, SecsumWos/sumWos); + meFakeTrackRecLVRelSumWosvsSumWos_->Fill(sumWos, FakesumWos/sumWos); + mePUTrackRecLVRelSumPtvsSumPt_->Fill(sumPt, PUsumPt/sumPt); + mePUTrackRecLVRelSumPt2vsSumPt2_->Fill(sumPt2, PUsumPt2/sumPt2); + mePUTrackRecLVRelSumPxvsSumPx_->Fill(std::abs(sumPx), std::abs(PUsumPx)/std::abs(sumPx)); + mePUTrackRecLVRelSumPyvsSumPy_->Fill(std::abs(sumPy), std::abs(PUsumPy)/std::abs(sumPy)); + mePUTrackRecLVRelSumPzvsSumPz_->Fill(std::abs(sumPz), std::abs(PUsumPz)/std::abs(sumPz)); meJetsRecLVPURelMult_->Fill(static_cast(nJets-nJetsnoPU)/nJets); meJetsRecLVPURelHt_->Fill((sumEtJets-sumEtJetsnoPU)/sumEtJets); meJetsRecLVPURelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); + meJetsRecLVFakeRelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); meJetsRecLVPURelMetPt_->Fill((metPt-metPtnoPU)/metPt); meJetsRecLVPURelSumPx_->Fill(std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); meJetsRecLVPURelSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); meJetsRecLVPURelSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); + meJetsRecLVPURelMultvsMult_->Fill(nJets, static_cast(nJets-nJetsnoPU)/nJets); + meJetsRecLVPURelHtvsHt_->Fill(sumEtJets, (sumEtJets-sumEtJetsnoPU)/sumEtJets); + meJetsRecLVPURelSumPt2vsSumPt2_->Fill(sumPt2Jets, (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); + meJetsRecLVFakeRelSumPt2vsSumPt2_->Fill(sumPt2Jets, (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); + meJetsRecLVPURelMetPtvsMetPt_->Fill(metPt, (metPt-metPtnoPU)/metPt); + meJetsRecLVPURelSumPxvsSumPx_->Fill(std::abs(sumPxJets), std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); + meJetsRecLVPURelSumPyvsSumPy_->Fill(std::abs(sumPyJets), std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); + meJetsRecLVPURelSumPzvsSumPz_->Fill(std::abs(sumPzJets), std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); + if (debug_){ + edm::LogPrint("Primary4DVertexValidation") << "#PUTrks = " << PUnt << " #Trks = " << nt << " PURelMult = " + << std::setprecision(3) << static_cast(PUnt)/nt; + edm::LogPrint("Primary4DVertexValidation") << "PUsumWnt = " << std::setprecision(3) << PUsumWnt << " sumWnt = " + << std::setprecision(3) << sumWnt << " PURelsumWnt = " + << std::setprecision(3) << PUsumWnt/sumWnt; + edm::LogPrint("Primary4DVertexValidation") << "PuSumPt2 = " << std::setprecision(3) << PUsumPt2 << " SumPt2 = " + << std::setprecision(4) << sumPt2 << " PURelSumPt2 = " + << std::setprecision(3) << PUsumPt2/sumPt2; + } if (optionalPlots_) { mePUTrackRecLVMult_->Fill(PUnt); - mePUTrackRecLVSumW_->Fill(sumW); - mePUTrackRecLVSumPt_->Fill(sumPt); - mePUTrackRecLVSumPt2_->Fill(sumPt2); - mePUTrackRecLVSumPx_->Fill(std::abs(sumPx)); - mePUTrackRecLVSumPy_->Fill(std::abs(sumPy)); - mePUTrackRecLVSumPz_->Fill(std::abs(sumPz)); + mePUTrackRecLVSumWnt_->Fill(PUsumWnt); + mePUTrackRecLVSumWos_->Fill(PUsumWos); + meSecTrackRecLVSumWos_->Fill(PUsumWos); + mePUTrackRecLVSumPt_->Fill(PUsumPt); + mePUTrackRecLVSumPt2_->Fill(PUsumPt2); + mePUTrackRecLVSumPx_->Fill(std::abs(PUsumPx)); + mePUTrackRecLVSumPy_->Fill(std::abs(PUsumPy)); + mePUTrackRecLVSumPz_->Fill(std::abs(PUsumPz)); meJetsRecLVPUMult_->Fill(nJets-nJetsnoPU); meJetsRecLVPUHt_->Fill(sumEtJets-sumEtJetsnoPU); @@ -1925,9 +2141,9 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve } } } - } + } // loop on simpv } // ndof - } + } // loop on recopv int real = 0; int fake = 0; @@ -2138,6 +2354,52 @@ void Primary4DVertexValidation::fillDescriptions(edm::ConfigurationDescriptions& descriptions.add("vertices4DValid", desc); } +void Primary4DVertexValidation::printMatchedRecoTrackInfo(const reco::Vertex& vtx, + const reco::TrackBaseRef& trk, + const TrackingParticleRef& tp, + const unsigned int& categ) { + std::string strTrk; + if (categ == 0) strTrk = "Reco_Track:"; + if (categ == 1) strTrk = "SecRecoTrk:"; + if (categ == 2) strTrk = "PU_RecoTrk:"; + edm::LogPrint("Primary4DVertexValidation") << strTrk << " w =" << std::setw(6) << std::setprecision(2) + << vtx.trackWeight(trk) << " pt =" << std::setw(6) + << std::setprecision(2) << trk->pt() << " eta =" + << std::setw(6) << std::setprecision(2) << trk->eta() + << " MatchedTP: Pt =" << std::setw(6) << std::setprecision(2) + << tp->pt() << " eta =" << std::setw(6) << std::setprecision(2) + << tp->eta() << " Parent vtx: z =" << std::setw(8) + << std::setprecision(4) << tp->parentVertex()->position().z() + << " t =" << std::setw(8) << std::setprecision(4) + << tp->parentVertex()->position().t() * simUnit_ << " BX =" + << tp->parentVertex()->eventId().bunchCrossing() << " ev =" + << tp->parentVertex()->eventId().event() << std::endl; +} + +void Primary4DVertexValidation::printSimVtxRecoVtxInfo(const struct Primary4DVertexValidation::simPrimaryVertex& simpVtx, const struct Primary4DVertexValidation::recoPrimaryVertex& recopVtx) { + edm::LogPrint("Primary4DVertexValidation") << "Sim vtx (x,y,z,t) = (" << std::setprecision(4) << simpVtx.x << "," + << std::setprecision(4) << simpVtx.y << "," << std::setprecision(4) + << simpVtx.z << "," << std::setprecision(4) << simpVtx.t * simUnit_ << ")"; + edm::LogPrint("Primary4DVertexValidation") << "Sim vtx: pt = " << std::setprecision(4) << simpVtx.pt + << " ptsq = " << std::setprecision(6) << simpVtx.ptsq << " nGenTrk = " + << simpVtx.nGenTrk << " nmatch recotrks = " << simpVtx.num_matched_reco_tracks; + edm::LogPrint("Primary4DVertexValidation") << "Reco vtx (x,y,z) = (" << std::setprecision(4) << recopVtx.x << "," + << std::setprecision(4) << recopVtx.y << "," << std::setprecision(4) + << recopVtx.z << ")"; + edm::LogPrint("Primary4DVertexValidation") << "Reco vtx: pt = " << std::setprecision(4) << recopVtx.pt + << " ptsq = " << std::setprecision(6) << recopVtx.ptsq << " nrecotrks = " + << recopVtx.nRecoTrk << " nmatch simtrks = " << recopVtx.num_matched_sim_tracks; + edm::LogPrint("Primary4DVertexValidation") << "wnt " << recopVtx.sumwnt << " wos = " << recopVtx.sumwos; + for (auto iTP = simpVtx.sim_vertex->daughterTracks_begin(); iTP != simpVtx.sim_vertex->daughterTracks_end(); ++iTP) { + if (use_only_charged_tracks_ && (**iTP).charge() == 0) { + continue; + } + edm::LogPrint("Primary4DVertexValidation") << "Daughter track of sim vertex: pt =" << std::setw(6) + << std::setprecision(2) << (*iTP)->pt() << " eta =" + << std::setw(6) << std::setprecision(2) << (*iTP)->eta(); + } +} + const bool Primary4DVertexValidation::mvaTPSel(const TrackingParticle& tp) { bool match = false; if (tp.status() != 1) { From a81d0565d031f7b48a59087ba921888b687c3198 Mon Sep 17 00:00:00 2001 From: Raffaele Delli Gatti Date: Wed, 6 Mar 2024 13:59:25 +0100 Subject: [PATCH 4/7] Separate function for wnt and wos, use3dNotime tracked and optional plots for Primary4DVertexValidation.cc, removed EDM_ML_DEBUG from MtdTracksValidation.cc --- .../plugins/MtdTracksValidation.cc | 1 - .../plugins/Primary4DVertexValidation.cc | 402 +++++++++--------- 2 files changed, 197 insertions(+), 206 deletions(-) diff --git a/Validation/MtdValidation/plugins/MtdTracksValidation.cc b/Validation/MtdValidation/plugins/MtdTracksValidation.cc index 1cec67199edbf..7458303eb872a 100644 --- a/Validation/MtdValidation/plugins/MtdTracksValidation.cc +++ b/Validation/MtdValidation/plugins/MtdTracksValidation.cc @@ -1,4 +1,3 @@ -#define EDM_ML_DEBUG #include #include "FWCore/Framework/interface/Frameworkfwd.h" diff --git a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc index 1688a57f803d7..afd1b8b01da56 100644 --- a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc +++ b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc @@ -215,19 +215,16 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { std::pair>*,int> getMatchedTP(const reco::TrackBaseRef&, const TrackingVertexRef&); double timeFromTrueMass(double, double, double, double); bool select(const reco::Vertex&, int level = 0); - void observablesFromJets(const std::vector&, const std::vector&, - const std::vector&, const std::string&, - unsigned int&, double&, double&, double&, - double&, double&, double&); - void isParticle(const reco::TrackBaseRef&, const double&, - const edm::ValueMap&, const edm::ValueMap&, - const edm::ValueMap&, unsigned int&, bool&, - bool&, bool&, bool&); - void printMatchedRecoTrackInfo(const reco::Vertex&, const reco::TrackBaseRef&, const TrackingParticleRef&, const unsigned int&); - void printSimVtxRecoVtxInfo(const struct Primary4DVertexValidation::simPrimaryVertex&, const struct Primary4DVertexValidation::recoPrimaryVertex&); + void observablesFromJets(const std::vector&, const std::vector&, const std::vector&, + const std::string&, unsigned int&, double&, double&, double&, double&, double&, double&); + void isParticle(const reco::TrackBaseRef&, const edm::ValueMap&, const edm::ValueMap&, + const edm::ValueMap&, unsigned int&, bool&, bool&, bool&, bool&); + void getWosWnt(const reco::Vertex&, const reco::TrackBaseRef&, const edm::ValueMap&, const edm::Handle&, double&, double&); std::vector getSimPVs(const edm::Handle&); std::vector getRecoPVs(const edm::Handle>&); + void printMatchedRecoTrackInfo(const reco::Vertex&, const reco::TrackBaseRef&, const TrackingParticleRef&, const unsigned int&); + void printSimVtxRecoVtxInfo(const struct Primary4DVertexValidation::simPrimaryVertex&, const struct Primary4DVertexValidation::recoPrimaryVertex&); const bool mvaTPSel(const TrackingParticle&); const bool mvaRecSel(const reco::TrackBase&, const reco::Vertex&, const double&, const double&); @@ -515,7 +512,7 @@ Primary4DVertexValidation::Primary4DVertexValidation(const edm::ParameterSet& iC use_only_charged_tracks_(iConfig.getParameter("useOnlyChargedTracks")), debug_(iConfig.getUntrackedParameter("debug")), optionalPlots_(iConfig.getUntrackedParameter("optionalPlots")), - use3dNoTime_(iConfig.getUntrackedParameter("use3dNoTime")), + use3dNoTime_(iConfig.getParameter("use3dNoTime")), minProbHeavy_(iConfig.getParameter("minProbHeavy")), trackweightTh_(iConfig.getParameter("trackweightTh")), mvaTh_(iConfig.getParameter("mvaTh")), @@ -695,18 +692,6 @@ void Primary4DVertexValidation::bookHistograms(DQMStore::IBooker& ibook, mePUTrackRelSumPy_ = ibook.book1D("PUTrackRelSumPy", "Relative Sum of Py of PU tracks for matched vertices; PUSumPy/SumPy", 50, 0., 1.); mePUTrackRelSumPz_ = ibook.book1D("PUTrackRelSumPz", "Relative Sum of Pz of PU tracks for matched vertices; PUSumPz/SumPz", 50, 0., 1.); - mePUTrackRelMultvsMult_ = ibook.bookProfile("PUTrackRelMultvsMult", "Relative PU multiplicity vs Number of tracks for matched vertices; #Trks; #PUTrks/#Trks", 50, 0., 50., 0., 1.,"s"); - meFakeTrackRelMultvsMult_ = ibook.bookProfile("FakeTrackRelMultvsMult", "Relative multiplicity of fake tracks vs Number of tracks for matched vertices; #Trks; #FakeTrks/#Trks", 50, 0., 50., 0., 1.,"s"); - mePUTrackRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched vertices; SumW*min(Pt, 1.); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 40., 0., 1.,"s"); - mePUTrackRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; SumWos; PUSumWos/SumWos", 50, 0., 10000., 0., 1.,"s"); - meSecTrackRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRelSumWosvsSumWos", "Relative Sum of Wos of secondary tracks vs Sum of Wos of tracks for matched vertices; SumWos; SecSumWos/SumWos", 50, 0., 10000., 0., 1.,"s"); - meFakeTrackRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; SumWos; FakeSumWos/SumWos", 50, 0., 10000., 0., 1.,"s"); - mePUTrackRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched vertices; SumPt [GeV]; PUSumPt/SumPt", 50, 0., 50., 0., 1.,"s"); - mePUTrackRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of Pt2 of tracks for matched vertices; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 0., 50., 0., 1.,"s"); - mePUTrackRelSumPxvsSumPx_ = ibook.bookProfile("PUTrackRelSumPxvsSumPx", "Relative PU Sum of Px vs Sum of Px of tracks for matched vertices; SumPx [GeV]; PUSumPx/SumPx", 50, 0., 10, 0., 1.,"s"); - mePUTrackRelSumPyvsSumPy_ = ibook.bookProfile("PUTrackRelSumPyvsSumPy", "Relative PU Sum of Py vs Sum of Py of tracks for matched vertices; SumPy [GeV]; PUSumPy/SumPy", 50, 0., 10, 0., 1.,"s"); - mePUTrackRelSumPzvsSumPz_ = ibook.bookProfile("PUTrackRelSumPzvsSumPz", "Relative PU Sum of Pz vs Sum of Pz of tracks for matched vertices; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 50., 0., 1.,"s"); - mePUTrackRecLVRelMult_ = ibook.book1D("PUTrackRecLVRelMult", "Relative multiplicity of PU tracks for matched LV; #PUTrks/#Trks", 50, 0., 1.); meFakeTrackRecLVRelMult_ = ibook.book1D("FakeTrackRecLVRelMult", "Relative multiplicity of fake tracks for matched LV; #FakeTrks/#Trks", 50, 0., 1.); mePUTrackRecLVRelSumWnt_ = ibook.book1D("PUTrackRecLVRelSumWnt", "Relative Sum of Wnt of PU tracks for matched LV; PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 1.); @@ -719,94 +704,106 @@ void Primary4DVertexValidation::bookHistograms(DQMStore::IBooker& ibook, mePUTrackRecLVRelSumPy_ = ibook.book1D("PUTrackRecLVRelSumPy", "Relative Sum of Py of PU tracks for matched LV; PUSumPy/SumPy", 50, 0., 1.); mePUTrackRecLVRelSumPz_ = ibook.book1D("PUTrackRecLVRelSumPz", "Relative Sum of Pz of PU tracks for matched LV; PUSumPz/SumPz", 50, 0., 1.); - mePUTrackRecLVRelMultvsMult_ = ibook.bookProfile("PUTrackRecLVRelMultvsMult", "Relative PU multiplicity vs Number of tracks for matched LV; #Trks; #PUTrks/#Trks", 50, 0., 300., 0., 1.,"s"); - meFakeTrackRecLVRelMultvsMult_ = ibook.bookProfile("FakeTrackRecLVRelMultvsMult", "Relative multiplicity of fake tracks vs Number of tracks for matched LV; #Trks; #FakeTrks/#Trks", 50, 0., 300., 0., 1.,"s"); - mePUTrackRecLVRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRecLVRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched LV; SumW*min(Pt, 1.); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 100., 0., 1.,"s"); - mePUTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRecLVRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; SumWos; PUSumWos/SumWos", 50, 0., 4000000., 0., 1.,"s"); - meSecTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of secondary tracks vs Sum of Wos of tracks for matched vertices; SumWos; SecSumWos/SumWos", 50, 0., 4000000., 0., 1.,"s"); - meFakeTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; SumWos; FakeSumWos/SumWos", 50, 0., 4000000., 0., 1.,"s"); - mePUTrackRecLVRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRecLVRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched LV; SumPt [GeV]; PUSumPt/SumPt", 50, 0., 500., 0., 1.,"s"); - mePUTrackRecLVRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRecLVRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of tracks for matched LV; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 0., 2000., 0., 1.,"s"); - mePUTrackRecLVRelSumPxvsSumPx_ = ibook.bookProfile("PUTrackRecLVRelSumPxvsSumPx", "Relative PU Sum of Px vs Sum of Px of tracks for matched LV; SumPx [GeV]; PUSumPx/SumPx", 50, 0., 100, 0., 1.,"s"); - mePUTrackRecLVRelSumPyvsSumPy_ = ibook.bookProfile("PUTrackRecLVRelSumPyvsSumPy", "Relative PU Sum of Py vs Sum of Py of tracks for matched LV; SumPy [GeV]; PUSumPy/SumPy", 50, 0., 100, 0., 1.,"s"); - mePUTrackRecLVRelSumPzvsSumPz_ = ibook.bookProfile("PUTrackRecLVRelSumPzvsSumPz", "Relative PU Sum of Pz vs Sum of Pz of tracks for matched LV; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 500., 0., 1.,"s"); - if (optionalPlots_) { - mePUTrackMult_ = ibook.book1D("PUTrackMult", "Number of PU tracks for matched vertices; #PUTrks", 50, 0., 50.); + mePUTrackMult_ = ibook.book1D("PUTrackMult", "Number of PU tracks for matched vertices; #PUTrks", 50, 0., 100.); mePUTrackWnt_ = ibook.book1D("PUTrackWnt", "Wnt of PU tracks for matched vertices; PUTrkW*min(Pt, 1.)", 50, 0., 1.); - mePUTrackSumWnt_ = ibook.book1D("PUTrackSumWnt", "Sum of wnt of PU tracks for matched vertices; PUSumW*min(Pt, 1.)", 50, 0., 40.); - mePUTrackSumWos_ = ibook.book1D("PUTrackSumWos", "Sum of wos of PU tracks for matched vertices; PUSumWos", 50, 0., 10000.); - meSecTrackSumWos_ = ibook.book1D("SecTrackSumWos", "Sum of wos of secondary tracks for matched vertices; SecSumWos", 50, 0., 10000.); - mePUTrackSumPt_ = ibook.book1D("PUTrackSumPt", "Sum of Pt of PU tracks for matched vertices; PUSumPt [GeV]", 50, 0., 50.); - mePUTrackSumPt2_ = ibook.book1D("PUTrackSumPt2", "Sum of Pt2 of PU tracks for matched vertices; PUSumPt2 [GeV2]", 50, 0., 50.); - mePUTrackSumPx_ = ibook.book1D("PUTrackSumPx", "Sum of Px of PU tracks for matched vertices; PUSumPx [GeV]", 50, 0., 10.); - mePUTrackSumPy_ = ibook.book1D("PUTrackSumPy", "Sum of Py of PU tracks for matched vertices; PUSumPy [GeV]", 50, 0., 10.); - mePUTrackSumPz_ = ibook.book1D("PUTrackSumPz", "Sum of Pz of PU tracks for matched vertices; PUSumPz [GeV]", 50, 0., 50.); + mePUTrackSumWnt_ = ibook.book1D("PUTrackSumWnt", "Sum of wnt of PU tracks for matched vertices; PUSumW*min(Pt, 1.)", 50, -2., 3.); + mePUTrackSumWos_ = ibook.book1D("PUTrackSumWos", "Sum of wos of PU tracks for matched vertices; PUSumWos", 50, -1., 7.); + meSecTrackSumWos_ = ibook.book1D("SecTrackSumWos", "Sum of wos of secondary tracks for matched vertices; SecSumWos", 50, -1., 7.); + mePUTrackSumPt_ = ibook.book1D("PUTrackSumPt", "Sum of Pt of PU tracks for matched vertices; PUSumPt [GeV]", 50, -2., 3.); + mePUTrackSumPt2_ = ibook.book1D("PUTrackSumPt2", "Sum of Pt2 of PU tracks for matched vertices; PUSumPt2 [GeV2]", 50, -3., 3.); + mePUTrackSumPx_ = ibook.book1D("PUTrackSumPx", "Sum of Px of PU tracks for matched vertices; PUSumPx [GeV]", 50, -5., 2.); + mePUTrackSumPy_ = ibook.book1D("PUTrackSumPy", "Sum of Py of PU tracks for matched vertices; PUSumPy [GeV]", 50, -5., 2.); + mePUTrackSumPz_ = ibook.book1D("PUTrackSumPz", "Sum of Pz of PU tracks for matched vertices; PUSumPz [GeV]", 50, -4., 3.); + + mePUTrackRelMultvsMult_ = ibook.bookProfile("PUTrackRelMultvsMult", "Relative PU multiplicity vs Number of tracks for matched vertices; #Trks; #PUTrks/#Trks", 50, 0., 200., 0., 1.,"s"); + meFakeTrackRelMultvsMult_ = ibook.bookProfile("FakeTrackRelMultvsMult", "Relative multiplicity of fake tracks vs Number of tracks for matched vertices; #Trks; #FakeTrks/#Trks", 50, 0., 200., 0., 1.,"s"); + mePUTrackRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched vertices; SumW*min(Pt, 1.); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 3., 0., 1.,"s"); + mePUTrackRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; SumWos; PUSumWos/SumWos", 50, 2.5, 7.5, 0., 1.,"s"); + meSecTrackRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRelSumWosvsSumWos", "Relative Sum of Wos of secondary tracks vs Sum of Wos of tracks for matched vertices; SumWos; SecSumWos/SumWos", 50, 2.5, 7.5, 0., 1.,"s"); + meFakeTrackRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; SumWos; FakeSumWos/SumWos", 50, 2.5, 7.5, 0., 1.,"s"); + mePUTrackRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched vertices; SumPt [GeV]; PUSumPt/SumPt", 50, 0., 3., 0., 1.,"s"); + mePUTrackRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of Pt2 of tracks for matched vertices; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, -1., 4., 0., 1.,"s"); + mePUTrackRelSumPxvsSumPx_ = ibook.bookProfile("PUTrackRelSumPxvsSumPx", "Relative PU Sum of Px vs Sum of Px of tracks for matched vertices; SumPx [GeV]; PUSumPx/SumPx", 50, -3., 2, 0., 1.,"s"); + mePUTrackRelSumPyvsSumPy_ = ibook.bookProfile("PUTrackRelSumPyvsSumPy", "Relative PU Sum of Py vs Sum of Py of tracks for matched vertices; SumPy [GeV]; PUSumPy/SumPy", 50, -3., 2., 0., 1.,"s"); + mePUTrackRelSumPzvsSumPz_ = ibook.bookProfile("PUTrackRelSumPzvsSumPz", "Relative PU Sum of Pz vs Sum of Pz of tracks for matched vertices; SumPz [GeV]; PUSumPz/SumPz", 50, -2., 3., 0., 1.,"s"); mePUTrackRecLVMult_ = ibook.book1D("PUTrackRecLVMult", "Number of PU tracks for matched LV; #PUTrks", 50, 0., 100.); mePUTrackRecLVWnt_ = ibook.book1D("PUTrackRecLVWnt", "Wnt of PU tracks for matched LV; PUTrkW*min(Pt, 1.)", 50, 0., 1.); - mePUTrackRecLVSumWnt_ = ibook.book1D("PUTrackRecLVSumWnt", "Sum of wnt of PU tracks for matched LV; PUSumW*min(Pt, 1.)", 50, 0., 40.); - mePUTrackRecLVSumWos_ = ibook.book1D("PUTrackRecLVSumWos", "Sum of wos of PU tracks for matched LV; PUSumWos", 50, 0., 10000.); - meSecTrackRecLVSumWos_ = ibook.book1D("SecTrackRecLVSumWos", "Sum of wos of secondary tracks for matched LV; SecSumWos", 50, 0., 10000); - mePUTrackRecLVSumPt_ = ibook.book1D("PUTrackRecLVSumPt", "Sum of Pt of PU tracks for matched LV; PUSumPt [GeV]", 50, 0., 100.); - mePUTrackRecLVSumPt2_ = ibook.book1D("PUTrackRecLVSumPt2", "Sum of Pt2 of PU tracks for matched LV; PUSumPt2 [GeV2]", 50, 0., 100.); - mePUTrackRecLVSumPx_ = ibook.book1D("PUTrackRecLVSumPx", "Sum of Px of PU tracks for matched LV; PUSumPx [GeV]", 50, 0., 10.); - mePUTrackRecLVSumPy_ = ibook.book1D("PUTrackRecLVSumPy", "Sum of Py of PU tracks for matched LV; PUSumPy [GeV]", 50, 0., 10.); - mePUTrackRecLVSumPz_ = ibook.book1D("PUTrackRecLVSumPz", "Sum of Pz of PU tracks for matched LV; PUSumPz [GeV]", 50, 0., 50.); + mePUTrackRecLVSumWnt_ = ibook.book1D("PUTrackRecLVSumWnt", "Sum of wnt of PU tracks for matched LV; PUSumW*min(Pt, 1.)", 50, -2., 3.); + mePUTrackRecLVSumWos_ = ibook.book1D("PUTrackRecLVSumWos", "Sum of wos of PU tracks for matched LV; PUSumWos", 50, -1., 7.); + meSecTrackRecLVSumWos_ = ibook.book1D("SecTrackRecLVSumWos", "Sum of wos of secondary tracks for matched LV; SecSumWos", 50, -1., 7.); + mePUTrackRecLVSumPt_ = ibook.book1D("PUTrackRecLVSumPt", "Sum of Pt of PU tracks for matched LV; PUSumPt [GeV]", 50, -2., 3.); + mePUTrackRecLVSumPt2_ = ibook.book1D("PUTrackRecLVSumPt2", "Sum of Pt2 of PU tracks for matched LV; PUSumPt2 [GeV2]", 50, -3., 3.); + mePUTrackRecLVSumPx_ = ibook.book1D("PUTrackRecLVSumPx", "Sum of Px of PU tracks for matched LV; PUSumPx [GeV]", 50, -5., 2.); + mePUTrackRecLVSumPy_ = ibook.book1D("PUTrackRecLVSumPy", "Sum of Py of PU tracks for matched LV; PUSumPy [GeV]", 50, -5., 2.); + mePUTrackRecLVSumPz_ = ibook.book1D("PUTrackRecLVSumPz", "Sum of Pz of PU tracks for matched LV; PUSumPz [GeV]", 50, -4., 3.); + + mePUTrackRecLVRelMultvsMult_ = ibook.bookProfile("PUTrackRecLVRelMultvsMult", "Relative PU multiplicity vs Number of tracks for matched LV; #Trks; #PUTrks/#Trks", 50, 0., 200., 0., 1.,"s"); + meFakeTrackRecLVRelMultvsMult_ = ibook.bookProfile("FakeTrackRecLVRelMultvsMult", "Relative multiplicity of fake tracks vs Number of tracks for matched LV; #Trks; #FakeTrks/#Trks", 50, 0., 200., 0., 1.,"s"); + mePUTrackRecLVRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRecLVRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched LV; SumW*min(Pt, 1.); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 1., 3., 0., 1.,"s"); + mePUTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRecLVRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; SumWos; PUSumWos/SumWos", 50, 4.5, 7.5, 0., 1.,"s"); + meSecTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of secondary tracks vs Sum of Wos of tracks for matched vertices; SumWos; SecSumWos/SumWos", 50, 4.5, 7.5, 0., 1.,"s"); + meFakeTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; SumWos; FakeSumWos/SumWos", 50, 4.5, 7.5, 0., 1.,"s"); + mePUTrackRecLVRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRecLVRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched LV; SumPt [GeV]; PUSumPt/SumPt", 50, 1., 3., 0., 1.,"s"); + mePUTrackRecLVRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRecLVRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of tracks for matched LV; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 2., 4., 0., 1.,"s"); + mePUTrackRecLVRelSumPxvsSumPx_ = ibook.bookProfile("PUTrackRecLVRelSumPxvsSumPx", "Relative PU Sum of Px vs Sum of Px of tracks for matched LV; SumPx [GeV]; PUSumPx/SumPx", 50, -1., 2., 0., 1.,"s"); + mePUTrackRecLVRelSumPyvsSumPy_ = ibook.bookProfile("PUTrackRecLVRelSumPyvsSumPy", "Relative PU Sum of Py vs Sum of Py of tracks for matched LV; SumPy [GeV]; PUSumPy/SumPy", 50, -1., 2, 0., 1.,"s"); + mePUTrackRecLVRelSumPzvsSumPz_ = ibook.bookProfile("PUTrackRecLVRelSumPzvsSumPz", "Relative PU Sum of Pz vs Sum of Pz of tracks for matched LV; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 3., 0., 1.,"s"); } - meJetsPURelMult_ = ibook.book1D("JetsPURelMult", "Relative multiplicity of PU jets for matched vertices; #PUJets/#JetsTot", 50, 0., 1.); - meJetsPURelHt_ = ibook.book1D("JetsPURelHt", "Relative scalar sum of Et of PU jets for matched vertices; PUHt/HTTot", 50, 0., 1.); - meJetsPURelSumPt2_ = ibook.book1D("JetsPURelSumPt2", "Relative sum of Pt2 of PU jets for matched vertices; PUSumPt2/SumPt2Tot", 50, 0., 1.); - meJetsFakeRelSumPt2_ = ibook.book1D("JetsFakeRelSumPt2", "Relative sum of Pt2 of fake jets for matched vertices; FakeSumPt2/SumPt2Tot", 50, 0., 1.); - meJetsPURelMetPt_ = ibook.book1D("JetsPURelMetPt", "Relative Missing Transverse Energy of PU jets for matched vertices; PUMet/MetTot", 50, 0., 1.); - meJetsPURelSumPx_ = ibook.book1D("JetsPURelSumPx", "Relative Sum of Px of PU jets for matched vertices; PUSumPx/SumPxTot", 50, 0., 1.); - meJetsPURelSumPy_ = ibook.book1D("JetsPURelSumPy", "Relative Sum of Py of PU jets for matched vertices; PUSumPy/SumPyTot", 50, 0., 1.); - meJetsPURelSumPz_ = ibook.book1D("JetsPURelSumPz", "Relative Sum of Pz of PU jets for matched vertices; PUSumPz/SumPzTot", 50, 0., 1.); - - meJetsPURelMultvsMult_ = ibook.bookProfile("JetsPURelMultvsMult", "Relative multiplicity of PU jets vs Number of jets for matched verticess; #Jets; #PUJets/#Jets", 50, 0., 50., 0., 1.,"s"); - meJetsPURelHtvsHt_ = ibook.bookProfile("JetsPURelHtvsHt", "Relative scalar sum of Et of PU jets vs scalar sum of Et for matched vertices; Ht [GeV]; PUHt/HT", 50, 0., 100., 0., 1.,"s"); - meJetsPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsPURelSumPt2vsSumPt2", "Relative sum of Pt2 of PU jets vs sum of Pt2 for matched vertices; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 0., 100., 0., 1.,"s"); - meJetsFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsFakeRelSumPt2vsSumPt2", "Relative sum of Pt2 of fake jets vs sum of Pt2 for matched vertices; SumPt2 [GeV2]; FakeSumPt2/SumPt2", 50, 0., 100., 0., 1.,"s"); - meJetsPURelMetPtvsMetPt_ = ibook.bookProfile("JetsPURelMetPtvsMetPt", "Relative Missing Transverse Energy of PU jets vs MET for matched vertices; Met [GeV]; PUMet/Met", 50, 0., 40., 0., 1.,"s"); - meJetsPURelSumPxvsSumPx_ = ibook.bookProfile("JetsPURelSumPxvsSumPx", "Relative Sum of Px of PU jets vs Sum of Px for matched vertices; SumPx [GeV]; PUSumPx/SumPx", 50, 0., 10., 0., 1.,"s"); - meJetsPURelSumPyvsSumPy_ = ibook.bookProfile("JetsPURelSumPyvsSumPy", "Relative Sum of Py of PU jets vs Sum of Py for matched vertices; SumPy [GeV]; PUSumPy/SumPy", 50, 0., 10., 0., 1.,"s"); - meJetsPURelSumPzvsSumPz_ = ibook.bookProfile("JetsPURelSumPzvsSumPz", "Relative Sum of Pz of PU jets vs Sum of Pz for matched vertices; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 50., 0., 1.,"s"); - - meJetsRecLVPURelMult_ = ibook.book1D("JetsRecLVPURelMult", "Relative multiplicity of PU jets for matched LV; #PUJets/#JetsTot", 50, 0., 1.); - meJetsRecLVPURelHt_ = ibook.book1D("JetsRecLVPURelHt", "Relative scalar sum of Et of PU jets for matched LV; PUHt/HTTot", 50, 0., 1.); - meJetsRecLVPURelSumPt2_ = ibook.book1D("JetsRecLVPURelSumPt2", "Relative sum of Pt2 of PU jets for matched LV; PUSumPt2/SumPt2Tot", 50, 0., 1.); - meJetsRecLVFakeRelSumPt2_ = ibook.book1D("JetsRecLVFakeRelSumPt2", "Relative sum of Pt2 of fake jets for matched LV; FakeSumPt2/SumPt2Tot", 50, 0., 1.); - meJetsRecLVPURelMetPt_ = ibook.book1D("JetsRecLVPURelMetPt", "Relative Missing Transverse Energy of PU jets for matched LV; PUMet/MetTot", 50, 0., 1.); - meJetsRecLVPURelSumPx_ = ibook.book1D("JetsRecLVPURelSumPx", "Relative Sum of Px of PU jets for matched LV; SumPx/SumPxTot", 50, 0., 1.); - meJetsRecLVPURelSumPy_ = ibook.book1D("JetsRecLVPURelSumPy", "Relative Sum of Py of PU jets for matched LV; SumPy/SumPyTot", 50, 0., 1.); - meJetsRecLVPURelSumPz_ = ibook.book1D("JetsRecLVPURelSumPz", "Relative Sum of Pz of PU jets for matched LV; SumPz/SumPzTot", 50, 0., 1.); - - meJetsRecLVPURelMultvsMult_ = ibook.bookProfile("JetsRecLVPURelMultvsMult", "Relative multiplicity of PU jets vs Number of jets for matched LV; #Jets; #PUJets/#Jets", 50, 0., 200., 0., 1.,"s"); - meJetsRecLVPURelHtvsHt_ = ibook.bookProfile("JetsRecLVPURelHtvsHt", "Relative scalar sum of Et of PU jets vs scalar sum of Et for matched LV; Ht [GeV]; PUHt/HT", 50, 0., 500., 0., 1.,"s"); - meJetsRecLVPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVPURelSumPt2vsSumPt2", "Relative sum of Pt2 of PU jets vs sum of Pt2 for matched LV; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 0., 2000., 0., 1.,"s"); - meJetsRecLVFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVFakeRelSumPt2vsSumPt2", "Relative sum of Pt2 of fake jets vs sum of Pt2 for matched LV; SumPt2 [GeV2]; FakeSumPt2/SumPt2", 50, 0., 2000., 0., 1.,"s"); - meJetsRecLVPURelMetPtvsMetPt_ = ibook.bookProfile("JetsRecLVPURelMetPtvsMetPt", "Relative Missing Transverse Energy of PU jets vs MET for LV vertices; Met [GeV]; PUMet/Met", 50, 0., 200., 0., 1.,"s"); - meJetsRecLVPURelSumPxvsSumPx_ = ibook.bookProfile("JetsRecLVPURelSumPxvsSumPx", "Relative Sum of Px of PU jets vs Sum of Px for matched LV; SumPx [GeV]; PUSumPx/SumPx", 50, 0., 100., 0., 1.,"s"); - meJetsRecLVPURelSumPyvsSumPy_ = ibook.bookProfile("JetsRecLVPURelSumPyvsSumPy", "Relative Sum of Py of PU jets vs Sum of Py for matched LV; SumPy [GeV]; PUSumPy/SumPy", 50, 0., 100., 0., 1.,"s"); - meJetsRecLVPURelSumPzvsSumPz_ = ibook.bookProfile("JetsRecLVPURelSumPzvsSumPz", "Relative Sum of Pz of PU jets vs Sum of Pz for matched LV; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 400., 0., 1.,"s"); + meJetsPURelMult_ = ibook.book1D("JetsPURelMult", "Relative multiplicity of PU jets for matched vertices; #PUJets/#Jets", 50, 0., 1.); + meJetsPURelHt_ = ibook.book1D("JetsPURelHt", "Relative scalar sum of Et of PU jets for matched vertices; PUHt/HT", 50, 0., 1.); + meJetsPURelSumPt2_ = ibook.book1D("JetsPURelSumPt2", "Relative sum of Pt2 of PU jets for matched vertices; PUSumPt2/SumPt2", 50, 0., 1.); + meJetsFakeRelSumPt2_ = ibook.book1D("JetsFakeRelSumPt2", "Relative sum of Pt2 of fake jets for matched vertices; FakeSumPt2/SumPt2", 50, 0., 1.); + meJetsPURelMetPt_ = ibook.book1D("JetsPURelMetPt", "Relative Missing Transverse Energy of PU jets for matched vertices; PUMet/Met", 50, 0., 1.); + meJetsPURelSumPx_ = ibook.book1D("JetsPURelSumPx", "Relative Sum of Px of PU jets for matched vertices; PUSumPx/SumPx", 50, 0., 1.); + meJetsPURelSumPy_ = ibook.book1D("JetsPURelSumPy", "Relative Sum of Py of PU jets for matched vertices; PUSumPy/SumPy", 50, 0., 1.); + meJetsPURelSumPz_ = ibook.book1D("JetsPURelSumPz", "Relative Sum of Pz of PU jets for matched vertices; PUSumPz/SumPz", 50, 0., 1.); + + meJetsRecLVPURelMult_ = ibook.book1D("JetsRecLVPURelMult", "Relative multiplicity of PU jets for matched LV; #PUJets/#Jets", 50, 0., 1.); + meJetsRecLVPURelHt_ = ibook.book1D("JetsRecLVPURelHt", "Relative scalar sum of Et of PU jets for matched LV; PUHt/HT", 50, 0., 1.); + meJetsRecLVPURelSumPt2_ = ibook.book1D("JetsRecLVPURelSumPt2", "Relative sum of Pt2 of PU jets for matched LV; PUSumPt2/SumPt2", 50, 0., 1.); + meJetsRecLVFakeRelSumPt2_ = ibook.book1D("JetsRecLVFakeRelSumPt2", "Relative sum of Pt2 of fake jets for matched LV; FakeSumPt2/SumPt2", 50, 0., 1.); + meJetsRecLVPURelMetPt_ = ibook.book1D("JetsRecLVPURelMetPt", "Relative Missing Transverse Energy of PU jets for matched LV; PUMet/Met", 50, 0., 1.); + meJetsRecLVPURelSumPx_ = ibook.book1D("JetsRecLVPURelSumPx", "Relative Sum of Px of PU jets for matched LV; SumPx/SumPx", 50, 0., 1.); + meJetsRecLVPURelSumPy_ = ibook.book1D("JetsRecLVPURelSumPy", "Relative Sum of Py of PU jets for matched LV; SumPy/SumPy", 50, 0., 1.); + meJetsRecLVPURelSumPz_ = ibook.book1D("JetsRecLVPURelSumPz", "Relative Sum of Pz of PU jets for matched LV; SumPz/SumPz", 50, 0., 1.); if (optionalPlots_) { - meJetsPUMult_ = ibook.book1D("JetsPUMult", "Number of PU jets for matched vertices; #PUJets", 50, 0., 50.); - meJetsPUHt_ = ibook.book1D("JetsPUHt", "Scalar sum of Et of PU jets for matched vertices; PUHt [GeV]", 50, 0., 100.); - meJetsPUSumPt2_ = ibook.book1D("JetsPUSumPt2", "Sum of Pt2 of PU jets for matched vertices; PUSumPt2 [GeV2]", 50, 0., 100.); - meJetsPUMetPt_ = ibook.book1D("JetsPUMetPt", "Missing Transverse Energy of PU jets for matched vertices; PUMet [GeV]", 50, 0., 40.); - meJetsPUSumPx_ = ibook.book1D("JetsPUSumPx", "Sum of Px of PU jets for matched vertices; PUSumPx [GeV]", 50, 0., 10.); - meJetsPUSumPy_ = ibook.book1D("JetsPUSumPy", "Sum of Py of PU jets for matched vertices; PUSumPy [GeV]", 50, 0., 10.); - meJetsPUSumPz_ = ibook.book1D("JetsPUSumPz", "Sum of Pz of PU jets for matched vertices; PUSumPz [GeV]", 50, 0., 50.); - - meJetsRecLVPUMult_ = ibook.book1D("JetsRecLVPUMult", "Number of PU jets for matched LV; #PUJets", 50, 0., 50.); - meJetsRecLVPUHt_ = ibook.book1D("JetsRecLVPUHt", "Scalar sum of Et of PU jets for matched LV; PUHt [GeV]", 50, 0., 100.); - meJetsRecLVPUSumPt2_ = ibook.book1D("JetsRecLVPUSumPt2", "Sum of Pt2 of PU jets for matched LV; PUSumPt2 [GeV2]", 50, 0., 2000.); - meJetsRecLVPUMetPt_ = ibook.book1D("JetsRecLVPUMetPt", "Missing Transverse Energy of PU jets for matched LV; PUMet [GeV]", 50, 0., 40.); - meJetsRecLVPUSumPx_ = ibook.book1D("JetsRecLVPUSumPx", "Sum of Px of PU jets for matched LV; PUSumPx [GeV]", 50, 0., 20.); - meJetsRecLVPUSumPy_ = ibook.book1D("JetsRecLVPUSumPy", "Sum of Py of PU jets for matched LV; PUSumPy [GeV]", 50, 0., 20.); - meJetsRecLVPUSumPz_ = ibook.book1D("JetsRecLVPUSumPz", "Sum of Pz of PU jets for matched LV; PUSumPz [GeV]", 50, 0., 100.); + meJetsPUMult_ = ibook.book1D("JetsPUMult", "Number of PU jets for matched vertices; #PUJets", 50, 0., 100.); + meJetsPUHt_ = ibook.book1D("JetsPUHt", "Scalar sum of Et of PU jets for matched vertices; PUHt [GeV]", 50, -2., 3.); + meJetsPUSumPt2_ = ibook.book1D("JetsPUSumPt2", "Sum of Pt2 of PU jets for matched vertices; PUSumPt2 [GeV2]", 50, -5., 3.); + meJetsPUMetPt_ = ibook.book1D("JetsPUMetPt", "Missing Transverse Energy of PU jets for matched vertices; PUMet [GeV]", 50, -5., 2.); + meJetsPUSumPx_ = ibook.book1D("JetsPUSumPx", "Sum of Px of PU jets for matched vertices; PUSumPx [GeV]", 50, -5., 2.); + meJetsPUSumPy_ = ibook.book1D("JetsPUSumPy", "Sum of Py of PU jets for matched vertices; PUSumPy [GeV]", 50, -5., 2.); + meJetsPUSumPz_ = ibook.book1D("JetsPUSumPz", "Sum of Pz of PU jets for matched vertices; PUSumPz [GeV]", 50, -4., 3.); + + meJetsPURelMultvsMult_ = ibook.bookProfile("JetsPURelMultvsMult", "Relative multiplicity of PU jets vs Number of jets for matched verticess; #Jets; #PUJets/#Jets", 50, 0., 120., 0., 1.,"s"); + meJetsPURelHtvsHt_ = ibook.bookProfile("JetsPURelHtvsHt", "Relative scalar sum of Et of PU jets vs scalar sum of Et for matched vertices; Ht [GeV]; PUHt/HT", 50, 0., 3., 0., 1.,"s"); + meJetsPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsPURelSumPt2vsSumPt2", "Relative sum of Pt2 of PU jets vs sum of Pt2 for matched vertices; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, -1., 4., 0., 1.,"s"); + meJetsFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsFakeRelSumPt2vsSumPt2", "Relative sum of Pt2 of fake jets vs sum of Pt2 for matched vertices; SumPt2 [GeV2]; FakeSumPt2/SumPt2", 50, -1., 4., 0., 1.,"s"); + meJetsPURelMetPtvsMetPt_ = ibook.bookProfile("JetsPURelMetPtvsMetPt", "Relative Missing Transverse Energy of PU jets vs MET for matched vertices; Met [GeV]; PUMet/Met", 50, -2., 2., 0., 1.,"s"); + meJetsPURelSumPxvsSumPx_ = ibook.bookProfile("JetsPURelSumPxvsSumPx", "Relative Sum of Px of PU jets vs Sum of Px for matched vertices; SumPx [GeV]; PUSumPx/SumPx", 50, -2., 2., 0., 1.,"s"); + meJetsPURelSumPyvsSumPy_ = ibook.bookProfile("JetsPURelSumPyvsSumPy", "Relative Sum of Py of PU jets vs Sum of Py for matched vertices; SumPy [GeV]; PUSumPy/SumPy", 50, -2., 2., 0., 1.,"s"); + meJetsPURelSumPzvsSumPz_ = ibook.bookProfile("JetsPURelSumPzvsSumPz", "Relative Sum of Pz of PU jets vs Sum of Pz for matched vertices; SumPz [GeV]; PUSumPz/SumPz", 50, -2., 3., 0., 1.,"s"); + + meJetsRecLVPUMult_ = ibook.book1D("JetsRecLVPUMult", "Number of PU jets for matched LV; #PUJets", 50, 0., 100.); + meJetsRecLVPUHt_ = ibook.book1D("JetsRecLVPUHt", "Scalar sum of Et of PU jets for matched LV; PUHt [GeV]", 50, -2., 3.); + meJetsRecLVPUSumPt2_ = ibook.book1D("JetsRecLVPUSumPt2", "Sum of Pt2 of PU jets for matched LV; PUSumPt2 [GeV2]", 50, -5., 3.); + meJetsRecLVPUMetPt_ = ibook.book1D("JetsRecLVPUMetPt", "Missing Transverse Energy of PU jets for matched LV; PUMet [GeV]", 50, -5., 2.); + meJetsRecLVPUSumPx_ = ibook.book1D("JetsRecLVPUSumPx", "Sum of Px of PU jets for matched LV; PUSumPx [GeV]", 50, -5., 2.); + meJetsRecLVPUSumPy_ = ibook.book1D("JetsRecLVPUSumPy", "Sum of Py of PU jets for matched LV; PUSumPy [GeV]", 50, -5., 2.); + meJetsRecLVPUSumPz_ = ibook.book1D("JetsRecLVPUSumPz", "Sum of Pz of PU jets for matched LV; PUSumPz [GeV]", 50, -4., 3.); + + meJetsRecLVPURelMultvsMult_ = ibook.bookProfile("JetsRecLVPURelMultvsMult", "Relative multiplicity of PU jets vs Number of jets for matched LV; #Jets; #PUJets/#Jets", 50, 0., 120., 0., 1.,"s"); + meJetsRecLVPURelHtvsHt_ = ibook.bookProfile("JetsRecLVPURelHtvsHt", "Relative scalar sum of Et of PU jets vs scalar sum of Et for matched LV; Ht [GeV]; PUHt/HT", 50, 1., 3., 0., 1.,"s"); + meJetsRecLVPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVPURelSumPt2vsSumPt2", "Relative sum of Pt2 of PU jets vs sum of Pt2 for matched LV; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 2., 5., 0., 1.,"s"); + meJetsRecLVFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVFakeRelSumPt2vsSumPt2", "Relative sum of Pt2 of fake jets vs sum of Pt2 for matched LV; SumPt2 [GeV2]; FakeSumPt2/SumPt2", 50, 2., 5., 0., 1.,"s"); + meJetsRecLVPURelMetPtvsMetPt_ = ibook.bookProfile("JetsRecLVPURelMetPtvsMetPt", "Relative Missing Transverse Energy of PU jets vs MET for LV vertices; Met [GeV]; PUMet/Met", 50, -3., 2., 0., 1.,"s"); + meJetsRecLVPURelSumPxvsSumPx_ = ibook.bookProfile("JetsRecLVPURelSumPxvsSumPx", "Relative Sum of Px of PU jets vs Sum of Px for matched LV; SumPx [GeV]; PUSumPx/SumPx", 50, -1., 3., 0., 1.,"s"); + meJetsRecLVPURelSumPyvsSumPy_ = ibook.bookProfile("JetsRecLVPURelSumPyvsSumPy", "Relative Sum of Py of PU jets vs Sum of Py for matched LV; SumPy [GeV]; PUSumPy/SumPy", 50, -1., 3., 0., 1.,"s"); + meJetsRecLVPURelSumPzvsSumPz_ = ibook.bookProfile("JetsRecLVPURelSumPzvsSumPz", "Relative Sum of Pz of PU jets vs Sum of Pz for matched LV; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 4., 0., 1.,"s"); } // some tests @@ -1046,7 +1043,9 @@ std::pair>*,int> Primary4DVertexVal return std::make_pair (&tp.first,1); } // matched TP not associated to the sim vertex (PU track) - else return std::make_pair (&tp.first,2); + else { + return std::make_pair (&tp.first,2); + } } // reco track not matched to any TP from vertex @@ -1153,10 +1152,9 @@ void Primary4DVertexValidation::observablesFromJets(const std::vector& probPi, const edm::ValueMap& probK, - const edm::ValueMap& probP, unsigned int& no_PIDtype, bool& no_PID, - bool& is_Pi, bool& is_K, bool& is_P) { +void Primary4DVertexValidation::isParticle(const reco::TrackBaseRef& recoTrack, const edm::ValueMap& probPi, + const edm::ValueMap& probK, const edm::ValueMap& probP, + unsigned int& no_PIDtype, bool& no_PID, bool& is_Pi, bool& is_K, bool& is_P) { no_PIDtype = 0; no_PID = false; is_Pi = false; @@ -1166,8 +1164,7 @@ void Primary4DVertexValidation::isParticle(const reco::TrackBaseRef& recoTrack, no_PIDtype = 1; } else if (std::isnan(probPi[recoTrack])) { no_PIDtype = 2; - } else if (probPi[ -recoTrack] == 1 && probK[recoTrack] == 0 && probP[recoTrack] == 0) { + } else if (probPi[recoTrack] == 1 && probK[recoTrack] == 0 && probP[recoTrack] == 0) { no_PIDtype = 3; } no_PID = no_PIDtype > 0; @@ -1176,6 +1173,22 @@ recoTrack] == 1 && probK[recoTrack] == 0 && probP[recoTrack] == 0) { is_P = !no_PID && !is_Pi && !is_K; } +void Primary4DVertexValidation::getWosWnt(const reco::Vertex& recoVtx, const reco::TrackBaseRef& recoTrk, const edm::ValueMap& sigmat0, + const edm::Handle& BS, double& wos, double& wnt) { + double dz2_beam = pow((*BS).BeamWidthX() * cos(recoTrk->phi()) / tan(recoTrk->theta()), 2) + + pow((*BS).BeamWidthY() * sin(recoTrk->phi()) / tan(recoTrk->theta()), 2); + double dz2 = pow(recoTrk->dzError(), 2) + dz2_beam + + pow(0.0020, 2); // added 20 um, some tracks have crazy small resolutions + wos = recoVtx.trackWeight(recoTrk) / dz2; + wnt = recoVtx.trackWeight(recoTrk) * std::min(recoTrk->pt(), 1.0); + + if (sigmat0[recoTrk] > 0) { + double sigmaZ = (*BS).sigmaZ(); + double sigmaT = sigmaZ / c_; // c in cm/ns + wos = wos / erf(sigmat0[recoTrk] / sigmaT); + } +} + /* Extract information form TrackingParticles/TrackingVertex and fill * the helper class simPrimaryVertex with proper generation-level * information */ @@ -1371,8 +1384,6 @@ void Primary4DVertexValidation::matchReco2Sim(std::vector& re double evnt = 0; for (auto iTrack = vertex->tracks_begin(); iTrack != vertex->tracks_end(); ++iTrack) { - double pt = (*iTrack)->pt(); - if (vertex->trackWeight(*iTrack) < trackweightTh_) continue; if (MVA[(*iTrack)] < mvaTh_) @@ -1382,18 +1393,7 @@ void Primary4DVertexValidation::matchReco2Sim(std::vector& re int matchCategory = getMatchedTP(*iTrack, simpv.at(iev).sim_vertex).second; // matched TP equal to any TP of sim vertex if (tp_info != nullptr && matchCategory == 0) { - double dz2_beam = pow((*BS).BeamWidthX() * cos((*iTrack)->phi()) / tan((*iTrack)->theta()), 2) + - pow((*BS).BeamWidthY() * sin((*iTrack)->phi()) / tan((*iTrack)->theta()), 2); - double dz2 = pow((*iTrack)->dzError(), 2) + dz2_beam + - pow(0.0020, 2); // added 20 um, some tracks have crazy small resolutions - wos = vertex->trackWeight(*iTrack) / dz2; - wnt = vertex->trackWeight(*iTrack) * std::min(pt, 1.0); - - if (sigmat0[(*iTrack)] > 0) { - double sigmaZ = (*BS).sigmaZ(); - double sigmaT = sigmaZ / c_; // c in cm/ns - wos = wos / erf(sigmat0[(*iTrack)] / sigmaT); - } + getWosWnt(*vertex, *iTrack, sigmat0, BS, wos, wnt); simpv.at(iev).addTrack(iv, wos, wnt); recopv.at(iv).addTrack(iev, wos, wnt); evwos += wos; @@ -1673,7 +1673,7 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve unsigned int no_PIDtype = 0; bool no_PID, is_Pi, is_K, is_P; int PartID = 211; // pion - isParticle(*iTrack, minProbHeavy_, probPi, probK, probP, no_PIDtype, no_PID, is_Pi, is_K, is_P); + isParticle(*iTrack, probPi, probK, probP, no_PIDtype, no_PID, is_Pi, is_K, is_P); if (!use3dNoTime_) { if (no_PID || is_Pi) { PartID = 211; @@ -1689,17 +1689,7 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve double mass = PData->mass().value(); massVector.push_back(mass); recotracks.push_back(**iTrack); - double dz2_beam = pow((*BeamSpotH).BeamWidthX() * cos((*iTrack)->phi()) / tan((*iTrack)->theta()), 2) + - pow((*BeamSpotH).BeamWidthY() * sin((*iTrack)->phi()) / tan((*iTrack)->theta()), 2); - double dz2 = pow((*iTrack)->dzError(), 2) + dz2_beam + - pow(0.0020, 2); // added 20 um, some tracks have crazy small resolutions - wnt = vertex->trackWeight(*iTrack) * std::min((*iTrack)->pt(), 1.0); - wos = vertex->trackWeight(*iTrack) / dz2; - if (sigmat0Safe[(*iTrack)] > 0) { - double sigmaZ = (*BeamSpotH).sigmaZ(); - double sigmaT = sigmaZ / c_; // c in cm/ns - wos = wos / erf(sigmat0Safe[(*iTrack)] / sigmaT); - } + getWosWnt(*vertex, *iTrack, sigmat0Safe, BeamSpotH, wos, wnt); // reco track matched to some TP if (tp_info != nullptr) { if (debug_ && selectedLV) { @@ -1790,7 +1780,7 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve unsigned int noPIDtype = 0; bool noPID = false, isPi = false, isK = false, isP = false; - isParticle(*iTrack, minProbHeavy_, probPi, probK, probP, noPIDtype, noPID, isPi, isK, isP); + isParticle(*iTrack, probPi, probK, probP, noPIDtype, noPID, isPi, isK, isP); if ((isPi && std::abs(tMtd[*iTrack] - tofPi[*iTrack] - t0Pid[*iTrack]) > tol_) || (isK && std::abs(tMtd[*iTrack] - tofK[*iTrack] - t0Pid[*iTrack]) > tol_) || @@ -2016,18 +2006,6 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve mePUTrackRelSumPy_->Fill(std::abs(PUsumPy)/std::abs(sumPy)); mePUTrackRelSumPz_->Fill(std::abs(PUsumPz)/std::abs(sumPz)); - mePUTrackRelMultvsMult_->Fill(nt, static_cast(PUnt)/nt); - meFakeTrackRelMultvsMult_->Fill(nt, static_cast(Fakent)/nt); - mePUTrackRelSumWntvsSumWnt_->Fill(sumWnt, PUsumWnt/sumWnt); - mePUTrackRelSumWosvsSumWos_->Fill(sumWos, PUsumWos/sumWos); - meSecTrackRelSumWosvsSumWos_->Fill(sumWos, SecsumWos/sumWos); - meFakeTrackRelSumWosvsSumWos_->Fill(sumWos, FakesumWos/sumWos); - mePUTrackRelSumPtvsSumPt_->Fill(sumPt, PUsumPt/sumPt); - mePUTrackRelSumPt2vsSumPt2_->Fill(sumPt2, PUsumPt2/sumPt2); - mePUTrackRelSumPxvsSumPx_->Fill(std::abs(sumPx), std::abs(PUsumPx)/std::abs(sumPx)); - mePUTrackRelSumPyvsSumPy_->Fill(std::abs(sumPy), std::abs(PUsumPy)/std::abs(sumPy)); - mePUTrackRelSumPzvsSumPz_->Fill(std::abs(sumPz), std::abs(PUsumPz)/std::abs(sumPz)); - observablesFromJets(recotracks, massVector, categoryVector, "use_allTracks", nJets, sumEtJets, sumPt2Jets, metPt, sumPxJets, sumPyJets, sumPzJets); observablesFromJets(recotracks, massVector, categoryVector, "skip_Fake", nJetsnoFake, sumEtJetsnoFake, sumPt2JetsnoFake, metPtnoFake, sumPxJetsnoFake, sumPyJetsnoFake, sumPzJetsnoFake); observablesFromJets(recotracks, massVector, categoryVector, "skip_PU", nJetsnoPU, sumEtJetsnoPU, sumPt2JetsnoPU, metPtnoPU, sumPxJetsnoPU, sumPyJetsnoPU, sumPzJetsnoPU); @@ -2041,32 +2019,45 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve meJetsPURelSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); meJetsPURelSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); - meJetsPURelMultvsMult_->Fill(nJets, static_cast(nJets-nJetsnoPU)/nJets); - meJetsPURelHtvsHt_->Fill(sumEtJets, (sumEtJets-sumEtJetsnoPU)/sumEtJets); - meJetsPURelSumPt2vsSumPt2_->Fill(sumPt2Jets, (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); - meJetsFakeRelSumPt2vsSumPt2_->Fill(sumPt2Jets, (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); - meJetsPURelMetPtvsMetPt_->Fill(metPt, (metPt-metPtnoPU)/metPt); - meJetsPURelSumPxvsSumPx_->Fill(std::abs(sumPxJets), std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); - meJetsPURelSumPyvsSumPy_->Fill(std::abs(sumPyJets), std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); - meJetsPURelSumPzvsSumPz_->Fill(std::abs(sumPzJets), std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); if (optionalPlots_) { mePUTrackMult_->Fill(PUnt); - mePUTrackSumWnt_->Fill(PUsumWnt); - mePUTrackSumWos_->Fill(PUsumWos); - meSecTrackSumWos_->Fill(SecsumWos); - mePUTrackSumPt_->Fill(PUsumPt); - mePUTrackSumPt2_->Fill(PUsumPt2); - mePUTrackSumPx_->Fill(std::abs(PUsumPx)); - mePUTrackSumPy_->Fill(std::abs(PUsumPy)); - mePUTrackSumPz_->Fill(std::abs(PUsumPz)); + mePUTrackSumWnt_->Fill(log10(std::max(0.01,PUsumWnt))); + mePUTrackSumWos_->Fill(log10(std::max(0.1,PUsumWos))); + meSecTrackSumWos_->Fill(log10(std::max(0.1,SecsumWos))); + mePUTrackSumPt_->Fill(log10(std::max(0.01,PUsumPt))); + mePUTrackSumPt2_->Fill(log10(std::max(0.001,PUsumPt2))); + mePUTrackSumPx_->Fill(log10(std::max(0.00001,std::abs(PUsumPx)))); + mePUTrackSumPy_->Fill(log10(std::max(0.00001,std::abs(PUsumPy)))); + mePUTrackSumPz_->Fill(log10(std::max(0.0001,std::abs(PUsumPz)))); + + mePUTrackRelMultvsMult_->Fill(nt, static_cast(PUnt)/nt); + meFakeTrackRelMultvsMult_->Fill(nt, static_cast(Fakent)/nt); + mePUTrackRelSumWntvsSumWnt_->Fill(log10(std::max(0.01,sumWnt)), PUsumWnt/sumWnt); + mePUTrackRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), PUsumWos/sumWos); + meSecTrackRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), SecsumWos/sumWos); + meFakeTrackRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), FakesumWos/sumWos); + mePUTrackRelSumPtvsSumPt_->Fill(log10(std::max(0.01,sumPt)), PUsumPt/sumPt); + mePUTrackRelSumPt2vsSumPt2_->Fill(log10(std::max(0.001,sumPt2)), PUsumPt2/sumPt2); + mePUTrackRelSumPxvsSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPx))), std::abs(PUsumPx)/std::abs(sumPx)); + mePUTrackRelSumPyvsSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPy))), std::abs(PUsumPy)/std::abs(sumPy)); + mePUTrackRelSumPzvsSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPz))), std::abs(PUsumPz)/std::abs(sumPz)); meJetsPUMult_->Fill(nJets-nJetsnoPU); - meJetsPUHt_->Fill(sumEtJets-sumEtJetsnoPU); - meJetsPUSumPt2_->Fill(sumPt2Jets-sumPt2JetsnoPU); - meJetsPUMetPt_->Fill(metPt-metPtnoPU); - meJetsPUSumPx_->Fill(std::abs(sumPxJets-sumPxJetsnoPU)); - meJetsPUSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)); - meJetsPUSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)); + meJetsPUHt_->Fill(log10(std::max(0.01,sumEtJets-sumEtJetsnoPU))); + meJetsPUSumPt2_->Fill(log10(std::max(0.00001,sumPt2Jets-sumPt2JetsnoPU))); + meJetsPUMetPt_->Fill(log10(std::max(0.00001,metPt-metPtnoPU))); + meJetsPUSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPxJets-sumPxJetsnoPU)))); + meJetsPUSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPyJets-sumPyJetsnoPU)))); + meJetsPUSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPzJets-sumPzJetsnoPU)))); + + meJetsPURelMultvsMult_->Fill(nJets, static_cast(nJets-nJetsnoPU)/nJets); + meJetsPURelHtvsHt_->Fill(log10(std::max(0.01,sumEtJets)), (sumEtJets-sumEtJetsnoPU)/sumEtJets); + meJetsPURelSumPt2vsSumPt2_->Fill(log10(std::max(0.0001,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); + meJetsFakeRelSumPt2vsSumPt2_->Fill(log10(std::max(0.0001,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); + meJetsPURelMetPtvsMetPt_->Fill(log10(std::max(0.0001,metPt)), (metPt-metPtnoPU)/metPt); + meJetsPURelSumPxvsSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPxJets))), std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); + meJetsPURelSumPyvsSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPyJets))), std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); + meJetsPURelSumPzvsSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPzJets))), std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); } if (selectedLV) { mePUTrackRecLVRelMult_->Fill(static_cast(PUnt)/nt); @@ -2081,18 +2072,6 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve mePUTrackRecLVRelSumPy_->Fill(std::abs(PUsumPy)/std::abs(sumPy)); mePUTrackRecLVRelSumPz_->Fill(std::abs(PUsumPz)/std::abs(sumPz)); - mePUTrackRecLVRelMultvsMult_->Fill(nt, static_cast(PUnt)/nt); - meFakeTrackRecLVRelMultvsMult_->Fill(nt, static_cast(Fakent)/nt); - mePUTrackRecLVRelSumWntvsSumWnt_->Fill(sumWnt, PUsumWnt/sumWnt); - mePUTrackRecLVRelSumWosvsSumWos_->Fill(sumWos, PUsumWos/sumWos); - meSecTrackRecLVRelSumWosvsSumWos_->Fill(sumWos, SecsumWos/sumWos); - meFakeTrackRecLVRelSumWosvsSumWos_->Fill(sumWos, FakesumWos/sumWos); - mePUTrackRecLVRelSumPtvsSumPt_->Fill(sumPt, PUsumPt/sumPt); - mePUTrackRecLVRelSumPt2vsSumPt2_->Fill(sumPt2, PUsumPt2/sumPt2); - mePUTrackRecLVRelSumPxvsSumPx_->Fill(std::abs(sumPx), std::abs(PUsumPx)/std::abs(sumPx)); - mePUTrackRecLVRelSumPyvsSumPy_->Fill(std::abs(sumPy), std::abs(PUsumPy)/std::abs(sumPy)); - mePUTrackRecLVRelSumPzvsSumPz_->Fill(std::abs(sumPz), std::abs(PUsumPz)/std::abs(sumPz)); - meJetsRecLVPURelMult_->Fill(static_cast(nJets-nJetsnoPU)/nJets); meJetsRecLVPURelHt_->Fill((sumEtJets-sumEtJetsnoPU)/sumEtJets); meJetsRecLVPURelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); @@ -2102,14 +2081,6 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve meJetsRecLVPURelSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); meJetsRecLVPURelSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); - meJetsRecLVPURelMultvsMult_->Fill(nJets, static_cast(nJets-nJetsnoPU)/nJets); - meJetsRecLVPURelHtvsHt_->Fill(sumEtJets, (sumEtJets-sumEtJetsnoPU)/sumEtJets); - meJetsRecLVPURelSumPt2vsSumPt2_->Fill(sumPt2Jets, (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); - meJetsRecLVFakeRelSumPt2vsSumPt2_->Fill(sumPt2Jets, (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); - meJetsRecLVPURelMetPtvsMetPt_->Fill(metPt, (metPt-metPtnoPU)/metPt); - meJetsRecLVPURelSumPxvsSumPx_->Fill(std::abs(sumPxJets), std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); - meJetsRecLVPURelSumPyvsSumPy_->Fill(std::abs(sumPyJets), std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); - meJetsRecLVPURelSumPzvsSumPz_->Fill(std::abs(sumPzJets), std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); if (debug_){ edm::LogPrint("Primary4DVertexValidation") << "#PUTrks = " << PUnt << " #Trks = " << nt << " PURelMult = " << std::setprecision(3) << static_cast(PUnt)/nt; @@ -2122,22 +2093,43 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve } if (optionalPlots_) { mePUTrackRecLVMult_->Fill(PUnt); - mePUTrackRecLVSumWnt_->Fill(PUsumWnt); - mePUTrackRecLVSumWos_->Fill(PUsumWos); - meSecTrackRecLVSumWos_->Fill(PUsumWos); - mePUTrackRecLVSumPt_->Fill(PUsumPt); - mePUTrackRecLVSumPt2_->Fill(PUsumPt2); - mePUTrackRecLVSumPx_->Fill(std::abs(PUsumPx)); - mePUTrackRecLVSumPy_->Fill(std::abs(PUsumPy)); - mePUTrackRecLVSumPz_->Fill(std::abs(PUsumPz)); + mePUTrackRecLVSumWnt_->Fill(log10(std::max(0.01,PUsumWnt))); + mePUTrackRecLVSumWos_->Fill(log10(std::max(0.1,PUsumWos))); + meSecTrackRecLVSumWos_->Fill(log10(std::max(0.1,PUsumWos))); + mePUTrackRecLVSumPt_->Fill(log10(std::max(0.01,PUsumPt))); + mePUTrackRecLVSumPt2_->Fill(log10(std::max(0.001,PUsumPt2))); + mePUTrackRecLVSumPx_->Fill(log10(std::max(0.00001,std::abs(PUsumPx)))); + mePUTrackRecLVSumPy_->Fill(log10(std::max(0.00001,std::abs(PUsumPy)))); + mePUTrackRecLVSumPz_->Fill(log10(std::max(0.0001,std::abs(PUsumPz)))); + + mePUTrackRecLVRelMultvsMult_->Fill(nt, static_cast(PUnt)/nt); + meFakeTrackRecLVRelMultvsMult_->Fill(nt, static_cast(Fakent)/nt); + mePUTrackRecLVRelSumWntvsSumWnt_->Fill(log10(std::max(0.01,sumWnt)), PUsumWnt/sumWnt); + mePUTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), PUsumWos/sumWos); + meSecTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), SecsumWos/sumWos); + meFakeTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), FakesumWos/sumWos); + mePUTrackRecLVRelSumPtvsSumPt_->Fill(log10(std::max(0.01,sumPt)), PUsumPt/sumPt); + mePUTrackRecLVRelSumPt2vsSumPt2_->Fill(log10(std::max(0.001,sumPt2)), PUsumPt2/sumPt2); + mePUTrackRecLVRelSumPxvsSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPx))), std::abs(PUsumPx)/std::abs(sumPx)); + mePUTrackRecLVRelSumPyvsSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPy))), std::abs(PUsumPy)/std::abs(sumPy)); + mePUTrackRecLVRelSumPzvsSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPz))), std::abs(PUsumPz)/std::abs(sumPz)); meJetsRecLVPUMult_->Fill(nJets-nJetsnoPU); - meJetsRecLVPUHt_->Fill(sumEtJets-sumEtJetsnoPU); - meJetsRecLVPUSumPt2_->Fill(sumPt2Jets-sumPt2JetsnoPU); - meJetsRecLVPUMetPt_->Fill(metPt-metPtnoPU); - meJetsRecLVPUSumPx_->Fill(std::abs(sumPxJets-sumPxJetsnoPU)); - meJetsRecLVPUSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)); - meJetsRecLVPUSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)); + meJetsRecLVPUHt_->Fill(log10(std::max(0.01,sumEtJets-sumEtJetsnoPU))); + meJetsRecLVPUSumPt2_->Fill(log10(std::max(0.00001,sumPt2Jets-sumPt2JetsnoPU))); + meJetsRecLVPUMetPt_->Fill(log10(std::max(0.00001,metPt-metPtnoPU))); + meJetsRecLVPUSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPxJets-sumPxJetsnoPU)))); + meJetsRecLVPUSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPyJets-sumPyJetsnoPU)))); + meJetsRecLVPUSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPzJets-sumPzJetsnoPU)))); + + meJetsRecLVPURelMultvsMult_->Fill(nJets, static_cast(nJets-nJetsnoPU)/nJets); + meJetsRecLVPURelHtvsHt_->Fill(log10(std::max(0.01,sumEtJets)), (sumEtJets-sumEtJetsnoPU)/sumEtJets); + meJetsRecLVPURelSumPt2vsSumPt2_->Fill(log10(std::max(0.0001,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); + meJetsRecLVFakeRelSumPt2vsSumPt2_->Fill(log10(std::max(0.0001,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); + meJetsRecLVPURelMetPtvsMetPt_->Fill(log10(std::max(0.0001,metPt)), (metPt-metPtnoPU)/metPt); + meJetsRecLVPURelSumPxvsSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPxJets))), std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); + meJetsRecLVPURelSumPyvsSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPyJets))), std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); + meJetsRecLVPURelSumPzvsSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPzJets))), std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); } } } @@ -2339,7 +2331,7 @@ void Primary4DVertexValidation::fillDescriptions(edm::ConfigurationDescriptions& desc.add("useOnlyChargedTracks", true); desc.addUntracked("debug", false); desc.addUntracked("optionalPlots", false); - desc.addUntracked("use3dNoTime", false); + desc.add("use3dNoTime", false); desc.add("trackweightTh", 0.5); desc.add("mvaTh", 0.01); desc.add("minProbHeavy", 0.75); From 05fd2787e1bdbea9444570160754925d9786037f Mon Sep 17 00:00:00 2001 From: Raffaele Delli Gatti Date: Wed, 6 Mar 2024 15:40:58 +0100 Subject: [PATCH 5/7] Plots for sumpx and sumpy removed, range and titles of some histograms modified, some comments rewritten, member data for min threshold in log histograms added --- .../plugins/Primary4DVertexValidation.cc | 356 +++++++----------- 1 file changed, 134 insertions(+), 222 deletions(-) diff --git a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc index afd1b8b01da56..887a19117ad89 100644 --- a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc +++ b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc @@ -216,7 +216,7 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { double timeFromTrueMass(double, double, double, double); bool select(const reco::Vertex&, int level = 0); void observablesFromJets(const std::vector&, const std::vector&, const std::vector&, - const std::string&, unsigned int&, double&, double&, double&, double&, double&, double&); + const std::string&, unsigned int&, double&, double&, double&, double&); void isParticle(const reco::TrackBaseRef&, const edm::ValueMap&, const edm::ValueMap&, const edm::ValueMap&, unsigned int&, bool&, bool&, bool&, bool&); void getWosWnt(const reco::Vertex&, const reco::TrackBaseRef&, const edm::ValueMap&, const edm::Handle&, double&, double&); @@ -248,6 +248,12 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { static constexpr double trackMinEtlEta_ = 1.6; static constexpr double trackMaxEtlEta_ = 3.; static constexpr double tol_ = 1.e-4; // tolerance on reconstructed track time, [ns] + static constexpr double minThrSumWnt_ = 0.01; // min threshold for filling histograms with logarithmic scale + static constexpr double minThrSumWos_ = 0.1; + static constexpr double minThrSumPt_ = 0.01; + static constexpr double minThrSumPt2_ = 0.001; + static constexpr double minThrMetPt_ = 0.001; + static constexpr double minThrSumPz_ = 0.0001; static constexpr float c_cm_ns = geant_units::operators::convertMmToCm(CLHEP::c_light); // [mm/ns] -> [cm/ns] @@ -352,12 +358,6 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* mePUTrackRelSumPt_; MonitorElement* mePUTrackSumPt2_; MonitorElement* mePUTrackRelSumPt2_; - MonitorElement* mePUTrackSumPx_; - MonitorElement* mePUTrackSumPy_; - MonitorElement* mePUTrackSumPz_; - MonitorElement* mePUTrackRelSumPx_; - MonitorElement* mePUTrackRelSumPy_; - MonitorElement* mePUTrackRelSumPz_; MonitorElement* mePUTrackRelMultvsMult_; MonitorElement* meFakeTrackRelMultvsMult_; @@ -367,9 +367,6 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* meSecTrackRelSumWosvsSumWos_; MonitorElement* mePUTrackRelSumPtvsSumPt_; MonitorElement* mePUTrackRelSumPt2vsSumPt2_; - MonitorElement* mePUTrackRelSumPxvsSumPx_; - MonitorElement* mePUTrackRelSumPyvsSumPy_; - MonitorElement* mePUTrackRelSumPzvsSumPz_; MonitorElement* mePUTrackRecLVMult_; MonitorElement* mePUTrackRecLVRelMult_; @@ -386,12 +383,6 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* mePUTrackRecLVRelSumPt_; MonitorElement* mePUTrackRecLVSumPt2_; MonitorElement* mePUTrackRecLVRelSumPt2_; - MonitorElement* mePUTrackRecLVSumPx_; - MonitorElement* mePUTrackRecLVSumPy_; - MonitorElement* mePUTrackRecLVSumPz_; - MonitorElement* mePUTrackRecLVRelSumPx_; - MonitorElement* mePUTrackRecLVRelSumPy_; - MonitorElement* mePUTrackRecLVRelSumPz_; MonitorElement* mePUTrackRecLVRelMultvsMult_; MonitorElement* meFakeTrackRecLVRelMultvsMult_; @@ -401,24 +392,17 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* meFakeTrackRecLVRelSumWosvsSumWos_; MonitorElement* mePUTrackRecLVRelSumPtvsSumPt_; MonitorElement* mePUTrackRecLVRelSumPt2vsSumPt2_; - MonitorElement* mePUTrackRecLVRelSumPxvsSumPx_; - MonitorElement* mePUTrackRecLVRelSumPyvsSumPy_; - MonitorElement* mePUTrackRecLVRelSumPzvsSumPz_; MonitorElement* meJetsPUMult_; MonitorElement* meJetsPUHt_; MonitorElement* meJetsPUSumPt2_; MonitorElement* meJetsPUMetPt_; - MonitorElement* meJetsPUSumPx_; - MonitorElement* meJetsPUSumPy_; MonitorElement* meJetsPUSumPz_; MonitorElement* meJetsPURelMult_; MonitorElement* meJetsPURelHt_; MonitorElement* meJetsPURelSumPt2_; MonitorElement* meJetsFakeRelSumPt2_; MonitorElement* meJetsPURelMetPt_; - MonitorElement* meJetsPURelSumPx_; - MonitorElement* meJetsPURelSumPy_; MonitorElement* meJetsPURelSumPz_; MonitorElement* meJetsPURelMultvsMult_; @@ -426,24 +410,18 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* meJetsPURelSumPt2vsSumPt2_; MonitorElement* meJetsFakeRelSumPt2vsSumPt2_; MonitorElement* meJetsPURelMetPtvsMetPt_; - MonitorElement* meJetsPURelSumPxvsSumPx_; - MonitorElement* meJetsPURelSumPyvsSumPy_; MonitorElement* meJetsPURelSumPzvsSumPz_; MonitorElement* meJetsRecLVPUMult_; MonitorElement* meJetsRecLVPUHt_; MonitorElement* meJetsRecLVPUSumPt2_; MonitorElement* meJetsRecLVPUMetPt_; - MonitorElement* meJetsRecLVPUSumPx_; - MonitorElement* meJetsRecLVPUSumPy_; MonitorElement* meJetsRecLVPUSumPz_; MonitorElement* meJetsRecLVPURelMult_; MonitorElement* meJetsRecLVPURelHt_; MonitorElement* meJetsRecLVPURelSumPt2_; MonitorElement* meJetsRecLVFakeRelSumPt2_; MonitorElement* meJetsRecLVPURelMetPt_; - MonitorElement* meJetsRecLVPURelSumPx_; - MonitorElement* meJetsRecLVPURelSumPy_; MonitorElement* meJetsRecLVPURelSumPz_; MonitorElement* meJetsRecLVPURelMultvsMult_; @@ -451,8 +429,6 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { MonitorElement* meJetsRecLVPURelSumPt2vsSumPt2_; MonitorElement* meJetsRecLVFakeRelSumPt2vsSumPt2_; MonitorElement* meJetsRecLVPURelMetPtvsMetPt_; - MonitorElement* meJetsRecLVPURelSumPxvsSumPx_; - MonitorElement* meJetsRecLVPURelSumPyvsSumPy_; MonitorElement* meJetsRecLVPURelSumPzvsSumPz_; // some tests @@ -684,126 +660,96 @@ void Primary4DVertexValidation::bookHistograms(DQMStore::IBooker& ibook, meFakeTrackRelMult_ = ibook.book1D("FakeTrackRelMult", "Relative multiplicity of fake tracks for matched vertices; #fakeTrks/#Trks", 50, 0., 1.); mePUTrackRelSumWnt_ = ibook.book1D("PUTrackRelSumWnt", "Relative Sum of wnt of PU tracks for matched vertices; PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 1.); mePUTrackRelSumWos_ = ibook.book1D("PUTrackRelSumWos", "Relative Sum of wos of PU tracks for matched vertices; PUSumWos/SumWos", 50, 0., 1.); - meSecTrackRelSumWos_ = ibook.book1D("SecTrackRelSumWos", "Relative Sum of wos of secondary tracks for matched vertices; SecSumWos/SumWos", 50, 0., 1.); + meSecTrackRelSumWos_ = ibook.book1D("SecTrackRelSumWos", "Relative Sum of wos of tracks from secondary vtx for matched vertices; SecSumWos/SumWos", 50, 0., 1.); meFakeTrackRelSumWos_ = ibook.book1D("FakeTrackRelSumWos", "Relative Sum of wos of fake tracks for matched vertices; FakeSumWos/SumWos", 50, 0., 1.); mePUTrackRelSumPt_ = ibook.book1D("PUTrackRelSumPt", "Relative Sum of Pt of PU tracks for matched vertices; PUSumPt/SumPt", 50, 0., 1.); mePUTrackRelSumPt2_ = ibook.book1D("PUTrackRelSumPt2", "Relative Sum of Pt2 for PU tracks for matched vertices; PUSumPt2/SumPt2", 50, 0., 1.); - mePUTrackRelSumPx_ = ibook.book1D("PUTrackRelSumPx", "Relative Sum of Px of PU tracks for matched vertices; PUSumPx/SumPx", 50, 0., 1.); - mePUTrackRelSumPy_ = ibook.book1D("PUTrackRelSumPy", "Relative Sum of Py of PU tracks for matched vertices; PUSumPy/SumPy", 50, 0., 1.); - mePUTrackRelSumPz_ = ibook.book1D("PUTrackRelSumPz", "Relative Sum of Pz of PU tracks for matched vertices; PUSumPz/SumPz", 50, 0., 1.); mePUTrackRecLVRelMult_ = ibook.book1D("PUTrackRecLVRelMult", "Relative multiplicity of PU tracks for matched LV; #PUTrks/#Trks", 50, 0., 1.); meFakeTrackRecLVRelMult_ = ibook.book1D("FakeTrackRecLVRelMult", "Relative multiplicity of fake tracks for matched LV; #FakeTrks/#Trks", 50, 0., 1.); mePUTrackRecLVRelSumWnt_ = ibook.book1D("PUTrackRecLVRelSumWnt", "Relative Sum of Wnt of PU tracks for matched LV; PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 1.); mePUTrackRecLVRelSumWos_ = ibook.book1D("PUTrackRecLVRelSumWos", "Relative Sum of Wos of PU tracks for matched LV; PUSumWos/SumWos", 50, 0., 1.); - meSecTrackRecLVRelSumWos_ = ibook.book1D("SecTrackRecLVRelSumWos", "Relative Sum of wos of secondary tracks for matched LV; SecSumWos/SumWos", 50, 0., 1.); + meSecTrackRecLVRelSumWos_ = ibook.book1D("SecTrackRecLVRelSumWos", "Relative Sum of wos of tracks from secondary vtx for matched LV; SecSumWos/SumWos", 50, 0., 1.); meFakeTrackRecLVRelSumWos_ = ibook.book1D("FakeTrackRecLVRelSumWos", "Relative Sum of wos of fake tracks for matched LV; FakeSumWos/SumWos", 50, 0., 1.); mePUTrackRecLVRelSumPt_ = ibook.book1D("PUTrackRecLVRelSumPt", "Relative Sum of Pt of PU tracks for matched LV; PUSumPt/SumPt", 50, 0., 1.); mePUTrackRecLVRelSumPt2_ = ibook.book1D("PUTrackRecLVRelSumPt2", "Relative Sum of Pt2 of PU tracks for matched LV; PUSumPt2/SumPt2", 50, 0., 1.); - mePUTrackRecLVRelSumPx_ = ibook.book1D("PUTrackRecLVRelSumPx", "Relative Sum of Px of PU tracks for matched LV; PUSumPx/SumPx", 50, 0., 1.); - mePUTrackRecLVRelSumPy_ = ibook.book1D("PUTrackRecLVRelSumPy", "Relative Sum of Py of PU tracks for matched LV; PUSumPy/SumPy", 50, 0., 1.); - mePUTrackRecLVRelSumPz_ = ibook.book1D("PUTrackRecLVRelSumPz", "Relative Sum of Pz of PU tracks for matched LV; PUSumPz/SumPz", 50, 0., 1.); if (optionalPlots_) { mePUTrackMult_ = ibook.book1D("PUTrackMult", "Number of PU tracks for matched vertices; #PUTrks", 50, 0., 100.); mePUTrackWnt_ = ibook.book1D("PUTrackWnt", "Wnt of PU tracks for matched vertices; PUTrkW*min(Pt, 1.)", 50, 0., 1.); - mePUTrackSumWnt_ = ibook.book1D("PUTrackSumWnt", "Sum of wnt of PU tracks for matched vertices; PUSumW*min(Pt, 1.)", 50, -2., 3.); - mePUTrackSumWos_ = ibook.book1D("PUTrackSumWos", "Sum of wos of PU tracks for matched vertices; PUSumWos", 50, -1., 7.); - meSecTrackSumWos_ = ibook.book1D("SecTrackSumWos", "Sum of wos of secondary tracks for matched vertices; SecSumWos", 50, -1., 7.); - mePUTrackSumPt_ = ibook.book1D("PUTrackSumPt", "Sum of Pt of PU tracks for matched vertices; PUSumPt [GeV]", 50, -2., 3.); - mePUTrackSumPt2_ = ibook.book1D("PUTrackSumPt2", "Sum of Pt2 of PU tracks for matched vertices; PUSumPt2 [GeV2]", 50, -3., 3.); - mePUTrackSumPx_ = ibook.book1D("PUTrackSumPx", "Sum of Px of PU tracks for matched vertices; PUSumPx [GeV]", 50, -5., 2.); - mePUTrackSumPy_ = ibook.book1D("PUTrackSumPy", "Sum of Py of PU tracks for matched vertices; PUSumPy [GeV]", 50, -5., 2.); - mePUTrackSumPz_ = ibook.book1D("PUTrackSumPz", "Sum of Pz of PU tracks for matched vertices; PUSumPz [GeV]", 50, -4., 3.); + mePUTrackSumWnt_ = ibook.book1D("PUTrackSumWnt", "Sum of wnt of PU tracks for matched vertices; log10(PUSumW*min(Pt, 1.))", 50, -2., 3.); + mePUTrackSumWos_ = ibook.book1D("PUTrackSumWos", "Sum of wos of PU tracks for matched vertices; log10(PUSumWos)", 50, -1., 7.); + meSecTrackSumWos_ = ibook.book1D("SecTrackSumWos", "Sum of wos of tracks from secondary vtx for matched vertices; log10(SecSumWos)", 50, -1., 7.); + mePUTrackSumPt_ = ibook.book1D("PUTrackSumPt", "Sum of Pt of PU tracks for matched vertices; log10(PUSumPt)", 50, -2., 3.); + mePUTrackSumPt2_ = ibook.book1D("PUTrackSumPt2", "Sum of Pt2 of PU tracks for matched vertices; log10(PUSumPt2)", 50, -3., 3.); mePUTrackRelMultvsMult_ = ibook.bookProfile("PUTrackRelMultvsMult", "Relative PU multiplicity vs Number of tracks for matched vertices; #Trks; #PUTrks/#Trks", 50, 0., 200., 0., 1.,"s"); meFakeTrackRelMultvsMult_ = ibook.bookProfile("FakeTrackRelMultvsMult", "Relative multiplicity of fake tracks vs Number of tracks for matched vertices; #Trks; #FakeTrks/#Trks", 50, 0., 200., 0., 1.,"s"); - mePUTrackRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched vertices; SumW*min(Pt, 1.); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 3., 0., 1.,"s"); - mePUTrackRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; SumWos; PUSumWos/SumWos", 50, 2.5, 7.5, 0., 1.,"s"); - meSecTrackRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRelSumWosvsSumWos", "Relative Sum of Wos of secondary tracks vs Sum of Wos of tracks for matched vertices; SumWos; SecSumWos/SumWos", 50, 2.5, 7.5, 0., 1.,"s"); - meFakeTrackRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; SumWos; FakeSumWos/SumWos", 50, 2.5, 7.5, 0., 1.,"s"); - mePUTrackRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched vertices; SumPt [GeV]; PUSumPt/SumPt", 50, 0., 3., 0., 1.,"s"); - mePUTrackRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of Pt2 of tracks for matched vertices; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, -1., 4., 0., 1.,"s"); - mePUTrackRelSumPxvsSumPx_ = ibook.bookProfile("PUTrackRelSumPxvsSumPx", "Relative PU Sum of Px vs Sum of Px of tracks for matched vertices; SumPx [GeV]; PUSumPx/SumPx", 50, -3., 2, 0., 1.,"s"); - mePUTrackRelSumPyvsSumPy_ = ibook.bookProfile("PUTrackRelSumPyvsSumPy", "Relative PU Sum of Py vs Sum of Py of tracks for matched vertices; SumPy [GeV]; PUSumPy/SumPy", 50, -3., 2., 0., 1.,"s"); - mePUTrackRelSumPzvsSumPz_ = ibook.bookProfile("PUTrackRelSumPzvsSumPz", "Relative PU Sum of Pz vs Sum of Pz of tracks for matched vertices; SumPz [GeV]; PUSumPz/SumPz", 50, -2., 3., 0., 1.,"s"); + mePUTrackRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched vertices; log10(SumW*min(Pt, 1.)); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 2.5, 0., 1.,"s"); + mePUTrackRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; log10(SumWos); PUSumWos/SumWos", 50, 2.5, 7., 0., 1.,"s"); + meSecTrackRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRelSumWosvsSumWos", "Relative Sum of Wos of tracks from secondary vtx vs Sum of Wos of tracks for matched vertices; log10(SumWos); SecSumWos/SumWos", 50, 2., 7., 0., 1.,"s"); + meFakeTrackRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; log10(SumWos); FakeSumWos/SumWos", 50, 2.5, 7.5, 0., 1.,"s"); + mePUTrackRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched vertices; log10(SumPt); PUSumPt/SumPt", 50, 0., 3., 0., 1.,"s"); + mePUTrackRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of Pt2 of tracks for matched vertices; log10(SumPt2); PUSumPt2/SumPt2", 50, 0., 4., 0., 1.,"s"); mePUTrackRecLVMult_ = ibook.book1D("PUTrackRecLVMult", "Number of PU tracks for matched LV; #PUTrks", 50, 0., 100.); mePUTrackRecLVWnt_ = ibook.book1D("PUTrackRecLVWnt", "Wnt of PU tracks for matched LV; PUTrkW*min(Pt, 1.)", 50, 0., 1.); - mePUTrackRecLVSumWnt_ = ibook.book1D("PUTrackRecLVSumWnt", "Sum of wnt of PU tracks for matched LV; PUSumW*min(Pt, 1.)", 50, -2., 3.); - mePUTrackRecLVSumWos_ = ibook.book1D("PUTrackRecLVSumWos", "Sum of wos of PU tracks for matched LV; PUSumWos", 50, -1., 7.); - meSecTrackRecLVSumWos_ = ibook.book1D("SecTrackRecLVSumWos", "Sum of wos of secondary tracks for matched LV; SecSumWos", 50, -1., 7.); - mePUTrackRecLVSumPt_ = ibook.book1D("PUTrackRecLVSumPt", "Sum of Pt of PU tracks for matched LV; PUSumPt [GeV]", 50, -2., 3.); - mePUTrackRecLVSumPt2_ = ibook.book1D("PUTrackRecLVSumPt2", "Sum of Pt2 of PU tracks for matched LV; PUSumPt2 [GeV2]", 50, -3., 3.); - mePUTrackRecLVSumPx_ = ibook.book1D("PUTrackRecLVSumPx", "Sum of Px of PU tracks for matched LV; PUSumPx [GeV]", 50, -5., 2.); - mePUTrackRecLVSumPy_ = ibook.book1D("PUTrackRecLVSumPy", "Sum of Py of PU tracks for matched LV; PUSumPy [GeV]", 50, -5., 2.); - mePUTrackRecLVSumPz_ = ibook.book1D("PUTrackRecLVSumPz", "Sum of Pz of PU tracks for matched LV; PUSumPz [GeV]", 50, -4., 3.); + mePUTrackRecLVSumWnt_ = ibook.book1D("PUTrackRecLVSumWnt", "Sum of wnt of PU tracks for matched LV; log10(PUSumW*min(Pt, 1.))", 50, -2., 3.); + mePUTrackRecLVSumWos_ = ibook.book1D("PUTrackRecLVSumWos", "Sum of wos of PU tracks for matched LV; log10(PUSumWos)", 50, -1., 7.); + meSecTrackRecLVSumWos_ = ibook.book1D("SecTrackRecLVSumWos", "Sum of wos of tracks from secondary vtx for matched LV; log10(SecSumWos)", 50, -1., 7.); + mePUTrackRecLVSumPt_ = ibook.book1D("PUTrackRecLVSumPt", "Sum of Pt of PU tracks for matched LV; log10(PUSumPt)", 50, -2., 3.); + mePUTrackRecLVSumPt2_ = ibook.book1D("PUTrackRecLVSumPt2", "Sum of Pt2 of PU tracks for matched LV; log10(PUSumPt2)", 50, -3., 3.); mePUTrackRecLVRelMultvsMult_ = ibook.bookProfile("PUTrackRecLVRelMultvsMult", "Relative PU multiplicity vs Number of tracks for matched LV; #Trks; #PUTrks/#Trks", 50, 0., 200., 0., 1.,"s"); meFakeTrackRecLVRelMultvsMult_ = ibook.bookProfile("FakeTrackRecLVRelMultvsMult", "Relative multiplicity of fake tracks vs Number of tracks for matched LV; #Trks; #FakeTrks/#Trks", 50, 0., 200., 0., 1.,"s"); - mePUTrackRecLVRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRecLVRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched LV; SumW*min(Pt, 1.); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 1., 3., 0., 1.,"s"); - mePUTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRecLVRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; SumWos; PUSumWos/SumWos", 50, 4.5, 7.5, 0., 1.,"s"); - meSecTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of secondary tracks vs Sum of Wos of tracks for matched vertices; SumWos; SecSumWos/SumWos", 50, 4.5, 7.5, 0., 1.,"s"); - meFakeTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; SumWos; FakeSumWos/SumWos", 50, 4.5, 7.5, 0., 1.,"s"); - mePUTrackRecLVRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRecLVRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched LV; SumPt [GeV]; PUSumPt/SumPt", 50, 1., 3., 0., 1.,"s"); - mePUTrackRecLVRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRecLVRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of tracks for matched LV; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 2., 4., 0., 1.,"s"); - mePUTrackRecLVRelSumPxvsSumPx_ = ibook.bookProfile("PUTrackRecLVRelSumPxvsSumPx", "Relative PU Sum of Px vs Sum of Px of tracks for matched LV; SumPx [GeV]; PUSumPx/SumPx", 50, -1., 2., 0., 1.,"s"); - mePUTrackRecLVRelSumPyvsSumPy_ = ibook.bookProfile("PUTrackRecLVRelSumPyvsSumPy", "Relative PU Sum of Py vs Sum of Py of tracks for matched LV; SumPy [GeV]; PUSumPy/SumPy", 50, -1., 2, 0., 1.,"s"); - mePUTrackRecLVRelSumPzvsSumPz_ = ibook.bookProfile("PUTrackRecLVRelSumPzvsSumPz", "Relative PU Sum of Pz vs Sum of Pz of tracks for matched LV; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 3., 0., 1.,"s"); + mePUTrackRecLVRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRecLVRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched LV; log10(SumW*min(Pt, 1.)); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 1., 2.3, 0., 1.,"s"); + mePUTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRecLVRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; log10(SumWos); PUSumWos/SumWos", 50, 5.5, 7., 0., 1.,"s"); + meSecTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of tracks from secondary vtx vs Sum of Wos of tracks for matched vertices; log10(SumWos); SecSumWos/SumWos", 50, 5.5, 7., 0., 1.,"s"); + meFakeTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; log10(SumWos); FakeSumWos/SumWos", 50, 5.5, 7., 0., 1.,"s"); + mePUTrackRecLVRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRecLVRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched LV; log10(SumPt); PUSumPt/SumPt", 50, 1.4, 3., 0., 1.,"s"); + mePUTrackRecLVRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRecLVRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of tracks for matched LV; log10(SumPt2); PUSumPt2/SumPt2", 50, 2., 4., 0., 1.,"s"); } - meJetsPURelMult_ = ibook.book1D("JetsPURelMult", "Relative multiplicity of PU jets for matched vertices; #PUJets/#Jets", 50, 0., 1.); - meJetsPURelHt_ = ibook.book1D("JetsPURelHt", "Relative scalar sum of Et of PU jets for matched vertices; PUHt/HT", 50, 0., 1.); - meJetsPURelSumPt2_ = ibook.book1D("JetsPURelSumPt2", "Relative sum of Pt2 of PU jets for matched vertices; PUSumPt2/SumPt2", 50, 0., 1.); - meJetsFakeRelSumPt2_ = ibook.book1D("JetsFakeRelSumPt2", "Relative sum of Pt2 of fake jets for matched vertices; FakeSumPt2/SumPt2", 50, 0., 1.); - meJetsPURelMetPt_ = ibook.book1D("JetsPURelMetPt", "Relative Missing Transverse Energy of PU jets for matched vertices; PUMet/Met", 50, 0., 1.); - meJetsPURelSumPx_ = ibook.book1D("JetsPURelSumPx", "Relative Sum of Px of PU jets for matched vertices; PUSumPx/SumPx", 50, 0., 1.); - meJetsPURelSumPy_ = ibook.book1D("JetsPURelSumPy", "Relative Sum of Py of PU jets for matched vertices; PUSumPy/SumPy", 50, 0., 1.); - meJetsPURelSumPz_ = ibook.book1D("JetsPURelSumPz", "Relative Sum of Pz of PU jets for matched vertices; PUSumPz/SumPz", 50, 0., 1.); - - meJetsRecLVPURelMult_ = ibook.book1D("JetsRecLVPURelMult", "Relative multiplicity of PU jets for matched LV; #PUJets/#Jets", 50, 0., 1.); - meJetsRecLVPURelHt_ = ibook.book1D("JetsRecLVPURelHt", "Relative scalar sum of Et of PU jets for matched LV; PUHt/HT", 50, 0., 1.); - meJetsRecLVPURelSumPt2_ = ibook.book1D("JetsRecLVPURelSumPt2", "Relative sum of Pt2 of PU jets for matched LV; PUSumPt2/SumPt2", 50, 0., 1.); - meJetsRecLVFakeRelSumPt2_ = ibook.book1D("JetsRecLVFakeRelSumPt2", "Relative sum of Pt2 of fake jets for matched LV; FakeSumPt2/SumPt2", 50, 0., 1.); - meJetsRecLVPURelMetPt_ = ibook.book1D("JetsRecLVPURelMetPt", "Relative Missing Transverse Energy of PU jets for matched LV; PUMet/Met", 50, 0., 1.); - meJetsRecLVPURelSumPx_ = ibook.book1D("JetsRecLVPURelSumPx", "Relative Sum of Px of PU jets for matched LV; SumPx/SumPx", 50, 0., 1.); - meJetsRecLVPURelSumPy_ = ibook.book1D("JetsRecLVPURelSumPy", "Relative Sum of Py of PU jets for matched LV; SumPy/SumPy", 50, 0., 1.); - meJetsRecLVPURelSumPz_ = ibook.book1D("JetsRecLVPURelSumPz", "Relative Sum of Pz of PU jets for matched LV; SumPz/SumPz", 50, 0., 1.); + meJetsPURelMult_ = ibook.book1D("JetsPURelMult", "Relative contribution of PU to jet multiplicity for matched vertices; (#Jets-#JetsNoPU)/#Jets", 50, 0., 1.); + meJetsPURelHt_ = ibook.book1D("JetsPURelHt", "Relative contribution of PU to scalar sum of Et of jets for matched vertices; (Ht-HtNoPU)/HT", 50, 0., 1.); + meJetsPURelSumPt2_ = ibook.book1D("JetsPURelSumPt2", "Relative contribution of PU to sum of Pt2 of jets for matched vertices; (SumPt2-SumPt2NoPU)/SumPt2", 50, 0., 1.); + meJetsFakeRelSumPt2_ = ibook.book1D("JetsFakeRelSumPt2", "Relative contribution of fake tracks to sum of Pt2 of jets for matched vertices; (SumPt2-SumPt2NoFake)/SumPt2", 50, 0., 1.); + meJetsPURelMetPt_ = ibook.book1D("JetsPURelMetPt", "Relative contribution of PU to Missing Transverse Energy for matched vertices; (Met-MetNoPU)/Met", 50, -1., 1.); + meJetsPURelSumPz_ = ibook.book1D("JetsPURelSumPz", "Relative contribution of PU to sum of Pz of jets for matched vertices; (SumPz-SumPzNoPU)/SumPz", 50, -1., 1.); + + meJetsRecLVPURelMult_ = ibook.book1D("JetsRecLVPURelMult", "Relative contribution of PU to jet multiplicity for matched LV; (#Jets-#JetsNoPU)/#Jets", 50, 0., 1.); + meJetsRecLVPURelHt_ = ibook.book1D("JetsRecLVPURelHt", "Relative contribution of PU to scalar sum of Et of jets for matched LV; (Ht-HtNoPU)/HT", 50, 0., 1.); + meJetsRecLVPURelSumPt2_ = ibook.book1D("JetsRecLVPURelSumPt2", "Relative contribution of PU to sum of Pt2 of jets for matched LV; (SumPt2-SumPt2NoPU)/SumPt2", 50, 0., 1.); + meJetsRecLVFakeRelSumPt2_ = ibook.book1D("JetsRecLVFakeRelSumPt2", "Relative contribution of fake tracks to sum of Pt2 of jets for matched LV; (SumPt2-SumPt2NoFake)/SumPt2", 50, 0., 1.); + meJetsRecLVPURelMetPt_ = ibook.book1D("JetsRecLVPURelMetPt", "Relative contribution of PU to Missing Transverse Energy for matched LV; (Met-MetNoPU)/Met", 50, -1., 1.); + meJetsRecLVPURelSumPz_ = ibook.book1D("JetsRecLVPURelSumPz", "Relative contribution of PU to sum of Pz of jets for matched LV; (SumPz-SumPzNoPU)/SumPz", 50, -1., 1.); if (optionalPlots_) { - meJetsPUMult_ = ibook.book1D("JetsPUMult", "Number of PU jets for matched vertices; #PUJets", 50, 0., 100.); - meJetsPUHt_ = ibook.book1D("JetsPUHt", "Scalar sum of Et of PU jets for matched vertices; PUHt [GeV]", 50, -2., 3.); - meJetsPUSumPt2_ = ibook.book1D("JetsPUSumPt2", "Sum of Pt2 of PU jets for matched vertices; PUSumPt2 [GeV2]", 50, -5., 3.); - meJetsPUMetPt_ = ibook.book1D("JetsPUMetPt", "Missing Transverse Energy of PU jets for matched vertices; PUMet [GeV]", 50, -5., 2.); - meJetsPUSumPx_ = ibook.book1D("JetsPUSumPx", "Sum of Px of PU jets for matched vertices; PUSumPx [GeV]", 50, -5., 2.); - meJetsPUSumPy_ = ibook.book1D("JetsPUSumPy", "Sum of Py of PU jets for matched vertices; PUSumPy [GeV]", 50, -5., 2.); - meJetsPUSumPz_ = ibook.book1D("JetsPUSumPz", "Sum of Pz of PU jets for matched vertices; PUSumPz [GeV]", 50, -4., 3.); - - meJetsPURelMultvsMult_ = ibook.bookProfile("JetsPURelMultvsMult", "Relative multiplicity of PU jets vs Number of jets for matched verticess; #Jets; #PUJets/#Jets", 50, 0., 120., 0., 1.,"s"); - meJetsPURelHtvsHt_ = ibook.bookProfile("JetsPURelHtvsHt", "Relative scalar sum of Et of PU jets vs scalar sum of Et for matched vertices; Ht [GeV]; PUHt/HT", 50, 0., 3., 0., 1.,"s"); - meJetsPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsPURelSumPt2vsSumPt2", "Relative sum of Pt2 of PU jets vs sum of Pt2 for matched vertices; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, -1., 4., 0., 1.,"s"); - meJetsFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsFakeRelSumPt2vsSumPt2", "Relative sum of Pt2 of fake jets vs sum of Pt2 for matched vertices; SumPt2 [GeV2]; FakeSumPt2/SumPt2", 50, -1., 4., 0., 1.,"s"); - meJetsPURelMetPtvsMetPt_ = ibook.bookProfile("JetsPURelMetPtvsMetPt", "Relative Missing Transverse Energy of PU jets vs MET for matched vertices; Met [GeV]; PUMet/Met", 50, -2., 2., 0., 1.,"s"); - meJetsPURelSumPxvsSumPx_ = ibook.bookProfile("JetsPURelSumPxvsSumPx", "Relative Sum of Px of PU jets vs Sum of Px for matched vertices; SumPx [GeV]; PUSumPx/SumPx", 50, -2., 2., 0., 1.,"s"); - meJetsPURelSumPyvsSumPy_ = ibook.bookProfile("JetsPURelSumPyvsSumPy", "Relative Sum of Py of PU jets vs Sum of Py for matched vertices; SumPy [GeV]; PUSumPy/SumPy", 50, -2., 2., 0., 1.,"s"); - meJetsPURelSumPzvsSumPz_ = ibook.bookProfile("JetsPURelSumPzvsSumPz", "Relative Sum of Pz of PU jets vs Sum of Pz for matched vertices; SumPz [GeV]; PUSumPz/SumPz", 50, -2., 3., 0., 1.,"s"); - - meJetsRecLVPUMult_ = ibook.book1D("JetsRecLVPUMult", "Number of PU jets for matched LV; #PUJets", 50, 0., 100.); - meJetsRecLVPUHt_ = ibook.book1D("JetsRecLVPUHt", "Scalar sum of Et of PU jets for matched LV; PUHt [GeV]", 50, -2., 3.); - meJetsRecLVPUSumPt2_ = ibook.book1D("JetsRecLVPUSumPt2", "Sum of Pt2 of PU jets for matched LV; PUSumPt2 [GeV2]", 50, -5., 3.); - meJetsRecLVPUMetPt_ = ibook.book1D("JetsRecLVPUMetPt", "Missing Transverse Energy of PU jets for matched LV; PUMet [GeV]", 50, -5., 2.); - meJetsRecLVPUSumPx_ = ibook.book1D("JetsRecLVPUSumPx", "Sum of Px of PU jets for matched LV; PUSumPx [GeV]", 50, -5., 2.); - meJetsRecLVPUSumPy_ = ibook.book1D("JetsRecLVPUSumPy", "Sum of Py of PU jets for matched LV; PUSumPy [GeV]", 50, -5., 2.); - meJetsRecLVPUSumPz_ = ibook.book1D("JetsRecLVPUSumPz", "Sum of Pz of PU jets for matched LV; PUSumPz [GeV]", 50, -4., 3.); - - meJetsRecLVPURelMultvsMult_ = ibook.bookProfile("JetsRecLVPURelMultvsMult", "Relative multiplicity of PU jets vs Number of jets for matched LV; #Jets; #PUJets/#Jets", 50, 0., 120., 0., 1.,"s"); - meJetsRecLVPURelHtvsHt_ = ibook.bookProfile("JetsRecLVPURelHtvsHt", "Relative scalar sum of Et of PU jets vs scalar sum of Et for matched LV; Ht [GeV]; PUHt/HT", 50, 1., 3., 0., 1.,"s"); - meJetsRecLVPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVPURelSumPt2vsSumPt2", "Relative sum of Pt2 of PU jets vs sum of Pt2 for matched LV; SumPt2 [GeV2]; PUSumPt2/SumPt2", 50, 2., 5., 0., 1.,"s"); - meJetsRecLVFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVFakeRelSumPt2vsSumPt2", "Relative sum of Pt2 of fake jets vs sum of Pt2 for matched LV; SumPt2 [GeV2]; FakeSumPt2/SumPt2", 50, 2., 5., 0., 1.,"s"); - meJetsRecLVPURelMetPtvsMetPt_ = ibook.bookProfile("JetsRecLVPURelMetPtvsMetPt", "Relative Missing Transverse Energy of PU jets vs MET for LV vertices; Met [GeV]; PUMet/Met", 50, -3., 2., 0., 1.,"s"); - meJetsRecLVPURelSumPxvsSumPx_ = ibook.bookProfile("JetsRecLVPURelSumPxvsSumPx", "Relative Sum of Px of PU jets vs Sum of Px for matched LV; SumPx [GeV]; PUSumPx/SumPx", 50, -1., 3., 0., 1.,"s"); - meJetsRecLVPURelSumPyvsSumPy_ = ibook.bookProfile("JetsRecLVPURelSumPyvsSumPy", "Relative Sum of Py of PU jets vs Sum of Py for matched LV; SumPy [GeV]; PUSumPy/SumPy", 50, -1., 3., 0., 1.,"s"); - meJetsRecLVPURelSumPzvsSumPz_ = ibook.bookProfile("JetsRecLVPURelSumPzvsSumPz", "Relative Sum of Pz of PU jets vs Sum of Pz for matched LV; SumPz [GeV]; PUSumPz/SumPz", 50, 0., 4., 0., 1.,"s"); + meJetsPUMult_ = ibook.book1D("JetsPUMult", "Contribution of PU to jet multiplicity for matched vertices; #Jets-#JetsNoPU", 50, 0., 100.); + meJetsPUHt_ = ibook.book1D("JetsPUHt", "Contribution of PU to scalar sum of Et of jets for matched vertices; log10(Ht-HtNoPU)", 50, -2., 3.); + meJetsPUSumPt2_ = ibook.book1D("JetsPUSumPt2", "Contribution of PU to sum of Pt2 of jets for matched vertices; log10(sumPt2-SumPt2NoPU)", 50, -3., 3.); + meJetsPUMetPt_ = ibook.book1D("JetsPUMetPt", "Contribution of PU to Missing Transverse Energy for matched vertices; log10(Met-MetNoPU)", 50, -3., 2.); + meJetsPUSumPz_ = ibook.book1D("JetsPUSumPz", "Contribution of PU to sum of Pz of jets for matched vertices; log10(abs(SumPz-SumPzNoPU))", 50, -4., 3.); + + meJetsPURelMultvsMult_ = ibook.bookProfile("JetsPURelMultvsMult", "Relative contribution of PU to jet multiplicity vs number of jets for matched vertices; #Jets; (#Jets-#JetsNoPU)/#Jets", 50, 0., 120., 0., 1.,"s"); + meJetsPURelHtvsHt_ = ibook.bookProfile("JetsPURelHtvsHt", "Relative contribution of PU to scalar sum of Et of jets vs scalar sum of Et for matched vertices; log10(Ht); (Ht-HtNoPU)/HT", 50, 0., 3., 0., 1.,"s"); + meJetsPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsPURelSumPt2vsSumPt2", "Relative contribution of PU to sum of Pt2 of jets vs sum of Pt2 for matched vertices; log10(SumPt2); (SumPt2-SumPt2NoPU)/SumPt2", 50, -1., 4., 0., 1.,"s"); + meJetsFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsFakeRelSumPt2vsSumPt2", "Relative contribution of fake tracks to sum of Pt2 of jets vs sum of Pt2 for matched vertices; log10(SumPt2); (SumPt2-SumPt2NoFake)/SumPt2", 50, -1., 4., 0., 1.,"s"); + meJetsPURelMetPtvsMetPt_ = ibook.bookProfile("JetsPURelMetPtvsMetPt", "Relative contribution of PU to Missing Transverse Energy vs MET for matched vertices; log10(Met); (Met-MetNoPU)/Met", 50, -1., 2., -1., 1.,"s"); + meJetsPURelSumPzvsSumPz_ = ibook.bookProfile("JetsPURelSumPzvsSumPz", "Relative contribution of PU to sum of Pz of jets vs Sum of Pz for matched vertices; log10(abs SumPz); (SumPz-SumPzNoPU)/SumPz", 50, -2., 3., -1., 1.,"s"); + + meJetsRecLVPUMult_ = ibook.book1D("JetsRecLVPUMult", "Contribution of PU to jet multiplicity for matched LV; #Jets-#JetsNoPU", 50, 0., 100.); + meJetsRecLVPUHt_ = ibook.book1D("JetsRecLVPUHt", "Contribution of PU to scalar sum of Et of jets for matched LV; log10(Ht-HtNoPU)", 50, -2., 3.); + meJetsRecLVPUSumPt2_ = ibook.book1D("JetsRecLVPUSumPt2", "Contribution of PU to sum of Pt2 of jets for matched LV; log10(sumPt2-SumPt2NoPU)", 50, -3., 3.); + meJetsRecLVPUMetPt_ = ibook.book1D("JetsRecLVPUMetPt", "Contribution of PU to Missing Transverse Energy for matched LV; log10(Met-MetNoPU)", 50, -3., 2.); + meJetsRecLVPUSumPz_ = ibook.book1D("JetsRecLVPUSumPz", "Contribution of PU to sum of Pz of jets for matched LV; log10(abs(SumPz-SumPzNoPU))", 50, -4., 3.); + + meJetsRecLVPURelMultvsMult_ = ibook.bookProfile("JetsRecLVPURelMultvsMult", "Relative contribution of PU to jet multiplicity vs number of jets for matched vertices; #Jets; (#Jets-#JetsNoPU)/#Jets", 50, 0., 120., 0., 1.,"s"); + meJetsRecLVPURelHtvsHt_ = ibook.bookProfile("JetsRecLVPURelHtvsHt", "Relative contribution of PU to scalar sum of Et of jets vs scalar sum of Et for matched vertices; log10(Ht); (Ht-HtNoPU)/HT", 50, 1.5, 3., 0., 1.,"s"); + meJetsRecLVPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVPURelSumPt2vsSumPt2", "Relative contribution of PU to sum of Pt2 of jets vs sum of Pt2 for matched vertices; log10(SumPt2); (SumPt2-SumPt2NoPU)/SumPt2", 50, 2., 5., 0., 1.,"s"); + meJetsRecLVFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVFakeRelSumPt2vsSumPt2", "Relative contribution of fake tracks to sum of Pt2 of jets vs sum of Pt2 for matched vertices; log10(SumPt2); (SumPt2-SumPt2NoFake)/SumPt2", 50, 2., 5., 0., 1.,"s"); + meJetsRecLVPURelMetPtvsMetPt_ = ibook.bookProfile("JetsRecLVPURelMetPtvsMetPt", "Relative contribution of PU to Missing Transverse Energy vs MET for matched vertices; log10(Met); (Met-MetNoPU)/Met", 50, 0., 2.5, -1., 1.,"s"); + meJetsRecLVPURelSumPzvsSumPz_ = ibook.bookProfile("JetsRecLVPURelSumPzvsSumPz", "Relative contribution of PU to sum of Pz of jets vs Sum of Pz for matched vertices; log10(abs SumPz); (SumPz-SumPzNoPU)/SumPz", 50, 0.5, 3.5, -1., 1.,"s"); } // some tests @@ -1032,17 +978,17 @@ std::pair>*,int> Primary4DVertexVal if (found == r2s_->end()) return std::make_pair (nullptr,-1); - // matched TP equal to any TP of sim vertex + // matched TP equal to any TP of a given sim vertex for (const auto& tp : found->val) { if (std::find_if(vsim->daughterTracks_begin(), vsim->daughterTracks_end(), [&](const TrackingParticleRef& vtp) { return tp.first == vtp; }) != vsim->daughterTracks_end()) return std::make_pair (&tp.first,0); - // matched TP not associated to any daughter track of the sim vertex but having the same eventID (secondary track) + // matched TP not associated to any daughter track of a given sim vertex but having the same eventID (track from secondary vtx) else if (tp.first->eventId().bunchCrossing() == vsim->eventId().bunchCrossing() && tp.first->eventId().event() == vsim->eventId().event()) { return std::make_pair (&tp.first,1); } - // matched TP not associated to the sim vertex (PU track) + // matched TP not associated to any sim vertex of a given simulated event (PU track) else { return std::make_pair (&tp.first,2); } @@ -1086,14 +1032,12 @@ bool Primary4DVertexValidation::select(const reco::Vertex& v, int level) { void Primary4DVertexValidation::observablesFromJets(const std::vector& reco_Tracks, const std::vector& mass_Tracks, const std::vector& category_Tracks, const std::string& skip_Tracks, unsigned int& n_Jets, double& sum_EtJets, double& sum_Pt2Jets, double& met_Pt, - double& sum_PxJets, double& sum_PyJets, double& sum_PzJets) { + double& sum_PzJets) { double sum_PtJets = 0; n_Jets = 0; sum_EtJets = 0; sum_Pt2Jets = 0; met_Pt = 0; - sum_PxJets = 0; - sum_PyJets = 0; sum_PzJets = 0; auto met = LorentzVector(0, 0, 0, 0); std::vector fjInputs_; @@ -1137,8 +1081,6 @@ void Primary4DVertexValidation::observablesFromJets(const std::vector& re auto tp_info = getMatchedTP(*iTrack, simpv.at(iev).sim_vertex).first; int matchCategory = getMatchedTP(*iTrack, simpv.at(iev).sim_vertex).second; - // matched TP equal to any TP of sim vertex + // matched TP equal to any TP of a given sim vertex if (tp_info != nullptr && matchCategory == 0) { getWosWnt(*vertex, *iTrack, sigmat0, BS, wos, wnt); simpv.at(iev).addTrack(iv, wos, wnt); @@ -1636,16 +1578,16 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve double vtsim = simpv.at(iev).t * simUnit_; double wnt = 0, wos = 0; - double PUsumWnt = 0, PUsumWos = 0, SecsumWos = 0, FakesumWos = 0, PUsumPt = 0, PUsumPt2 = 0, PUsumPx = 0, PUsumPy = 0, PUsumPz = 0; - double sumWnt = 0, sumWos = 0, sumPt = 0, sumPt2 = 0, sumPx = 0, sumPy = 0, sumPz = 0; + double PUsumWnt = 0, PUsumWos = 0, SecsumWos = 0, FakesumWos = 0, PUsumPt = 0, PUsumPt2 = 0; + double sumWnt = 0, sumWos = 0, sumPt = 0, sumPt2 = 0; unsigned int nt = 0, PUnt = 0, Fakent = 0; std::vector massVector; std::vector recotracks; std::vector categoryVector; - double sumEtJets = 0, sumPt2Jets = 0, metPt = 0, sumPxJets = 0, sumPyJets = 0, sumPzJets = 0; - double sumEtJetsnoPU = 0, sumPt2JetsnoPU = 0, metPtnoPU = 0, sumPxJetsnoPU = 0, sumPyJetsnoPU = 0, sumPzJetsnoPU = 0; - double sumEtJetsnoFake = 0, sumPt2JetsnoFake = 0, metPtnoFake = 0, sumPxJetsnoFake = 0, sumPyJetsnoFake = 0, sumPzJetsnoFake = 0; + double sumEtJets = 0, sumPt2Jets = 0, metPt = 0, sumPzJets = 0; + double sumEtJetsnoPU = 0, sumPt2JetsnoPU = 0, metPtnoPU = 0, sumPzJetsnoPU = 0; + double sumEtJetsnoFake = 0, sumPt2JetsnoFake = 0, metPtnoFake = 0, sumPzJetsnoFake = 0; unsigned int nJets = 0, nJetsnoPU = 0, nJetsnoFake = 0; for (auto iTrack = vertex->tracks_begin(); iTrack != vertex->tracks_end(); ++iTrack) { if (trackAssoc[*iTrack] == -1) { @@ -1690,17 +1632,17 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve massVector.push_back(mass); recotracks.push_back(**iTrack); getWosWnt(*vertex, *iTrack, sigmat0Safe, BeamSpotH, wos, wnt); - // reco track matched to some TP + // reco track matched to any TP if (tp_info != nullptr) { if (debug_ && selectedLV) { printMatchedRecoTrackInfo(*vertex, *iTrack, *tp_info, matchCategory); } - // matched TP not associated to any daughter track of the sim vertex but having the same eventID (secondary track) + // matched TP not associated to any daughter track of a given sim vertex but having the same eventID (track from secondary vtx) if (matchCategory == 1) { categoryVector.push_back(matchCategory); SecsumWos += wos; } - // matched TP not associated to the sim vertex (PU track) + // matched TP not associated to any sim vertex of a given simulated event (PU track) if (matchCategory == 2) { if (optionalPlots_){ mePUTrackWnt_->Fill(wnt); @@ -1712,9 +1654,6 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve PUsumWos += wos; PUsumPt += (*iTrack)->pt(); PUsumPt2 += ((*iTrack)->pt() * (*iTrack)->pt()); - PUsumPx += (*iTrack)->px(); - PUsumPy += (*iTrack)->py(); - PUsumPz += (*iTrack)->pz(); PUnt++; categoryVector.push_back(2); } @@ -1730,12 +1669,9 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve sumWos += wos; sumPt += (*iTrack)->pt(); sumPt2 += ((*iTrack)->pt() * (*iTrack)->pt()); - sumPx += (*iTrack)->px(); - sumPy += (*iTrack)->py(); - sumPz += (*iTrack)->pz(); } - // matched TP equal to any TP of sim vertex + // matched TP equal to any TP of a given sim vertex if (tp_info != nullptr && matchCategory == 0) { categoryVector.push_back(matchCategory); double mass = (*tp_info)->mass(); @@ -2002,62 +1938,47 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve meFakeTrackRelSumWos_->Fill(FakesumWos/sumWos); mePUTrackRelSumPt_->Fill(PUsumPt/sumPt); mePUTrackRelSumPt2_->Fill(PUsumPt2/sumPt2); - mePUTrackRelSumPx_->Fill(std::abs(PUsumPx)/std::abs(sumPx)); - mePUTrackRelSumPy_->Fill(std::abs(PUsumPy)/std::abs(sumPy)); - mePUTrackRelSumPz_->Fill(std::abs(PUsumPz)/std::abs(sumPz)); - observablesFromJets(recotracks, massVector, categoryVector, "use_allTracks", nJets, sumEtJets, sumPt2Jets, metPt, sumPxJets, sumPyJets, sumPzJets); - observablesFromJets(recotracks, massVector, categoryVector, "skip_Fake", nJetsnoFake, sumEtJetsnoFake, sumPt2JetsnoFake, metPtnoFake, sumPxJetsnoFake, sumPyJetsnoFake, sumPzJetsnoFake); - observablesFromJets(recotracks, massVector, categoryVector, "skip_PU", nJetsnoPU, sumEtJetsnoPU, sumPt2JetsnoPU, metPtnoPU, sumPxJetsnoPU, sumPyJetsnoPU, sumPzJetsnoPU); + observablesFromJets(recotracks, massVector, categoryVector, "use_allTracks", nJets, sumEtJets, sumPt2Jets, metPt, sumPzJets); + observablesFromJets(recotracks, massVector, categoryVector, "skip_Fake", nJetsnoFake, sumEtJetsnoFake, sumPt2JetsnoFake, metPtnoFake, sumPzJetsnoFake); + observablesFromJets(recotracks, massVector, categoryVector, "skip_PU", nJetsnoPU, sumEtJetsnoPU, sumPt2JetsnoPU, metPtnoPU, sumPzJetsnoPU); meJetsPURelMult_->Fill(static_cast(nJets-nJetsnoPU)/nJets); meJetsPURelHt_->Fill((sumEtJets-sumEtJetsnoPU)/sumEtJets); meJetsPURelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); meJetsFakeRelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); meJetsPURelMetPt_->Fill((metPt-metPtnoPU)/metPt); - meJetsPURelSumPx_->Fill(std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); - meJetsPURelSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); - meJetsPURelSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); + meJetsPURelSumPz_->Fill((sumPzJets-sumPzJetsnoPU)/sumPzJets); if (optionalPlots_) { mePUTrackMult_->Fill(PUnt); - mePUTrackSumWnt_->Fill(log10(std::max(0.01,PUsumWnt))); - mePUTrackSumWos_->Fill(log10(std::max(0.1,PUsumWos))); - meSecTrackSumWos_->Fill(log10(std::max(0.1,SecsumWos))); - mePUTrackSumPt_->Fill(log10(std::max(0.01,PUsumPt))); - mePUTrackSumPt2_->Fill(log10(std::max(0.001,PUsumPt2))); - mePUTrackSumPx_->Fill(log10(std::max(0.00001,std::abs(PUsumPx)))); - mePUTrackSumPy_->Fill(log10(std::max(0.00001,std::abs(PUsumPy)))); - mePUTrackSumPz_->Fill(log10(std::max(0.0001,std::abs(PUsumPz)))); + mePUTrackSumWnt_->Fill(log10(std::max(minThrSumWnt_,PUsumWnt))); + mePUTrackSumWos_->Fill(log10(std::max(minThrSumWos_,PUsumWos))); + meSecTrackSumWos_->Fill(log10(std::max(minThrSumWos_,SecsumWos))); + mePUTrackSumPt_->Fill(log10(std::max(minThrSumPt_,PUsumPt))); + mePUTrackSumPt2_->Fill(log10(std::max(minThrSumPt2_,PUsumPt2))); mePUTrackRelMultvsMult_->Fill(nt, static_cast(PUnt)/nt); meFakeTrackRelMultvsMult_->Fill(nt, static_cast(Fakent)/nt); - mePUTrackRelSumWntvsSumWnt_->Fill(log10(std::max(0.01,sumWnt)), PUsumWnt/sumWnt); - mePUTrackRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), PUsumWos/sumWos); - meSecTrackRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), SecsumWos/sumWos); - meFakeTrackRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), FakesumWos/sumWos); - mePUTrackRelSumPtvsSumPt_->Fill(log10(std::max(0.01,sumPt)), PUsumPt/sumPt); - mePUTrackRelSumPt2vsSumPt2_->Fill(log10(std::max(0.001,sumPt2)), PUsumPt2/sumPt2); - mePUTrackRelSumPxvsSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPx))), std::abs(PUsumPx)/std::abs(sumPx)); - mePUTrackRelSumPyvsSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPy))), std::abs(PUsumPy)/std::abs(sumPy)); - mePUTrackRelSumPzvsSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPz))), std::abs(PUsumPz)/std::abs(sumPz)); + mePUTrackRelSumWntvsSumWnt_->Fill(log10(std::max(minThrSumWnt_,sumWnt)), PUsumWnt/sumWnt); + mePUTrackRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), PUsumWos/sumWos); + meSecTrackRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), SecsumWos/sumWos); + meFakeTrackRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), FakesumWos/sumWos); + mePUTrackRelSumPtvsSumPt_->Fill(log10(std::max(minThrSumPt_,sumPt)), PUsumPt/sumPt); + mePUTrackRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2)), PUsumPt2/sumPt2); meJetsPUMult_->Fill(nJets-nJetsnoPU); - meJetsPUHt_->Fill(log10(std::max(0.01,sumEtJets-sumEtJetsnoPU))); - meJetsPUSumPt2_->Fill(log10(std::max(0.00001,sumPt2Jets-sumPt2JetsnoPU))); - meJetsPUMetPt_->Fill(log10(std::max(0.00001,metPt-metPtnoPU))); - meJetsPUSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPxJets-sumPxJetsnoPU)))); - meJetsPUSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPyJets-sumPyJetsnoPU)))); - meJetsPUSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPzJets-sumPzJetsnoPU)))); + meJetsPUHt_->Fill(log10(std::max(minThrSumPt_,sumEtJets-sumEtJetsnoPU))); + meJetsPUSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets-sumPt2JetsnoPU))); + meJetsPUMetPt_->Fill(log10(std::max(minThrMetPt_,metPt-metPtnoPU))); + meJetsPUSumPz_->Fill(log10(std::max(minThrSumPz_,std::abs(sumPzJets-sumPzJetsnoPU)))); meJetsPURelMultvsMult_->Fill(nJets, static_cast(nJets-nJetsnoPU)/nJets); - meJetsPURelHtvsHt_->Fill(log10(std::max(0.01,sumEtJets)), (sumEtJets-sumEtJetsnoPU)/sumEtJets); - meJetsPURelSumPt2vsSumPt2_->Fill(log10(std::max(0.0001,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); - meJetsFakeRelSumPt2vsSumPt2_->Fill(log10(std::max(0.0001,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); - meJetsPURelMetPtvsMetPt_->Fill(log10(std::max(0.0001,metPt)), (metPt-metPtnoPU)/metPt); - meJetsPURelSumPxvsSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPxJets))), std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); - meJetsPURelSumPyvsSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPyJets))), std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); - meJetsPURelSumPzvsSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPzJets))), std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); + meJetsPURelHtvsHt_->Fill(log10(std::max(minThrSumPt_,sumEtJets)), (sumEtJets-sumEtJetsnoPU)/sumEtJets); + meJetsPURelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); + meJetsFakeRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); + meJetsPURelMetPtvsMetPt_->Fill(log10(std::max(minThrMetPt_,metPt)), (metPt-metPtnoPU)/metPt); + meJetsPURelSumPzvsSumPz_->Fill(log10(std::max(minThrSumPz_,std::abs(sumPzJets))), (sumPzJets-sumPzJetsnoPU)/sumPzJets); } if (selectedLV) { mePUTrackRecLVRelMult_->Fill(static_cast(PUnt)/nt); @@ -2068,18 +1989,13 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve meFakeTrackRecLVRelSumWos_->Fill(FakesumWos/sumWos); mePUTrackRecLVRelSumPt_->Fill(PUsumPt/sumPt); mePUTrackRecLVRelSumPt2_->Fill(PUsumPt2/sumPt2); - mePUTrackRecLVRelSumPx_->Fill(std::abs(PUsumPx)/std::abs(sumPx)); - mePUTrackRecLVRelSumPy_->Fill(std::abs(PUsumPy)/std::abs(sumPy)); - mePUTrackRecLVRelSumPz_->Fill(std::abs(PUsumPz)/std::abs(sumPz)); meJetsRecLVPURelMult_->Fill(static_cast(nJets-nJetsnoPU)/nJets); meJetsRecLVPURelHt_->Fill((sumEtJets-sumEtJetsnoPU)/sumEtJets); meJetsRecLVPURelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); meJetsRecLVFakeRelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); meJetsRecLVPURelMetPt_->Fill((metPt-metPtnoPU)/metPt); - meJetsRecLVPURelSumPx_->Fill(std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); - meJetsRecLVPURelSumPy_->Fill(std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); - meJetsRecLVPURelSumPz_->Fill(std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); + meJetsRecLVPURelSumPz_->Fill((sumPzJets-sumPzJetsnoPU)/sumPzJets); if (debug_){ edm::LogPrint("Primary4DVertexValidation") << "#PUTrks = " << PUnt << " #Trks = " << nt << " PURelMult = " @@ -2087,49 +2003,45 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve edm::LogPrint("Primary4DVertexValidation") << "PUsumWnt = " << std::setprecision(3) << PUsumWnt << " sumWnt = " << std::setprecision(3) << sumWnt << " PURelsumWnt = " << std::setprecision(3) << PUsumWnt/sumWnt; + edm::LogPrint("Primary4DVertexValidation") << "PUsumWos = " << std::setprecision(3) << PUsumWos << " sumWos = " + << std::setprecision(3) << sumWos << " PURelsumWos = " + << std::setprecision(3) << PUsumWos/sumWos; + edm::LogPrint("Primary4DVertexValidation") << "PuSumPt = " << std::setprecision(3) << PUsumPt << " SumPt = " + << std::setprecision(4) << sumPt << " PURelSumPt = " + << std::setprecision(3) << PUsumPt/sumPt; edm::LogPrint("Primary4DVertexValidation") << "PuSumPt2 = " << std::setprecision(3) << PUsumPt2 << " SumPt2 = " << std::setprecision(4) << sumPt2 << " PURelSumPt2 = " << std::setprecision(3) << PUsumPt2/sumPt2; } if (optionalPlots_) { mePUTrackRecLVMult_->Fill(PUnt); - mePUTrackRecLVSumWnt_->Fill(log10(std::max(0.01,PUsumWnt))); - mePUTrackRecLVSumWos_->Fill(log10(std::max(0.1,PUsumWos))); - meSecTrackRecLVSumWos_->Fill(log10(std::max(0.1,PUsumWos))); - mePUTrackRecLVSumPt_->Fill(log10(std::max(0.01,PUsumPt))); - mePUTrackRecLVSumPt2_->Fill(log10(std::max(0.001,PUsumPt2))); - mePUTrackRecLVSumPx_->Fill(log10(std::max(0.00001,std::abs(PUsumPx)))); - mePUTrackRecLVSumPy_->Fill(log10(std::max(0.00001,std::abs(PUsumPy)))); - mePUTrackRecLVSumPz_->Fill(log10(std::max(0.0001,std::abs(PUsumPz)))); + mePUTrackRecLVSumWnt_->Fill(log10(std::max(minThrSumWnt_,PUsumWnt))); + mePUTrackRecLVSumWos_->Fill(log10(std::max(minThrSumWos_,PUsumWos))); + meSecTrackRecLVSumWos_->Fill(log10(std::max(minThrSumWos_,PUsumWos))); + mePUTrackRecLVSumPt_->Fill(log10(std::max(minThrSumPt_,PUsumPt))); + mePUTrackRecLVSumPt2_->Fill(log10(std::max(minThrSumPt2_,PUsumPt2))); mePUTrackRecLVRelMultvsMult_->Fill(nt, static_cast(PUnt)/nt); meFakeTrackRecLVRelMultvsMult_->Fill(nt, static_cast(Fakent)/nt); - mePUTrackRecLVRelSumWntvsSumWnt_->Fill(log10(std::max(0.01,sumWnt)), PUsumWnt/sumWnt); - mePUTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), PUsumWos/sumWos); - meSecTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), SecsumWos/sumWos); - meFakeTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(0.1,sumWos)), FakesumWos/sumWos); - mePUTrackRecLVRelSumPtvsSumPt_->Fill(log10(std::max(0.01,sumPt)), PUsumPt/sumPt); - mePUTrackRecLVRelSumPt2vsSumPt2_->Fill(log10(std::max(0.001,sumPt2)), PUsumPt2/sumPt2); - mePUTrackRecLVRelSumPxvsSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPx))), std::abs(PUsumPx)/std::abs(sumPx)); - mePUTrackRecLVRelSumPyvsSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPy))), std::abs(PUsumPy)/std::abs(sumPy)); - mePUTrackRecLVRelSumPzvsSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPz))), std::abs(PUsumPz)/std::abs(sumPz)); + mePUTrackRecLVRelSumWntvsSumWnt_->Fill(log10(std::max(minThrSumWnt_,sumWnt)), PUsumWnt/sumWnt); + mePUTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), PUsumWos/sumWos); + meSecTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), SecsumWos/sumWos); + meFakeTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), FakesumWos/sumWos); + mePUTrackRecLVRelSumPtvsSumPt_->Fill(log10(std::max(minThrSumPt_,sumPt)), PUsumPt/sumPt); + mePUTrackRecLVRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2)), PUsumPt2/sumPt2); meJetsRecLVPUMult_->Fill(nJets-nJetsnoPU); - meJetsRecLVPUHt_->Fill(log10(std::max(0.01,sumEtJets-sumEtJetsnoPU))); - meJetsRecLVPUSumPt2_->Fill(log10(std::max(0.00001,sumPt2Jets-sumPt2JetsnoPU))); - meJetsRecLVPUMetPt_->Fill(log10(std::max(0.00001,metPt-metPtnoPU))); - meJetsRecLVPUSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPxJets-sumPxJetsnoPU)))); - meJetsRecLVPUSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPyJets-sumPyJetsnoPU)))); - meJetsRecLVPUSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPzJets-sumPzJetsnoPU)))); + meJetsRecLVPUHt_->Fill(log10(std::max(minThrSumPt_,sumEtJets-sumEtJetsnoPU))); + meJetsRecLVPUSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets-sumPt2JetsnoPU))); + meJetsRecLVPUMetPt_->Fill(log10(std::max(minThrMetPt_,metPt-metPtnoPU))); + meJetsRecLVPUSumPz_->Fill(log10(std::max(minThrSumPz_,std::abs(sumPzJets-sumPzJetsnoPU)))); meJetsRecLVPURelMultvsMult_->Fill(nJets, static_cast(nJets-nJetsnoPU)/nJets); - meJetsRecLVPURelHtvsHt_->Fill(log10(std::max(0.01,sumEtJets)), (sumEtJets-sumEtJetsnoPU)/sumEtJets); - meJetsRecLVPURelSumPt2vsSumPt2_->Fill(log10(std::max(0.0001,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); - meJetsRecLVFakeRelSumPt2vsSumPt2_->Fill(log10(std::max(0.0001,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); - meJetsRecLVPURelMetPtvsMetPt_->Fill(log10(std::max(0.0001,metPt)), (metPt-metPtnoPU)/metPt); - meJetsRecLVPURelSumPxvsSumPx_->Fill(log10(std::max(0.00001,std::abs(sumPxJets))), std::abs(sumPxJets-sumPxJetsnoPU)/std::abs(sumPxJets)); - meJetsRecLVPURelSumPyvsSumPy_->Fill(log10(std::max(0.00001,std::abs(sumPyJets))), std::abs(sumPyJets-sumPyJetsnoPU)/std::abs(sumPyJets)); - meJetsRecLVPURelSumPzvsSumPz_->Fill(log10(std::max(0.0001,std::abs(sumPzJets))), std::abs(sumPzJets-sumPzJetsnoPU)/std::abs(sumPzJets)); + meJetsRecLVPURelHtvsHt_->Fill(log10(std::max(minThrSumPt_,sumEtJets)), (sumEtJets-sumEtJetsnoPU)/sumEtJets); + meJetsRecLVPURelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); + meJetsRecLVFakeRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); + meJetsRecLVPURelMetPtvsMetPt_->Fill(log10(std::max(minThrMetPt_,metPt)), (metPt-metPtnoPU)/metPt); + meJetsRecLVPURelSumPzvsSumPz_->Fill(log10(std::max(minThrSumPz_,std::abs(sumPzJets))), (sumPzJets-sumPzJetsnoPU)/sumPzJets); } } } From b0673be83e40c1d0243b569440cad4bc853959fe Mon Sep 17 00:00:00 2001 From: Raffaele Delli Gatti Date: Wed, 13 Mar 2024 15:25:48 +0100 Subject: [PATCH 6/7] Switch statement instead of if logic, edm::isNotFinite instead of std::isnan --- .../plugins/Primary4DVertexValidation.cc | 22 +++++++++++++------ 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc index 887a19117ad89..35ae4f6d17b41 100644 --- a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc +++ b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc @@ -251,9 +251,9 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { static constexpr double minThrSumWnt_ = 0.01; // min threshold for filling histograms with logarithmic scale static constexpr double minThrSumWos_ = 0.1; static constexpr double minThrSumPt_ = 0.01; - static constexpr double minThrSumPt2_ = 0.001; - static constexpr double minThrMetPt_ = 0.001; - static constexpr double minThrSumPz_ = 0.0001; + static constexpr double minThrSumPt2_ = 1.e-3; + static constexpr double minThrMetPt_ = 1.e-3; + static constexpr double minThrSumPz_ = 1.e-4; static constexpr float c_cm_ns = geant_units::operators::convertMmToCm(CLHEP::c_light); // [mm/ns] -> [cm/ns] @@ -1104,7 +1104,7 @@ void Primary4DVertexValidation::isParticle(const reco::TrackBaseRef& recoTrack, is_P = false; if (probPi[recoTrack] == -1) { no_PIDtype = 1; - } else if (std::isnan(probPi[recoTrack])) { + } else if (edm::isNotFinite(probPi[recoTrack])) { no_PIDtype = 2; } else if (probPi[recoTrack] == 1 && probK[recoTrack] == 0 && probP[recoTrack] == 0) { no_PIDtype = 3; @@ -2263,9 +2263,17 @@ void Primary4DVertexValidation::printMatchedRecoTrackInfo(const reco::Vertex& vt const TrackingParticleRef& tp, const unsigned int& categ) { std::string strTrk; - if (categ == 0) strTrk = "Reco_Track:"; - if (categ == 1) strTrk = "SecRecoTrk:"; - if (categ == 2) strTrk = "PU_RecoTrk:"; + switch (categ) { + case 0: + strTrk = "Reco_Track:"; + break; + case 1: + strTrk = "SecRecoTrk:"; + break; + case 2: + strTrk = "PU_RecoTrk:"; + break; + } edm::LogPrint("Primary4DVertexValidation") << strTrk << " w =" << std::setw(6) << std::setprecision(2) << vtx.trackWeight(trk) << " pt =" << std::setw(6) << std::setprecision(2) << trk->pt() << " eta =" From 42b0c6da027009a8d304a669b756367925f8c83e Mon Sep 17 00:00:00 2001 From: Raffaele Delli Gatti Date: Wed, 13 Mar 2024 15:39:07 +0100 Subject: [PATCH 7/7] code-format applyed --- .../plugins/Primary4DVertexValidation.cc | 968 +++++++++++++----- 1 file changed, 701 insertions(+), 267 deletions(-) diff --git a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc index 35ae4f6d17b41..001725e7951f9 100644 --- a/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc +++ b/Validation/MtdValidation/plugins/Primary4DVertexValidation.cc @@ -212,19 +212,43 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { const edm::ValueMap&, const edm::Handle&); bool matchRecoTrack2SimSignal(const reco::TrackBaseRef&); - std::pair>*,int> getMatchedTP(const reco::TrackBaseRef&, const TrackingVertexRef&); + std::pair>*, int> getMatchedTP(const reco::TrackBaseRef&, + const TrackingVertexRef&); double timeFromTrueMass(double, double, double, double); bool select(const reco::Vertex&, int level = 0); - void observablesFromJets(const std::vector&, const std::vector&, const std::vector&, - const std::string&, unsigned int&, double&, double&, double&, double&); - void isParticle(const reco::TrackBaseRef&, const edm::ValueMap&, const edm::ValueMap&, - const edm::ValueMap&, unsigned int&, bool&, bool&, bool&, bool&); - void getWosWnt(const reco::Vertex&, const reco::TrackBaseRef&, const edm::ValueMap&, const edm::Handle&, double&, double&); + void observablesFromJets(const std::vector&, + const std::vector&, + const std::vector&, + const std::string&, + unsigned int&, + double&, + double&, + double&, + double&); + void isParticle(const reco::TrackBaseRef&, + const edm::ValueMap&, + const edm::ValueMap&, + const edm::ValueMap&, + unsigned int&, + bool&, + bool&, + bool&, + bool&); + void getWosWnt(const reco::Vertex&, + const reco::TrackBaseRef&, + const edm::ValueMap&, + const edm::Handle&, + double&, + double&); std::vector getSimPVs(const edm::Handle&); std::vector getRecoPVs(const edm::Handle>&); - void printMatchedRecoTrackInfo(const reco::Vertex&, const reco::TrackBaseRef&, const TrackingParticleRef&, const unsigned int&); - void printSimVtxRecoVtxInfo(const struct Primary4DVertexValidation::simPrimaryVertex&, const struct Primary4DVertexValidation::recoPrimaryVertex&); + void printMatchedRecoTrackInfo(const reco::Vertex&, + const reco::TrackBaseRef&, + const TrackingParticleRef&, + const unsigned int&); + void printSimVtxRecoVtxInfo(const struct Primary4DVertexValidation::simPrimaryVertex&, + const struct Primary4DVertexValidation::recoPrimaryVertex&); const bool mvaTPSel(const TrackingParticle&); const bool mvaRecSel(const reco::TrackBase&, const reco::Vertex&, const double&, const double&); @@ -247,8 +271,8 @@ class Primary4DVertexValidation : public DQMEDAnalyzer { static constexpr double trackMaxBtlEta_ = 1.5; static constexpr double trackMinEtlEta_ = 1.6; static constexpr double trackMaxEtlEta_ = 3.; - static constexpr double tol_ = 1.e-4; // tolerance on reconstructed track time, [ns] - static constexpr double minThrSumWnt_ = 0.01; // min threshold for filling histograms with logarithmic scale + static constexpr double tol_ = 1.e-4; // tolerance on reconstructed track time, [ns] + static constexpr double minThrSumWnt_ = 0.01; // min threshold for filling histograms with logarithmic scale static constexpr double minThrSumWos_ = 0.1; static constexpr double minThrSumPt_ = 0.01; static constexpr double minThrSumPt2_ = 1.e-3; @@ -656,100 +680,470 @@ void Primary4DVertexValidation::bookHistograms(DQMStore::IBooker& ibook, meRecPVT_ = ibook.book1D("recPVT", "#Rec vertices/10 ps", 200, -1., 1.); meSimPVZ_ = ibook.book1D("simPVZ", "Weighted #Sim vertices/mm", 400, -20., 20.); - mePUTrackRelMult_ = ibook.book1D("PUTrackRelMult", "Relative multiplicity of PU tracks for matched vertices; #PUTrks/#Trks", 50, 0., 1.); - meFakeTrackRelMult_ = ibook.book1D("FakeTrackRelMult", "Relative multiplicity of fake tracks for matched vertices; #fakeTrks/#Trks", 50, 0., 1.); - mePUTrackRelSumWnt_ = ibook.book1D("PUTrackRelSumWnt", "Relative Sum of wnt of PU tracks for matched vertices; PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 1.); - mePUTrackRelSumWos_ = ibook.book1D("PUTrackRelSumWos", "Relative Sum of wos of PU tracks for matched vertices; PUSumWos/SumWos", 50, 0., 1.); - meSecTrackRelSumWos_ = ibook.book1D("SecTrackRelSumWos", "Relative Sum of wos of tracks from secondary vtx for matched vertices; SecSumWos/SumWos", 50, 0., 1.); - meFakeTrackRelSumWos_ = ibook.book1D("FakeTrackRelSumWos", "Relative Sum of wos of fake tracks for matched vertices; FakeSumWos/SumWos", 50, 0., 1.); - mePUTrackRelSumPt_ = ibook.book1D("PUTrackRelSumPt", "Relative Sum of Pt of PU tracks for matched vertices; PUSumPt/SumPt", 50, 0., 1.); - mePUTrackRelSumPt2_ = ibook.book1D("PUTrackRelSumPt2", "Relative Sum of Pt2 for PU tracks for matched vertices; PUSumPt2/SumPt2", 50, 0., 1.); - - mePUTrackRecLVRelMult_ = ibook.book1D("PUTrackRecLVRelMult", "Relative multiplicity of PU tracks for matched LV; #PUTrks/#Trks", 50, 0., 1.); - meFakeTrackRecLVRelMult_ = ibook.book1D("FakeTrackRecLVRelMult", "Relative multiplicity of fake tracks for matched LV; #FakeTrks/#Trks", 50, 0., 1.); - mePUTrackRecLVRelSumWnt_ = ibook.book1D("PUTrackRecLVRelSumWnt", "Relative Sum of Wnt of PU tracks for matched LV; PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 1.); - mePUTrackRecLVRelSumWos_ = ibook.book1D("PUTrackRecLVRelSumWos", "Relative Sum of Wos of PU tracks for matched LV; PUSumWos/SumWos", 50, 0., 1.); - meSecTrackRecLVRelSumWos_ = ibook.book1D("SecTrackRecLVRelSumWos", "Relative Sum of wos of tracks from secondary vtx for matched LV; SecSumWos/SumWos", 50, 0., 1.); - meFakeTrackRecLVRelSumWos_ = ibook.book1D("FakeTrackRecLVRelSumWos", "Relative Sum of wos of fake tracks for matched LV; FakeSumWos/SumWos", 50, 0., 1.); - mePUTrackRecLVRelSumPt_ = ibook.book1D("PUTrackRecLVRelSumPt", "Relative Sum of Pt of PU tracks for matched LV; PUSumPt/SumPt", 50, 0., 1.); - mePUTrackRecLVRelSumPt2_ = ibook.book1D("PUTrackRecLVRelSumPt2", "Relative Sum of Pt2 of PU tracks for matched LV; PUSumPt2/SumPt2", 50, 0., 1.); + mePUTrackRelMult_ = ibook.book1D( + "PUTrackRelMult", "Relative multiplicity of PU tracks for matched vertices; #PUTrks/#Trks", 50, 0., 1.); + meFakeTrackRelMult_ = ibook.book1D( + "FakeTrackRelMult", "Relative multiplicity of fake tracks for matched vertices; #fakeTrks/#Trks", 50, 0., 1.); + mePUTrackRelSumWnt_ = + ibook.book1D("PUTrackRelSumWnt", + "Relative Sum of wnt of PU tracks for matched vertices; PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", + 50, + 0., + 1.); + mePUTrackRelSumWos_ = ibook.book1D( + "PUTrackRelSumWos", "Relative Sum of wos of PU tracks for matched vertices; PUSumWos/SumWos", 50, 0., 1.); + meSecTrackRelSumWos_ = + ibook.book1D("SecTrackRelSumWos", + "Relative Sum of wos of tracks from secondary vtx for matched vertices; SecSumWos/SumWos", + 50, + 0., + 1.); + meFakeTrackRelSumWos_ = ibook.book1D( + "FakeTrackRelSumWos", "Relative Sum of wos of fake tracks for matched vertices; FakeSumWos/SumWos", 50, 0., 1.); + mePUTrackRelSumPt_ = ibook.book1D( + "PUTrackRelSumPt", "Relative Sum of Pt of PU tracks for matched vertices; PUSumPt/SumPt", 50, 0., 1.); + mePUTrackRelSumPt2_ = ibook.book1D( + "PUTrackRelSumPt2", "Relative Sum of Pt2 for PU tracks for matched vertices; PUSumPt2/SumPt2", 50, 0., 1.); + + mePUTrackRecLVRelMult_ = ibook.book1D( + "PUTrackRecLVRelMult", "Relative multiplicity of PU tracks for matched LV; #PUTrks/#Trks", 50, 0., 1.); + meFakeTrackRecLVRelMult_ = ibook.book1D( + "FakeTrackRecLVRelMult", "Relative multiplicity of fake tracks for matched LV; #FakeTrks/#Trks", 50, 0., 1.); + mePUTrackRecLVRelSumWnt_ = + ibook.book1D("PUTrackRecLVRelSumWnt", + "Relative Sum of Wnt of PU tracks for matched LV; PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", + 50, + 0., + 1.); + mePUTrackRecLVRelSumWos_ = ibook.book1D( + "PUTrackRecLVRelSumWos", "Relative Sum of Wos of PU tracks for matched LV; PUSumWos/SumWos", 50, 0., 1.); + meSecTrackRecLVRelSumWos_ = + ibook.book1D("SecTrackRecLVRelSumWos", + "Relative Sum of wos of tracks from secondary vtx for matched LV; SecSumWos/SumWos", + 50, + 0., + 1.); + meFakeTrackRecLVRelSumWos_ = ibook.book1D( + "FakeTrackRecLVRelSumWos", "Relative Sum of wos of fake tracks for matched LV; FakeSumWos/SumWos", 50, 0., 1.); + mePUTrackRecLVRelSumPt_ = + ibook.book1D("PUTrackRecLVRelSumPt", "Relative Sum of Pt of PU tracks for matched LV; PUSumPt/SumPt", 50, 0., 1.); + mePUTrackRecLVRelSumPt2_ = ibook.book1D( + "PUTrackRecLVRelSumPt2", "Relative Sum of Pt2 of PU tracks for matched LV; PUSumPt2/SumPt2", 50, 0., 1.); if (optionalPlots_) { mePUTrackMult_ = ibook.book1D("PUTrackMult", "Number of PU tracks for matched vertices; #PUTrks", 50, 0., 100.); mePUTrackWnt_ = ibook.book1D("PUTrackWnt", "Wnt of PU tracks for matched vertices; PUTrkW*min(Pt, 1.)", 50, 0., 1.); - mePUTrackSumWnt_ = ibook.book1D("PUTrackSumWnt", "Sum of wnt of PU tracks for matched vertices; log10(PUSumW*min(Pt, 1.))", 50, -2., 3.); - mePUTrackSumWos_ = ibook.book1D("PUTrackSumWos", "Sum of wos of PU tracks for matched vertices; log10(PUSumWos)", 50, -1., 7.); - meSecTrackSumWos_ = ibook.book1D("SecTrackSumWos", "Sum of wos of tracks from secondary vtx for matched vertices; log10(SecSumWos)", 50, -1., 7.); - mePUTrackSumPt_ = ibook.book1D("PUTrackSumPt", "Sum of Pt of PU tracks for matched vertices; log10(PUSumPt)", 50, -2., 3.); - mePUTrackSumPt2_ = ibook.book1D("PUTrackSumPt2", "Sum of Pt2 of PU tracks for matched vertices; log10(PUSumPt2)", 50, -3., 3.); - - mePUTrackRelMultvsMult_ = ibook.bookProfile("PUTrackRelMultvsMult", "Relative PU multiplicity vs Number of tracks for matched vertices; #Trks; #PUTrks/#Trks", 50, 0., 200., 0., 1.,"s"); - meFakeTrackRelMultvsMult_ = ibook.bookProfile("FakeTrackRelMultvsMult", "Relative multiplicity of fake tracks vs Number of tracks for matched vertices; #Trks; #FakeTrks/#Trks", 50, 0., 200., 0., 1.,"s"); - mePUTrackRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched vertices; log10(SumW*min(Pt, 1.)); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 0., 2.5, 0., 1.,"s"); - mePUTrackRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; log10(SumWos); PUSumWos/SumWos", 50, 2.5, 7., 0., 1.,"s"); - meSecTrackRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRelSumWosvsSumWos", "Relative Sum of Wos of tracks from secondary vtx vs Sum of Wos of tracks for matched vertices; log10(SumWos); SecSumWos/SumWos", 50, 2., 7., 0., 1.,"s"); - meFakeTrackRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; log10(SumWos); FakeSumWos/SumWos", 50, 2.5, 7.5, 0., 1.,"s"); - mePUTrackRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched vertices; log10(SumPt); PUSumPt/SumPt", 50, 0., 3., 0., 1.,"s"); - mePUTrackRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of Pt2 of tracks for matched vertices; log10(SumPt2); PUSumPt2/SumPt2", 50, 0., 4., 0., 1.,"s"); + mePUTrackSumWnt_ = ibook.book1D( + "PUTrackSumWnt", "Sum of wnt of PU tracks for matched vertices; log10(PUSumW*min(Pt, 1.))", 50, -2., 3.); + mePUTrackSumWos_ = + ibook.book1D("PUTrackSumWos", "Sum of wos of PU tracks for matched vertices; log10(PUSumWos)", 50, -1., 7.); + meSecTrackSumWos_ = ibook.book1D( + "SecTrackSumWos", "Sum of wos of tracks from secondary vtx for matched vertices; log10(SecSumWos)", 50, -1., 7.); + mePUTrackSumPt_ = + ibook.book1D("PUTrackSumPt", "Sum of Pt of PU tracks for matched vertices; log10(PUSumPt)", 50, -2., 3.); + mePUTrackSumPt2_ = + ibook.book1D("PUTrackSumPt2", "Sum of Pt2 of PU tracks for matched vertices; log10(PUSumPt2)", 50, -3., 3.); + + mePUTrackRelMultvsMult_ = + ibook.bookProfile("PUTrackRelMultvsMult", + "Relative PU multiplicity vs Number of tracks for matched vertices; #Trks; #PUTrks/#Trks", + 50, + 0., + 200., + 0., + 1., + "s"); + meFakeTrackRelMultvsMult_ = ibook.bookProfile( + "FakeTrackRelMultvsMult", + "Relative multiplicity of fake tracks vs Number of tracks for matched vertices; #Trks; #FakeTrks/#Trks", + 50, + 0., + 200., + 0., + 1., + "s"); + mePUTrackRelSumWntvsSumWnt_ = + ibook.bookProfile("PUTrackRelSumWntvsSumWnt", + "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched vertices; log10(SumW*min(Pt, " + "1.)); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", + 50, + 0., + 2.5, + 0., + 1., + "s"); + mePUTrackRelSumWosvsSumWos_ = ibook.bookProfile( + "PUTrackRelSumWosvsSumWos", + "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; log10(SumWos); PUSumWos/SumWos", + 50, + 2.5, + 7., + 0., + 1., + "s"); + meSecTrackRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRelSumWosvsSumWos", + "Relative Sum of Wos of tracks from secondary vtx vs Sum of Wos " + "of tracks for matched vertices; log10(SumWos); SecSumWos/SumWos", + 50, + 2., + 7., + 0., + 1., + "s"); + meFakeTrackRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRelSumWosvsSumWos", + "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for " + "matched vertices; log10(SumWos); FakeSumWos/SumWos", + 50, + 2.5, + 7.5, + 0., + 1., + "s"); + mePUTrackRelSumPtvsSumPt_ = ibook.bookProfile( + "PUTrackRelSumPtvsSumPt", + "Relative PU Sum of Pt vs Sum of Pt of tracks for matched vertices; log10(SumPt); PUSumPt/SumPt", + 50, + 0., + 3., + 0., + 1., + "s"); + mePUTrackRelSumPt2vsSumPt2_ = ibook.bookProfile( + "PUTrackRelSumPt2vsSumPt2", + "Relative PU Sum of Pt2 vs Sum of Pt2 of tracks for matched vertices; log10(SumPt2); PUSumPt2/SumPt2", + 50, + 0., + 4., + 0., + 1., + "s"); mePUTrackRecLVMult_ = ibook.book1D("PUTrackRecLVMult", "Number of PU tracks for matched LV; #PUTrks", 50, 0., 100.); - mePUTrackRecLVWnt_ = ibook.book1D("PUTrackRecLVWnt", "Wnt of PU tracks for matched LV; PUTrkW*min(Pt, 1.)", 50, 0., 1.); - mePUTrackRecLVSumWnt_ = ibook.book1D("PUTrackRecLVSumWnt", "Sum of wnt of PU tracks for matched LV; log10(PUSumW*min(Pt, 1.))", 50, -2., 3.); - mePUTrackRecLVSumWos_ = ibook.book1D("PUTrackRecLVSumWos", "Sum of wos of PU tracks for matched LV; log10(PUSumWos)", 50, -1., 7.); - meSecTrackRecLVSumWos_ = ibook.book1D("SecTrackRecLVSumWos", "Sum of wos of tracks from secondary vtx for matched LV; log10(SecSumWos)", 50, -1., 7.); - mePUTrackRecLVSumPt_ = ibook.book1D("PUTrackRecLVSumPt", "Sum of Pt of PU tracks for matched LV; log10(PUSumPt)", 50, -2., 3.); - mePUTrackRecLVSumPt2_ = ibook.book1D("PUTrackRecLVSumPt2", "Sum of Pt2 of PU tracks for matched LV; log10(PUSumPt2)", 50, -3., 3.); - - mePUTrackRecLVRelMultvsMult_ = ibook.bookProfile("PUTrackRecLVRelMultvsMult", "Relative PU multiplicity vs Number of tracks for matched LV; #Trks; #PUTrks/#Trks", 50, 0., 200., 0., 1.,"s"); - meFakeTrackRecLVRelMultvsMult_ = ibook.bookProfile("FakeTrackRecLVRelMultvsMult", "Relative multiplicity of fake tracks vs Number of tracks for matched LV; #Trks; #FakeTrks/#Trks", 50, 0., 200., 0., 1.,"s"); - mePUTrackRecLVRelSumWntvsSumWnt_ = ibook.bookProfile("PUTrackRecLVRelSumWntvsSumWnt", "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched LV; log10(SumW*min(Pt, 1.)); PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", 50, 1., 2.3, 0., 1.,"s"); - mePUTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("PUTrackRecLVRelSumWosvsSumWos", "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; log10(SumWos); PUSumWos/SumWos", 50, 5.5, 7., 0., 1.,"s"); - meSecTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("SecTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of tracks from secondary vtx vs Sum of Wos of tracks for matched vertices; log10(SumWos); SecSumWos/SumWos", 50, 5.5, 7., 0., 1.,"s"); - meFakeTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRecLVRelSumWosvsSumWos", "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks for matched vertices; log10(SumWos); FakeSumWos/SumWos", 50, 5.5, 7., 0., 1.,"s"); - mePUTrackRecLVRelSumPtvsSumPt_ = ibook.bookProfile("PUTrackRecLVRelSumPtvsSumPt", "Relative PU Sum of Pt vs Sum of Pt of tracks for matched LV; log10(SumPt); PUSumPt/SumPt", 50, 1.4, 3., 0., 1.,"s"); - mePUTrackRecLVRelSumPt2vsSumPt2_ = ibook.bookProfile("PUTrackRecLVRelSumPt2vsSumPt2", "Relative PU Sum of Pt2 vs Sum of tracks for matched LV; log10(SumPt2); PUSumPt2/SumPt2", 50, 2., 4., 0., 1.,"s"); + mePUTrackRecLVWnt_ = + ibook.book1D("PUTrackRecLVWnt", "Wnt of PU tracks for matched LV; PUTrkW*min(Pt, 1.)", 50, 0., 1.); + mePUTrackRecLVSumWnt_ = ibook.book1D( + "PUTrackRecLVSumWnt", "Sum of wnt of PU tracks for matched LV; log10(PUSumW*min(Pt, 1.))", 50, -2., 3.); + mePUTrackRecLVSumWos_ = + ibook.book1D("PUTrackRecLVSumWos", "Sum of wos of PU tracks for matched LV; log10(PUSumWos)", 50, -1., 7.); + meSecTrackRecLVSumWos_ = ibook.book1D( + "SecTrackRecLVSumWos", "Sum of wos of tracks from secondary vtx for matched LV; log10(SecSumWos)", 50, -1., 7.); + mePUTrackRecLVSumPt_ = + ibook.book1D("PUTrackRecLVSumPt", "Sum of Pt of PU tracks for matched LV; log10(PUSumPt)", 50, -2., 3.); + mePUTrackRecLVSumPt2_ = + ibook.book1D("PUTrackRecLVSumPt2", "Sum of Pt2 of PU tracks for matched LV; log10(PUSumPt2)", 50, -3., 3.); + + mePUTrackRecLVRelMultvsMult_ = + ibook.bookProfile("PUTrackRecLVRelMultvsMult", + "Relative PU multiplicity vs Number of tracks for matched LV; #Trks; #PUTrks/#Trks", + 50, + 0., + 200., + 0., + 1., + "s"); + meFakeTrackRecLVRelMultvsMult_ = ibook.bookProfile( + "FakeTrackRecLVRelMultvsMult", + "Relative multiplicity of fake tracks vs Number of tracks for matched LV; #Trks; #FakeTrks/#Trks", + 50, + 0., + 200., + 0., + 1., + "s"); + mePUTrackRecLVRelSumWntvsSumWnt_ = + ibook.bookProfile("PUTrackRecLVRelSumWntvsSumWnt", + "Relative PU Sum of Wnt vs Sum of Wnt of tracks for matched LV; log10(SumW*min(Pt, 1.)); " + "PUSumW*min(Pt, 1.)/SumW*min(Pt, 1.)", + 50, + 1., + 2.3, + 0., + 1., + "s"); + mePUTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile( + "PUTrackRecLVRelSumWosvsSumWos", + "Relative PU Sum of Wos vs Sum of Wos of tracks for matched vertices; log10(SumWos); PUSumWos/SumWos", + 50, + 5.5, + 7., + 0., + 1., + "s"); + meSecTrackRecLVRelSumWosvsSumWos_ = + ibook.bookProfile("SecTrackRecLVRelSumWosvsSumWos", + "Relative Sum of Wos of tracks from secondary vtx vs Sum of Wos of tracks for matched " + "vertices; log10(SumWos); SecSumWos/SumWos", + 50, + 5.5, + 7., + 0., + 1., + "s"); + meFakeTrackRecLVRelSumWosvsSumWos_ = ibook.bookProfile("FakeTrackRecLVRelSumWosvsSumWos", + "Relative Sum of Wos of fake tracks vs Sum of Wos of tracks " + "for matched vertices; log10(SumWos); FakeSumWos/SumWos", + 50, + 5.5, + 7., + 0., + 1., + "s"); + mePUTrackRecLVRelSumPtvsSumPt_ = + ibook.bookProfile("PUTrackRecLVRelSumPtvsSumPt", + "Relative PU Sum of Pt vs Sum of Pt of tracks for matched LV; log10(SumPt); PUSumPt/SumPt", + 50, + 1.4, + 3., + 0., + 1., + "s"); + mePUTrackRecLVRelSumPt2vsSumPt2_ = + ibook.bookProfile("PUTrackRecLVRelSumPt2vsSumPt2", + "Relative PU Sum of Pt2 vs Sum of tracks for matched LV; log10(SumPt2); PUSumPt2/SumPt2", + 50, + 2., + 4., + 0., + 1., + "s"); } - meJetsPURelMult_ = ibook.book1D("JetsPURelMult", "Relative contribution of PU to jet multiplicity for matched vertices; (#Jets-#JetsNoPU)/#Jets", 50, 0., 1.); - meJetsPURelHt_ = ibook.book1D("JetsPURelHt", "Relative contribution of PU to scalar sum of Et of jets for matched vertices; (Ht-HtNoPU)/HT", 50, 0., 1.); - meJetsPURelSumPt2_ = ibook.book1D("JetsPURelSumPt2", "Relative contribution of PU to sum of Pt2 of jets for matched vertices; (SumPt2-SumPt2NoPU)/SumPt2", 50, 0., 1.); - meJetsFakeRelSumPt2_ = ibook.book1D("JetsFakeRelSumPt2", "Relative contribution of fake tracks to sum of Pt2 of jets for matched vertices; (SumPt2-SumPt2NoFake)/SumPt2", 50, 0., 1.); - meJetsPURelMetPt_ = ibook.book1D("JetsPURelMetPt", "Relative contribution of PU to Missing Transverse Energy for matched vertices; (Met-MetNoPU)/Met", 50, -1., 1.); - meJetsPURelSumPz_ = ibook.book1D("JetsPURelSumPz", "Relative contribution of PU to sum of Pz of jets for matched vertices; (SumPz-SumPzNoPU)/SumPz", 50, -1., 1.); + meJetsPURelMult_ = + ibook.book1D("JetsPURelMult", + "Relative contribution of PU to jet multiplicity for matched vertices; (#Jets-#JetsNoPU)/#Jets", + 50, + 0., + 1.); + meJetsPURelHt_ = + ibook.book1D("JetsPURelHt", + "Relative contribution of PU to scalar sum of Et of jets for matched vertices; (Ht-HtNoPU)/HT", + 50, + 0., + 1.); + meJetsPURelSumPt2_ = + ibook.book1D("JetsPURelSumPt2", + "Relative contribution of PU to sum of Pt2 of jets for matched vertices; (SumPt2-SumPt2NoPU)/SumPt2", + 50, + 0., + 1.); + meJetsFakeRelSumPt2_ = ibook.book1D( + "JetsFakeRelSumPt2", + "Relative contribution of fake tracks to sum of Pt2 of jets for matched vertices; (SumPt2-SumPt2NoFake)/SumPt2", + 50, + 0., + 1.); + meJetsPURelMetPt_ = + ibook.book1D("JetsPURelMetPt", + "Relative contribution of PU to Missing Transverse Energy for matched vertices; (Met-MetNoPU)/Met", + 50, + -1., + 1.); + meJetsPURelSumPz_ = + ibook.book1D("JetsPURelSumPz", + "Relative contribution of PU to sum of Pz of jets for matched vertices; (SumPz-SumPzNoPU)/SumPz", + 50, + -1., + 1.); - meJetsRecLVPURelMult_ = ibook.book1D("JetsRecLVPURelMult", "Relative contribution of PU to jet multiplicity for matched LV; (#Jets-#JetsNoPU)/#Jets", 50, 0., 1.); - meJetsRecLVPURelHt_ = ibook.book1D("JetsRecLVPURelHt", "Relative contribution of PU to scalar sum of Et of jets for matched LV; (Ht-HtNoPU)/HT", 50, 0., 1.); - meJetsRecLVPURelSumPt2_ = ibook.book1D("JetsRecLVPURelSumPt2", "Relative contribution of PU to sum of Pt2 of jets for matched LV; (SumPt2-SumPt2NoPU)/SumPt2", 50, 0., 1.); - meJetsRecLVFakeRelSumPt2_ = ibook.book1D("JetsRecLVFakeRelSumPt2", "Relative contribution of fake tracks to sum of Pt2 of jets for matched LV; (SumPt2-SumPt2NoFake)/SumPt2", 50, 0., 1.); - meJetsRecLVPURelMetPt_ = ibook.book1D("JetsRecLVPURelMetPt", "Relative contribution of PU to Missing Transverse Energy for matched LV; (Met-MetNoPU)/Met", 50, -1., 1.); - meJetsRecLVPURelSumPz_ = ibook.book1D("JetsRecLVPURelSumPz", "Relative contribution of PU to sum of Pz of jets for matched LV; (SumPz-SumPzNoPU)/SumPz", 50, -1., 1.); + meJetsRecLVPURelMult_ = + ibook.book1D("JetsRecLVPURelMult", + "Relative contribution of PU to jet multiplicity for matched LV; (#Jets-#JetsNoPU)/#Jets", + 50, + 0., + 1.); + meJetsRecLVPURelHt_ = + ibook.book1D("JetsRecLVPURelHt", + "Relative contribution of PU to scalar sum of Et of jets for matched LV; (Ht-HtNoPU)/HT", + 50, + 0., + 1.); + meJetsRecLVPURelSumPt2_ = + ibook.book1D("JetsRecLVPURelSumPt2", + "Relative contribution of PU to sum of Pt2 of jets for matched LV; (SumPt2-SumPt2NoPU)/SumPt2", + 50, + 0., + 1.); + meJetsRecLVFakeRelSumPt2_ = ibook.book1D( + "JetsRecLVFakeRelSumPt2", + "Relative contribution of fake tracks to sum of Pt2 of jets for matched LV; (SumPt2-SumPt2NoFake)/SumPt2", + 50, + 0., + 1.); + meJetsRecLVPURelMetPt_ = + ibook.book1D("JetsRecLVPURelMetPt", + "Relative contribution of PU to Missing Transverse Energy for matched LV; (Met-MetNoPU)/Met", + 50, + -1., + 1.); + meJetsRecLVPURelSumPz_ = + ibook.book1D("JetsRecLVPURelSumPz", + "Relative contribution of PU to sum of Pz of jets for matched LV; (SumPz-SumPzNoPU)/SumPz", + 50, + -1., + 1.); if (optionalPlots_) { - meJetsPUMult_ = ibook.book1D("JetsPUMult", "Contribution of PU to jet multiplicity for matched vertices; #Jets-#JetsNoPU", 50, 0., 100.); - meJetsPUHt_ = ibook.book1D("JetsPUHt", "Contribution of PU to scalar sum of Et of jets for matched vertices; log10(Ht-HtNoPU)", 50, -2., 3.); - meJetsPUSumPt2_ = ibook.book1D("JetsPUSumPt2", "Contribution of PU to sum of Pt2 of jets for matched vertices; log10(sumPt2-SumPt2NoPU)", 50, -3., 3.); - meJetsPUMetPt_ = ibook.book1D("JetsPUMetPt", "Contribution of PU to Missing Transverse Energy for matched vertices; log10(Met-MetNoPU)", 50, -3., 2.); - meJetsPUSumPz_ = ibook.book1D("JetsPUSumPz", "Contribution of PU to sum of Pz of jets for matched vertices; log10(abs(SumPz-SumPzNoPU))", 50, -4., 3.); - - meJetsPURelMultvsMult_ = ibook.bookProfile("JetsPURelMultvsMult", "Relative contribution of PU to jet multiplicity vs number of jets for matched vertices; #Jets; (#Jets-#JetsNoPU)/#Jets", 50, 0., 120., 0., 1.,"s"); - meJetsPURelHtvsHt_ = ibook.bookProfile("JetsPURelHtvsHt", "Relative contribution of PU to scalar sum of Et of jets vs scalar sum of Et for matched vertices; log10(Ht); (Ht-HtNoPU)/HT", 50, 0., 3., 0., 1.,"s"); - meJetsPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsPURelSumPt2vsSumPt2", "Relative contribution of PU to sum of Pt2 of jets vs sum of Pt2 for matched vertices; log10(SumPt2); (SumPt2-SumPt2NoPU)/SumPt2", 50, -1., 4., 0., 1.,"s"); - meJetsFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsFakeRelSumPt2vsSumPt2", "Relative contribution of fake tracks to sum of Pt2 of jets vs sum of Pt2 for matched vertices; log10(SumPt2); (SumPt2-SumPt2NoFake)/SumPt2", 50, -1., 4., 0., 1.,"s"); - meJetsPURelMetPtvsMetPt_ = ibook.bookProfile("JetsPURelMetPtvsMetPt", "Relative contribution of PU to Missing Transverse Energy vs MET for matched vertices; log10(Met); (Met-MetNoPU)/Met", 50, -1., 2., -1., 1.,"s"); - meJetsPURelSumPzvsSumPz_ = ibook.bookProfile("JetsPURelSumPzvsSumPz", "Relative contribution of PU to sum of Pz of jets vs Sum of Pz for matched vertices; log10(abs SumPz); (SumPz-SumPzNoPU)/SumPz", 50, -2., 3., -1., 1.,"s"); - - meJetsRecLVPUMult_ = ibook.book1D("JetsRecLVPUMult", "Contribution of PU to jet multiplicity for matched LV; #Jets-#JetsNoPU", 50, 0., 100.); - meJetsRecLVPUHt_ = ibook.book1D("JetsRecLVPUHt", "Contribution of PU to scalar sum of Et of jets for matched LV; log10(Ht-HtNoPU)", 50, -2., 3.); - meJetsRecLVPUSumPt2_ = ibook.book1D("JetsRecLVPUSumPt2", "Contribution of PU to sum of Pt2 of jets for matched LV; log10(sumPt2-SumPt2NoPU)", 50, -3., 3.); - meJetsRecLVPUMetPt_ = ibook.book1D("JetsRecLVPUMetPt", "Contribution of PU to Missing Transverse Energy for matched LV; log10(Met-MetNoPU)", 50, -3., 2.); - meJetsRecLVPUSumPz_ = ibook.book1D("JetsRecLVPUSumPz", "Contribution of PU to sum of Pz of jets for matched LV; log10(abs(SumPz-SumPzNoPU))", 50, -4., 3.); - - meJetsRecLVPURelMultvsMult_ = ibook.bookProfile("JetsRecLVPURelMultvsMult", "Relative contribution of PU to jet multiplicity vs number of jets for matched vertices; #Jets; (#Jets-#JetsNoPU)/#Jets", 50, 0., 120., 0., 1.,"s"); - meJetsRecLVPURelHtvsHt_ = ibook.bookProfile("JetsRecLVPURelHtvsHt", "Relative contribution of PU to scalar sum of Et of jets vs scalar sum of Et for matched vertices; log10(Ht); (Ht-HtNoPU)/HT", 50, 1.5, 3., 0., 1.,"s"); - meJetsRecLVPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVPURelSumPt2vsSumPt2", "Relative contribution of PU to sum of Pt2 of jets vs sum of Pt2 for matched vertices; log10(SumPt2); (SumPt2-SumPt2NoPU)/SumPt2", 50, 2., 5., 0., 1.,"s"); - meJetsRecLVFakeRelSumPt2vsSumPt2_ = ibook.bookProfile("JetsRecLVFakeRelSumPt2vsSumPt2", "Relative contribution of fake tracks to sum of Pt2 of jets vs sum of Pt2 for matched vertices; log10(SumPt2); (SumPt2-SumPt2NoFake)/SumPt2", 50, 2., 5., 0., 1.,"s"); - meJetsRecLVPURelMetPtvsMetPt_ = ibook.bookProfile("JetsRecLVPURelMetPtvsMetPt", "Relative contribution of PU to Missing Transverse Energy vs MET for matched vertices; log10(Met); (Met-MetNoPU)/Met", 50, 0., 2.5, -1., 1.,"s"); - meJetsRecLVPURelSumPzvsSumPz_ = ibook.bookProfile("JetsRecLVPURelSumPzvsSumPz", "Relative contribution of PU to sum of Pz of jets vs Sum of Pz for matched vertices; log10(abs SumPz); (SumPz-SumPzNoPU)/SumPz", 50, 0.5, 3.5, -1., 1.,"s"); + meJetsPUMult_ = ibook.book1D( + "JetsPUMult", "Contribution of PU to jet multiplicity for matched vertices; #Jets-#JetsNoPU", 50, 0., 100.); + meJetsPUHt_ = ibook.book1D("JetsPUHt", + "Contribution of PU to scalar sum of Et of jets for matched vertices; log10(Ht-HtNoPU)", + 50, + -2., + 3.); + meJetsPUSumPt2_ = + ibook.book1D("JetsPUSumPt2", + "Contribution of PU to sum of Pt2 of jets for matched vertices; log10(sumPt2-SumPt2NoPU)", + 50, + -3., + 3.); + meJetsPUMetPt_ = + ibook.book1D("JetsPUMetPt", + "Contribution of PU to Missing Transverse Energy for matched vertices; log10(Met-MetNoPU)", + 50, + -3., + 2.); + meJetsPUSumPz_ = + ibook.book1D("JetsPUSumPz", + "Contribution of PU to sum of Pz of jets for matched vertices; log10(abs(SumPz-SumPzNoPU))", + 50, + -4., + 3.); + + meJetsPURelMultvsMult_ = ibook.bookProfile("JetsPURelMultvsMult", + "Relative contribution of PU to jet multiplicity vs number of jets for " + "matched vertices; #Jets; (#Jets-#JetsNoPU)/#Jets", + 50, + 0., + 120., + 0., + 1., + "s"); + meJetsPURelHtvsHt_ = ibook.bookProfile("JetsPURelHtvsHt", + "Relative contribution of PU to scalar sum of Et of jets vs scalar sum of " + "Et for matched vertices; log10(Ht); (Ht-HtNoPU)/HT", + 50, + 0., + 3., + 0., + 1., + "s"); + meJetsPURelSumPt2vsSumPt2_ = ibook.bookProfile("JetsPURelSumPt2vsSumPt2", + "Relative contribution of PU to sum of Pt2 of jets vs sum of Pt2 " + "for matched vertices; log10(SumPt2); (SumPt2-SumPt2NoPU)/SumPt2", + 50, + -1., + 4., + 0., + 1., + "s"); + meJetsFakeRelSumPt2vsSumPt2_ = + ibook.bookProfile("JetsFakeRelSumPt2vsSumPt2", + "Relative contribution of fake tracks to sum of Pt2 of jets vs sum of Pt2 for matched " + "vertices; log10(SumPt2); (SumPt2-SumPt2NoFake)/SumPt2", + 50, + -1., + 4., + 0., + 1., + "s"); + meJetsPURelMetPtvsMetPt_ = ibook.bookProfile("JetsPURelMetPtvsMetPt", + "Relative contribution of PU to Missing Transverse Energy vs MET for " + "matched vertices; log10(Met); (Met-MetNoPU)/Met", + 50, + -1., + 2., + -1., + 1., + "s"); + meJetsPURelSumPzvsSumPz_ = ibook.bookProfile("JetsPURelSumPzvsSumPz", + "Relative contribution of PU to sum of Pz of jets vs Sum of Pz for " + "matched vertices; log10(abs SumPz); (SumPz-SumPzNoPU)/SumPz", + 50, + -2., + 3., + -1., + 1., + "s"); + + meJetsRecLVPUMult_ = ibook.book1D( + "JetsRecLVPUMult", "Contribution of PU to jet multiplicity for matched LV; #Jets-#JetsNoPU", 50, 0., 100.); + meJetsRecLVPUHt_ = ibook.book1D( + "JetsRecLVPUHt", "Contribution of PU to scalar sum of Et of jets for matched LV; log10(Ht-HtNoPU)", 50, -2., 3.); + meJetsRecLVPUSumPt2_ = + ibook.book1D("JetsRecLVPUSumPt2", + "Contribution of PU to sum of Pt2 of jets for matched LV; log10(sumPt2-SumPt2NoPU)", + 50, + -3., + 3.); + meJetsRecLVPUMetPt_ = + ibook.book1D("JetsRecLVPUMetPt", + "Contribution of PU to Missing Transverse Energy for matched LV; log10(Met-MetNoPU)", + 50, + -3., + 2.); + meJetsRecLVPUSumPz_ = + ibook.book1D("JetsRecLVPUSumPz", + "Contribution of PU to sum of Pz of jets for matched LV; log10(abs(SumPz-SumPzNoPU))", + 50, + -4., + 3.); + + meJetsRecLVPURelMultvsMult_ = ibook.bookProfile("JetsRecLVPURelMultvsMult", + "Relative contribution of PU to jet multiplicity vs number of jets " + "for matched vertices; #Jets; (#Jets-#JetsNoPU)/#Jets", + 50, + 0., + 120., + 0., + 1., + "s"); + meJetsRecLVPURelHtvsHt_ = ibook.bookProfile("JetsRecLVPURelHtvsHt", + "Relative contribution of PU to scalar sum of Et of jets vs scalar sum " + "of Et for matched vertices; log10(Ht); (Ht-HtNoPU)/HT", + 50, + 1.5, + 3., + 0., + 1., + "s"); + meJetsRecLVPURelSumPt2vsSumPt2_ = + ibook.bookProfile("JetsRecLVPURelSumPt2vsSumPt2", + "Relative contribution of PU to sum of Pt2 of jets vs sum of Pt2 for matched vertices; " + "log10(SumPt2); (SumPt2-SumPt2NoPU)/SumPt2", + 50, + 2., + 5., + 0., + 1., + "s"); + meJetsRecLVFakeRelSumPt2vsSumPt2_ = + ibook.bookProfile("JetsRecLVFakeRelSumPt2vsSumPt2", + "Relative contribution of fake tracks to sum of Pt2 of jets vs sum of Pt2 for matched " + "vertices; log10(SumPt2); (SumPt2-SumPt2NoFake)/SumPt2", + 50, + 2., + 5., + 0., + 1., + "s"); + meJetsRecLVPURelMetPtvsMetPt_ = ibook.bookProfile("JetsRecLVPURelMetPtvsMetPt", + "Relative contribution of PU to Missing Transverse Energy vs MET " + "for matched vertices; log10(Met); (Met-MetNoPU)/Met", + 50, + 0., + 2.5, + -1., + 1., + "s"); + meJetsRecLVPURelSumPzvsSumPz_ = ibook.bookProfile("JetsRecLVPURelSumPzvsSumPz", + "Relative contribution of PU to sum of Pz of jets vs Sum of Pz " + "for matched vertices; log10(abs SumPz); (SumPz-SumPzNoPU)/SumPz", + 50, + 0.5, + 3.5, + -1., + 1., + "s"); } // some tests @@ -970,32 +1364,33 @@ bool Primary4DVertexValidation::matchRecoTrack2SimSignal(const reco::TrackBaseRe return false; } -std::pair>*,int> Primary4DVertexValidation::getMatchedTP( +std::pair>*, int> Primary4DVertexValidation::getMatchedTP( const reco::TrackBaseRef& recoTrack, const TrackingVertexRef& vsim) { auto found = r2s_->find(recoTrack); // reco track not matched to any TP (fake tracks) if (found == r2s_->end()) - return std::make_pair (nullptr,-1); + return std::make_pair(nullptr, -1); // matched TP equal to any TP of a given sim vertex for (const auto& tp : found->val) { if (std::find_if(vsim->daughterTracks_begin(), vsim->daughterTracks_end(), [&](const TrackingParticleRef& vtp) { return tp.first == vtp; }) != vsim->daughterTracks_end()) - return std::make_pair (&tp.first,0); + return std::make_pair(&tp.first, 0); // matched TP not associated to any daughter track of a given sim vertex but having the same eventID (track from secondary vtx) - else if (tp.first->eventId().bunchCrossing() == vsim->eventId().bunchCrossing() && tp.first->eventId().event() == vsim->eventId().event()) { - return std::make_pair (&tp.first,1); + else if (tp.first->eventId().bunchCrossing() == vsim->eventId().bunchCrossing() && + tp.first->eventId().event() == vsim->eventId().event()) { + return std::make_pair(&tp.first, 1); } // matched TP not associated to any sim vertex of a given simulated event (PU track) else { - return std::make_pair (&tp.first,2); + return std::make_pair(&tp.first, 2); } } // reco track not matched to any TP from vertex - return std::make_pair (nullptr,-1); + return std::make_pair(nullptr, -1); } double Primary4DVertexValidation::timeFromTrueMass(double mass, double pathlength, double momentum, double time) { @@ -1029,9 +1424,14 @@ bool Primary4DVertexValidation::select(const reco::Vertex& v, int level) { return false; } -void Primary4DVertexValidation::observablesFromJets(const std::vector& reco_Tracks, const std::vector& mass_Tracks, - const std::vector& category_Tracks, const std::string& skip_Tracks, - unsigned int& n_Jets, double& sum_EtJets, double& sum_Pt2Jets, double& met_Pt, +void Primary4DVertexValidation::observablesFromJets(const std::vector& reco_Tracks, + const std::vector& mass_Tracks, + const std::vector& category_Tracks, + const std::string& skip_Tracks, + unsigned int& n_Jets, + double& sum_EtJets, + double& sum_Pt2Jets, + double& met_Pt, double& sum_PzJets) { double sum_PtJets = 0; n_Jets = 0; @@ -1052,14 +1452,14 @@ void Primary4DVertexValidation::observablesFromJets(const std::vector& probPi, - const edm::ValueMap& probK, const edm::ValueMap& probP, - unsigned int& no_PIDtype, bool& no_PID, bool& is_Pi, bool& is_K, bool& is_P) { +void Primary4DVertexValidation::isParticle(const reco::TrackBaseRef& recoTrack, + const edm::ValueMap& probPi, + const edm::ValueMap& probK, + const edm::ValueMap& probP, + unsigned int& no_PIDtype, + bool& no_PID, + bool& is_Pi, + bool& is_K, + bool& is_P) { no_PIDtype = 0; no_PID = false; is_Pi = false; @@ -1115,12 +1524,16 @@ void Primary4DVertexValidation::isParticle(const reco::TrackBaseRef& recoTrack, is_P = !no_PID && !is_Pi && !is_K; } -void Primary4DVertexValidation::getWosWnt(const reco::Vertex& recoVtx, const reco::TrackBaseRef& recoTrk, const edm::ValueMap& sigmat0, - const edm::Handle& BS, double& wos, double& wnt) { +void Primary4DVertexValidation::getWosWnt(const reco::Vertex& recoVtx, + const reco::TrackBaseRef& recoTrk, + const edm::ValueMap& sigmat0, + const edm::Handle& BS, + double& wos, + double& wnt) { double dz2_beam = pow((*BS).BeamWidthX() * cos(recoTrk->phi()) / tan(recoTrk->theta()), 2) + pow((*BS).BeamWidthY() * sin(recoTrk->phi()) / tan(recoTrk->theta()), 2); - double dz2 = pow(recoTrk->dzError(), 2) + dz2_beam + - pow(0.0020, 2); // added 20 um, some tracks have crazy small resolutions + double dz2 = + pow(recoTrk->dzError(), 2) + dz2_beam + pow(0.0020, 2); // added 20 um, some tracks have crazy small resolutions wos = recoVtx.trackWeight(recoTrk) / dz2; wnt = recoVtx.trackWeight(recoTrk) * std::min(recoTrk->pt(), 1.0); @@ -1564,8 +1977,8 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve bool selectedVtxMatching = recopv.at(iv).sim == iev && simpv.at(iev).rec == iv; bool selectedLV = simpv.at(iev).eventId.bunchCrossing() == 0 && simpv.at(iev).eventId.event() == 0 && - recopv.at(iv).OriginalIndex == 0; - bool selectedLVMatching = selectedVtxMatching && selectedLV; // bool for reco vtx leading match + recopv.at(iv).OriginalIndex == 0; + bool selectedLVMatching = selectedVtxMatching && selectedLV; // bool for reco vtx leading match if (selectedLVMatching && !recopv.at(iv).is_signal()) { edm::LogWarning("Primary4DVertexValidation") << "Reco vtx leading match inconsistent: BX/ID " << simpv.at(iev).eventId.bunchCrossing() << " " @@ -1614,16 +2027,14 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve if (selectedVtxMatching) { unsigned int no_PIDtype = 0; bool no_PID, is_Pi, is_K, is_P; - int PartID = 211; // pion + int PartID = 211; // pion isParticle(*iTrack, probPi, probK, probP, no_PIDtype, no_PID, is_Pi, is_K, is_P); if (!use3dNoTime_) { if (no_PID || is_Pi) { PartID = 211; - } - else if (is_K) { + } else if (is_K) { PartID = 321; - } - else if (is_P) { + } else if (is_P) { PartID = 2212; } } @@ -1639,12 +2050,12 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve } // matched TP not associated to any daughter track of a given sim vertex but having the same eventID (track from secondary vtx) if (matchCategory == 1) { - categoryVector.push_back(matchCategory); - SecsumWos += wos; + categoryVector.push_back(matchCategory); + SecsumWos += wos; } // matched TP not associated to any sim vertex of a given simulated event (PU track) if (matchCategory == 2) { - if (optionalPlots_){ + if (optionalPlots_) { mePUTrackWnt_->Fill(wnt); if (selectedLV) { mePUTrackRecLVWnt_->Fill(wnt); @@ -1928,126 +2339,151 @@ void Primary4DVertexValidation::analyze(const edm::Event& iEvent, const edm::Eve } } } // if tp_info != nullptr && MatchCategory == 0 - } // loop on reco tracks + } // loop on reco tracks if (selectedVtxMatching) { - mePUTrackRelMult_->Fill(static_cast(PUnt)/nt); - meFakeTrackRelMult_->Fill(static_cast(Fakent)/nt); - mePUTrackRelSumWnt_->Fill(PUsumWnt/sumWnt); - mePUTrackRelSumWos_->Fill(PUsumWos/sumWos); - meSecTrackRelSumWos_->Fill(SecsumWos/sumWos); - meFakeTrackRelSumWos_->Fill(FakesumWos/sumWos); - mePUTrackRelSumPt_->Fill(PUsumPt/sumPt); - mePUTrackRelSumPt2_->Fill(PUsumPt2/sumPt2); - - observablesFromJets(recotracks, massVector, categoryVector, "use_allTracks", nJets, sumEtJets, sumPt2Jets, metPt, sumPzJets); - observablesFromJets(recotracks, massVector, categoryVector, "skip_Fake", nJetsnoFake, sumEtJetsnoFake, sumPt2JetsnoFake, metPtnoFake, sumPzJetsnoFake); - observablesFromJets(recotracks, massVector, categoryVector, "skip_PU", nJetsnoPU, sumEtJetsnoPU, sumPt2JetsnoPU, metPtnoPU, sumPzJetsnoPU); - - meJetsPURelMult_->Fill(static_cast(nJets-nJetsnoPU)/nJets); - meJetsPURelHt_->Fill((sumEtJets-sumEtJetsnoPU)/sumEtJets); - meJetsPURelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); - meJetsFakeRelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); - meJetsPURelMetPt_->Fill((metPt-metPtnoPU)/metPt); - meJetsPURelSumPz_->Fill((sumPzJets-sumPzJetsnoPU)/sumPzJets); + mePUTrackRelMult_->Fill(static_cast(PUnt) / nt); + meFakeTrackRelMult_->Fill(static_cast(Fakent) / nt); + mePUTrackRelSumWnt_->Fill(PUsumWnt / sumWnt); + mePUTrackRelSumWos_->Fill(PUsumWos / sumWos); + meSecTrackRelSumWos_->Fill(SecsumWos / sumWos); + meFakeTrackRelSumWos_->Fill(FakesumWos / sumWos); + mePUTrackRelSumPt_->Fill(PUsumPt / sumPt); + mePUTrackRelSumPt2_->Fill(PUsumPt2 / sumPt2); + + observablesFromJets( + recotracks, massVector, categoryVector, "use_allTracks", nJets, sumEtJets, sumPt2Jets, metPt, sumPzJets); + observablesFromJets(recotracks, + massVector, + categoryVector, + "skip_Fake", + nJetsnoFake, + sumEtJetsnoFake, + sumPt2JetsnoFake, + metPtnoFake, + sumPzJetsnoFake); + observablesFromJets(recotracks, + massVector, + categoryVector, + "skip_PU", + nJetsnoPU, + sumEtJetsnoPU, + sumPt2JetsnoPU, + metPtnoPU, + sumPzJetsnoPU); + + meJetsPURelMult_->Fill(static_cast(nJets - nJetsnoPU) / nJets); + meJetsPURelHt_->Fill((sumEtJets - sumEtJetsnoPU) / sumEtJets); + meJetsPURelSumPt2_->Fill((sumPt2Jets - sumPt2JetsnoPU) / sumPt2Jets); + meJetsFakeRelSumPt2_->Fill((sumPt2Jets - sumPt2JetsnoFake) / sumPt2Jets); + meJetsPURelMetPt_->Fill((metPt - metPtnoPU) / metPt); + meJetsPURelSumPz_->Fill((sumPzJets - sumPzJetsnoPU) / sumPzJets); if (optionalPlots_) { mePUTrackMult_->Fill(PUnt); - mePUTrackSumWnt_->Fill(log10(std::max(minThrSumWnt_,PUsumWnt))); - mePUTrackSumWos_->Fill(log10(std::max(minThrSumWos_,PUsumWos))); - meSecTrackSumWos_->Fill(log10(std::max(minThrSumWos_,SecsumWos))); - mePUTrackSumPt_->Fill(log10(std::max(minThrSumPt_,PUsumPt))); - mePUTrackSumPt2_->Fill(log10(std::max(minThrSumPt2_,PUsumPt2))); - - mePUTrackRelMultvsMult_->Fill(nt, static_cast(PUnt)/nt); - meFakeTrackRelMultvsMult_->Fill(nt, static_cast(Fakent)/nt); - mePUTrackRelSumWntvsSumWnt_->Fill(log10(std::max(minThrSumWnt_,sumWnt)), PUsumWnt/sumWnt); - mePUTrackRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), PUsumWos/sumWos); - meSecTrackRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), SecsumWos/sumWos); - meFakeTrackRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), FakesumWos/sumWos); - mePUTrackRelSumPtvsSumPt_->Fill(log10(std::max(minThrSumPt_,sumPt)), PUsumPt/sumPt); - mePUTrackRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2)), PUsumPt2/sumPt2); - - meJetsPUMult_->Fill(nJets-nJetsnoPU); - meJetsPUHt_->Fill(log10(std::max(minThrSumPt_,sumEtJets-sumEtJetsnoPU))); - meJetsPUSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets-sumPt2JetsnoPU))); - meJetsPUMetPt_->Fill(log10(std::max(minThrMetPt_,metPt-metPtnoPU))); - meJetsPUSumPz_->Fill(log10(std::max(minThrSumPz_,std::abs(sumPzJets-sumPzJetsnoPU)))); - - meJetsPURelMultvsMult_->Fill(nJets, static_cast(nJets-nJetsnoPU)/nJets); - meJetsPURelHtvsHt_->Fill(log10(std::max(minThrSumPt_,sumEtJets)), (sumEtJets-sumEtJetsnoPU)/sumEtJets); - meJetsPURelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); - meJetsFakeRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); - meJetsPURelMetPtvsMetPt_->Fill(log10(std::max(minThrMetPt_,metPt)), (metPt-metPtnoPU)/metPt); - meJetsPURelSumPzvsSumPz_->Fill(log10(std::max(minThrSumPz_,std::abs(sumPzJets))), (sumPzJets-sumPzJetsnoPU)/sumPzJets); + mePUTrackSumWnt_->Fill(log10(std::max(minThrSumWnt_, PUsumWnt))); + mePUTrackSumWos_->Fill(log10(std::max(minThrSumWos_, PUsumWos))); + meSecTrackSumWos_->Fill(log10(std::max(minThrSumWos_, SecsumWos))); + mePUTrackSumPt_->Fill(log10(std::max(minThrSumPt_, PUsumPt))); + mePUTrackSumPt2_->Fill(log10(std::max(minThrSumPt2_, PUsumPt2))); + + mePUTrackRelMultvsMult_->Fill(nt, static_cast(PUnt) / nt); + meFakeTrackRelMultvsMult_->Fill(nt, static_cast(Fakent) / nt); + mePUTrackRelSumWntvsSumWnt_->Fill(log10(std::max(minThrSumWnt_, sumWnt)), PUsumWnt / sumWnt); + mePUTrackRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_, sumWos)), PUsumWos / sumWos); + meSecTrackRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_, sumWos)), SecsumWos / sumWos); + meFakeTrackRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_, sumWos)), FakesumWos / sumWos); + mePUTrackRelSumPtvsSumPt_->Fill(log10(std::max(minThrSumPt_, sumPt)), PUsumPt / sumPt); + mePUTrackRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_, sumPt2)), PUsumPt2 / sumPt2); + + meJetsPUMult_->Fill(nJets - nJetsnoPU); + meJetsPUHt_->Fill(log10(std::max(minThrSumPt_, sumEtJets - sumEtJetsnoPU))); + meJetsPUSumPt2_->Fill(log10(std::max(minThrSumPt2_, sumPt2Jets - sumPt2JetsnoPU))); + meJetsPUMetPt_->Fill(log10(std::max(minThrMetPt_, metPt - metPtnoPU))); + meJetsPUSumPz_->Fill(log10(std::max(minThrSumPz_, std::abs(sumPzJets - sumPzJetsnoPU)))); + + meJetsPURelMultvsMult_->Fill(nJets, static_cast(nJets - nJetsnoPU) / nJets); + meJetsPURelHtvsHt_->Fill(log10(std::max(minThrSumPt_, sumEtJets)), (sumEtJets - sumEtJetsnoPU) / sumEtJets); + meJetsPURelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_, sumPt2Jets)), + (sumPt2Jets - sumPt2JetsnoPU) / sumPt2Jets); + meJetsFakeRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_, sumPt2Jets)), + (sumPt2Jets - sumPt2JetsnoFake) / sumPt2Jets); + meJetsPURelMetPtvsMetPt_->Fill(log10(std::max(minThrMetPt_, metPt)), (metPt - metPtnoPU) / metPt); + meJetsPURelSumPzvsSumPz_->Fill(log10(std::max(minThrSumPz_, std::abs(sumPzJets))), + (sumPzJets - sumPzJetsnoPU) / sumPzJets); } if (selectedLV) { - mePUTrackRecLVRelMult_->Fill(static_cast(PUnt)/nt); - meFakeTrackRecLVRelMult_->Fill(static_cast(Fakent)/nt); - mePUTrackRecLVRelSumWnt_->Fill(PUsumWnt/sumWnt); - mePUTrackRecLVRelSumWos_->Fill(PUsumWos/sumWos); - meSecTrackRecLVRelSumWos_->Fill(SecsumWos/sumWos); - meFakeTrackRecLVRelSumWos_->Fill(FakesumWos/sumWos); - mePUTrackRecLVRelSumPt_->Fill(PUsumPt/sumPt); - mePUTrackRecLVRelSumPt2_->Fill(PUsumPt2/sumPt2); - - meJetsRecLVPURelMult_->Fill(static_cast(nJets-nJetsnoPU)/nJets); - meJetsRecLVPURelHt_->Fill((sumEtJets-sumEtJetsnoPU)/sumEtJets); - meJetsRecLVPURelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); - meJetsRecLVFakeRelSumPt2_->Fill((sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); - meJetsRecLVPURelMetPt_->Fill((metPt-metPtnoPU)/metPt); - meJetsRecLVPURelSumPz_->Fill((sumPzJets-sumPzJetsnoPU)/sumPzJets); - - if (debug_){ - edm::LogPrint("Primary4DVertexValidation") << "#PUTrks = " << PUnt << " #Trks = " << nt << " PURelMult = " - << std::setprecision(3) << static_cast(PUnt)/nt; - edm::LogPrint("Primary4DVertexValidation") << "PUsumWnt = " << std::setprecision(3) << PUsumWnt << " sumWnt = " - << std::setprecision(3) << sumWnt << " PURelsumWnt = " - << std::setprecision(3) << PUsumWnt/sumWnt; - edm::LogPrint("Primary4DVertexValidation") << "PUsumWos = " << std::setprecision(3) << PUsumWos << " sumWos = " - << std::setprecision(3) << sumWos << " PURelsumWos = " - << std::setprecision(3) << PUsumWos/sumWos; - edm::LogPrint("Primary4DVertexValidation") << "PuSumPt = " << std::setprecision(3) << PUsumPt << " SumPt = " - << std::setprecision(4) << sumPt << " PURelSumPt = " - << std::setprecision(3) << PUsumPt/sumPt; - edm::LogPrint("Primary4DVertexValidation") << "PuSumPt2 = " << std::setprecision(3) << PUsumPt2 << " SumPt2 = " - << std::setprecision(4) << sumPt2 << " PURelSumPt2 = " - << std::setprecision(3) << PUsumPt2/sumPt2; + mePUTrackRecLVRelMult_->Fill(static_cast(PUnt) / nt); + meFakeTrackRecLVRelMult_->Fill(static_cast(Fakent) / nt); + mePUTrackRecLVRelSumWnt_->Fill(PUsumWnt / sumWnt); + mePUTrackRecLVRelSumWos_->Fill(PUsumWos / sumWos); + meSecTrackRecLVRelSumWos_->Fill(SecsumWos / sumWos); + meFakeTrackRecLVRelSumWos_->Fill(FakesumWos / sumWos); + mePUTrackRecLVRelSumPt_->Fill(PUsumPt / sumPt); + mePUTrackRecLVRelSumPt2_->Fill(PUsumPt2 / sumPt2); + + meJetsRecLVPURelMult_->Fill(static_cast(nJets - nJetsnoPU) / nJets); + meJetsRecLVPURelHt_->Fill((sumEtJets - sumEtJetsnoPU) / sumEtJets); + meJetsRecLVPURelSumPt2_->Fill((sumPt2Jets - sumPt2JetsnoPU) / sumPt2Jets); + meJetsRecLVFakeRelSumPt2_->Fill((sumPt2Jets - sumPt2JetsnoFake) / sumPt2Jets); + meJetsRecLVPURelMetPt_->Fill((metPt - metPtnoPU) / metPt); + meJetsRecLVPURelSumPz_->Fill((sumPzJets - sumPzJetsnoPU) / sumPzJets); + + if (debug_) { + edm::LogPrint("Primary4DVertexValidation") + << "#PUTrks = " << PUnt << " #Trks = " << nt << " PURelMult = " << std::setprecision(3) + << static_cast(PUnt) / nt; + edm::LogPrint("Primary4DVertexValidation") + << "PUsumWnt = " << std::setprecision(3) << PUsumWnt << " sumWnt = " << std::setprecision(3) << sumWnt + << " PURelsumWnt = " << std::setprecision(3) << PUsumWnt / sumWnt; + edm::LogPrint("Primary4DVertexValidation") + << "PUsumWos = " << std::setprecision(3) << PUsumWos << " sumWos = " << std::setprecision(3) << sumWos + << " PURelsumWos = " << std::setprecision(3) << PUsumWos / sumWos; + edm::LogPrint("Primary4DVertexValidation") + << "PuSumPt = " << std::setprecision(3) << PUsumPt << " SumPt = " << std::setprecision(4) << sumPt + << " PURelSumPt = " << std::setprecision(3) << PUsumPt / sumPt; + edm::LogPrint("Primary4DVertexValidation") + << "PuSumPt2 = " << std::setprecision(3) << PUsumPt2 << " SumPt2 = " << std::setprecision(4) << sumPt2 + << " PURelSumPt2 = " << std::setprecision(3) << PUsumPt2 / sumPt2; } if (optionalPlots_) { mePUTrackRecLVMult_->Fill(PUnt); - mePUTrackRecLVSumWnt_->Fill(log10(std::max(minThrSumWnt_,PUsumWnt))); - mePUTrackRecLVSumWos_->Fill(log10(std::max(minThrSumWos_,PUsumWos))); - meSecTrackRecLVSumWos_->Fill(log10(std::max(minThrSumWos_,PUsumWos))); - mePUTrackRecLVSumPt_->Fill(log10(std::max(minThrSumPt_,PUsumPt))); - mePUTrackRecLVSumPt2_->Fill(log10(std::max(minThrSumPt2_,PUsumPt2))); - - mePUTrackRecLVRelMultvsMult_->Fill(nt, static_cast(PUnt)/nt); - meFakeTrackRecLVRelMultvsMult_->Fill(nt, static_cast(Fakent)/nt); - mePUTrackRecLVRelSumWntvsSumWnt_->Fill(log10(std::max(minThrSumWnt_,sumWnt)), PUsumWnt/sumWnt); - mePUTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), PUsumWos/sumWos); - meSecTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), SecsumWos/sumWos); - meFakeTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_,sumWos)), FakesumWos/sumWos); - mePUTrackRecLVRelSumPtvsSumPt_->Fill(log10(std::max(minThrSumPt_,sumPt)), PUsumPt/sumPt); - mePUTrackRecLVRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2)), PUsumPt2/sumPt2); - - meJetsRecLVPUMult_->Fill(nJets-nJetsnoPU); - meJetsRecLVPUHt_->Fill(log10(std::max(minThrSumPt_,sumEtJets-sumEtJetsnoPU))); - meJetsRecLVPUSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets-sumPt2JetsnoPU))); - meJetsRecLVPUMetPt_->Fill(log10(std::max(minThrMetPt_,metPt-metPtnoPU))); - meJetsRecLVPUSumPz_->Fill(log10(std::max(minThrSumPz_,std::abs(sumPzJets-sumPzJetsnoPU)))); - - meJetsRecLVPURelMultvsMult_->Fill(nJets, static_cast(nJets-nJetsnoPU)/nJets); - meJetsRecLVPURelHtvsHt_->Fill(log10(std::max(minThrSumPt_,sumEtJets)), (sumEtJets-sumEtJetsnoPU)/sumEtJets); - meJetsRecLVPURelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoPU)/sumPt2Jets); - meJetsRecLVFakeRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_,sumPt2Jets)), (sumPt2Jets-sumPt2JetsnoFake)/sumPt2Jets); - meJetsRecLVPURelMetPtvsMetPt_->Fill(log10(std::max(minThrMetPt_,metPt)), (metPt-metPtnoPU)/metPt); - meJetsRecLVPURelSumPzvsSumPz_->Fill(log10(std::max(minThrSumPz_,std::abs(sumPzJets))), (sumPzJets-sumPzJetsnoPU)/sumPzJets); + mePUTrackRecLVSumWnt_->Fill(log10(std::max(minThrSumWnt_, PUsumWnt))); + mePUTrackRecLVSumWos_->Fill(log10(std::max(minThrSumWos_, PUsumWos))); + meSecTrackRecLVSumWos_->Fill(log10(std::max(minThrSumWos_, PUsumWos))); + mePUTrackRecLVSumPt_->Fill(log10(std::max(minThrSumPt_, PUsumPt))); + mePUTrackRecLVSumPt2_->Fill(log10(std::max(minThrSumPt2_, PUsumPt2))); + + mePUTrackRecLVRelMultvsMult_->Fill(nt, static_cast(PUnt) / nt); + meFakeTrackRecLVRelMultvsMult_->Fill(nt, static_cast(Fakent) / nt); + mePUTrackRecLVRelSumWntvsSumWnt_->Fill(log10(std::max(minThrSumWnt_, sumWnt)), PUsumWnt / sumWnt); + mePUTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_, sumWos)), PUsumWos / sumWos); + meSecTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_, sumWos)), SecsumWos / sumWos); + meFakeTrackRecLVRelSumWosvsSumWos_->Fill(log10(std::max(minThrSumWos_, sumWos)), FakesumWos / sumWos); + mePUTrackRecLVRelSumPtvsSumPt_->Fill(log10(std::max(minThrSumPt_, sumPt)), PUsumPt / sumPt); + mePUTrackRecLVRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_, sumPt2)), PUsumPt2 / sumPt2); + + meJetsRecLVPUMult_->Fill(nJets - nJetsnoPU); + meJetsRecLVPUHt_->Fill(log10(std::max(minThrSumPt_, sumEtJets - sumEtJetsnoPU))); + meJetsRecLVPUSumPt2_->Fill(log10(std::max(minThrSumPt2_, sumPt2Jets - sumPt2JetsnoPU))); + meJetsRecLVPUMetPt_->Fill(log10(std::max(minThrMetPt_, metPt - metPtnoPU))); + meJetsRecLVPUSumPz_->Fill(log10(std::max(minThrSumPz_, std::abs(sumPzJets - sumPzJetsnoPU)))); + + meJetsRecLVPURelMultvsMult_->Fill(nJets, static_cast(nJets - nJetsnoPU) / nJets); + meJetsRecLVPURelHtvsHt_->Fill(log10(std::max(minThrSumPt_, sumEtJets)), + (sumEtJets - sumEtJetsnoPU) / sumEtJets); + meJetsRecLVPURelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_, sumPt2Jets)), + (sumPt2Jets - sumPt2JetsnoPU) / sumPt2Jets); + meJetsRecLVFakeRelSumPt2vsSumPt2_->Fill(log10(std::max(minThrSumPt2_, sumPt2Jets)), + (sumPt2Jets - sumPt2JetsnoFake) / sumPt2Jets); + meJetsRecLVPURelMetPtvsMetPt_->Fill(log10(std::max(minThrMetPt_, metPt)), (metPt - metPtnoPU) / metPt); + meJetsRecLVPURelSumPzvsSumPz_->Fill(log10(std::max(minThrSumPz_, std::abs(sumPzJets))), + (sumPzJets - sumPzJetsnoPU) / sumPzJets); } } } } // loop on simpv - } // ndof - } // loop on recopv + } // ndof + } // loop on recopv int real = 0; int fake = 0; @@ -2259,9 +2695,9 @@ void Primary4DVertexValidation::fillDescriptions(edm::ConfigurationDescriptions& } void Primary4DVertexValidation::printMatchedRecoTrackInfo(const reco::Vertex& vtx, - const reco::TrackBaseRef& trk, - const TrackingParticleRef& tp, - const unsigned int& categ) { + const reco::TrackBaseRef& trk, + const TrackingParticleRef& tp, + const unsigned int& categ) { std::string strTrk; switch (categ) { case 0: @@ -2274,42 +2710,40 @@ void Primary4DVertexValidation::printMatchedRecoTrackInfo(const reco::Vertex& vt strTrk = "PU_RecoTrk:"; break; } - edm::LogPrint("Primary4DVertexValidation") << strTrk << " w =" << std::setw(6) << std::setprecision(2) - << vtx.trackWeight(trk) << " pt =" << std::setw(6) - << std::setprecision(2) << trk->pt() << " eta =" - << std::setw(6) << std::setprecision(2) << trk->eta() - << " MatchedTP: Pt =" << std::setw(6) << std::setprecision(2) - << tp->pt() << " eta =" << std::setw(6) << std::setprecision(2) - << tp->eta() << " Parent vtx: z =" << std::setw(8) - << std::setprecision(4) << tp->parentVertex()->position().z() - << " t =" << std::setw(8) << std::setprecision(4) - << tp->parentVertex()->position().t() * simUnit_ << " BX =" - << tp->parentVertex()->eventId().bunchCrossing() << " ev =" - << tp->parentVertex()->eventId().event() << std::endl; + edm::LogPrint("Primary4DVertexValidation") + << strTrk << " w =" << std::setw(6) << std::setprecision(2) << vtx.trackWeight(trk) << " pt =" << std::setw(6) + << std::setprecision(2) << trk->pt() << " eta =" << std::setw(6) << std::setprecision(2) << trk->eta() + << " MatchedTP: Pt =" << std::setw(6) << std::setprecision(2) << tp->pt() << " eta =" << std::setw(6) + << std::setprecision(2) << tp->eta() << " Parent vtx: z =" << std::setw(8) << std::setprecision(4) + << tp->parentVertex()->position().z() << " t =" << std::setw(8) << std::setprecision(4) + << tp->parentVertex()->position().t() * simUnit_ << " BX =" << tp->parentVertex()->eventId().bunchCrossing() + << " ev =" << tp->parentVertex()->eventId().event() << std::endl; } -void Primary4DVertexValidation::printSimVtxRecoVtxInfo(const struct Primary4DVertexValidation::simPrimaryVertex& simpVtx, const struct Primary4DVertexValidation::recoPrimaryVertex& recopVtx) { - edm::LogPrint("Primary4DVertexValidation") << "Sim vtx (x,y,z,t) = (" << std::setprecision(4) << simpVtx.x << "," - << std::setprecision(4) << simpVtx.y << "," << std::setprecision(4) - << simpVtx.z << "," << std::setprecision(4) << simpVtx.t * simUnit_ << ")"; - edm::LogPrint("Primary4DVertexValidation") << "Sim vtx: pt = " << std::setprecision(4) << simpVtx.pt - << " ptsq = " << std::setprecision(6) << simpVtx.ptsq << " nGenTrk = " - << simpVtx.nGenTrk << " nmatch recotrks = " << simpVtx.num_matched_reco_tracks; - edm::LogPrint("Primary4DVertexValidation") << "Reco vtx (x,y,z) = (" << std::setprecision(4) << recopVtx.x << "," - << std::setprecision(4) << recopVtx.y << "," << std::setprecision(4) - << recopVtx.z << ")"; - edm::LogPrint("Primary4DVertexValidation") << "Reco vtx: pt = " << std::setprecision(4) << recopVtx.pt - << " ptsq = " << std::setprecision(6) << recopVtx.ptsq << " nrecotrks = " - << recopVtx.nRecoTrk << " nmatch simtrks = " << recopVtx.num_matched_sim_tracks; +void Primary4DVertexValidation::printSimVtxRecoVtxInfo( + const struct Primary4DVertexValidation::simPrimaryVertex& simpVtx, + const struct Primary4DVertexValidation::recoPrimaryVertex& recopVtx) { + edm::LogPrint("Primary4DVertexValidation") + << "Sim vtx (x,y,z,t) = (" << std::setprecision(4) << simpVtx.x << "," << std::setprecision(4) << simpVtx.y << "," + << std::setprecision(4) << simpVtx.z << "," << std::setprecision(4) << simpVtx.t * simUnit_ << ")"; + edm::LogPrint("Primary4DVertexValidation") + << "Sim vtx: pt = " << std::setprecision(4) << simpVtx.pt << " ptsq = " << std::setprecision(6) << simpVtx.ptsq + << " nGenTrk = " << simpVtx.nGenTrk << " nmatch recotrks = " << simpVtx.num_matched_reco_tracks; + edm::LogPrint("Primary4DVertexValidation") + << "Reco vtx (x,y,z) = (" << std::setprecision(4) << recopVtx.x << "," << std::setprecision(4) << recopVtx.y + << "," << std::setprecision(4) << recopVtx.z << ")"; + edm::LogPrint("Primary4DVertexValidation") + << "Reco vtx: pt = " << std::setprecision(4) << recopVtx.pt << " ptsq = " << std::setprecision(6) << recopVtx.ptsq + << " nrecotrks = " << recopVtx.nRecoTrk << " nmatch simtrks = " << recopVtx.num_matched_sim_tracks; edm::LogPrint("Primary4DVertexValidation") << "wnt " << recopVtx.sumwnt << " wos = " << recopVtx.sumwos; - for (auto iTP = simpVtx.sim_vertex->daughterTracks_begin(); iTP != simpVtx.sim_vertex->daughterTracks_end(); ++iTP) { - if (use_only_charged_tracks_ && (**iTP).charge() == 0) { - continue; - } - edm::LogPrint("Primary4DVertexValidation") << "Daughter track of sim vertex: pt =" << std::setw(6) - << std::setprecision(2) << (*iTP)->pt() << " eta =" - << std::setw(6) << std::setprecision(2) << (*iTP)->eta(); + for (auto iTP = simpVtx.sim_vertex->daughterTracks_begin(); iTP != simpVtx.sim_vertex->daughterTracks_end(); ++iTP) { + if (use_only_charged_tracks_ && (**iTP).charge() == 0) { + continue; } + edm::LogPrint("Primary4DVertexValidation") + << "Daughter track of sim vertex: pt =" << std::setw(6) << std::setprecision(2) << (*iTP)->pt() + << " eta =" << std::setw(6) << std::setprecision(2) << (*iTP)->eta(); + } } const bool Primary4DVertexValidation::mvaTPSel(const TrackingParticle& tp) {