Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
STrackCutStudy.plot.h
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file STrackCutStudy.plot.h
1 // ----------------------------------------------------------------------------
2 // 'STrackCutStudy.plot.h'
3 // Derek Anderson
4 // 03.14.2022
5 //
6 // Reads in the 'ntp_track' Ntuple
7 // generated by the SVtxEvaluator
8 // class and studies the impact
9 // of cutting on various quantities.
10 // ----------------------------------------------------------------------------
11 
12 #pragma once
13 
14 using namespace std;
15 
16 
17 
18 // plot methods ---------------------------------------------------------------
19 
20 void STrackCutStudy::MakeCutText() {
21 
22  // cut labels
23  const TString sPrimary("Is primary");
24  const TString sMVtxCut("MVTX hits = (");
25  const TString sNTpcCut("TPC hits = (");
26  const TString sVzCut("z-vertex = (");
27  const TString sDcaXyCut("DCA (XY) = (");
28  const TString sDcaZCut("DCA (Z) = (");
29  const TString sQualityCut("Quality = (");
30  const TString sVzUnits("cm");
31  const TString sDcaUnits("#mum");
32 
33  // make text
34  TString sMVtxTxt = sMVtxCut;
35  TString sNTpcTxt = sNTpcCut;
36  TString sVzTxt = sVzCut;
37  TString sDcaXyTxt = sDcaXyCut;
38  TString sDcaZTxt = sDcaZCut;
39  TString sQualityTxt = sQualityCut;
40  sMVtxTxt += nMVtxCut.first;
41  sNTpcTxt += nTpcCut.first;
42  sVzTxt += vzCut.first;
43  sDcaXyTxt += dcaXyCut.first;
44  sDcaZTxt += dcaZCut.first;
45  sQualityTxt += qualityCut.first;
46  sMVtxTxt += ", ";
47  sNTpcTxt += ", ";
48  sVzTxt += ", ";
49  sDcaXyTxt += ", ";
50  sDcaZTxt += ", ";
51  sQualityTxt += ", ";
52  sMVtxTxt += nMVtxCut.second;
53  sNTpcTxt += nTpcCut.second;
54  sVzTxt += vzCut.second;
55  sDcaXyTxt += dcaXyCut.second;
56  sDcaZTxt += dcaZCut.second;
57  sQualityTxt += qualityCut.second;
58  sMVtxTxt += ")";
59  sNTpcTxt += ")";
60  sVzTxt += ") ";
61  sDcaXyTxt += ") ";
62  sDcaZTxt += ") ";
63  sQualityTxt += ")";
64  sVzTxt += sVzUnits.Data();
65  sDcaXyTxt += sDcaUnits.Data();
66  sDcaZTxt += sDcaUnits.Data();
67 
68  // determine how many lines to add
69  UInt_t nCut(0);
70  if (doPrimaryCut) nCut++;
71  if (doMVtxCut) nCut++;
72  if (doTpcCut) nCut++;
73  if (doVzCut) nCut++;
74  if (doDcaXyCut) nCut++;
75  if (doDcaZCut) nCut++;
76  if (doQualityCut) nCut++;
77 
78  // make text box
79  const UInt_t fTxtC = 42;
80  const UInt_t fAlnC = 12;
81  const UInt_t fColC = 0;
82  const UInt_t fLinC = 1;
83  const UInt_t fFilC = 0;
84  const Float_t hCut = 0.05 * nCut;
85  const Float_t yCut = 0.1 + hCut;
86  const Float_t xyCut[NVtx] = {0.5, 0.1, 0.7, yCut};
87 
88  ptCut = new TPaveText(xyCut[0], xyCut[1], xyCut[2], xyCut[3], "NDC NB");
89  ptCut -> SetFillColor(fColC);
90  ptCut -> SetFillStyle(fFilC);
91  ptCut -> SetLineColor(fColC);
92  ptCut -> SetLineStyle(fLinC);
93  ptCut -> SetTextFont(fTxtC);
94  ptCut -> SetTextAlign(fAlnC);
95  if (doPrimaryCut) ptCut -> AddText(sPrimary.Data());
96  if (doMVtxCut) ptCut -> AddText(sMVtxTxt.Data());
97  if (doTpcCut) ptCut -> AddText(sNTpcTxt.Data());
98  if (doVzCut) ptCut -> AddText(sVzTxt.Data());
99  if (doDcaXyCut) ptCut -> AddText(sDcaXyTxt.Data());
100  if (doDcaZCut) ptCut -> AddText(sDcaZTxt.Data());
101  if (doQualityCut) ptCut -> AddText(sQualityTxt.Data());
102 
103  cout << " Made text box for cuts." << endl;
104  return;
105 
106 } // end 'MakeCutText()'
107 
108 
109 
110 void STrackCutStudy::ConstructPlots(const Ssiz_t nToDraw, const Int_t typesToDraw[], const TString sDirToSaveTo, const TString sPlotLabel) {
111 
112  // check if saving directory is made, if so, recurse into it
113  Bool_t dirIsThere = fOut -> cd(sDirToSaveTo.Data());
114  if (!dirIsThere) {
115  fOut -> mkdir(sDirToSaveTo.Data());
116  fOut -> cd(sDirToSaveTo.Data());
117  }
118 
119  // construct legend
120  const UInt_t fTxtL = 42;
121  const UInt_t fColL = 0;
122  const UInt_t fLinL = 1;
123  const UInt_t fFilL = 0;
124  const Float_t hLeg = 0.05 * nToDraw;
125  const Float_t yLeg = 0.1 + hLeg;
126  const Float_t xyLeg[NVtx] = {0.1, 0.1, 0.3, yLeg};
127 
128  TLegend *leg = new TLegend(xyLeg[0], xyLeg[1], xyLeg[2], xyLeg[3]);
129  leg -> SetFillColor(fColL);
130  leg -> SetFillStyle(fFilL);
131  leg -> SetLineColor(fColL);
132  leg -> SetLineStyle(fLinL);
133  leg -> SetTextFont(fTxtL);
134  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
135  leg -> AddEntry(hTrkVar[typesToDraw[iToDraw]][0], sTrkLabels[typesToDraw[iToDraw]].Data(), "pf");
136  }
137 
138  // determine what to text to add to box
139  Ssiz_t nTxt(0);
140  Bool_t hasPileup(false);
141  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
142  if (isPileup[typesToDraw[iToDraw]]) {
143  hasPileup = true;
144  break;
145  }
146  }
147 
148  if (hasPileup) {
149  nTxt = nTxtPU;
150  } else {
151  nTxt = nTxtEO;
152  }
153 
154  // construct text box
155  const UInt_t fTxtT = 42;
156  const UInt_t fAlnT = 12;
157  const UInt_t fColT = 0;
158  const UInt_t fLinT = 1;
159  const UInt_t fFilT = 0;
160  const Float_t hTxt = 0.05 * nTxt;
161  const Float_t yTxt = 0.1 + hTxt;
162  const Float_t xyTxt[NVtx] = {0.3, 0.1, 0.5, yTxt};
163 
164  TPaveText *ptTxt = new TPaveText(xyTxt[0], xyTxt[1], xyTxt[2], xyTxt[3], "NDC NB");
165  ptTxt -> SetFillColor(fColT);
166  ptTxt -> SetFillStyle(fFilT);
167  ptTxt -> SetLineColor(fColT);
168  ptTxt -> SetLineStyle(fLinT);
169  ptTxt -> SetTextFont(fTxtT);
170  ptTxt -> SetTextAlign(fAlnT);
171  for (Ssiz_t iTxt = 0; iTxt < nTxt; iTxt++) {
172  if (hasPileup) {
173  ptTxt -> AddText(sTxtPU[iTxt].Data());
174  } else {
175  ptTxt -> AddText(sTxtEO[iTxt].Data());
176  }
177  }
178 
179  // construct plots
180  const UInt_t fWidth1P(750);
181  const UInt_t fWidth2P(1500);
182  const UInt_t fHeight1P(750);
183  const UInt_t fHeight2P(750);
184  const UInt_t fMode(0);
185  const UInt_t fBord(2);
186  const UInt_t fGrid(0);
187  const UInt_t fTick(1);
188  const UInt_t fLogX(0);
189  const UInt_t fLogY(0);
190  const UInt_t fLogZ(1);
191  const UInt_t fFrame(0);
192  const Float_t fMarginL(0.12);
193  const Float_t fMarginR1(0.02);
194  const Float_t fMarginR2(0.12);
195  const Float_t fMarginT(0.02);
196  const Float_t fMarginB(0.12);
197  const Float_t padXY[NPanel][NVtx] = {{0., 0., 0.5, 1.}, {0.5, 0., 1., 1.}};
198  const TString sOneVsTwoDimPanels[NPanel] = {"pOneDim", "pTwoDim"};
199 
200  // form canvas names
201  const TString sDiffSuffix("Diff");
202  const TString sFracSuffix("Frac");
203  const TString sVsNTpcSuffix("VsNTpc");
204  const TString sVsDcaXySuffix("VsDcaXY");
205  const TString sVsDcaZSuffix("VsDcaZ");
206  const TString sVsPtRecoSuffix("VsPtReco");
207  const TString sVsPtTrueSuffix("VsPtTrue");
208  const TString sVsPtFracSuffix("VsPtFrac");
209 
210  // for track-variable canvas names
211  TString sTrkVar[NTrkVar];
212  TString sTrkVarDiff[NTrkVar];
213  TString sTrkVarFrac[NTrkVar];
214  TString sTrkVarVsNTpc[NTrkVar];
215  TString sTrkVarVsDcaXY[NTrkVar];
216  TString sTrkVarVsDcaZ[NTrkVar];
217  TString sTrkVarVsPtReco[NTrkVar];
218  TString sTrkVarVsPtTrue[NTrkVar];
219  TString sTrkVarVsPtFrac[NTrkVar];
220 
221  // for physics-variable canvas names
222  TString sPhysVar[NPhysVar];
223  TString sPhysVarDiff[NPhysVar];
224  TString sPhysVarFrac[NPhysVar];
225  TString sPhysVarVsNTpc[NPhysVar];
226  TString sPhysVarVsDcaXY[NPhysVar];
227  TString sPhysVarVsDcaZ[NPhysVar];
228  TString sPhysVarVsPtReco[NPhysVar];
229  TString sPhysVarVsPtTrue[NPhysVar];
230  TString sPhysVarVsPtFrac[NPhysVar];
231 
232  // construct variable prefixes
233  TString sTrkVarName[NTrkVar];
234  TString sPhysVarName[NPhysVar];
235  for (size_t iTrkVar = 0; iTrkVar < NTrkVar; iTrkVar++) {
236  sTrkVarName[iTrkVar] = "c";
237  sTrkVarName[iTrkVar].Append(sTrkVars[iTrkVar].Data());
238  }
239  for (size_t iPhysVar = 0; iPhysVar < NPhysVar; iPhysVar++) {
240  sPhysVarName[iPhysVar] = "c";
241  sPhysVarName[iPhysVar].Append(sPhysVars[iPhysVar].Data());
242  }
243 
244  for (size_t iTrkVar = 0; iTrkVar < NTrkVar; iTrkVar++) {
245  sTrkVar[iTrkVar] = sTrkVarName[iTrkVar].Data();
246  sTrkVarDiff[iTrkVar] = sTrkVarName[iTrkVar].Data();
247  sTrkVarFrac[iTrkVar] = sTrkVarName[iTrkVar].Data();
248  sTrkVarVsNTpc[iTrkVar] = sTrkVarName[iTrkVar].Data();
249  sTrkVarVsDcaXY[iTrkVar] = sTrkVarName[iTrkVar].Data();
250  sTrkVarVsDcaZ[iTrkVar] = sTrkVarName[iTrkVar].Data();
251  sTrkVarVsPtReco[iTrkVar] = sTrkVarName[iTrkVar].Data();
252  sTrkVarVsPtTrue[iTrkVar] = sTrkVarName[iTrkVar].Data();
253  sTrkVarVsPtFrac[iTrkVar] = sTrkVarName[iTrkVar].Data();
254  sTrkVarDiff[iTrkVar].Append(sDiffSuffix.Data());
255  sTrkVarFrac[iTrkVar].Append(sFracSuffix.Data());
256  sTrkVarVsNTpc[iTrkVar].Append(sVsNTpcSuffix.Data());
257  sTrkVarVsDcaXY[iTrkVar].Append(sVsDcaXySuffix.Data());
258  sTrkVarVsDcaZ[iTrkVar].Append(sVsDcaZSuffix.Data());
259  sTrkVarVsPtReco[iTrkVar].Append(sVsPtRecoSuffix.Data());
260  sTrkVarVsPtTrue[iTrkVar].Append(sVsPtTrueSuffix.Data());
261  sTrkVarVsPtFrac[iTrkVar].Append(sVsPtFracSuffix.Data());
262  sTrkVar[iTrkVar].Append("_");
263  sTrkVarDiff[iTrkVar].Append("_");
264  sTrkVarFrac[iTrkVar].Append("_");
265  sTrkVarVsNTpc[iTrkVar].Append("_");
266  sTrkVarVsDcaXY[iTrkVar].Append("_");
267  sTrkVarVsDcaZ[iTrkVar].Append("_");
268  sTrkVarVsPtReco[iTrkVar].Append("_");
269  sTrkVarVsPtTrue[iTrkVar].Append("_");
270  sTrkVarVsPtFrac[iTrkVar].Append("_");
271  sTrkVar[iTrkVar].Append(sPlotLabel.Data());
272  sTrkVarDiff[iTrkVar].Append(sPlotLabel.Data());
273  sTrkVarFrac[iTrkVar].Append(sPlotLabel.Data());
274  sTrkVarVsNTpc[iTrkVar].Append(sPlotLabel.Data());
275  sTrkVarVsDcaXY[iTrkVar].Append(sPlotLabel.Data());
276  sTrkVarVsDcaZ[iTrkVar].Append(sPlotLabel.Data());
277  sTrkVarVsPtReco[iTrkVar].Append(sPlotLabel.Data());
278  sTrkVarVsPtTrue[iTrkVar].Append(sPlotLabel.Data());
279  sTrkVarVsPtFrac[iTrkVar].Append(sPlotLabel.Data());
280  }
281  for (size_t iPhysVar = 0; iPhysVar < NPhysVar; iPhysVar++) {
282  sPhysVar[iPhysVar] = sPhysVarName[iPhysVar].Data();
283  sPhysVarDiff[iPhysVar] = sPhysVarName[iPhysVar].Data();
284  sPhysVarFrac[iPhysVar] = sPhysVarName[iPhysVar].Data();
285  sPhysVarVsNTpc[iPhysVar] = sPhysVarName[iPhysVar].Data();
286  sPhysVarVsDcaXY[iPhysVar] = sPhysVarName[iPhysVar].Data();
287  sPhysVarVsDcaZ[iPhysVar] = sPhysVarName[iPhysVar].Data();
288  sPhysVarVsPtReco[iPhysVar] = sPhysVarName[iPhysVar].Data();
289  sPhysVarVsPtTrue[iPhysVar] = sPhysVarName[iPhysVar].Data();
290  sPhysVarVsPtFrac[iPhysVar] = sPhysVarName[iPhysVar].Data();
291  sPhysVarDiff[iPhysVar].Append(sDiffSuffix.Data());
292  sPhysVarFrac[iPhysVar].Append(sFracSuffix.Data());
293  sPhysVarVsNTpc[iPhysVar].Append(sVsNTpcSuffix.Data());
294  sPhysVarVsDcaXY[iPhysVar].Append(sVsDcaXySuffix.Data());
295  sPhysVarVsDcaZ[iPhysVar].Append(sVsDcaZSuffix.Data());
296  sPhysVarVsPtReco[iPhysVar].Append(sVsPtRecoSuffix.Data());
297  sPhysVarVsPtTrue[iPhysVar].Append(sVsPtTrueSuffix.Data());
298  sPhysVarVsPtFrac[iPhysVar].Append(sVsPtFracSuffix.Data());
299  sPhysVar[iPhysVar].Append("_");
300  sPhysVarDiff[iPhysVar].Append("_");
301  sPhysVarFrac[iPhysVar].Append("_");
302  sPhysVarVsNTpc[iPhysVar].Append("_");
303  sPhysVarVsDcaXY[iPhysVar].Append("_");
304  sPhysVarVsDcaZ[iPhysVar].Append("_");
305  sPhysVarVsPtReco[iPhysVar].Append("_");
306  sPhysVarVsPtTrue[iPhysVar].Append("_");
307  sPhysVarVsPtFrac[iPhysVar].Append("_");
308  sPhysVar[iPhysVar].Append(sPlotLabel.Data());
309  sPhysVarDiff[iPhysVar].Append(sPlotLabel.Data());
310  sPhysVarFrac[iPhysVar].Append(sPlotLabel.Data());
311  sPhysVarVsNTpc[iPhysVar].Append(sPlotLabel.Data());
312  sPhysVarVsDcaXY[iPhysVar].Append(sPlotLabel.Data());
313  sPhysVarVsDcaZ[iPhysVar].Append(sPlotLabel.Data());
314  sPhysVarVsPtReco[iPhysVar].Append(sPlotLabel.Data());
315  sPhysVarVsPtTrue[iPhysVar].Append(sPlotLabel.Data());
316  sPhysVarVsPtFrac[iPhysVar].Append(sPlotLabel.Data());
317  }
318 
319  // for track-variable plots
320  TCanvas *cTrkVar[NTrkVar];
321  TCanvas *cTrkVarDiff[NTrkVar];
322  TCanvas *cTrkVarFrac[NTrkVar];
323  TCanvas *cTrkVarVsNTpc[NTrkVar];
324  TCanvas *cTrkVarVsDcaXY[NTrkVar];
325  TCanvas *cTrkVarVsDcaZ[NTrkVar];
326  TCanvas *cTrkVarVsPtReco[NTrkVar];
327  TCanvas *cTrkVarVsPtTrue[NTrkVar];
328  TCanvas *cTrkVarVsPtFrac[NTrkVar];
329  TPad *pTrkVarVsNTpc[NTrkVar][NPanel];
330  TPad *pTrkVarVsDcaXY[NTrkVar][NPanel];
331  TPad *pTrkVarVsDcaZ[NTrkVar][NPanel];
332  TPad *pTrkVarVsPtReco[NTrkVar][NPanel];
333  TPad *pTrkVarVsPtTrue[NTrkVar][NPanel];
334  TPad *pTrkVarVsPtFrac[NTrkVar][NPanel];
335  for (size_t iTrkVar = 0; iTrkVar < NTrkVar; iTrkVar++) {
336 
337  // 1d track variable
338  cTrkVar[iTrkVar] = new TCanvas(sTrkVar[iTrkVar].Data(), "", fWidth1P, fHeight1P);
339  cTrkVar[iTrkVar] -> SetGrid(fGrid, fGrid);
340  cTrkVar[iTrkVar] -> SetTicks(fTick, fTick);
341  cTrkVar[iTrkVar] -> SetLogx(fLogX);
342  cTrkVar[iTrkVar] -> SetLogy(fLogY);
343  cTrkVar[iTrkVar] -> SetLogz(fLogZ);
344  cTrkVar[iTrkVar] -> SetBorderMode(fMode);
345  cTrkVar[iTrkVar] -> SetBorderSize(fBord);
346  cTrkVar[iTrkVar] -> SetFrameBorderMode(fFrame);
347  cTrkVar[iTrkVar] -> SetLeftMargin(fMarginL);
348  cTrkVar[iTrkVar] -> SetRightMargin(fMarginR1);
349  cTrkVar[iTrkVar] -> SetTopMargin(fMarginT);
350  cTrkVar[iTrkVar] -> SetBottomMargin(fMarginB);
351  cTrkVar[iTrkVar] -> cd();
352  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
353  if (iToDraw == 0) {
354  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
355  } else {
356  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
357  }
358  } // end to-draw loop
359  leg -> Draw();
360  ptTxt -> Draw();
361  ptCut -> Draw();
362  cTrkVar[iTrkVar] -> Write();
363  cTrkVar[iTrkVar] -> Close();
364 
365  // 1d track difference
366  cTrkVarDiff[iTrkVar] = new TCanvas(sTrkVarDiff[iTrkVar].Data(), "", fWidth1P, fHeight1P);
367  cTrkVarDiff[iTrkVar] -> SetGrid(fGrid, fGrid);
368  cTrkVarDiff[iTrkVar] -> SetTicks(fTick, fTick);
369  cTrkVarDiff[iTrkVar] -> SetLogx(fLogX);
370  cTrkVarDiff[iTrkVar] -> SetLogy(fLogY);
371  cTrkVarDiff[iTrkVar] -> SetLogz(fLogZ);
372  cTrkVarDiff[iTrkVar] -> SetBorderMode(fMode);
373  cTrkVarDiff[iTrkVar] -> SetBorderSize(fBord);
374  cTrkVarDiff[iTrkVar] -> SetFrameBorderMode(fFrame);
375  cTrkVarDiff[iTrkVar] -> SetLeftMargin(fMarginL);
376  cTrkVarDiff[iTrkVar] -> SetRightMargin(fMarginR1);
377  cTrkVarDiff[iTrkVar] -> SetTopMargin(fMarginT);
378  cTrkVarDiff[iTrkVar] -> SetBottomMargin(fMarginB);
379  cTrkVarDiff[iTrkVar] -> cd();
380  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
381  if (iToDraw == 0) {
382  hTrkVarDiff[typesToDraw[iToDraw]][iTrkVar] -> Draw();
383  } else {
384  hTrkVarDiff[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
385  }
386  } // end to-draw loop
387  leg -> Draw();
388  ptTxt -> Draw();
389  ptCut -> Draw();
390  cTrkVarDiff[iTrkVar] -> Write();
391  cTrkVarDiff[iTrkVar] -> Close();
392 
393  // 1d track fraction
394  cTrkVarFrac[iTrkVar] = new TCanvas(sTrkVarFrac[iTrkVar].Data(), "", fWidth1P, fHeight1P);
395  cTrkVarFrac[iTrkVar] -> SetGrid(fGrid, fGrid);
396  cTrkVarFrac[iTrkVar] -> SetTicks(fTick, fTick);
397  cTrkVarFrac[iTrkVar] -> SetLogx(fLogX);
398  cTrkVarFrac[iTrkVar] -> SetLogy(fLogY);
399  cTrkVarFrac[iTrkVar] -> SetLogz(fLogZ);
400  cTrkVarFrac[iTrkVar] -> SetBorderMode(fMode);
401  cTrkVarFrac[iTrkVar] -> SetBorderSize(fBord);
402  cTrkVarFrac[iTrkVar] -> SetFrameBorderMode(fFrame);
403  cTrkVarFrac[iTrkVar] -> SetLeftMargin(fMarginL);
404  cTrkVarFrac[iTrkVar] -> SetRightMargin(fMarginR1);
405  cTrkVarFrac[iTrkVar] -> SetTopMargin(fMarginT);
406  cTrkVarFrac[iTrkVar] -> SetBottomMargin(fMarginB);
407  cTrkVarFrac[iTrkVar] -> cd();
408  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
409  if (iToDraw == 0) {
410  hTrkVarFrac[typesToDraw[iToDraw]][iTrkVar] -> Draw();
411  } else {
412  hTrkVarFrac[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
413  }
414  } // end to-draw loop
415  leg -> Draw();
416  ptTxt -> Draw();
417  ptCut -> Draw();
418  cTrkVarFrac[iTrkVar] -> Write();
419  cTrkVarFrac[iTrkVar] -> Close();
420 
421  // 2d track variables vs. ntpc
422  cTrkVarVsNTpc[iTrkVar] = new TCanvas(sTrkVarVsNTpc[iTrkVar].Data(), "", fWidth2P, fHeight2P);
423  pTrkVarVsNTpc[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
424  pTrkVarVsNTpc[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
425  cTrkVarVsNTpc[iTrkVar] -> SetGrid(fGrid, fGrid);
426  cTrkVarVsNTpc[iTrkVar] -> SetTicks(fTick, fTick);
427  cTrkVarVsNTpc[iTrkVar] -> SetBorderMode(fMode);
428  cTrkVarVsNTpc[iTrkVar] -> SetBorderSize(fBord);
429  pTrkVarVsNTpc[iTrkVar][0] -> SetGrid(fGrid, fGrid);
430  pTrkVarVsNTpc[iTrkVar][0] -> SetTicks(fTick, fTick);
431  pTrkVarVsNTpc[iTrkVar][0] -> SetLogx(fLogX);
432  pTrkVarVsNTpc[iTrkVar][0] -> SetLogy(fLogY);
433  pTrkVarVsNTpc[iTrkVar][0] -> SetLogz(fLogZ);
434  pTrkVarVsNTpc[iTrkVar][0] -> SetBorderMode(fMode);
435  pTrkVarVsNTpc[iTrkVar][0] -> SetBorderSize(fBord);
436  pTrkVarVsNTpc[iTrkVar][0] -> SetFrameBorderMode(fFrame);
437  pTrkVarVsNTpc[iTrkVar][0] -> SetLeftMargin(fMarginL);
438  pTrkVarVsNTpc[iTrkVar][0] -> SetRightMargin(fMarginR1);
439  pTrkVarVsNTpc[iTrkVar][0] -> SetTopMargin(fMarginT);
440  pTrkVarVsNTpc[iTrkVar][0] -> SetBottomMargin(fMarginB);
441  pTrkVarVsNTpc[iTrkVar][1] -> SetGrid(fGrid, fGrid);
442  pTrkVarVsNTpc[iTrkVar][1] -> SetTicks(fTick, fTick);
443  pTrkVarVsNTpc[iTrkVar][1] -> SetLogx(fLogX);
444  pTrkVarVsNTpc[iTrkVar][1] -> SetLogy(fLogY);
445  pTrkVarVsNTpc[iTrkVar][1] -> SetLogz(fLogZ);
446  pTrkVarVsNTpc[iTrkVar][1] -> SetBorderMode(fMode);
447  pTrkVarVsNTpc[iTrkVar][1] -> SetBorderSize(fBord);
448  pTrkVarVsNTpc[iTrkVar][1] -> SetFrameBorderMode(fFrame);
449  pTrkVarVsNTpc[iTrkVar][1] -> SetLeftMargin(fMarginL);
450  pTrkVarVsNTpc[iTrkVar][1] -> SetRightMargin(fMarginR2);
451  pTrkVarVsNTpc[iTrkVar][1] -> SetTopMargin(fMarginT);
452  pTrkVarVsNTpc[iTrkVar][1] -> SetBottomMargin(fMarginB);
453  cTrkVarVsNTpc[iTrkVar] -> cd();
454  pTrkVarVsNTpc[iTrkVar][0] -> Draw();
455  pTrkVarVsNTpc[iTrkVar][1] -> Draw();
456  pTrkVarVsNTpc[iTrkVar][0] -> cd();
457  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
458  if (iToDraw == 0) {
459  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
460  } else {
461  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
462  }
463  } // end to-draw loop
464  leg -> Draw();
465  ptTxt -> Draw();
466  ptCut -> Draw();
467  pTrkVarVsNTpc[iTrkVar][1] -> cd();
468  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
469  if (iToDraw == 0) {
470  hTrkVarVsNTpc[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
471  } else {
472  hTrkVarVsNTpc[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
473  }
474  } // end to-draw loop
475  cTrkVarVsNTpc[iTrkVar] -> Write();
476  cTrkVarVsNTpc[iTrkVar] -> Close();
477 
478  // 2d track variables vs. dcaxy
479  cTrkVarVsDcaXY[iTrkVar] = new TCanvas(sTrkVarVsDcaXY[iTrkVar].Data(), "", fWidth2P, fHeight2P);
480  pTrkVarVsDcaXY[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
481  pTrkVarVsDcaXY[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
482  cTrkVarVsDcaXY[iTrkVar] -> SetGrid(fGrid, fGrid);
483  cTrkVarVsDcaXY[iTrkVar] -> SetTicks(fTick, fTick);
484  cTrkVarVsDcaXY[iTrkVar] -> SetBorderMode(fMode);
485  cTrkVarVsDcaXY[iTrkVar] -> SetBorderSize(fBord);
486  pTrkVarVsDcaXY[iTrkVar][0] -> SetGrid(fGrid, fGrid);
487  pTrkVarVsDcaXY[iTrkVar][0] -> SetTicks(fTick, fTick);
488  pTrkVarVsDcaXY[iTrkVar][0] -> SetLogx(fLogX);
489  pTrkVarVsDcaXY[iTrkVar][0] -> SetLogy(fLogY);
490  pTrkVarVsDcaXY[iTrkVar][0] -> SetLogz(fLogZ);
491  pTrkVarVsDcaXY[iTrkVar][0] -> SetBorderMode(fMode);
492  pTrkVarVsDcaXY[iTrkVar][0] -> SetBorderSize(fBord);
493  pTrkVarVsDcaXY[iTrkVar][0] -> SetFrameBorderMode(fFrame);
494  pTrkVarVsDcaXY[iTrkVar][0] -> SetLeftMargin(fMarginL);
495  pTrkVarVsDcaXY[iTrkVar][0] -> SetRightMargin(fMarginR1);
496  pTrkVarVsDcaXY[iTrkVar][0] -> SetTopMargin(fMarginT);
497  pTrkVarVsDcaXY[iTrkVar][0] -> SetBottomMargin(fMarginB);
498  pTrkVarVsDcaXY[iTrkVar][1] -> SetGrid(fGrid, fGrid);
499  pTrkVarVsDcaXY[iTrkVar][1] -> SetTicks(fTick, fTick);
500  pTrkVarVsDcaXY[iTrkVar][1] -> SetLogx(fLogX);
501  pTrkVarVsDcaXY[iTrkVar][1] -> SetLogy(fLogY);
502  pTrkVarVsDcaXY[iTrkVar][1] -> SetLogz(fLogZ);
503  pTrkVarVsDcaXY[iTrkVar][1] -> SetBorderMode(fMode);
504  pTrkVarVsDcaXY[iTrkVar][1] -> SetBorderSize(fBord);
505  pTrkVarVsDcaXY[iTrkVar][1] -> SetFrameBorderMode(fFrame);
506  pTrkVarVsDcaXY[iTrkVar][1] -> SetLeftMargin(fMarginL);
507  pTrkVarVsDcaXY[iTrkVar][1] -> SetRightMargin(fMarginR2);
508  pTrkVarVsDcaXY[iTrkVar][1] -> SetTopMargin(fMarginT);
509  pTrkVarVsDcaXY[iTrkVar][1] -> SetBottomMargin(fMarginB);
510  cTrkVarVsDcaXY[iTrkVar] -> cd();
511  pTrkVarVsDcaXY[iTrkVar][0] -> Draw();
512  pTrkVarVsDcaXY[iTrkVar][1] -> Draw();
513  pTrkVarVsDcaXY[iTrkVar][0] -> cd();
514  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
515  if (iToDraw == 0) {
516  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
517  } else {
518  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
519  }
520  } // end to-draw loop
521  leg -> Draw();
522  ptTxt -> Draw();
523  ptCut -> Draw();
524  pTrkVarVsDcaXY[iTrkVar][1] -> cd();
525  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
526  if (iToDraw == 0) {
527  hTrkVarVsDcaXY[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
528  } else {
529  hTrkVarVsDcaXY[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
530  }
531  } // end to-draw loop
532  cTrkVarVsDcaXY[iTrkVar] -> Write();
533  cTrkVarVsDcaXY[iTrkVar] -> Close();
534 
535  // 2d track variables vs. dcaz
536  cTrkVarVsDcaZ[iTrkVar] = new TCanvas(sTrkVarVsDcaZ[iTrkVar].Data(), "", fWidth2P, fHeight2P);
537  pTrkVarVsDcaZ[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
538  pTrkVarVsDcaZ[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
539  cTrkVarVsDcaZ[iTrkVar] -> SetGrid(fGrid, fGrid);
540  cTrkVarVsDcaZ[iTrkVar] -> SetTicks(fTick, fTick);
541  cTrkVarVsDcaZ[iTrkVar] -> SetBorderMode(fMode);
542  cTrkVarVsDcaZ[iTrkVar] -> SetBorderSize(fBord);
543  pTrkVarVsDcaZ[iTrkVar][0] -> SetGrid(fGrid, fGrid);
544  pTrkVarVsDcaZ[iTrkVar][0] -> SetTicks(fTick, fTick);
545  pTrkVarVsDcaZ[iTrkVar][0] -> SetLogx(fLogX);
546  pTrkVarVsDcaZ[iTrkVar][0] -> SetLogy(fLogY);
547  pTrkVarVsDcaZ[iTrkVar][0] -> SetLogz(fLogZ);
548  pTrkVarVsDcaZ[iTrkVar][0] -> SetBorderMode(fMode);
549  pTrkVarVsDcaZ[iTrkVar][0] -> SetBorderSize(fBord);
550  pTrkVarVsDcaZ[iTrkVar][0] -> SetFrameBorderMode(fFrame);
551  pTrkVarVsDcaZ[iTrkVar][0] -> SetLeftMargin(fMarginL);
552  pTrkVarVsDcaZ[iTrkVar][0] -> SetRightMargin(fMarginR1);
553  pTrkVarVsDcaZ[iTrkVar][0] -> SetTopMargin(fMarginT);
554  pTrkVarVsDcaZ[iTrkVar][0] -> SetBottomMargin(fMarginB);
555  pTrkVarVsDcaZ[iTrkVar][1] -> SetGrid(fGrid, fGrid);
556  pTrkVarVsDcaZ[iTrkVar][1] -> SetTicks(fTick, fTick);
557  pTrkVarVsDcaZ[iTrkVar][1] -> SetLogx(fLogX);
558  pTrkVarVsDcaZ[iTrkVar][1] -> SetLogy(fLogY);
559  pTrkVarVsDcaZ[iTrkVar][1] -> SetLogz(fLogZ);
560  pTrkVarVsDcaZ[iTrkVar][1] -> SetBorderMode(fMode);
561  pTrkVarVsDcaZ[iTrkVar][1] -> SetBorderSize(fBord);
562  pTrkVarVsDcaZ[iTrkVar][1] -> SetFrameBorderMode(fFrame);
563  pTrkVarVsDcaZ[iTrkVar][1] -> SetLeftMargin(fMarginL);
564  pTrkVarVsDcaZ[iTrkVar][1] -> SetRightMargin(fMarginR2);
565  pTrkVarVsDcaZ[iTrkVar][1] -> SetTopMargin(fMarginT);
566  pTrkVarVsDcaZ[iTrkVar][1] -> SetBottomMargin(fMarginB);
567  cTrkVarVsDcaZ[iTrkVar] -> cd();
568  pTrkVarVsDcaZ[iTrkVar][0] -> Draw();
569  pTrkVarVsDcaZ[iTrkVar][1] -> Draw();
570  pTrkVarVsDcaZ[iTrkVar][0] -> cd();
571  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
572  if (iToDraw == 0) {
573  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
574  } else {
575  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
576  }
577  } // end to-draw loop
578  leg -> Draw();
579  ptTxt -> Draw();
580  ptCut -> Draw();
581  pTrkVarVsDcaZ[iTrkVar][1] -> cd();
582  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
583  if (iToDraw == 0) {
584  hTrkVarVsDcaZ[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
585  } else {
586  hTrkVarVsDcaZ[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
587  }
588  } // end to-draw loop
589  cTrkVarVsDcaZ[iTrkVar] -> Write();
590  cTrkVarVsDcaZ[iTrkVar] -> Close();
591 
592  // 2d track variables vs. ptreco
593  cTrkVarVsPtReco[iTrkVar] = new TCanvas(sTrkVarVsPtReco[iTrkVar].Data(), "", fWidth2P, fHeight2P);
594  pTrkVarVsPtReco[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
595  pTrkVarVsPtReco[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
596  cTrkVarVsPtReco[iTrkVar] -> SetGrid(fGrid, fGrid);
597  cTrkVarVsPtReco[iTrkVar] -> SetTicks(fTick, fTick);
598  cTrkVarVsPtReco[iTrkVar] -> SetBorderMode(fMode);
599  cTrkVarVsPtReco[iTrkVar] -> SetBorderSize(fBord);
600  pTrkVarVsPtReco[iTrkVar][0] -> SetGrid(fGrid, fGrid);
601  pTrkVarVsPtReco[iTrkVar][0] -> SetTicks(fTick, fTick);
602  pTrkVarVsPtReco[iTrkVar][0] -> SetLogx(fLogX);
603  pTrkVarVsPtReco[iTrkVar][0] -> SetLogy(fLogY);
604  pTrkVarVsPtReco[iTrkVar][0] -> SetLogz(fLogZ);
605  pTrkVarVsPtReco[iTrkVar][0] -> SetBorderMode(fMode);
606  pTrkVarVsPtReco[iTrkVar][0] -> SetBorderSize(fBord);
607  pTrkVarVsPtReco[iTrkVar][0] -> SetFrameBorderMode(fFrame);
608  pTrkVarVsPtReco[iTrkVar][0] -> SetLeftMargin(fMarginL);
609  pTrkVarVsPtReco[iTrkVar][0] -> SetRightMargin(fMarginR1);
610  pTrkVarVsPtReco[iTrkVar][0] -> SetTopMargin(fMarginT);
611  pTrkVarVsPtReco[iTrkVar][0] -> SetBottomMargin(fMarginB);
612  pTrkVarVsPtReco[iTrkVar][1] -> SetGrid(fGrid, fGrid);
613  pTrkVarVsPtReco[iTrkVar][1] -> SetTicks(fTick, fTick);
614  pTrkVarVsPtReco[iTrkVar][1] -> SetLogx(fLogX);
615  pTrkVarVsPtReco[iTrkVar][1] -> SetLogy(fLogY);
616  pTrkVarVsPtReco[iTrkVar][1] -> SetLogz(fLogZ);
617  pTrkVarVsPtReco[iTrkVar][1] -> SetBorderMode(fMode);
618  pTrkVarVsPtReco[iTrkVar][1] -> SetBorderSize(fBord);
619  pTrkVarVsPtReco[iTrkVar][1] -> SetFrameBorderMode(fFrame);
620  pTrkVarVsPtReco[iTrkVar][1] -> SetLeftMargin(fMarginL);
621  pTrkVarVsPtReco[iTrkVar][1] -> SetRightMargin(fMarginR2);
622  pTrkVarVsPtReco[iTrkVar][1] -> SetTopMargin(fMarginT);
623  pTrkVarVsPtReco[iTrkVar][1] -> SetBottomMargin(fMarginB);
624  cTrkVarVsPtReco[iTrkVar] -> cd();
625  pTrkVarVsPtReco[iTrkVar][0] -> Draw();
626  pTrkVarVsPtReco[iTrkVar][1] -> Draw();
627  pTrkVarVsPtReco[iTrkVar][0] -> cd();
628  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
629  if (iToDraw == 0) {
630  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
631  } else {
632  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
633  }
634  } // end to-draw loop
635  leg -> Draw();
636  ptTxt -> Draw();
637  ptCut -> Draw();
638  pTrkVarVsPtReco[iTrkVar][1] -> cd();
639  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
640  if (iToDraw == 0) {
641  hTrkVarVsPtReco[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
642  } else {
643  hTrkVarVsPtReco[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
644  }
645  } // end to-draw loop
646  cTrkVarVsPtReco[iTrkVar] -> Write();
647  cTrkVarVsPtReco[iTrkVar] -> Close();
648 
649  // 2d track variables vs. pttrue
650  cTrkVarVsPtTrue[iTrkVar] = new TCanvas(sTrkVarVsPtTrue[iTrkVar].Data(), "", fWidth2P, fHeight2P);
651  pTrkVarVsPtTrue[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
652  pTrkVarVsPtTrue[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
653  cTrkVarVsPtTrue[iTrkVar] -> SetGrid(fGrid, fGrid);
654  cTrkVarVsPtTrue[iTrkVar] -> SetTicks(fTick, fTick);
655  cTrkVarVsPtTrue[iTrkVar] -> SetBorderMode(fMode);
656  cTrkVarVsPtTrue[iTrkVar] -> SetBorderSize(fBord);
657  pTrkVarVsPtTrue[iTrkVar][0] -> SetGrid(fGrid, fGrid);
658  pTrkVarVsPtTrue[iTrkVar][0] -> SetTicks(fTick, fTick);
659  pTrkVarVsPtTrue[iTrkVar][0] -> SetLogx(fLogX);
660  pTrkVarVsPtTrue[iTrkVar][0] -> SetLogy(fLogY);
661  pTrkVarVsPtTrue[iTrkVar][0] -> SetLogz(fLogZ);
662  pTrkVarVsPtTrue[iTrkVar][0] -> SetBorderMode(fMode);
663  pTrkVarVsPtTrue[iTrkVar][0] -> SetBorderSize(fBord);
664  pTrkVarVsPtTrue[iTrkVar][0] -> SetFrameBorderMode(fFrame);
665  pTrkVarVsPtTrue[iTrkVar][0] -> SetLeftMargin(fMarginL);
666  pTrkVarVsPtTrue[iTrkVar][0] -> SetRightMargin(fMarginR1);
667  pTrkVarVsPtTrue[iTrkVar][0] -> SetTopMargin(fMarginT);
668  pTrkVarVsPtTrue[iTrkVar][0] -> SetBottomMargin(fMarginB);
669  pTrkVarVsPtTrue[iTrkVar][1] -> SetGrid(fGrid, fGrid);
670  pTrkVarVsPtTrue[iTrkVar][1] -> SetTicks(fTick, fTick);
671  pTrkVarVsPtTrue[iTrkVar][1] -> SetLogx(fLogX);
672  pTrkVarVsPtTrue[iTrkVar][1] -> SetLogy(fLogY);
673  pTrkVarVsPtTrue[iTrkVar][1] -> SetLogz(fLogZ);
674  pTrkVarVsPtTrue[iTrkVar][1] -> SetBorderMode(fMode);
675  pTrkVarVsPtTrue[iTrkVar][1] -> SetBorderSize(fBord);
676  pTrkVarVsPtTrue[iTrkVar][1] -> SetFrameBorderMode(fFrame);
677  pTrkVarVsPtTrue[iTrkVar][1] -> SetLeftMargin(fMarginL);
678  pTrkVarVsPtTrue[iTrkVar][1] -> SetRightMargin(fMarginR2);
679  pTrkVarVsPtTrue[iTrkVar][1] -> SetTopMargin(fMarginT);
680  pTrkVarVsPtTrue[iTrkVar][1] -> SetBottomMargin(fMarginB);
681  cTrkVarVsPtTrue[iTrkVar] -> cd();
682  pTrkVarVsPtTrue[iTrkVar][0] -> Draw();
683  pTrkVarVsPtTrue[iTrkVar][1] -> Draw();
684  pTrkVarVsPtTrue[iTrkVar][0] -> cd();
685  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
686  if (iToDraw == 0) {
687  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
688  } else {
689  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
690  }
691  } // end to-draw loop
692  leg -> Draw();
693  ptTxt -> Draw();
694  ptCut -> Draw();
695  pTrkVarVsPtTrue[iTrkVar][1] -> cd();
696  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
697  if (iToDraw == 0) {
698  hTrkVarVsPtTrue[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
699  } else {
700  hTrkVarVsPtTrue[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
701  }
702  } // end to-draw loop
703  cTrkVarVsPtTrue[iTrkVar] -> Write();
704  cTrkVarVsPtTrue[iTrkVar] -> Close();
705 
706  // 2d track variables vs. pttrue
707  cTrkVarVsPtFrac[iTrkVar] = new TCanvas(sTrkVarVsPtFrac[iTrkVar].Data(), "", fWidth2P, fHeight2P);
708  pTrkVarVsPtFrac[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
709  pTrkVarVsPtFrac[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
710  cTrkVarVsPtFrac[iTrkVar] -> SetGrid(fGrid, fGrid);
711  cTrkVarVsPtFrac[iTrkVar] -> SetTicks(fTick, fTick);
712  cTrkVarVsPtFrac[iTrkVar] -> SetBorderMode(fMode);
713  cTrkVarVsPtFrac[iTrkVar] -> SetBorderSize(fBord);
714  pTrkVarVsPtFrac[iTrkVar][0] -> SetGrid(fGrid, fGrid);
715  pTrkVarVsPtFrac[iTrkVar][0] -> SetTicks(fTick, fTick);
716  pTrkVarVsPtFrac[iTrkVar][0] -> SetLogx(fLogX);
717  pTrkVarVsPtFrac[iTrkVar][0] -> SetLogy(fLogY);
718  pTrkVarVsPtFrac[iTrkVar][0] -> SetLogz(fLogZ);
719  pTrkVarVsPtFrac[iTrkVar][0] -> SetBorderMode(fMode);
720  pTrkVarVsPtFrac[iTrkVar][0] -> SetBorderSize(fBord);
721  pTrkVarVsPtFrac[iTrkVar][0] -> SetFrameBorderMode(fFrame);
722  pTrkVarVsPtFrac[iTrkVar][0] -> SetLeftMargin(fMarginL);
723  pTrkVarVsPtFrac[iTrkVar][0] -> SetRightMargin(fMarginR1);
724  pTrkVarVsPtFrac[iTrkVar][0] -> SetTopMargin(fMarginT);
725  pTrkVarVsPtFrac[iTrkVar][0] -> SetBottomMargin(fMarginB);
726  pTrkVarVsPtFrac[iTrkVar][1] -> SetGrid(fGrid, fGrid);
727  pTrkVarVsPtFrac[iTrkVar][1] -> SetTicks(fTick, fTick);
728  pTrkVarVsPtFrac[iTrkVar][1] -> SetLogx(fLogX);
729  pTrkVarVsPtFrac[iTrkVar][1] -> SetLogy(fLogY);
730  pTrkVarVsPtFrac[iTrkVar][1] -> SetLogz(fLogZ);
731  pTrkVarVsPtFrac[iTrkVar][1] -> SetBorderMode(fMode);
732  pTrkVarVsPtFrac[iTrkVar][1] -> SetBorderSize(fBord);
733  pTrkVarVsPtFrac[iTrkVar][1] -> SetFrameBorderMode(fFrame);
734  pTrkVarVsPtFrac[iTrkVar][1] -> SetLeftMargin(fMarginL);
735  pTrkVarVsPtFrac[iTrkVar][1] -> SetRightMargin(fMarginR2);
736  pTrkVarVsPtFrac[iTrkVar][1] -> SetTopMargin(fMarginT);
737  pTrkVarVsPtFrac[iTrkVar][1] -> SetBottomMargin(fMarginB);
738  cTrkVarVsPtFrac[iTrkVar] -> cd();
739  pTrkVarVsPtFrac[iTrkVar][0] -> Draw();
740  pTrkVarVsPtFrac[iTrkVar][1] -> Draw();
741  pTrkVarVsPtFrac[iTrkVar][0] -> cd();
742  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
743  if (iToDraw == 0) {
744  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
745  } else {
746  hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
747  }
748  } // end to-draw loop
749  leg -> Draw();
750  ptTxt -> Draw();
751  ptCut -> Draw();
752  pTrkVarVsPtFrac[iTrkVar][1] -> cd();
753  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
754  if (iToDraw == 0) {
755  hTrkVarVsPtFrac[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
756  } else {
757  hTrkVarVsPtFrac[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
758  }
759  } // end to-draw loop
760  cTrkVarVsPtFrac[iTrkVar] -> Write();
761  cTrkVarVsPtFrac[iTrkVar] -> Close();
762  } // end track variable loop
763 
764  // for physics-variable plots
765  TCanvas *cPhysVar[NPhysVar];
766  TCanvas *cPhysVarDiff[NPhysVar];
767  TCanvas *cPhysVarFrac[NPhysVar];
768  TCanvas *cPhysVarVsNTpc[NPhysVar];
769  TCanvas *cPhysVarVsDcaXY[NPhysVar];
770  TCanvas *cPhysVarVsDcaZ[NPhysVar];
771  TCanvas *cPhysVarVsPtReco[NPhysVar];
772  TCanvas *cPhysVarVsPtTrue[NPhysVar];
773  TCanvas *cPhysVarVsPtFrac[NPhysVar];
774  TPad *pPhysVarVsNTpc[NPhysVar][NPanel];
775  TPad *pPhysVarVsDcaXY[NPhysVar][NPanel];
776  TPad *pPhysVarVsDcaZ[NPhysVar][NPanel];
777  TPad *pPhysVarVsPtReco[NPhysVar][NPanel];
778  TPad *pPhysVarVsPtTrue[NPhysVar][NPanel];
779  TPad *pPhysVarVsPtFrac[NPhysVar][NPanel];
780  for (size_t iPhysVar = 0; iPhysVar < NPhysVar; iPhysVar++) {
781 
782  // 1d physics variable
783  cPhysVar[iPhysVar] = new TCanvas(sPhysVar[iPhysVar].Data(), "", fWidth1P, fHeight1P);
784  cPhysVar[iPhysVar] -> SetGrid(fGrid, fGrid);
785  cPhysVar[iPhysVar] -> SetTicks(fTick, fTick);
786  cPhysVar[iPhysVar] -> SetLogx(fLogX);
787  cPhysVar[iPhysVar] -> SetLogy(fLogY);
788  cPhysVar[iPhysVar] -> SetLogz(fLogZ);
789  cPhysVar[iPhysVar] -> SetBorderMode(fMode);
790  cPhysVar[iPhysVar] -> SetBorderSize(fBord);
791  cPhysVar[iPhysVar] -> SetFrameBorderMode(fFrame);
792  cPhysVar[iPhysVar] -> SetLeftMargin(fMarginL);
793  cPhysVar[iPhysVar] -> SetRightMargin(fMarginR1);
794  cPhysVar[iPhysVar] -> SetTopMargin(fMarginT);
795  cPhysVar[iPhysVar] -> SetBottomMargin(fMarginB);
796  cPhysVar[iPhysVar] -> cd();
797  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
798  if (iToDraw == 0) {
799  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw();
800  } else {
801  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
802  }
803  } // end to-draw loop
804  leg -> Draw();
805  ptTxt -> Draw();
806  ptCut -> Draw();
807  cPhysVar[iPhysVar] -> Write();
808  cPhysVar[iPhysVar] -> Close();
809 
810  // 1d physics difference
811  cPhysVarDiff[iPhysVar] = new TCanvas(sPhysVarDiff[iPhysVar].Data(), "", fWidth1P, fHeight1P);
812  cPhysVarDiff[iPhysVar] -> SetGrid(fGrid, fGrid);
813  cPhysVarDiff[iPhysVar] -> SetTicks(fTick, fTick);
814  cPhysVarDiff[iPhysVar] -> SetLogx(fLogX);
815  cPhysVarDiff[iPhysVar] -> SetLogy(fLogY);
816  cPhysVarDiff[iPhysVar] -> SetLogz(fLogZ);
817  cPhysVarDiff[iPhysVar] -> SetBorderMode(fMode);
818  cPhysVarDiff[iPhysVar] -> SetBorderSize(fBord);
819  cPhysVarDiff[iPhysVar] -> SetFrameBorderMode(fFrame);
820  cPhysVarDiff[iPhysVar] -> SetLeftMargin(fMarginL);
821  cPhysVarDiff[iPhysVar] -> SetRightMargin(fMarginR1);
822  cPhysVarDiff[iPhysVar] -> SetTopMargin(fMarginT);
823  cPhysVarDiff[iPhysVar] -> SetBottomMargin(fMarginB);
824  cPhysVarDiff[iPhysVar] -> cd();
825  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
826  if (iToDraw == 0) {
827  hPhysVarDiff[typesToDraw[iToDraw]][iPhysVar] -> Draw();
828  } else {
829  hPhysVarDiff[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
830  }
831  } // end to-draw loop
832  leg -> Draw();
833  ptTxt -> Draw();
834  ptCut -> Draw();
835  cPhysVarDiff[iPhysVar] -> Write();
836  cPhysVarDiff[iPhysVar] -> Close();
837 
838  // 1d physics fraction
839  cPhysVarFrac[iPhysVar] = new TCanvas(sPhysVarFrac[iPhysVar].Data(), "", fWidth1P, fHeight1P);
840  cPhysVarFrac[iPhysVar] -> SetGrid(fGrid, fGrid);
841  cPhysVarFrac[iPhysVar] -> SetTicks(fTick, fTick);
842  cPhysVarFrac[iPhysVar] -> SetLogx(fLogX);
843  cPhysVarFrac[iPhysVar] -> SetLogy(fLogY);
844  cPhysVarFrac[iPhysVar] -> SetLogz(fLogZ);
845  cPhysVarFrac[iPhysVar] -> SetBorderMode(fMode);
846  cPhysVarFrac[iPhysVar] -> SetBorderSize(fBord);
847  cPhysVarFrac[iPhysVar] -> SetFrameBorderMode(fFrame);
848  cPhysVarFrac[iPhysVar] -> SetLeftMargin(fMarginL);
849  cPhysVarFrac[iPhysVar] -> SetRightMargin(fMarginR1);
850  cPhysVarFrac[iPhysVar] -> SetTopMargin(fMarginT);
851  cPhysVarFrac[iPhysVar] -> SetBottomMargin(fMarginB);
852  cPhysVarFrac[iPhysVar] -> cd();
853  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
854  if (iToDraw == 0) {
855  hPhysVarFrac[typesToDraw[iToDraw]][iPhysVar] -> Draw();
856  } else {
857  hPhysVarFrac[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
858  }
859  } // end to-draw loop
860  leg -> Draw();
861  ptTxt -> Draw();
862  ptCut -> Draw();
863  cPhysVarFrac[iPhysVar] -> Write();
864  cPhysVarFrac[iPhysVar] -> Close();
865 
866  // 2d physics variables vs. ntpc
867  cPhysVarVsNTpc[iPhysVar] = new TCanvas(sPhysVarVsNTpc[iPhysVar].Data(), "", fWidth2P, fHeight2P);
868  pPhysVarVsNTpc[iPhysVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
869  pPhysVarVsNTpc[iPhysVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
870  cPhysVarVsNTpc[iPhysVar] -> SetGrid(fGrid, fGrid);
871  cPhysVarVsNTpc[iPhysVar] -> SetTicks(fTick, fTick);
872  cPhysVarVsNTpc[iPhysVar] -> SetBorderMode(fMode);
873  cPhysVarVsNTpc[iPhysVar] -> SetBorderSize(fBord);
874  pPhysVarVsNTpc[iPhysVar][0] -> SetGrid(fGrid, fGrid);
875  pPhysVarVsNTpc[iPhysVar][0] -> SetTicks(fTick, fTick);
876  pPhysVarVsNTpc[iPhysVar][0] -> SetLogx(fLogX);
877  pPhysVarVsNTpc[iPhysVar][0] -> SetLogy(fLogY);
878  pPhysVarVsNTpc[iPhysVar][0] -> SetLogz(fLogZ);
879  pPhysVarVsNTpc[iPhysVar][0] -> SetBorderMode(fMode);
880  pPhysVarVsNTpc[iPhysVar][0] -> SetBorderSize(fBord);
881  pPhysVarVsNTpc[iPhysVar][0] -> SetFrameBorderMode(fFrame);
882  pPhysVarVsNTpc[iPhysVar][0] -> SetLeftMargin(fMarginL);
883  pPhysVarVsNTpc[iPhysVar][0] -> SetRightMargin(fMarginR1);
884  pPhysVarVsNTpc[iPhysVar][0] -> SetTopMargin(fMarginT);
885  pPhysVarVsNTpc[iPhysVar][0] -> SetBottomMargin(fMarginB);
886  pPhysVarVsNTpc[iPhysVar][1] -> SetGrid(fGrid, fGrid);
887  pPhysVarVsNTpc[iPhysVar][1] -> SetTicks(fTick, fTick);
888  pPhysVarVsNTpc[iPhysVar][1] -> SetLogx(fLogX);
889  pPhysVarVsNTpc[iPhysVar][1] -> SetLogy(fLogY);
890  pPhysVarVsNTpc[iPhysVar][1] -> SetLogz(fLogZ);
891  pPhysVarVsNTpc[iPhysVar][1] -> SetBorderMode(fMode);
892  pPhysVarVsNTpc[iPhysVar][1] -> SetBorderSize(fBord);
893  pPhysVarVsNTpc[iPhysVar][1] -> SetFrameBorderMode(fFrame);
894  pPhysVarVsNTpc[iPhysVar][1] -> SetLeftMargin(fMarginL);
895  pPhysVarVsNTpc[iPhysVar][1] -> SetRightMargin(fMarginR2);
896  pPhysVarVsNTpc[iPhysVar][1] -> SetTopMargin(fMarginT);
897  pPhysVarVsNTpc[iPhysVar][1] -> SetBottomMargin(fMarginB);
898  cPhysVarVsNTpc[iPhysVar] -> cd();
899  pPhysVarVsNTpc[iPhysVar][0] -> Draw();
900  pPhysVarVsNTpc[iPhysVar][1] -> Draw();
901  pPhysVarVsNTpc[iPhysVar][0] -> cd();
902  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
903  if (iToDraw == 0) {
904  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw();
905  } else {
906  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
907  }
908  } // end to-draw loop
909  leg -> Draw();
910  ptTxt -> Draw();
911  ptCut -> Draw();
912  pPhysVarVsNTpc[iPhysVar][1] -> cd();
913  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
914  if (iToDraw == 0) {
915  hPhysVarVsNTpc[typesToDraw[iToDraw]][iPhysVar] -> Draw("colz");
916  } else {
917  hPhysVarVsNTpc[typesToDraw[iToDraw]][iPhysVar] -> Draw("scat same");
918  }
919  } // end to-draw loop
920  cPhysVarVsNTpc[iPhysVar] -> Write();
921  cPhysVarVsNTpc[iPhysVar] -> Close();
922 
923  // 2d physics variables vs. dcaxy
924  cPhysVarVsDcaXY[iPhysVar] = new TCanvas(sPhysVarVsDcaXY[iPhysVar].Data(), "", fWidth2P, fHeight2P);
925  pPhysVarVsDcaXY[iPhysVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
926  pPhysVarVsDcaXY[iPhysVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
927  cPhysVarVsDcaXY[iPhysVar] -> SetGrid(fGrid, fGrid);
928  cPhysVarVsDcaXY[iPhysVar] -> SetTicks(fTick, fTick);
929  cPhysVarVsDcaXY[iPhysVar] -> SetBorderMode(fMode);
930  cPhysVarVsDcaXY[iPhysVar] -> SetBorderSize(fBord);
931  pPhysVarVsDcaXY[iPhysVar][0] -> SetGrid(fGrid, fGrid);
932  pPhysVarVsDcaXY[iPhysVar][0] -> SetTicks(fTick, fTick);
933  pPhysVarVsDcaXY[iPhysVar][0] -> SetLogx(fLogX);
934  pPhysVarVsDcaXY[iPhysVar][0] -> SetLogy(fLogY);
935  pPhysVarVsDcaXY[iPhysVar][0] -> SetLogz(fLogZ);
936  pPhysVarVsDcaXY[iPhysVar][0] -> SetBorderMode(fMode);
937  pPhysVarVsDcaXY[iPhysVar][0] -> SetBorderSize(fBord);
938  pPhysVarVsDcaXY[iPhysVar][0] -> SetFrameBorderMode(fFrame);
939  pPhysVarVsDcaXY[iPhysVar][0] -> SetLeftMargin(fMarginL);
940  pPhysVarVsDcaXY[iPhysVar][0] -> SetRightMargin(fMarginR1);
941  pPhysVarVsDcaXY[iPhysVar][0] -> SetTopMargin(fMarginT);
942  pPhysVarVsDcaXY[iPhysVar][0] -> SetBottomMargin(fMarginB);
943  pPhysVarVsDcaXY[iPhysVar][1] -> SetGrid(fGrid, fGrid);
944  pPhysVarVsDcaXY[iPhysVar][1] -> SetTicks(fTick, fTick);
945  pPhysVarVsDcaXY[iPhysVar][1] -> SetLogx(fLogX);
946  pPhysVarVsDcaXY[iPhysVar][1] -> SetLogy(fLogY);
947  pPhysVarVsDcaXY[iPhysVar][1] -> SetLogz(fLogZ);
948  pPhysVarVsDcaXY[iPhysVar][1] -> SetBorderMode(fMode);
949  pPhysVarVsDcaXY[iPhysVar][1] -> SetBorderSize(fBord);
950  pPhysVarVsDcaXY[iPhysVar][1] -> SetFrameBorderMode(fFrame);
951  pPhysVarVsDcaXY[iPhysVar][1] -> SetLeftMargin(fMarginL);
952  pPhysVarVsDcaXY[iPhysVar][1] -> SetRightMargin(fMarginR2);
953  pPhysVarVsDcaXY[iPhysVar][1] -> SetTopMargin(fMarginT);
954  pPhysVarVsDcaXY[iPhysVar][1] -> SetBottomMargin(fMarginB);
955  cPhysVarVsDcaXY[iPhysVar] -> cd();
956  pPhysVarVsDcaXY[iPhysVar][0] -> Draw();
957  pPhysVarVsDcaXY[iPhysVar][1] -> Draw();
958  pPhysVarVsDcaXY[iPhysVar][0] -> cd();
959  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
960  if (iToDraw == 0) {
961  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw();
962  } else {
963  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
964  }
965  } // end to-draw loop
966  leg -> Draw();
967  ptTxt -> Draw();
968  ptCut -> Draw();
969  pPhysVarVsDcaXY[iPhysVar][1] -> cd();
970  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
971  if (iToDraw == 0) {
972  hPhysVarVsDcaXY[typesToDraw[iToDraw]][iPhysVar] -> Draw("colz");
973  } else {
974  hPhysVarVsDcaXY[typesToDraw[iToDraw]][iPhysVar] -> Draw("scat same");
975  }
976  } // end to-draw loop
977  cPhysVarVsDcaXY[iPhysVar] -> Write();
978  cPhysVarVsDcaXY[iPhysVar] -> Close();
979 
980  // 2d physics variables vs. dcaz
981  cPhysVarVsDcaZ[iPhysVar] = new TCanvas(sPhysVarVsDcaZ[iPhysVar].Data(), "", fWidth2P, fHeight2P);
982  pPhysVarVsDcaZ[iPhysVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
983  pPhysVarVsDcaZ[iPhysVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
984  cPhysVarVsDcaZ[iPhysVar] -> SetGrid(fGrid, fGrid);
985  cPhysVarVsDcaZ[iPhysVar] -> SetTicks(fTick, fTick);
986  cPhysVarVsDcaZ[iPhysVar] -> SetBorderMode(fMode);
987  cPhysVarVsDcaZ[iPhysVar] -> SetBorderSize(fBord);
988  pPhysVarVsDcaZ[iPhysVar][0] -> SetGrid(fGrid, fGrid);
989  pPhysVarVsDcaZ[iPhysVar][0] -> SetTicks(fTick, fTick);
990  pPhysVarVsDcaZ[iPhysVar][0] -> SetLogx(fLogX);
991  pPhysVarVsDcaZ[iPhysVar][0] -> SetLogy(fLogY);
992  pPhysVarVsDcaZ[iPhysVar][0] -> SetLogz(fLogZ);
993  pPhysVarVsDcaZ[iPhysVar][0] -> SetBorderMode(fMode);
994  pPhysVarVsDcaZ[iPhysVar][0] -> SetBorderSize(fBord);
995  pPhysVarVsDcaZ[iPhysVar][0] -> SetFrameBorderMode(fFrame);
996  pPhysVarVsDcaZ[iPhysVar][0] -> SetLeftMargin(fMarginL);
997  pPhysVarVsDcaZ[iPhysVar][0] -> SetRightMargin(fMarginR1);
998  pPhysVarVsDcaZ[iPhysVar][0] -> SetTopMargin(fMarginT);
999  pPhysVarVsDcaZ[iPhysVar][0] -> SetBottomMargin(fMarginB);
1000  pPhysVarVsDcaZ[iPhysVar][1] -> SetGrid(fGrid, fGrid);
1001  pPhysVarVsDcaZ[iPhysVar][1] -> SetTicks(fTick, fTick);
1002  pPhysVarVsDcaZ[iPhysVar][1] -> SetLogx(fLogX);
1003  pPhysVarVsDcaZ[iPhysVar][1] -> SetLogy(fLogY);
1004  pPhysVarVsDcaZ[iPhysVar][1] -> SetLogz(fLogZ);
1005  pPhysVarVsDcaZ[iPhysVar][1] -> SetBorderMode(fMode);
1006  pPhysVarVsDcaZ[iPhysVar][1] -> SetBorderSize(fBord);
1007  pPhysVarVsDcaZ[iPhysVar][1] -> SetFrameBorderMode(fFrame);
1008  pPhysVarVsDcaZ[iPhysVar][1] -> SetLeftMargin(fMarginL);
1009  pPhysVarVsDcaZ[iPhysVar][1] -> SetRightMargin(fMarginR2);
1010  pPhysVarVsDcaZ[iPhysVar][1] -> SetTopMargin(fMarginT);
1011  pPhysVarVsDcaZ[iPhysVar][1] -> SetBottomMargin(fMarginB);
1012  cPhysVarVsDcaZ[iPhysVar] -> cd();
1013  pPhysVarVsDcaZ[iPhysVar][0] -> Draw();
1014  pPhysVarVsDcaZ[iPhysVar][1] -> Draw();
1015  pPhysVarVsDcaZ[iPhysVar][0] -> cd();
1016  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
1017  if (iToDraw == 0) {
1018  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw();
1019  } else {
1020  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
1021  }
1022  } // end to-draw loop
1023  leg -> Draw();
1024  ptTxt -> Draw();
1025  ptCut -> Draw();
1026  pPhysVarVsDcaZ[iPhysVar][1] -> cd();
1027  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
1028  if (iToDraw == 0) {
1029  hPhysVarVsDcaZ[typesToDraw[iToDraw]][iPhysVar] -> Draw("colz");
1030  } else {
1031  hPhysVarVsDcaZ[typesToDraw[iToDraw]][iPhysVar] -> Draw("scat same");
1032  }
1033  } // end to-draw loop
1034  cPhysVarVsDcaZ[iPhysVar] -> Write();
1035  cPhysVarVsDcaZ[iPhysVar] -> Close();
1036 
1037  // 2d physics variables vs. ptreco
1038  cPhysVarVsPtReco[iPhysVar] = new TCanvas(sPhysVarVsPtReco[iPhysVar].Data(), "", fWidth2P, fHeight2P);
1039  pPhysVarVsPtReco[iPhysVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
1040  pPhysVarVsPtReco[iPhysVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
1041  cPhysVarVsPtReco[iPhysVar] -> SetGrid(fGrid, fGrid);
1042  cPhysVarVsPtReco[iPhysVar] -> SetTicks(fTick, fTick);
1043  cPhysVarVsPtReco[iPhysVar] -> SetBorderMode(fMode);
1044  cPhysVarVsPtReco[iPhysVar] -> SetBorderSize(fBord);
1045  pPhysVarVsPtReco[iPhysVar][0] -> SetGrid(fGrid, fGrid);
1046  pPhysVarVsPtReco[iPhysVar][0] -> SetTicks(fTick, fTick);
1047  pPhysVarVsPtReco[iPhysVar][0] -> SetLogx(fLogX);
1048  pPhysVarVsPtReco[iPhysVar][0] -> SetLogy(fLogY);
1049  pPhysVarVsPtReco[iPhysVar][0] -> SetLogz(fLogZ);
1050  pPhysVarVsPtReco[iPhysVar][0] -> SetBorderMode(fMode);
1051  pPhysVarVsPtReco[iPhysVar][0] -> SetBorderSize(fBord);
1052  pPhysVarVsPtReco[iPhysVar][0] -> SetFrameBorderMode(fFrame);
1053  pPhysVarVsPtReco[iPhysVar][0] -> SetLeftMargin(fMarginL);
1054  pPhysVarVsPtReco[iPhysVar][0] -> SetRightMargin(fMarginR1);
1055  pPhysVarVsPtReco[iPhysVar][0] -> SetTopMargin(fMarginT);
1056  pPhysVarVsPtReco[iPhysVar][0] -> SetBottomMargin(fMarginB);
1057  pPhysVarVsPtReco[iPhysVar][1] -> SetGrid(fGrid, fGrid);
1058  pPhysVarVsPtReco[iPhysVar][1] -> SetTicks(fTick, fTick);
1059  pPhysVarVsPtReco[iPhysVar][1] -> SetLogx(fLogX);
1060  pPhysVarVsPtReco[iPhysVar][1] -> SetLogy(fLogY);
1061  pPhysVarVsPtReco[iPhysVar][1] -> SetLogz(fLogZ);
1062  pPhysVarVsPtReco[iPhysVar][1] -> SetBorderMode(fMode);
1063  pPhysVarVsPtReco[iPhysVar][1] -> SetBorderSize(fBord);
1064  pPhysVarVsPtReco[iPhysVar][1] -> SetFrameBorderMode(fFrame);
1065  pPhysVarVsPtReco[iPhysVar][1] -> SetLeftMargin(fMarginL);
1066  pPhysVarVsPtReco[iPhysVar][1] -> SetRightMargin(fMarginR2);
1067  pPhysVarVsPtReco[iPhysVar][1] -> SetTopMargin(fMarginT);
1068  pPhysVarVsPtReco[iPhysVar][1] -> SetBottomMargin(fMarginB);
1069  cPhysVarVsPtReco[iPhysVar] -> cd();
1070  pPhysVarVsPtReco[iPhysVar][0] -> Draw();
1071  pPhysVarVsPtReco[iPhysVar][1] -> Draw();
1072  pPhysVarVsPtReco[iPhysVar][0] -> cd();
1073  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
1074  if (iToDraw == 0) {
1075  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw();
1076  } else {
1077  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
1078  }
1079  } // end to-draw loop
1080  leg -> Draw();
1081  ptTxt -> Draw();
1082  ptCut -> Draw();
1083  pPhysVarVsPtReco[iPhysVar][1] -> cd();
1084  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
1085  if (iToDraw == 0) {
1086  hPhysVarVsPtReco[typesToDraw[iToDraw]][iPhysVar] -> Draw("colz");
1087  } else {
1088  hPhysVarVsPtReco[typesToDraw[iToDraw]][iPhysVar] -> Draw("scat same");
1089  }
1090  } // end to-draw loop
1091  cPhysVarVsPtReco[iPhysVar] -> Write();
1092  cPhysVarVsPtReco[iPhysVar] -> Close();
1093 
1094  // 2d physics variables vs. pttrue
1095  cPhysVarVsPtTrue[iPhysVar] = new TCanvas(sPhysVarVsPtTrue[iPhysVar].Data(), "", fWidth2P, fHeight2P);
1096  pPhysVarVsPtTrue[iPhysVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
1097  pPhysVarVsPtTrue[iPhysVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
1098  cPhysVarVsPtTrue[iPhysVar] -> SetGrid(fGrid, fGrid);
1099  cPhysVarVsPtTrue[iPhysVar] -> SetTicks(fTick, fTick);
1100  cPhysVarVsPtTrue[iPhysVar] -> SetBorderMode(fMode);
1101  cPhysVarVsPtTrue[iPhysVar] -> SetBorderSize(fBord);
1102  pPhysVarVsPtTrue[iPhysVar][0] -> SetGrid(fGrid, fGrid);
1103  pPhysVarVsPtTrue[iPhysVar][0] -> SetTicks(fTick, fTick);
1104  pPhysVarVsPtTrue[iPhysVar][0] -> SetLogx(fLogX);
1105  pPhysVarVsPtTrue[iPhysVar][0] -> SetLogy(fLogY);
1106  pPhysVarVsPtTrue[iPhysVar][0] -> SetLogz(fLogZ);
1107  pPhysVarVsPtTrue[iPhysVar][0] -> SetBorderMode(fMode);
1108  pPhysVarVsPtTrue[iPhysVar][0] -> SetBorderSize(fBord);
1109  pPhysVarVsPtTrue[iPhysVar][0] -> SetFrameBorderMode(fFrame);
1110  pPhysVarVsPtTrue[iPhysVar][0] -> SetLeftMargin(fMarginL);
1111  pPhysVarVsPtTrue[iPhysVar][0] -> SetRightMargin(fMarginR1);
1112  pPhysVarVsPtTrue[iPhysVar][0] -> SetTopMargin(fMarginT);
1113  pPhysVarVsPtTrue[iPhysVar][0] -> SetBottomMargin(fMarginB);
1114  pPhysVarVsPtTrue[iPhysVar][1] -> SetGrid(fGrid, fGrid);
1115  pPhysVarVsPtTrue[iPhysVar][1] -> SetTicks(fTick, fTick);
1116  pPhysVarVsPtTrue[iPhysVar][1] -> SetLogx(fLogX);
1117  pPhysVarVsPtTrue[iPhysVar][1] -> SetLogy(fLogY);
1118  pPhysVarVsPtTrue[iPhysVar][1] -> SetLogz(fLogZ);
1119  pPhysVarVsPtTrue[iPhysVar][1] -> SetBorderMode(fMode);
1120  pPhysVarVsPtTrue[iPhysVar][1] -> SetBorderSize(fBord);
1121  pPhysVarVsPtTrue[iPhysVar][1] -> SetFrameBorderMode(fFrame);
1122  pPhysVarVsPtTrue[iPhysVar][1] -> SetLeftMargin(fMarginL);
1123  pPhysVarVsPtTrue[iPhysVar][1] -> SetRightMargin(fMarginR2);
1124  pPhysVarVsPtTrue[iPhysVar][1] -> SetTopMargin(fMarginT);
1125  pPhysVarVsPtTrue[iPhysVar][1] -> SetBottomMargin(fMarginB);
1126  cPhysVarVsPtTrue[iPhysVar] -> cd();
1127  pPhysVarVsPtTrue[iPhysVar][0] -> Draw();
1128  pPhysVarVsPtTrue[iPhysVar][1] -> Draw();
1129  pPhysVarVsPtTrue[iPhysVar][0] -> cd();
1130  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
1131  if (iToDraw == 0) {
1132  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw();
1133  } else {
1134  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
1135  }
1136  } // end to-draw loop
1137  leg -> Draw();
1138  ptTxt -> Draw();
1139  ptCut -> Draw();
1140  pPhysVarVsPtTrue[iPhysVar][1] -> cd();
1141  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
1142  if (iToDraw == 0) {
1143  hPhysVarVsPtTrue[typesToDraw[iToDraw]][iPhysVar] -> Draw("colz");
1144  } else {
1145  hPhysVarVsPtTrue[typesToDraw[iToDraw]][iPhysVar] -> Draw("scat same");
1146  }
1147  } // end to-draw loop
1148  cPhysVarVsPtTrue[iPhysVar] -> Write();
1149  cPhysVarVsPtTrue[iPhysVar] -> Close();
1150 
1151  // 2d physics variables vs. pttrue
1152  cPhysVarVsPtFrac[iPhysVar] = new TCanvas(sPhysVarVsPtFrac[iPhysVar].Data(), "", fWidth2P, fHeight2P);
1153  pPhysVarVsPtFrac[iPhysVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
1154  pPhysVarVsPtFrac[iPhysVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
1155  cPhysVarVsPtFrac[iPhysVar] -> SetGrid(fGrid, fGrid);
1156  cPhysVarVsPtFrac[iPhysVar] -> SetTicks(fTick, fTick);
1157  cPhysVarVsPtFrac[iPhysVar] -> SetBorderMode(fMode);
1158  cPhysVarVsPtFrac[iPhysVar] -> SetBorderSize(fBord);
1159  pPhysVarVsPtFrac[iPhysVar][0] -> SetGrid(fGrid, fGrid);
1160  pPhysVarVsPtFrac[iPhysVar][0] -> SetTicks(fTick, fTick);
1161  pPhysVarVsPtFrac[iPhysVar][0] -> SetLogx(fLogX);
1162  pPhysVarVsPtFrac[iPhysVar][0] -> SetLogy(fLogY);
1163  pPhysVarVsPtFrac[iPhysVar][0] -> SetLogz(fLogZ);
1164  pPhysVarVsPtFrac[iPhysVar][0] -> SetBorderMode(fMode);
1165  pPhysVarVsPtFrac[iPhysVar][0] -> SetBorderSize(fBord);
1166  pPhysVarVsPtFrac[iPhysVar][0] -> SetFrameBorderMode(fFrame);
1167  pPhysVarVsPtFrac[iPhysVar][0] -> SetLeftMargin(fMarginL);
1168  pPhysVarVsPtFrac[iPhysVar][0] -> SetRightMargin(fMarginR1);
1169  pPhysVarVsPtFrac[iPhysVar][0] -> SetTopMargin(fMarginT);
1170  pPhysVarVsPtFrac[iPhysVar][0] -> SetBottomMargin(fMarginB);
1171  pPhysVarVsPtFrac[iPhysVar][1] -> SetGrid(fGrid, fGrid);
1172  pPhysVarVsPtFrac[iPhysVar][1] -> SetTicks(fTick, fTick);
1173  pPhysVarVsPtFrac[iPhysVar][1] -> SetLogx(fLogX);
1174  pPhysVarVsPtFrac[iPhysVar][1] -> SetLogy(fLogY);
1175  pPhysVarVsPtFrac[iPhysVar][1] -> SetLogz(fLogZ);
1176  pPhysVarVsPtFrac[iPhysVar][1] -> SetBorderMode(fMode);
1177  pPhysVarVsPtFrac[iPhysVar][1] -> SetBorderSize(fBord);
1178  pPhysVarVsPtFrac[iPhysVar][1] -> SetFrameBorderMode(fFrame);
1179  pPhysVarVsPtFrac[iPhysVar][1] -> SetLeftMargin(fMarginL);
1180  pPhysVarVsPtFrac[iPhysVar][1] -> SetRightMargin(fMarginR2);
1181  pPhysVarVsPtFrac[iPhysVar][1] -> SetTopMargin(fMarginT);
1182  pPhysVarVsPtFrac[iPhysVar][1] -> SetBottomMargin(fMarginB);
1183  cPhysVarVsPtFrac[iPhysVar] -> cd();
1184  pPhysVarVsPtFrac[iPhysVar][0] -> Draw();
1185  pPhysVarVsPtFrac[iPhysVar][1] -> Draw();
1186  pPhysVarVsPtFrac[iPhysVar][0] -> cd();
1187  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
1188  if (iToDraw == 0) {
1189  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw();
1190  } else {
1191  hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
1192  }
1193  } // end to-draw loop
1194  leg -> Draw();
1195  ptTxt -> Draw();
1196  ptCut -> Draw();
1197  pPhysVarVsPtFrac[iPhysVar][1] -> cd();
1198  for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
1199  if (iToDraw == 0) {
1200  hPhysVarVsPtFrac[typesToDraw[iToDraw]][iPhysVar] -> Draw("colz");
1201  } else {
1202  hPhysVarVsPtFrac[typesToDraw[iToDraw]][iPhysVar] -> Draw("scat same");
1203  }
1204  } // end to-draw loop
1205  cPhysVarVsPtFrac[iPhysVar] -> Write();
1206  cPhysVarVsPtFrac[iPhysVar] -> Close();
1207  } // end physics variable loop
1208 
1209  // return to top dir
1210  fOut -> cd();
1211  return;
1212 
1213 } // end 'ConstructPlots(Ssiz_t, Int_t[], TString, TString)'
1214 
1215 // end ------------------------------------------------------------------------