Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-06 08:11:52 

0001 // ----------------------------------------------------------------------------
0002 // 'STrackCutStudy.plot.h'
0003 // Derek Anderson
0004 // 03.14.2022
0005 //
0006 // Reads in the 'ntp_track' Ntuple
0007 // generated by the SVtxEvaluator
0008 // class and studies the impact
0009 // of cutting on various quantities.
0010 // ----------------------------------------------------------------------------
0011 
0012 #pragma once
0013 
0014 using namespace std;
0015 
0016 
0017 
0018 // plot methods ---------------------------------------------------------------
0019 
0020 void STrackCutStudy::MakeCutText() {
0021 
0022   // cut labels
0023   const TString sPrimary("Is primary");
0024   const TString sMVtxCut("MVTX hits = (");
0025   const TString sNTpcCut("TPC hits = (");
0026   const TString sVzCut("z-vertex = (");
0027   const TString sDcaXyCut("DCA (XY) = (");
0028   const TString sDcaZCut("DCA (Z) = (");
0029   const TString sQualityCut("Quality = (");
0030   const TString sVzUnits("cm");
0031   const TString sDcaUnits("#mum");
0032 
0033   // make text
0034   TString sMVtxTxt     = sMVtxCut;
0035   TString sNTpcTxt     = sNTpcCut;
0036   TString sVzTxt       = sVzCut;
0037   TString sDcaXyTxt    = sDcaXyCut;
0038   TString sDcaZTxt     = sDcaZCut;
0039   TString sQualityTxt  = sQualityCut;
0040   sMVtxTxt            += nMVtxCut.first;
0041   sNTpcTxt            += nTpcCut.first;
0042   sVzTxt              += vzCut.first;
0043   sDcaXyTxt           += dcaXyCut.first;
0044   sDcaZTxt            += dcaZCut.first;
0045   sQualityTxt         += qualityCut.first;
0046   sMVtxTxt            += ", ";
0047   sNTpcTxt            += ", ";
0048   sVzTxt              += ", ";
0049   sDcaXyTxt           += ", ";
0050   sDcaZTxt            += ", ";
0051   sQualityTxt         += ", ";
0052   sMVtxTxt            += nMVtxCut.second;
0053   sNTpcTxt            += nTpcCut.second;
0054   sVzTxt              += vzCut.second;
0055   sDcaXyTxt           += dcaXyCut.second;
0056   sDcaZTxt            += dcaZCut.second;
0057   sQualityTxt         += qualityCut.second;
0058   sMVtxTxt            += ")";
0059   sNTpcTxt            += ")";
0060   sVzTxt              += ") ";
0061   sDcaXyTxt           += ") ";
0062   sDcaZTxt            += ") ";
0063   sQualityTxt         += ")";
0064   sVzTxt              += sVzUnits.Data();
0065   sDcaXyTxt           += sDcaUnits.Data();
0066   sDcaZTxt            += sDcaUnits.Data();
0067 
0068   // determine how many lines to add
0069   UInt_t nCut(0);
0070   if (doPrimaryCut) nCut++;
0071   if (doMVtxCut)    nCut++;
0072   if (doTpcCut)     nCut++;
0073   if (doVzCut)      nCut++;
0074   if (doDcaXyCut)   nCut++;
0075   if (doDcaZCut)    nCut++;
0076   if (doQualityCut) nCut++;
0077 
0078   // make text box
0079   const UInt_t  fTxtC       = 42;
0080   const UInt_t  fAlnC       = 12;
0081   const UInt_t  fColC       = 0;
0082   const UInt_t  fLinC       = 1;
0083   const UInt_t  fFilC       = 0;
0084   const Float_t hCut        = 0.05 * nCut;
0085   const Float_t yCut        = 0.1 + hCut;
0086   const Float_t xyCut[NVtx] = {0.5, 0.1, 0.7, yCut};
0087 
0088   ptCut = new TPaveText(xyCut[0], xyCut[1], xyCut[2], xyCut[3], "NDC NB");
0089   ptCut -> SetFillColor(fColC);
0090   ptCut -> SetFillStyle(fFilC);
0091   ptCut -> SetLineColor(fColC);
0092   ptCut -> SetLineStyle(fLinC);
0093   ptCut -> SetTextFont(fTxtC);
0094   ptCut -> SetTextAlign(fAlnC);
0095   if (doPrimaryCut) ptCut -> AddText(sPrimary.Data());
0096   if (doMVtxCut)    ptCut -> AddText(sMVtxTxt.Data());
0097   if (doTpcCut)     ptCut -> AddText(sNTpcTxt.Data());
0098   if (doVzCut)      ptCut -> AddText(sVzTxt.Data());
0099   if (doDcaXyCut)   ptCut -> AddText(sDcaXyTxt.Data());
0100   if (doDcaZCut)    ptCut -> AddText(sDcaZTxt.Data());
0101   if (doQualityCut) ptCut -> AddText(sQualityTxt.Data());
0102 
0103   cout << "    Made text box for cuts." << endl;
0104   return;
0105 
0106 }  // end 'MakeCutText()'
0107 
0108 
0109 
0110 void STrackCutStudy::ConstructPlots(const Ssiz_t nToDraw, const Int_t typesToDraw[], const TString sDirToSaveTo, const TString sPlotLabel) {
0111 
0112   // check if saving directory is made, if so, recurse into it
0113   Bool_t dirIsThere = fOut -> cd(sDirToSaveTo.Data());
0114   if (!dirIsThere) {
0115     fOut -> mkdir(sDirToSaveTo.Data());
0116     fOut -> cd(sDirToSaveTo.Data());
0117   }
0118 
0119   // construct legend
0120   const UInt_t  fTxtL       = 42;
0121   const UInt_t  fColL       = 0;
0122   const UInt_t  fLinL       = 1;
0123   const UInt_t  fFilL       = 0;
0124   const Float_t hLeg        = 0.05 * nToDraw;
0125   const Float_t yLeg        = 0.1 + hLeg;
0126   const Float_t xyLeg[NVtx] = {0.1, 0.1, 0.3, yLeg};
0127 
0128   TLegend *leg = new TLegend(xyLeg[0], xyLeg[1], xyLeg[2], xyLeg[3]);
0129   leg -> SetFillColor(fColL);
0130   leg -> SetFillStyle(fFilL);
0131   leg -> SetLineColor(fColL);
0132   leg -> SetLineStyle(fLinL);
0133   leg -> SetTextFont(fTxtL);
0134   for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0135     leg -> AddEntry(hTrkVar[typesToDraw[iToDraw]][0], sTrkLabels[typesToDraw[iToDraw]].Data(), "pf");
0136   }
0137 
0138   // determine what to text to add to box
0139   Ssiz_t nTxt(0);
0140   Bool_t hasPileup(false);
0141   for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0142     if (isPileup[typesToDraw[iToDraw]]) {
0143       hasPileup = true;
0144       break;
0145     }
0146   }
0147 
0148   if (hasPileup) {
0149     nTxt = nTxtPU;
0150   } else {
0151     nTxt = nTxtEO;
0152   }
0153 
0154   // construct text box
0155   const UInt_t  fTxtT       = 42;
0156   const UInt_t  fAlnT       = 12;
0157   const UInt_t  fColT       = 0;
0158   const UInt_t  fLinT       = 1;
0159   const UInt_t  fFilT       = 0;
0160   const Float_t hTxt        = 0.05 * nTxt;
0161   const Float_t yTxt        = 0.1 + hTxt;
0162   const Float_t xyTxt[NVtx] = {0.3, 0.1, 0.5, yTxt};
0163 
0164   TPaveText *ptTxt = new TPaveText(xyTxt[0], xyTxt[1], xyTxt[2], xyTxt[3], "NDC NB");
0165   ptTxt -> SetFillColor(fColT);
0166   ptTxt -> SetFillStyle(fFilT);
0167   ptTxt -> SetLineColor(fColT);
0168   ptTxt -> SetLineStyle(fLinT);
0169   ptTxt -> SetTextFont(fTxtT);
0170   ptTxt -> SetTextAlign(fAlnT);
0171   for (Ssiz_t iTxt = 0; iTxt < nTxt; iTxt++) {
0172     if (hasPileup) {
0173       ptTxt -> AddText(sTxtPU[iTxt].Data());
0174     } else {
0175       ptTxt -> AddText(sTxtEO[iTxt].Data());
0176     }
0177   }
0178 
0179   // construct plots
0180   const UInt_t  fWidth1P(750);
0181   const UInt_t  fWidth2P(1500);
0182   const UInt_t  fHeight1P(750);
0183   const UInt_t  fHeight2P(750);
0184   const UInt_t  fMode(0);
0185   const UInt_t  fBord(2);
0186   const UInt_t  fGrid(0);
0187   const UInt_t  fTick(1);
0188   const UInt_t  fLogX(0);
0189   const UInt_t  fLogY(0);
0190   const UInt_t  fLogZ(1);
0191   const UInt_t  fFrame(0);
0192   const Float_t fMarginL(0.12);
0193   const Float_t fMarginR1(0.02);
0194   const Float_t fMarginR2(0.12);
0195   const Float_t fMarginT(0.02);
0196   const Float_t fMarginB(0.12);
0197   const Float_t padXY[NPanel][NVtx]        = {{0., 0., 0.5, 1.}, {0.5, 0., 1., 1.}};
0198   const TString sOneVsTwoDimPanels[NPanel] = {"pOneDim", "pTwoDim"};
0199 
0200   // form canvas names
0201   const TString sDiffSuffix("Diff");
0202   const TString sFracSuffix("Frac");
0203   const TString sVsNTpcSuffix("VsNTpc");
0204   const TString sVsDcaXySuffix("VsDcaXY");
0205   const TString sVsDcaZSuffix("VsDcaZ");
0206   const TString sVsPtRecoSuffix("VsPtReco");
0207   const TString sVsPtTrueSuffix("VsPtTrue");
0208   const TString sVsPtFracSuffix("VsPtFrac");
0209 
0210   // for track-variable canvas names
0211   TString sTrkVar[NTrkVar];
0212   TString sTrkVarDiff[NTrkVar];
0213   TString sTrkVarFrac[NTrkVar];
0214   TString sTrkVarVsNTpc[NTrkVar];
0215   TString sTrkVarVsDcaXY[NTrkVar];
0216   TString sTrkVarVsDcaZ[NTrkVar];
0217   TString sTrkVarVsPtReco[NTrkVar];
0218   TString sTrkVarVsPtTrue[NTrkVar];
0219   TString sTrkVarVsPtFrac[NTrkVar];
0220 
0221   // for physics-variable canvas names
0222   TString sPhysVar[NPhysVar];
0223   TString sPhysVarDiff[NPhysVar];
0224   TString sPhysVarFrac[NPhysVar];
0225   TString sPhysVarVsNTpc[NPhysVar];
0226   TString sPhysVarVsDcaXY[NPhysVar];
0227   TString sPhysVarVsDcaZ[NPhysVar];
0228   TString sPhysVarVsPtReco[NPhysVar];
0229   TString sPhysVarVsPtTrue[NPhysVar];
0230   TString sPhysVarVsPtFrac[NPhysVar];
0231 
0232   // construct variable prefixes
0233   TString sTrkVarName[NTrkVar];
0234   TString sPhysVarName[NPhysVar];
0235   for (size_t iTrkVar = 0; iTrkVar < NTrkVar; iTrkVar++) {
0236     sTrkVarName[iTrkVar] = "c";
0237     sTrkVarName[iTrkVar].Append(sTrkVars[iTrkVar].Data());
0238   }
0239   for (size_t iPhysVar = 0; iPhysVar < NPhysVar; iPhysVar++) {
0240     sPhysVarName[iPhysVar] = "c";
0241     sPhysVarName[iPhysVar].Append(sPhysVars[iPhysVar].Data());
0242   }
0243 
0244   for (size_t iTrkVar = 0; iTrkVar < NTrkVar; iTrkVar++) {
0245     sTrkVar[iTrkVar]         = sTrkVarName[iTrkVar].Data();
0246     sTrkVarDiff[iTrkVar]     = sTrkVarName[iTrkVar].Data();
0247     sTrkVarFrac[iTrkVar]     = sTrkVarName[iTrkVar].Data();
0248     sTrkVarVsNTpc[iTrkVar]   = sTrkVarName[iTrkVar].Data();
0249     sTrkVarVsDcaXY[iTrkVar]  = sTrkVarName[iTrkVar].Data();
0250     sTrkVarVsDcaZ[iTrkVar]   = sTrkVarName[iTrkVar].Data();
0251     sTrkVarVsPtReco[iTrkVar] = sTrkVarName[iTrkVar].Data();
0252     sTrkVarVsPtTrue[iTrkVar] = sTrkVarName[iTrkVar].Data();
0253     sTrkVarVsPtFrac[iTrkVar] = sTrkVarName[iTrkVar].Data();
0254     sTrkVarDiff[iTrkVar].Append(sDiffSuffix.Data());
0255     sTrkVarFrac[iTrkVar].Append(sFracSuffix.Data());
0256     sTrkVarVsNTpc[iTrkVar].Append(sVsNTpcSuffix.Data());
0257     sTrkVarVsDcaXY[iTrkVar].Append(sVsDcaXySuffix.Data());
0258     sTrkVarVsDcaZ[iTrkVar].Append(sVsDcaZSuffix.Data());
0259     sTrkVarVsPtReco[iTrkVar].Append(sVsPtRecoSuffix.Data());
0260     sTrkVarVsPtTrue[iTrkVar].Append(sVsPtTrueSuffix.Data());
0261     sTrkVarVsPtFrac[iTrkVar].Append(sVsPtFracSuffix.Data());
0262     sTrkVar[iTrkVar].Append("_");
0263     sTrkVarDiff[iTrkVar].Append("_");
0264     sTrkVarFrac[iTrkVar].Append("_");
0265     sTrkVarVsNTpc[iTrkVar].Append("_");
0266     sTrkVarVsDcaXY[iTrkVar].Append("_");
0267     sTrkVarVsDcaZ[iTrkVar].Append("_");
0268     sTrkVarVsPtReco[iTrkVar].Append("_");
0269     sTrkVarVsPtTrue[iTrkVar].Append("_");
0270     sTrkVarVsPtFrac[iTrkVar].Append("_");
0271     sTrkVar[iTrkVar].Append(sPlotLabel.Data());
0272     sTrkVarDiff[iTrkVar].Append(sPlotLabel.Data());
0273     sTrkVarFrac[iTrkVar].Append(sPlotLabel.Data());
0274     sTrkVarVsNTpc[iTrkVar].Append(sPlotLabel.Data());
0275     sTrkVarVsDcaXY[iTrkVar].Append(sPlotLabel.Data());
0276     sTrkVarVsDcaZ[iTrkVar].Append(sPlotLabel.Data());
0277     sTrkVarVsPtReco[iTrkVar].Append(sPlotLabel.Data());
0278     sTrkVarVsPtTrue[iTrkVar].Append(sPlotLabel.Data());
0279     sTrkVarVsPtFrac[iTrkVar].Append(sPlotLabel.Data());
0280   }
0281   for (size_t iPhysVar = 0; iPhysVar < NPhysVar; iPhysVar++) {
0282     sPhysVar[iPhysVar]         = sPhysVarName[iPhysVar].Data();
0283     sPhysVarDiff[iPhysVar]     = sPhysVarName[iPhysVar].Data();
0284     sPhysVarFrac[iPhysVar]     = sPhysVarName[iPhysVar].Data();
0285     sPhysVarVsNTpc[iPhysVar]   = sPhysVarName[iPhysVar].Data();
0286     sPhysVarVsDcaXY[iPhysVar]  = sPhysVarName[iPhysVar].Data();
0287     sPhysVarVsDcaZ[iPhysVar]   = sPhysVarName[iPhysVar].Data();
0288     sPhysVarVsPtReco[iPhysVar] = sPhysVarName[iPhysVar].Data();
0289     sPhysVarVsPtTrue[iPhysVar] = sPhysVarName[iPhysVar].Data();
0290     sPhysVarVsPtFrac[iPhysVar] = sPhysVarName[iPhysVar].Data();
0291     sPhysVarDiff[iPhysVar].Append(sDiffSuffix.Data());
0292     sPhysVarFrac[iPhysVar].Append(sFracSuffix.Data());
0293     sPhysVarVsNTpc[iPhysVar].Append(sVsNTpcSuffix.Data());
0294     sPhysVarVsDcaXY[iPhysVar].Append(sVsDcaXySuffix.Data());
0295     sPhysVarVsDcaZ[iPhysVar].Append(sVsDcaZSuffix.Data());
0296     sPhysVarVsPtReco[iPhysVar].Append(sVsPtRecoSuffix.Data());
0297     sPhysVarVsPtTrue[iPhysVar].Append(sVsPtTrueSuffix.Data());
0298     sPhysVarVsPtFrac[iPhysVar].Append(sVsPtFracSuffix.Data());
0299     sPhysVar[iPhysVar].Append("_");
0300     sPhysVarDiff[iPhysVar].Append("_");
0301     sPhysVarFrac[iPhysVar].Append("_");
0302     sPhysVarVsNTpc[iPhysVar].Append("_");
0303     sPhysVarVsDcaXY[iPhysVar].Append("_");
0304     sPhysVarVsDcaZ[iPhysVar].Append("_");
0305     sPhysVarVsPtReco[iPhysVar].Append("_");
0306     sPhysVarVsPtTrue[iPhysVar].Append("_");
0307     sPhysVarVsPtFrac[iPhysVar].Append("_");
0308     sPhysVar[iPhysVar].Append(sPlotLabel.Data());
0309     sPhysVarDiff[iPhysVar].Append(sPlotLabel.Data());
0310     sPhysVarFrac[iPhysVar].Append(sPlotLabel.Data());
0311     sPhysVarVsNTpc[iPhysVar].Append(sPlotLabel.Data());
0312     sPhysVarVsDcaXY[iPhysVar].Append(sPlotLabel.Data());
0313     sPhysVarVsDcaZ[iPhysVar].Append(sPlotLabel.Data());
0314     sPhysVarVsPtReco[iPhysVar].Append(sPlotLabel.Data());
0315     sPhysVarVsPtTrue[iPhysVar].Append(sPlotLabel.Data());
0316     sPhysVarVsPtFrac[iPhysVar].Append(sPlotLabel.Data());
0317   }
0318 
0319   // for track-variable plots
0320   TCanvas *cTrkVar[NTrkVar];
0321   TCanvas *cTrkVarDiff[NTrkVar];
0322   TCanvas *cTrkVarFrac[NTrkVar];
0323   TCanvas *cTrkVarVsNTpc[NTrkVar];
0324   TCanvas *cTrkVarVsDcaXY[NTrkVar];
0325   TCanvas *cTrkVarVsDcaZ[NTrkVar];
0326   TCanvas *cTrkVarVsPtReco[NTrkVar];
0327   TCanvas *cTrkVarVsPtTrue[NTrkVar];
0328   TCanvas *cTrkVarVsPtFrac[NTrkVar];
0329   TPad    *pTrkVarVsNTpc[NTrkVar][NPanel];
0330   TPad    *pTrkVarVsDcaXY[NTrkVar][NPanel];
0331   TPad    *pTrkVarVsDcaZ[NTrkVar][NPanel];
0332   TPad    *pTrkVarVsPtReco[NTrkVar][NPanel];
0333   TPad    *pTrkVarVsPtTrue[NTrkVar][NPanel];
0334   TPad    *pTrkVarVsPtFrac[NTrkVar][NPanel];
0335   for (size_t iTrkVar = 0; iTrkVar < NTrkVar; iTrkVar++) {
0336 
0337     // 1d track variable
0338     cTrkVar[iTrkVar] = new TCanvas(sTrkVar[iTrkVar].Data(), "", fWidth1P, fHeight1P);
0339     cTrkVar[iTrkVar] -> SetGrid(fGrid, fGrid);
0340     cTrkVar[iTrkVar] -> SetTicks(fTick, fTick);
0341     cTrkVar[iTrkVar] -> SetLogx(fLogX);
0342     cTrkVar[iTrkVar] -> SetLogy(fLogY);
0343     cTrkVar[iTrkVar] -> SetLogz(fLogZ);
0344     cTrkVar[iTrkVar] -> SetBorderMode(fMode);
0345     cTrkVar[iTrkVar] -> SetBorderSize(fBord);
0346     cTrkVar[iTrkVar] -> SetFrameBorderMode(fFrame);
0347     cTrkVar[iTrkVar] -> SetLeftMargin(fMarginL);
0348     cTrkVar[iTrkVar] -> SetRightMargin(fMarginR1);
0349     cTrkVar[iTrkVar] -> SetTopMargin(fMarginT);
0350     cTrkVar[iTrkVar] -> SetBottomMargin(fMarginB);
0351     cTrkVar[iTrkVar] -> cd();
0352     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0353       if (iToDraw == 0) {
0354         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
0355       } else {
0356         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
0357       }
0358     }  // end to-draw loop
0359     leg              -> Draw();
0360     ptTxt            -> Draw();
0361     ptCut            -> Draw();
0362     cTrkVar[iTrkVar] -> Write();
0363     cTrkVar[iTrkVar] -> Close();
0364 
0365     // 1d track difference
0366     cTrkVarDiff[iTrkVar] = new TCanvas(sTrkVarDiff[iTrkVar].Data(), "", fWidth1P, fHeight1P);
0367     cTrkVarDiff[iTrkVar] -> SetGrid(fGrid, fGrid);
0368     cTrkVarDiff[iTrkVar] -> SetTicks(fTick, fTick);
0369     cTrkVarDiff[iTrkVar] -> SetLogx(fLogX);
0370     cTrkVarDiff[iTrkVar] -> SetLogy(fLogY);
0371     cTrkVarDiff[iTrkVar] -> SetLogz(fLogZ);
0372     cTrkVarDiff[iTrkVar] -> SetBorderMode(fMode);
0373     cTrkVarDiff[iTrkVar] -> SetBorderSize(fBord);
0374     cTrkVarDiff[iTrkVar] -> SetFrameBorderMode(fFrame);
0375     cTrkVarDiff[iTrkVar] -> SetLeftMargin(fMarginL);
0376     cTrkVarDiff[iTrkVar] -> SetRightMargin(fMarginR1);
0377     cTrkVarDiff[iTrkVar] -> SetTopMargin(fMarginT);
0378     cTrkVarDiff[iTrkVar] -> SetBottomMargin(fMarginB);
0379     cTrkVarDiff[iTrkVar] -> cd();
0380     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0381       if (iToDraw == 0) {
0382         hTrkVarDiff[typesToDraw[iToDraw]][iTrkVar] -> Draw();
0383       } else {
0384         hTrkVarDiff[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
0385       }
0386     }  // end to-draw loop
0387     leg                  -> Draw();
0388     ptTxt                -> Draw();
0389     ptCut                -> Draw();
0390     cTrkVarDiff[iTrkVar] -> Write();
0391     cTrkVarDiff[iTrkVar] -> Close();
0392 
0393     // 1d track fraction
0394     cTrkVarFrac[iTrkVar] = new TCanvas(sTrkVarFrac[iTrkVar].Data(), "", fWidth1P, fHeight1P);
0395     cTrkVarFrac[iTrkVar] -> SetGrid(fGrid, fGrid);
0396     cTrkVarFrac[iTrkVar] -> SetTicks(fTick, fTick);
0397     cTrkVarFrac[iTrkVar] -> SetLogx(fLogX);
0398     cTrkVarFrac[iTrkVar] -> SetLogy(fLogY);
0399     cTrkVarFrac[iTrkVar] -> SetLogz(fLogZ);
0400     cTrkVarFrac[iTrkVar] -> SetBorderMode(fMode);
0401     cTrkVarFrac[iTrkVar] -> SetBorderSize(fBord);
0402     cTrkVarFrac[iTrkVar] -> SetFrameBorderMode(fFrame);
0403     cTrkVarFrac[iTrkVar] -> SetLeftMargin(fMarginL);
0404     cTrkVarFrac[iTrkVar] -> SetRightMargin(fMarginR1);
0405     cTrkVarFrac[iTrkVar] -> SetTopMargin(fMarginT);
0406     cTrkVarFrac[iTrkVar] -> SetBottomMargin(fMarginB);
0407     cTrkVarFrac[iTrkVar] -> cd();
0408     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0409       if (iToDraw == 0) {
0410         hTrkVarFrac[typesToDraw[iToDraw]][iTrkVar] -> Draw();
0411       } else {
0412         hTrkVarFrac[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
0413       }
0414     }  // end to-draw loop
0415     leg                  -> Draw();
0416     ptTxt                -> Draw();
0417     ptCut                -> Draw();
0418     cTrkVarFrac[iTrkVar] -> Write();
0419     cTrkVarFrac[iTrkVar] -> Close();
0420 
0421     // 2d track variables vs. ntpc
0422     cTrkVarVsNTpc[iTrkVar]    = new TCanvas(sTrkVarVsNTpc[iTrkVar].Data(), "", fWidth2P, fHeight2P);
0423     pTrkVarVsNTpc[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
0424     pTrkVarVsNTpc[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
0425     cTrkVarVsNTpc[iTrkVar]    -> SetGrid(fGrid, fGrid);
0426     cTrkVarVsNTpc[iTrkVar]    -> SetTicks(fTick, fTick);
0427     cTrkVarVsNTpc[iTrkVar]    -> SetBorderMode(fMode);
0428     cTrkVarVsNTpc[iTrkVar]    -> SetBorderSize(fBord);
0429     pTrkVarVsNTpc[iTrkVar][0] -> SetGrid(fGrid, fGrid);
0430     pTrkVarVsNTpc[iTrkVar][0] -> SetTicks(fTick, fTick);
0431     pTrkVarVsNTpc[iTrkVar][0] -> SetLogx(fLogX);
0432     pTrkVarVsNTpc[iTrkVar][0] -> SetLogy(fLogY);
0433     pTrkVarVsNTpc[iTrkVar][0] -> SetLogz(fLogZ);
0434     pTrkVarVsNTpc[iTrkVar][0] -> SetBorderMode(fMode);
0435     pTrkVarVsNTpc[iTrkVar][0] -> SetBorderSize(fBord);
0436     pTrkVarVsNTpc[iTrkVar][0] -> SetFrameBorderMode(fFrame);
0437     pTrkVarVsNTpc[iTrkVar][0] -> SetLeftMargin(fMarginL);
0438     pTrkVarVsNTpc[iTrkVar][0] -> SetRightMargin(fMarginR1);
0439     pTrkVarVsNTpc[iTrkVar][0] -> SetTopMargin(fMarginT);
0440     pTrkVarVsNTpc[iTrkVar][0] -> SetBottomMargin(fMarginB);
0441     pTrkVarVsNTpc[iTrkVar][1] -> SetGrid(fGrid, fGrid);
0442     pTrkVarVsNTpc[iTrkVar][1] -> SetTicks(fTick, fTick);
0443     pTrkVarVsNTpc[iTrkVar][1] -> SetLogx(fLogX);
0444     pTrkVarVsNTpc[iTrkVar][1] -> SetLogy(fLogY);
0445     pTrkVarVsNTpc[iTrkVar][1] -> SetLogz(fLogZ);
0446     pTrkVarVsNTpc[iTrkVar][1] -> SetBorderMode(fMode);
0447     pTrkVarVsNTpc[iTrkVar][1] -> SetBorderSize(fBord);
0448     pTrkVarVsNTpc[iTrkVar][1] -> SetFrameBorderMode(fFrame);
0449     pTrkVarVsNTpc[iTrkVar][1] -> SetLeftMargin(fMarginL);
0450     pTrkVarVsNTpc[iTrkVar][1] -> SetRightMargin(fMarginR2);
0451     pTrkVarVsNTpc[iTrkVar][1] -> SetTopMargin(fMarginT);
0452     pTrkVarVsNTpc[iTrkVar][1] -> SetBottomMargin(fMarginB);
0453     cTrkVarVsNTpc[iTrkVar]    -> cd();
0454     pTrkVarVsNTpc[iTrkVar][0] -> Draw();
0455     pTrkVarVsNTpc[iTrkVar][1] -> Draw();
0456     pTrkVarVsNTpc[iTrkVar][0] -> cd();
0457     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0458       if (iToDraw == 0) {
0459         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
0460       } else {
0461         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
0462       }
0463     }  // end to-draw loop
0464     leg                       -> Draw();
0465     ptTxt                     -> Draw();
0466     ptCut                     -> Draw();
0467     pTrkVarVsNTpc[iTrkVar][1] -> cd();
0468     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0469       if (iToDraw == 0) {
0470         hTrkVarVsNTpc[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
0471       } else {
0472         hTrkVarVsNTpc[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
0473       }
0474     }  // end to-draw loop
0475     cTrkVarVsNTpc[iTrkVar] -> Write();
0476     cTrkVarVsNTpc[iTrkVar] -> Close();
0477 
0478     // 2d track variables vs. dcaxy
0479     cTrkVarVsDcaXY[iTrkVar]    = new TCanvas(sTrkVarVsDcaXY[iTrkVar].Data(), "", fWidth2P, fHeight2P);
0480     pTrkVarVsDcaXY[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
0481     pTrkVarVsDcaXY[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
0482     cTrkVarVsDcaXY[iTrkVar]    -> SetGrid(fGrid, fGrid);
0483     cTrkVarVsDcaXY[iTrkVar]    -> SetTicks(fTick, fTick);
0484     cTrkVarVsDcaXY[iTrkVar]    -> SetBorderMode(fMode);
0485     cTrkVarVsDcaXY[iTrkVar]    -> SetBorderSize(fBord);
0486     pTrkVarVsDcaXY[iTrkVar][0] -> SetGrid(fGrid, fGrid);
0487     pTrkVarVsDcaXY[iTrkVar][0] -> SetTicks(fTick, fTick);
0488     pTrkVarVsDcaXY[iTrkVar][0] -> SetLogx(fLogX);
0489     pTrkVarVsDcaXY[iTrkVar][0] -> SetLogy(fLogY);
0490     pTrkVarVsDcaXY[iTrkVar][0] -> SetLogz(fLogZ);
0491     pTrkVarVsDcaXY[iTrkVar][0] -> SetBorderMode(fMode);
0492     pTrkVarVsDcaXY[iTrkVar][0] -> SetBorderSize(fBord);
0493     pTrkVarVsDcaXY[iTrkVar][0] -> SetFrameBorderMode(fFrame);
0494     pTrkVarVsDcaXY[iTrkVar][0] -> SetLeftMargin(fMarginL);
0495     pTrkVarVsDcaXY[iTrkVar][0] -> SetRightMargin(fMarginR1);
0496     pTrkVarVsDcaXY[iTrkVar][0] -> SetTopMargin(fMarginT);
0497     pTrkVarVsDcaXY[iTrkVar][0] -> SetBottomMargin(fMarginB);
0498     pTrkVarVsDcaXY[iTrkVar][1] -> SetGrid(fGrid, fGrid);
0499     pTrkVarVsDcaXY[iTrkVar][1] -> SetTicks(fTick, fTick);
0500     pTrkVarVsDcaXY[iTrkVar][1] -> SetLogx(fLogX);
0501     pTrkVarVsDcaXY[iTrkVar][1] -> SetLogy(fLogY);
0502     pTrkVarVsDcaXY[iTrkVar][1] -> SetLogz(fLogZ);
0503     pTrkVarVsDcaXY[iTrkVar][1] -> SetBorderMode(fMode);
0504     pTrkVarVsDcaXY[iTrkVar][1] -> SetBorderSize(fBord);
0505     pTrkVarVsDcaXY[iTrkVar][1] -> SetFrameBorderMode(fFrame);
0506     pTrkVarVsDcaXY[iTrkVar][1] -> SetLeftMargin(fMarginL);
0507     pTrkVarVsDcaXY[iTrkVar][1] -> SetRightMargin(fMarginR2);
0508     pTrkVarVsDcaXY[iTrkVar][1] -> SetTopMargin(fMarginT);
0509     pTrkVarVsDcaXY[iTrkVar][1] -> SetBottomMargin(fMarginB);
0510     cTrkVarVsDcaXY[iTrkVar]    -> cd();
0511     pTrkVarVsDcaXY[iTrkVar][0] -> Draw();
0512     pTrkVarVsDcaXY[iTrkVar][1] -> Draw();
0513     pTrkVarVsDcaXY[iTrkVar][0] -> cd();
0514     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0515       if (iToDraw == 0) {
0516         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
0517       } else {
0518         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
0519       }
0520     }  // end to-draw loop
0521     leg                        -> Draw();
0522     ptTxt                      -> Draw();
0523     ptCut                      -> Draw();
0524     pTrkVarVsDcaXY[iTrkVar][1] -> cd();
0525     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0526       if (iToDraw == 0) {
0527         hTrkVarVsDcaXY[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
0528       } else {
0529         hTrkVarVsDcaXY[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
0530       }
0531     }  // end to-draw loop
0532     cTrkVarVsDcaXY[iTrkVar] -> Write();
0533     cTrkVarVsDcaXY[iTrkVar] -> Close();
0534 
0535     // 2d track variables vs. dcaz
0536     cTrkVarVsDcaZ[iTrkVar]    = new TCanvas(sTrkVarVsDcaZ[iTrkVar].Data(), "", fWidth2P, fHeight2P);
0537     pTrkVarVsDcaZ[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
0538     pTrkVarVsDcaZ[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
0539     cTrkVarVsDcaZ[iTrkVar]    -> SetGrid(fGrid, fGrid);
0540     cTrkVarVsDcaZ[iTrkVar]    -> SetTicks(fTick, fTick);
0541     cTrkVarVsDcaZ[iTrkVar]    -> SetBorderMode(fMode);
0542     cTrkVarVsDcaZ[iTrkVar]    -> SetBorderSize(fBord);
0543     pTrkVarVsDcaZ[iTrkVar][0] -> SetGrid(fGrid, fGrid);
0544     pTrkVarVsDcaZ[iTrkVar][0] -> SetTicks(fTick, fTick);
0545     pTrkVarVsDcaZ[iTrkVar][0] -> SetLogx(fLogX);
0546     pTrkVarVsDcaZ[iTrkVar][0] -> SetLogy(fLogY);
0547     pTrkVarVsDcaZ[iTrkVar][0] -> SetLogz(fLogZ);
0548     pTrkVarVsDcaZ[iTrkVar][0] -> SetBorderMode(fMode);
0549     pTrkVarVsDcaZ[iTrkVar][0] -> SetBorderSize(fBord);
0550     pTrkVarVsDcaZ[iTrkVar][0] -> SetFrameBorderMode(fFrame);
0551     pTrkVarVsDcaZ[iTrkVar][0] -> SetLeftMargin(fMarginL);
0552     pTrkVarVsDcaZ[iTrkVar][0] -> SetRightMargin(fMarginR1);
0553     pTrkVarVsDcaZ[iTrkVar][0] -> SetTopMargin(fMarginT);
0554     pTrkVarVsDcaZ[iTrkVar][0] -> SetBottomMargin(fMarginB);
0555     pTrkVarVsDcaZ[iTrkVar][1] -> SetGrid(fGrid, fGrid);
0556     pTrkVarVsDcaZ[iTrkVar][1] -> SetTicks(fTick, fTick);
0557     pTrkVarVsDcaZ[iTrkVar][1] -> SetLogx(fLogX);
0558     pTrkVarVsDcaZ[iTrkVar][1] -> SetLogy(fLogY);
0559     pTrkVarVsDcaZ[iTrkVar][1] -> SetLogz(fLogZ);
0560     pTrkVarVsDcaZ[iTrkVar][1] -> SetBorderMode(fMode);
0561     pTrkVarVsDcaZ[iTrkVar][1] -> SetBorderSize(fBord);
0562     pTrkVarVsDcaZ[iTrkVar][1] -> SetFrameBorderMode(fFrame);
0563     pTrkVarVsDcaZ[iTrkVar][1] -> SetLeftMargin(fMarginL);
0564     pTrkVarVsDcaZ[iTrkVar][1] -> SetRightMargin(fMarginR2);
0565     pTrkVarVsDcaZ[iTrkVar][1] -> SetTopMargin(fMarginT);
0566     pTrkVarVsDcaZ[iTrkVar][1] -> SetBottomMargin(fMarginB);
0567     cTrkVarVsDcaZ[iTrkVar]    -> cd();
0568     pTrkVarVsDcaZ[iTrkVar][0] -> Draw();
0569     pTrkVarVsDcaZ[iTrkVar][1] -> Draw();
0570     pTrkVarVsDcaZ[iTrkVar][0] -> cd();
0571     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0572       if (iToDraw == 0) {
0573         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
0574       } else {
0575         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
0576       }
0577     }  // end to-draw loop
0578     leg                       -> Draw();
0579     ptTxt                     -> Draw();
0580     ptCut                     -> Draw();
0581     pTrkVarVsDcaZ[iTrkVar][1] -> cd();
0582     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0583       if (iToDraw == 0) {
0584         hTrkVarVsDcaZ[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
0585       } else {
0586         hTrkVarVsDcaZ[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
0587       }
0588     }  // end to-draw loop
0589     cTrkVarVsDcaZ[iTrkVar] -> Write();
0590     cTrkVarVsDcaZ[iTrkVar] -> Close();
0591 
0592     // 2d track variables vs. ptreco
0593     cTrkVarVsPtReco[iTrkVar]    = new TCanvas(sTrkVarVsPtReco[iTrkVar].Data(), "", fWidth2P, fHeight2P);
0594     pTrkVarVsPtReco[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
0595     pTrkVarVsPtReco[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
0596     cTrkVarVsPtReco[iTrkVar]    -> SetGrid(fGrid, fGrid);
0597     cTrkVarVsPtReco[iTrkVar]    -> SetTicks(fTick, fTick);
0598     cTrkVarVsPtReco[iTrkVar]    -> SetBorderMode(fMode);
0599     cTrkVarVsPtReco[iTrkVar]    -> SetBorderSize(fBord);
0600     pTrkVarVsPtReco[iTrkVar][0] -> SetGrid(fGrid, fGrid);
0601     pTrkVarVsPtReco[iTrkVar][0] -> SetTicks(fTick, fTick);
0602     pTrkVarVsPtReco[iTrkVar][0] -> SetLogx(fLogX);
0603     pTrkVarVsPtReco[iTrkVar][0] -> SetLogy(fLogY);
0604     pTrkVarVsPtReco[iTrkVar][0] -> SetLogz(fLogZ);
0605     pTrkVarVsPtReco[iTrkVar][0] -> SetBorderMode(fMode);
0606     pTrkVarVsPtReco[iTrkVar][0] -> SetBorderSize(fBord);
0607     pTrkVarVsPtReco[iTrkVar][0] -> SetFrameBorderMode(fFrame);
0608     pTrkVarVsPtReco[iTrkVar][0] -> SetLeftMargin(fMarginL);
0609     pTrkVarVsPtReco[iTrkVar][0] -> SetRightMargin(fMarginR1);
0610     pTrkVarVsPtReco[iTrkVar][0] -> SetTopMargin(fMarginT);
0611     pTrkVarVsPtReco[iTrkVar][0] -> SetBottomMargin(fMarginB);
0612     pTrkVarVsPtReco[iTrkVar][1] -> SetGrid(fGrid, fGrid);
0613     pTrkVarVsPtReco[iTrkVar][1] -> SetTicks(fTick, fTick);
0614     pTrkVarVsPtReco[iTrkVar][1] -> SetLogx(fLogX);
0615     pTrkVarVsPtReco[iTrkVar][1] -> SetLogy(fLogY);
0616     pTrkVarVsPtReco[iTrkVar][1] -> SetLogz(fLogZ);
0617     pTrkVarVsPtReco[iTrkVar][1] -> SetBorderMode(fMode);
0618     pTrkVarVsPtReco[iTrkVar][1] -> SetBorderSize(fBord);
0619     pTrkVarVsPtReco[iTrkVar][1] -> SetFrameBorderMode(fFrame);
0620     pTrkVarVsPtReco[iTrkVar][1] -> SetLeftMargin(fMarginL);
0621     pTrkVarVsPtReco[iTrkVar][1] -> SetRightMargin(fMarginR2);
0622     pTrkVarVsPtReco[iTrkVar][1] -> SetTopMargin(fMarginT);
0623     pTrkVarVsPtReco[iTrkVar][1] -> SetBottomMargin(fMarginB);
0624     cTrkVarVsPtReco[iTrkVar]    -> cd();
0625     pTrkVarVsPtReco[iTrkVar][0] -> Draw();
0626     pTrkVarVsPtReco[iTrkVar][1] -> Draw();
0627     pTrkVarVsPtReco[iTrkVar][0] -> cd();
0628     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0629       if (iToDraw == 0) {
0630         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
0631       } else {
0632         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
0633       }
0634     }  // end to-draw loop
0635     leg                         -> Draw();
0636     ptTxt                       -> Draw();
0637     ptCut                       -> Draw();
0638     pTrkVarVsPtReco[iTrkVar][1] -> cd();
0639     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0640       if (iToDraw == 0) {
0641         hTrkVarVsPtReco[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
0642       } else {
0643         hTrkVarVsPtReco[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
0644       }
0645     }  // end to-draw loop
0646     cTrkVarVsPtReco[iTrkVar] -> Write();
0647     cTrkVarVsPtReco[iTrkVar] -> Close();
0648 
0649     // 2d track variables vs. pttrue
0650     cTrkVarVsPtTrue[iTrkVar]    = new TCanvas(sTrkVarVsPtTrue[iTrkVar].Data(), "", fWidth2P, fHeight2P);
0651     pTrkVarVsPtTrue[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
0652     pTrkVarVsPtTrue[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
0653     cTrkVarVsPtTrue[iTrkVar]    -> SetGrid(fGrid, fGrid);
0654     cTrkVarVsPtTrue[iTrkVar]    -> SetTicks(fTick, fTick);
0655     cTrkVarVsPtTrue[iTrkVar]    -> SetBorderMode(fMode);
0656     cTrkVarVsPtTrue[iTrkVar]    -> SetBorderSize(fBord);
0657     pTrkVarVsPtTrue[iTrkVar][0] -> SetGrid(fGrid, fGrid);
0658     pTrkVarVsPtTrue[iTrkVar][0] -> SetTicks(fTick, fTick);
0659     pTrkVarVsPtTrue[iTrkVar][0] -> SetLogx(fLogX);
0660     pTrkVarVsPtTrue[iTrkVar][0] -> SetLogy(fLogY);
0661     pTrkVarVsPtTrue[iTrkVar][0] -> SetLogz(fLogZ);
0662     pTrkVarVsPtTrue[iTrkVar][0] -> SetBorderMode(fMode);
0663     pTrkVarVsPtTrue[iTrkVar][0] -> SetBorderSize(fBord);
0664     pTrkVarVsPtTrue[iTrkVar][0] -> SetFrameBorderMode(fFrame);
0665     pTrkVarVsPtTrue[iTrkVar][0] -> SetLeftMargin(fMarginL);
0666     pTrkVarVsPtTrue[iTrkVar][0] -> SetRightMargin(fMarginR1);
0667     pTrkVarVsPtTrue[iTrkVar][0] -> SetTopMargin(fMarginT);
0668     pTrkVarVsPtTrue[iTrkVar][0] -> SetBottomMargin(fMarginB);
0669     pTrkVarVsPtTrue[iTrkVar][1] -> SetGrid(fGrid, fGrid);
0670     pTrkVarVsPtTrue[iTrkVar][1] -> SetTicks(fTick, fTick);
0671     pTrkVarVsPtTrue[iTrkVar][1] -> SetLogx(fLogX);
0672     pTrkVarVsPtTrue[iTrkVar][1] -> SetLogy(fLogY);
0673     pTrkVarVsPtTrue[iTrkVar][1] -> SetLogz(fLogZ);
0674     pTrkVarVsPtTrue[iTrkVar][1] -> SetBorderMode(fMode);
0675     pTrkVarVsPtTrue[iTrkVar][1] -> SetBorderSize(fBord);
0676     pTrkVarVsPtTrue[iTrkVar][1] -> SetFrameBorderMode(fFrame);
0677     pTrkVarVsPtTrue[iTrkVar][1] -> SetLeftMargin(fMarginL);
0678     pTrkVarVsPtTrue[iTrkVar][1] -> SetRightMargin(fMarginR2);
0679     pTrkVarVsPtTrue[iTrkVar][1] -> SetTopMargin(fMarginT);
0680     pTrkVarVsPtTrue[iTrkVar][1] -> SetBottomMargin(fMarginB);
0681     cTrkVarVsPtTrue[iTrkVar]    -> cd();
0682     pTrkVarVsPtTrue[iTrkVar][0] -> Draw();
0683     pTrkVarVsPtTrue[iTrkVar][1] -> Draw();
0684     pTrkVarVsPtTrue[iTrkVar][0] -> cd();
0685     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0686       if (iToDraw == 0) {
0687         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
0688       } else {
0689         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
0690       }
0691     }  // end to-draw loop
0692     leg                         -> Draw();
0693     ptTxt                       -> Draw();
0694     ptCut                       -> Draw();
0695     pTrkVarVsPtTrue[iTrkVar][1] -> cd();
0696     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0697       if (iToDraw == 0) {
0698         hTrkVarVsPtTrue[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
0699       } else {
0700         hTrkVarVsPtTrue[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
0701       }
0702     }  // end to-draw loop
0703     cTrkVarVsPtTrue[iTrkVar] -> Write();
0704     cTrkVarVsPtTrue[iTrkVar] -> Close();
0705 
0706     // 2d track variables vs. pttrue
0707     cTrkVarVsPtFrac[iTrkVar]    = new TCanvas(sTrkVarVsPtFrac[iTrkVar].Data(), "", fWidth2P, fHeight2P);
0708     pTrkVarVsPtFrac[iTrkVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
0709     pTrkVarVsPtFrac[iTrkVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
0710     cTrkVarVsPtFrac[iTrkVar]    -> SetGrid(fGrid, fGrid);
0711     cTrkVarVsPtFrac[iTrkVar]    -> SetTicks(fTick, fTick);
0712     cTrkVarVsPtFrac[iTrkVar]    -> SetBorderMode(fMode);
0713     cTrkVarVsPtFrac[iTrkVar]    -> SetBorderSize(fBord);
0714     pTrkVarVsPtFrac[iTrkVar][0] -> SetGrid(fGrid, fGrid);
0715     pTrkVarVsPtFrac[iTrkVar][0] -> SetTicks(fTick, fTick);
0716     pTrkVarVsPtFrac[iTrkVar][0] -> SetLogx(fLogX);
0717     pTrkVarVsPtFrac[iTrkVar][0] -> SetLogy(fLogY);
0718     pTrkVarVsPtFrac[iTrkVar][0] -> SetLogz(fLogZ);
0719     pTrkVarVsPtFrac[iTrkVar][0] -> SetBorderMode(fMode);
0720     pTrkVarVsPtFrac[iTrkVar][0] -> SetBorderSize(fBord);
0721     pTrkVarVsPtFrac[iTrkVar][0] -> SetFrameBorderMode(fFrame);
0722     pTrkVarVsPtFrac[iTrkVar][0] -> SetLeftMargin(fMarginL);
0723     pTrkVarVsPtFrac[iTrkVar][0] -> SetRightMargin(fMarginR1);
0724     pTrkVarVsPtFrac[iTrkVar][0] -> SetTopMargin(fMarginT);
0725     pTrkVarVsPtFrac[iTrkVar][0] -> SetBottomMargin(fMarginB);
0726     pTrkVarVsPtFrac[iTrkVar][1] -> SetGrid(fGrid, fGrid);
0727     pTrkVarVsPtFrac[iTrkVar][1] -> SetTicks(fTick, fTick);
0728     pTrkVarVsPtFrac[iTrkVar][1] -> SetLogx(fLogX);
0729     pTrkVarVsPtFrac[iTrkVar][1] -> SetLogy(fLogY);
0730     pTrkVarVsPtFrac[iTrkVar][1] -> SetLogz(fLogZ);
0731     pTrkVarVsPtFrac[iTrkVar][1] -> SetBorderMode(fMode);
0732     pTrkVarVsPtFrac[iTrkVar][1] -> SetBorderSize(fBord);
0733     pTrkVarVsPtFrac[iTrkVar][1] -> SetFrameBorderMode(fFrame);
0734     pTrkVarVsPtFrac[iTrkVar][1] -> SetLeftMargin(fMarginL);
0735     pTrkVarVsPtFrac[iTrkVar][1] -> SetRightMargin(fMarginR2);
0736     pTrkVarVsPtFrac[iTrkVar][1] -> SetTopMargin(fMarginT);
0737     pTrkVarVsPtFrac[iTrkVar][1] -> SetBottomMargin(fMarginB);
0738     cTrkVarVsPtFrac[iTrkVar]    -> cd();
0739     pTrkVarVsPtFrac[iTrkVar][0] -> Draw();
0740     pTrkVarVsPtFrac[iTrkVar][1] -> Draw();
0741     pTrkVarVsPtFrac[iTrkVar][0] -> cd();
0742     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0743       if (iToDraw == 0) {
0744         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw();
0745       } else {
0746         hTrkVar[typesToDraw[iToDraw]][iTrkVar] -> Draw("same");
0747       }
0748     }  // end to-draw loop
0749     leg                         -> Draw();
0750     ptTxt                       -> Draw();
0751     ptCut                       -> Draw();
0752     pTrkVarVsPtFrac[iTrkVar][1] -> cd();
0753     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0754       if (iToDraw == 0) {
0755         hTrkVarVsPtFrac[typesToDraw[iToDraw]][iTrkVar] -> Draw("colz");
0756       } else {
0757         hTrkVarVsPtFrac[typesToDraw[iToDraw]][iTrkVar] -> Draw("scat same");
0758       }
0759     }  // end to-draw loop
0760     cTrkVarVsPtFrac[iTrkVar] -> Write();
0761     cTrkVarVsPtFrac[iTrkVar] -> Close();
0762   }  // end track variable loop
0763 
0764   // for physics-variable plots
0765   TCanvas *cPhysVar[NPhysVar];
0766   TCanvas *cPhysVarDiff[NPhysVar];
0767   TCanvas *cPhysVarFrac[NPhysVar];
0768   TCanvas *cPhysVarVsNTpc[NPhysVar];
0769   TCanvas *cPhysVarVsDcaXY[NPhysVar];
0770   TCanvas *cPhysVarVsDcaZ[NPhysVar];
0771   TCanvas *cPhysVarVsPtReco[NPhysVar];
0772   TCanvas *cPhysVarVsPtTrue[NPhysVar];
0773   TCanvas *cPhysVarVsPtFrac[NPhysVar];
0774   TPad    *pPhysVarVsNTpc[NPhysVar][NPanel];
0775   TPad    *pPhysVarVsDcaXY[NPhysVar][NPanel];
0776   TPad    *pPhysVarVsDcaZ[NPhysVar][NPanel];
0777   TPad    *pPhysVarVsPtReco[NPhysVar][NPanel];
0778   TPad    *pPhysVarVsPtTrue[NPhysVar][NPanel];
0779   TPad    *pPhysVarVsPtFrac[NPhysVar][NPanel];
0780   for (size_t iPhysVar = 0; iPhysVar < NPhysVar; iPhysVar++) {
0781 
0782     // 1d physics variable
0783     cPhysVar[iPhysVar] = new TCanvas(sPhysVar[iPhysVar].Data(), "", fWidth1P, fHeight1P);
0784     cPhysVar[iPhysVar] -> SetGrid(fGrid, fGrid);
0785     cPhysVar[iPhysVar] -> SetTicks(fTick, fTick);
0786     cPhysVar[iPhysVar] -> SetLogx(fLogX);
0787     cPhysVar[iPhysVar] -> SetLogy(fLogY);
0788     cPhysVar[iPhysVar] -> SetLogz(fLogZ);
0789     cPhysVar[iPhysVar] -> SetBorderMode(fMode);
0790     cPhysVar[iPhysVar] -> SetBorderSize(fBord);
0791     cPhysVar[iPhysVar] -> SetFrameBorderMode(fFrame);
0792     cPhysVar[iPhysVar] -> SetLeftMargin(fMarginL);
0793     cPhysVar[iPhysVar] -> SetRightMargin(fMarginR1);
0794     cPhysVar[iPhysVar] -> SetTopMargin(fMarginT);
0795     cPhysVar[iPhysVar] -> SetBottomMargin(fMarginB);
0796     cPhysVar[iPhysVar] -> cd();
0797     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0798       if (iToDraw == 0) {
0799         hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw();
0800       } else {
0801         hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
0802       }
0803     }  // end to-draw loop
0804     leg                -> Draw();
0805     ptTxt              -> Draw();
0806     ptCut              -> Draw();
0807     cPhysVar[iPhysVar] -> Write();
0808     cPhysVar[iPhysVar] -> Close();
0809 
0810     // 1d physics difference
0811     cPhysVarDiff[iPhysVar] = new TCanvas(sPhysVarDiff[iPhysVar].Data(), "", fWidth1P, fHeight1P);
0812     cPhysVarDiff[iPhysVar] -> SetGrid(fGrid, fGrid);
0813     cPhysVarDiff[iPhysVar] -> SetTicks(fTick, fTick);
0814     cPhysVarDiff[iPhysVar] -> SetLogx(fLogX);
0815     cPhysVarDiff[iPhysVar] -> SetLogy(fLogY);
0816     cPhysVarDiff[iPhysVar] -> SetLogz(fLogZ);
0817     cPhysVarDiff[iPhysVar] -> SetBorderMode(fMode);
0818     cPhysVarDiff[iPhysVar] -> SetBorderSize(fBord);
0819     cPhysVarDiff[iPhysVar] -> SetFrameBorderMode(fFrame);
0820     cPhysVarDiff[iPhysVar] -> SetLeftMargin(fMarginL);
0821     cPhysVarDiff[iPhysVar] -> SetRightMargin(fMarginR1);
0822     cPhysVarDiff[iPhysVar] -> SetTopMargin(fMarginT);
0823     cPhysVarDiff[iPhysVar] -> SetBottomMargin(fMarginB);
0824     cPhysVarDiff[iPhysVar] -> cd();
0825     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0826       if (iToDraw == 0) {
0827         hPhysVarDiff[typesToDraw[iToDraw]][iPhysVar] -> Draw();
0828       } else {
0829         hPhysVarDiff[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
0830       }
0831     }  // end to-draw loop
0832     leg                    -> Draw();
0833     ptTxt                  -> Draw();
0834     ptCut                  -> Draw();
0835     cPhysVarDiff[iPhysVar] -> Write();
0836     cPhysVarDiff[iPhysVar] -> Close();
0837 
0838     // 1d physics fraction
0839     cPhysVarFrac[iPhysVar] = new TCanvas(sPhysVarFrac[iPhysVar].Data(), "", fWidth1P, fHeight1P);
0840     cPhysVarFrac[iPhysVar] -> SetGrid(fGrid, fGrid);
0841     cPhysVarFrac[iPhysVar] -> SetTicks(fTick, fTick);
0842     cPhysVarFrac[iPhysVar] -> SetLogx(fLogX);
0843     cPhysVarFrac[iPhysVar] -> SetLogy(fLogY);
0844     cPhysVarFrac[iPhysVar] -> SetLogz(fLogZ);
0845     cPhysVarFrac[iPhysVar] -> SetBorderMode(fMode);
0846     cPhysVarFrac[iPhysVar] -> SetBorderSize(fBord);
0847     cPhysVarFrac[iPhysVar] -> SetFrameBorderMode(fFrame);
0848     cPhysVarFrac[iPhysVar] -> SetLeftMargin(fMarginL);
0849     cPhysVarFrac[iPhysVar] -> SetRightMargin(fMarginR1);
0850     cPhysVarFrac[iPhysVar] -> SetTopMargin(fMarginT);
0851     cPhysVarFrac[iPhysVar] -> SetBottomMargin(fMarginB);
0852     cPhysVarFrac[iPhysVar] -> cd();
0853     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0854       if (iToDraw == 0) {
0855         hPhysVarFrac[typesToDraw[iToDraw]][iPhysVar] -> Draw();
0856       } else {
0857         hPhysVarFrac[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
0858       }
0859     }  // end to-draw loop
0860     leg                    -> Draw();
0861     ptTxt                  -> Draw();
0862     ptCut                  -> Draw();
0863     cPhysVarFrac[iPhysVar] -> Write();
0864     cPhysVarFrac[iPhysVar] -> Close();
0865 
0866     // 2d physics variables vs. ntpc
0867     cPhysVarVsNTpc[iPhysVar]    = new TCanvas(sPhysVarVsNTpc[iPhysVar].Data(), "", fWidth2P, fHeight2P);
0868     pPhysVarVsNTpc[iPhysVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
0869     pPhysVarVsNTpc[iPhysVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
0870     cPhysVarVsNTpc[iPhysVar]    -> SetGrid(fGrid, fGrid);
0871     cPhysVarVsNTpc[iPhysVar]    -> SetTicks(fTick, fTick);
0872     cPhysVarVsNTpc[iPhysVar]    -> SetBorderMode(fMode);
0873     cPhysVarVsNTpc[iPhysVar]    -> SetBorderSize(fBord);
0874     pPhysVarVsNTpc[iPhysVar][0] -> SetGrid(fGrid, fGrid);
0875     pPhysVarVsNTpc[iPhysVar][0] -> SetTicks(fTick, fTick);
0876     pPhysVarVsNTpc[iPhysVar][0] -> SetLogx(fLogX);
0877     pPhysVarVsNTpc[iPhysVar][0] -> SetLogy(fLogY);
0878     pPhysVarVsNTpc[iPhysVar][0] -> SetLogz(fLogZ);
0879     pPhysVarVsNTpc[iPhysVar][0] -> SetBorderMode(fMode);
0880     pPhysVarVsNTpc[iPhysVar][0] -> SetBorderSize(fBord);
0881     pPhysVarVsNTpc[iPhysVar][0] -> SetFrameBorderMode(fFrame);
0882     pPhysVarVsNTpc[iPhysVar][0] -> SetLeftMargin(fMarginL);
0883     pPhysVarVsNTpc[iPhysVar][0] -> SetRightMargin(fMarginR1);
0884     pPhysVarVsNTpc[iPhysVar][0] -> SetTopMargin(fMarginT);
0885     pPhysVarVsNTpc[iPhysVar][0] -> SetBottomMargin(fMarginB);
0886     pPhysVarVsNTpc[iPhysVar][1] -> SetGrid(fGrid, fGrid);
0887     pPhysVarVsNTpc[iPhysVar][1] -> SetTicks(fTick, fTick);
0888     pPhysVarVsNTpc[iPhysVar][1] -> SetLogx(fLogX);
0889     pPhysVarVsNTpc[iPhysVar][1] -> SetLogy(fLogY);
0890     pPhysVarVsNTpc[iPhysVar][1] -> SetLogz(fLogZ);
0891     pPhysVarVsNTpc[iPhysVar][1] -> SetBorderMode(fMode);
0892     pPhysVarVsNTpc[iPhysVar][1] -> SetBorderSize(fBord);
0893     pPhysVarVsNTpc[iPhysVar][1] -> SetFrameBorderMode(fFrame);
0894     pPhysVarVsNTpc[iPhysVar][1] -> SetLeftMargin(fMarginL);
0895     pPhysVarVsNTpc[iPhysVar][1] -> SetRightMargin(fMarginR2);
0896     pPhysVarVsNTpc[iPhysVar][1] -> SetTopMargin(fMarginT);
0897     pPhysVarVsNTpc[iPhysVar][1] -> SetBottomMargin(fMarginB);
0898     cPhysVarVsNTpc[iPhysVar]    -> cd();
0899     pPhysVarVsNTpc[iPhysVar][0] -> Draw();
0900     pPhysVarVsNTpc[iPhysVar][1] -> Draw();
0901     pPhysVarVsNTpc[iPhysVar][0] -> cd();
0902     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0903       if (iToDraw == 0) {
0904         hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw();
0905       } else {
0906         hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
0907       }
0908     }  // end to-draw loop
0909     leg                         -> Draw();
0910     ptTxt                       -> Draw();
0911     ptCut                       -> Draw();
0912     pPhysVarVsNTpc[iPhysVar][1] -> cd();
0913     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0914       if (iToDraw == 0) {
0915         hPhysVarVsNTpc[typesToDraw[iToDraw]][iPhysVar] -> Draw("colz");
0916       } else {
0917         hPhysVarVsNTpc[typesToDraw[iToDraw]][iPhysVar] -> Draw("scat same");
0918       }
0919     }  // end to-draw loop
0920     cPhysVarVsNTpc[iPhysVar] -> Write();
0921     cPhysVarVsNTpc[iPhysVar] -> Close();
0922 
0923     // 2d physics variables vs. dcaxy
0924     cPhysVarVsDcaXY[iPhysVar]    = new TCanvas(sPhysVarVsDcaXY[iPhysVar].Data(), "", fWidth2P, fHeight2P);
0925     pPhysVarVsDcaXY[iPhysVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
0926     pPhysVarVsDcaXY[iPhysVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
0927     cPhysVarVsDcaXY[iPhysVar]    -> SetGrid(fGrid, fGrid);
0928     cPhysVarVsDcaXY[iPhysVar]    -> SetTicks(fTick, fTick);
0929     cPhysVarVsDcaXY[iPhysVar]    -> SetBorderMode(fMode);
0930     cPhysVarVsDcaXY[iPhysVar]    -> SetBorderSize(fBord);
0931     pPhysVarVsDcaXY[iPhysVar][0] -> SetGrid(fGrid, fGrid);
0932     pPhysVarVsDcaXY[iPhysVar][0] -> SetTicks(fTick, fTick);
0933     pPhysVarVsDcaXY[iPhysVar][0] -> SetLogx(fLogX);
0934     pPhysVarVsDcaXY[iPhysVar][0] -> SetLogy(fLogY);
0935     pPhysVarVsDcaXY[iPhysVar][0] -> SetLogz(fLogZ);
0936     pPhysVarVsDcaXY[iPhysVar][0] -> SetBorderMode(fMode);
0937     pPhysVarVsDcaXY[iPhysVar][0] -> SetBorderSize(fBord);
0938     pPhysVarVsDcaXY[iPhysVar][0] -> SetFrameBorderMode(fFrame);
0939     pPhysVarVsDcaXY[iPhysVar][0] -> SetLeftMargin(fMarginL);
0940     pPhysVarVsDcaXY[iPhysVar][0] -> SetRightMargin(fMarginR1);
0941     pPhysVarVsDcaXY[iPhysVar][0] -> SetTopMargin(fMarginT);
0942     pPhysVarVsDcaXY[iPhysVar][0] -> SetBottomMargin(fMarginB);
0943     pPhysVarVsDcaXY[iPhysVar][1] -> SetGrid(fGrid, fGrid);
0944     pPhysVarVsDcaXY[iPhysVar][1] -> SetTicks(fTick, fTick);
0945     pPhysVarVsDcaXY[iPhysVar][1] -> SetLogx(fLogX);
0946     pPhysVarVsDcaXY[iPhysVar][1] -> SetLogy(fLogY);
0947     pPhysVarVsDcaXY[iPhysVar][1] -> SetLogz(fLogZ);
0948     pPhysVarVsDcaXY[iPhysVar][1] -> SetBorderMode(fMode);
0949     pPhysVarVsDcaXY[iPhysVar][1] -> SetBorderSize(fBord);
0950     pPhysVarVsDcaXY[iPhysVar][1] -> SetFrameBorderMode(fFrame);
0951     pPhysVarVsDcaXY[iPhysVar][1] -> SetLeftMargin(fMarginL);
0952     pPhysVarVsDcaXY[iPhysVar][1] -> SetRightMargin(fMarginR2);
0953     pPhysVarVsDcaXY[iPhysVar][1] -> SetTopMargin(fMarginT);
0954     pPhysVarVsDcaXY[iPhysVar][1] -> SetBottomMargin(fMarginB);
0955     cPhysVarVsDcaXY[iPhysVar]    -> cd();
0956     pPhysVarVsDcaXY[iPhysVar][0] -> Draw();
0957     pPhysVarVsDcaXY[iPhysVar][1] -> Draw();
0958     pPhysVarVsDcaXY[iPhysVar][0] -> cd();
0959     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0960       if (iToDraw == 0) {
0961         hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw();
0962       } else {
0963         hPhysVar[typesToDraw[iToDraw]][iPhysVar] -> Draw("same");
0964       }
0965     }  // end to-draw loop
0966     leg                          -> Draw();
0967     ptTxt                        -> Draw();
0968     ptCut                        -> Draw();
0969     pPhysVarVsDcaXY[iPhysVar][1] -> cd();
0970     for (Ssiz_t iToDraw = 0; iToDraw < nToDraw; iToDraw++) {
0971       if (iToDraw == 0) {
0972         hPhysVarVsDcaXY[typesToDraw[iToDraw]][iPhysVar] -> Draw("colz");
0973       } else {
0974         hPhysVarVsDcaXY[typesToDraw[iToDraw]][iPhysVar] -> Draw("scat same");
0975       }
0976     }  // end to-draw loop
0977     cPhysVarVsDcaXY[iPhysVar] -> Write();
0978     cPhysVarVsDcaXY[iPhysVar] -> Close();
0979 
0980     // 2d physics variables vs. dcaz
0981     cPhysVarVsDcaZ[iPhysVar]    = new TCanvas(sPhysVarVsDcaZ[iPhysVar].Data(), "", fWidth2P, fHeight2P);
0982     pPhysVarVsDcaZ[iPhysVar][0] = new TPad(sOneVsTwoDimPanels[0].Data(), "", padXY[0][0], padXY[0][1], padXY[0][2], padXY[0][3]);
0983     pPhysVarVsDcaZ[iPhysVar][1] = new TPad(sOneVsTwoDimPanels[1].Data(), "", padXY[1][0], padXY[1][1], padXY[1][2], padXY[1][3]);
0984     cPhysVarVsDcaZ[iPhysVar]    -> SetGrid(fGrid, fGrid);
0985     cPhysVarVsDcaZ[iPhysVar]    -> SetTicks(fTick, fTick);
0986     cPhysVarVsDcaZ[iPhysVar]    -> SetBorderMode(fMode);
0987     cPhysVarVsDcaZ[iPhysVar]    -> SetBorderSize(fBord);
0988     pPhysVarVsDcaZ[iPhysVar][0] -> SetGrid(fGrid, fGrid);
0989     pPhysVarVsDcaZ[iPhysVar][0] -> SetTicks(fTick, fTick);
0990     pPhysVarVsDcaZ[iPhysVar][0] -> SetLogx(fLogX);
0991     pPhysVarVsDcaZ[iPhysVar][0] -> SetLogy(fLogY);
0992     pPhysVarVsDcaZ[iPhysVar][0] -> SetLogz(fLogZ);
0993     pPhysVarVsDcaZ[iPhysVar][0] -> SetBorderMode(fMode);
0994     pPhysVarVsDcaZ[iPhysVar][0] -> SetBorderSize(fBord);
0995     pPhysVarVsDcaZ[iPhysVar][0] -> SetFrameBorderMode(fFrame);
0996     pPhysVarVsDcaZ[iPhysVar][0] -> SetLeftMargin(fMarginL);
0997     pPhysVarVsDcaZ[iPhysVar][0] -> SetRightMargin(fMarginR1);
0998     pPhysVarVsDcaZ[iPhysVar][0] -> SetTopMargin(fMarginT);
0999     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 ------------------------------------------------------------------------
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!