PWG3/hfe/AliHFEelecbackground.cxx

   1  /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15 //
  16 //
  17 // First implementation of a class
  18 // to reject tagged electron coming from conversion, pi0 and eta
  19 // by calculating the e+e- invariant mass
  20 // of the tagged electron with other tracks
  21 // after looser cuts for the partner.
  22 // PostProcess should extract the background yield
  23 // If running with MC, it can be compared to the expected background yield
  24 //
  25 // Authors:
  26 //   Raphaelle Bailhache <rbailhache@ikf.uni-frankfurt.de > <R.Bailhache@gsi.de >
  27 //
  28 //
  29
  30 #include <THnSparse.h>
  31 #include <TParticle.h>
  32 #include <TFile.h>
  33 #include <TCanvas.h>
  34 #include <TAxis.h>
  35 #include <TH1D.h>
  36 #include <TH2D.h>
  37 #include <TString.h>
  38 #include <TLegend.h>
  39
  40 #include <AliESDEvent.h>
  41 #include <AliAODEvent.h>
  42 #include <AliESDtrack.h>
  43 #include <AliAODTrack.h>
  44 #include "AliHFEelecbackground.h"
  45 #include <AliMCEvent.h>
  46 #include <AliStack.h>
  47
  48
  49 ClassImp(AliHFEelecbackground)
  50
  51 Bool_t AliHFEelecbackground::fgUseMCPID = kFALSE;
  52 const Double_t    AliHFEelecbackground::fgkMe = 0.00051099892;
  53
  54 //___________________________________________________________________________________________
  55 AliHFEelecbackground::AliHFEelecbackground():
  56   fESD1(0x0)
  57   ,fAOD1(0x0)
  58   ,fMCEvent(0x0)
  59   ,fBz(0)
  60   ,fkVertex(0x0)
  61   ,fPtESD(0.0)
  62   ,fIndexTrack(0)
  63   ,fPdg(0)
  64   ,fLabMother(-1)
  65   ,fIsFrom(-1)
  66   ,fMotherGamma(-1)
  67   ,fMotherPi0(-1)
  68   ,fMotherC(-1)
  69   ,fMotherB(-1)
  70   ,fMotherEta(-1)
  71   ,fIsPartner(kFALSE)
  72   ,fIsSplittedTrack(kFALSE)
  73   ,fList(0x0)
  74   ,fListPostProcess(0x0)
  75 {
  76   //
  77   // Default constructor
  78   //
  79
  80 }
  81
  82 //_______________________________________________________________________________________________
  83 AliHFEelecbackground::AliHFEelecbackground(const AliHFEelecbackground &p):
  84   TObject(p)
  85   ,fESD1(0x0)
  86   ,fAOD1(0x0)
  87   ,fMCEvent(0x0)
  88   ,fBz(p.fBz)
  89   ,fkVertex(p.fkVertex)
  90   ,fPtESD(p.fPtESD)
  91   ,fIndexTrack(0)
  92   ,fPdg(0)
  93   ,fLabMother(-1)
  94   ,fIsFrom(-1)
  95   ,fMotherGamma(-1)
  96   ,fMotherPi0(-1)
  97   ,fMotherC(-1)
  98   ,fMotherB(-1)
  99   ,fMotherEta(-1)
 100   ,fIsPartner(kFALSE)
 101   ,fIsSplittedTrack(kFALSE)
 102   ,fList(0x0)
 103   ,fListPostProcess(0x0)
 104 {
 105   //
 106   // Copy constructor
 107   //
 108 }
 109
 110 //_______________________________________________________________________________________________
 111 AliHFEelecbackground&
 112 AliHFEelecbackground::operator=(const AliHFEelecbackground &)
 113 {
 114   //
 115   // Assignment operator
 116   //
 117
 118   AliInfo("Not yet implemented.");
 119   return *this;
 120 }
 121
 122 //_______________________________________________________________________________________________
 123 AliHFEelecbackground::~AliHFEelecbackground()
 124 {
 125   //
 126   // Destructor
 127   //
 128
 129   if(fList){
 130     fList->Clear();
 131     delete fList;
 132   }
 133
 134   if(fListPostProcess){
 135     fListPostProcess->Clear();
 136     delete fListPostProcess;
 137   }
 138 }
 139 //___________________________________________________________________________________________
 140 Bool_t AliHFEelecbackground::Load(const Char_t *filename)
 141 {
 142   //
 143   // Generic container loader
 144   //
 145
 146   if(!TFile::Open(filename)){
 147     return kFALSE;
 148   }
 149   TList *o = 0x0;
 150   if(!(o = (TList*)gFile->Get("Results"))){
 151     return kFALSE;
 152   }
 153   TList *oe = 0x0;
 154   if(!(oe = (TList*)dynamic_cast<TList *>(o->FindObject("HFEelecbackground")))){
 155     return kFALSE;
 156   }
 157   fList = (TList*)oe->Clone("HFEelecbackground");
 158   gFile->Close();
 159   return kTRUE;
 160 }
 161 //_______________________________________________________________________________________________
 162 void AliHFEelecbackground::Reset()
 163 {
 164   //
 165   // Reset variables
 166   //
 167   fPtESD = 0.0;
 168   fIndexTrack = -1;
 169   fPdg = -1;
 170   fLabMother = -1;
 171   fIsFrom = -1;
 172   fMotherGamma = -1;
 173   fMotherPi0 = -1;
 174   fMotherC = -1;
 175   fMotherB = -1;
 176   fMotherEta = -1;
 177   fIsPartner = kFALSE;
 178   fIsSplittedTrack = kFALSE;
 179
 180 }
 181 //_______________________________________________________________________________________________
 182 void AliHFEelecbackground::CreateHistograms(TList* const qaList)
 183 {
 184   //
 185   // create histograms
 186   //
 187   if(!qaList) return;
 188
 189   fList = qaList;
 190   fList->SetName("HFEelecbackground");
 191
 192   // bins
 193
 194   Int_t nBinsPt = 25;
 195   Double_t minPt = 0.001;
 196   Double_t maxPt = 10.0;
 197
 198   Int_t nBinsInv = 50;
 199   Double_t minInv = 0.0;
 200   Double_t maxInv = 0.2;
 201
 202   Int_t nBinsOp = 50;
 203   Double_t minOp = 0.0;
 204   Double_t maxOp = 2;
 205
 206   Double_t *binLimLogPt = new Double_t[nBinsPt+1];
 207   Double_t *binLimPt    = new Double_t[nBinsPt+1];
 208   for(Int_t i=0; i<=nBinsPt; i++) binLimLogPt[i]=(Double_t)TMath::Log10(minPt) + (TMath::Log10(maxPt)-TMath::Log10(minPt))/nBinsPt*(Double_t)i ;
 209   for(Int_t i=0; i<=nBinsPt; i++) binLimPt[i]=(Double_t)TMath::Power(10,binLimLogPt[i]);
 210
 211   Double_t *binLimInv    = new Double_t[nBinsInv+1];
 212   for(Int_t i=0; i<=nBinsInv; i++) binLimInv[i]=(Double_t)minInv  + (maxInv-minInv)  /nBinsInv*(Double_t)i ;
 213
 214   Double_t *binLimOp    = new Double_t[nBinsOp+1];
 215   for(Int_t i=0; i<=nBinsOp; i++) binLimOp[i]=(Double_t)minOp  + (maxOp-minOp) /nBinsOp*(Double_t)i ;
 216
 217
 218   const Int_t nvarO = 3; // ptrectaggede, ptrecmother, openingangle or invmass
 219
 220   Int_t iBinOInv[nvarO];
 221   iBinOInv[0]=nBinsPt;
 222   iBinOInv[1]=nBinsPt;
 223   iBinOInv[2]=nBinsInv;
 224
 225   Int_t iBinOOp[nvarO];
 226   iBinOOp[0]=nBinsPt;
 227   iBinOOp[1]=nBinsPt;
 228   iBinOOp[2]=nBinsOp;
 229
 230   //
 231   //
 232   //
 233
 234   THnSparseF *openinganglepp = new THnSparseF("openinganglepp","",nvarO,iBinOOp);
 235   openinganglepp->SetBinEdges(0,binLimPt);
 236   openinganglepp->SetBinEdges(1,binLimPt);
 237   openinganglepp->SetBinEdges(2,binLimOp);
 238   openinganglepp->Sumw2();
 239
 240   THnSparseF *openinganglenn = new THnSparseF("openinganglenn","",nvarO,iBinOOp);
 241   openinganglenn->SetBinEdges(0,binLimPt);
 242   openinganglenn->SetBinEdges(1,binLimPt);
 243   openinganglenn->SetBinEdges(2,binLimOp);
 244   openinganglenn->Sumw2();
 245
 246   THnSparseF *openingangless = new THnSparseF("openingangless","",nvarO,iBinOOp);
 247   openingangless->SetBinEdges(0,binLimPt);
 248   openingangless->SetBinEdges(1,binLimPt);
 249   openingangless->SetBinEdges(2,binLimOp);
 250   openingangless->Sumw2();
 251
 252   THnSparseF *openingangler = new THnSparseF("openingangler","",nvarO,iBinOOp);
 253   openingangler->SetBinEdges(0,binLimPt);
 254   openingangler->SetBinEdges(1,binLimPt);
 255   openingangler->SetBinEdges(2,binLimOp);
 256   openingangler->Sumw2();
 257
 258   THnSparseF *openingangleos = new THnSparseF("openingangleos","",nvarO,iBinOOp);
 259   openingangleos->SetBinEdges(0,binLimPt);
 260   openingangleos->SetBinEdges(1,binLimPt);
 261   openingangleos->SetBinEdges(2,binLimOp);
 262   openingangleos->Sumw2();
 263
 264   THnSparseF *openinganglepi0=0x0;
 265   THnSparseF *openingangleeta=0x0;
 266   THnSparseF *openinganglegamma=0x0;
 267   THnSparseF *openingangleC=0x0;
 268   THnSparseF *openingangleB=0x0;
 269   THnSparseF *openingangleSplittedTrackss=0x0;
 270   THnSparseF *openingangleSplittedTrackos=0x0;
 271
 272   if(HasMCData()) {
 273
 274     openinganglepi0 = new THnSparseF("openinganglepi0","",nvarO,iBinOOp);
 275     openinganglepi0->SetBinEdges(0,binLimPt);
 276     openinganglepi0->SetBinEdges(1,binLimPt);
 277     openinganglepi0->SetBinEdges(2,binLimOp);
 278     openinganglepi0->Sumw2();
 279
 280     openingangleeta = new THnSparseF("openingangleeta","",nvarO,iBinOOp);
 281     openingangleeta->SetBinEdges(0,binLimPt);
 282     openingangleeta->SetBinEdges(1,binLimPt);
 283     openingangleeta->SetBinEdges(2,binLimOp);
 284     openingangleeta->Sumw2();
 285
 286     openinganglegamma = new THnSparseF("openinganglegamma","",nvarO,iBinOOp);
 287     openinganglegamma->SetBinEdges(0,binLimPt);
 288     openinganglegamma->SetBinEdges(1,binLimPt);
 289     openinganglegamma->SetBinEdges(2,binLimOp);
 290     openinganglegamma->Sumw2();
 291
 292     openingangleC = new THnSparseF("openingangleC","",nvarO,iBinOOp);
 293     openingangleC->SetBinEdges(0,binLimPt);
 294     openingangleC->SetBinEdges(1,binLimPt);
 295     openingangleC->SetBinEdges(2,binLimOp);
 296     openingangleC->Sumw2();
 297
 298     openingangleB = new THnSparseF("openingangleB","",nvarO,iBinOOp);
 299     openingangleB->SetBinEdges(0,binLimPt);
 300     openingangleB->SetBinEdges(1,binLimPt);
 301     openingangleB->SetBinEdges(2,binLimOp);
 302     openingangleB->Sumw2();
 303
 304     openingangleSplittedTrackss = new THnSparseF("openingangleSplittedTrackss","",nvarO,iBinOOp);
 305     openingangleSplittedTrackss->SetBinEdges(0,binLimPt);
 306     openingangleSplittedTrackss->SetBinEdges(1,binLimPt);
 307     openingangleSplittedTrackss->SetBinEdges(2,binLimOp);
 308     openingangleSplittedTrackss->Sumw2();
 309
 310     openingangleSplittedTrackos = new THnSparseF("openingangleSplittedTrackos","",nvarO,iBinOOp);
 311     openingangleSplittedTrackos->SetBinEdges(0,binLimPt);
 312     openingangleSplittedTrackos->SetBinEdges(1,binLimPt);
 313     openingangleSplittedTrackos->SetBinEdges(2,binLimOp);
 314     openingangleSplittedTrackos->Sumw2();
 315
 316   }
 317
 318   //
 319
 320   THnSparseF *invmasspp = new THnSparseF("invmasspp","",nvarO,iBinOInv);
 321   invmasspp->SetBinEdges(0,binLimPt);
 322   invmasspp->SetBinEdges(1,binLimPt);
 323   invmasspp->SetBinEdges(2,binLimInv);
 324   invmasspp->Sumw2();
 325
 326   THnSparseF *invmassnn = new THnSparseF("invmassnn","",nvarO,iBinOInv);
 327   invmassnn->SetBinEdges(0,binLimPt);
 328   invmassnn->SetBinEdges(1,binLimPt);
 329   invmassnn->SetBinEdges(2,binLimInv);
 330   invmassnn->Sumw2();
 331
 332   THnSparseF *invmassss = new THnSparseF("invmassss","",nvarO,iBinOInv);
 333   invmassss->SetBinEdges(0,binLimPt);
 334   invmassss->SetBinEdges(1,binLimPt);
 335   invmassss->SetBinEdges(2,binLimInv);
 336   invmassss->Sumw2();
 337
 338   THnSparseF *invmassr = new THnSparseF("invmassr","",nvarO,iBinOInv);
 339   invmassr->SetBinEdges(0,binLimPt);
 340   invmassr->SetBinEdges(1,binLimPt);
 341   invmassr->SetBinEdges(2,binLimInv);
 342   invmassr->Sumw2();
 343
 344   THnSparseF *invmassos = new THnSparseF("invmassos","",nvarO,iBinOInv);
 345   invmassos->SetBinEdges(0,binLimPt);
 346   invmassos->SetBinEdges(1,binLimPt);
 347   invmassos->SetBinEdges(2,binLimInv);
 348   invmassos->Sumw2();
 349
 350   THnSparseF *invmasspi0=0x0;
 351   THnSparseF *invmasseta=0x0;
 352   THnSparseF *invmassgamma=0x0;
 353   THnSparseF *invmassC=0x0;
 354   THnSparseF *invmassB=0x0;
 355   THnSparseF *invmassSplittedTrackss=0x0;
 356   THnSparseF *invmassSplittedTrackos=0x0;
 357
 358   if(HasMCData()) {
 359
 360     invmasspi0 = new THnSparseF("invmasspi0","",nvarO,iBinOInv);
 361     invmasspi0->SetBinEdges(0,binLimPt);
 362     invmasspi0->SetBinEdges(1,binLimPt);
 363     invmasspi0->SetBinEdges(2,binLimInv);
 364     invmasspi0->Sumw2();
 365
 366     invmasseta = new THnSparseF("invmasseta","",nvarO,iBinOInv);
 367     invmasseta->SetBinEdges(0,binLimPt);
 368     invmasseta->SetBinEdges(1,binLimPt);
 369     invmasseta->SetBinEdges(2,binLimInv);
 370     invmasseta->Sumw2();
 371
 372     invmassgamma = new THnSparseF("invmassgamma","",nvarO,iBinOInv);
 373     invmassgamma->SetBinEdges(0,binLimPt);
 374     invmassgamma->SetBinEdges(1,binLimPt);
 375     invmassgamma->SetBinEdges(2,binLimInv);
 376     invmassgamma->Sumw2();
 377
 378     invmassC = new THnSparseF("invmassC","",nvarO,iBinOInv);
 379     invmassC->SetBinEdges(0,binLimPt);
 380     invmassC->SetBinEdges(1,binLimPt);
 381     invmassC->SetBinEdges(2,binLimInv);
 382     invmassC->Sumw2();
 383
 384     invmassB = new THnSparseF("invmassB","",nvarO,iBinOInv);
 385     invmassB->SetBinEdges(0,binLimPt);
 386     invmassB->SetBinEdges(1,binLimPt);
 387     invmassB->SetBinEdges(2,binLimInv);
 388     invmassB->Sumw2();
 389
 390     invmassSplittedTrackss = new THnSparseF("invmassSplittedTrackss","",nvarO,iBinOInv);
 391     invmassSplittedTrackss->SetBinEdges(0,binLimPt);
 392     invmassSplittedTrackss->SetBinEdges(1,binLimPt);
 393     invmassSplittedTrackss->SetBinEdges(2,binLimInv);
 394     invmassSplittedTrackss->Sumw2();
 395
 396     invmassSplittedTrackos = new THnSparseF("invmassSplittedTrackos","",nvarO,iBinOInv);
 397     invmassSplittedTrackos->SetBinEdges(0,binLimPt);
 398     invmassSplittedTrackos->SetBinEdges(1,binLimPt);
 399     invmassSplittedTrackos->SetBinEdges(2,binLimInv);
 400     invmassSplittedTrackos->Sumw2();
 401
 402   }
 403
 404   //
 405   //
 406   //
 407
 408   fList->AddAt(openinganglepp,kPp);
 409   fList->AddAt(openinganglenn,kNn);
 410   fList->AddAt(openingangless,kSs);
 411   fList->AddAt(openingangler,kR);
 412   fList->AddAt(openingangleos,kOs);
 413
 414   fList->AddAt(invmasspp,kNSignComb+kPp);
 415   fList->AddAt(invmassnn,kNSignComb+kNn);
 416   fList->AddAt(invmassss,kNSignComb+kSs);
 417   fList->AddAt(invmassr,kNSignComb+kR);
 418   fList->AddAt(invmassos,kNSignComb+kOs);
 419
 420   if(HasMCData()) {
 421     fList->AddAt(openinganglegamma,2*kNSignComb+kElectronFromGamma);
 422     fList->AddAt(openinganglepi0,2*kNSignComb+kElectronFromPi0);
 423     fList->AddAt(openingangleC,2*kNSignComb+kElectronFromC);
 424     fList->AddAt(openingangleB,2*kNSignComb+kElectronFromB);
 425     fList->AddAt(openingangleeta,2*kNSignComb+kElectronFromEta);
 426     fList->AddAt(openingangleSplittedTrackss,2*kNSignComb+kSplittedTrackss);
 427     fList->AddAt(openingangleSplittedTrackos,2*kNSignComb+kSplittedTrackos);
 428
 429     fList->AddAt(invmassgamma,2*kNSignComb+kNMCInfo+kElectronFromGamma);
 430     fList->AddAt(invmasspi0,2*kNSignComb+kNMCInfo+kElectronFromPi0);
 431     fList->AddAt(invmassC,2*kNSignComb+kNMCInfo+kElectronFromC);
 432     fList->AddAt(invmassB,2*kNSignComb+kNMCInfo+kElectronFromB);
 433     fList->AddAt(invmasseta,2*kNSignComb+kNMCInfo+kElectronFromEta);
 434     fList->AddAt(invmassSplittedTrackss,2*kNSignComb+kNMCInfo+kSplittedTrackss);
 435     fList->AddAt(invmassSplittedTrackos,2*kNSignComb+kNMCInfo+kSplittedTrackos);
 436
 437   }
 438
 439 }
 440 //_______________________________________________________________________________________________
 441 void AliHFEelecbackground::PairAnalysis(AliESDtrack* const track, AliESDtrack* const trackPart)
 442 {
 443   //
 444   // calculate (tagged e-partner) dca, opening angle, invariant mass
 445   //
 446
 447   ////////////////////////
 448   // Partner track cut
 449   ////////////////////////
 450   if(!SingleTrackCut(trackPart)) return;
 451
 452   ////////////////////////
 453   // Take label
 454   ////////////////////////
 455   Int_t indexTrack = TMath::Abs(track->GetLabel());
 456   Int_t indexTrackPart = TMath::Abs(trackPart->GetLabel());
 457
 458   /////////////////////////
 459   // If MC data
 460   ////////////////////////
 461
 462   if(HasMCData()) {
 463
 464     // Take info track if not already done
 465     if(indexTrack!= fIndexTrack) {
 466
 467       fIsFrom = -1;
 468
 469       fPdg = GetPdg(indexTrack);
 470       fLabMother = GetLabMother(indexTrack);
 471
 472       fMotherGamma = IsMotherGamma(indexTrack);
 473       if((fMotherGamma != -1) && ((TMath::Abs(fPdg)) == 11)) fIsFrom = kElectronFromGamma;
 474       fMotherPi0 = IsMotherPi0(indexTrack);
 475       if((fMotherPi0 != -1) && ((TMath::Abs(fPdg)) == 11)) fIsFrom = kElectronFromPi0;
 476       fMotherC = IsMotherC(indexTrack);
 477       if((fMotherC != -1) && ((TMath::Abs(fPdg)) == 11)) fIsFrom = kElectronFromC;
 478       fMotherB = IsMotherB(indexTrack);
 479       if((fMotherB != -1) && ((TMath::Abs(fPdg)) == 11)) fIsFrom = kElectronFromB;
 480       fMotherEta = IsMotherEta(indexTrack);
 481       if((fMotherEta != -1) && ((TMath::Abs(fPdg)) == 11)) fIsFrom = kElectronFromEta;
 482
 483       fIndexTrack = indexTrack;
 484
 485     }
 486
 487     // MC PID for tagged
 488     if(fgUseMCPID) {
 489       if(TMath::Abs(fPdg) != 11) return;
 490     }
 491
 492     // Look at trackPart
 493     fIsPartner = kFALSE;
 494     Int_t pdgPart = GetPdg(indexTrackPart);
 495     if(TMath::Abs(pdgPart) == 11) {
 496       Int_t labMotherPart = GetLabMother(indexTrackPart);
 497       if((labMotherPart == fLabMother) && (indexTrack != indexTrackPart) && (TMath::Abs(fPdg) == 11) && (fPdg*pdgPart < 0) && (fLabMother >=0) && (fLabMother < (((AliStack *)fMCEvent->Stack())->GetNtrack()))) fIsPartner = kTRUE;
 498       // special case of c and b
 499       Int_t motherCPart = IsMotherC(indexTrackPart);
 500       if((motherCPart != -1) && (fIsFrom == kElectronFromC) && (fPdg*pdgPart < 0)){
 501         fIsPartner = kTRUE;
 502       }
 503       Int_t motherBPart = IsMotherB(indexTrackPart);
 504       if((motherBPart != -1) && (fIsFrom == kElectronFromB) && (fPdg*pdgPart < 0)){
 505         fIsPartner = kTRUE;
 506       }
 507     }
 508
 509     // Look at splitted tracks
 510     fIsSplittedTrack = kFALSE;
 511     if(indexTrackPart == fIndexTrack) fIsSplittedTrack = kTRUE;
 512
 513   }
 514
 515   //////////////////////
 516   // Sign
 517   /////////////////////
 518   Int_t sign = -1;
 519   if((track->Charge() > 0.0) && (trackPart->Charge() > 0.0)) sign = kPp;
 520   if((track->Charge() < 0.0) && (trackPart->Charge() < 0.0)) sign = kNn;
 521   if(((track->Charge() > 0.0) && (trackPart->Charge() < 0.0)) || ((track->Charge() < 0.0) && (trackPart->Charge() > 0.0))) sign = kOs;
 522
 523   //////////////////////
 524   // DCA
 525   /////////////////////
 526
 527   Double_t xthis,xp;
 528   Double_t dca = track->GetDCA(trackPart,fBz,xthis,xp);
 529   if(TMath::Abs(dca) > 3.0) return;
 530
 531   /////////////////////////////
 532   // Propagate
 533   ////////////////////////////
 534
 535   Double_t norradius = TMath::Sqrt(fkVertex->GetX()*fkVertex->GetX()+fkVertex->GetY()*fkVertex->GetY());
 536
 537   AliESDtrack *trackCopy = new AliESDtrack(*track);
 538   AliESDtrack *trackPartCopy = new AliESDtrack(*trackPart);
 539   Bool_t propagateok = kTRUE;
 540   if((!(trackPartCopy->PropagateTo(norradius,fBz))) || (!(trackCopy->PropagateTo(norradius,fBz)))) propagateok = kFALSE;
 541   if(!propagateok) {
 542     if(trackCopy) delete trackCopy;
 543     if(trackPartCopy) delete trackPartCopy;
 544     return;
 545   }
 546
 547   ///////////////////////////////////
 548   // Calcul mother variables
 549   ///////////////////////////////////
 550   Double_t results[5];
 551   Double_t resultsr[5];
 552
 553   CalculateMotherVariable(trackCopy,trackPartCopy,&results[0]);
 554   CalculateMotherVariableR(trackCopy,trackPartCopy,&resultsr[0]);
 555
 556   /////////////////////////////////////
 557   // Fill
 558   /////////////////////////////////////
 559
 560   FillOutput(results, resultsr, sign);
 561
 562   if(trackCopy) delete trackCopy;
 563   if(trackPartCopy) delete trackPartCopy;
 564
 565 }
 566 //_____________________________________________________________________________________
 567 void AliHFEelecbackground::CalculateMotherVariable(AliESDtrack* const track, AliESDtrack* const trackpart, Double_t *results)
 568 {
 569   //
 570   // variables mother and take the pt of the track
 571   //
 572   // results contain: ptmother, invmass, etamother, phimother, openingangle
 573   //
 574
 575   TVector3 v3Dtagged;
 576   TVector3 v3Dpart;
 577
 578   Double_t *pxyz = new Double_t[3];
 579   track->PxPyPz(pxyz);
 580   v3Dtagged.SetXYZ(pxyz[0],pxyz[1],pxyz[2]);
 581   fPtESD = TMath::Sqrt(pxyz[0]*pxyz[0]+pxyz[1]*pxyz[1]);
 582
 583   Double_t *pxyzpart = new Double_t[3];
 584   trackpart->PxPyPz(pxyzpart);
 585   v3Dpart.SetXYZ(pxyzpart[0],pxyzpart[1],pxyzpart[2]);
 586
 587
 588
 589   TVector3 motherrec = v3Dtagged + v3Dpart;
 590
 591   Double_t etaESDmother = motherrec.Eta();
 592   Double_t ptESDmother  = motherrec.Pt();
 593   Double_t phiESDmother = motherrec.Phi();
 594   if(phiESDmother > TMath::Pi()) phiESDmother = phiESDmother - (2*TMath::Pi());
 595
 596
 597   // openinganglepropagated
 598   Double_t openingangle = v3Dtagged.Angle(v3Dpart);
 599
 600   // invmass
 601   Double_t pESD      = TMath::Sqrt(pxyz[0]*pxyz[0]+pxyz[1]*pxyz[1]+pxyz[2]*pxyz[2]);
 602   Double_t pESDpart  = TMath::Sqrt(pxyzpart[0]*pxyzpart[0]+pxyzpart[1]*pxyzpart[1]+pxyzpart[2]*pxyzpart[2]);
 603
 604   // e propagate
 605   Double_t eESD     = TMath::Sqrt(pESD*pESD+fgkMe*fgkMe);
 606   Double_t eESDpart = TMath::Sqrt(pESDpart*pESDpart+fgkMe*fgkMe);
 607
 608   Double_t invmass = TMath::Sqrt((eESD+eESDpart)*(eESD+eESDpart)-(motherrec.Px()*motherrec.Px()+motherrec.Py()*motherrec.Py()+motherrec.Pz()*motherrec.Pz()));
 609
 610   if(!results) {
 611     results = new Double_t[5];
 612   }
 613   results[0] = ptESDmother;
 614   results[1] = etaESDmother;
 615   results[2] = phiESDmother;
 616   results[3] = invmass;
 617   results[4] = openingangle;
 618
 619 }
 620 //_____________________________________________________________________________________
 621 void AliHFEelecbackground::CalculateMotherVariableR(AliESDtrack* const track, AliESDtrack* const trackpart, Double_t *results)
 622 {
 623   //
 624   // variables mother
 625   //
 626   // results contain: ptmother, invmass, etamother, phimother, openingangle
 627   //
 628
 629   TVector3 v3Dtagged;
 630   TVector3 v3Dpart;
 631
 632   Double_t *pxyz = new Double_t[3];
 633   track->PxPyPz(pxyz);
 634   v3Dtagged.SetXYZ(pxyz[0],pxyz[1],pxyz[2]);
 635   Double_t *pxyzpart = new Double_t[3];
 636   trackpart->PxPyPz(pxyzpart);
 637   v3Dpart.SetXYZ(pxyzpart[0],pxyzpart[1],pxyzpart[2]);
 638
 639   // rotate the partner
 640   v3Dpart.RotateZ(TMath::Pi());
 641   v3Dpart.GetXYZ(pxyzpart);
 642
 643
 644   TVector3 motherrec = v3Dtagged + v3Dpart;
 645
 646   Double_t etaESDmother = motherrec.Eta();
 647   Double_t ptESDmother  = motherrec.Pt();
 648   Double_t phiESDmother = motherrec.Phi();
 649   if(phiESDmother > TMath::Pi()) phiESDmother = phiESDmother - (2*TMath::Pi());
 650
 651
 652   // openinganglepropagated
 653   Double_t openingangle = v3Dtagged.Angle(v3Dpart);
 654   //printf("Openingangle %f\n",openingangle);
 655
 656   // invmass
 657   Double_t pESD      = TMath::Sqrt(pxyz[0]*pxyz[0]+pxyz[1]*pxyz[1]+pxyz[2]*pxyz[2]);
 658   Double_t pESDpart  = TMath::Sqrt(pxyzpart[0]*pxyzpart[0]+pxyzpart[1]*pxyzpart[1]+pxyzpart[2]*pxyzpart[2]);
 659   // e propagate
 660   Double_t eESD     = TMath::Sqrt(pESD*pESD+fgkMe*fgkMe);
 661   Double_t eESDpart = TMath::Sqrt(pESDpart*pESDpart+fgkMe*fgkMe);
 662
 663   Double_t invmass = TMath::Sqrt((eESD+eESDpart)*(eESD+eESDpart)-(motherrec.Px()*motherrec.Px()+motherrec.Py()*motherrec.Py()+motherrec.Pz()*motherrec.Pz()));
 664
 665   if(!results) {
 666     results = new Double_t[5];
 667   }
 668   results[0] = ptESDmother;
 669   results[1] = etaESDmother;
 670   results[2] = phiESDmother;
 671   results[3] = invmass;
 672   results[4] = openingangle;
 673
 674
 675 }
 676 //_________________________________________________________________________________
 677 void AliHFEelecbackground::FillOutput(Double_t *results, Double_t *resultsr, Int_t sign)
 678 {
 679   //
 680   // Fill the invariant mass and opening angle distributions
 681   //
 682
 683   Double_t co[3];
 684   co[0] = fPtESD;
 685
 686   switch(sign){
 687
 688       case kPp:
 689         co[1] = results[0];
 690         co[2] = TMath::Abs(results[4]);
 691         (dynamic_cast<THnSparseF *>(fList->At(kPp)))->Fill(co);
 692         (dynamic_cast<THnSparseF *>(fList->At(kSs)))->Fill(co);
 693         if(HasMCData()){
 694           if(fIsSplittedTrack) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kSplittedTrackss)))->Fill(co);
 695         }
 696
 697
 698         co[2] = results[3];
 699         if(TMath::Abs(results[4]) < 0.8){
 700           (dynamic_cast<THnSparseF *>(fList->At(kPp+kNSignComb)))->Fill(co);
 701           (dynamic_cast<THnSparseF *>(fList->At(kSs+kNSignComb)))->Fill(co);
 702           if(HasMCData()){
 703             if(fIsSplittedTrack) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kSplittedTrackss+kNMCInfo)))->Fill(co);
 704           }
 705         }
 706
 707         break;
 708
 709       case kNn:
 710         co[1] = results[0];
 711         co[2] = TMath::Abs(results[4]);
 712         (dynamic_cast<THnSparseF *>(fList->At(kNn)))->Fill(co);
 713         (dynamic_cast<THnSparseF *>(fList->At(kSs)))->Fill(co);
 714         if(HasMCData()){
 715           if(fIsSplittedTrack) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kSplittedTrackss)))->Fill(co);
 716         }
 717
 718         co[2] = results[3];
 719         if(TMath::Abs(results[4]) < 0.8){
 720           (dynamic_cast<THnSparseF *>(fList->At(kNn+kNSignComb)))->Fill(co);
 721           (dynamic_cast<THnSparseF *>(fList->At(kSs+kNSignComb)))->Fill(co);
 722           if(HasMCData()){
 723             if(fIsSplittedTrack) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kSplittedTrackss+kNMCInfo)))->Fill(co);
 724           }
 725         }
 726         break;
 727
 728       case kOs:
 729         co[1] = results[0];
 730         co[2] = TMath::Abs(results[4]);
 731         (dynamic_cast<THnSparseF *>(fList->At(kOs)))->Fill(co);
 732         if(HasMCData()) {
 733           if((fIsFrom == kElectronFromPi0) && (fIsPartner)) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kElectronFromPi0)))->Fill(co);
 734           if((fIsFrom == kElectronFromEta) && (fIsPartner)) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kElectronFromEta)))->Fill(co);
 735           if((fIsFrom == kElectronFromGamma) && (fIsPartner)) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kElectronFromGamma)))->Fill(co);
 736           if((fIsFrom == kElectronFromC) && (fIsPartner)) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kElectronFromC)))->Fill(co);
 737           if((fIsFrom == kElectronFromB) && (fIsPartner)) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kElectronFromB)))->Fill(co);
 738           if(fIsSplittedTrack) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kSplittedTrackos)))->Fill(co);
 739         }
 740
 741         co[2] = results[3];
 742         if(TMath::Abs(results[4]) < 0.8){
 743           (dynamic_cast<THnSparseF *>(fList->At(kOs+kNSignComb)))->Fill(co);
 744           if(HasMCData()) {
 745             if((fIsFrom == kElectronFromPi0) && (fIsPartner)) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kElectronFromPi0+kNMCInfo)))->Fill(co);
 746             if((fIsFrom == kElectronFromEta) && (fIsPartner)) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kElectronFromEta+kNMCInfo)))->Fill(co);
 747             if((fIsFrom == kElectronFromGamma) && (fIsPartner)) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kElectronFromGamma+kNMCInfo)))->Fill(co);
 748             if((fIsFrom == kElectronFromC) && (fIsPartner)) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kElectronFromC+kNMCInfo)))->Fill(co);
 749             if((fIsFrom == kElectronFromB) && (fIsPartner)) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kElectronFromB+kNMCInfo)))->Fill(co);
 750             if(fIsSplittedTrack) (dynamic_cast<THnSparseF *>(fList->At(2*kNSignComb+kSplittedTrackos+kNMCInfo)))->Fill(co);
 751           }
 752         }
 753
 754         // rotated
 755         co[1] = resultsr[0];
 756         co[2] = TMath::Abs(resultsr[4]);
 757
 758         (dynamic_cast<THnSparseF *>(fList->At(kR)))->Fill(co);
 759
 760         co[2] = resultsr[3];
 761         if(TMath::Abs(resultsr[4]) < 0.8){
 762           (dynamic_cast<THnSparseF *>(fList->At(kR+kNSignComb)))->Fill(co);
 763         }
 764         break;
 765
 766   default:
 767
 768     break;
 769
 770   }
 771 }
 772 //_______________________________________________________________________________________________
 773 Bool_t AliHFEelecbackground::SingleTrackCut(AliESDtrack* const track) const
 774 {
 775   //
 776   // Return minimum quality for the partner
 777   //
 778
 779   //if(track->GetKinkIndex(0)>0) return kFALSE;
 780
 781   UInt_t status = track->GetStatus();
 782
 783   if(((status & AliESDtrack::kTPCin)==0) && (status & AliESDtrack::kITSin)) {
 784
 785     Int_t nbcl = track->GetITSclusters(0);
 786     if(nbcl > 1) return kTRUE;
 787     else return kFALSE;
 788
 789   }
 790
 791   if(status & AliESDtrack::kTPCin) {
 792
 793     if(status & AliESDtrack::kTPCrefit)  return kTRUE;
 794     else return kFALSE;
 795
 796   }
 797
 798   return kFALSE;
 799
 800 }
 801 //______________________________________________________________________________________________
 802 void AliHFEelecbackground::SetEvent(AliESDEvent* const ESD)
 803 {
 804   //
 805   // Set the AliESD Event, the magnetic field and the primary vertex
 806   //
 807
 808   fESD1=ESD;
 809   fBz=fESD1->GetMagneticField();
 810   fkVertex = fESD1->GetPrimaryVertex();
 811
 812 }
 813 //____________________________________________________________________________________________________________
 814 Int_t AliHFEelecbackground::IsMotherGamma(Int_t tr) {
 815
 816   //
 817   // Return the lab of gamma mother or -1 if not gamma
 818   //
 819
 820   AliStack* stack = fMCEvent->Stack();
 821   if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
 822
 823   // Take mother
 824   TParticle * particle = stack->Particle(tr);
 825   if(!particle) return -1;
 826   Int_t imother   = particle->GetFirstMother();
 827   if((imother < 0) || (imother >= stack->GetNtrack())) return -1;
 828   TParticle * mother = stack->Particle(imother);
 829   if(!mother) return -1;
 830
 831   // Check gamma
 832   Int_t pdg = mother->GetPdgCode();
 833   if(TMath::Abs(pdg) == 22) return imother;
 834   if(TMath::Abs(pdg) == 11) {
 835     return IsMotherGamma(imother);
 836   }
 837   return -1;
 838
 839 }
 840 //
 841 //____________________________________________________________________________________________________________
 842 Int_t AliHFEelecbackground::IsMotherPi0(Int_t tr) {
 843
 844   //
 845   // Return the lab of pi0 mother or -1 if not pi0
 846   //
 847
 848   AliStack* stack = fMCEvent->Stack();
 849   if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
 850
 851   // Take mother
 852   TParticle * particle = stack->Particle(tr);
 853   if(!particle) return -1;
 854   Int_t imother   = particle->GetFirstMother();
 855   if((imother < 0) || (imother >= stack->GetNtrack())) return -1;
 856   TParticle * mother = stack->Particle(imother);
 857   if(!mother) return -1;
 858
 859   // Check gamma
 860   Int_t pdg = mother->GetPdgCode();
 861   if(TMath::Abs(pdg) == 111) return imother;
 862   if(TMath::Abs(pdg) == 11) {
 863     return IsMotherPi0(imother);
 864   }
 865   return -1;
 866
 867 }
 868 //____________________________________________________________________________________________________________
 869 Int_t AliHFEelecbackground::IsMotherEta(Int_t tr) {
 870
 871   //
 872   // Return the lab of pi0 mother or -1 if not pi0
 873   //
 874
 875   AliStack* stack = fMCEvent->Stack();
 876   if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
 877
 878   // Take mother
 879   TParticle * particle = stack->Particle(tr);
 880   if(!particle) return -1;
 881   Int_t imother   = particle->GetFirstMother();
 882   if((imother < 0) || (imother >= stack->GetNtrack())) return -1;
 883   TParticle * mother = stack->Particle(imother);
 884   if(!mother) return -1;
 885
 886   // Check gamma
 887   Int_t pdg = mother->GetPdgCode();
 888   if(TMath::Abs(pdg) == 221) return imother;
 889   if(TMath::Abs(pdg) == 11) {
 890     return IsMotherEta(imother);
 891   }
 892   return -1;
 893
 894 }
 895 //____________________________________________________________________________________________________________
 896 Int_t AliHFEelecbackground::IsMotherC(Int_t tr) {
 897
 898   //
 899   // Return the lab of signal mother or -1 if not signal
 900   //
 901
 902   AliStack* stack = fMCEvent->Stack();
 903   if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
 904
 905   // Take mother
 906   TParticle * particle = stack->Particle(tr);
 907   if(!particle) return -1;
 908   Int_t imother   = particle->GetFirstMother();
 909   if((imother < 0) || (imother >= stack->GetNtrack())) return -1;
 910   TParticle * mother = stack->Particle(imother);
 911   if(!mother) return -1;
 912
 913   // Check gamma
 914   Int_t pdg = mother->GetPdgCode();
 915   if((TMath::Abs(pdg)==411) || (TMath::Abs(pdg)==421) || (TMath::Abs(pdg)==431) || (TMath::Abs(pdg)==4122) || (TMath::Abs(pdg)==4132) || (TMath::Abs(pdg)==4232) || (TMath::Abs(pdg)==43320)) return imother;
 916   if(TMath::Abs(pdg) == 11) {
 917     return IsMotherC(imother);
 918   }
 919   return -1;
 920
 921 }
 922 //____________________________________________________________________________________________________________
 923 Int_t AliHFEelecbackground::IsMotherB(Int_t tr) {
 924
 925   //
 926   // Return the lab of signal mother or -1 if not signal
 927   //
 928
 929   AliStack* stack = fMCEvent->Stack();
 930   if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
 931
 932   // Take mother
 933   TParticle * particle = stack->Particle(tr);
 934   if(!particle) return -1;
 935   Int_t imother   = particle->GetFirstMother();
 936   if((imother < 0) || (imother >= stack->GetNtrack())) return -1;
 937   TParticle * mother = stack->Particle(imother);
 938   if(!mother) return -1;
 939
 940   // Check gamma
 941   Int_t pdg = mother->GetPdgCode();
 942   if((TMath::Abs(pdg)==511) || (TMath::Abs(pdg)==521) || (TMath::Abs(pdg)==531) || (TMath::Abs(pdg)==5122) || (TMath::Abs(pdg)==5132) || (TMath::Abs(pdg)==5232) || (TMath::Abs(pdg)==53320)) return imother;
 943   if(TMath::Abs(pdg) == 11) {
 944     return IsMotherB(imother);
 945   }
 946   return -1;
 947
 948 }
 949 //____________________________________________________________________________________________________________
 950 Int_t AliHFEelecbackground::GetPdg(Int_t tr) {
 951
 952   //
 953   // Simply pdg code
 954   //
 955
 956   AliStack* stack = fMCEvent->Stack();
 957   if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
 958
 959   // MC Information
 960   TParticle * particle = stack->Particle(tr);
 961   if(!particle) return -1;
 962   Int_t pdg = particle->GetPdgCode();
 963
 964   return pdg;
 965
 966 }
 967 //____________________________________________________________________________________________________________
 968 Int_t AliHFEelecbackground::GetLabMother(Int_t tr) {
 969
 970   //
 971   // Simply lab mother
 972   //
 973
 974   AliStack* stack = fMCEvent->Stack();
 975   if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
 976
 977   // MC Information
 978   TParticle * particle = stack->Particle(tr);
 979   if(!particle) return -1;
 980   Int_t imother = particle->GetFirstMother();
 981
 982   return imother;
 983
 984 }
 985 //_______________________________________________________________________________________________
 986 void AliHFEelecbackground::PostProcess()
 987 {
 988   //
 989   // Post process the histos and extract the background pt spectra
 990   //
 991
 992   if(!fList) return;
 993
 994   // invariant mass input spectra
 995   THnSparseF *invmassss = dynamic_cast<THnSparseF *>(fList->FindObject("invmassss"));
 996   THnSparseF *invmassr  = dynamic_cast<THnSparseF *>(fList->FindObject("invmassr"));
 997   THnSparseF *invmassos = dynamic_cast<THnSparseF *>(fList->FindObject("invmassos"));
 998   THnSparseF *invmassgamma = dynamic_cast<THnSparseF *>(fList->FindObject("invmassgamma"));
 999   THnSparseF *invmasspi0 = dynamic_cast<THnSparseF *>(fList->FindObject("invmasspi0"));
1000   THnSparseF *invmasseta = dynamic_cast<THnSparseF *>(fList->FindObject("invmasseta"));
1001   THnSparseF *invmassC = dynamic_cast<THnSparseF *>(fList->FindObject("invmassC"));
1002   THnSparseF *invmassB = dynamic_cast<THnSparseF *>(fList->FindObject("invmassB"));
1003
1004   TAxis *ptaxisinvmass = invmassss->GetAxis(0);
1005   Int_t  nbinsptinvmass = ptaxisinvmass->GetNbins();
1006
1007   // outputs
1008   TH1D **invmassosptproj = new TH1D*[nbinsptinvmass];
1009   TH1D **invmassssptproj = new TH1D*[nbinsptinvmass];
1010   TH1D **invmassrptproj = new TH1D*[nbinsptinvmass];
1011   TH1D **invmassdiffptproj = new TH1D*[nbinsptinvmass];
1012   TH1D **invmassgammaptproj = new TH1D*[nbinsptinvmass];
1013   TH1D **invmasspi0ptproj = new TH1D*[nbinsptinvmass];
1014   TH1D **invmassetaptproj = new TH1D*[nbinsptinvmass];
1015   TH1D **invmassCptproj = new TH1D*[nbinsptinvmass];
1016   TH1D **invmassBptproj = new TH1D*[nbinsptinvmass];
1017
1018   TH1D *yieldPtFound = (TH1D *) invmassss->Projection(0);
1019   yieldPtFound->SetName("Found yield");
1020   yieldPtFound->Reset();
1021
1022   TH1D *yieldPtSourcesMC = 0x0;
1023   if(invmasspi0 && invmasseta && invmassgamma) {
1024     yieldPtSourcesMC = (TH1D *) invmassss->Projection(0);
1025     yieldPtSourcesMC->SetName("Found yield");
1026     yieldPtSourcesMC->Reset();
1027   }
1028
1029   TH1D *yieldPtSignalCutMC = 0x0;
1030   if(invmassC && invmassB) {
1031     yieldPtSignalCutMC = (TH1D *) invmassss->Projection(0);
1032     yieldPtSignalCutMC->SetName("Found yield");
1033     yieldPtSignalCutMC->Reset();
1034   }
1035
1036   // canvas
1037   Int_t nbrow = (Int_t) (nbinsptinvmass/5);
1038   TString namecanvas("Invmassnamecanvas");
1039   TCanvas * canvas =new TCanvas(namecanvas,namecanvas,800,800);
1040   canvas->Divide(5,nbrow+1);
1041
1042
1043   // loop on pt bins
1044   for(Int_t k=1; k <= nbinsptinvmass; k++){
1045
1046     Double_t lowedge = ptaxisinvmass->GetBinLowEdge(k);
1047     Double_t upedge  = ptaxisinvmass->GetBinUpEdge(k);
1048
1049     ((TAxis *)invmassss->GetAxis(0))->SetRange(k,k);
1050     ((TAxis *)invmassr->GetAxis(0))->SetRange(k,k);
1051     ((TAxis *)invmassos->GetAxis(0))->SetRange(k,k);
1052
1053     invmassosptproj[k-1] = invmassos->Projection(2);
1054     invmassssptproj[k-1] = invmassss->Projection(2);
1055     invmassrptproj[k-1]  = invmassr->Projection(2);
1056     invmassgammaptproj[k-1] = 0x0;
1057     invmasspi0ptproj[k-1] = 0x0;
1058     invmassetaptproj[k-1] = 0x0;
1059     invmassCptproj[k-1] = 0x0;
1060     invmassBptproj[k-1] = 0x0;
1061     if(invmassgamma) invmassgammaptproj[k-1] = invmassgamma->Projection(2);
1062     if(invmasspi0) invmasspi0ptproj[k-1] = invmasspi0->Projection(2);
1063     if(invmasseta) invmassetaptproj[k-1] = invmasseta->Projection(2);
1064     if(invmassC) invmassCptproj[k-1] = invmassC->Projection(2);
1065     if(invmassB) invmassBptproj[k-1] = invmassB->Projection(2);
1066
1067     invmassdiffptproj[k-1] = (TH1D *) invmassosptproj[k-1]->Clone();
1068     TString name("Invmassdiffptbin");
1069     name += k;
1070     invmassdiffptproj[k-1]->SetName(name);
1071     invmassdiffptproj[k-1]->Add(invmassssptproj[k-1],-1.0);
1072
1073     TString namee("p_{T} tagged from ");
1074     namee += lowedge;
1075     namee += " GeV/c to ";
1076     namee += upedge;
1077     namee += " GeV/c";
1078
1079     invmassosptproj[k-1]->SetTitle((const char*)namee);
1080     invmassssptproj[k-1]->SetTitle((const char*)namee);
1081     invmassrptproj[k-1]->SetTitle((const char*)namee);
1082     invmassdiffptproj[k-1]->SetTitle((const char*)namee);
1083     if(invmassgammaptproj[k-1]) invmassgammaptproj[k-1]->SetTitle((const char*)namee);
1084     if(invmasspi0ptproj[k-1]) invmasspi0ptproj[k-1]->SetTitle((const char*)namee);
1085     if(invmassetaptproj[k-1]) invmassetaptproj[k-1]->SetTitle((const char*)namee);
1086     if(invmassCptproj[k-1]) invmassCptproj[k-1]->SetTitle((const char*)namee);
1087     if(invmassBptproj[k-1]) invmassBptproj[k-1]->SetTitle((const char*)namee);
1088
1089
1090
1091     invmassosptproj[k-1]->SetStats(0);
1092     invmassssptproj[k-1]->SetStats(0);
1093     invmassrptproj[k-1]->SetStats(0);
1094     invmassdiffptproj[k-1]->SetStats(0);
1095     if(invmassgammaptproj[k-1]) invmassgammaptproj[k-1]->SetStats(0);
1096     if(invmasspi0ptproj[k-1]) invmasspi0ptproj[k-1]->SetStats(0);
1097     if(invmassetaptproj[k-1]) invmassetaptproj[k-1]->SetStats(0);
1098     if(invmassCptproj[k-1]) invmassCptproj[k-1]->SetStats(0);
1099     if(invmassBptproj[k-1]) invmassBptproj[k-1]->SetStats(0);
1100
1101     Double_t yieldf = invmassdiffptproj[k-1]->Integral();
1102     if(invmassetaptproj[k-1] && invmasspi0ptproj[k-1] && invmassgammaptproj[k-1] && invmassCptproj[k-1] && invmassBptproj[k-1]) {
1103       Double_t yieldg = invmassetaptproj[k-1]->Integral() + invmasspi0ptproj[k-1]->Integral() + invmassgammaptproj[k-1]->Integral();
1104       yieldPtSourcesMC->SetBinContent(k,yieldg);
1105
1106       Double_t yieldsignal = invmassCptproj[k-1]->Integral() + invmassBptproj[k-1]->Integral();
1107       yieldPtSignalCutMC->SetBinContent(k,yieldsignal);
1108     }
1109
1110     yieldPtFound->SetBinContent(k,yieldf);
1111
1112     canvas->cd(k);
1113     invmassosptproj[k-1]->Draw();
1114     invmassssptproj[k-1]->Draw("same");
1115     invmassdiffptproj[k-1]->Draw("same");
1116     invmassrptproj[k-1]->Draw("same");
1117     TLegend *legiv = new TLegend(0.4,0.6,0.89,0.89);
1118     legiv->AddEntry(invmassosptproj[k-1],"Opposite signs","p");
1119     legiv->AddEntry(invmassssptproj[k-1],"Same signs","p");
1120     legiv->AddEntry(invmassdiffptproj[k-1],"(Opposite - Same) signs","p");
1121     legiv->AddEntry(invmassrptproj[k-1],"rotated","p");
1122     if(invmassgammaptproj[k-1]) legiv->AddEntry(invmassgammaptproj[k-1],"e^{+}e^{-} from #gamma","p");
1123     if(invmasspi0ptproj[k-1]) legiv->AddEntry(invmasspi0ptproj[k-1],"e^{+}e^{-} from #pi^{0}","p");
1124     if(invmassetaptproj[k-1]) legiv->AddEntry(invmassetaptproj[k-1],"e^{+}e^{-} from #eta","p");
1125     legiv->Draw("same");
1126
1127   }
1128
1129   yieldPtFound->SetStats(0);
1130   if(yieldPtSourcesMC) yieldPtSourcesMC->SetStats(0);
1131   if(yieldPtSignalCutMC) yieldPtSignalCutMC->SetStats(0);
1132
1133   TCanvas * canvasfin =new TCanvas("results","results",800,800);
1134   canvasfin->cd(1);
1135   yieldPtFound->Draw();
1136   if(yieldPtSourcesMC && yieldPtSignalCutMC) {
1137     yieldPtSourcesMC->Draw("same");
1138     yieldPtSignalCutMC->Draw("same");
1139     TLegend *lega = new TLegend(0.4,0.6,0.89,0.89);
1140     lega->AddEntry(yieldPtFound,"Contributions found","p");
1141     lega->AddEntry(yieldPtSourcesMC,"Contributions of e^{+}e^{-} from #gamma, #pi^{0} and #eta","p");
1142     lega->AddEntry(yieldPtSignalCutMC,"Contributions of e^{+}e^{-} from C and B","p");
1143     lega->Draw("same");
1144   }
1145
1146
1147
1148   if(!fListPostProcess) fListPostProcess = new TList();
1149   fListPostProcess->SetName("ListPostProcess");
1150
1151   for(Int_t k=0; k < nbinsptinvmass; k++){
1152     fListPostProcess->AddAt(invmassosptproj[k],kOos+kNOutput*k);
1153     fListPostProcess->AddAt(invmassssptproj[k],kOss+kNOutput*k);
1154     fListPostProcess->AddAt(invmassrptproj[k],kOr+kNOutput*k);
1155     fListPostProcess->AddAt(invmassdiffptproj[k],kOdiff+kNOutput*k);
1156     if(invmassgammaptproj[k]) fListPostProcess->AddAt(invmassgammaptproj[k],kNOutput*nbinsptinvmass+kNMCInfo*k+kElectronFromGamma);
1157     if(invmasspi0ptproj[k]) fListPostProcess->AddAt(invmasspi0ptproj[k],kNOutput*nbinsptinvmass+kNMCInfo*k+kElectronFromPi0);
1158     if(invmassetaptproj[k]) fListPostProcess->AddAt(invmassetaptproj[k],kNOutput*nbinsptinvmass+kNMCInfo*k+kElectronFromEta);
1159     if(invmassCptproj[k]) fListPostProcess->AddAt(invmassCptproj[k],kNOutput*nbinsptinvmass+kNMCInfo*k+kElectronFromC);
1160     if(invmassBptproj[k]) fListPostProcess->AddAt(invmassBptproj[k],kNOutput*nbinsptinvmass+kNMCInfo*k+kElectronFromB);
1161   }
1162
1163   fListPostProcess->AddAt(yieldPtFound,kNOutput*nbinsptinvmass+kNMCInfo*nbinsptinvmass);
1164   if(yieldPtSourcesMC) fListPostProcess->AddAt(yieldPtSourcesMC,kNOutput*nbinsptinvmass+kNMCInfo*nbinsptinvmass+1);
1165   if(yieldPtSignalCutMC) fListPostProcess->AddAt(yieldPtSignalCutMC,kNOutput*nbinsptinvmass+kNMCInfo*nbinsptinvmass+2);
1166
1167   // delete dynamic array
1168   delete[] invmassosptproj;
1169   delete[] invmassssptproj;
1170   delete[] invmassrptproj;
1171   delete[] invmassdiffptproj;
1172   delete[] invmassgammaptproj;
1173   delete[] invmasspi0ptproj;
1174   delete[] invmassetaptproj;
1175   delete[] invmassCptproj;
1176   delete[] invmassBptproj;
1177
1178 }
1179 //_______________________________________________________________________________________________
1180 void AliHFEelecbackground::Plot() const
1181 {
1182   //
1183   // Plot the output
1184   //
1185
1186   if(!fList) return;
1187
1188   // opening angle
1189   THnSparseF *openinganglepp = dynamic_cast<THnSparseF *>(fList->FindObject("openinganglepp"));
1190   THnSparseF *openinganglenn = dynamic_cast<THnSparseF *>(fList->FindObject("openinganglenn"));
1191   THnSparseF *openingangless = dynamic_cast<THnSparseF *>(fList->FindObject("openingangless"));
1192   THnSparseF *openingangler  = dynamic_cast<THnSparseF *>(fList->FindObject("openingangler"));
1193   THnSparseF *openingangleos = dynamic_cast<THnSparseF *>(fList->FindObject("openingangleos"));
1194
1195   THnSparseF *openinganglegamma = dynamic_cast<THnSparseF *>(fList->FindObject("openinganglegamma"));
1196   THnSparseF *openinganglepi0 = dynamic_cast<THnSparseF *>(fList->FindObject("openinganglepi0"));
1197   THnSparseF *openingangleC = dynamic_cast<THnSparseF *>(fList->FindObject("openingangleC"));
1198   THnSparseF *openingangleB = dynamic_cast<THnSparseF *>(fList->FindObject("openingangleB"));
1199   THnSparseF *openingangleeta = dynamic_cast<THnSparseF *>(fList->FindObject("openingangleeta"));
1200
1201   THnSparseF *openingangleSplittedTrackss = dynamic_cast<THnSparseF *>(fList->FindObject("openingangleSplittedTrackss"));
1202   THnSparseF *openingangleSplittedTrackos = dynamic_cast<THnSparseF *>(fList->FindObject("openingangleSplittedTrackos"));
1203
1204
1205   // invariant mass
1206   THnSparseF *invmasspp = dynamic_cast<THnSparseF *>(fList->FindObject("invmasspp"));
1207   THnSparseF *invmassnn = dynamic_cast<THnSparseF *>(fList->FindObject("invmassnn"));
1208   THnSparseF *invmassss = dynamic_cast<THnSparseF *>(fList->FindObject("invmassss"));
1209   THnSparseF *invmassr  = dynamic_cast<THnSparseF *>(fList->FindObject("invmassr"));
1210   THnSparseF *invmassos = dynamic_cast<THnSparseF *>(fList->FindObject("invmassos"));
1211
1212   THnSparseF *invmassgamma = dynamic_cast<THnSparseF *>(fList->FindObject("invmassgamma"));
1213   THnSparseF *invmasspi0 = dynamic_cast<THnSparseF *>(fList->FindObject("invmasspi0"));
1214   THnSparseF *invmassC = dynamic_cast<THnSparseF *>(fList->FindObject("invmassC"));
1215   THnSparseF *invmassB = dynamic_cast<THnSparseF *>(fList->FindObject("invmassB"));
1216   THnSparseF *invmasseta = dynamic_cast<THnSparseF *>(fList->FindObject("invmasseta"));
1217
1218   THnSparseF *invmassSplittedTrackss = dynamic_cast<THnSparseF *>(fList->FindObject("invmassSplittedTrackss"));
1219   THnSparseF *invmassSplittedTrackos = dynamic_cast<THnSparseF *>(fList->FindObject("invmassSplittedTrackos"));
1220
1221   // Projection over all pt
1222   TH1D *openingangleppproj = openinganglepp->Projection(2);
1223   TH1D *openinganglennproj = openinganglenn->Projection(2);
1224   TH1D *openinganglessproj = openingangless->Projection(2);
1225   TH1D *openinganglerproj  = openingangler->Projection(2);
1226   TH1D *openingangleosproj = openingangleos->Projection(2);
1227
1228   TH1D *openinganglegammaproj = 0x0;
1229   TH1D *openinganglepi0proj = 0x0;
1230   TH1D *openingangleCproj = 0x0;
1231   TH1D *openingangleBproj = 0x0;
1232   TH1D *openingangleetaproj = 0x0;
1233   TH1D *openingangleSplittedTrackssproj = 0x0;
1234   TH1D *openingangleSplittedTrackosproj = 0x0;
1235   if(openinganglegamma) openinganglegammaproj = openinganglegamma->Projection(2);
1236   if(openinganglepi0) openinganglepi0proj = openinganglepi0->Projection(2);
1237   if(openingangleC) openingangleCproj = openingangleC->Projection(2);
1238   if(openingangleB) openingangleBproj = openingangleB->Projection(2);
1239   if(openingangleeta) openingangleetaproj = openingangleeta->Projection(2);
1240   if(openingangleSplittedTrackss) openingangleSplittedTrackssproj = openingangleSplittedTrackss->Projection(2);
1241   if(openingangleSplittedTrackos) openingangleSplittedTrackosproj = openingangleSplittedTrackos->Projection(2);
1242
1243
1244   TH1D *invmassppproj = invmasspp->Projection(2);
1245   TH1D *invmassnnproj = invmassnn->Projection(2);
1246   TH1D *invmassssproj = invmassss->Projection(2);
1247   TH1D *invmassrproj  = invmassr->Projection(2);
1248   TH1D *invmassosproj = invmassos->Projection(2);
1249
1250   TH1D *invmassgammaproj = 0x0;
1251   TH1D *invmasspi0proj = 0x0;
1252   TH1D *invmassCproj = 0x0;
1253   TH1D *invmassBproj = 0x0;
1254   TH1D *invmassetaproj = 0x0;
1255   TH1D *invmassSplittedTrackssproj = 0x0;
1256   TH1D *invmassSplittedTrackosproj = 0x0;
1257   if(invmassgamma) invmassgammaproj = invmassgamma->Projection(2);
1258   if(invmasspi0) invmasspi0proj = invmasspi0->Projection(2);
1259   if(invmassC) invmassCproj = invmassC->Projection(2);
1260   if(invmassB) invmassBproj = invmassB->Projection(2);
1261   if(invmasseta) invmassetaproj = invmasseta->Projection(2);
1262   if(invmassSplittedTrackss) invmassSplittedTrackssproj = invmassSplittedTrackss->Projection(2);
1263   if(invmassSplittedTrackos) invmassSplittedTrackosproj = invmassSplittedTrackos->Projection(2);
1264
1265   openingangleppproj->SetStats(0);
1266   openinganglennproj->SetStats(0);
1267   openinganglessproj->SetStats(0);
1268   openinganglerproj->SetStats(0);
1269   openingangleosproj->SetStats(0);
1270   if(openinganglegammaproj) openinganglegammaproj->SetStats(0);
1271   if(openinganglepi0proj) openinganglepi0proj->SetStats(0);
1272   if(openingangleCproj) openingangleCproj->SetStats(0);
1273   if(openingangleBproj) openingangleBproj->SetStats(0);
1274   if(openingangleetaproj) openingangleetaproj->SetStats(0);
1275   if(openingangleSplittedTrackssproj) openingangleSplittedTrackssproj->SetStats(0);
1276   if(openingangleSplittedTrackosproj) openingangleSplittedTrackosproj->SetStats(0);
1277
1278   invmassppproj->SetStats(0);
1279   invmassnnproj->SetStats(0);
1280   invmassssproj->SetStats(0);
1281   invmassrproj->SetStats(0);
1282   invmassosproj->SetStats(0);
1283   if(invmassgammaproj) invmassgammaproj->SetStats(0);
1284   if(invmasspi0proj) invmasspi0proj->SetStats(0);
1285   if(invmassCproj) invmassCproj->SetStats(0);
1286   if(invmassBproj) invmassBproj->SetStats(0);
1287   if(invmassetaproj) invmassetaproj->SetStats(0);
1288   if(invmassSplittedTrackssproj) invmassSplittedTrackssproj->SetStats(0);
1289   if(invmassSplittedTrackosproj) invmassSplittedTrackosproj->SetStats(0);
1290
1291   openingangleppproj->SetTitle("");
1292   openinganglennproj->SetTitle("");
1293   openinganglessproj->SetTitle("");
1294   openinganglerproj->SetTitle("");
1295   openingangleosproj->SetTitle("");
1296   if(openinganglegammaproj) openinganglegammaproj->SetTitle("");
1297   if(openinganglepi0proj) openinganglepi0proj->SetTitle("");
1298   if(openingangleCproj) openingangleCproj->SetTitle("");
1299   if(openingangleBproj) openingangleBproj->SetTitle("");
1300   if(openingangleetaproj) openingangleetaproj->SetTitle("");
1301   if(openingangleSplittedTrackssproj) openingangleSplittedTrackssproj->SetTitle("");
1302   if(openingangleSplittedTrackosproj) openingangleSplittedTrackosproj->SetTitle("");
1303
1304   invmassppproj->SetTitle("");
1305   invmassnnproj->SetTitle("");
1306   invmassssproj->SetTitle("");
1307   invmassrproj->SetTitle("");
1308   invmassosproj->SetTitle("");
1309   if(invmassgammaproj) invmassgammaproj->SetTitle("");
1310   if(invmasspi0proj) invmasspi0proj->SetTitle("");
1311   if(invmassCproj) invmassCproj->SetTitle("");
1312   if(invmassBproj) invmassBproj->SetTitle("");
1313   if(invmassetaproj) invmassetaproj->SetTitle("");
1314   if(invmassSplittedTrackssproj) invmassSplittedTrackssproj->SetTitle("");
1315   if(invmassSplittedTrackosproj) invmassSplittedTrackosproj->SetTitle("");
1316
1317   // Projection pttagged variable
1318   TH2D *openingangleppproj2D = openinganglepp->Projection(0,2);
1319   TH2D *openinganglennproj2D = openinganglenn->Projection(0,2);
1320   TH2D *openinganglessproj2D = openingangless->Projection(0,2);
1321   TH2D *openinganglerproj2D  = openingangler->Projection(0,2);
1322   TH2D *openingangleosproj2D = openingangleos->Projection(0,2);
1323
1324   TH2D *openinganglegammaproj2D = 0x0;
1325   TH2D *openinganglepi0proj2D = 0x0;
1326   TH2D *openingangleCproj2D = 0x0;
1327   TH2D *openingangleBproj2D = 0x0;
1328   TH2D *openingangleetaproj2D = 0x0;
1329   TH2D *openingangleSplittedTrackssproj2D = 0x0;
1330   TH2D *openingangleSplittedTrackosproj2D = 0x0;
1331   if(openinganglegamma) openinganglegammaproj2D = openinganglegamma->Projection(0,2);
1332   if(openinganglepi0) openinganglepi0proj2D = openinganglepi0->Projection(0,2);
1333   if(openingangleC) openingangleCproj2D = openingangleC->Projection(0,2);
1334   if(openingangleB) openingangleBproj2D = openingangleB->Projection(0,2);
1335   if(openingangleeta) openingangleetaproj2D = openingangleeta->Projection(0,2);
1336   if(openingangleSplittedTrackss) openingangleSplittedTrackssproj2D = openingangleSplittedTrackss->Projection(0,2);
1337   if(openingangleSplittedTrackos) openingangleSplittedTrackosproj2D = openingangleSplittedTrackos->Projection(0,2);
1338
1339
1340   TH2D *invmassppproj2D = invmasspp->Projection(0,2);
1341   TH2D *invmassnnproj2D = invmassnn->Projection(0,2);
1342   TH2D *invmassssproj2D = invmassss->Projection(0,2);
1343   TH2D *invmassrproj2D  = invmassr->Projection(0,2);
1344   TH2D *invmassosproj2D = invmassos->Projection(0,2);
1345
1346   TH2D *invmassgammaproj2D = 0x0;
1347   TH2D *invmasspi0proj2D = 0x0;
1348   TH2D *invmassCproj2D = 0x0;
1349   TH2D *invmassBproj2D = 0x0;
1350   TH2D *invmassetaproj2D = 0x0;
1351   TH2D *invmassSplittedTrackssproj2D = 0x0;
1352   TH2D *invmassSplittedTrackosproj2D = 0x0;
1353   if(invmassgamma) invmassgammaproj2D = invmassgamma->Projection(0,2);
1354   if(invmasspi0) invmasspi0proj2D = invmasspi0->Projection(0,2);
1355   if(invmassC) invmassCproj2D = invmassC->Projection(0,2);
1356   if(invmassB) invmassBproj2D = invmassB->Projection(0,2);
1357   if(invmasseta) invmassetaproj2D = invmasseta->Projection(0,2);
1358   if(invmassSplittedTrackss) invmassSplittedTrackssproj2D = invmassSplittedTrackss->Projection(0,2);
1359   if(invmassSplittedTrackos) invmassSplittedTrackosproj2D = invmassSplittedTrackos->Projection(0,2);
1360
1361   openingangleppproj2D->SetStats(0);
1362   openinganglennproj2D->SetStats(0);
1363   openinganglessproj2D->SetStats(0);
1364   openinganglerproj2D->SetStats(0);
1365   openingangleosproj2D->SetStats(0);
1366   if(openinganglegammaproj2D) openinganglegammaproj2D->SetStats(0);
1367   if(openinganglepi0proj2D) openinganglepi0proj2D->SetStats(0);
1368   if(openingangleCproj2D) openingangleCproj2D->SetStats(0);
1369   if(openingangleBproj2D) openingangleBproj2D->SetStats(0);
1370   if(openingangleetaproj2D) openingangleetaproj2D->SetStats(0);
1371   if(openingangleSplittedTrackssproj2D) openingangleSplittedTrackssproj2D->SetStats(0);
1372   if(openingangleSplittedTrackosproj2D) openingangleSplittedTrackosproj2D->SetStats(0);
1373
1374   invmassppproj2D->SetStats(0);
1375   invmassnnproj2D->SetStats(0);
1376   invmassssproj2D->SetStats(0);
1377   invmassrproj2D->SetStats(0);
1378   invmassosproj2D->SetStats(0);
1379   if(invmassgammaproj2D) invmassgammaproj2D->SetStats(0);
1380   if(invmasspi0proj2D) invmasspi0proj2D->SetStats(0);
1381   if(invmassCproj2D) invmassCproj2D->SetStats(0);
1382   if(invmassBproj2D) invmassBproj2D->SetStats(0);
1383   if(invmassetaproj2D) invmassetaproj2D->SetStats(0);
1384   if(invmassSplittedTrackssproj2D) invmassSplittedTrackssproj2D->SetStats(0);
1385   if(invmassSplittedTrackosproj2D) invmassSplittedTrackosproj2D->SetStats(0);
1386
1387   openingangleppproj2D->SetTitle("openingangleppproj2D");
1388   openinganglennproj2D->SetTitle("openinganglennproj2D");
1389   openinganglessproj2D->SetTitle("openinganglessproj2D");
1390   openinganglerproj2D->SetTitle("openinganglerproj2D");
1391   openingangleosproj2D->SetTitle("openingangleosproj2D");
1392   if(openinganglegammaproj2D) openinganglegammaproj2D->SetTitle("openinganglegammaproj2D");
1393   if(openinganglepi0proj2D) openinganglepi0proj2D->SetTitle("openinganglepi0proj2D");
1394   if(openingangleCproj2D) openingangleCproj2D->SetTitle("openingangleCproj2D");
1395   if(openingangleBproj2D) openingangleBproj2D->SetTitle("openingangleBproj2D");
1396   if(openingangleetaproj2D) openingangleetaproj2D->SetTitle("openingangleetaproj2D");
1397   if(openingangleSplittedTrackssproj2D) openingangleSplittedTrackssproj2D->SetTitle("openingangleSplittedTrackssproj2D");
1398   if(openingangleSplittedTrackosproj2D) openingangleSplittedTrackosproj2D->SetTitle("openingangleSplittedTrackosproj2D");
1399
1400   invmassppproj2D->SetTitle("invmassppproj2D");
1401   invmassnnproj2D->SetTitle("invmassnnproj2D");
1402   invmassssproj2D->SetTitle("invmassssproj2D");
1403   invmassrproj2D->SetTitle("invmassrproj2D");
1404   invmassosproj2D->SetTitle("invmassosproj2D");
1405   if(invmassgammaproj2D) invmassgammaproj2D->SetTitle("invmassgammaproj2D");
1406   if(invmasspi0proj2D) invmasspi0proj2D->SetTitle("invmasspi0proj2D");
1407   if(invmassCproj2D) invmassCproj2D->SetTitle("invmassCproj2D");
1408   if(invmassBproj2D) invmassBproj2D->SetTitle("invmassBproj2D");
1409   if(invmassetaproj2D) invmassetaproj2D->SetTitle("invmassetaproj2D");
1410   if(invmassSplittedTrackssproj2D) invmassSplittedTrackssproj2D->SetTitle("invmassSplittedTrackssproj2D");
1411   if(invmassSplittedTrackosproj2D) invmassSplittedTrackosproj2D->SetTitle("invmassSplittedTrackosproj2D");
1412
1413
1414   // Draw histograms for opening angle
1415   TCanvas * copeningangle =new TCanvas("openingangle","Openingangle",800,800);
1416   copeningangle->cd();
1417   openingangleppproj->Draw();
1418   openinganglennproj->Draw("same");
1419   openinganglessproj->Draw("same");
1420   openinganglerproj->Draw("same");
1421   openingangleosproj->Draw("same");
1422   if(openinganglegammaproj) openinganglegammaproj->Draw("same");
1423   if(openinganglepi0proj) openinganglepi0proj->Draw("same");
1424   if(openingangleCproj) openingangleCproj->Draw("same");
1425   if(openingangleBproj) openingangleBproj->Draw("same");
1426   if(openingangleetaproj) openingangleetaproj->Draw("same");
1427   if(openingangleSplittedTrackssproj) openingangleSplittedTrackssproj->Draw("same");
1428   if(openingangleSplittedTrackosproj) openingangleSplittedTrackosproj->Draw("same");
1429   TLegend *lego = new TLegend(0.4,0.6,0.89,0.89);
1430   lego->AddEntry(openingangleppproj,"positive-positive","p");
1431   lego->AddEntry(openinganglennproj,"negative-negative","p");
1432   lego->AddEntry(openinganglessproj,"same-sign","p");
1433   lego->AddEntry(openinganglerproj,"rotated","p");
1434   lego->AddEntry(openingangleosproj,"positive-negative","p");
1435   if(openinganglegammaproj) lego->AddEntry(openinganglegammaproj,"e^{+}e^{-} from #gamma","p");
1436   if(openinganglepi0proj) lego->AddEntry(openinganglepi0proj,"e^{+}e^{-} from #pi^{0}","p");
1437   if(openingangleCproj) lego->AddEntry(openingangleCproj,"e^{+}e^{-} from c","p");
1438   if(openingangleBproj) lego->AddEntry(openingangleBproj,"e^{+}e^{-} from b","p");
1439   if(openingangleetaproj) lego->AddEntry(openingangleetaproj,"e^{+}e^{-} from #eta","p");
1440   if(openingangleSplittedTrackssproj) lego->AddEntry(openingangleSplittedTrackssproj,"Splitted tracks same sign","p");
1441   if(openingangleSplittedTrackosproj) lego->AddEntry(openingangleSplittedTrackosproj,"Splitted tracks opposite sign","p");
1442   lego->Draw("same");
1443
1444   // Draw histograms for invariant mass
1445   TCanvas * cinvmass =new TCanvas("invmass","Invmass",800,800);
1446   cinvmass->cd();
1447   invmassppproj->Draw();
1448   invmassnnproj->Draw("same");
1449   invmassssproj->Draw("same");
1450   invmassrproj->Draw("same");
1451   invmassosproj->Draw("same");
1452   if(invmassgammaproj) invmassgammaproj->Draw("same");
1453   if(invmasspi0proj) invmasspi0proj->Draw("same");
1454   if(invmassCproj) invmassCproj->Draw("same");
1455   if(invmassBproj) invmassBproj->Draw("same");
1456   if(invmassetaproj) invmassetaproj->Draw("same");
1457   if(invmassSplittedTrackssproj) invmassSplittedTrackssproj->Draw("same");
1458   if(invmassSplittedTrackosproj) invmassSplittedTrackosproj->Draw("same");
1459   TLegend *legi = new TLegend(0.4,0.6,0.89,0.89);
1460   legi->AddEntry(invmassppproj,"positive-positive","p");
1461   legi->AddEntry(invmassnnproj,"negative-negative","p");
1462   legi->AddEntry(invmassssproj,"same-sign","p");
1463   legi->AddEntry(invmassrproj,"rotated","p");
1464   legi->AddEntry(invmassosproj,"positive-negative","p");
1465   if(invmassgammaproj) legi->AddEntry(invmassgammaproj,"e^{+}e^{-} from #gamma","p");
1466   if(invmasspi0proj) legi->AddEntry(invmasspi0proj,"e^{+}e^{-} from #pi^{0}","p");
1467   if(invmassCproj) legi->AddEntry(invmassCproj,"e^{+}e^{-} from c","p");
1468   if(invmassBproj) legi->AddEntry(invmassBproj,"e^{+}e^{-} from b","p");
1469   if(invmassetaproj) legi->AddEntry(invmassetaproj,"e^{+}e^{-} from #eta","p");
1470   if(invmassSplittedTrackssproj) legi->AddEntry(invmassSplittedTrackssproj,"Splitted tracks same sign","p");
1471   if(invmassSplittedTrackosproj) legi->AddEntry(invmassSplittedTrackosproj,"Splitted tracks opposite sign","p");
1472   legi->Draw("same");
1473
1474   // Draw histograms for opening angle 2D
1475   TCanvas * copeningangle2D =new TCanvas("openingangle2D","Openingangle2D",800,800);
1476   copeningangle2D->Divide(6,2);
1477   copeningangle2D->cd(1);
1478   openingangleppproj2D->Draw("lego");
1479   copeningangle2D->cd(2);
1480   openinganglennproj2D->Draw("lego");
1481   copeningangle2D->cd(3);
1482   openinganglessproj2D->Draw("lego");
1483   copeningangle2D->cd(4);
1484   openinganglerproj2D->Draw("lego");
1485   copeningangle2D->cd(5);
1486   openingangleosproj2D->Draw("lego");
1487   copeningangle2D->cd(6);
1488   if(openinganglegammaproj2D) openinganglegammaproj2D->Draw("lego");
1489   copeningangle2D->cd(7);
1490   if(openinganglepi0proj2D) openinganglepi0proj2D->Draw("lego");
1491   copeningangle2D->cd(8);
1492   if(openingangleCproj2D) openingangleCproj2D->Draw("lego");
1493   copeningangle2D->cd(9);
1494   if(openingangleBproj2D) openingangleBproj2D->Draw("lego");
1495   copeningangle2D->cd(10);
1496   if(openingangleetaproj2D) openingangleetaproj2D->Draw("lego");
1497   copeningangle2D->cd(11);
1498   if(openingangleSplittedTrackssproj2D) openingangleSplittedTrackssproj2D->Draw("lego");
1499   copeningangle2D->cd(12);
1500   if(openingangleSplittedTrackosproj2D) openingangleSplittedTrackosproj2D->Draw("lego");
1501
1502   // Draw histograms for invariant mass 2D
1503   TCanvas * cinvmass2D =new TCanvas("invmass2D","Invmass2D",800,800);
1504   cinvmass2D->Divide(6,2);
1505   cinvmass2D->cd(1);
1506   invmassppproj2D->Draw("lego");
1507   cinvmass2D->cd(2);
1508   invmassnnproj2D->Draw("lego");
1509   cinvmass2D->cd(3);
1510   invmassssproj2D->Draw("lego");
1511   cinvmass2D->cd(4);
1512   invmassrproj2D->Draw("lego");
1513   cinvmass2D->cd(5);
1514   invmassosproj2D->Draw("lego");
1515   cinvmass2D->cd(6);
1516   if(invmassgammaproj2D) invmassgammaproj2D->Draw("lego");
1517   cinvmass2D->cd(7);
1518   if(invmasspi0proj2D) invmasspi0proj2D->Draw("lego");
1519   cinvmass2D->cd(8);
1520   if(invmassCproj2D) invmassCproj2D->Draw("lego");
1521   cinvmass2D->cd(9);
1522   if(invmassBproj2D) invmassBproj2D->Draw("lego");
1523   cinvmass2D->cd(10);
1524   if(invmassetaproj2D) invmassetaproj2D->Draw("lego");
1525   cinvmass2D->cd(11);
1526   if(invmassSplittedTrackssproj2D) invmassSplittedTrackssproj2D->Draw("lego");
1527   cinvmass2D->cd(12);
1528   if(invmassSplittedTrackosproj2D) invmassSplittedTrackosproj2D->Draw("lego");
1529
1530 }