PWGCF/EBYE/macros/drawBalanceFunction2DPsi.C

   1 const Int_t numberOfCentralityBins = 8;
   2 TString centralityArray[numberOfCentralityBins] = {"0-10","10-20","20-30","30-40","40-50","50-60","60-70","70-80"};
   3
   4 const Int_t gRebin = 1;
   5 void drawBalanceFunction2DPsi(const char* filename = "AnalysisResultsPsi.root",
   6                               Int_t gCentrality = 1,
   7                               Bool_t kShowShuffled = kFALSE,
   8                               Bool_t kShowMixed = kTRUE,
   9                               Double_t psiMin = -0.5, Double_t psiMax = 0.5,
  10                               Double_t ptTriggerMin = -1.,
  11                               Double_t ptTriggerMax = -1.,
  12                               Double_t ptAssociatedMin = -1.,
  13                               Double_t ptAssociatedMax = -1.) {
  14   //Macro that draws the BF distributions for each centrality bin
  15   //for reaction plane dependent analysis
  16   //Author: Panos.Christakoglou@nikhef.nl
  17   //Load the PWG2ebye library
  18   gSystem->Load("libANALYSIS.so");
  19   gSystem->Load("libANALYSISalice.so");
  20   gSystem->Load("libEventMixing.so");
  21   gSystem->Load("libCORRFW.so");
  22   gSystem->Load("libPWGTools.so");
  23   gSystem->Load("libPWGCFebye.so");
  24
  25   gROOT->LoadMacro("~/SetPlotStyle.C");
  26   SetPlotStyle();
  27   gStyle->SetPalette(1,0);
  28
  29   //Prepare the objects and return them
  30   TList *listBF = GetListOfObjects(filename,gCentrality,0);
  31   TList *listBFShuffled = NULL;
  32   if(kShowShuffled) listBFShuffled = GetListOfObjects(filename,gCentrality,1);
  33   TList *listBFMixed = NULL;
  34   if(kShowMixed) listBFMixed = GetListOfObjects(filename,gCentrality,2);
  35   if(!listBF) {
  36     Printf("The TList object was not created");
  37     return;
  38   }
  39   else
  40     draw(listBF,listBFShuffled,listBFMixed,gCentrality,psiMin,psiMax,
  41          ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
  42 }
  43
  44 //______________________________________________________//
  45 TList *GetListOfObjects(const char* filename,
  46                         Int_t gCentrality, Int_t kData = 1) {
  47   //Get the TList objects (QA, bf, bf shuffled)
  48   //kData == 0: data
  49   //kData == 1: shuffling
  50   //kData == 2: mixing
  51   TList *listQA = 0x0;
  52   TList *listBF = 0x0;
  53
  54   //Open the file
  55   TFile *f = TFile::Open(filename);
  56   if((!f)||(!f->IsOpen())) {
  57     Printf("The file %s is not found. Aborting...",filename);
  58     return listBF;
  59   }
  60   //f->ls();
  61
  62   TDirectoryFile *dir = dynamic_cast<TDirectoryFile *>(f->Get("PWGCFEbyE.outputBalanceFunctionPsiAnalysis"));
  63   if(!dir) {
  64     Printf("The TDirectoryFile is not found. Aborting...",filename);
  65     return listBF;
  66   }
  67   //dir->ls();
  68
  69   TString listBFName;
  70   if(kData == 0) {
  71     //cout<<"no shuffling - no mixing"<<endl;
  72     listBFName = "listBFPsi_";
  73   }
  74   else if(kData == 1) {
  75     //cout<<"shuffling - no mixing"<<endl;
  76     listBFName = "listBFPsiShuffled_";
  77   }
  78   else if(kData == 2) {
  79     //cout<<"no shuffling - mixing"<<endl;
  80     listBFName = "listBFPsiMixed_";
  81   }
  82   listBFName += centralityArray[gCentrality-1];
  83   listBF = dynamic_cast<TList *>(dir->Get(listBFName.Data()));
  84   cout<<"======================================================="<<endl;
  85   cout<<"List name: "<<listBF->GetName()<<endl;
  86   //listBF->ls();
  87
  88   //Get the histograms
  89   TString histoName;
  90   if(kData == 0)
  91     histoName = "fHistPV0M";
  92   else if(kData == 1)
  93     histoName = "fHistP_shuffleV0M";
  94   else if(kData == 2)
  95     histoName = "fHistPV0M";
  96   AliTHn *fHistP = dynamic_cast<AliTHn *>(listBF->FindObject(histoName.Data()));
  97   if(!fHistP) {
  98     Printf("fHistP %s not found!!!",histoName.Data());
  99     break;
 100   }
 101   fHistP->FillParent(); fHistP->DeleteContainers();
 102
 103   if(kData == 0)
 104     histoName = "fHistNV0M";
 105   if(kData == 1)
 106     histoName = "fHistN_shuffleV0M";
 107   if(kData == 2)
 108     histoName = "fHistNV0M";
 109   AliTHn *fHistN = dynamic_cast<AliTHn *>(listBF->FindObject(histoName.Data()));
 110   if(!fHistN) {
 111     Printf("fHistN %s not found!!!",histoName.Data());
 112     break;
 113   }
 114   fHistN->FillParent(); fHistN->DeleteContainers();
 115
 116   if(kData == 0)
 117     histoName = "fHistPNV0M";
 118   if(kData == 1)
 119     histoName = "fHistPN_shuffleV0M";
 120   if(kData == 2)
 121     histoName = "fHistPNV0M";
 122   AliTHn *fHistPN = dynamic_cast<AliTHn *>(listBF->FindObject(histoName.Data()));
 123   if(!fHistPN) {
 124     Printf("fHistPN %s not found!!!",histoName.Data());
 125     break;
 126   }
 127   fHistPN->FillParent(); fHistPN->DeleteContainers();
 128
 129   if(kData == 0)
 130     histoName = "fHistNPV0M";
 131   if(kData == 1)
 132     histoName = "fHistNP_shuffleV0M";
 133   if(kData == 2)
 134     histoName = "fHistNPV0M";
 135   AliTHn *fHistNP = dynamic_cast<AliTHn *>(listBF->FindObject(histoName.Data()));
 136   if(!fHistNP) {
 137     Printf("fHistNP %s not found!!!",histoName.Data());
 138     break;
 139   }
 140   fHistNP->FillParent(); fHistNP->DeleteContainers();
 141
 142   if(kData == 0)
 143     histoName = "fHistPPV0M";
 144   if(kData == 1)
 145     histoName = "fHistPP_shuffleV0M";
 146   if(kData == 2)
 147     histoName = "fHistPPV0M";
 148   AliTHn *fHistPP = dynamic_cast<AliTHn *>(listBF->FindObject(histoName.Data()));
 149   if(!fHistPP) {
 150     Printf("fHistPP %s not found!!!",histoName.Data());
 151     break;
 152   }
 153   fHistPP->FillParent(); fHistPP->DeleteContainers();
 154
 155   if(kData == 0)
 156     histoName = "fHistNNV0M";
 157   if(kData == 1)
 158     histoName = "fHistNN_shuffleV0M";
 159   if(kData == 2)
 160     histoName = "fHistNNV0M";
 161   AliTHn *fHistNN = dynamic_cast<AliTHn *>(listBF->FindObject(histoName.Data()));
 162   if(!fHistNN) {
 163     Printf("fHistNN %s not found!!!",histoName.Data());
 164     break;
 165   }
 166   fHistNN->FillParent(); fHistNN->DeleteContainers();
 167
 168   return listBF;
 169 }
 170
 171 //______________________________________________________//
 172 void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
 173           Int_t gCentrality, Double_t psiMin, Double_t psiMax,
 174           Double_t ptTriggerMin, Double_t ptTriggerMax,
 175           Double_t ptAssociatedMin, Double_t ptAssociatedMax) {
 176   //balance function
 177   AliTHn *hP = NULL;
 178   AliTHn *hN = NULL;
 179   AliTHn *hPN = NULL;
 180   AliTHn *hNP = NULL;
 181   AliTHn *hPP = NULL;
 182   AliTHn *hNN = NULL;
 183   //listBF->ls();
 184   //Printf("=================");
 185   hP = (AliTHn*) listBF->FindObject("fHistPV0M");
 186   hP->SetName("gHistP");
 187   hN = (AliTHn*) listBF->FindObject("fHistNV0M");
 188   hN->SetName("gHistN");
 189   hPN = (AliTHn*) listBF->FindObject("fHistPNV0M");
 190   hPN->SetName("gHistPN");
 191   hNP = (AliTHn*) listBF->FindObject("fHistNPV0M");
 192   hNP->SetName("gHistNP");
 193   hPP = (AliTHn*) listBF->FindObject("fHistPPV0M");
 194   hPP->SetName("gHistPP");
 195   hNN = (AliTHn*) listBF->FindObject("fHistNNV0M");
 196   hNN->SetName("gHistNN");
 197
 198   AliBalancePsi *b = new AliBalancePsi();
 199   b->SetHistNp(hP);
 200   b->SetHistNn(hN);
 201   b->SetHistNpn(hPN);
 202   b->SetHistNnp(hNP);
 203   b->SetHistNpp(hPP);
 204   b->SetHistNnn(hNN);
 205
 206   //balance function shuffling
 207   AliTHn *hPShuffled = NULL;
 208   AliTHn *hNShuffled = NULL;
 209   AliTHn *hPNShuffled = NULL;
 210   AliTHn *hNPShuffled = NULL;
 211   AliTHn *hPPShuffled = NULL;
 212   AliTHn *hNNShuffled = NULL;
 213   if(listBFShuffled) {
 214     //listBFShuffled->ls();
 215
 216     hPShuffled = (AliTHn*) listBFShuffled->FindObject("fHistP_shuffleV0M");
 217     hPShuffled->SetName("gHistPShuffled");
 218     hNShuffled = (AliTHn*) listBFShuffled->FindObject("fHistN_shuffleV0M");
 219     hNShuffled->SetName("gHistNShuffled");
 220     hPNShuffled = (AliTHn*) listBFShuffled->FindObject("fHistPN_shuffleV0M");
 221     hPNShuffled->SetName("gHistPNShuffled");
 222     hNPShuffled = (AliTHn*) listBFShuffled->FindObject("fHistNP_shuffleV0M");
 223     hNPShuffled->SetName("gHistNPShuffled");
 224     hPPShuffled = (AliTHn*) listBFShuffled->FindObject("fHistPP_shuffleV0M");
 225     hPPShuffled->SetName("gHistPPShuffled");
 226     hNNShuffled = (AliTHn*) listBFShuffled->FindObject("fHistNN_shuffleV0M");
 227     hNNShuffled->SetName("gHistNNShuffled");
 228
 229     AliBalancePsi *bShuffled = new AliBalancePsi();
 230     bShuffled->SetHistNp(hPShuffled);
 231     bShuffled->SetHistNn(hNShuffled);
 232     bShuffled->SetHistNpn(hPNShuffled);
 233     bShuffled->SetHistNnp(hNPShuffled);
 234     bShuffled->SetHistNpp(hPPShuffled);
 235     bShuffled->SetHistNnn(hNNShuffled);
 236   }
 237
 238   //balance function mixing
 239   AliTHn *hPMixed = NULL;
 240   AliTHn *hNMixed = NULL;
 241   AliTHn *hPNMixed = NULL;
 242   AliTHn *hNPMixed = NULL;
 243   AliTHn *hPPMixed = NULL;
 244   AliTHn *hNNMixed = NULL;
 245
 246   if(listBFMixed) {
 247     //listBFMixed->ls();
 248
 249     hPMixed = (AliTHn*) listBFMixed->FindObject("fHistPV0M");
 250     hPMixed->SetName("gHistPMixed");
 251     hNMixed = (AliTHn*) listBFMixed->FindObject("fHistNV0M");
 252     hNMixed->SetName("gHistNMixed");
 253     hPNMixed = (AliTHn*) listBFMixed->FindObject("fHistPNV0M");
 254     hPNMixed->SetName("gHistPNMixed");
 255     hNPMixed = (AliTHn*) listBFMixed->FindObject("fHistNPV0M");
 256     hNPMixed->SetName("gHistNPMixed");
 257     hPPMixed = (AliTHn*) listBFMixed->FindObject("fHistPPV0M");
 258     hPPMixed->SetName("gHistPPMixed");
 259     hNNMixed = (AliTHn*) listBFMixed->FindObject("fHistNNV0M");
 260     hNNMixed->SetName("gHistNNMixed");
 261
 262     AliBalancePsi *bMixed = new AliBalancePsi();
 263     bMixed->SetHistNp(hPMixed);
 264     bMixed->SetHistNn(hNMixed);
 265     bMixed->SetHistNpn(hPNMixed);
 266     bMixed->SetHistNnp(hNPMixed);
 267     bMixed->SetHistNpp(hPPMixed);
 268     bMixed->SetHistNnn(hNNMixed);
 269   }
 270
 271   TH2D *gHistBalanceFunction;
 272   TH2D *gHistBalanceFunctionSubtracted;
 273   TH2D *gHistBalanceFunctionShuffled;
 274   TH2D *gHistBalanceFunctionMixed;
 275   TString histoTitle, pngName;
 276
 277   histoTitle = "Centrality: ";
 278   histoTitle += centralityArray[gCentrality-1];
 279   histoTitle += "%";
 280   if((psiMin == -0.5)&&(psiMax == 0.5))
 281     histoTitle += " (-7.5^{o} < #varphi - #Psi_{2} < 7.5^{o})";
 282   else if((psiMin == 0.5)&&(psiMax == 1.5))
 283     histoTitle += " (37.5^{o} < #varphi - #Psi_{2} < 52.5^{o})";
 284   else if((psiMin == 1.5)&&(psiMax == 2.5))
 285     histoTitle += " (82.5^{o} < #varphi - #Psi_{2} < 97.5^{o})";
 286   else
 287     histoTitle += " (0^{o} < #varphi - #Psi_{2} < 180^{o})";
 288
 289   gHistBalanceFunction = b->GetBalanceFunctionDeltaEtaDeltaPhi(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
 290   gHistBalanceFunction->SetTitle(histoTitle.Data());
 291   gHistBalanceFunction->GetYaxis()->SetTitleOffset(1.3);
 292   gHistBalanceFunction->SetName("gHistBalanceFunction");
 293
 294   if(listBFShuffled) {
 295     gHistBalanceFunctionShuffled = bShuffled->GetBalanceFunctionDeltaEtaDeltaPhi(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
 296     gHistBalanceFunctionShuffled->SetTitle(histoTitle.Data());
 297     gHistBalanceFunctionShuffled->GetYaxis()->SetTitleOffset(1.3);
 298     gHistBalanceFunctionShuffled->SetName("gHistBalanceFunctionShuffled");
 299   }
 300
 301   if(listBFMixed) {
 302     gHistBalanceFunctionMixed = bMixed->GetBalanceFunctionDeltaEtaDeltaPhi(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
 303     gHistBalanceFunctionMixed->SetTitle(histoTitle.Data());
 304     gHistBalanceFunctionMixed->GetYaxis()->SetTitleOffset(1.3);
 305     gHistBalanceFunctionMixed->SetName("gHistBalanceFunctionMixed");
 306
 307     gHistBalanceFunctionSubtracted = dynamic_cast<TH2D *>(gHistBalanceFunction->Clone());
 308     gHistBalanceFunctionSubtracted->Add(gHistBalanceFunctionMixed,-1);
 309     gHistBalanceFunctionSubtracted->SetTitle(histoTitle.Data());
 310     gHistBalanceFunctionSubtracted->GetYaxis()->SetTitleOffset(1.3);
 311     gHistBalanceFunctionSubtracted->SetName("gHistBalanceFunctionSubtracted");
 312   }
 313
 314   //Draw the results
 315   TCanvas *c1 = new TCanvas("c1","",0,0,600,500);
 316   c1->SetFillColor(10);
 317   c1->SetHighLightColor(10);
 318   c1->SetLeftMargin(0.15);
 319   gHistBalanceFunction->DrawCopy("lego2");
 320   TCanvas *c1a = new TCanvas("c1a","",600,0,600,500);
 321   c1a->SetFillColor(10);
 322   c1a->SetHighLightColor(10);
 323   c1a->SetLeftMargin(0.15);
 324   gHistBalanceFunction->DrawCopy("colz");
 325
 326   if(listBFShuffled) {
 327     TCanvas *c2 = new TCanvas("c2","",100,100,600,500);
 328     c2->SetFillColor(10);
 329     c2->SetHighLightColor(10);
 330     c2->SetLeftMargin(0.15);
 331     gHistBalanceFunctionShuffled->DrawCopy("lego2");
 332     TCanvas *c2a = new TCanvas("c2a","",700,100,600,500);
 333     c2a->SetFillColor(10);
 334     c2a->SetHighLightColor(10);
 335     c2a->SetLeftMargin(0.15);
 336     gHistBalanceFunctionShuffled->DrawCopy("colz");
 337   }
 338
 339   if(listBFMixed) {
 340     TCanvas *c3 = new TCanvas("c3","",200,200,600,500);
 341     c3->SetFillColor(10);
 342     c3->SetHighLightColor(10);
 343     c3->SetLeftMargin(0.15);
 344     gHistBalanceFunctionMixed->DrawCopy("lego2");
 345     TCanvas *c3a = new TCanvas("c3a","",800,200,600,500);
 346     c3a->SetFillColor(10);
 347     c3a->SetHighLightColor(10);
 348     c3a->SetLeftMargin(0.15);
 349     gHistBalanceFunctionMixed->DrawCopy("colz");
 350
 351     TCanvas *c4 = new TCanvas("c4","",300,300,600,500);
 352     c4->SetFillColor(10);
 353     c4->SetHighLightColor(10);
 354     c4->SetLeftMargin(0.15);
 355     gHistBalanceFunctionSubtracted->DrawCopy("lego2");
 356     TCanvas *c4a = new TCanvas("c4a","",900,300,600,500);
 357     c4a->SetFillColor(10);
 358     c4a->SetHighLightColor(10);
 359     c4a->SetLeftMargin(0.15);
 360     gHistBalanceFunctionSubtracted->DrawCopy("colz");
 361   }
 362
 363   TString newFileName = "balanceFunction2D.Centrality";
 364   newFileName += gCentrality; newFileName += ".Psi";
 365   if((psiMin == -0.5)&&(psiMax == 0.5)) newFileName += "InPlane.Ptt";
 366   else if((psiMin == 0.5)&&(psiMax == 1.5)) newFileName += "Intermediate.Ptt";
 367   else if((psiMin == 1.5)&&(psiMax == 2.5)) newFileName += "OutOfPlane.Ptt";
 368   else if((psiMin == 2.5)&&(psiMax == 3.5)) newFileName += "Rest.PttFrom";
 369   else newFileName += "All.PttFrom";
 370   newFileName += Form("%.1f",ptTriggerMin); newFileName += "To";
 371   newFileName += Form("%.1f",ptTriggerMax); newFileName += "PtaFrom";
 372   newFileName += Form("%.1f",ptAssociatedMin); newFileName += "To";
 373   newFileName += Form("%.1f",ptAssociatedMax);
 374   newFileName += ".root";
 375
 376   TFile *fOutput = new TFile(newFileName.Data(),"recreate");
 377   fOutput->cd();
 378   /*hP->Write(); hN->Write();
 379   hPN->Write(); hNP->Write();
 380   hPP->Write(); hNN->Write();
 381   hPShuffled->Write(); hNShuffled->Write();
 382   hPNShuffled->Write(); hNPShuffled->Write();
 383   hPPShuffled->Write(); hNNShuffled->Write();
 384   hPMixed->Write(); hNMixed->Write();
 385   hPNMixed->Write(); hNPMixed->Write();
 386   hPPMixed->Write(); hNNMixed->Write();*/
 387   gHistBalanceFunction->Write();
 388   if(listBFShuffled) gHistBalanceFunctionShuffled->Write();
 389   if(listBFMixed) {
 390     gHistBalanceFunctionMixed->Write();
 391     gHistBalanceFunctionSubtracted->Write();
 392   }
 393   fOutput->Close();
 394 }
 395
 396 //____________________________________________________________//
 397 void drawBFPsi2D(const char* lhcPeriod = "LHC11h",
 398                  Int_t gCentrality = 1,
 399                  Bool_t kShowShuffled = kFALSE,
 400                  Bool_t kShowMixed = kFALSE,
 401                  Double_t psiMin = -0.5, Double_t psiMax = 0.5,
 402                  Double_t ptTriggerMin = -1.,
 403                  Double_t ptTriggerMax = -1.,
 404                  Double_t ptAssociatedMin = -1.,
 405                  Double_t ptAssociatedMax = -1.) {
 406   //Macro that draws the BF distributions for each centrality bin
 407   //for reaction plane dependent analysis
 408   //Author: Panos.Christakoglou@nikhef.nl
 409   TGaxis::SetMaxDigits(1);
 410
 411   //Get the input file
 412   TString filename = lhcPeriod; filename +="/PttFrom";
 413   filename += Form("%.1f",ptTriggerMin); filename += "To";
 414   filename += Form("%.1f",ptTriggerMax); filename += "PtaFrom";
 415   filename += Form("%.1f",ptAssociatedMin); filename += "To";
 416   filename += Form("%.1f",ptAssociatedMax);
 417   filename += "/balanceFunction2D.Centrality";
 418   filename += gCentrality; filename += ".Psi";
 419   if((psiMin == -0.5)&&(psiMax == 0.5)) filename += "InPlane.Ptt";
 420   else if((psiMin == 0.5)&&(psiMax == 1.5)) filename += "Intermediate.Ptt";
 421   else if((psiMin == 1.5)&&(psiMax == 2.5)) filename += "OutOfPlane.Ptt";
 422   else if((psiMin == 2.5)&&(psiMax == 3.5)) filename += "Rest.Ptt";
 423   else filename += "All.PttFrom";
 424   filename += Form("%.1f",ptTriggerMin); filename += "To";
 425   filename += Form("%.1f",ptTriggerMax); filename += ".PtaFrom";
 426   filename += Form("%.1f",ptAssociatedMin); filename += "To";
 427   filename += Form("%.1f",ptAssociatedMax);  filename += ".root";
 428
 429   //Open the file
 430   TFile *f = TFile::Open(filename.Data());
 431   if((!f)||(!f->IsOpen())) {
 432     Printf("The file %s is not found. Aborting...",filename);
 433     return listBF;
 434   }
 435   //f->ls();
 436
 437   //Raw balance function
 438   TH1D *gHistBalanceFunction = dynamic_cast<TH1D *>(f->Get("gHistBalanceFunction"));
 439   gHistBalanceFunction->SetStats(kFALSE);
 440   gHistBalanceFunction->GetXaxis()->SetNdivisions(10);
 441   gHistBalanceFunction->GetYaxis()->SetNdivisions(10);
 442   gHistBalanceFunction->GetZaxis()->SetNdivisions(10);
 443   gHistBalanceFunction->GetXaxis()->SetTitleOffset(1.3);
 444   gHistBalanceFunction->GetYaxis()->SetTitleOffset(1.3);
 445   gHistBalanceFunction->GetZaxis()->SetTitleOffset(1.3);
 446   gHistBalanceFunction->GetXaxis()->SetTitle("#Delta #eta");
 447   gHistBalanceFunction->GetYaxis()->SetTitle("#Delta #varphi (deg.)");
 448   gHistBalanceFunction->GetZaxis()->SetTitle("B(#Delta #eta, #Delta #varphi)");
 449
 450   //Shuffled balance function
 451   if(kShowShuffled) {
 452     TH1D *gHistBalanceFunctionShuffled = dynamic_cast<TH1D *>(f->Get("gHistBalanceFunctionShuffled"));
 453     gHistBalanceFunctionShuffled->SetStats(kFALSE);
 454     gHistBalanceFunctionShuffled->GetXaxis()->SetNdivisions(10);
 455     gHistBalanceFunctionShuffled->GetYaxis()->SetNdivisions(10);
 456     gHistBalanceFunctionShuffled->GetZaxis()->SetNdivisions(10);
 457     gHistBalanceFunctionShuffled->GetXaxis()->SetTitleOffset(1.3);
 458     gHistBalanceFunctionShuffled->GetYaxis()->SetTitleOffset(1.3);
 459     gHistBalanceFunctionShuffled->GetZaxis()->SetTitleOffset(1.3);
 460     gHistBalanceFunctionShuffled->GetXaxis()->SetTitle("#Delta #eta");
 461     gHistBalanceFunctionShuffled->GetYaxis()->SetTitle("#Delta #varphi (deg.)");
 462     gHistBalanceFunctionShuffled->GetZaxis()->SetTitle("B(#Delta #eta, #Delta #varphi)");
 463   }
 464
 465   //Mixed balance function
 466   if(kShowMixed) {
 467     TH1D *gHistBalanceFunctionMixed = dynamic_cast<TH1D *>(f->Get("gHistBalanceFunctionMixed"));
 468     gHistBalanceFunctionMixed->SetStats(kFALSE);
 469     gHistBalanceFunctionMixed->GetXaxis()->SetNdivisions(10);
 470     gHistBalanceFunctionMixed->GetYaxis()->SetNdivisions(10);
 471     gHistBalanceFunctionMixed->GetZaxis()->SetNdivisions(10);
 472     gHistBalanceFunctionMixed->GetXaxis()->SetTitleOffset(1.3);
 473     gHistBalanceFunctionMixed->GetYaxis()->SetTitleOffset(1.3);
 474     gHistBalanceFunctionMixed->GetZaxis()->SetTitleOffset(1.3);
 475     gHistBalanceFunctionMixed->GetXaxis()->SetTitle("#Delta #eta");
 476     gHistBalanceFunctionMixed->GetYaxis()->SetTitle("#Delta #varphi (deg.)");
 477     gHistBalanceFunctionMixed->GetZaxis()->SetTitle("B(#Delta #eta, #Delta #varphi)");
 478   }
 479
 480   //Subtracted balance function
 481   if(kShowMixed) {
 482     TH1D *gHistBalanceFunctionSubtracted = dynamic_cast<TH1D *>(f->Get("gHistBalanceFunctionSubtracted"));
 483     gHistBalanceFunctionSubtracted->SetStats(kFALSE);
 484     gHistBalanceFunctionSubtracted->GetXaxis()->SetNdivisions(10);
 485     gHistBalanceFunctionSubtracted->GetYaxis()->SetNdivisions(10);
 486     gHistBalanceFunctionSubtracted->GetZaxis()->SetNdivisions(10);
 487     gHistBalanceFunctionSubtracted->GetXaxis()->SetTitleOffset(1.3);
 488     gHistBalanceFunctionSubtracted->GetYaxis()->SetTitleOffset(1.3);
 489     gHistBalanceFunctionSubtracted->GetZaxis()->SetTitleOffset(1.3);
 490     gHistBalanceFunctionSubtracted->GetXaxis()->SetTitle("#Delta #eta");
 491     gHistBalanceFunctionSubtracted->GetYaxis()->SetTitle("#Delta #varphi (deg.)");
 492     gHistBalanceFunctionSubtracted->GetZaxis()->SetTitle("B(#Delta #eta, #Delta #varphi)");
 493   }
 494
 495   TString pngName;
 496
 497   TString centralityLatex = "Centrality: ";
 498   centralityLatex += centralityArray[gCentrality-1];
 499   centralityLatex += "%";
 500
 501   TString psiLatex;
 502   if((psiMin == -0.5)&&(psiMax == 0.5))
 503     psiLatex = " -7.5^{o} < #varphi - #Psi_{2} < 7.5^{o}";
 504   else if((psiMin == 0.5)&&(psiMax == 1.5))
 505     psiLatex = " 37.5^{o} < #varphi - #Psi_{2} < 52.5^{o}";
 506   else if((psiMin == 1.5)&&(psiMax == 2.5))
 507     psiLatex = " 82.5^{o} < #varphi - #Psi_{2} < 97.5^{o}";
 508   else
 509     psiLatex = " 0^{o} < #varphi - #Psi_{2} < 180^{o}";
 510
 511   TString pttLatex = Form("%.1f",ptTriggerMin);
 512   pttLatex += " < p_{T}^{t} < "; pttLatex += Form("%.1f",ptTriggerMax);
 513   pttLatex += " GeV/c";
 514
 515   TString ptaLatex = Form("%.1f",ptAssociatedMin);
 516   ptaLatex += " < p_{T}^{a} < "; ptaLatex += Form("%.1f",ptAssociatedMax);
 517   ptaLatex += " GeV/c";
 518
 519   TLatex *latexInfo1 = new TLatex();
 520   latexInfo1->SetNDC();
 521   latexInfo1->SetTextSize(0.045);
 522   latexInfo1->SetTextColor(1);
 523
 524   //Draw the results
 525   TCanvas *c1 = new TCanvas("c1","Raw balance function 2D",0,0,600,500);
 526   c1->SetFillColor(10); c1->SetHighLightColor(10);
 527   c1->SetLeftMargin(0.17); c1->SetTopMargin(0.05);
 528   gHistBalanceFunction->SetTitle("Raw balance function");
 529   gHistBalanceFunction->GetYaxis()->SetTitleOffset(1.4);
 530   gHistBalanceFunction->GetYaxis()->SetNdivisions(10);
 531   gHistBalanceFunction->GetXaxis()->SetNdivisions(10);
 532   gHistBalanceFunction->DrawCopy("lego2");
 533
 534   latexInfo1->DrawLatex(0.64,0.88,centralityLatex.Data());
 535   latexInfo1->DrawLatex(0.64,0.82,psiLatex.Data());
 536   latexInfo1->DrawLatex(0.64,0.76,pttLatex.Data());
 537   latexInfo1->DrawLatex(0.64,0.70,ptaLatex.Data());
 538
 539   if(kShowShuffled) {
 540     TCanvas *c2 = new TCanvas("c2","Shuffled balance function 2D",100,100,600,500);
 541     c2->SetFillColor(10); c2->SetHighLightColor(10);
 542     c2->SetLeftMargin(0.17); c2->SetTopMargin(0.05);
 543     gHistBalanceFunctionShuffled->SetTitle("Shuffled events");
 544     gHistBalanceFunctionShuffled->GetYaxis()->SetTitleOffset(1.4);
 545     gHistBalanceFunctionShuffled->GetYaxis()->SetNdivisions(10);
 546     gHistBalanceFunctionShuffled->GetXaxis()->SetNdivisions(10);
 547     gHistBalanceFunctionShuffled->DrawCopy("lego2");
 548
 549     latexInfo1->DrawLatex(0.64,0.88,centralityLatex.Data());
 550     latexInfo1->DrawLatex(0.64,0.82,psiLatex.Data());
 551     latexInfo1->DrawLatex(0.64,0.76,pttLatex.Data());
 552     latexInfo1->DrawLatex(0.64,0.70,ptaLatex.Data());
 553   }
 554
 555   if(kShowMixed) {
 556     TCanvas *c3 = new TCanvas("c3","Mixed balance function 2D",200,200,600,500);
 557     c3->SetFillColor(10); c3->SetHighLightColor(10);
 558     c3->SetLeftMargin(0.17); c3->SetTopMargin(0.05);
 559     gHistBalanceFunctionMixed->SetTitle("Mixed events");
 560     gHistBalanceFunctionMixed->GetYaxis()->SetTitleOffset(1.4);
 561     gHistBalanceFunctionMixed->GetYaxis()->SetNdivisions(10);
 562     gHistBalanceFunctionMixed->GetXaxis()->SetNdivisions(10);
 563     gHistBalanceFunctionMixed->DrawCopy("lego2");
 564
 565     latexInfo1->DrawLatex(0.64,0.88,centralityLatex.Data());
 566     latexInfo1->DrawLatex(0.64,0.82,psiLatex.Data());
 567     latexInfo1->DrawLatex(0.64,0.76,pttLatex.Data());
 568     latexInfo1->DrawLatex(0.64,0.70,ptaLatex.Data());
 569   }
 570
 571   if(kShowMixed) {
 572     TCanvas *c4 = new TCanvas("c4","Subtracted balance function 2D",300,300,600,500);
 573     c4->SetFillColor(10); c4->SetHighLightColor(10);
 574     c4->SetLeftMargin(0.17); c4->SetTopMargin(0.05);
 575     gHistBalanceFunctionSubtracted->SetTitle("Subtracted balance function");
 576     gHistBalanceFunctionSubtracted->GetYaxis()->SetTitleOffset(1.4);
 577     gHistBalanceFunctionSubtracted->GetYaxis()->SetNdivisions(10);
 578     gHistBalanceFunctionSubtracted->GetXaxis()->SetNdivisions(10);
 579     gHistBalanceFunctionSubtracted->DrawCopy("lego2");
 580
 581     latexInfo1->DrawLatex(0.64,0.88,centralityLatex.Data());
 582     latexInfo1->DrawLatex(0.64,0.82,psiLatex.Data());
 583     latexInfo1->DrawLatex(0.64,0.76,pttLatex.Data());
 584     latexInfo1->DrawLatex(0.64,0.70,ptaLatex.Data());
 585   }
 586 }