CMS 3D CMS Logo
TkConvValidator.cc
Go to the documentation of this file.
1 #include <iostream>
2 //
3 #include "FWCore/ServiceRegistry/interface/Service.h"
4 #include "CommonTools/UtilAlgos/interface/TFileService.h"
5 //
6 #include "Validation/RecoEgamma/plugins/TkConvValidator.h"
7 
8 //
9 #include "FWCore/Framework/interface/MakerMacros.h"
10 #include "FWCore/MessageLogger/interface/MessageLogger.h"
11 #include "FWCore/Utilities/interface/Exception.h"
12 //
13 #include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
14 #include "SimDataFormats/Track/interface/SimTrack.h"
15 #include "SimDataFormats/Track/interface/SimTrackContainer.h"
16 #include "SimDataFormats/Vertex/interface/SimVertex.h"
17 #include "SimDataFormats/Vertex/interface/SimVertexContainer.h"
18 //
19 #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h"
20 #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"
21 #include "SimDataFormats/TrackingAnalysis/interface/TrackingVertexContainer.h"
22 //
23 #include "SimTracker/TrackerHitAssociation/interface/TrackerHitAssociator.h"
24 #include "SimTracker/Records/interface/TrackAssociatorRecord.h"
25 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
26 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
27 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
28 //
29 #include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h"
30 #include "TrackingTools/PatternTools/interface/TwoTrackMinimumDistance.h"
31 #include "TrackingTools/TransientTrack/interface/TrackTransientTrack.h"
32 //
33 #include "CLHEP/Units/GlobalPhysicalConstants.h"
34 #include "CommonTools/Statistics/interface/ChiSquaredProbability.h"
35 //
36 #include "MagneticField/Engine/interface/MagneticField.h"
37 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
38 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
39 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
40 #include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
41 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
42 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
43 #include "TrackingTools/MaterialEffects/interface/PropagatorWithMaterial.h"
44 
45 //
46 #include "DataFormats/Common/interface/Handle.h"
47 #include "DataFormats/TrackReco/interface/Track.h"
48 #include "DataFormats/TrackReco/interface/TrackExtra.h"
49 #include "DataFormats/TrackReco/interface/TrackFwd.h"
50 #include "DataFormats/EgammaCandidates/interface/Conversion.h"
51 #include "DataFormats/EgammaCandidates/interface/Photon.h"
52 #include "DataFormats/EgammaReco/interface/SuperCluster.h"
53 #include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h"
54 #include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
55 #include "DataFormats/EgammaReco/interface/BasicCluster.h"
56 #include "DataFormats/EgammaReco/interface/BasicCluster.h"
57 #include "DataFormats/EgammaReco/interface/BasicClusterFwd.h"
58 #include "DataFormats/CaloRecHit/interface/CaloCluster.h"
59 #include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h"
60 #include "DataFormats/DetId/interface/DetId.h"
61 #include "DataFormats/JetReco/interface/GenJetCollection.h"
62 #include "DataFormats/HepMCCandidate/interface/GenParticle.h"
63 #include "DataFormats/GeometrySurface/interface/BoundCylinder.h"
64 #include "DataFormats/GeometrySurface/interface/BoundDisk.h"
65 #include "DataFormats/GeometrySurface/interface/SimpleCylinderBounds.h"
66 #include "DataFormats/GeometrySurface/interface/SimpleDiskBounds.h"
67 #include "DataFormats/Math/interface/deltaPhi.h"
68 
69 //
70 #include "RecoEgamma/EgammaMCTools/interface/PhotonMCTruthFinder.h"
71 #include "RecoEgamma/EgammaMCTools/interface/PhotonMCTruth.h"
72 #include "RecoEgamma/EgammaMCTools/interface/ElectronMCTruth.h"
73 #include "RecoEcal/EgammaCoreTools/interface/EcalClusterTools.h"
74 #include "Geometry/CaloTopology/interface/CaloTopology.h"
75 #include "Geometry/Records/interface/CaloTopologyRecord.h"
76 
77 //
78 //
79 #include "TFile.h"
80 #include "TH1.h"
81 #include "TH2.h"
82 #include "TTree.h"
83 #include "TVector3.h"
84 #include "TProfile.h"
85 //
94 using namespace std;
95 
96 TkConvValidator::TkConvValidator(const edm::ParameterSet& pset)
97  : magneticFieldToken_{esConsumes<edm::Transition::BeginRun>()},
98  caloGeometryToken_{esConsumes()},
99  transientTrackBuilderToken_{esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))},
100  trackerGeometryToken_{esConsumes()} {
101  fName_ = pset.getUntrackedParameter<std::string>("Name");
102  verbosity_ = pset.getUntrackedParameter<int>("Verbosity");
103  parameters_ = pset;
104 
105  photonCollectionProducer_ = pset.getParameter<std::string>("phoProducer");
106  photonCollection_ = pset.getParameter<std::string>("photonCollection");
107  photonCollectionPr_Token_ =
108  consumes<reco::PhotonCollection>(edm::InputTag(photonCollectionProducer_, photonCollection_));
109 
110  conversionCollectionProducer_ = pset.getParameter<std::string>("convProducer");
111  conversionCollection_ = pset.getParameter<std::string>("conversionCollection");
112  conversionCollectionPr_Token_ =
113  consumes<reco::ConversionCollection>(edm::InputTag(conversionCollectionProducer_, conversionCollection_));
114 
115  // conversionTrackProducer_ = pset.getParameter<std::string>("trackProducer");
116  dqmpath_ = pset.getParameter<std::string>("dqmpath");
117  minPhoEtCut_ = pset.getParameter<double>("minPhoEtCut");
118  generalTracksOnly_ = pset.getParameter<bool>("generalTracksOnly");
119  arbitratedMerged_ = pset.getParameter<bool>("arbitratedMerged");
120  arbitratedEcalSeeded_ = pset.getParameter<bool>("arbitratedEcalSeeded");
121  ecalalgotracks_ = pset.getParameter<bool>("ecalalgotracks");
122  highPurity_ = pset.getParameter<bool>("highPurity");
123  minProb_ = pset.getParameter<double>("minProb");
124  maxHitsBeforeVtx_ = pset.getParameter<uint>("maxHitsBeforeVtx");
125  minLxy_ = pset.getParameter<double>("minLxy");
126  isRunCentrally_ = pset.getParameter<bool>("isRunCentrally");
127 
128  offline_pvToken_ = consumes<reco::VertexCollection>(
129  pset.getUntrackedParameter<edm::InputTag>("offlinePV", edm::InputTag("offlinePrimaryVertices")));
130  beamspotToken_ =
131  consumes<reco::BeamSpot>(pset.getUntrackedParameter<edm::InputTag>("beamspot", edm::InputTag("offlineBeamSpot")));
132  g4_simTk_Token_ = consumes<edm::SimTrackContainer>(pset.getParameter<edm::InputTag>("simTracks"));
133  g4_simVtx_Token_ = consumes<edm::SimVertexContainer>(pset.getParameter<edm::InputTag>("simTracks"));
134 
135  tpSelForEff_Token_ = consumes<TrackingParticleRefVector>(edm::InputTag("tpSelecForEfficiency"));
136  tpSelForFake_Token_ = consumes<TrackingParticleRefVector>(edm::InputTag("tpSelecForFakeRate"));
137  //hepMC_Token_ = consumes<edm::HepMCProduct>(edm::InputTag("generatorSmeared"));
138  //genjets_Token_ = consumes<reco::GenJetCollection>(
139  // edm::InputTag("ak4GenJets"));
140 
141  trackAssociator_Token_ =
142  consumes<reco::TrackToTrackingParticleAssociator>(edm::InputTag("trackAssociatorByHitsForConversionValidation"));
143 }
144 
145 TkConvValidator::~TkConvValidator() {}
146 
147 void TkConvValidator::bookHistograms(DQMStore::IBooker& iBooker, edm::Run const& run, edm::EventSetup const&) {
148  nEvt_ = 0;
149  nEntry_ = 0;
150  nRecConv_ = 0;
151  nRecConvAss_ = 0;
152  nRecConvAssWithEcal_ = 0;
153 
154  nInvalidPCA_ = 0;
155 
156  dbe_ = nullptr;
157  dbe_ = edm::Service<DQMStore>().operator->();
158 
159  double etMin = parameters_.getParameter<double>("etMin");
160  double etMax = parameters_.getParameter<double>("etMax");
161  int etBin = parameters_.getParameter<int>("etBin");
162 
163  double resMin = parameters_.getParameter<double>("resMin");
164  double resMax = parameters_.getParameter<double>("resMax");
165  int resBin = parameters_.getParameter<int>("resBin");
166 
167  double etaMin = parameters_.getParameter<double>("etaMin");
168  double etaMax = parameters_.getParameter<double>("etaMax");
169  int etaBin = parameters_.getParameter<int>("etaBin");
170  int etaBin2 = parameters_.getParameter<int>("etaBin2");
171 
172  double phiMin = parameters_.getParameter<double>("phiMin");
173  double phiMax = parameters_.getParameter<double>("phiMax");
174  int phiBin = parameters_.getParameter<int>("phiBin");
175 
176  double rMin = parameters_.getParameter<double>("rMin");
177  double rMax = parameters_.getParameter<double>("rMax");
178  int rBin = parameters_.getParameter<int>("rBin");
179 
180  double zMin = parameters_.getParameter<double>("zMin");
181  double zMax = parameters_.getParameter<double>("zMax");
182  int zBin = parameters_.getParameter<int>("zBin");
183 
184  double dPhiTracksMin = parameters_.getParameter<double>("dPhiTracksMin");
185  double dPhiTracksMax = parameters_.getParameter<double>("dPhiTracksMax");
186  int dPhiTracksBin = parameters_.getParameter<int>("dPhiTracksBin");
187 
188  double eoverpMin = parameters_.getParameter<double>("eoverpMin");
189  double eoverpMax = parameters_.getParameter<double>("eoverpMax");
190  int eoverpBin = parameters_.getParameter<int>("eoverpBin");
191 
192  // double dEtaTracksMin = parameters_.getParameter<double>("dEtaTracksMin"); // unused
193  // double dEtaTracksMax = parameters_.getParameter<double>("dEtaTracksMax"); // unused
194  // int dEtaTracksBin = parameters_.getParameter<int>("dEtaTracksBin"); // unused
195 
196  double dCotTracksMin = parameters_.getParameter<double>("dCotTracksMin");
197  double dCotTracksMax = parameters_.getParameter<double>("dCotTracksMax");
198  int dCotTracksBin = parameters_.getParameter<int>("dCotTracksBin");
199 
200  double chi2Min = parameters_.getParameter<double>("chi2Min");
201  double chi2Max = parameters_.getParameter<double>("chi2Max");
202 
203  double rMinForXray = parameters_.getParameter<double>("rMinForXray");
204  double rMaxForXray = parameters_.getParameter<double>("rMaxForXray");
205  int rBinForXray = parameters_.getParameter<int>("rBinForXray");
206  double zMinForXray = parameters_.getParameter<double>("zMinForXray");
207  double zMaxForXray = parameters_.getParameter<double>("zMaxForXray");
208  int zBinForXray = parameters_.getParameter<int>("zBinForXray");
209  int zBin2ForXray = parameters_.getParameter<int>("zBin2ForXray");
210 
211  minPhoPtForEffic = parameters_.getParameter<double>("minPhoPtForEffic");
212  maxPhoEtaForEffic = parameters_.getParameter<double>("maxPhoEtaForEffic");
213  maxPhoZForEffic = parameters_.getParameter<double>("maxPhoZForEffic");
214  maxPhoRForEffic = parameters_.getParameter<double>("maxPhoRForEffic");
215  minPhoPtForPurity = parameters_.getParameter<double>("minPhoPtForPurity");
216  maxPhoEtaForPurity = parameters_.getParameter<double>("maxPhoEtaForPurity");
217  maxPhoZForPurity = parameters_.getParameter<double>("maxPhoZForPurity");
218  maxPhoRForPurity = parameters_.getParameter<double>("maxPhoRForPurity");
219 
220  if (dbe_) {
222  // SC from reco photons
223 
224  //TString simfolder = TString(
225  std::string simpath = dqmpath_ + "SimulationInfo";
226  iBooker.setCurrentFolder(simpath);
227  //
228  // simulation information about conversions
230  std::string histname = "nOfSimConversions";
231  h_nSimConv_[0] = iBooker.book1D(histname, "# of Sim conversions per event ", 20, -0.5, 19.5);
233  histname = "h_AllSimConvEta";
234  h_AllSimConv_[0] = iBooker.book1D(histname, " All conversions: simulated #eta", etaBin2, etaMin, etaMax);
235  histname = "h_AllSimConvPhi";
236  h_AllSimConv_[1] = iBooker.book1D(histname, " All conversions: simulated #phi", phiBin, phiMin, phiMax);
237  histname = "h_AllSimConvR";
238  h_AllSimConv_[2] = iBooker.book1D(histname, " All conversions: simulated R", rBin, rMin, rMax);
239  histname = "h_AllSimConvZ";
240  h_AllSimConv_[3] = iBooker.book1D(histname, " All conversions: simulated Z", zBin, zMin, zMax);
241  histname = "h_AllSimConvEt";
242  h_AllSimConv_[4] = iBooker.book1D(histname, " All conversions: simulated Et", etBin, etMin, etMax);
243  //
244  histname = "nOfVisSimConversions";
245  h_nSimConv_[1] = iBooker.book1D(histname, "# of Sim conversions per event ", 20, -0.5, 19.5);
246  histname = "h_VisSimConvEta";
247  h_VisSimConv_[0] = iBooker.book1D(histname, " All vis conversions: simulated #eta", etaBin2, etaMin, etaMax);
248  histname = "h_VisSimConvPhi";
249  h_VisSimConv_[1] = iBooker.book1D(histname, " All vis conversions: simulated #phi", phiBin, phiMin, phiMax);
250  histname = "h_VisSimConvR";
251  h_VisSimConv_[2] = iBooker.book1D(histname, " All vis conversions: simulated R", rBin, rMin, rMax);
252  histname = "h_VisSimConvZ";
253  h_VisSimConv_[3] = iBooker.book1D(histname, " All vis conversions: simulated Z", zBin, zMin, zMax);
254  histname = "h_VisSimConvEt";
255  h_VisSimConv_[4] = iBooker.book1D(histname, " All vis conversions: simulated Et", etBin, etMin, etMax);
256 
257  //
258  histname = "h_SimConvTwoMTracksEta";
259  h_SimConvTwoMTracks_[0] = iBooker.book1D(
260  histname, " All vis conversions with 2 reco-matching tracks: simulated #eta", etaBin2, etaMin, etaMax);
261  histname = "h_SimConvTwoMTracksPhi";
262  h_SimConvTwoMTracks_[1] = iBooker.book1D(
263  histname, " All vis conversions with 2 reco-matching tracks: simulated #phi", phiBin, phiMin, phiMax);
264  histname = "h_SimConvTwoMTracksR";
265  h_SimConvTwoMTracks_[2] =
266  iBooker.book1D(histname, " All vis conversions with 2 reco-matching tracks: simulated R", rBin, rMin, rMax);
267  histname = "h_SimConvTwoMTracksZ";
268  h_SimConvTwoMTracks_[3] =
269  iBooker.book1D(histname, " All vis conversions with 2 reco-matching tracks: simulated Z", zBin, zMin, zMax);
270  histname = "h_SimConvTwoMTracksEt";
271  h_SimConvTwoMTracks_[4] =
272  iBooker.book1D(histname, " All vis conversions with 2 reco-matching tracks: simulated Et", etBin, etMin, etMax);
273  //
274  histname = "h_SimConvTwoTracksEta";
275  h_SimConvTwoTracks_[0] =
276  iBooker.book1D(histname, " All vis conversions with 2 reco tracks: simulated #eta", etaBin2, etaMin, etaMax);
277  histname = "h_SimConvTwoTracksPhi";
278  h_SimConvTwoTracks_[1] =
279  iBooker.book1D(histname, " All vis conversions with 2 reco tracks: simulated #phi", phiBin, phiMin, phiMax);
280  histname = "h_SimConvTwoTracksR";
281  h_SimConvTwoTracks_[2] =
282  iBooker.book1D(histname, " All vis conversions with 2 reco tracks: simulated R", rBin, rMin, rMax);
283  histname = "h_SimConvTwoTracksZ";
284  h_SimConvTwoTracks_[3] =
285  iBooker.book1D(histname, " All vis conversions with 2 reco tracks: simulated Z", zBin, zMin, zMax);
286  histname = "h_SimConvTwoTracksEt";
287  h_SimConvTwoTracks_[4] =
288  iBooker.book1D(histname, " All vis conversions with 2 reco tracks: simulated Et", etBin, etMin, etMax);
289  //
290  histname = "h_SimConvTwoMTracksEtaAndVtxPGT0";
291  h_SimConvTwoMTracksAndVtxPGT0_[0] = iBooker.book1D(
292  histname, " All vis conversions with 2 reco-matching tracks + vertex: simulated #eta", etaBin2, etaMin, etaMax);
293  histname = "h_SimConvTwoMTracksPhiAndVtxPGT0";
294  h_SimConvTwoMTracksAndVtxPGT0_[1] = iBooker.book1D(
295  histname, " All vis conversions with 2 reco-matching tracks + vertex: simulated #phi", phiBin, phiMin, phiMax);
296  histname = "h_SimConvTwoMTracksRAndVtxPGT0";
297  h_SimConvTwoMTracksAndVtxPGT0_[2] = iBooker.book1D(
298  histname, " All vis conversions with 2 reco-matching tracks + vertex: simulated R", rBin, rMin, rMax);
299  histname = "h_SimConvTwoMTracksZAndVtxPGT0";
300  h_SimConvTwoMTracksAndVtxPGT0_[3] = iBooker.book1D(
301  histname, " All vis conversions with 2 reco-matching tracks + vertex: simulated Z", zBin, zMin, zMax);
302  histname = "h_SimConvTwoMTracksEtAndVtxPGT0";
303  h_SimConvTwoMTracksAndVtxPGT0_[4] = iBooker.book1D(
304  histname, " All vis conversions with 2 reco-matching tracks + vertex: simulated Et", etBin, etMin, etMax);
305 
306  //
307  histname = "h_SimConvTwoMTracksEtaAndVtxPGT0005";
308  h_SimConvTwoMTracksAndVtxPGT0005_[0] = iBooker.book1D(
309  histname, " All vis conversions with 2 reco-matching tracks + vertex: simulated #eta", etaBin2, etaMin, etaMax);
310  histname = "h_SimConvTwoMTracksPhiAndVtxPGT0005";
311  h_SimConvTwoMTracksAndVtxPGT0005_[1] = iBooker.book1D(
312  histname, " All vis conversions with 2 reco-matching tracks + vertex: simulated #phi", phiBin, phiMin, phiMax);
313  histname = "h_SimConvTwoMTracksRAndVtxPGT0005";
314  h_SimConvTwoMTracksAndVtxPGT0005_[2] = iBooker.book1D(
315  histname, " All vis conversions with 2 reco-matching tracks + vertex: simulated R", rBin, rMin, rMax);
316  histname = "h_SimConvTwoMTracksZAndVtxPGT0005";
317  h_SimConvTwoMTracksAndVtxPGT0005_[3] = iBooker.book1D(
318  histname, " All vis conversions with 2 reco-matching tracks + vertex: simulated Z", zBin, zMin, zMax);
319  histname = "h_SimConvTwoMTracksEtAndVtxPGT0005";
320  h_SimConvTwoMTracksAndVtxPGT0005_[4] = iBooker.book1D(
321  histname, " All vis conversions with 2 reco-matching tracks + vertex: simulated Et", etBin, etMin, etMax);
322 
323  histname = "h_SimRecConvTwoMTracksEta";
324  h_SimRecConvTwoMTracks_[0] = iBooker.book1D(
325  histname, " All vis conversions with 2 reco-matching tracks: simulated #eta", etaBin2, etaMin, etaMax);
326  histname = "h_SimRecConvTwoMTracksPhi";
327  h_SimRecConvTwoMTracks_[1] = iBooker.book1D(
328  histname, " All vis conversions with 2 reco-matching tracks: simulated #phi", phiBin, phiMin, phiMax);
329  histname = "h_SimRecConvTwoMTracksR";
330  h_SimRecConvTwoMTracks_[2] =
331  iBooker.book1D(histname, " All vis conversions with 2 reco-matching tracks: simulated R", rBin, rMin, rMax);
332  histname = "h_SimRecConvTwoMTracksZ";
333  h_SimRecConvTwoMTracks_[3] =
334  iBooker.book1D(histname, " All vis conversions with 2 reco-matching tracks: simulated Z", zBin, zMin, zMax);
335  histname = "h_SimRecConvTwoMTracksEt";
336  h_SimRecConvTwoMTracks_[4] =
337  iBooker.book1D(histname, " All vis conversions with 2 reco-matching tracks: simulated Et", etBin, etMin, etMax);
338  //
339 
340  h_SimConvEtaPix_[0] = iBooker.book1D("simConvEtaPix", " sim converted Photon Eta: Pix ", etaBin, etaMin, etaMax);
341  h_simTkPt_ = iBooker.book1D("simTkPt", "Sim conversion tracks pt ", etBin * 3, 0., etMax);
342  h_simTkEta_ = iBooker.book1D("simTkEta", "Sim conversion tracks eta ", etaBin, etaMin, etaMax);
343 
344  h_simConvVtxRvsZ_[0] = iBooker.book2D("simConvVtxRvsZAll",
345  " Photon Sim conversion vtx position",
346  zBinForXray,
347  zMinForXray,
348  zMaxForXray,
349  rBinForXray,
350  rMinForXray,
351  rMaxForXray);
352  h_simConvVtxRvsZ_[1] = iBooker.book2D("simConvVtxRvsZBarrel",
353  " Photon Sim conversion vtx position",
354  zBinForXray,
355  zMinForXray,
356  zMaxForXray,
357  rBinForXray,
358  rMinForXray,
359  rMaxForXray);
360  h_simConvVtxRvsZ_[2] = iBooker.book2D("simConvVtxRvsZEndcap",
361  " Photon Sim conversion vtx position",
362  zBin2ForXray,
363  zMinForXray,
364  zMaxForXray,
365  rBinForXray,
366  rMinForXray,
367  rMaxForXray);
368  h_simConvVtxRvsZ_[3] = iBooker.book2D("simConvVtxRvsZBarrel2",
369  " Photon Sim conversion vtx position when reco R<4cm",
370  zBinForXray,
371  zMinForXray,
372  zMaxForXray,
373  rBinForXray,
374  rMinForXray,
375  rMaxForXray);
376  h_simConvVtxYvsX_ = iBooker.book2D(
377  "simConvVtxYvsXTrkBarrel", " Photon Sim conversion vtx position, (x,y) eta<1 ", 100, -80., 80., 100, -80., 80.);
378 
379  std::string convpath = dqmpath_ + "ConversionInfo";
380  iBooker.setCurrentFolder(convpath);
381 
382  histname = "nConv";
383  h_nConv_[0][0] = iBooker.book1D(
384  histname + "All", "Number Of Conversions per isolated candidates per events: All Ecal ", 10, -0.5, 9.5);
385  h_nConv_[0][1] = iBooker.book1D(
386  histname + "Barrel", "Number Of Conversions per isolated candidates per events: Ecal Barrel ", 10, -0.5, 9.5);
387  h_nConv_[0][2] = iBooker.book1D(
388  histname + "Endcap", "Number Of Conversions per isolated candidates per events: Ecal Endcap ", 10, -0.5, 9.5);
389  h_nConv_[1][0] = iBooker.book1D(histname + "All_Ass",
390  "Number Of associated Conversions per isolated candidates per events: All Ecal ",
391  10,
392  -0.5,
393  9.5);
394 
395  h_convEta_[0][0] = iBooker.book1D("convEta", " converted Photon Eta ", etaBin, etaMin, etaMax);
396  h_convEtaMatchSC_[0][0] =
397  iBooker.book1D("convEtaMatchSC", " converted Photon Eta when SC is matched ", etaBin, etaMin, etaMax);
398  h_convEta2_[0][0] = iBooker.book1D("convEta2", " converted Photon Eta ", etaBin2, etaMin, etaMax);
399  h_convPhi_[0][0] = iBooker.book1D("convPhi", " converted Photon Phi ", phiBin, phiMin, phiMax);
400  h_convR_[0][0] = iBooker.book1D("convR", " converted photon R", rBin, rMin, rMax);
401  h_convZ_[0][0] = iBooker.book1D("convZ", " converted photon Z", zBin, zMin, zMax);
402  h_convPt_[0][0] = iBooker.book1D("convPt", " conversions Transverse Energy: all eta ", etBin, etMin, etMax);
403 
404  h_convEta_[1][0] = iBooker.book1D("convEtaAss2", " Matched converted Photon Eta ", etaBin2, etaMin, etaMax);
405  h_convEta_[1][1] = iBooker.book1D("convEtaAss", " Matched converted Photon Eta ", etaBin, etaMin, etaMax);
406  h_convEtaMatchSC_[1][0] =
407  iBooker.book1D("convEtaMatchSCAss", " converted Photon Eta when SC is matched ", etaBin, etaMin, etaMax);
408  h_convPhi_[1][0] = iBooker.book1D("convPhiAss", " Matched converted Photon Phi ", phiBin, phiMin, phiMax);
409  h_convR_[1][0] = iBooker.book1D("convRAss", " Matched converted photon R", rBin, rMin, rMax);
410  h_convZ_[1][0] = iBooker.book1D("convZAss", " Matched converted photon Z", zBin, zMin, zMax);
411  h_convPt_[1][0] =
412  iBooker.book1D("convPtAss", "Matched conversions Transverse Energy: all eta ", etBin, etMin, etMax);
413 
414  h_convEta_[2][0] = iBooker.book1D("convEtaFake2", " Fake converted Photon Eta ", etaBin2, etaMin, etaMax);
415  h_convEta_[2][1] = iBooker.book1D("convEtaFake", " Fake converted Photon Eta ", etaBin, etaMin, etaMax);
416  h_convEtaMatchSC_[2][0] =
417  iBooker.book1D("convEtaMatchSCFake", " converted Photon Eta when SC is matched ", etaBin, etaMin, etaMax);
418  h_convPhi_[2][0] = iBooker.book1D("convPhiFake", " Fake converted Photon Phi ", phiBin, phiMin, phiMax);
419  h_convR_[2][0] = iBooker.book1D("convRFake", " Fake converted photon R", rBin, rMin, rMax);
420  h_convZ_[2][0] = iBooker.book1D("convZFake", " Fake converted photon Z", zBin, zMin, zMax);
421  h_convPt_[2][0] = iBooker.book1D("convPtFake", "Fake conversions Transverse Energy: all eta ", etBin, etMin, etMax);
422 
423  h_convRplot_ = iBooker.book1D("convRplot", " converted photon R", 600, 0., 120.);
424  h_convZplot_ = iBooker.book1D("convZplot", " converted photon Z", 320, -160., 160.);
425 
426  histname = "convSCdPhi";
427  h_convSCdPhi_[0][0] = iBooker.book1D(histname + "All", "dPhi between SC and conversion", 100, -0.1, 0.1);
428  h_convSCdPhi_[0][1] =
429  iBooker.book1D(histname + "Barrel", " dPhi between SC and conversion: Barrel", 100, -0.1, 0.1);
430  h_convSCdPhi_[0][2] =
431  iBooker.book1D(histname + "Endcap", " dPhi between SC and conversion: Endcap", 100, -0.1, 0.1);
432  h_convSCdPhi_[1][0] = iBooker.book1D(histname + "All_Ass", "dPhi between SC and conversion", 100, -0.1, 0.1);
433  h_convSCdPhi_[1][1] =
434  iBooker.book1D(histname + "Barrel_Ass", " dPhi between SC and conversion: Barrel", 100, -0.1, 0.1);
435  h_convSCdPhi_[1][2] =
436  iBooker.book1D(histname + "Endcap_Ass", " dPhi between SC and conversion: Endcap", 100, -0.1, 0.1);
437  h_convSCdPhi_[2][0] = iBooker.book1D(histname + "All_Fakes", "dPhi between SC and conversion", 100, -0.1, 0.1);
438  h_convSCdPhi_[2][1] =
439  iBooker.book1D(histname + "Barrel_Fakes", " dPhi between SC and conversion: Barrel", 100, -0.1, 0.1);
440  h_convSCdPhi_[2][2] =
441  iBooker.book1D(histname + "Endcap_Fakes", " dPhi between SC and conversion: Endcap", 100, -0.1, 0.1);
442  histname = "convSCdEta";
443  h_convSCdEta_[0][0] = iBooker.book1D(histname + "All", " dEta between SC and conversion", 100, -0.1, 0.1);
444  h_convSCdEta_[0][1] =
445  iBooker.book1D(histname + "Barrel", " dEta between SC and conversion: Barrel", 100, -0.1, 0.1);
446  h_convSCdEta_[0][2] =
447  iBooker.book1D(histname + "Endcap", " dEta between SC and conversion: Endcap", 100, -0.1, 0.1);
448  h_convSCdEta_[1][0] = iBooker.book1D(histname + "All_Ass", " dEta between SC and conversion", 100, -0.1, 0.1);
449  h_convSCdEta_[1][1] =
450  iBooker.book1D(histname + "Barrel_Ass", " dEta between SC and conversion: Barrel", 100, -0.1, 0.1);
451  h_convSCdEta_[1][2] =
452  iBooker.book1D(histname + "Endcap_Ass", " dEta between SC and conversion: Endcap", 100, -0.1, 0.1);
453  h_convSCdEta_[2][0] = iBooker.book1D(histname + "All_Fakes", " dEta between SC and conversion", 100, -0.1, 0.1);
454  h_convSCdEta_[2][1] =
455  iBooker.book1D(histname + "Barrel_Fakes", " dEta between SC and conversion: Barrel", 100, -0.1, 0.1);
456  h_convSCdEta_[2][2] =
457  iBooker.book1D(histname + "Endcap_Fakes", " dEta between SC and conversion: Endcap", 100, -0.1, 0.1);
458 
459  histname = "convPtRes";
460  h_convPtRes_[0] = iBooker.book1D(histname + "All", " Conversion Pt rec/true : All ecal ", resBin, resMin, resMax);
461  h_convPtRes_[1] = iBooker.book1D(histname + "Barrel", " Conversion Pt rec/true : Barrel ", resBin, resMin, resMax);
462  h_convPtRes_[2] = iBooker.book1D(histname + "Endcap", " Conversion Pt rec/true : Endcap ", resBin, resMin, resMax);
463 
464  histname = "hInvMass";
465  h_invMass_[0][0] = iBooker.book1D(
466  histname + "All_AllTracks", " Photons:Tracks from conversion: Pair invariant mass: all Ecal ", 100, 0., 1.5);
467  h_invMass_[0][1] = iBooker.book1D(histname + "Barrel_AllTracks",
468  " Photons:Tracks from conversion: Pair invariant mass: Barrel Ecal ",
469  100,
470  0.,
471  1.5);
472  h_invMass_[0][2] = iBooker.book1D(histname + "Endcap_AllTracks",
473  " Photons:Tracks from conversion: Pair invariant mass: Endcap Ecal ",
474  100,
475  0.,
476  1.5);
477  //
478  h_invMass_[1][0] = iBooker.book1D(
479  histname + "All_AssTracks", " Photons:Tracks from conversion: Pair invariant mass: all Ecal ", 100, 0., 1.5);
480  h_invMass_[1][1] = iBooker.book1D(histname + "Barrel_AssTracks",
481  " Photons:Tracks from conversion: Pair invariant mass: Barrel Ecal ",
482  100,
483  0.,
484  1.5);
485  h_invMass_[1][2] = iBooker.book1D(histname + "Endcap_AssTracks",
486  " Photons:Tracks from conversion: Pair invariant mass: Endcap Ecal ",
487  100,
488  0.,
489  1.5);
490  //
491  h_invMass_[2][0] = iBooker.book1D(
492  histname + "All_FakeTracks", " Photons:Tracks from conversion: Pair invariant mass: all Ecal ", 100, 0., 1.5);
493  h_invMass_[2][1] = iBooker.book1D(histname + "Barrel_FakeTracks",
494  " Photons:Tracks from conversion: Pair invariant mass: Barrel Ecal ",
495  100,
496  0.,
497  1.5);
498  h_invMass_[2][2] = iBooker.book1D(histname + "Endcap_FaleTracks",
499  " Photons:Tracks from conversion: Pair invariant mass: Endcap Ecal ",
500  100,
501  0.,
502  1.5);
503 
504  histname = "hDPhiTracksAtVtx";
505  h_DPhiTracksAtVtx_[0][0] = iBooker.book1D(histname + "All",
506  " Photons:Tracks from conversions: #delta#phi Tracks at vertex: all Ecal",
507  dPhiTracksBin,
508  dPhiTracksMin,
509  dPhiTracksMax);
510  h_DPhiTracksAtVtx_[0][1] =
511  iBooker.book1D(histname + "Barrel",
512  " Photons:Tracks from conversions: #delta#phi Tracks at vertex: Barrel Ecal",
513  dPhiTracksBin,
514  dPhiTracksMin,
515  dPhiTracksMax);
516  h_DPhiTracksAtVtx_[0][2] =
517  iBooker.book1D(histname + "Endcap",
518  " Photons:Tracks from conversions: #delta#phi Tracks at vertex: Endcap Ecal",
519  dPhiTracksBin,
520  dPhiTracksMin,
521  dPhiTracksMax);
522  h_DPhiTracksAtVtx_[1][0] = iBooker.book1D(histname + "All_Ass",
523  " Photons:Tracks from conversions: #delta#phi Tracks at vertex: all Ecal",
524  dPhiTracksBin,
525  dPhiTracksMin,
526  dPhiTracksMax);
527  h_DPhiTracksAtVtx_[1][1] =
528  iBooker.book1D(histname + "Barrel_Ass",
529  " Photons:Tracks from conversions: #delta#phi Tracks at vertex: Barrel Ecal",
530  dPhiTracksBin,
531  dPhiTracksMin,
532  dPhiTracksMax);
533  h_DPhiTracksAtVtx_[1][2] =
534  iBooker.book1D(histname + "Endcap_Ass",
535  " Photons:Tracks from conversions: #delta#phi Tracks at vertex: Endcap Ecal",
536  dPhiTracksBin,
537  dPhiTracksMin,
538  dPhiTracksMax);
539  h_DPhiTracksAtVtx_[2][0] = iBooker.book1D(histname + "All_Fakes",
540  " Photons:Tracks from conversions: #delta#phi Tracks at vertex: all Ecal",
541  dPhiTracksBin,
542  dPhiTracksMin,
543  dPhiTracksMax);
544  h_DPhiTracksAtVtx_[2][1] =
545  iBooker.book1D(histname + "Barrel_Fakes",
546  " Photons:Tracks from conversions: #delta#phi Tracks at vertex: Barrel Ecal",
547  dPhiTracksBin,
548  dPhiTracksMin,
549  dPhiTracksMax);
550  h_DPhiTracksAtVtx_[2][2] =
551  iBooker.book1D(histname + "Endcap_Fakes",
552  " Photons:Tracks from conversions: #delta#phi Tracks at vertex: Endcap Ecal",
553  dPhiTracksBin,
554  dPhiTracksMin,
555  dPhiTracksMax);
556 
557  histname = "hDPhiTracksAtVtxVsEta";
558  h2_DPhiTracksAtVtxVsEta_ = iBooker.book2D(histname + "All",
559  " Photons:Tracks from conversions: #delta#phi Tracks at vertex vs #eta",
560  etaBin2,
561  etaMin,
562  etaMax,
563  100,
564  -0.5,
565  0.5);
566  histname = "pDPhiTracksAtVtxVsEta";
567  p_DPhiTracksAtVtxVsEta_ =
568  iBooker.bookProfile(histname + "All",
569  " Photons:Tracks from conversions: #delta#phi Tracks at vertex vs #eta ",
570  etaBin2,
571  etaMin,
572  etaMax,
573  100,
574  -0.5,
575  0.5,
576  "");
577 
578  histname = "hDPhiTracksAtVtxVsR";
579  h2_DPhiTracksAtVtxVsR_ = iBooker.book2D(histname + "All",
580  " Photons:Tracks from conversions: #delta#phi Tracks at vertex vs R",
581  rBin,
582  rMin,
583  rMax,
584  100,
585  -0.5,
586  0.5);
587  histname = "pDPhiTracksAtVtxVsR";
588  p_DPhiTracksAtVtxVsR_ = iBooker.bookProfile(histname + "All",
589  " Photons:Tracks from conversions: #delta#phi Tracks at vertex vs R ",
590  rBin,
591  rMin,
592  rMax,
593  100,
594  -0.5,
595  0.5,
596  "");
597 
598  histname = "hDCotTracks";
599  h_DCotTracks_[0][0] = iBooker.book1D(histname + "All",
600  " Photons:Tracks from conversions #delta cotg(#Theta) Tracks: all Ecal ",
601  dCotTracksBin,
602  dCotTracksMin,
603  dCotTracksMax);
604  h_DCotTracks_[0][1] = iBooker.book1D(histname + "Barrel",
605  " Photons:Tracks from conversions #delta cotg(#Theta) Tracks: Barrel Ecal ",
606  dCotTracksBin,
607  dCotTracksMin,
608  dCotTracksMax);
609  h_DCotTracks_[0][2] = iBooker.book1D(histname + "Endcap",
610  " Photons:Tracks from conversions #delta cotg(#Theta) Tracks: Endcap Ecal ",
611  dCotTracksBin,
612  dCotTracksMin,
613  dCotTracksMax);
614  h_DCotTracks_[1][0] = iBooker.book1D(histname + "All_Ass",
615  " Photons:Tracks from conversions #delta cotg(#Theta) Tracks: all Ecal ",
616  dCotTracksBin,
617  dCotTracksMin,
618  dCotTracksMax);
619  h_DCotTracks_[1][1] = iBooker.book1D(histname + "Barrel_Ass",
620  " Photons:Tracks from conversions #delta cotg(#Theta) Tracks: Barrel Ecal ",
621  dCotTracksBin,
622  dCotTracksMin,
623  dCotTracksMax);
624  h_DCotTracks_[1][2] = iBooker.book1D(histname + "Endcap_Ass",
625  " Photons:Tracks from conversions #delta cotg(#Theta) Tracks: Endcap Ecal ",
626  dCotTracksBin,
627  dCotTracksMin,
628  dCotTracksMax);
629  h_DCotTracks_[2][0] = iBooker.book1D(histname + "All_Fakes",
630  " Photons:Tracks from conversions #delta cotg(#Theta) Tracks: all Ecal ",
631  dCotTracksBin,
632  dCotTracksMin,
633  dCotTracksMax);
634  h_DCotTracks_[2][1] = iBooker.book1D(histname + "Barrel_Fakes",
635  " Photons:Tracks from conversions #delta cotg(#Theta) Tracks: Barrel Ecal ",
636  dCotTracksBin,
637  dCotTracksMin,
638  dCotTracksMax);
639  h_DCotTracks_[2][2] = iBooker.book1D(histname + "Endcap_Fakes",
640  " Photons:Tracks from conversions #delta cotg(#Theta) Tracks: Endcap Ecal ",
641  dCotTracksBin,
642  dCotTracksMin,
643  dCotTracksMax);
644 
645  histname = "hDCotTracksVsEta";
646  h2_DCotTracksVsEta_ = iBooker.book2D(histname + "All",
647  " Photons:Tracks from conversions: #delta cotg(#Theta) Tracks vs #eta",
648  etaBin2,
649  etaMin,
650  etaMax,
651  100,
652  -0.2,
653  0.2);
654  histname = "pDCotTracksVsEta";
655  p_DCotTracksVsEta_ = iBooker.bookProfile(histname + "All",
656  " Photons:Tracks from conversions: #delta cotg(#Theta) Tracks vs #eta ",
657  etaBin2,
658  etaMin,
659  etaMax,
660  100,
661  -0.2,
662  0.2,
663  "");
664 
665  histname = "hDCotTracksVsR";
666  h2_DCotTracksVsR_ = iBooker.book2D(histname + "All",
667  " Photons:Tracks from conversions: #delta cotg(#Theta) Tracks at vertex vs R",
668  rBin,
669  rMin,
670  rMax,
671  100,
672  -0.2,
673  0.2);
674  histname = "pDCotTracksVsR";
675  p_DCotTracksVsR_ =
676  iBooker.bookProfile(histname + "All",
677  " Photons:Tracks from conversions: #delta cotg(#Theta) Tracks at vertex vs R ",
678  rBin,
679  rMin,
680  rMax,
681  100,
682  -0.2,
683  0.2,
684  "");
685 
686  histname = "hDistMinAppTracks";
687  h_distMinAppTracks_[0][0] = iBooker.book1D(
688  histname + "All", " Photons:Tracks from conversions Min Approach Dist Tracks: all Ecal ", 120, -0.5, 1.0);
689  h_distMinAppTracks_[0][1] = iBooker.book1D(
690  histname + "Barrel", " Photons:Tracks from conversions Min Approach Dist Tracks: Barrel Ecal ", 120, -0.5, 1.0);
691  h_distMinAppTracks_[0][2] = iBooker.book1D(
692  histname + "Endcap", " Photons:Tracks from conversions Min Approach Dist Tracks: Endcap Ecal ", 120, -0.5, 1.0);
693  h_distMinAppTracks_[1][0] = iBooker.book1D(
694  histname + "All_Ass", " Photons:Tracks from conversions Min Approach Dist Tracks: all Ecal ", 120, -0.5, 1.0);
695  h_distMinAppTracks_[1][1] =
696  iBooker.book1D(histname + "Barrel_Ass",
697  " Photons:Tracks from conversions Min Approach Dist Tracks: Barrel Ecal ",
698  120,
699  -0.5,
700  1.0);
701  h_distMinAppTracks_[1][2] =
702  iBooker.book1D(histname + "Endcap_Ass",
703  " Photons:Tracks from conversions Min Approach Dist Tracks: Endcap Ecal ",
704  120,
705  -0.5,
706  1.0);
707  h_distMinAppTracks_[2][0] = iBooker.book1D(
708  histname + "All_Fakes", " Photons:Tracks from conversions Min Approach Dist Tracks: all Ecal ", 120, -0.5, 1.0);
709  h_distMinAppTracks_[2][1] =
710  iBooker.book1D(histname + "Barrel_Fakes",
711  " Photons:Tracks from conversions Min Approach Dist Tracks: Barrel Ecal ",
712  120,
713  -0.5,
714  1.0);
715  h_distMinAppTracks_[2][2] =
716  iBooker.book1D(histname + "Endcap_Fakes",
717  " Photons:Tracks from conversions Min Approach Dist Tracks: Endcap Ecal ",
718  120,
719  -0.5,
720  1.0);
721 
722  h_convVtxRvsZ_[0] = iBooker.book2D("convVtxRvsZAll",
723  " Photon Reco conversion vtx position",
724  zBinForXray,
725  zMinForXray,
726  zMaxForXray,
727  rBinForXray,
728  rMinForXray,
729  rMaxForXray);
730  h_convVtxRvsZ_[1] = iBooker.book2D("convVtxRvsZBarrel",
731  " Photon Reco conversion vtx position",
732  zBinForXray,
733  zMinForXray,
734  zMaxForXray,
735  rBinForXray,
736  rMinForXray,
737  rMaxForXray);
738  h_convVtxRvsZ_[2] = iBooker.book2D("convVtxRvsZEndcap",
739  " Photon Reco conversion vtx position",
740  zBin2ForXray,
741  zMinForXray,
742  zMaxForXray,
743  rBinForXray,
744  rMinForXray,
745  rMaxForXray);
746  h_convVtxYvsX_ = iBooker.book2D(
747  "convVtxYvsXTrkBarrel", " Photon Reco conversion vtx position, (x,y) eta<1 ", 1000, -60., 60., 1000, -60., 60.);
749  h_convVtxRvsZ_zoom_[0] = iBooker.book2D("convVtxRvsZBarrelZoom1",
750  " Photon Reco conversion vtx position",
751  zBinForXray,
752  zMinForXray,
753  zMaxForXray,
754  rBinForXray,
755  -10.,
756  40.);
757  h_convVtxRvsZ_zoom_[1] = iBooker.book2D("convVtxRvsZBarrelZoom2",
758  " Photon Reco conversion vtx position",
759  zBinForXray,
760  zMinForXray,
761  zMaxForXray,
762  rBinForXray,
763  -10.,
764  20.);
765  h_convVtxYvsX_zoom_[0] = iBooker.book2D("convVtxYvsXTrkBarrelZoom1",
766  " Photon Reco conversion vtx position, (x,y) eta<1 ",
767  100,
768  -40.,
769  40.,
770  100,
771  -40.,
772  40.);
773  h_convVtxYvsX_zoom_[1] = iBooker.book2D("convVtxYvsXTrkBarrelZoom2",
774  " Photon Reco conversion vtx position, (x,y) eta<1 ",
775  100,
776  -20.,
777  20.,
778  100,
779  -20.,
780  20.);
781 
782  h_convVtxdR_ = iBooker.book1D("convVtxdR", " Photon Reco conversion vtx dR", 100, -10., 10.);
783  h_convVtxdX_ = iBooker.book1D("convVtxdX", " Photon Reco conversion vtx dX", 100, -10., 10.);
784  h_convVtxdY_ = iBooker.book1D("convVtxdY", " Photon Reco conversion vtx dY", 100, -10., 10.);
785  h_convVtxdZ_ = iBooker.book1D("convVtxdZ", " Photon Reco conversion vtx dZ", 100, -20., 20.);
786 
787  h_convVtxdPhi_ = iBooker.book1D("convVtxdPhi", " Photon Reco conversion vtx dPhi", 100, -0.01, 0.01);
788  h_convVtxdEta_ = iBooker.book1D("convVtxdEta", " Photon Reco conversion vtx dEta", 100, -0.5, 0.5);
789 
790  h_convVtxdR_barrel_ =
791  iBooker.book1D("convVtxdR_barrel", " Photon Reco conversion vtx dR, |eta|<=1.2", 100, -10., 10.);
792  h_convVtxdX_barrel_ =
793  iBooker.book1D("convVtxdX_barrel", " Photon Reco conversion vtx dX, |eta|<=1.2", 100, -10., 10.);
794  h_convVtxdY_barrel_ =
795  iBooker.book1D("convVtxdY_barrel", " Photon Reco conversion vtx dY, |eta|<=1.2 ", 100, -10., 10.);
796  h_convVtxdZ_barrel_ =
797  iBooker.book1D("convVtxdZ_barrel", " Photon Reco conversion vtx dZ, |eta|<=1.2,", 100, -20., 20.);
798 
799  h_convVtxdR_endcap_ =
800  iBooker.book1D("convVtxdR_endcap", " Photon Reco conversion vtx dR, |eta|>1.2 ", 100, -10., 10.);
801  h_convVtxdX_endcap_ =
802  iBooker.book1D("convVtxdX_endcap", " Photon Reco conversion vtx dX, |eta|>1.2", 100, -10., 10.);
803  h_convVtxdY_endcap_ =
804  iBooker.book1D("convVtxdY_endcap", " Photon Reco conversion vtx dY, |eta|>1.2", 100, -10., 10.);
805  h_convVtxdZ_endcap_ =
806  iBooker.book1D("convVtxdZ_endcap", " Photon Reco conversion vtx dZ, |eta|>1.2", 100, -20., 20.);
807 
808  h2_convVtxdRVsR_ = iBooker.book2D("h2ConvVtxdRVsR", " Conversion vtx dR vsR", rBin, rMin, rMax, 100, -20., 20.);
809  h2_convVtxdRVsEta_ =
810  iBooker.book2D("h2ConvVtxdRVsEta", "Conversion vtx dR vs Eta", etaBin2, etaMin, etaMax, 100, -20., 20.);
811 
812  p_convVtxdRVsR_ =
813  iBooker.bookProfile("pConvVtxdRVsR", " Conversion vtx dR vsR", rBin, rMin, rMax, 100, -20., 20., "");
814  p_convVtxdRVsEta_ =
815  iBooker.bookProfile("pConvVtxdRVsEta", "Conversion vtx dR vs Eta", etaBin2, etaMin, etaMax, 100, -20., 20., "");
816  p_convVtxdXVsX_ = iBooker.bookProfile("pConvVtxdXVsX", "Conversion vtx dX vs X", 120, -60, 60, 100, -20., 20., "");
817  p_convVtxdYVsY_ = iBooker.bookProfile("pConvVtxdYVsY", "Conversion vtx dY vs Y", 120, -60, 60, 100, -20., 20., "");
818  p_convVtxdZVsZ_ =
819  iBooker.bookProfile("pConvVtxdZVsZ", "Conversion vtx dZ vs Z", zBin, zMin, zMax, 100, -20., 20., "");
820 
821  p_convVtxdZVsR_ =
822  iBooker.bookProfile("pConvVtxdZVsR", "Conversion vtx dZ vs R", rBin, rMin, rMax, 100, -20., 20., "");
823  p2_convVtxdRVsRZ_ = iBooker.bookProfile2D(
824  "p2ConvVtxdRVsRZ", "Conversion vtx dR vs RZ", zBin, zMin, zMax, rBin, rMin, rMax, 100, 0., 20., "s");
825  p2_convVtxdZVsRZ_ = iBooker.bookProfile2D(
826  "p2ConvVtxdZVsRZ", "Conversion vtx dZ vs RZ", zBin, zMin, zMax, rBin, rMin, rMax, 100, 0., 20., "s");
827 
828  histname = "EoverPtracks";
829  h_EoverPTracks_[0][0] =
830  iBooker.book1D(histname + "All", " photons conversion E/p: all Ecal ", eoverpBin, eoverpMin, eoverpMax);
831  h_EoverPTracks_[0][1] =
832  iBooker.book1D(histname + "Barrel", " photons conversion E/p: Barrel Ecal", eoverpBin, eoverpMin, eoverpMax);
833  h_EoverPTracks_[0][2] =
834  iBooker.book1D(histname + "Endcap", " photons conversion E/p: Endcap Ecal ", eoverpBin, eoverpMin, eoverpMax);
835  h_EoverPTracks_[1][0] =
836  iBooker.book1D(histname + "All_Ass", " photons conversion E/p: all Ecal ", eoverpBin, eoverpMin, eoverpMax);
837  h_EoverPTracks_[1][1] = iBooker.book1D(
838  histname + "Barrel_Ass", " photons conversion E/p: Barrel Ecal", eoverpBin, eoverpMin, eoverpMax);
839  h_EoverPTracks_[1][2] = iBooker.book1D(
840  histname + "Endcap_Ass", " photons conversion E/p: Endcap Ecal ", eoverpBin, eoverpMin, eoverpMax);
841  h_EoverPTracks_[2][0] =
842  iBooker.book1D(histname + "All_Fakes", " photons conversion E/p: all Ecal ", eoverpBin, eoverpMin, eoverpMax);
843  h_EoverPTracks_[2][1] = iBooker.book1D(
844  histname + "Barrel_Fakes", " photons conversion E/p: Barrel Ecal", eoverpBin, eoverpMin, eoverpMax);
845  h_EoverPTracks_[2][2] = iBooker.book1D(
846  histname + "Endcap_Fakes", " photons conversion E/p: Endcap Ecal ", eoverpBin, eoverpMin, eoverpMax);
847 
848  h2_convVtxRrecVsTrue_ = iBooker.book2D(
849  "h2ConvVtxRrecVsTrue", "Photon Reco conversion vtx R rec vs true", rBin, rMin, rMax, rBin, rMin, rMax);
850 
851  histname = "vtxChi2Prob";
852  h_vtxChi2Prob_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 100, 0., 1.);
853  h_vtxChi2Prob_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 100, 0., 1.);
854  h_vtxChi2Prob_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 100, 0., 1.);
855  h_vtxChi2Prob_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 100, 0., 1.);
856  h_vtxChi2Prob_[1][1] = iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 100, 0., 1.);
857  h_vtxChi2Prob_[1][2] = iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 100, 0., 1.);
858  h_vtxChi2Prob_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 100, 0., 1.);
859  h_vtxChi2Prob_[2][1] = iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 100, 0., 1.);
860  h_vtxChi2Prob_[2][2] = iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 100, 0., 1.);
861 
862  h_zPVFromTracks_[1] = iBooker.book1D("zPVFromTracks", " Photons: PV z from conversion tracks", 100, -25., 25.);
863  h_dzPVFromTracks_[1] =
864  iBooker.book1D("dzPVFromTracks", " Photons: PV Z_rec - Z_true from conversion tracks", 100, -5., 5.);
865  h2_dzPVVsR_ = iBooker.book2D("h2dzPVVsR", "Photon Reco conversions: dz(PV) vs R", rBin, rMin, rMax, 100, -3., 3.);
866  p_dzPVVsR_ =
867  iBooker.bookProfile("pdzPVVsR", "Photon Reco conversions: dz(PV) vs R", rBin, rMin, rMax, 100, -3., 3., "");
868 
869  histname = "lxybs";
870  h_lxybs_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 200, -100., 100.);
871  h_lxybs_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 200, -100., 100.);
872  h_lxybs_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 200, -100., 100.);
873  h_lxybs_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 200, -100., 100.);
874  h_lxybs_[1][1] = iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 200, -100., 100.);
875  h_lxybs_[1][2] = iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 200, -100., 100.);
876  h_lxybs_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 200, -100., 100.);
877  h_lxybs_[2][1] = iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 200, -100., 100.);
878  h_lxybs_[2][2] = iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 200, -100., 100.);
879 
880  histname = "maxNHitsBeforeVtx";
881  h_maxNHitsBeforeVtx_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 16, -0.5, 15.5);
882  h_maxNHitsBeforeVtx_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
883  h_maxNHitsBeforeVtx_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
884  h_maxNHitsBeforeVtx_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 16, -0.5, 15.5);
885  h_maxNHitsBeforeVtx_[1][1] = iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
886  h_maxNHitsBeforeVtx_[1][2] = iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
887  h_maxNHitsBeforeVtx_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 16, -0.5, 15.5);
888  h_maxNHitsBeforeVtx_[2][1] = iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
889  h_maxNHitsBeforeVtx_[2][2] = iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
890 
891  histname = "leadNHitsBeforeVtx";
892  h_leadNHitsBeforeVtx_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 16, -0.5, 15.5);
893  h_leadNHitsBeforeVtx_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
894  h_leadNHitsBeforeVtx_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
895  h_leadNHitsBeforeVtx_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 16, -0.5, 15.5);
896  h_leadNHitsBeforeVtx_[1][1] = iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
897  h_leadNHitsBeforeVtx_[1][2] = iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
898  h_leadNHitsBeforeVtx_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 16, -0.5, 15.5);
899  h_leadNHitsBeforeVtx_[2][1] = iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
900  h_leadNHitsBeforeVtx_[2][2] = iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
901 
902  histname = "trailNHitsBeforeVtx";
903  h_trailNHitsBeforeVtx_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 16, -0.5, 15.5);
904  h_trailNHitsBeforeVtx_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
905  h_trailNHitsBeforeVtx_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
906  h_trailNHitsBeforeVtx_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 16, -0.5, 15.5);
907  h_trailNHitsBeforeVtx_[1][1] = iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
908  h_trailNHitsBeforeVtx_[1][2] = iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
909  h_trailNHitsBeforeVtx_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 16, -0.5, 15.5);
910  h_trailNHitsBeforeVtx_[2][1] = iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
911  h_trailNHitsBeforeVtx_[2][2] = iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
912 
913  histname = "sumNHitsBeforeVtx";
914  h_sumNHitsBeforeVtx_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 16, -0.5, 15.5);
915  h_sumNHitsBeforeVtx_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
916  h_sumNHitsBeforeVtx_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
917  h_sumNHitsBeforeVtx_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 16, -0.5, 15.5);
918  h_sumNHitsBeforeVtx_[1][1] = iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
919  h_sumNHitsBeforeVtx_[1][2] = iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
920  h_sumNHitsBeforeVtx_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 16, -0.5, 15.5);
921  h_sumNHitsBeforeVtx_[2][1] = iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
922  h_sumNHitsBeforeVtx_[2][2] = iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
923 
924  histname = "maxDlClosestHitToVtx";
925  h_maxDlClosestHitToVtx_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 100, -10., 10.);
926  h_maxDlClosestHitToVtx_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 100, -10., 10.);
927  h_maxDlClosestHitToVtx_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 100, -10., 10.);
928  h_maxDlClosestHitToVtx_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 100, -10., 10.);
929  h_maxDlClosestHitToVtx_[1][1] = iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 100, -10., 10.);
930  h_maxDlClosestHitToVtx_[1][2] = iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 100, -10., 10.);
931  h_maxDlClosestHitToVtx_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 100, -10., 10.);
932  h_maxDlClosestHitToVtx_[2][1] = iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 100, -10., 10.);
933  h_maxDlClosestHitToVtx_[2][2] = iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 100, -10., 10.);
934 
935  histname = "maxDlClosestHitToVtxSig";
936  h_maxDlClosestHitToVtxSig_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 100, -8., 8.);
937  h_maxDlClosestHitToVtxSig_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 100, -8., 8.);
938  h_maxDlClosestHitToVtxSig_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 100, -8., 8.);
939  h_maxDlClosestHitToVtxSig_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 100, -8., 8.);
940  h_maxDlClosestHitToVtxSig_[1][1] = iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 100, -8., 8.);
941  h_maxDlClosestHitToVtxSig_[1][2] = iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 100, -8., 8.);
942  h_maxDlClosestHitToVtxSig_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 100, -8., 8.);
943  h_maxDlClosestHitToVtxSig_[2][1] =
944  iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 100, -8., 8.);
945  h_maxDlClosestHitToVtxSig_[2][2] =
946  iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 100, -8., 8.);
947 
948  histname = "deltaExpectedHitsInner";
949  h_deltaExpectedHitsInner_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 31, -15.5, 15.5);
950  h_deltaExpectedHitsInner_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 31, -15.5, 15.5);
951  h_deltaExpectedHitsInner_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 31, -15.5, 15.5);
952  h_deltaExpectedHitsInner_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 31, -15.5, 15.5);
953  h_deltaExpectedHitsInner_[1][1] =
954  iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 31, -15.5, 15.5);
955  h_deltaExpectedHitsInner_[1][2] =
956  iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 31, -15.5, 15.5);
957  h_deltaExpectedHitsInner_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 31, -15.5, 15.5);
958  h_deltaExpectedHitsInner_[2][1] =
959  iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 31, -15.5, 15.5);
960  h_deltaExpectedHitsInner_[2][2] =
961  iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 31, -15.5, 15.5);
962 
963  histname = "leadExpectedHitsInner";
964  h_leadExpectedHitsInner_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 16, -0.5, 15.5);
965  h_leadExpectedHitsInner_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
966  h_leadExpectedHitsInner_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
967  h_leadExpectedHitsInner_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 16, -0.5, 15.5);
968  h_leadExpectedHitsInner_[1][1] = iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
969  h_leadExpectedHitsInner_[1][2] = iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
970  h_leadExpectedHitsInner_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 16, -0.5, 15.5);
971  h_leadExpectedHitsInner_[2][1] =
972  iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
973  h_leadExpectedHitsInner_[2][2] =
974  iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
975 
976  histname = "nSharedHits";
977  h_nSharedHits_[0][0] = iBooker.book1D(histname + "All", "vertex #chi^{2} all", 16, -0.5, 15.5);
978  h_nSharedHits_[0][1] = iBooker.book1D(histname + "Barrel", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
979  h_nSharedHits_[0][2] = iBooker.book1D(histname + "Endcap", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
980  h_nSharedHits_[1][0] = iBooker.book1D(histname + "All_Ass", "vertex #chi^{2} all", 16, -0.5, 15.5);
981  h_nSharedHits_[1][1] = iBooker.book1D(histname + "Barrel_Ass", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
982  h_nSharedHits_[1][2] = iBooker.book1D(histname + "Endcap_Ass", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
983  h_nSharedHits_[2][0] = iBooker.book1D(histname + "All_Fakes", "vertex #chi^{2} all", 16, -0.5, 15.5);
984  h_nSharedHits_[2][1] = iBooker.book1D(histname + "Barrel_Fakes", "vertex #chi^{2} barrel", 16, -0.5, 15.5);
985  h_nSharedHits_[2][2] = iBooker.book1D(histname + "Endcap_Fakes", "vertex #chi^{2} endcap", 16, -0.5, 15.5);
986 
988  histname = "nHits";
989  nHits_[0] = iBooker.book2D(histname + "AllTracks",
990  "Photons:Tracks from conversions: # of hits all tracks",
991  etaBin,
992  etaMin,
993  etaMax,
994  30,
995  0.,
996  30.);
997  nHits_[1] = iBooker.book2D(histname + "AllTracks_Ass",
998  "Photons:Tracks from conversions: # of hits all tracks ass",
999  etaBin,
1000  etaMin,
1001  etaMax,
1002  30,
1003  0.,
1004  30.);
1005  nHits_[2] = iBooker.book2D(histname + "AllTracks_Fakes",
1006  "Photons:Tracks from conversions: # of hits all tracks fakes",
1007  etaBin,
1008  etaMin,
1009  etaMax,
1010  30,
1011  0.,
1012  30.);
1013 
1014  histname = "nHitsVsEta";
1015  nHitsVsEta_[0] = iBooker.book2D(histname + "AllTracks",
1016  "Photons:Tracks from conversions: # of hits vs #eta all tracks",
1017  etaBin,
1018  etaMin,
1019  etaMax,
1020  30,
1021  0.,
1022  30.);
1023  nHitsVsEta_[1] = iBooker.book2D(histname + "AllTracks_Ass",
1024  "Photons:Tracks from conversions: # of hits vs #eta all tracks",
1025  etaBin,
1026  etaMin,
1027  etaMax,
1028  30,
1029  0.,
1030  30.);
1031  nHitsVsEta_[2] = iBooker.book2D(histname + "AllTracks_Fakes",
1032  "Photons:Tracks from conversions: # of hits vs #eta all tracks",
1033  etaBin,
1034  etaMin,
1035  etaMax,
1036  30,
1037  0.,
1038  30.);
1039  histname = "h_nHitsVsEta";
1040  p_nHitsVsEta_[0] = iBooker.bookProfile(histname + "AllTracks",
1041  "Photons:Tracks from conversions: # of hits vs #eta all tracks",
1042  etaBin,
1043  etaMin,
1044  etaMax,
1045  30,
1046  -0.5,
1047  29.5,
1048  "");
1049  p_nHitsVsEta_[1] = iBooker.bookProfile(histname + "AllTracks_Ass",
1050  "Photons:Tracks from conversions: # of hits vs #eta all tracks",
1051  etaBin,
1052  etaMin,
1053  etaMax,
1054  30,
1055  -0.5,
1056  29.5,
1057  "");
1058  p_nHitsVsEta_[2] = iBooker.bookProfile(histname + "AllTracks_Fakes",
1059  "Photons:Tracks from conversions: # of hits vs #eta all tracks",
1060  etaBin,
1061  etaMin,
1062  etaMax,
1063  30,
1064  -0.5,
1065  29.5,
1066  "");
1067 
1068  histname = "nHitsVsR";
1069  nHitsVsR_[0] = iBooker.book2D(histname + "AllTracks",
1070  "Photons:Tracks from conversions: # of hits vs radius all tracks",
1071  rBin,
1072  rMin,
1073  rMax,
1074  30,
1075  0.,
1076  30.);
1077  nHitsVsR_[1] = iBooker.book2D(histname + "AllTracks_Ass",
1078  "Photons:Tracks from conversions: # of hits vs radius all tracks",
1079  rBin,
1080  rMin,
1081  rMax,
1082  30,
1083  0.,
1084  30.);
1085  nHitsVsR_[2] = iBooker.book2D(histname + "AllTracks_Fakes",
1086  "Photons:Tracks from conversions: # of hits vs radius all tracks",
1087  rBin,
1088  rMin,
1089  rMax,
1090  30,
1091  0.,
1092  30.);
1093 
1094  histname = "h_nHitsVsR";
1095  p_nHitsVsR_[0] = iBooker.bookProfile(histname + "AllTracks",
1096  "Photons:Tracks from conversions: # of hits vs radius all tracks",
1097  rBin,
1098  rMin,
1099  rMax,
1100  30,
1101  -0.5,
1102  29.5,
1103  "");
1104  p_nHitsVsR_[1] = iBooker.bookProfile(histname + "AllTracks_Ass",
1105  "Photons:Tracks from conversions: # of hits vs radius all tracks",
1106  rBin,
1107  rMin,
1108  rMax,
1109  30,
1110  -0.5,
1111  29.5,
1112  "");
1113  p_nHitsVsR_[2] = iBooker.bookProfile(histname + "AllTracks_Fakes",
1114  "Photons:Tracks from conversions: # of hits vs radius all tracks",
1115  rBin,
1116  rMin,
1117  rMax,
1118  30,
1119  -0.5,
1120  29.5,
1121  "");
1122 
1123  histname = "tkChi2";
1124  h_tkChi2_[0] = iBooker.book1D(
1125  histname + "AllTracks", "Photons:Tracks from conversions: #chi^{2} of all tracks", 100, chi2Min, chi2Max);
1126  h_tkChi2_[1] = iBooker.book1D(
1127  histname + "AllTracks_Ass", "Photons:Tracks from conversions: #chi^{2} of all tracks", 100, chi2Min, chi2Max);
1128  h_tkChi2_[2] = iBooker.book1D(
1129  histname + "AllTracks_Fakes", "Photons:Tracks from conversions: #chi^{2} of all tracks", 100, chi2Min, chi2Max);
1130 
1131  histname = "tkChi2Large";
1132  h_tkChi2Large_[0] = iBooker.book1D(
1133  histname + "AllTracks", "Photons:Tracks from conversions: #chi^{2} of all tracks", 1000, 0., 5000.0);
1134  h_tkChi2Large_[1] = iBooker.book1D(
1135  histname + "AllTracks_Ass", "Photons:Tracks from conversions: #chi^{2} of all tracks", 1000, 0., 5000.0);
1136  h_tkChi2Large_[2] = iBooker.book1D(
1137  histname + "AllTracks_Fakes", "Photons:Tracks from conversions: #chi^{2} of all tracks", 1000, 0., 5000.0);
1138 
1139  histname = "h2Chi2VsEta";
1140  h2_Chi2VsEta_[0] = iBooker.book2D(
1141  histname + "All", " Reco Track #chi^{2} vs #eta: All ", etaBin2, etaMin, etaMax, 100, chi2Min, chi2Max);
1142  h2_Chi2VsEta_[1] = iBooker.book2D(
1143  histname + "All_Ass", " Reco Track #chi^{2} vs #eta: All ", etaBin2, etaMin, etaMax, 100, chi2Min, chi2Max);
1144  h2_Chi2VsEta_[2] = iBooker.book2D(
1145  histname + "All_Fakes", " Reco Track #chi^{2} vs #eta: All ", etaBin2, etaMin, etaMax, 100, chi2Min, chi2Max);
1146  histname = "pChi2VsEta";
1147  p_Chi2VsEta_[0] = iBooker.bookProfile(
1148  histname + "All", " Reco Track #chi^{2} vs #eta : All ", etaBin2, etaMin, etaMax, 100, chi2Min, chi2Max, "");
1149  p_Chi2VsEta_[1] = iBooker.bookProfile(
1150  histname + "All_Ass", " Reco Track #chi^{2} vs #eta : All ", etaBin2, etaMin, etaMax, 100, chi2Min, chi2Max, "");
1151  p_Chi2VsEta_[2] = iBooker.bookProfile(histname + "All_Fakes",
1152  " Reco Track #chi^{2} vs #eta : All ",
1153  etaBin2,
1154  etaMin,
1155  etaMax,
1156  100,
1157  chi2Min,
1158  chi2Max,
1159  "");
1160 
1161  histname = "h2Chi2VsR";
1162  h2_Chi2VsR_[0] =
1163  iBooker.book2D(histname + "All", " Reco Track #chi^{2} vs R: All ", rBin, rMin, rMax, 100, chi2Min, chi2Max);
1164  h2_Chi2VsR_[1] = iBooker.book2D(
1165  histname + "All_Ass", " Reco Track #chi^{2} vs R: All ", rBin, rMin, rMax, 100, chi2Min, chi2Max);
1166  h2_Chi2VsR_[2] = iBooker.book2D(
1167  histname + "All_Fakes", " Reco Track #chi^{2} vs R: All ", rBin, rMin, rMax, 100, chi2Min, chi2Max);
1168  histname = "pChi2VsR";
1169  p_Chi2VsR_[0] = iBooker.bookProfile(
1170  histname + "All", " Reco Track #chi^{2} vas R : All ", rBin, rMin, rMax, 100, chi2Min, chi2Max, "");
1171  p_Chi2VsR_[1] = iBooker.bookProfile(
1172  histname + "All_Ass", " Reco Track #chi^{2} vas R : All ", rBin, rMin, rMax, 100, chi2Min, chi2Max, "");
1173  p_Chi2VsR_[2] = iBooker.bookProfile(
1174  histname + "All_Fakes", " Reco Track #chi^{2} vas R : All ", rBin, rMin, rMax, 100, chi2Min, chi2Max, "");
1175 
1176  histname = "hTkD0";
1177  h_TkD0_[0] = iBooker.book1D(histname + "All", " Reco Track D0*q: All ", 200, -0.1, 60);
1178  h_TkD0_[1] = iBooker.book1D(histname + "All_Ass", " Reco Track D0*q: Barrel ", 200, -0.1, 60);
1179  h_TkD0_[2] = iBooker.book1D(histname + "All_Fakes", " Reco Track D0*q: Endcap ", 200, -0.1, 60);
1180 
1181  histname = "hTkPtPull";
1182  h_TkPtPull_[0] = iBooker.book1D(histname + "All", " Reco Track Pt pull: All ", 100, -20., 10.);
1183  histname = "hTkPtPull";
1184  h_TkPtPull_[1] = iBooker.book1D(histname + "Barrel", " Reco Track Pt pull: Barrel ", 100, -20., 10.);
1185  histname = "hTkPtPull";
1186  h_TkPtPull_[2] = iBooker.book1D(histname + "Endcap", " Reco Track Pt pull: Endcap ", 100, -20., 10.);
1187 
1188  histname = "h2TkPtPullEta";
1189  h2_TkPtPull_[0] =
1190  iBooker.book2D(histname + "All", " Reco Track Pt pull: All ", etaBin2, etaMin, etaMax, 100, -20., 10.);
1191  histname = "pTkPtPullEta";
1192  p_TkPtPull_[0] = iBooker.bookProfile(
1193  histname + "All", " Reco Track Pt pull: All ", etaBin2, etaMin, etaMax, 100, -20., 10., " ");
1194 
1195  histname = "PtRecVsPtSim";
1196  h2_PtRecVsPtSim_[0] =
1197  iBooker.book2D(histname + "All", "Pt Rec vs Pt sim: All ", etBin, etMin, etMax, etBin, etMin, etMax);
1198  h2_PtRecVsPtSim_[1] =
1199  iBooker.book2D(histname + "Barrel", "Pt Rec vs Pt sim: Barrel ", etBin, etMin, etMax, etBin, etMin, etMax);
1200  h2_PtRecVsPtSim_[2] =
1201  iBooker.book2D(histname + "Endcap", "Pt Rec vs Pt sim: Endcap ", etBin, etMin, etMax, etBin, etMin, etMax);
1202 
1203  histname = "photonPtRecVsPtSim";
1204  h2_photonPtRecVsPtSim_ =
1205  iBooker.book2D(histname + "All", "Pt Rec vs Pt sim: All ", etBin, etMin, etMax, etBin, etMin, etMax);
1206 
1207  histname = "nHitsBeforeVtx";
1208  h_nHitsBeforeVtx_[0] = iBooker.book1D(histname + "All", "Pt Rec vs Pt sim: All ", 16, -0.5, 15.5);
1209  h_nHitsBeforeVtx_[1] = iBooker.book1D(histname + "Barrel", "Pt Rec vs Pt sim: Barrel ", 16, -0.5, 15.5);
1210  h_nHitsBeforeVtx_[2] = iBooker.book1D(histname + "Endcap", "Pt Rec vs Pt sim: Endcap ", 16, -0.5, 15.5);
1211 
1212  histname = "dlClosestHitToVtx";
1213  h_dlClosestHitToVtx_[0] = iBooker.book1D(histname + "All", "Pt Rec vs Pt sim: All ", 100, -10., 10.);
1214  h_dlClosestHitToVtx_[1] = iBooker.book1D(histname + "Barrel", "Pt Rec vs Pt sim: Barrel ", 100, -10., 10.);
1215  h_dlClosestHitToVtx_[2] = iBooker.book1D(histname + "Endcap", "Pt Rec vs Pt sim: Endcap ", 100, -10., 10.);
1216 
1217  histname = "dlClosestHitToVtxSig";
1218  h_dlClosestHitToVtxSig_[0] = iBooker.book1D(histname + "All", "Pt Rec vs Pt sim: All ", 100, -8., 8.);
1219  h_dlClosestHitToVtxSig_[1] = iBooker.book1D(histname + "Barrel", "Pt Rec vs Pt sim: Barrel ", 100, -8., 8.);
1220  h_dlClosestHitToVtxSig_[2] = iBooker.book1D(histname + "Endcap", "Pt Rec vs Pt sim: Endcap ", 100, -8., 8.);
1221 
1222  h_match_ = iBooker.book1D("h_match", " ", 3, -0.5, 2.5);
1223 
1224  } // if DQM
1225 }
1226 
1227 void TkConvValidator::dqmBeginRun(edm::Run const& r, edm::EventSetup const& theEventSetup) {
1228  //get magnetic field
1229  edm::LogInfo("ConvertedPhotonProducer") << " get magnetic field"
1230  << "\n";
1231  theMF_ = theEventSetup.getHandle(magneticFieldToken_);
1232 
1233  thePhotonMCTruthFinder_ = new PhotonMCTruthFinder();
1234 }
1235 
1236 void TkConvValidator::dqmEndRun(edm::Run const& r, edm::EventSetup const&) { delete thePhotonMCTruthFinder_; }
1237 
1238 void TkConvValidator::analyze(const edm::Event& e, const edm::EventSetup& esup) {
1239  thePhotonMCTruthFinder_->clear();
1240  using namespace edm;
1241  // const float etaPhiDistance=0.01;
1242  // Fiducial region
1243  // const float TRK_BARL =0.9;
1244  const float BARL = 1.4442; // DAQ TDR p.290
1245  // const float END_LO = 1.566; // unused
1246  const float END_HI = 2.5;
1247  // Electron mass
1248  // const Float_t mElec= 0.000511; // unused
1249 
1250  Handle<reco::TrackToTrackingParticleAssociator> theTrackAssociator;
1251  e.getByToken(trackAssociator_Token_, theTrackAssociator);
1252 
1253  nEvt_++;
1254  LogInfo("TkConvValidator") << "TkConvValidator Analyzing event number: " << e.id() << " Global Counter " << nEvt_
1255  << "\n";
1256  // std::cout << "TkConvValidator Analyzing event number: " << e.id() << " Global Counter " << nEvt_ <<"\n";
1257 
1258  // get the geometry from the event setup:
1259  theCaloGeom_ = esup.getHandle(caloGeometryToken_);
1260 
1261  // Transform Track into TransientTrack (needed by the Vertex fitter)
1262  auto theTTB = esup.getHandle(transientTrackBuilderToken_);
1263 
1265  Handle<reco::ConversionCollection> convHandle;
1266  e.getByToken(conversionCollectionPr_Token_, convHandle);
1267  const reco::ConversionCollection convCollection = *(convHandle.product());
1268  if (!convHandle.isValid()) {
1269  edm::LogError("ConversionsProducer") << "Error! Can't get the collection " << std::endl;
1270  return;
1271  }
1272 
1274  Handle<reco::PhotonCollection> photonHandle;
1275  e.getByToken(photonCollectionPr_Token_, photonHandle);
1276  const reco::PhotonCollection photonCollection = *(photonHandle.product());
1277  if (!photonHandle.isValid()) {
1278  edm::LogError("PhotonProducer") << "Error! Can't get the Photon collection " << std::endl;
1279  return;
1280  }
1281 
1282  // offline Primary vertex
1283  edm::Handle<reco::VertexCollection> vertexHandle;
1284  reco::VertexCollection vertexCollection;
1285  e.getByToken(offline_pvToken_, vertexHandle);
1286  if (!vertexHandle.isValid()) {
1287  edm::LogError("TrackerOnlyConversionProducer") << "Error! Can't get the product primary Vertex Collection "
1288  << "\n";
1289  } else {
1290  vertexCollection = *(vertexHandle.product());
1291  }
1292  reco::Vertex the_pvtx;
1293  bool valid_pvtx = false;
1294  if (!vertexCollection.empty()) {
1295  the_pvtx = *(vertexCollection.begin());
1296  //asking for one good vertex
1297  if (the_pvtx.isValid() && fabs(the_pvtx.position().z()) <= 15 && the_pvtx.position().Rho() <= 2) {
1298  valid_pvtx = true;
1299  }
1300  }
1301 
1302  edm::Handle<reco::BeamSpot> bsHandle;
1303  e.getByToken(beamspotToken_, bsHandle);
1304  if (!bsHandle.isValid()) {
1305  edm::LogError("TrackerOnlyConversionProducer") << "Error! Can't get the product primary Vertex Collection "
1306  << "\n";
1307  return;
1308  }
1309  const reco::BeamSpot& thebs = *bsHandle.product();
1310 
1311  //get tracker geometry for hits positions
1312  //edm::ESHandle<TrackerGeometry> tracker;
1313  //esup.get<TrackerDigiGeometryRecord>().get(tracker);
1314  auto tracker = esup.getHandle(trackerGeometryToken_);
1315  const TrackerGeometry* trackerGeom = tracker.product();
1316 
1318  //get simtrack info
1319  //std::vector<SimTrack> theSimTracks;
1320  //std::vector<SimVertex> theSimVertices;
1321 
1322  edm::Handle<SimTrackContainer> SimTk;
1323  edm::Handle<SimVertexContainer> SimVtx;
1324  e.getByToken(g4_simTk_Token_, SimTk);
1325  e.getByToken(g4_simVtx_Token_, SimVtx);
1326 
1327  bool useTP = parameters_.getParameter<bool>("useTP");
1328  TrackingParticleRefVector dummy;
1329  edm::Handle<TrackingParticleRefVector> TPHandleForEff;
1330  edm::Handle<TrackingParticleRefVector> TPHandleForFakeRate;
1331  if (useTP) {
1332  e.getByToken(tpSelForEff_Token_, TPHandleForEff);
1333  e.getByToken(tpSelForFake_Token_, TPHandleForFakeRate);
1334  }
1335 
1336  const TrackingParticleRefVector& tpForEfficiency = useTP ? *(TPHandleForEff.product()) : dummy;
1337  const TrackingParticleRefVector& tpForFakeRate = useTP ? *(TPHandleForFakeRate.product()) : dummy;
1338 
1339  const std::vector<SimTrack>& theSimTracks = *SimTk;
1340  const std::vector<SimVertex>& theSimVertices = *SimVtx;
1341 
1342  //theSimTracks.insert(theSimTracks.end(),SimTk->begin(),SimTk->end());
1343  //theSimVertices.insert(theSimVertices.end(),SimVtx->begin(),SimVtx->end());
1344  std::vector<PhotonMCTruth> mcPhotons = thePhotonMCTruthFinder_->find(theSimTracks, theSimVertices);
1345 
1346  //edm::Handle<edm::HepMCProduct> hepMC;
1347  //e.getByToken(hepMC_Token_, hepMC);
1348  // const HepMC::GenEvent *myGenEvent = hepMC->GetEvent(); // unused
1349 
1350  // get generated jets
1351  //edm::Handle<reco::GenJetCollection> GenJetsHandle;
1352  //e.getByToken(genjets_Token_, GenJetsHandle);
1353  //const reco::GenJetCollection &genJetCollection = *(GenJetsHandle.product());
1354 
1355  // ################ SIM to RECO ######################### //
1356  std::map<const reco::Track*, TrackingParticleRef> myAss;
1357  std::map<const reco::Track*, TrackingParticleRef>::const_iterator itAss;
1358 
1359  for (std::vector<PhotonMCTruth>::const_iterator mcPho = mcPhotons.begin(); mcPho != mcPhotons.end(); mcPho++) {
1360  mcConvPt_ = (*mcPho).fourMomentum().et();
1361  float mcPhi = (*mcPho).fourMomentum().phi();
1362  mcPhi_ = phiNormalization(mcPhi);
1363  mcEta_ = (*mcPho).fourMomentum().pseudoRapidity();
1364  mcEta_ = etaTransformation(mcEta_, (*mcPho).primaryVertex().z());
1365  mcConvR_ = (*mcPho).vertex().perp();
1366  mcConvX_ = (*mcPho).vertex().x();
1367  mcConvY_ = (*mcPho).vertex().y();
1368  mcConvZ_ = (*mcPho).vertex().z();
1369  mcConvEta_ = (*mcPho).vertex().eta();
1370  mcConvPhi_ = (*mcPho).vertex().phi();
1371 
1372  if (fabs(mcEta_) > END_HI)
1373  continue;
1374 
1375  if (mcConvPt_ < minPhoPtForEffic)
1376  continue;
1377  if (fabs(mcEta_) > maxPhoEtaForEffic)
1378  continue;
1379  if (fabs(mcConvZ_) > maxPhoZForEffic)
1380  continue;
1381  if (mcConvR_ > maxPhoRForEffic)
1382  continue;
1384 
1385  bool goodSimConversion = false;
1386  bool visibleConversion = false;
1387  bool visibleConversionsWithTwoSimTracks = false;
1388  if ((*mcPho).isAConversion() == 1) {
1389  nSimConv_[0]++;
1390  h_AllSimConv_[0]->Fill(mcEta_);
1391  h_AllSimConv_[1]->Fill(mcPhi_);
1392  h_AllSimConv_[2]->Fill(mcConvR_);
1393  h_AllSimConv_[3]->Fill(mcConvZ_);
1394  h_AllSimConv_[4]->Fill((*mcPho).fourMomentum().et());
1395 
1396  if (mcConvR_ < 15)
1397  h_SimConvEtaPix_[0]->Fill(mcEta_);
1398 
1399  if ((fabs(mcEta_) <= BARL && mcConvR_ < 85) ||
1400  (fabs(mcEta_) > BARL && fabs(mcEta_) <= END_HI && fabs((*mcPho).vertex().z()) < 210))
1401  visibleConversion = true;
1402 
1403  theConvTP_.clear();
1404  // std::cout << " TkConvValidator TrackingParticles TrackingParticleCollection size "<< trackingParticles.size() << "\n";
1405  //duplicated TP collections for two associations
1406  for (const TrackingParticleRef& tp : tpForEfficiency) {
1407  if (fabs(tp->vx() - (*mcPho).vertex().x()) < 0.0001 && fabs(tp->vy() - (*mcPho).vertex().y()) < 0.0001 &&
1408  fabs(tp->vz() - (*mcPho).vertex().z()) < 0.0001) {
1409  theConvTP_.push_back(tp);
1410  }
1411  }
1412  //std::cout << " TkConvValidator theConvTP_ size " << theConvTP_.size() << std::endl;
1413 
1414  if (theConvTP_.size() == 2)
1415  visibleConversionsWithTwoSimTracks = true;
1416  goodSimConversion = false;
1417 
1418  if (visibleConversion && visibleConversionsWithTwoSimTracks)
1419  goodSimConversion = true;
1420  if (goodSimConversion) {
1421  nSimConv_[1]++;
1422  h_VisSimConv_[0]->Fill(mcEta_);
1423  h_VisSimConv_[1]->Fill(mcPhi_);
1424  h_VisSimConv_[2]->Fill(mcConvR_);
1425  h_VisSimConv_[3]->Fill(mcConvZ_);
1426  h_VisSimConv_[4]->Fill((*mcPho).fourMomentum().et());
1427  }
1428 
1429  for (edm::RefVector<TrackingParticleCollection>::iterator iTrk = theConvTP_.begin(); iTrk != theConvTP_.end();
1430  ++iTrk) {
1431  h_simTkPt_->Fill((*iTrk)->pt());
1432  h_simTkEta_->Fill((*iTrk)->eta());
1433  }
1434 
1435  }
1436 
1437  if (!(visibleConversion && visibleConversionsWithTwoSimTracks))
1438  continue;
1439 
1440  h_simConvVtxRvsZ_[0]->Fill(fabs(mcConvZ_), mcConvR_);
1441  if (fabs(mcEta_) <= 1.) {
1442  h_simConvVtxRvsZ_[1]->Fill(fabs(mcConvZ_), mcConvR_);
1443  h_simConvVtxYvsX_->Fill(mcConvX_, mcConvY_);
1444  } else
1445  h_simConvVtxRvsZ_[2]->Fill(fabs(mcConvZ_), mcConvR_);
1446 
1447  //std::cout << " TkConvValidator theConvTP_ size " << theConvTP_.size() << std::endl;
1448  for (edm::RefVector<TrackingParticleCollection>::iterator iTP = theConvTP_.begin(); iTP != theConvTP_.end();
1449  iTP++) {
1450  // std::cout << " SIM to RECO TP vertex " << (*iTP)->vx() << " " << (*iTP)->vy() << " " << (*iTP)->vz() << " pt " << (*iTP)->pt() << std::endl;
1451  }
1452 
1453  bool recomatch = false;
1454  float chi2Prob = 0.;
1456  // cout << " size of conversions " << convHandle->size() << endl;
1457  for (reco::ConversionCollection::const_iterator conv = convHandle->begin(); conv != convHandle->end(); ++conv) {
1458  const reco::Conversion aConv = (*conv);
1459  if (arbitratedMerged_ && !aConv.quality(reco::Conversion::arbitratedMerged))
1460  continue;
1461  if (generalTracksOnly_ && !aConv.quality(reco::Conversion::generalTracksOnly))
1462  continue;
1463  if (arbitratedEcalSeeded_ && !aConv.quality(reco::Conversion::arbitratedEcalSeeded))
1464  continue;
1465 
1466  if (highPurity_ && !aConv.quality(reco::Conversion::highPurity))
1467  continue;
1468 
1469  //problematic?
1470  const std::vector<edm::RefToBase<reco::Track> >& tracks = aConv.tracks();
1471 
1472  const reco::Vertex& vtx = aConv.conversionVertex();
1473  //requires two tracks and a valid vertex
1474  if (tracks.size() != 2 || !(vtx.isValid()))
1475  continue;
1476 
1477  if (ChiSquaredProbability(aConv.conversionVertex().chi2(), aConv.conversionVertex().ndof()) <= minProb_)
1478  continue;
1479  if (aConv.nHitsBeforeVtx().size() > 1 &&
1480  max(aConv.nHitsBeforeVtx().at(0), aConv.nHitsBeforeVtx().at(1)) > maxHitsBeforeVtx_)
1481  continue;
1482 
1483  //compute transverse decay length with respect to beamspot
1484  math::XYZVectorF themom = aConv.refittedPairMomentum();
1485  double dbsx = aConv.conversionVertex().x() - thebs.x0();
1486  double dbsy = aConv.conversionVertex().y() - thebs.y0();
1487  double lxy = (themom.x() * dbsx + themom.y() * dbsy) / themom.rho();
1488 
1489  if (lxy < minLxy_)
1490  continue;
1491 
1492  // bool phoIsInBarrel=false; // unused
1493  // bool phoIsInEndcap=false; // unused
1494  RefToBase<reco::Track> tfrb1 = aConv.tracks().front();
1495  RefToBase<reco::Track> tfrb2 = aConv.tracks().back();
1496 
1497  if (ecalalgotracks_ && (!(tfrb1->algo() == reco::TrackBase::outInEcalSeededConv ||
1498  tfrb1->algo() == reco::TrackBase::inOutEcalSeededConv) ||
1499  !(tfrb2->algo() == reco::TrackBase::outInEcalSeededConv ||
1500  tfrb2->algo() == reco::TrackBase::inOutEcalSeededConv)))
1501  continue;
1502 
1503  //reco::TrackRef tk1 = aConv.tracks().front();
1504  //reco::TrackRef tk2 = aConv.tracks().back();
1505  //std::cout << "SIM to RECO conversion track pt " << tk1->pt() << " " << tk2->pt() << endl;
1506  //
1507  //Use two RefToBaseVector and do two association actions to avoid that if two tracks from different collection
1508  RefToBaseVector<reco::Track> tc1, tc2;
1509  tc1.push_back(tfrb1);
1510  tc2.push_back(tfrb2);
1511  bool isAssociated = false;
1512  reco::SimToRecoCollection q1 = theTrackAssociator->associateSimToReco(tc1, theConvTP_);
1513  reco::SimToRecoCollection q2 = theTrackAssociator->associateSimToReco(tc2, theConvTP_);
1514  //try {
1515  std::vector<std::pair<RefToBase<reco::Track>, double> > trackV1, trackV2;
1516 
1517  int tp_1 = 0, tp_2 = 1; //the index of associated tp in theConvTP_ for two tracks
1518  if (q1.find(theConvTP_[0]) != q1.end()) {
1519  trackV1 = (std::vector<std::pair<RefToBase<reco::Track>, double> >)q1[theConvTP_[0]];
1520  } else if (q1.find(theConvTP_[1]) != q1.end()) {
1521  trackV1 = (std::vector<std::pair<RefToBase<reco::Track>, double> >)q1[theConvTP_[1]];
1522  tp_1 = 1;
1523  }
1524  if (q2.find(theConvTP_[1]) != q2.end()) {
1525  trackV2 = (std::vector<std::pair<RefToBase<reco::Track>, double> >)q2[theConvTP_[1]];
1526  } else if (q2.find(theConvTP_[0]) != q2.end()) {
1527  trackV2 = (std::vector<std::pair<RefToBase<reco::Track>, double> >)q2[theConvTP_[0]];
1528  tp_2 = 0;
1529  }
1530  if (!(!trackV1.empty() && !trackV2.empty()))
1531  continue;
1532  if (tp_1 == tp_2)
1533  continue;
1534 
1535  edm::RefToBase<reco::Track> tr1 = trackV1.front().first;
1536  edm::RefToBase<reco::Track> tr2 = trackV2.front().first;
1537  //std::cout << "associated tp1 " <<theConvTP_[0]->pt() << " to track with pT=" << tr1->pt() << " " << (tr1.get())->pt() << endl;
1538  //std::cout << "associated tp2 " <<theConvTP_[1]->pt() << " to track with pT=" << tr2->pt() << " " << (tr2.get())->pt() << endl;
1539  myAss.insert(std::make_pair(tr1.get(), theConvTP_[tp_1]));
1540  myAss.insert(std::make_pair(tr2.get(), theConvTP_[tp_2]));
1541 
1542  //} catch (Exception const& event) {
1543  //cout << "continue: " << event.what() << endl;
1544  // continue;
1545  //}
1546 
1547  isAssociated = true;
1548  recomatch = true;
1549  chi2Prob = ChiSquaredProbability(aConv.conversionVertex().chi2(), aConv.conversionVertex().ndof());
1550 
1551  if (isAssociated) {
1552  h_SimRecConvTwoMTracks_[0]->Fill(mcEta_);
1553  h_SimRecConvTwoMTracks_[1]->Fill(mcPhi_);
1554  h_SimRecConvTwoMTracks_[2]->Fill(mcConvR_);
1555  h_SimRecConvTwoMTracks_[3]->Fill(mcConvZ_);
1556  h_SimRecConvTwoMTracks_[4]->Fill((*mcPho).fourMomentum().et());
1557  }
1558 
1559  // break;
1560  } // loop over reco conversions
1561  if (recomatch) {
1563  h_SimConvTwoMTracks_[0]->Fill(mcEta_);
1564  h_SimConvTwoMTracks_[1]->Fill(mcPhi_);
1565  h_SimConvTwoMTracks_[2]->Fill(mcConvR_);
1566  h_SimConvTwoMTracks_[3]->Fill(mcConvZ_);
1567  h_SimConvTwoMTracks_[4]->Fill((*mcPho).fourMomentum().et());
1568 
1569  if (chi2Prob > 0) {
1570  h_SimConvTwoMTracksAndVtxPGT0_[0]->Fill(mcEta_);
1571  h_SimConvTwoMTracksAndVtxPGT0_[1]->Fill(mcPhi_);
1572  h_SimConvTwoMTracksAndVtxPGT0_[2]->Fill(mcConvR_);
1573  h_SimConvTwoMTracksAndVtxPGT0_[3]->Fill(mcConvZ_);
1574  h_SimConvTwoMTracksAndVtxPGT0_[4]->Fill((*mcPho).fourMomentum().et());
1575  }
1576  if (chi2Prob > 0.0005) {
1577  h_SimConvTwoMTracksAndVtxPGT0005_[0]->Fill(mcEta_);
1578  h_SimConvTwoMTracksAndVtxPGT0005_[1]->Fill(mcPhi_);
1579  h_SimConvTwoMTracksAndVtxPGT0005_[2]->Fill(mcConvR_);
1580  h_SimConvTwoMTracksAndVtxPGT0005_[3]->Fill(mcConvZ_);
1581  h_SimConvTwoMTracksAndVtxPGT0005_[4]->Fill((*mcPho).fourMomentum().et());
1582  }
1583  }
1584 
1585  } //End loop over simulated conversions
1586 
1587  // ########################### RECO to SIM ############################## //
1588 
1589  for (reco::ConversionCollection::const_iterator conv = convHandle->begin(); conv != convHandle->end(); ++conv) {
1590  const reco::Conversion aConv = (*conv);
1591  if (arbitratedMerged_ && !aConv.quality(reco::Conversion::arbitratedMerged))
1592  continue;
1593  if (generalTracksOnly_ && !aConv.quality(reco::Conversion::generalTracksOnly))
1594  continue;
1595  if (arbitratedEcalSeeded_ && !aConv.quality(reco::Conversion::arbitratedEcalSeeded))
1596  continue;
1597 
1598  if (highPurity_ && !aConv.quality(reco::Conversion::highPurity))
1599  continue;
1600 
1601  //problematic?
1602  std::vector<edm::RefToBase<reco::Track> > tracks = aConv.tracks();
1603 
1604  const reco::Vertex& vtx = aConv.conversionVertex();
1605  //requires two tracks and a valid vertex
1606  if (tracks.size() != 2 || !(vtx.isValid()))
1607  continue;
1608  //if (tracks.size() !=2) continue;
1609 
1610  if (ChiSquaredProbability(aConv.conversionVertex().chi2(), aConv.conversionVertex().ndof()) <= minProb_)
1611  continue;
1612  if (aConv.nHitsBeforeVtx().size() > 1 &&
1613  max(aConv.nHitsBeforeVtx().at(0), aConv.nHitsBeforeVtx().at(1)) > maxHitsBeforeVtx_)
1614  continue;
1615 
1616  //compute transverse decay length with respect to beamspot
1617  math::XYZVectorF themom = aConv.refittedPairMomentum();
1618  double dbsx = aConv.conversionVertex().x() - thebs.x0();
1619  double dbsy = aConv.conversionVertex().y() - thebs.y0();
1620  double lxy = (themom.x() * dbsx + themom.y() * dbsy) / themom.rho();
1621 
1622  if (lxy < minLxy_)
1623  continue;
1624 
1625  bool phoIsInBarrel = false;
1626  bool phoIsInEndcap = false;
1627  RefToBase<reco::Track> tk1 = aConv.tracks().front();
1628  RefToBase<reco::Track> tk2 = aConv.tracks().back();
1629  RefToBaseVector<reco::Track> tc1, tc2;
1630  tc1.push_back(tk1);
1631  tc2.push_back(tk2);
1632 
1633  if (ecalalgotracks_ &&
1634  (!(tk1->algo() == reco::TrackBase::outInEcalSeededConv ||
1635  tk1->algo() == reco::TrackBase::inOutEcalSeededConv) ||
1636  !(tk2->algo() == reco::TrackBase::outInEcalSeededConv || tk2->algo() == reco::TrackBase::inOutEcalSeededConv)))
1637  continue;
1638 
1639  //std::cout << " RECO to SIM conversion track pt " << tk1->pt() << " " << tk2->pt() << endl;
1640  const reco::Track refTk1 = aConv.conversionVertex().refittedTracks().front();
1641  const reco::Track refTk2 = aConv.conversionVertex().refittedTracks().back();
1642 
1643  float dPhiTracksAtVtx;
1644  // override with the phi calculated at the vertex
1645  math::XYZVector p1AtVtx = recalculateMomentumAtFittedVertex((*theMF_), *trackerGeom, tk1, aConv.conversionVertex());
1646  math::XYZVector p2AtVtx = recalculateMomentumAtFittedVertex((*theMF_), *trackerGeom, tk2, aConv.conversionVertex());
1647  if (p1AtVtx.perp2() > p2AtVtx.perp2())
1648  dPhiTracksAtVtx = p1AtVtx.phi() - p2AtVtx.phi();
1649  else
1650  dPhiTracksAtVtx = p2AtVtx.phi() - p1AtVtx.phi();
1651 
1652  math::XYZVectorF refittedMom = aConv.refittedPairMomentum();
1653 
1654  if (fabs(refittedMom.eta()) < 1.479) {
1655  phoIsInBarrel = true;
1656  } else {
1657  phoIsInEndcap = true;
1658  }
1659 
1660  nRecConv_++;
1661 
1662  // check matching with reco photon
1663  double Mindeltaeta = 999999;
1664  double Mindeltaphi = 999999;
1665  bool matchConvSC = false;
1666  reco::PhotonCollection::const_iterator iMatchingSC;
1667  for (reco::PhotonCollection::const_iterator iPho = photonCollection.begin(); iPho != photonCollection.end();
1668  iPho++) {
1669  reco::Photon aPho = reco::Photon(*iPho);
1670  const double deltaphi = reco::deltaPhi(aConv.refittedPairMomentum().phi(), aPho.superCluster()->position().phi());
1671  double ConvEta = etaTransformation(aConv.refittedPairMomentum().eta(), aConv.zOfPrimaryVertexFromTracks());
1672  double deltaeta = abs(aPho.superCluster()->position().eta() - ConvEta);
1673  if (abs(deltaeta) < abs(Mindeltaeta) && abs(deltaphi) < abs(Mindeltaphi)) {
1674  Mindeltaphi = abs(deltaphi);
1675  Mindeltaeta = abs(deltaeta);
1676  iMatchingSC = iPho;
1677  }
1678  }
1679  if (abs(Mindeltaeta) < 0.1 && abs(Mindeltaphi) < 0.1) {
1680  matchConvSC = true;
1681  }
1682 
1684  int match = 0;
1685  float invM = aConv.pairInvariantMass();
1686  float chi2Prob = ChiSquaredProbability(aConv.conversionVertex().chi2(), aConv.conversionVertex().ndof());
1687  uint maxNHitsBeforeVtx =
1688  aConv.nHitsBeforeVtx().size() > 1 ? max(aConv.nHitsBeforeVtx().at(0), aConv.nHitsBeforeVtx().at(1)) : 0;
1689  uint sumNHitsBeforeVtx =
1690  aConv.nHitsBeforeVtx().size() > 1 ? aConv.nHitsBeforeVtx().at(0) + aConv.nHitsBeforeVtx().at(1) : 0;
1691  float maxDlClosestHitToVtx = aConv.dlClosestHitToVtx().size() > 1 ? max(aConv.dlClosestHitToVtx().at(0).value(),
1692  aConv.dlClosestHitToVtx().at(1).value())
1693  : 0;
1694  float maxDlClosestHitToVtxSig =
1695  aConv.dlClosestHitToVtx().size() > 1
1696  ? max(aConv.dlClosestHitToVtx().at(0).value() / aConv.dlClosestHitToVtx().at(0).error(),
1697  aConv.dlClosestHitToVtx().at(1).value() / aConv.dlClosestHitToVtx().at(1).error())
1698  : 0;
1699 
1700  int ilead = 0, itrail = 1;
1701  if (tk2->pt() > tk1->pt()) {
1702  ilead = 1;
1703  itrail = 0;
1704  }
1705  RefToBase<reco::Track> tklead = aConv.tracks().at(ilead);
1706  RefToBase<reco::Track> tktrail = aConv.tracks().at(itrail);
1707 
1708  int deltaExpectedHitsInner = tklead->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) -
1709  tktrail->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
1710  int leadExpectedHitsInner = tklead->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
1711  uint leadNHitsBeforeVtx = aConv.nHitsBeforeVtx().size() > 1 ? aConv.nHitsBeforeVtx().at(ilead) : 0;
1712  uint trailNHitsBeforeVtx = aConv.nHitsBeforeVtx().size() > 1 ? aConv.nHitsBeforeVtx().at(itrail) : 0;
1713 
1714  h_convEta_[match][0]->Fill(refittedMom.eta());
1715  h_convEta2_[match][0]->Fill(refittedMom.eta());
1716 
1717  h_convPhi_[match][0]->Fill(refittedMom.phi());
1718  h_convR_[match][0]->Fill(sqrt(aConv.conversionVertex().position().perp2()));
1719  h_convRplot_->Fill(sqrt(aConv.conversionVertex().position().perp2()));
1720  h_convZ_[match][0]->Fill(aConv.conversionVertex().position().z());
1721  h_convZplot_->Fill(aConv.conversionVertex().position().z());
1722  h_convPt_[match][0]->Fill(sqrt(refittedMom.perp2()));
1723  h_invMass_[match][0]->Fill(invM);
1724  h_vtxChi2Prob_[match][0]->Fill(chi2Prob);
1725  h_lxybs_[match][0]->Fill(lxy);
1726  h_maxNHitsBeforeVtx_[match][0]->Fill(maxNHitsBeforeVtx);
1727  h_leadNHitsBeforeVtx_[match][0]->Fill(leadNHitsBeforeVtx);
1728  h_trailNHitsBeforeVtx_[match][0]->Fill(trailNHitsBeforeVtx);
1729  h_sumNHitsBeforeVtx_[match][0]->Fill(sumNHitsBeforeVtx);
1730  h_deltaExpectedHitsInner_[match][0]->Fill(deltaExpectedHitsInner);
1731  h_leadExpectedHitsInner_[match][0]->Fill(leadExpectedHitsInner);
1732  h_maxDlClosestHitToVtx_[match][0]->Fill(maxDlClosestHitToVtx);
1733  h_maxDlClosestHitToVtxSig_[match][0]->Fill(maxDlClosestHitToVtxSig);
1734  h_nSharedHits_[match][0]->Fill(aConv.nSharedHits());
1735 
1736  if (matchConvSC) {
1737  h_convEtaMatchSC_[match][0]->Fill(refittedMom.eta());
1738  h_EoverPTracks_[match][0]->Fill(iMatchingSC->superCluster()->energy() / sqrt(refittedMom.mag2()));
1739  h_convSCdPhi_[match][0]->Fill(iMatchingSC->superCluster()->position().phi() - refittedMom.phi());
1740  double ConvEta = etaTransformation(aConv.refittedPairMomentum().eta(), aConv.zOfPrimaryVertexFromTracks());
1741  h_convSCdEta_[match][0]->Fill(iMatchingSC->superCluster()->position().eta() - ConvEta);
1742  }
1743 
1744  h_distMinAppTracks_[match][0]->Fill(aConv.distOfMinimumApproach());
1745  h_DPhiTracksAtVtx_[match][0]->Fill(dPhiTracksAtVtx);
1746  h2_DPhiTracksAtVtxVsEta_->Fill(mcEta_, dPhiTracksAtVtx);
1747  h2_DPhiTracksAtVtxVsR_->Fill(mcConvR_, dPhiTracksAtVtx);
1748  p_DPhiTracksAtVtxVsEta_->Fill(mcEta_, dPhiTracksAtVtx);
1749  p_DPhiTracksAtVtxVsR_->Fill(mcConvR_, dPhiTracksAtVtx);
1750 
1751  h_DCotTracks_[match][0]->Fill(aConv.pairCotThetaSeparation());
1752  h2_DCotTracksVsEta_->Fill(mcEta_, aConv.pairCotThetaSeparation());
1753  h2_DCotTracksVsR_->Fill(mcConvR_, aConv.pairCotThetaSeparation());
1754  p_DCotTracksVsEta_->Fill(mcEta_, aConv.pairCotThetaSeparation());
1755  p_DCotTracksVsR_->Fill(mcConvR_, aConv.pairCotThetaSeparation());
1756 
1757  if (phoIsInBarrel) {
1758  h_invMass_[match][1]->Fill(invM);
1759  h_vtxChi2Prob_[match][1]->Fill(chi2Prob);
1760  h_distMinAppTracks_[match][1]->Fill(aConv.distOfMinimumApproach());
1761  h_DPhiTracksAtVtx_[match][1]->Fill(dPhiTracksAtVtx);
1762  h_DCotTracks_[match][1]->Fill(aConv.pairCotThetaSeparation());
1763  h_lxybs_[match][1]->Fill(lxy);
1764  h_maxNHitsBeforeVtx_[match][1]->Fill(maxNHitsBeforeVtx);
1765  h_leadNHitsBeforeVtx_[match][1]->Fill(leadNHitsBeforeVtx);
1766  h_trailNHitsBeforeVtx_[match][1]->Fill(trailNHitsBeforeVtx);
1767  h_sumNHitsBeforeVtx_[match][1]->Fill(sumNHitsBeforeVtx);
1768  h_deltaExpectedHitsInner_[match][1]->Fill(deltaExpectedHitsInner);
1769  h_leadExpectedHitsInner_[match][1]->Fill(leadExpectedHitsInner);
1770  h_maxDlClosestHitToVtx_[match][1]->Fill(maxDlClosestHitToVtx);
1771  h_maxDlClosestHitToVtxSig_[match][1]->Fill(maxDlClosestHitToVtxSig);
1772  h_nSharedHits_[match][1]->Fill(aConv.nSharedHits());
1773 
1774  /*
1775  if ( aConv.caloCluster().size() ) {
1776  h_convSCdPhi_[match][1]->Fill( aConv.caloCluster()[0]->phi() - refittedMom.phi() );
1777  double ConvEta = etaTransformation(aConv.refittedPairMomentum().eta(),aConv.zOfPrimaryVertexFromTracks());
1778  h_convSCdEta_[match][1]->Fill( aConv.caloCluster()[0]->eta() - ConvEta );
1779  }
1780  */
1781 
1782  if (matchConvSC) {
1783  h_EoverPTracks_[match][1]->Fill(iMatchingSC->superCluster()->energy() / sqrt(refittedMom.mag2()));
1784  h_convSCdPhi_[match][1]->Fill(iMatchingSC->superCluster()->position().phi() - refittedMom.phi());
1785  double ConvEta = etaTransformation(aConv.refittedPairMomentum().eta(), aConv.zOfPrimaryVertexFromTracks());
1786  h_convSCdEta_[match][1]->Fill(iMatchingSC->superCluster()->position().eta() - ConvEta);
1787  }
1788  }
1789 
1790  if (phoIsInEndcap) {
1791  h_invMass_[match][2]->Fill(invM);
1792  h_vtxChi2Prob_[match][2]->Fill(chi2Prob);
1793  h_distMinAppTracks_[match][2]->Fill(aConv.distOfMinimumApproach());
1794  h_DPhiTracksAtVtx_[match][2]->Fill(dPhiTracksAtVtx);
1795  h_DCotTracks_[match][2]->Fill(aConv.pairCotThetaSeparation());
1796  h_lxybs_[match][2]->Fill(lxy);
1797  h_maxNHitsBeforeVtx_[match][2]->Fill(maxNHitsBeforeVtx);
1798  h_leadNHitsBeforeVtx_[match][2]->Fill(leadNHitsBeforeVtx);
1799  h_trailNHitsBeforeVtx_[match][2]->Fill(trailNHitsBeforeVtx);
1800  h_sumNHitsBeforeVtx_[match][2]->Fill(sumNHitsBeforeVtx);
1801  h_deltaExpectedHitsInner_[match][2]->Fill(deltaExpectedHitsInner);
1802  h_leadExpectedHitsInner_[match][2]->Fill(leadExpectedHitsInner);
1803  h_maxDlClosestHitToVtx_[match][2]->Fill(maxDlClosestHitToVtx);
1804  h_maxDlClosestHitToVtxSig_[match][2]->Fill(maxDlClosestHitToVtxSig);
1805  h_nSharedHits_[match][2]->Fill(aConv.nSharedHits());
1806  if (matchConvSC) {
1807  h_EoverPTracks_[match][2]->Fill(iMatchingSC->superCluster()->energy() / sqrt(refittedMom.mag2()));
1808  h_convSCdPhi_[match][2]->Fill(iMatchingSC->superCluster()->position().phi() - refittedMom.phi());
1809  double ConvEta = etaTransformation(aConv.refittedPairMomentum().eta(), aConv.zOfPrimaryVertexFromTracks());
1810  h_convSCdEta_[match][2]->Fill(iMatchingSC->superCluster()->position().eta() - ConvEta);
1811  }
1812  }
1813 
1814  h_convVtxRvsZ_[0]->Fill(fabs(aConv.conversionVertex().position().z()),
1815  sqrt(aConv.conversionVertex().position().perp2()));
1816  h_convVtxYvsX_->Fill(aConv.conversionVertex().position().x(), aConv.conversionVertex().position().y());
1817  h_convVtxYvsX_zoom_[0]->Fill(aConv.conversionVertex().position().x(), aConv.conversionVertex().position().y());
1818  h_convVtxYvsX_zoom_[1]->Fill(aConv.conversionVertex().position().x(), aConv.conversionVertex().position().y());
1819 
1820  // quantities per track: all conversions
1821  for (unsigned int i = 0; i < tracks.size(); i++) {
1822  double d0;
1823  if (valid_pvtx) {
1824  d0 = -tracks[i]->dxy(the_pvtx.position());
1825  } else {
1826  d0 = tracks[i]->d0();
1827  }
1828  h_TkD0_[match]->Fill(d0 * tracks[i]->charge());
1829  h_nHitsBeforeVtx_[match]->Fill(aConv.nHitsBeforeVtx().size() > 1 ? aConv.nHitsBeforeVtx().at(i) : 0);
1830  h_dlClosestHitToVtx_[match]->Fill(aConv.dlClosestHitToVtx().size() > 1 ? aConv.dlClosestHitToVtx().at(i).value()
1831  : 0);
1832  h_dlClosestHitToVtxSig_[match]->Fill(aConv.dlClosestHitToVtx().size() > 1
1833  ? aConv.dlClosestHitToVtx().at(i).value() /
1834  aConv.dlClosestHitToVtx().at(i).error()
1835  : 0);
1836 
1837  nHitsVsEta_[match]->Fill(mcEta_, float(tracks[i]->numberOfValidHits()));
1838  nHitsVsR_[match]->Fill(mcConvR_, float(tracks[i]->numberOfValidHits()));
1839  p_nHitsVsEta_[match]->Fill(mcEta_, float(tracks[i]->numberOfValidHits()) - 0.0001);
1840  p_nHitsVsR_[match]->Fill(mcConvR_, float(tracks[i]->numberOfValidHits()) - 0.0001);
1841  h_tkChi2_[match]->Fill(tracks[i]->normalizedChi2());
1842  h_tkChi2Large_[match]->Fill(tracks[i]->normalizedChi2());
1843  h2_Chi2VsEta_[match]->Fill(mcEta_, tracks[i]->normalizedChi2());
1844  h2_Chi2VsR_[match]->Fill(mcConvR_, tracks[i]->normalizedChi2());
1845  p_Chi2VsEta_[match]->Fill(mcEta_, tracks[i]->normalizedChi2());
1846  p_Chi2VsR_[match]->Fill(mcConvR_, tracks[i]->normalizedChi2());
1847  }
1848 
1849  bool associated = false;
1850  float mcConvPt_ = -99999999.0;
1851  // float mcPhi= 0; // unused
1852  float simPV_Z = 0;
1853  for (std::vector<PhotonMCTruth>::const_iterator mcPho = mcPhotons.begin(); mcPho != mcPhotons.end(); mcPho++) {
1854  mcConvPt_ = (*mcPho).fourMomentum().et();
1855  float mcPhi = (*mcPho).fourMomentum().phi();
1856  simPV_Z = (*mcPho).primaryVertex().z();
1857  mcPhi_ = phiNormalization(mcPhi);
1858  mcEta_ = (*mcPho).fourMomentum().pseudoRapidity();
1859  mcEta_ = etaTransformation(mcEta_, (*mcPho).primaryVertex().z());
1860  mcConvR_ = (*mcPho).vertex().perp();
1861  mcConvX_ = (*mcPho).vertex().x();
1862  mcConvY_ = (*mcPho).vertex().y();
1863  mcConvZ_ = (*mcPho).vertex().z();
1864  mcConvEta_ = (*mcPho).vertex().eta();
1865  mcConvPhi_ = (*mcPho).vertex().phi();
1866  if (fabs(mcEta_) > END_HI)
1867  continue;
1868  if (mcConvPt_ < minPhoPtForPurity)
1869  continue;
1870  if (fabs(mcEta_) > maxPhoEtaForPurity)
1871  continue;
1872  if (fabs(mcConvZ_) > maxPhoZForPurity)
1873  continue;
1874  if (mcConvR_ > maxPhoRForEffic)
1875  continue;
1876 
1877  if ((*mcPho).isAConversion() != 1)
1878  continue;
1879  if (!((fabs(mcEta_) <= BARL && mcConvR_ < 85) ||
1880  (fabs(mcEta_) > BARL && fabs(mcEta_) <= END_HI && fabs((*mcPho).vertex().z()) < 210)))
1881  continue;
1882 
1883  theConvTP_.clear();
1884  for (const TrackingParticleRef& tp : tpForFakeRate) {
1885  if (fabs(tp->vx() - (*mcPho).vertex().x()) < 0.0001 && fabs(tp->vy() - (*mcPho).vertex().y()) < 0.0001 &&
1886  fabs(tp->vz() - (*mcPho).vertex().z()) < 0.0001) {
1887  theConvTP_.push_back(tp);
1888  }
1889  }
1890 
1891  if (theConvTP_.size() < 2)
1892  continue;
1893 
1894  //associated = false;
1895  reco::RecoToSimCollection const& p1 = theTrackAssociator->associateRecoToSim(tc1, theConvTP_);
1896  reco::RecoToSimCollection const& p2 = theTrackAssociator->associateRecoToSim(tc2, theConvTP_);
1897 
1898  auto itP1 = p1.find(tk1);
1899  auto itP2 = p2.find(tk2);
1900  bool good = (itP1 != p1.end()) and (not itP1->val.empty()) and (itP2 != p2.end()) and (not itP2->val.empty());
1901  if (not good) {
1902  itP1 = p1.find(tk2);
1903  itP2 = p2.find(tk1);
1904  good = (itP1 != p1.end()) and (not itP1->val.empty()) and (itP2 != p2.end()) and (not itP2->val.empty());
1905  }
1906 
1907  if (good) {
1908  std::vector<std::pair<TrackingParticleRef, double> > const& tp1 = itP1->val;
1909  std::vector<std::pair<TrackingParticleRef, double> > const& tp2 = itP2->val;
1910  TrackingParticleRef tpr1 = tp1.front().first;
1911  TrackingParticleRef tpr2 = tp2.front().first;
1912  if (abs(tpr1->pdgId()) == 11 && abs(tpr2->pdgId()) == 11 && tpr1->pdgId() * tpr2->pdgId() < 0) {
1913  if ((tpr1->parentVertex()->sourceTracks_end() - tpr1->parentVertex()->sourceTracks_begin() == 1) &&
1914  (tpr2->parentVertex()->sourceTracks_end() - tpr2->parentVertex()->sourceTracks_begin() == 1)) {
1915  if (tpr1->parentVertex().key() == tpr2->parentVertex().key() &&
1916  ((*tpr1->parentVertex()->sourceTracks_begin())->pdgId() == 22)) {
1917  mcConvR_ = sqrt(tpr1->parentVertex()->position().Perp2());
1918  mcConvZ_ = tpr1->parentVertex()->position().z();
1919  mcConvX_ = tpr1->parentVertex()->position().x();
1920  mcConvY_ = tpr1->parentVertex()->position().y();
1921  mcConvEta_ = tpr1->parentVertex()->position().eta();
1922  mcConvPhi_ = tpr1->parentVertex()->position().phi();
1923  mcConvPt_ = sqrt((*tpr1->parentVertex()->sourceTracks_begin())->momentum().Perp2());
1924  //std::cout << " Reco to Sim mcconvpt " << mcConvPt_ << std::endl;
1925  //cout << "associated track1 to " << tpr1->pdgId() << " with p=" << tpr1->p4() << " with pT=" << tpr1->pt() << endl;
1926  //cout << "associated track2 to " << tpr2->pdgId() << " with p=" << tpr2->p4() << " with pT=" << tpr2->pt() << endl;
1927  associated = true;
1928  break;
1929  }
1930  }
1931  }
1932  }
1933 
1934  } // end loop on sim photons
1935 
1936  if (false) {
1937  theConvTP_.clear();
1938  theConvTP_ = tpForFakeRate;
1939  reco::RecoToSimCollection p1incl = theTrackAssociator->associateRecoToSim(tc1, theConvTP_);
1940  reco::RecoToSimCollection p2incl = theTrackAssociator->associateRecoToSim(tc2, theConvTP_);
1941 
1942  for (std::vector<PhotonMCTruth>::const_iterator mcPho = mcPhotons.begin(); mcPho != mcPhotons.end(); mcPho++) {
1943  mcConvPt_ = (*mcPho).fourMomentum().et();
1944  float mcPhi = (*mcPho).fourMomentum().phi();
1945  simPV_Z = (*mcPho).primaryVertex().z();
1946  mcPhi_ = phiNormalization(mcPhi);
1947  mcEta_ = (*mcPho).fourMomentum().pseudoRapidity();
1948  mcEta_ = etaTransformation(mcEta_, (*mcPho).primaryVertex().z());
1949  mcConvR_ = (*mcPho).vertex().perp();
1950  mcConvX_ = (*mcPho).vertex().x();
1951  mcConvY_ = (*mcPho).vertex().y();
1952  mcConvZ_ = (*mcPho).vertex().z();
1953  mcConvEta_ = (*mcPho).vertex().eta();
1954  mcConvPhi_ = (*mcPho).vertex().phi();
1955  if (fabs(mcEta_) > END_HI)
1956  continue;
1957  if (mcConvPt_ < minPhoPtForPurity)
1958  continue;
1959  if (fabs(mcEta_) > maxPhoEtaForPurity)
1960  continue;
1961  if (fabs(mcConvZ_) > maxPhoZForPurity)
1962  continue;
1963  if (mcConvR_ > maxPhoRForEffic)
1964  continue;
1965 
1966  if ((*mcPho).isAConversion() != 1)
1967  continue;
1968  if (!((fabs(mcEta_) <= BARL && mcConvR_ < 85) ||
1969  (fabs(mcEta_) > BARL && fabs(mcEta_) <= END_HI && fabs((*mcPho).vertex().z()) < 210)))
1970  continue;
1971 
1972  theConvTP_.clear();
1973  for (const TrackingParticleRef& tp : tpForFakeRate) {
1974  if (fabs(tp->vx() - (*mcPho).vertex().x()) < 0.0001 && fabs(tp->vy() - (*mcPho).vertex().y()) < 0.0001 &&
1975  fabs(tp->vz() - (*mcPho).vertex().z()) < 0.0001) {
1976  theConvTP_.push_back(tp);
1977  }
1978  }
1979 
1980  if (theConvTP_.size() < 2)
1981  continue;
1982 
1983  //associated = false;
1984  reco::RecoToSimCollection p1 = theTrackAssociator->associateRecoToSim(tc1, theConvTP_);
1985  reco::RecoToSimCollection p2 = theTrackAssociator->associateRecoToSim(tc2, theConvTP_);
1986 
1987  if ((!p1incl.empty() && !p2incl.empty()) && (!p1.empty() || !p2.empty())) { // associated = true;
1988  try {
1989  std::vector<std::pair<TrackingParticleRef, double> > tp1 = p1incl[tk1];
1990  std::vector<std::pair<TrackingParticleRef, double> > tp2 = p2incl[tk2];
1991  if (!(!tp1.empty() && !tp2.empty())) {
1992  tp1 = p1[tk2];
1993  tp2 = p2[tk1];
1994  }
1995  if (!tp1.empty() && !tp2.empty()) {
1996  TrackingParticleRef tpr1 = tp1.front().first;
1997  TrackingParticleRef tpr2 = tp2.front().first;
1998  if (abs(tpr1->pdgId()) == 11 && abs(tpr2->pdgId()) == 11 && tpr1->pdgId() * tpr2->pdgId() < 0) {
1999  if (((tpr1->parentVertex()->sourceTracks_end() - tpr1->parentVertex()->sourceTracks_begin() >= 1) &&
2000  (*tpr1->parentVertex()->sourceTracks_begin())->pdgId() == 22) &&
2001  ((tpr2->parentVertex()->sourceTracks_end() - tpr2->parentVertex()->sourceTracks_begin() >= 1) &&
2002  (*tpr2->parentVertex()->sourceTracks_begin())->pdgId() == 22)) {
2003  // if ( fabs(tpr1->vx() - tpr2->vx()) < 0.1 && fabs(tpr1->vy() - tpr2->vy()) < 0.1 && fabs(tpr1->vz() - tpr2->vz()) < 0.1) {
2004  //if (((*tpr1->parentVertex()->sourceTracks_begin())->pdgId()==22) || ((*tpr2->parentVertex()->sourceTracks_begin())->pdgId()==22)) {
2005  // mcConvR_ = sqrt(tpr1->parentVertex()->position().Perp2());
2006  // mcConvZ_ = tpr1->parentVertex()->position().z();
2007  // mcConvX_ = tpr1->parentVertex()->position().x();
2008  // mcConvY_ = tpr1->parentVertex()->position().y();
2009  // mcConvEta_ = tpr1->parentVertex()->position().eta();
2010  // mcConvPhi_ = tpr1->parentVertex()->position().phi();
2011  // mcConvPt_ = sqrt((*tpr1->parentVertex()->sourceTracks_begin())->momentum().Perp2());
2012  //std::cout << " Reco to Sim mcconvpt " << mcConvPt_ << std::endl;
2013  //cout << "associated track1 to " << tpr1->pdgId() << " with p=" << tpr1->p4() << " with pT=" << tpr1->pt() << endl;
2014  //cout << "associated track2 to " << tpr2->pdgId() << " with p=" << tpr2->p4() << " with pT=" << tpr2->pt() << endl;
2015  associated = true;
2016  break;
2017  //}
2018  //}
2019  }
2020  }
2021  }
2022  } catch (Exception const& event) {
2023  //cout << "do not continue: " << event.what() << endl;
2024  //continue;
2025  }
2026  }
2027  }
2028  }
2029 
2030  if (associated)
2031  match = 1;
2032  else
2033  match = 2;
2034 
2035  h_match_->Fill(float(match));
2037  if (match == 1)
2038  nRecConvAss_++;
2039  h_convEta_[match][0]->Fill(refittedMom.eta());
2040  h_convEta_[match][1]->Fill(refittedMom.eta());
2041  if (matchConvSC)
2042  h_convEtaMatchSC_[match][0]->Fill(refittedMom.eta());
2043  h_convPhi_[match][0]->Fill(refittedMom.phi());
2044  h_convR_[match][0]->Fill(sqrt(aConv.conversionVertex().position().perp2()));
2045  h_convZ_[match][0]->Fill(aConv.conversionVertex().position().z());
2046  h_convPt_[match][0]->Fill(sqrt(refittedMom.perp2()));
2047  h_invMass_[match][0]->Fill(invM);
2048  h_vtxChi2Prob_[match][0]->Fill(chi2Prob);
2049  h_DPhiTracksAtVtx_[match][0]->Fill(dPhiTracksAtVtx);
2050  h_DCotTracks_[match][0]->Fill(aConv.pairCotThetaSeparation());
2051  h_distMinAppTracks_[match][0]->Fill(aConv.distOfMinimumApproach());
2052  h_lxybs_[match][0]->Fill(lxy);
2053  h_maxNHitsBeforeVtx_[match][0]->Fill(maxNHitsBeforeVtx);
2054  h_leadNHitsBeforeVtx_[match][0]->Fill(leadNHitsBeforeVtx);
2055  h_trailNHitsBeforeVtx_[match][0]->Fill(trailNHitsBeforeVtx);
2056  h_sumNHitsBeforeVtx_[match][0]->Fill(sumNHitsBeforeVtx);
2057  h_deltaExpectedHitsInner_[match][0]->Fill(deltaExpectedHitsInner);
2058  h_leadExpectedHitsInner_[match][0]->Fill(leadExpectedHitsInner);
2059  h_maxDlClosestHitToVtx_[match][0]->Fill(maxDlClosestHitToVtx);
2060  h_maxDlClosestHitToVtxSig_[match][0]->Fill(maxDlClosestHitToVtxSig);
2061  h_nSharedHits_[match][0]->Fill(aConv.nSharedHits());
2062  if (matchConvSC) {
2063  //h_EoverPTracks_[match][0] ->Fill (aConv.EoverPrefittedTracks());
2064  h_EoverPTracks_[match][0]->Fill(iMatchingSC->superCluster()->energy() / sqrt(refittedMom.mag2()));
2065  h_convSCdPhi_[match][0]->Fill(iMatchingSC->superCluster()->position().phi() - refittedMom.phi());
2066  double ConvEta = etaTransformation(aConv.refittedPairMomentum().eta(), aConv.zOfPrimaryVertexFromTracks());
2067  h_convSCdEta_[match][0]->Fill(iMatchingSC->superCluster()->position().eta() - ConvEta);
2068  }
2069  if (match == 1) {
2070  h2_photonPtRecVsPtSim_->Fill(mcConvPt_, sqrt(refittedMom.perp2()));
2071  h_convPtRes_[0]->Fill(sqrt(refittedMom.perp2()) / mcConvPt_);
2072  }
2073 
2074  if (phoIsInBarrel) {
2075  h_invMass_[match][1]->Fill(invM);
2076  h_vtxChi2Prob_[match][1]->Fill(chi2Prob);
2077  h_DPhiTracksAtVtx_[match][1]->Fill(dPhiTracksAtVtx);
2078  h_DCotTracks_[match][1]->Fill(aConv.pairCotThetaSeparation());
2079  h_distMinAppTracks_[match][1]->Fill(aConv.distOfMinimumApproach());
2080  h_lxybs_[match][1]->Fill(lxy);
2081  h_maxNHitsBeforeVtx_[match][1]->Fill(maxNHitsBeforeVtx);
2082  h_leadNHitsBeforeVtx_[match][1]->Fill(leadNHitsBeforeVtx);
2083  h_trailNHitsBeforeVtx_[match][1]->Fill(trailNHitsBeforeVtx);
2084  h_sumNHitsBeforeVtx_[match][1]->Fill(sumNHitsBeforeVtx);
2085  h_deltaExpectedHitsInner_[match][1]->Fill(deltaExpectedHitsInner);
2086  h_leadExpectedHitsInner_[match][1]->Fill(leadExpectedHitsInner);
2087  h_maxDlClosestHitToVtx_[match][1]->Fill(maxDlClosestHitToVtx);
2088  h_maxDlClosestHitToVtxSig_[match][1]->Fill(maxDlClosestHitToVtxSig);
2089  h_nSharedHits_[match][1]->Fill(aConv.nSharedHits());
2090  if (matchConvSC) {
2091  // h_EoverPTracks_[match][1] ->Fill (aConv.EoverPrefittedTracks());
2092  h_EoverPTracks_[match][1]->Fill(iMatchingSC->superCluster()->energy() / sqrt(refittedMom.mag2()));
2093  h_convSCdPhi_[match][1]->Fill(iMatchingSC->superCluster()->position().phi() - refittedMom.phi());
2094  double ConvEta = etaTransformation(aConv.refittedPairMomentum().eta(), aConv.zOfPrimaryVertexFromTracks());
2095  h_convSCdEta_[match][1]->Fill(iMatchingSC->superCluster()->position().eta() - ConvEta);
2096  }
2097  if (match == 1)
2098  h_convPtRes_[1]->Fill(sqrt(refittedMom.perp2()) / mcConvPt_);
2099  }
2100 
2101  if (phoIsInEndcap) {
2102  h_invMass_[match][2]->Fill(invM);
2103  h_vtxChi2Prob_[match][2]->Fill(chi2Prob);
2104  h_DPhiTracksAtVtx_[match][2]->Fill(dPhiTracksAtVtx);
2105  h_DCotTracks_[match][2]->Fill(aConv.pairCotThetaSeparation());
2106  h_distMinAppTracks_[match][2]->Fill(aConv.distOfMinimumApproach());
2107  h_lxybs_[match][2]->Fill(lxy);
2108  h_maxNHitsBeforeVtx_[match][2]->Fill(maxNHitsBeforeVtx);
2109  h_leadNHitsBeforeVtx_[match][2]->Fill(leadNHitsBeforeVtx);
2110  h_trailNHitsBeforeVtx_[match][2]->Fill(trailNHitsBeforeVtx);
2111  h_sumNHitsBeforeVtx_[match][2]->Fill(sumNHitsBeforeVtx);
2112  h_deltaExpectedHitsInner_[match][2]->Fill(deltaExpectedHitsInner);
2113  h_leadExpectedHitsInner_[match][2]->Fill(leadExpectedHitsInner);
2114  h_maxDlClosestHitToVtx_[match][2]->Fill(maxDlClosestHitToVtx);
2115  h_maxDlClosestHitToVtxSig_[match][2]->Fill(maxDlClosestHitToVtxSig);
2116  h_nSharedHits_[match][2]->Fill(aConv.nSharedHits());
2117  if (matchConvSC) {
2118  // h_EoverPTracks_[match][2] ->Fill (aConv.EoverPrefittedTracks());
2119  h_EoverPTracks_[match][2]->Fill(iMatchingSC->superCluster()->energy() / sqrt(refittedMom.mag2()));
2120  h_convSCdPhi_[match][2]->Fill(iMatchingSC->superCluster()->position().phi() - refittedMom.phi());
2121  double ConvEta = etaTransformation(aConv.refittedPairMomentum().eta(), aConv.zOfPrimaryVertexFromTracks());
2122  h_convSCdEta_[match][2]->Fill(iMatchingSC->superCluster()->position().eta() - ConvEta);
2123  }
2124  if (match == 1)
2125  h_convPtRes_[2]->Fill(sqrt(refittedMom.perp2()) / mcConvPt_);
2126  }
2127 
2128  if (match == 1) {
2129  h_convVtxdX_->Fill(aConv.conversionVertex().position().x() - mcConvX_);
2130  h_convVtxdY_->Fill(aConv.conversionVertex().position().y() - mcConvY_);
2131  h_convVtxdZ_->Fill(aConv.conversionVertex().position().z() - mcConvZ_);
2132  h_convVtxdR_->Fill(sqrt(aConv.conversionVertex().position().perp2()) - mcConvR_);
2133  h_convVtxdPhi_->Fill(aConv.conversionVertex().position().phi() - mcConvPhi_);
2134  h_convVtxdEta_->Fill(aConv.conversionVertex().position().eta() - mcConvEta_);
2135  h2_convVtxdRVsR_->Fill(mcConvR_, sqrt(aConv.conversionVertex().position().perp2()) - mcConvR_);
2136  h2_convVtxdRVsEta_->Fill(mcEta_, sqrt(aConv.conversionVertex().position().perp2()) - mcConvR_);
2137  p_convVtxdRVsR_->Fill(mcConvR_, sqrt(aConv.conversionVertex().position().perp2()) - mcConvR_);
2138  p_convVtxdRVsEta_->Fill(mcEta_, sqrt(aConv.conversionVertex().position().perp2()) - mcConvR_);
2139  p_convVtxdXVsX_->Fill(mcConvX_, aConv.conversionVertex().position().x() - mcConvX_);
2140  p_convVtxdYVsY_->Fill(mcConvY_, aConv.conversionVertex().position().y() - mcConvY_);
2141  p_convVtxdZVsZ_->Fill(mcConvZ_, aConv.conversionVertex().position().z() - mcConvZ_);
2142  p_convVtxdZVsR_->Fill(mcConvR_, aConv.conversionVertex().position().z() - mcConvZ_);
2143 
2144  float dR = sqrt(aConv.conversionVertex().position().perp2()) - mcConvR_;
2145  float dZ = aConv.conversionVertex().position().z() - mcConvZ_;
2146  p2_convVtxdRVsRZ_->Fill(mcConvZ_, mcConvR_, dR);
2147  p2_convVtxdZVsRZ_->Fill(mcConvZ_, mcConvR_, dZ);
2148 
2149  h2_convVtxRrecVsTrue_->Fill(mcConvR_, sqrt(aConv.conversionVertex().position().perp2()));
2150 
2151  h_zPVFromTracks_[match]->Fill(aConv.zOfPrimaryVertexFromTracks());
2152  h_dzPVFromTracks_[match]->Fill(aConv.zOfPrimaryVertexFromTracks() - simPV_Z);
2153  h2_dzPVVsR_->Fill(mcConvR_, aConv.zOfPrimaryVertexFromTracks() - simPV_Z);
2154  p_dzPVVsR_->Fill(mcConvR_, aConv.zOfPrimaryVertexFromTracks() - simPV_Z);
2155 
2156  if (phoIsInBarrel) {
2157  h_convVtxdX_barrel_->Fill(aConv.conversionVertex().position().x() - mcConvX_);
2158  h_convVtxdY_barrel_->Fill(aConv.conversionVertex().position().y() - mcConvY_);
2159  h_convVtxdZ_barrel_->Fill(aConv.conversionVertex().position().z() - mcConvZ_);
2160  h_convVtxdR_barrel_->Fill(sqrt(aConv.conversionVertex().position().perp2()) - mcConvR_);
2161  }
2162  if (phoIsInEndcap) {
2163  h_convVtxdX_endcap_->Fill(aConv.conversionVertex().position().x() - mcConvX_);
2164  h_convVtxdY_endcap_->Fill(aConv.conversionVertex().position().y() - mcConvY_);
2165  h_convVtxdZ_endcap_->Fill(aConv.conversionVertex().position().z() - mcConvZ_);
2166  h_convVtxdR_endcap_->Fill(sqrt(aConv.conversionVertex().position().perp2()) - mcConvR_);
2167  }
2168  }
2169 
2171  for (unsigned int i = 0; i < tracks.size(); i++) {
2172  //std::cout << " Loop over tracks pt " << tracks[i]->pt() << std::endl;
2173  RefToBase<reco::Track> tfrb(aConv.tracks()[i]);
2174  itAss = myAss.find(tfrb.get());
2175 
2176  nHitsVsEta_[match]->Fill(mcEta_, float(tracks[i]->numberOfValidHits()));
2177  nHitsVsR_[match]->Fill(mcConvR_, float(tracks[i]->numberOfValidHits()));
2178  p_nHitsVsEta_[match]->Fill(mcEta_, float(tracks[i]->numberOfValidHits()) - 0.0001);
2179  p_nHitsVsR_[match]->Fill(mcConvR_, float(tracks[i]->numberOfValidHits()) - 0.0001);
2180  h_tkChi2_[match]->Fill(tracks[i]->normalizedChi2());
2181  h_tkChi2Large_[match]->Fill(tracks[i]->normalizedChi2());
2182  h2_Chi2VsEta_[match]->Fill(mcEta_, tracks[i]->normalizedChi2());
2183  h2_Chi2VsR_[match]->Fill(mcConvR_, tracks[i]->normalizedChi2());
2184  p_Chi2VsEta_[match]->Fill(mcEta_, tracks[i]->normalizedChi2());
2185  p_Chi2VsR_[match]->Fill(mcConvR_, tracks[i]->normalizedChi2());
2186  double d0;
2187  if (valid_pvtx) {
2188  d0 = -tracks[i]->dxy(the_pvtx.position());
2189  } else {
2190  d0 = tracks[i]->d0();
2191  }
2192  h_TkD0_[match]->Fill(d0 * tracks[i]->charge());
2193  h_nHitsBeforeVtx_[match]->Fill(aConv.nHitsBeforeVtx().size() > 1 ? aConv.nHitsBeforeVtx().at(i) : 0);
2194  h_dlClosestHitToVtx_[match]->Fill(aConv.dlClosestHitToVtx().size() > 1 ? aConv.dlClosestHitToVtx().at(i).value()
2195  : 0);
2196  h_dlClosestHitToVtxSig_[match]->Fill(aConv.dlClosestHitToVtx().size() > 1
2197  ? aConv.dlClosestHitToVtx().at(i).value() /
2198  aConv.dlClosestHitToVtx().at(i).error()
2199  : 0);
2200 
2201  if (itAss == myAss.end())
2202  continue;
2203  reco::Track refTrack = aConv.conversionVertex().refittedTracks()[i];
2204 
2205  float simPt = sqrt(((*itAss).second)->momentum().perp2());
2206  float recPt = refTrack.pt();
2207  float ptres = recPt - simPt;
2208  //float pterror = aConv.tracks()[i]->ptError();
2209  float pterror = aConv.conversionVertex().refittedTracks()[i].ptError();
2210  h2_PtRecVsPtSim_[0]->Fill(simPt, recPt);
2211  h_TkPtPull_[0]->Fill(ptres / pterror);
2212  h2_TkPtPull_[0]->Fill(mcEta_, ptres / pterror);
2213 
2214  if (phoIsInBarrel) {
2215  h_TkPtPull_[1]->Fill(ptres / pterror);
2216  h2_PtRecVsPtSim_[1]->Fill(simPt, recPt);
2217  }
2218  if (phoIsInEndcap) {
2219  h_TkPtPull_[2]->Fill(ptres / pterror);
2220  h2_PtRecVsPtSim_[2]->Fill(simPt, recPt);
2221  }
2222  } // end loop over track
2223 
2224  } // loop over reco conversions
2225 
2226  h_nConv_[0][0]->Fill(float(nRecConv_));
2227  h_nConv_[1][0]->Fill(float(nRecConvAss_));
2228 }
2229 
2230 void TkConvValidator::endJob() {
2231  std::string outputFileName = parameters_.getParameter<std::string>("OutputFileName");
2232  if (!isRunCentrally_) {
2233  dbe_->save(outputFileName);
2234  }
2235 
2236  edm::LogInfo("TkConvValidator") << "Analyzed " << nEvt_ << "\n";
2237  // std::cout << "::endJob Analyzed " << nEvt_ << " events " << " with total " << nPho_ << " Photons " << "\n";
2238  // std::cout << "TkConvValidator::endJob Analyzed " << nEvt_ << " events " << "\n";
2239 
2240  return;
2241 }
2242 
2243 math::XYZVector TkConvValidator::recalculateMomentumAtFittedVertex(const MagneticField& mf,
2244  const TrackerGeometry& trackerGeom,
2245  const edm::RefToBase<reco::Track>& tk,
2246  const reco::Vertex& vtx) {
2247  math::XYZVector result;
2248  Surface::RotationType rot;
2249  auto scp = new SimpleCylinderBounds(sqrt(vtx.position().perp2()) - 0.001f,
2250  sqrt(vtx.position().perp2()) + 0.001f,
2251  -fabs(vtx.position().z()),
2252  fabs(vtx.position().z()));
2253  ReferenceCountingPointer<Cylinder> theBarrel_(
2254  new Cylinder(Cylinder::computeRadius(*scp), Surface::PositionType(0, 0, 0), rot, scp));
2255 
2256  ReferenceCountingPointer<Disk> theDisk_(
2257  new Disk(Surface::PositionType(0, 0, vtx.position().z()),
2258  rot,
2259  new SimpleDiskBounds(0, sqrt(vtx.position().perp2()), -0.001, 0.001)));
2260 
2261  const TrajectoryStateOnSurface myTSOS = trajectoryStateTransform::innerStateOnSurface(*tk, trackerGeom, &mf);
2262  PropagatorWithMaterial propag(anyDirection, 0.000511, &mf);
2263  TrajectoryStateOnSurface stateAtVtx;
2264  stateAtVtx = propag.propagate(myTSOS, *theBarrel_);
2265  if (!stateAtVtx.isValid()) {
2266  stateAtVtx = propag.propagate(myTSOS, *theDisk_);
2267  }
2268  if (stateAtVtx.isValid()) {
2269  return math::XYZVector(double(stateAtVtx.globalMomentum().x()),
2270  double(stateAtVtx.globalMomentum().y()),
2271  double(stateAtVtx.globalMomentum().z()));
2272  } else {
2273  return math::XYZVector(0., 0., 0.);
2274  }
2275 }
2276 
2277 float TkConvValidator::phiNormalization(float& phi) {
2278  //---Definitions
2279  const float PI = 3.1415927;
2280  const float TWOPI = 2.0 * PI;
2281 
2282  if (phi > PI) {
2283  phi = phi - TWOPI;
2284  }
2285  if (phi < -PI) {
2286  phi = phi + TWOPI;
2287  }
2288 
2289  // cout << " Float_t PHInormalization out " << PHI << endl;
2290  return phi;
2291 }
2292 
2293 float TkConvValidator::etaTransformation(float EtaParticle, float Zvertex) {
2294  //---Definitions
2295  const float PI = 3.1415927;
2296 
2297  //---Definitions for ECAL
2298  const float R_ECAL = 136.5;
2299  const float Z_Endcap = 328.0;
2300  const float etaBarrelEndcap = 1.479;
2301 
2302  //---ETA correction
2303 
2304  float Theta = 0.0;
2305  float ZEcal = R_ECAL * sinh(EtaParticle) + Zvertex;
2306 
2307  if (ZEcal != 0.0)
2308  Theta = atan(R_ECAL / ZEcal);
2309  if (Theta < 0.0)
2310  Theta = Theta + PI;
2311  float ETA = -log(tan(0.5 * Theta));
2312 
2313  if (fabs(ETA) > etaBarrelEndcap) {
2314  float Zend = Z_Endcap;
2315  if (EtaParticle < 0.0)
2316  Zend = -Zend;
2317  float Zlen = Zend - Zvertex;
2318  float RR = Zlen / sinh(EtaParticle);
2319  Theta = atan(RR / Zend);
2320  if (Theta < 0.0)
2321  Theta = Theta + PI;
2322  ETA = -log(tan(0.5 * Theta));
2323  }
2324  //---Return the result
2325  return ETA;
2326  //---end
2327 }
TkConvValidator::h_convR_
MonitorElement * h_convR_[3][3]
Definition: TkConvValidator.h:224
TkConvValidator::p_convVtxdZVsZ_
MonitorElement * p_convVtxdZVsZ_
Definition: TkConvValidator.h:291
reco::Conversion::pairCotThetaSeparation
double pairCotThetaSeparation() const
Delta cot(Theta) where Theta is the angle in the (y,z) plane between the two tracks....
Definition: Conversion.cc:179
PI
Definition: PayloadInspector.h:21
TkConvValidator::h_convEta_
MonitorElement * h_convEta_[3][3]
Definition: TkConvValidator.h:221
TrackExtra.h
TkRotation< float >
reco::Vertex::isValid
bool isValid() const
Tells whether the vertex is valid.
Definition: Vertex.h:72
good
const auto good
min quality of good
Definition: CAHitNtupletGeneratorKernelsImpl.h:760
TkConvValidator::h_SimRecConvTwoMTracks_
MonitorElement * h_SimRecConvTwoMTracks_[5]
Definition: TkConvValidator.h:211
GenJetCollection.h
reco::Conversion
Definition: Conversion.h:23
TrajectoryStateOnSurface.h
photonAnalyzer_cfi.rMax
rMax
Definition: photonAnalyzer_cfi.py:91
photonAnalyzer_cfi.etMin
etMin
Definition: photonAnalyzer_cfi.py:54
TkConvValidator::h_TkD0_
MonitorElement * h_TkD0_[3]
Definition: TkConvValidator.h:330
edm::RefVector::clear
void clear()
Clear the vector.
Definition: RefVector.h:142
Handle.h
TkConvValidator::maxPhoZForPurity
double maxPhoZForPurity
Definition: TkConvValidator.h:174
TkConvValidator::arbitratedEcalSeeded_
bool arbitratedEcalSeeded_
Definition: TkConvValidator.h:145
TkConvValidator::theMF_
edm::ESHandle< MagneticField > theMF_
Definition: TkConvValidator.h:76
ALCARECOTkAlBeamHalo_cff.etaMin
etaMin
GeV.
Definition: ALCARECOTkAlBeamHalo_cff.py:32
anyDirection
Definition: PropagationDirection.h:4
mps_fire.i
i
Definition: mps_fire.py:428
TkConvValidator::h_distMinAppTracks_
MonitorElement * h_distMinAppTracks_[3][3]
Definition: TkConvValidator.h:251
TkConvValidator::mcConvEta_
double mcConvEta_
Definition: TkConvValidator.h:161
edm::ESInputTag
Definition: ESInputTag.h:87
FreeTrajectoryState.h
TkConvValidator::p_DPhiTracksAtVtxVsEta_
MonitorElement * p_DPhiTracksAtVtxVsEta_
Definition: TkConvValidator.h:241
reco::Photon::superCluster
reco::SuperClusterRef superCluster() const override
Ref to SuperCluster.
reco::Conversion::generalTracksOnly
Definition: Conversion.h:28
photonAnalyzer_cfi.zMax
zMax
Definition: photonAnalyzer_cfi.py:95
MessageLogger.h
TkConvValidator::h2_Chi2VsR_
MonitorElement * h2_Chi2VsR_[3]
Definition: TkConvValidator.h:327
TkConvValidator::~TkConvValidator
~TkConvValidator() override
Definition: TkConvValidator.cc:145
TkConvValidator::h_convEta2_
MonitorElement * h_convEta2_[3][3]
Definition: TkConvValidator.h:222
TkConvValidator::h_convVtxdR_barrel_
MonitorElement * h_convVtxdR_barrel_
Definition: TkConvValidator.h:276
TrackerGeometry.h
edm::Handle::product
T const * product() const
Definition: Handle.h:70
TkConvValidator::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: TkConvValidator.cc:1238
TrackCandidateCollection.h
TkConvValidator::h_convVtxYvsX_
MonitorElement * h_convVtxYvsX_
Definition: TkConvValidator.h:262
photonAnalyzer_cfi.dPhiTracksMin
dPhiTracksMin
Definition: photonAnalyzer_cfi.py:102
etaBin
int etaBin(const l1t::HGCalMulticluster *cl)
Definition: L1EGammaEEProducer.cc:19
TkConvValidator::h_SimConvTwoTracks_
MonitorElement * h_SimConvTwoTracks_[5]
Definition: TkConvValidator.h:202
reco::TrackBase::inOutEcalSeededConv
Definition: TrackBase.h:106
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
photonAnalyzer_cfi.zBin
zBin
Definition: photonAnalyzer_cfi.py:93
PropagatorWithMaterial::propagate
TrajectoryStateOnSurface propagate(STA const &state, SUR const &surface) const
Definition: Propagator.h:50
TkConvValidator::h_convEtaMatchSC_
MonitorElement * h_convEtaMatchSC_[3][3]
Definition: TkConvValidator.h:220
reco::Conversion::tracks
std::vector< edm::RefToBase< reco::Track > > const & tracks() const
vector of track to base references
Definition: Conversion.cc:150
TkConvValidator::mcConvPt_
double mcConvPt_
Definition: TkConvValidator.h:155
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
photonAnalyzer_cfi.dPhiTracksBin
dPhiTracksBin
Definition: photonAnalyzer_cfi.py:101
BoundDisk.h
PI
#define PI
Definition: QcdUeDQM.h:37
TkConvValidator::h_convSCdPhi_
MonitorElement * h_convSCdPhi_[3][3]
Definition: TkConvValidator.h:230
TkConvValidator::h_VisSimConv_
MonitorElement * h_VisSimConv_[6]
Definition: TkConvValidator.h:197
edm::Run
Definition: Run.h:45
BeamMonitor_cff.phiBin
phiBin
Definition: BeamMonitor_cff.py:77
photonValidationSequence_cff.eoverpMax
eoverpMax
Definition: photonValidationSequence_cff.py:17
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
deltaPhi.h
BasicCluster.h
ChiSquaredProbability
float ChiSquaredProbability(double chiSquared, double nrDOF)
Definition: ChiSquaredProbability.cc:13
TkConvValidator::h_deltaExpectedHitsInner_
MonitorElement * h_deltaExpectedHitsInner_[3][3]
Definition: TkConvValidator.h:311
edm
HLT enums.
Definition: AlignableModifier.h:19
TkConvValidator::h_simConvVtxYvsX_
MonitorElement * h_simConvVtxYvsX_
Definition: TkConvValidator.h:193
dqm::implementation::IBooker::bookProfile2D
MonitorElement * bookProfile2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, double lowZ, double highZ, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:399
reco::TrackToTrackingParticleAssociator::associateRecoToSim
reco::RecoToSimCollection associateRecoToSim(const edm::Handle< edm::View< reco::Track >> &tCH, const edm::Handle< TrackingParticleCollection > &tPCH) const
Definition: TrackToTrackingParticleAssociator.h:64
photonValidationSequence_cff.eoverpMin
eoverpMin
Definition: photonValidationSequence_cff.py:16
TkConvValidator::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: TkConvValidator.cc:147
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
TkConvValidator::nRecConvAssWithEcal_
int nRecConvAssWithEcal_
Definition: TkConvValidator.h:85
edm::RefVector::begin
const_iterator begin() const
Initialize an iterator over the RefVector.
Definition: RefVector.h:223
TrackCollections2monitor_cff.numberOfValidHits
numberOfValidHits
Definition: TrackCollections2monitor_cff.py:248
TkConvValidator::h_convRplot_
MonitorElement * h_convRplot_
Definition: TkConvValidator.h:232
SimpleCylinderBounds.h
TkConvValidator::h2_DCotTracksVsEta_
MonitorElement * h2_DCotTracksVsEta_
Definition: TkConvValidator.h:246
TkConvValidator::h2_convVtxdRVsEta_
MonitorElement * h2_convVtxdRVsEta_
Definition: TkConvValidator.h:284
muonRecoAnalyzer_cfi.chi2Min
chi2Min
Definition: muonRecoAnalyzer_cfi.py:34
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
TkConvValidator::h_simTkEta_
MonitorElement * h_simTkEta_
Definition: TkConvValidator.h:190
TkConvValidator::nEntry_
int nEntry_
Definition: TkConvValidator.h:80
TkConvValidator::p_DCotTracksVsEta_
MonitorElement * p_DCotTracksVsEta_
Definition: TkConvValidator.h:247
TkConvValidator::h2_DPhiTracksAtVtxVsR_
MonitorElement * h2_DPhiTracksAtVtxVsR_
Definition: TkConvValidator.h:242
reco::Conversion::pairInvariantMass
double pairInvariantMass() const
if nTracks=2 returns the pair invariant mass. Original tracks are used here
Definition: Conversion.cc:159
ChiSquaredProbability.h
reco::Conversion::zOfPrimaryVertexFromTracks
double zOfPrimaryVertexFromTracks(const math::XYZPoint &myBeamSpot=math::XYZPoint()) const
Definition: Conversion.h:136
TkConvValidator::tpSelForEff_Token_
edm::EDGetTokenT< TrackingParticleRefVector > tpSelForEff_Token_
Definition: TkConvValidator.h:107
reco::Conversion::dlClosestHitToVtx
const std::vector< Measurement1DFloat > & dlClosestHitToVtx() const
Vector of signed decay length with uncertainty from nearest hit on track to the conversion vtx positi...
Definition: Conversion.h:156
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:127
TkConvValidator::h_convVtxdPhi_
MonitorElement * h_convVtxdPhi_
Definition: TkConvValidator.h:271
TrackerHitAssociator.h
TkConvValidator::h_EoverPTracks_
MonitorElement * h_EoverPTracks_[3][3]
Definition: TkConvValidator.h:227
photonValidator_cfi.dCotTracksMax
dCotTracksMax
Definition: photonValidator_cfi.py:100
TkConvValidator::p_TkPtPull_
MonitorElement * p_TkPtPull_[3]
Definition: TkConvValidator.h:334
TkConvValidator::h2_dzPVVsR_
MonitorElement * h2_dzPVVsR_
Definition: TkConvValidator.h:303
ReferenceCountingPointer< Cylinder >
BoundCylinder.h
TkConvValidator::h_convVtxdR_endcap_
MonitorElement * h_convVtxdR_endcap_
Definition: TkConvValidator.h:281
edm::RefVector< TrackingParticleCollection >
PhotonMCTruthFinder::find
std::vector< PhotonMCTruth > find(const std::vector< SimTrack > &simTracks, const std::vector< SimVertex > &simVertices)
Definition: PhotonMCTruthFinder.cc:17
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
photonValidator_cfi.zMinForXray
zMinForXray
Definition: photonValidator_cfi.py:122
TkConvValidator::h2_photonPtRecVsPtSim_
MonitorElement * h2_photonPtRecVsPtSim_
Definition: TkConvValidator.h:336
TkConvValidator::p_dzPVVsR_
MonitorElement * p_dzPVVsR_
Definition: TkConvValidator.h:304
reco::HitPattern::numberOfLostHits
int numberOfLostHits(HitCategory category) const
Definition: HitPattern.h:878
edm::Handle< reco::TrackToTrackingParticleAssociator >
parallelization.uint
uint
Definition: parallelization.py:124
TkConvValidator::parameters_
edm::ParameterSet parameters_
Definition: TkConvValidator.h:89
photonValidator_cfi.rMinForXray
rMinForXray
Definition: photonValidator_cfi.py:118
TkConvValidator::nHits_
MonitorElement * nHits_[3]
Definition: TkConvValidator.h:318
TkConvValidator::conversionCollectionPr_Token_
edm::EDGetTokenT< reco::ConversionCollection > conversionCollectionPr_Token_
Definition: TkConvValidator.h:95
BasicClusterFwd.h
TkConvValidator::h_TkPtPull_
MonitorElement * h_TkPtPull_[3]
Definition: TkConvValidator.h:332
TkConvValidator::beamspotToken_
edm::EDGetTokenT< reco::BeamSpot > beamspotToken_
Definition: TkConvValidator.h:104
TwoTrackMinimumDistance.h
TkConvValidator::h_SimConvTwoMTracksAndVtxPGT0_
MonitorElement * h_SimConvTwoMTracksAndVtxPGT0_[5]
Definition: TkConvValidator.h:204
TkConvValidator::h_nSimConv_
MonitorElement * h_nSimConv_[2]
Definition: TkConvValidator.h:186
edm::Ref< TrackingParticleCollection >
reco::ConversionCollection
std::vector< Conversion > ConversionCollection
collectin of Conversion objects
Definition: ConversionFwd.h:9
recPt
double recPt
Definition: PFJetBenchmarkAnalyzer.cc:75
TkConvValidator::isRunCentrally_
bool isRunCentrally_
Definition: TkConvValidator.h:124
edm::Exception
Definition: EDMException.h:77
GenParticle.h
photonAnalyzer_cfi.dPhiTracksMax
dPhiTracksMax
Definition: photonAnalyzer_cfi.py:103
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
SimpleCylinderBounds
Definition: SimpleCylinderBounds.h:19
PhotonMCTruthFinder::clear
void clear()
Definition: PhotonMCTruthFinder.h:27
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:637
TkConvValidator::generalTracksOnly_
bool generalTracksOnly_
Definition: TkConvValidator.h:143
SimpleDiskBounds
Definition: SimpleDiskBounds.h:11
conversionPostprocessing_cfi.etaBin2
etaBin2
Definition: conversionPostprocessing_cfi.py:19
TkConvValidator::caloGeometryToken_
const edm::ESGetToken< CaloGeometry, CaloGeometryRecord > caloGeometryToken_
Definition: TkConvValidator.h:114
TrajectoryStateOnSurface
Definition: TrajectoryStateOnSurface.h:16
reco::Conversion::refittedPairMomentum
math::XYZVectorF refittedPairMomentum() const
Conversion tracks momentum from the tracks refitted with vertex constraint.
Definition: Conversion.cc:206
MakerMacros.h
TkConvValidator::tpSelForFake_Token_
edm::EDGetTokenT< TrackingParticleRefVector > tpSelForFake_Token_
Definition: TkConvValidator.h:108
Photon.h
reco::Conversion::arbitratedMerged
Definition: Conversion.h:30
TkConvValidator::h_dlClosestHitToVtxSig_
MonitorElement * h_dlClosestHitToVtxSig_[3]
Definition: TkConvValidator.h:344
edm::RefVector::end
const_iterator end() const
Termination of iteration.
Definition: RefVector.h:228
PropagatorWithMaterial
Definition: PropagatorWithMaterial.h:25
TrackingRecHit.h
TkConvValidator::arbitratedMerged_
bool arbitratedMerged_
Definition: TkConvValidator.h:144
Track.h
TrackFwd.h
TkConvValidator.h
photonValidator_cfi.resMin
resMin
Definition: photonValidator_cfi.py:91
TrackingVertexContainer.h
reco::Conversion::nHitsBeforeVtx
const std::vector< uint8_t > & nHitsBeforeVtx() const
Vector of the number of hits before the vertex along each track trajector.
Definition: Conversion.h:154
TkConvValidator::h2_convVtxRrecVsTrue_
MonitorElement * h2_convVtxRrecVsTrue_
Definition: TkConvValidator.h:297
TkConvValidator::TkConvValidator
TkConvValidator(const edm::ParameterSet &)
Definition: TkConvValidator.cc:96
photonValidationSequence_cff.useTP
useTP
Definition: photonValidationSequence_cff.py:14
ElectronMCTruth.h
edm::RefToBaseVector::push_back
void push_back(const RefToBase< T > &)
Definition: RefToBaseVector.h:217
reco::Conversion::arbitratedEcalSeeded
Definition: Conversion.h:29
TkConvValidator::h_convVtxdZ_endcap_
MonitorElement * h_convVtxdZ_endcap_
Definition: TkConvValidator.h:280
reco::TrackBase::outInEcalSeededConv
Definition: TrackBase.h:105
TkConvValidator::h_leadExpectedHitsInner_
MonitorElement * h_leadExpectedHitsInner_[3][3]
Definition: TkConvValidator.h:312
PhotonMCTruth.h
Service.h
TkConvValidator::nRecConvAss_
int nRecConvAss_
Definition: TkConvValidator.h:84
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
SimVertex.h
TkConvValidator::nHitsVsR_
MonitorElement * nHitsVsR_[3]
Definition: TkConvValidator.h:322
TkConvValidator::p2_convVtxdZVsRZ_
MonitorElement * p2_convVtxdZVsRZ_
Definition: TkConvValidator.h:295
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
TkConvValidator::h_convVtxdX_
MonitorElement * h_convVtxdX_
Definition: TkConvValidator.h:266
AlignmentTrackSelector_cfi.phiMin
phiMin
Definition: AlignmentTrackSelector_cfi.py:18
photonValidator_cfi.rMaxForXray
rMaxForXray
Definition: photonValidator_cfi.py:119
reco::BeamSpot
Definition: BeamSpot.h:21
TkConvValidator::etaTransformation
float etaTransformation(float a, float b)
Definition: TkConvValidator.cc:2293
TkConvValidator::h_convSCdEta_
MonitorElement * h_convSCdEta_[3][3]
Definition: TkConvValidator.h:229
reco::Track
Definition: Track.h:27
IdealMagneticFieldRecord.h
AlignmentTrackSelector_cfi.phiMax
phiMax
Definition: AlignmentTrackSelector_cfi.py:17
p2
double p2[4]
Definition: TauolaWrapper.h:90
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:322
TkConvValidator::h_convVtxdY_endcap_
MonitorElement * h_convVtxdY_endcap_
Definition: TkConvValidator.h:279
photonValidator_cfi.zMaxForXray
zMaxForXray
Definition: photonValidator_cfi.py:123
TkConvValidator::h2_Chi2VsEta_
MonitorElement * h2_Chi2VsEta_[3]
Definition: TkConvValidator.h:325
CaloClusterFwd.h
TkConvValidator::h_convPhi_
MonitorElement * h_convPhi_[3][3]
Definition: TkConvValidator.h:223
reco_skim_cfg_mod.outputFileName
outputFileName
Definition: reco_skim_cfg_mod.py:15
TkConvValidator::mcConvX_
double mcConvX_
Definition: TkConvValidator.h:159
TkConvValidator::h_sumNHitsBeforeVtx_
MonitorElement * h_sumNHitsBeforeVtx_[3][3]
Definition: TkConvValidator.h:310
Point3DBase< float, GlobalTag >
TkConvValidator::minPhoPtForPurity
double minPhoPtForPurity
Definition: TkConvValidator.h:172
dqm::implementation::DQMStore::save
DQM_DEPRECATED void save(std::string const &filename, std::string const &path="")
Definition: DQMStore.cc:784
PhotonMCTruthFinder
Definition: PhotonMCTruthFinder.h:20
TkConvValidator::p_nHitsVsR_
MonitorElement * p_nHitsVsR_[3]
Definition: TkConvValidator.h:321
edm::RefToBase::get
value_type const * get() const
Definition: RefToBase.h:209
q2
double q2[4]
Definition: TauolaWrapper.h:88
cmsswSequenceInfo.tp
tp
Definition: cmsswSequenceInfo.py:17
TkConvValidator::magneticFieldToken_
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magneticFieldToken_
Definition: TkConvValidator.h:113
reco::Vertex::refittedTracks
const std::vector< Track > & refittedTracks() const
Returns the container of refitted tracks.
Definition: Vertex.h:196
TkConvValidator::recalculateMomentumAtFittedVertex
math::XYZVector recalculateMomentumAtFittedVertex(const MagneticField &mf, const TrackerGeometry &trackerGeom, const edm::RefToBase< reco::Track > &tk, const reco::Vertex &vtx)
Definition: TkConvValidator.cc:2243
TkConvValidator::h_lxybs_
MonitorElement * h_lxybs_[3][3]
Definition: TkConvValidator.h:306
photonValidator_cfi.eoverpBin
eoverpBin
Definition: photonValidator_cfi.py:106
TkConvValidator::g4_simTk_Token_
edm::EDGetTokenT< edm::SimTrackContainer > g4_simTk_Token_
Definition: TkConvValidator.h:105
TkConvValidator::h_nHitsBeforeVtx_
MonitorElement * h_nHitsBeforeVtx_[3]
Definition: TkConvValidator.h:342
TkConvValidator::maxPhoEtaForPurity
double maxPhoEtaForPurity
Definition: TkConvValidator.h:173
TkConvValidator::nEvt_
int nEvt_
Definition: TkConvValidator.h:79
TFileService.h
PhotonMCTruthFinder.h
TkConvValidator::h_simConvVtxRvsZ_
MonitorElement * h_simConvVtxRvsZ_[4]
Definition: TkConvValidator.h:192
TkConvValidator::h_DPhiTracksAtVtx_
MonitorElement * h_DPhiTracksAtVtx_[3][3]
Definition: TkConvValidator.h:239
PbPb_ZMuSkimMuonDPG_cff.tracker
tracker
Definition: PbPb_ZMuSkimMuonDPG_cff.py:60
ALCARECOTkAlJpsiMuMu_cff.charge
charge
Definition: ALCARECOTkAlJpsiMuMu_cff.py:47
TkConvValidator::h_convVtxdX_barrel_
MonitorElement * h_convVtxdX_barrel_
Definition: TkConvValidator.h:273
TkConvValidator::h_simTkPt_
MonitorElement * h_simTkPt_
Definition: TkConvValidator.h:189
TkConvValidator::h_maxDlClosestHitToVtx_
MonitorElement * h_maxDlClosestHitToVtx_[3][3]
Definition: TkConvValidator.h:313
TrackerDigiGeometryRecord.h
TkConvValidator::p_convVtxdRVsR_
MonitorElement * p_convVtxdRVsR_
Definition: TkConvValidator.h:286
TkConvValidator::mcConvZ_
double mcConvZ_
Definition: TkConvValidator.h:157
edm::ParameterSet
Definition: ParameterSet.h:47
q1
double q1[4]
Definition: TauolaWrapper.h:87
TkConvValidator::p_Chi2VsEta_
MonitorElement * p_Chi2VsEta_[3]
Definition: TkConvValidator.h:326
reco::Conversion::quality
bool quality(ConversionQuality q) const
Definition: Conversion.h:178
tracks
const uint32_t *__restrict__ const HitContainer *__restrict__ TkSoA *__restrict__ tracks
Definition: CAHitNtupletGeneratorKernelsImpl.h:176
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
TWOPI
#define TWOPI
Definition: DQMSourcePi0.cc:36
reco::Conversion::conversionVertex
const reco::Vertex & conversionVertex() const
returns the reco conversion vertex
Definition: Conversion.h:88
PropagatorWithMaterial.h
edm::AssociationMap< edm::OneToManyWithQualityGeneric< TrackingParticleCollection, edm::View< reco::Track >, double > >
TkConvValidator::dqmpath_
std::string dqmpath_
Definition: TkConvValidator.h:118
EcalClusterTools.h
reco::Vertex::x
double x() const
x coordinate
Definition: Vertex.h:129
TkConvValidator::h_convPt_
MonitorElement * h_convPt_[3][3]
Definition: TkConvValidator.h:226
match
std::pair< typename Association::data_type::first_type, double > match(Reference key, Association association, bool bestMatchByMaxValue)
Generic matching function.
Definition: Utils.h:10
math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:31
TkConvValidator::offline_pvToken_
edm::EDGetTokenT< reco::VertexCollection > offline_pvToken_
Definition: TkConvValidator.h:103
photonAnalyzer_cfi.zMin
zMin
Definition: photonAnalyzer_cfi.py:94
TkConvValidator::h_zPVFromTracks_
MonitorElement * h_zPVFromTracks_[2]
Definition: TkConvValidator.h:301
TkConvValidator::h_convVtxYvsX_zoom_
MonitorElement * h_convVtxYvsX_zoom_[2]
Definition: TkConvValidator.h:264
reco::Conversion::highPurity
Definition: Conversion.h:33
TkConvValidator::maxPhoRForPurity
double maxPhoRForPurity
Definition: TkConvValidator.h:175
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
TrackTransientTrack.h
photonValidator_cfi.dCotTracksMin
dCotTracksMin
Definition: photonValidator_cfi.py:99
edm::Service
Definition: Service.h:30
TkConvValidator::h_trailNHitsBeforeVtx_
MonitorElement * h_trailNHitsBeforeVtx_[3][3]
Definition: TkConvValidator.h:309
TkConvValidator::p_DPhiTracksAtVtxVsR_
MonitorElement * p_DPhiTracksAtVtxVsR_
Definition: TkConvValidator.h:243
photonAnalyzer_cfi.rBin
rBin
Definition: photonAnalyzer_cfi.py:89
muonRecoAnalyzer_cfi.chi2Max
chi2Max
Definition: muonRecoAnalyzer_cfi.py:35
reco::Conversion::distOfMinimumApproach
double distOfMinimumApproach() const
Definition: Conversion.h:116
TkConvValidator::h_convVtxRvsZ_zoom_
MonitorElement * h_convVtxRvsZ_zoom_[2]
Definition: TkConvValidator.h:263
edm::EventSetup::getHandle
ESHandle< T > getHandle(const ESGetToken< T, R > &iToken) const
Definition: EventSetup.h:155
TkConvValidator::maxPhoZForEffic
double maxPhoZForEffic
Definition: TkConvValidator.h:170
TkConvValidator::h_convVtxdEta_
MonitorElement * h_convVtxdEta_
Definition: TkConvValidator.h:270
photonValidator_cfi.resBin
resBin
Definition: photonValidator_cfi.py:90
p1
double p1[4]
Definition: TauolaWrapper.h:89
EgammaValidation_cff.pdgId
pdgId
Definition: EgammaValidation_cff.py:117
TkConvValidator::h_SimConvTwoMTracks_
MonitorElement * h_SimConvTwoMTracks_[5]
Definition: TkConvValidator.h:203
MagneticField.h
edm::EventSetup
Definition: EventSetup.h:58
TkConvValidator::p_convVtxdRVsEta_
MonitorElement * p_convVtxdRVsEta_
Definition: TkConvValidator.h:287
TrackAssociatorRecord.h
TkConvValidator::mcConvR_
double mcConvR_
Definition: TkConvValidator.h:156
photonValidator_cfi.zBin2ForXray
zBin2ForXray
Definition: photonValidator_cfi.py:121
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
TkConvValidator::h_DCotTracks_
MonitorElement * h_DCotTracks_[3][3]
Definition: TkConvValidator.h:245
TkConvValidator::h_dlClosestHitToVtx_
MonitorElement * h_dlClosestHitToVtx_[3]
Definition: TkConvValidator.h:343
edm::RefVector::push_back
void push_back(value_type const &ref)
Add a Ref<C, T> to the RefVector.
Definition: RefVector.h:67
edm::RefToBaseVector< reco::Track >
TrackCollections2monitor_cff.normalizedChi2
normalizedChi2
Definition: TrackCollections2monitor_cff.py:247
TkConvValidator::h_dzPVFromTracks_
MonitorElement * h_dzPVFromTracks_[2]
Definition: TkConvValidator.h:302
TkConvValidator::p_convVtxdYVsY_
MonitorElement * p_convVtxdYVsY_
Definition: TkConvValidator.h:290
nanoDQM_cff.Photon
Photon
Definition: nanoDQM_cff.py:96
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
TkConvValidator::h_match_
MonitorElement * h_match_
Definition: TkConvValidator.h:338
TkConvValidator::h_vtxChi2Prob_
MonitorElement * h_vtxChi2Prob_[3][3]
Definition: TkConvValidator.h:299
reco::Vertex::chi2
double chi2() const
chi-squares
Definition: Vertex.h:116
TkConvValidator::h_convVtxdY_
MonitorElement * h_convVtxdY_
Definition: TkConvValidator.h:267
TkConvValidator::dbe_
DQMStore * dbe_
Definition: TkConvValidator.h:75
TkConvValidator::mcConvY_
double mcConvY_
Definition: TkConvValidator.h:158
TkConvValidator::nRecConv_
int nRecConv_
Definition: TkConvValidator.h:83
TkConvValidator::theConvTP_
edm::RefVector< TrackingParticleCollection > theConvTP_
Definition: TkConvValidator.h:165
alignCSCRings.r
r
Definition: alignCSCRings.py:93
CaloTopology.h
TkConvValidator::ecalalgotracks_
bool ecalalgotracks_
Definition: TkConvValidator.h:146
reco::TrackBase::algo
TrackAlgorithm algo() const
Definition: TrackBase.h:547
TkConvValidator::h_AllSimConv_
MonitorElement * h_AllSimConv_[5]
Denominator for efficiencies.
Definition: TkConvValidator.h:196
TkConvValidator::h_convVtxdR_
MonitorElement * h_convVtxdR_
Definition: TkConvValidator.h:269
DDAxes::phi
TkConvValidator::h2_TkPtPull_
MonitorElement * h2_TkPtPull_[3]
Definition: TkConvValidator.h:333
TkConvValidator::h_maxNHitsBeforeVtx_
MonitorElement * h_maxNHitsBeforeVtx_[3][3]
Definition: TkConvValidator.h:307
reco::Photon
Definition: Photon.h:22
TkConvValidator::p_DCotTracksVsR_
MonitorElement * p_DCotTracksVsR_
Definition: TkConvValidator.h:249
cosmicPhotonAnalyzer_cfi.etMax
etMax
Definition: cosmicPhotonAnalyzer_cfi.py:11
TkConvValidator::h_convZplot_
MonitorElement * h_convZplot_
Definition: TkConvValidator.h:233
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:504
reco::BeamSpot::x0
double x0() const
x coordinate
Definition: BeamSpot.h:61
edm::AssociationMap::empty
bool empty() const
return true if empty
Definition: AssociationMap.h:164
reco::Conversion::nSharedHits
uint8_t nSharedHits() const
number of shared hits btw the two track
Definition: Conversion.h:158
TkConvValidator::p2_convVtxdRVsRZ_
MonitorElement * p2_convVtxdRVsRZ_
Definition: TkConvValidator.h:294
TrackingParticle.h
CaloTopologyRecord.h
TrajectoryStateOnSurface::globalMomentum
GlobalVector globalMomentum() const
Definition: TrajectoryStateOnSurface.h:66
TkConvValidator::p_nHitsVsEta_
MonitorElement * p_nHitsVsEta_[3]
Definition: TkConvValidator.h:319
GeomDet.h
TkConvValidator::h_convVtxdY_barrel_
MonitorElement * h_convVtxdY_barrel_
Definition: TkConvValidator.h:274
TkConvValidator::photonCollectionPr_Token_
edm::EDGetTokenT< reco::PhotonCollection > photonCollectionPr_Token_
Definition: TkConvValidator.h:101
Disk
Definition: BoundDisk.h:19
std
Definition: JetResolutionObject.h:76
writedatasetfile.run
run
Definition: writedatasetfile.py:27
reco::Vertex::y
double y() const
y coordinate
Definition: Vertex.h:131
photonValidator_cfi.dCotTracksBin
dCotTracksBin
Definition: photonValidator_cfi.py:98
TkConvValidator::minPhoPtForEffic
double minPhoPtForEffic
Definition: TkConvValidator.h:168
extraflags_cff.vtx
vtx
Definition: extraflags_cff.py:19
TkConvValidator::h_convVtxdX_endcap_
MonitorElement * h_convVtxdX_endcap_
Definition: TkConvValidator.h:278
TkConvValidator::h_convVtxdZ_
MonitorElement * h_convVtxdZ_
Definition: TkConvValidator.h:268
DetId.h
TrackingParticleFwd.h
spclusmultinvestigator_cfi.vertexCollection
vertexCollection
Definition: spclusmultinvestigator_cfi.py:4
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
TrackingComponentsRecord.h
TkConvValidator::mcEta_
double mcEta_
Definition: TkConvValidator.h:154
SuperCluster.h
edm::RefVectorIterator
Definition: EDProductfwd.h:33
ETA
#define ETA
Definition: GenericBenchmark.cc:28
reco::HitPattern::MISSING_INNER_HITS
Definition: HitPattern.h:155
TkConvValidator::g4_simVtx_Token_
edm::EDGetTokenT< edm::SimVertexContainer > g4_simVtx_Token_
Definition: TkConvValidator.h:106
TkConvValidator::maxPhoEtaForEffic
double maxPhoEtaForEffic
Definition: TkConvValidator.h:169
makeMuonMisalignmentScenario.rot
rot
Definition: makeMuonMisalignmentScenario.py:322
math::XYZVectorF
ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< float > > XYZVectorF
spatial vector with cartesian internal representation
Definition: Vector3D.h:16
TkConvValidator::h2_convVtxdRVsR_
MonitorElement * h2_convVtxdRVsR_
Definition: TkConvValidator.h:283
ALCARECOTkAlBeamHalo_cff.etaMax
etaMax
Definition: ALCARECOTkAlBeamHalo_cff.py:33
TkConvValidator::thePhotonMCTruthFinder_
PhotonMCTruthFinder * thePhotonMCTruthFinder_
Definition: TkConvValidator.h:122
TkConvValidator::h_convVtxdZ_barrel_
MonitorElement * h_convVtxdZ_barrel_
Definition: TkConvValidator.h:275
HiEvtPlane_cfi.pterror
pterror
Definition: HiEvtPlane_cfi.py:24
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
edm::RefToBase< reco::Track >
photonValidator_cfi.resMax
resMax
Definition: photonValidator_cfi.py:92
TrajectoryStateTransform.h
Exception.h
TkConvValidator::highPurity_
bool highPurity_
Definition: TkConvValidator.h:147
TkConvValidator::h_SimConvEtaPix_
MonitorElement * h_SimConvEtaPix_[2]
Definition: TkConvValidator.h:187
reco::TrackToTrackingParticleAssociator::associateSimToReco
reco::SimToRecoCollection associateSimToReco(const edm::Handle< edm::View< reco::Track >> &tCH, const edm::Handle< TrackingParticleCollection > &tPCH) const
Definition: TrackToTrackingParticleAssociator.h:71
TkConvValidator::maxHitsBeforeVtx_
uint maxHitsBeforeVtx_
Definition: TkConvValidator.h:149
TkConvValidator::p_Chi2VsR_
MonitorElement * p_Chi2VsR_[3]
Definition: TkConvValidator.h:328
dqm-mbProfile.log
log
Definition: dqm-mbProfile.py:17
photonValidator_cfi.rBinForXray
rBinForXray
Definition: photonValidator_cfi.py:117
dqm::implementation::IBooker
Definition: DQMStore.h:43
TkConvValidator::h_nSharedHits_
MonitorElement * h_nSharedHits_[3][3]
Definition: TkConvValidator.h:315
Cylinder::computeRadius
static float computeRadius(Bounds const &bounds)
Definition: Cylinder.h:28
TkConvValidator::nInvalidPCA_
int nInvalidPCA_
Definition: TkConvValidator.h:87
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:250
reco::PhotonCollection
std::vector< Photon > PhotonCollection
collectin of Photon objects
Definition: PhotonFwd.h:9
photonAnalyzer_cfi.rMin
rMin
Definition: photonAnalyzer_cfi.py:90
TkConvValidator::dqmEndRun
void dqmEndRun(edm::Run const &r, edm::EventSetup const &es) override
Definition: TkConvValidator.cc:1236
Cylinder
Definition: Cylinder.h:19
TkConvValidator::minLxy_
double minLxy_
Definition: TkConvValidator.h:150
mps_fire.result
result
Definition: mps_fire.py:311
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
TkConvValidator::h_SimConvTwoMTracksAndVtxPGT0005_
MonitorElement * h_SimConvTwoMTracksAndVtxPGT0005_[5]
Definition: TkConvValidator.h:205
TkConvValidator::h_nConv_
MonitorElement * h_nConv_[3][3]
info per conversion
Definition: TkConvValidator.h:219
SimpleDiskBounds.h
SimTrack.h
HGC3DClusterGenMatchSelector_cfi.dR
dR
Definition: HGC3DClusterGenMatchSelector_cfi.py:7
TkConvValidator::theCaloGeom_
edm::ESHandle< CaloGeometry > theCaloGeom_
Definition: TkConvValidator.h:90
ExoticaDQM_cfi.photonCollection
photonCollection
Definition: ExoticaDQM_cfi.py:17
dummy
Definition: DummySelector.h:38
TkConvValidator::p_convVtxdXVsX_
MonitorElement * p_convVtxdXVsX_
Definition: TkConvValidator.h:289
TkConvValidator::p_convVtxdZVsR_
MonitorElement * p_convVtxdZVsR_
Definition: TkConvValidator.h:292
TkConvValidator::h_leadNHitsBeforeVtx_
MonitorElement * h_leadNHitsBeforeVtx_[3][3]
Definition: TkConvValidator.h:308
HepMCProduct.h
TkConvValidator::h2_PtRecVsPtSim_
MonitorElement * h2_PtRecVsPtSim_[3]
Definition: TkConvValidator.h:335
TkConvValidator::endJob
void endJob() override
Definition: TkConvValidator.cc:2230
trajectoryStateTransform::innerStateOnSurface
TrajectoryStateOnSurface innerStateOnSurface(const reco::Track &tk, const TrackingGeometry &geom, const MagneticField *field, bool withErr=true)
Definition: TrajectoryStateTransform.cc:110
TkConvValidator::trackAssociator_Token_
edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator > trackAssociator_Token_
Definition: TkConvValidator.h:111
TkConvValidator::trackerGeometryToken_
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > trackerGeometryToken_
Definition: TkConvValidator.h:116
ZEcal
static constexpr float ZEcal
Definition: L1TkEmParticleProducer.cc:37
TkConvValidator::nHitsVsEta_
MonitorElement * nHitsVsEta_[3]
Definition: TkConvValidator.h:320
photonAnalyzer_cfi.etBin
etBin
Definition: photonAnalyzer_cfi.py:53
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
event
Definition: event.py:1
DeDxTools::esConsumes
ESGetTokenH3DDVariant esConsumes(std::string const &Reccord, edm::ConsumesCollector &)
Definition: DeDxTools.cc:283
reco::BeamSpot::y0
double y0() const
y coordinate
Definition: BeamSpot.h:63
edm::Event
Definition: Event.h:73
TkConvValidator::phiNormalization
float phiNormalization(float &a)
Definition: TkConvValidator.cc:2277
edm::RefVector::size
size_type size() const
Size of the RefVector.
Definition: RefVector.h:102
MagneticField
Definition: MagneticField.h:19
d0
static constexpr float d0
Definition: L1EGammaCrystalsEmulatorProducer.cc:85
TkConvValidator::mcPhi_
double mcPhi_
global variable for the MC photon
Definition: TkConvValidator.h:153
TkConvValidator::minProb_
double minProb_
Definition: TkConvValidator.h:148
reco::Vertex::ndof
double ndof() const
Definition: Vertex.h:123
TkConvValidator::h_maxDlClosestHitToVtxSig_
MonitorElement * h_maxDlClosestHitToVtxSig_[3][3]
Definition: TkConvValidator.h:314
SimTrackContainer.h
edm::InputTag
Definition: InputTag.h:15
TkConvValidator::maxPhoRForEffic
double maxPhoRForEffic
Definition: TkConvValidator.h:171
Z_Endcap
static constexpr float Z_Endcap
Definition: ECALPositionCalculator.cc:11
TkConvValidator::nSimConv_
int nSimConv_[2]
Definition: TkConvValidator.h:81
SimVertexContainer.h
TkConvValidator::h_tkChi2Large_
MonitorElement * h_tkChi2Large_[3]
Definition: TkConvValidator.h:324
reco::Vertex
Definition: Vertex.h:35
R_ECAL
static constexpr float R_ECAL
Definition: ECALPositionCalculator.cc:10
TrajectoryStateOnSurface::isValid
bool isValid() const
Definition: TrajectoryStateOnSurface.h:54
TkConvValidator::transientTrackBuilderToken_
const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord > transientTrackBuilderToken_
Definition: TkConvValidator.h:115
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
CaloCluster.h
TkConvValidator::h_invMass_
MonitorElement * h_invMass_[3][3]
Definition: TkConvValidator.h:237
TkConvValidator::h_tkChi2_
MonitorElement * h_tkChi2_[3]
Definition: TkConvValidator.h:323
TkConvValidator::h_convZ_
MonitorElement * h_convZ_[3][3]
Definition: TkConvValidator.h:225
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
TkConvValidator::mcConvPhi_
double mcConvPhi_
Definition: TkConvValidator.h:160
TkConvValidator::dqmBeginRun
void dqmBeginRun(edm::Run const &r, edm::EventSetup const &theEventSetup) override
Definition: TkConvValidator.cc:1227
TkConvValidator::h_convVtxRvsZ_
MonitorElement * h_convVtxRvsZ_[3]
Definition: TkConvValidator.h:261
TkConvValidator::h_convPtRes_
MonitorElement * h_convPtRes_[3]
Definition: TkConvValidator.h:235
TrackerGeometry
Definition: TrackerGeometry.h:14
etaBarrelEndcap
static constexpr float etaBarrelEndcap
Definition: ECALPositionCalculator.cc:12
conv
EPOS::IO_EPOS conv
Definition: ReggeGribovPartonMCHadronizer.cc:42
TkConvValidator::h2_DPhiTracksAtVtxVsEta_
MonitorElement * h2_DPhiTracksAtVtxVsEta_
Definition: TkConvValidator.h:240
photonValidator_cfi.zBinForXray
zBinForXray
Definition: photonValidator_cfi.py:120
TkConvValidator::h2_DCotTracksVsR_
MonitorElement * h2_DCotTracksVsR_
Definition: TkConvValidator.h:248
Conversion.h
Generated for CMSSW Reference Manual by doxygen 1.8.16