PWGGA/GammaConv/AliAnalysisTaskEtaToPiPlPiMiGamma.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: Pedro Gonz??lez, Pedro Ladr??n de Guevara, Ernesto L??pez Torres, *
   5  *         Eulogio Serradilla, Ana Marin, Friederike Bock                 *
   6  * Version 2                                                              *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16
  17 // Analysis task for pi0->e+e-gamma (Dalitz decay)
  18 // Analysis task for chic->JPsi+gamma
  19
  20 #include <vector>
  21
  22 #include "TParticle.h"
  23 #include "TPDGCode.h"
  24 #include "TMCProcess.h"
  25 #include "TDatabasePDG.h"
  26 #include "TList.h"
  27 #include "TChain.h"
  28 #include "TDirectory.h"
  29 #include "TTree.h"
  30 #include "TH1.h"
  31 #include "TH1F.h"
  32 #include "THnSparse.h"
  33 #include "TH2F.h"
  34 #include "AliStack.h"
  35 #include "AliAnalysisManager.h"
  36 #include "AliESDInputHandler.h"
  37 #include "AliESDtrack.h"
  38 #include "AliMCEvent.h"
  39 #include "AliStack.h"
  40 #include "AliMCEventHandler.h"
  41 #include "AliPID.h"
  42 #include "AliLog.h"
  43 #include "AliESDtrackCuts.h"
  44 #include "AliESDpidCuts.h"
  45 #include "AliMCEvent.h"
  46 #include "AliESDv0.h"
  47 #include "AliESDEvent.h"
  48 #include "AliESDpid.h"
  49 #include "AliKFParticle.h"
  50 #include "AliMCEventHandler.h"
  51 #include "AliKFVertex.h"
  52 #include "AliTriggerAnalysis.h"
  53 #include "AliCentrality.h"
  54 #include "AliMultiplicity.h"
  55 #include "AliAnalysisTaskEtaToPiPlPiMiGamma.h"
  56
  57
  58 ClassImp( AliAnalysisTaskEtaToPiPlPiMiGamma )
  59
  60 //-----------------------------------------------------------------------------------------------
  61 AliAnalysisTaskEtaToPiPlPiMiGamma::AliAnalysisTaskEtaToPiPlPiMiGamma():
  62         fV0Reader(NULL),
  63         fPionSelector(NULL),
  64         fBGHandler(NULL),
  65         fESDEvent(NULL),
  66         fMCEvent(NULL),
  67         fMCStack(NULL),
  68         fCutFolder(NULL),
  69         fESDList(NULL),
  70         fBackList(NULL),
  71         fMotherList(NULL),
  72         fTrueList(NULL),
  73         fMCList(NULL),
  74         fOutputContainer(0),
  75         fReaderGammas(NULL),
  76         fSelectorNegPionIndex(0),
  77         fSelectorPosPionIndex(0),
  78         fGoodGammas(NULL),
  79         fGoodVirtualParticles(NULL),
  80         fGammaCutArray(NULL),
  81         fPionCutArray(NULL),
  82         fMesonCutArray(NULL),
  83         fConversionCuts(NULL),
  84         fHistoConvGammaPt(NULL),
  85         fHistoConvGammaEta(NULL),
  86         fHistoNegPionPt(NULL),
  87         fHistoPosPionPt(NULL),
  88         fHistoNegPionPhi(NULL),
  89         fHistoPosPionPhi(NULL),
  90         fHistoNegPionEta(NULL),
  91         fHistoPosPionEta(NULL),
  92         fHistoNegPionClsTPC(NULL),
  93         fHistoPosPionClsTPC(NULL),
  94         fHistoPionDCAxy(NULL),
  95         fHistoPionDCAz(NULL),
  96         fHistoPionTPCdEdxNSigma(NULL),
  97         fHistoPionTPCdEdx(NULL),
  98         fHistoMotherInvMassPt(NULL),
  99         fTHnSparseMotherInvMassPtZM(NULL),
 100         fHistoMotherBackInvMassPt(NULL),
 101         fTHnSparseMotherBackInvMassPtZM(NULL),
 102         fHistoMCAllGammaPt(NULL),
 103         fHistoMCConvGammaPt(NULL),
 104         fHistoMCAllPosPionsPt(NULL),
 105         fHistoMCAllNegPionsPt(NULL),
 106         fHistoMCGammaFromEtaPt(NULL),
 107         fHistoMCPosPionsFromEtaPt(NULL),
 108         fHistoMCNegPionsFromEtaPt(NULL),
 109         fHistoMCEtaPiPlPiMiGammaPt(NULL),
 110         fHistoMCEtaGGPt(NULL),
 111         fHistoMCEtaDalitzPt(NULL),
 112         fHistoMCEtaPiPlPiMiGammaInAccPt(NULL),
 113         fHistoTrueMotherPiPlPiMiGammaInvMassPt(NULL),
 114         fHistoTrueMotherGammaGammaInvMassPt(NULL),
 115         fHistoTrueMotherDalitzInvMassPt(NULL),
 116         fHistoTrueConvGammaPt(NULL),
 117         fHistoTrueConvGammaFromEtaPt(NULL),
 118         fHistoTruePosPionPt(NULL),
 119         fHistoTruePosPionFromEtaPt(NULL),
 120         fHistoTrueNegPionPt(NULL),
 121         fHistoTrueNegPionFromEtaPt(NULL),
 122         fHistoNEvents(NULL),
 123         fHistoNGoodESDTracks(NULL),
 124         fProfileEtaShift(NULL),
 125         fRandom(0),
 126         fnCuts(0),
 127         fiCut(0),
 128         fNumberOfESDTracks(0),
 129         fMoveParticleAccordingToVertex(kFALSE),
 130         fIsHeavyIon(kFALSE),
 131         fDoMesonAnalysis(kTRUE),
 132         fDoMesonQA(kFALSE),
 133         fIsFromMBHeader(kTRUE),
 134         fIsMC(kFALSE)
 135 {
 136
 137 }
 138
 139 //-----------------------------------------------------------------------------------------------
 140 AliAnalysisTaskEtaToPiPlPiMiGamma::AliAnalysisTaskEtaToPiPlPiMiGamma( const char* name ):
 141         AliAnalysisTaskSE(name),
 142         fV0Reader(NULL),
 143         fPionSelector(NULL),
 144         fBGHandler(NULL),
 145         fESDEvent(NULL),
 146         fMCEvent(NULL),
 147         fMCStack(NULL),
 148         fCutFolder(NULL),
 149         fESDList(NULL),
 150         fBackList(NULL),
 151         fMotherList(NULL),
 152         fTrueList(NULL),
 153         fMCList(NULL),
 154         fOutputContainer(0),
 155         fReaderGammas(NULL),
 156         fSelectorNegPionIndex(0),
 157         fSelectorPosPionIndex(0),
 158         fGoodGammas(NULL),
 159         fGoodVirtualParticles(NULL),
 160         fGammaCutArray(NULL),
 161         fPionCutArray(NULL),
 162         fMesonCutArray(NULL),
 163         fConversionCuts(NULL),
 164         fHistoConvGammaPt(NULL),
 165         fHistoConvGammaEta(NULL),
 166         fHistoNegPionPt(NULL),
 167         fHistoPosPionPt(NULL),
 168         fHistoNegPionPhi(NULL),
 169         fHistoPosPionPhi(NULL),
 170         fHistoNegPionEta(NULL),
 171         fHistoPosPionEta(NULL),
 172         fHistoNegPionClsTPC(NULL),
 173         fHistoPosPionClsTPC(NULL),
 174         fHistoPionDCAxy(NULL),
 175         fHistoPionDCAz(NULL),
 176         fHistoPionTPCdEdxNSigma(NULL),
 177         fHistoPionTPCdEdx(NULL),
 178         fHistoMotherInvMassPt(NULL),
 179         fTHnSparseMotherInvMassPtZM(NULL),
 180         fHistoMotherBackInvMassPt(NULL),
 181         fTHnSparseMotherBackInvMassPtZM(NULL),
 182         fHistoMCAllGammaPt(NULL),
 183         fHistoMCConvGammaPt(NULL),
 184         fHistoMCAllPosPionsPt(NULL),
 185         fHistoMCAllNegPionsPt(NULL),
 186         fHistoMCGammaFromEtaPt(NULL),
 187         fHistoMCPosPionsFromEtaPt(NULL),
 188         fHistoMCNegPionsFromEtaPt(NULL),
 189         fHistoMCEtaPiPlPiMiGammaPt(NULL),
 190         fHistoMCEtaGGPt(NULL),
 191         fHistoMCEtaDalitzPt(NULL),
 192         fHistoMCEtaPiPlPiMiGammaInAccPt(NULL),
 193         fHistoTrueMotherPiPlPiMiGammaInvMassPt(NULL),
 194         fHistoTrueMotherGammaGammaInvMassPt(NULL),
 195         fHistoTrueMotherDalitzInvMassPt(NULL),
 196         fHistoTrueConvGammaPt(NULL),
 197         fHistoTrueConvGammaFromEtaPt(NULL),
 198         fHistoTruePosPionPt(NULL),
 199         fHistoTruePosPionFromEtaPt(NULL),
 200         fHistoTrueNegPionPt(NULL),
 201         fHistoTrueNegPionFromEtaPt(NULL),
 202         fHistoNEvents(NULL),
 203         fHistoNGoodESDTracks(NULL),
 204         fProfileEtaShift(NULL),
 205         fRandom(0),
 206         fnCuts(0),
 207         fiCut(0),
 208         fNumberOfESDTracks(0),
 209         fMoveParticleAccordingToVertex(kFALSE),
 210         fIsHeavyIon(kFALSE),
 211         fDoMesonAnalysis(kTRUE),
 212         fDoMesonQA(kFALSE),
 213         fIsFromMBHeader(kTRUE),
 214         fIsMC(kFALSE)
 215 {
 216    DefineOutput(1, TList::Class());
 217 }
 218
 219 //-----------------------------------------------------------------------------------------------
 220 AliAnalysisTaskEtaToPiPlPiMiGamma::~AliAnalysisTaskEtaToPiPlPiMiGamma()
 221 {
 222         //
 223         // virtual destructor
 224         //
 225         cout<<"Destructor"<<endl;
 226         if(fGoodGammas){
 227                 delete fGoodGammas;
 228                 fGoodGammas = 0x0;
 229         }
 230         if(fGoodVirtualParticles){
 231                 delete fGoodVirtualParticles;
 232                 fGoodGammas = 0x0;
 233         }
 234         if(fBGHandler){
 235                 delete[] fBGHandler;
 236                 fBGHandler = 0x0;
 237         }
 238 }
 239 //___________________________________________________________
 240 void AliAnalysisTaskEtaToPiPlPiMiGamma::InitBack(){
 241
 242         const Int_t nDim = 4;
 243         Int_t nBins[nDim] = {800,250,7,4};
 244         Double_t xMin[nDim] = {0,0, 0,0};
 245         Double_t xMax[nDim] = {0.8,25,7,4};
 246
 247         fTHnSparseMotherInvMassPtZM = new THnSparseF*[fnCuts];
 248         fTHnSparseMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
 249
 250         fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
 251         for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 252
 253                 TString cutstringPion     =   ((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->GetCutNumber();
 254                 TString cutstringMeson        =   ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
 255                 TString cutstringGamma        =   ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetCutNumber();
 256
 257                 Int_t collisionSystem = atoi((TString)(((AliConversionCuts*)fGammaCutArray->At(iCut))->GetCutNumber())(0,1));
 258                 Int_t centMin = atoi((TString)(((AliConversionCuts*)fGammaCutArray->At(iCut))->GetCutNumber())(1,1));
 259                 Int_t centMax = atoi((TString)(((AliConversionCuts*)fGammaCutArray->At(iCut))->GetCutNumber())(2,1));
 260
 261                 if(collisionSystem == 1 || collisionSystem == 2 ||
 262                         collisionSystem == 5 || collisionSystem == 8 ||
 263                         collisionSystem == 9){
 264                         centMin = centMin*10;
 265                         centMax = centMax*10;
 266                 }
 267                 else if(collisionSystem == 3 || collisionSystem == 6){
 268                         centMin = centMin*5;
 269                         centMax = centMax*5;
 270                 }
 271                 else if(collisionSystem == 4 || collisionSystem == 7){
 272                         centMin = ((centMin*5)+45);
 273                         centMax = ((centMax*5)+45);
 274                 }
 275
 276
 277                 fBackList[iCut] = new TList();
 278                 fBackList[iCut]->SetName(Form("%s_%s_%s Back histograms",cutstringGamma.Data(),cutstringPion.Data(),cutstringMeson.Data()));
 279                 fBackList[iCut]->SetOwner(kTRUE);
 280                 fCutFolder[iCut]->Add(fBackList[iCut]);
 281
 282                 fTHnSparseMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
 283                 fBackList[iCut]->Add(fTHnSparseMotherBackInvMassPtZM[iCut]);
 284
 285                 fMotherList[iCut] = new TList();
 286                 fMotherList[iCut]->SetName(Form("%s_%s_%s Mother histograms",cutstringGamma.Data(),cutstringPion.Data(),cutstringMeson.Data()));
 287                 fMotherList[iCut]->SetOwner(kTRUE);
 288                 fCutFolder[iCut]->Add(fMotherList[iCut]);
 289
 290                 fTHnSparseMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
 291                 fMotherList[iCut]->Add(fTHnSparseMotherInvMassPtZM[iCut]);
 292
 293
 294                 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(  collisionSystem,centMin,centMax,
 295                                                                                                                                 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents(),
 296                                                                                                                                 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity());
 297
 298         }
 299 }
 300
 301 //______________________________________________________________________
 302 void AliAnalysisTaskEtaToPiPlPiMiGamma::UserCreateOutputObjects()
 303 {
 304         //
 305         // Create ouput objects
 306         //
 307
 308         // Create the output container
 309         if(fOutputContainer != NULL){
 310                 delete fOutputContainer;
 311                 fOutputContainer = NULL;
 312         }
 313         if(fOutputContainer == NULL){
 314                 fOutputContainer = new TList();
 315                 fOutputContainer->SetOwner(kTRUE);
 316         }
 317
 318         fGoodGammas = new TList();
 319         //fGoodGammas->SetOwner(kTRUE);
 320
 321         fGoodVirtualParticles = new TList();
 322         //fGoodVirtualParticles->SetOwner(kTRUE);
 323
 324         fCutFolder                              = new TList*[fnCuts];
 325         fESDList                                = new TList*[fnCuts];
 326         fBackList                               = new TList*[fnCuts];
 327         fMotherList                     = new TList*[fnCuts];
 328         fHistoNEvents                   = new TH1I*[fnCuts];
 329         fHistoNGoodESDTracks    = new TH1I*[fnCuts];
 330         fProfileEtaShift                = new TProfile*[fnCuts];
 331         fHistoConvGammaPt               = new TH1F*[fnCuts];
 332         fHistoConvGammaEta              = new TH1F*[fnCuts];
 333         fHistoNegPionPt                 = new TH1F*[fnCuts];
 334         fHistoPosPionPt                 = new TH1F*[fnCuts];
 335         fHistoNegPionPhi                = new TH1F*[fnCuts];
 336         fHistoPosPionPhi                = new TH1F*[fnCuts];
 337
 338         if( fDoMesonQA ) {
 339                 fHistoNegPionEta                = new TH1F*[fnCuts];
 340                 fHistoPosPionEta                = new TH1F*[fnCuts];
 341                 fHistoNegPionClsTPC             = new TH2F*[fnCuts];
 342                 fHistoPosPionClsTPC             = new TH2F*[fnCuts];
 343                 fHistoPionDCAxy                 = new TH2F*[fnCuts];
 344                 fHistoPionDCAz                  = new TH2F*[fnCuts];
 345                 fHistoPionTPCdEdxNSigma = new TH2F*[fnCuts];
 346                 fHistoPionTPCdEdx               = new TH2F*[fnCuts];
 347         }
 348
 349         fHistoMotherInvMassPt           = new TH2F*[fnCuts];
 350         fHistoMotherBackInvMassPt       = new TH2F*[fnCuts];
 351
 352         for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 353                 TString cutstringPion =((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->GetCutNumber();
 354                 TString cutstringMeson= ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
 355                 TString cutstringGamma = ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetCutNumber();
 356
 357                 fCutFolder[iCut] = new TList();
 358                 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s",cutstringGamma.Data(),cutstringPion.Data(),cutstringMeson.Data()));
 359                 fCutFolder[iCut]->SetOwner(kTRUE);
 360                 fOutputContainer->Add(fCutFolder[iCut]);
 361
 362                 fESDList[iCut] = new TList();
 363                 fESDList[iCut]->SetName(Form("%s_%s_%s ESD histograms",cutstringGamma.Data(),cutstringPion.Data(),cutstringMeson.Data()));
 364                 fESDList[iCut]->SetOwner(kTRUE);
 365
 366                 fHistoNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
 367                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
 368                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
 369                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
 370                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
 371                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
 372                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
 373                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
 374                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
 375                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
 376                 fESDList[iCut]->Add(fHistoNEvents[iCut]);
 377
 378                 if(fIsHeavyIon) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",3000,0,3000);
 379                         else fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
 380                 fESDList[iCut]->Add(fHistoNGoodESDTracks[iCut]);
 381
 382                 fProfileEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
 383                 fESDList[iCut]->Add(fProfileEtaShift[iCut]);
 384                 fHistoConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
 385                 fESDList[iCut]->Add(fHistoConvGammaPt[iCut]);
 386                 fHistoConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",600,-1.5,1.5);
 387                 fESDList[iCut]->Add(fHistoConvGammaEta[iCut]);
 388                 fHistoNegPionPt[iCut] = new TH1F("ESD_PrimaryNegPions_Pt","ESD_PrimaryNegPions_Pt",1000,0,25);
 389                 fESDList[iCut]->Add(fHistoNegPionPt[iCut]);
 390                 fHistoPosPionPt[iCut] = new TH1F("ESD_PrimaryPosPions_Pt","ESD_PrimaryPosPions_Pt",1000,0,25);
 391                 fESDList[iCut]->Add(fHistoPosPionPt[iCut]);
 392                 fHistoNegPionPhi[iCut] = new TH1F("ESD_PrimaryNegPions_Phi","ESD_PrimaryNegPions_Phi",360,0,2*TMath::Pi());
 393                 fESDList[iCut]->Add(fHistoNegPionPhi[iCut]);
 394                 fHistoPosPionPhi[iCut] = new TH1F("ESD_PrimaryPosPions_Phi","ESD_PrimaryPosPions_Phi",360,0,2*TMath::Pi());
 395                 fESDList[iCut]->Add(fHistoPosPionPhi[iCut]);
 396
 397                 if ( fDoMesonQA ) {
 398                         fHistoNegPionEta[iCut] = new TH1F("ESD_PrimaryNegPions_Eta","ESD_PrimaryNegPions_Eta",600,-1.5,1.5);
 399                         fESDList[iCut]->Add(fHistoNegPionEta[iCut]);
 400                         fHistoPosPionEta[iCut] = new TH1F("ESD_PrimaryPosPions_Eta","ESD_PrimaryPosPions_Eta",600,-1.5,1.5);
 401                         fESDList[iCut]->Add(fHistoPosPionEta[iCut]);
 402                         fHistoNegPionClsTPC[iCut]  = new TH2F("ESD_PrimaryNegPions_ClsTPC","ESD_PrimaryNegPions_ClsTPC",100,0,1,400,0.,10.);
 403                         fESDList[iCut]->Add(fHistoNegPionClsTPC[iCut]);
 404                         fHistoPosPionClsTPC[iCut]  = new TH2F("ESD_PrimaryPosPions_ClsTPC","ESD_PrimaryPosPions_ClsTPC",100,0,1,400,0.,10.);
 405                         fESDList[iCut]->Add(fHistoPosPionClsTPC[iCut]);
 406                         fHistoPionDCAxy[iCut] = new TH2F("ESD_PrimaryPions_DCAxy","ESD_PrimaryPions_DCAxy",800,-4.0,4.0,400,0.,10.);
 407                         fESDList[iCut]->Add(fHistoPionDCAxy[iCut]);
 408                         fHistoPionDCAz[iCut]  = new TH2F("ESD_PrimaryPions_DCAz","ESD_PrimaryPions_DCAz",800,-4.0,4.0,400,0.,10.);
 409                         fESDList[iCut]->Add(fHistoPionDCAz[iCut]);
 410                         fHistoPionTPCdEdxNSigma[iCut] = new TH2F("ESD_PrimaryPions_TPCdEdx","ESD_PrimaryPions_TPCdEdx",150,0.05,20,400,-10,10);
 411                         fESDList[iCut]->Add(fHistoPionTPCdEdxNSigma[iCut]);
 412                         fHistoPionTPCdEdx[iCut] =new TH2F("ESD_PrimaryPions_TPCdEdxSignal","ESD_PrimaryPions_TPCdEdxSignal" ,150,0.05,20.0,800,0.0,200);
 413                         fESDList[iCut]->Add(fHistoPionTPCdEdx[iCut]);
 414                 }
 415
 416                 fHistoMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",900,0.3,1.2,250,0,25);
 417                 fESDList[iCut]->Add(fHistoMotherInvMassPt[iCut]);
 418                 fHistoMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",900,0.3,1.2,250,0,25);
 419                 fESDList[iCut]->Add(fHistoMotherBackInvMassPt[iCut]);
 420
 421                 if ( fDoMesonQA ) {
 422                         TAxis *AxisAfter = fHistoPionTPCdEdxNSigma[iCut]->GetXaxis();
 423                         Int_t bins = AxisAfter->GetNbins();
 424                         Double_t from = AxisAfter->GetXmin();
 425                         Double_t to = AxisAfter->GetXmax();
 426                         Double_t *newBins = new Double_t[bins+1];
 427                         newBins[0] = from;
 428                         Double_t factor = TMath::Power(to/from, 1./bins);
 429                         for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];
 430
 431                         AxisAfter->Set(bins, newBins);
 432                         AxisAfter = fHistoPionTPCdEdx[iCut]->GetXaxis();
 433                         AxisAfter->Set(bins, newBins);
 434
 435                         delete [] newBins;
 436                 }
 437
 438                 fCutFolder[iCut]->Add(fESDList[iCut]);
 439
 440         }
 441
 442         if( fIsMC ){
 443                 // MC Histogramms
 444                 fMCList = new TList*[fnCuts];
 445                 // True Histogramms
 446                 fTrueList = new TList*[fnCuts];
 447                 fHistoTrueConvGammaPt = new TH1F*[fnCuts];
 448                 fHistoTrueConvGammaFromEtaPt = new TH1F*[fnCuts];
 449                 fHistoTruePosPionPt  = new TH1F*[fnCuts];
 450                 fHistoTrueNegPionPt  = new TH1F*[fnCuts];
 451                 fHistoTruePosPionFromEtaPt  = new TH1F*[fnCuts];
 452                 fHistoTrueNegPionFromEtaPt  = new TH1F*[fnCuts];
 453
 454
 455                 fHistoMCAllGammaPt  = new TH1F*[fnCuts];
 456                 fHistoMCConvGammaPt = new TH1F*[fnCuts];
 457                 fHistoMCAllPosPionsPt = new TH1F*[fnCuts];
 458                 fHistoMCAllNegPionsPt = new TH1F*[fnCuts];
 459                 fHistoMCGammaFromEtaPt  = new TH1F*[fnCuts];
 460                 fHistoMCPosPionsFromEtaPt = new TH1F*[fnCuts];
 461                 fHistoMCNegPionsFromEtaPt = new TH1F*[fnCuts];
 462
 463 //              hMCPi0DalitzGammaPt    = new TH1F*[fnCuts];
 464 //              hMCPi0DalitzElectronPt = new TH1F*[fnCuts];
 465 //              hMCPi0DalitzPositronPt = new TH1F*[fnCuts];
 466
 467                 fHistoMCEtaPiPlPiMiGammaPt = new TH1F*[fnCuts];
 468                 fHistoMCEtaDalitzPt = new TH1F*[fnCuts];
 469                 fHistoMCEtaGGPt = new TH1F*[fnCuts];
 470                 fHistoMCEtaPiPlPiMiGammaInAccPt = new TH1F*[fnCuts];
 471 //
 472                 fHistoTrueMotherPiPlPiMiGammaInvMassPt = new TH2F*[fnCuts];
 473                 fHistoTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
 474                 fHistoTrueMotherGammaGammaInvMassPt = new TH2F*[fnCuts];
 475
 476                 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 477                         TString cutstringPion =((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->GetCutNumber();
 478                         TString cutstringMeson= ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
 479                         TString cutstringGamma = ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetCutNumber();
 480
 481                         fMCList[iCut] = new TList();
 482                         fMCList[iCut]->SetName(Form("%s_%s_%s MC histograms",cutstringGamma.Data(),cutstringPion.Data(),cutstringMeson.Data()));
 483                         fMCList[iCut]->SetOwner(kTRUE);
 484                         fCutFolder[iCut]->Add(fMCList[iCut]);
 485
 486                         fHistoMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
 487                         fMCList[iCut]->Add(fHistoMCAllGammaPt[iCut]);
 488                         fHistoMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
 489                         fMCList[iCut]->Add(fHistoMCConvGammaPt[iCut]);
 490                         fHistoMCAllPosPionsPt[iCut] = new TH1F("MC_AllPosPions_Pt","MC_AllPosPions_Pt",1000,0,25);
 491                         fMCList[iCut]->Add(fHistoMCAllPosPionsPt[iCut]);
 492                         fHistoMCAllNegPionsPt[iCut] = new TH1F("MC_AllNegPions_Pt","MC_AllNegPions_Pt",1000,0,25);
 493                         fMCList[iCut]->Add(fHistoMCAllNegPionsPt[iCut]);
 494                         fHistoMCGammaFromEtaPt[iCut] = new TH1F("MC_GammaFromEta_Pt","MC_GammaFromEta_Pt",250,0,25);
 495                         fMCList[iCut]->Add(fHistoMCGammaFromEtaPt[iCut]);
 496                         fHistoMCPosPionsFromEtaPt[iCut] = new TH1F("MC_PosPionsFromEta_Pt","MC_PosPionsFromEta_Pt",1000,0,25);
 497                         fMCList[iCut]->Add(fHistoMCPosPionsFromEtaPt[iCut]);
 498                         fHistoMCNegPionsFromEtaPt[iCut] = new TH1F("MC_NegPionsFromEta_Pt","MC_NegPionsFromEta_Pt",1000,0,25);
 499                         fMCList[iCut]->Add(fHistoMCNegPionsFromEtaPt[iCut]);
 500
 501                         fHistoMCEtaPiPlPiMiGammaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
 502                         fHistoMCEtaPiPlPiMiGammaPt[iCut]->Sumw2();
 503                         fMCList[iCut]->Add(fHistoMCEtaPiPlPiMiGammaPt[iCut]);
 504
 505                         fHistoMCEtaDalitzPt[iCut] = new TH1F("MC_Eta_Dalitz_Pt","MC_Eta_Pt",250,0,25);
 506                         fHistoMCEtaDalitzPt[iCut]->Sumw2();
 507                         fMCList[iCut]->Add(fHistoMCEtaDalitzPt[iCut]);
 508
 509                         fHistoMCEtaGGPt[iCut] = new TH1F("MC_Eta_GG_Pt","MC_Eta_GG_Pt",250,0,25);
 510                         fHistoMCEtaGGPt[iCut]->Sumw2();
 511                         fMCList[iCut]->Add(fHistoMCEtaGGPt[iCut]);
 512
 513                         fHistoMCEtaPiPlPiMiGammaInAccPt[iCut] = new TH1F("MC_EtaDalitzInAcc_Pt","MC_EtaDalitzInAcc_Pt",250,0,25);
 514                         fHistoMCEtaPiPlPiMiGammaInAccPt[iCut]->Sumw2();
 515                         fMCList[iCut]->Add(fHistoMCEtaPiPlPiMiGammaInAccPt[iCut]);
 516
 517                         fTrueList[iCut] = new TList();
 518                         fTrueList[iCut]->SetName(Form("%s_%s_%s True histograms",cutstringGamma.Data(),cutstringPion.Data(),cutstringMeson.Data()));
 519                         fTrueList[iCut]->SetOwner(kTRUE);
 520                         fCutFolder[iCut]->Add(fTrueList[iCut]);
 521
 522                         fHistoTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
 523                         fTrueList[iCut]->Add(fHistoTrueConvGammaPt[iCut]);
 524                         fHistoTrueConvGammaFromEtaPt[iCut] = new TH1F("ESD_TrueConvGammaFromEta_Pt","ESD_TrueConvGammaFromEta_Pt",250,0,25);
 525                         fTrueList[iCut]->Add(fHistoTrueConvGammaFromEtaPt[iCut]);
 526
 527                         fHistoTruePosPionPt[iCut] = new TH1F("ESD_TruePosPion_Pt","ESD_TruePosPion_Pt",1000,0,25);
 528                         fTrueList[iCut]->Add(fHistoTruePosPionPt[iCut]);
 529                         fHistoTrueNegPionPt[iCut] = new TH1F("ESD_TrueNegPion_Pt","ESD_TrueNegPion_Pt",1000,0,25);
 530                         fTrueList[iCut]->Add(fHistoTrueNegPionPt[iCut]);
 531
 532                         fHistoTrueNegPionFromEtaPt[iCut] = new TH1F("ESD_TrueNegPionFromEta_Pt","ESD_TrueNegPionFromEta_Pt",1000,0,25);
 533                         fTrueList[iCut]->Add(fHistoTrueNegPionFromEtaPt[iCut]);
 534                         fHistoTruePosPionFromEtaPt[iCut] = new TH1F("ESD_TruePosPionFromEta_Pt","ESD_TruePosPionFromEta_Pt",1000,0,25);
 535                         fTrueList[iCut]->Add(fHistoTruePosPionFromEtaPt[iCut]);
 536
 537                         fHistoTrueMotherPiPlPiMiGammaInvMassPt[iCut] = new TH2F("ESD_TrueMotherPiPlPiMiGamma_InvMass_Pt","ESD_TrueMotherPiPlPiMiGamma_InvMass_Pt",900,0.3,1.4,250,0,25);
 538                         fHistoTrueMotherPiPlPiMiGammaInvMassPt[iCut]->Sumw2();
 539                         fTrueList[iCut]->Add(fHistoTrueMotherPiPlPiMiGammaInvMassPt[iCut]);
 540
 541                         fHistoTrueMotherGammaGammaInvMassPt[iCut] = new TH2F("ESD_TrueMotherGG_InvMass_Pt","ESD_TrueMotherGG_InvMass_Pt",900,0.3,1.4,250,0,25);
 542                         fHistoTrueMotherGammaGammaInvMassPt[iCut]->Sumw2();
 543                         fTrueList[iCut]->Add(fHistoTrueMotherGammaGammaInvMassPt[iCut]);
 544
 545                         fHistoTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueMotherDalitz_InvMass_Pt","ESD_TrueMotherDalitz_InvMass_Pt",900,0.3,1.4,250,0,25);
 546                         fHistoTrueMotherDalitzInvMassPt[iCut]->Sumw2();
 547                         fTrueList[iCut]->Add(fHistoTrueMotherDalitzInvMassPt[iCut]);
 548
 549                 }
 550         }
 551
 552
 553
 554         InitBack(); // Init Background Handler
 555
 556         fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
 557         if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
 558
 559         if(fV0Reader)
 560                 if((AliConversionCuts*)fV0Reader->GetConversionCuts())
 561                         if(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
 562                                 fOutputContainer->Add(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
 563
 564
 565
 566         fPionSelector=(AliPrimaryPionSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("PionSelector");
 567         if(!fPionSelector){printf("Error: No PionSelector");return;} // GetV0Reader
 568
 569         if( fPionSelector ){
 570                 if ( ((AliPrimaryPionCuts*)fPionSelector->GetPrimaryPionCuts())->GetCutHistograms() ){
 571                         fOutputContainer->Add( ((AliPrimaryPionCuts*)fPionSelector->GetPrimaryPionCuts())->GetCutHistograms() );
 572                 }
 573         }
 574
 575         for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 576                 if( fPionCutArray ){
 577                         if( ((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->GetCutHistograms() ) {
 578                                 fCutFolder[iCut]->Add( ((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->GetCutHistograms() );
 579                         }
 580                 }
 581                 if( fMesonCutArray  ) {
 582                         if( ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms() ) {
 583                                 fCutFolder[iCut]->Add( ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
 584                         }
 585                 }
 586                 if( fGammaCutArray ) {
 587                         if( ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetCutHistograms() ) {
 588                                 fCutFolder[iCut]->Add( ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetCutHistograms()  );
 589                         }
 590                 }
 591         }
 592
 593         PostData(1, fOutputContainer);
 594
 595 }
 596
 597 //______________________________________________________________________
 598 void AliAnalysisTaskEtaToPiPlPiMiGamma::UserExec(Option_t *){
 599
 600         //
 601         // Execute analysis for current event
 602         //
 603
 604         fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
 605         if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
 606
 607         Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
 608
 609         if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
 610                 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
 611                         fHistoNEvents[iCut]->Fill(eventQuality);
 612                 }
 613                 return;
 614         }
 615
 616         fPionSelector=(AliPrimaryPionSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("PionSelector");
 617         if(!fPionSelector){printf("Error: No PionSelector");return;} // GetV0Reader
 618
 619         if(fIsMC) fMCEvent     =  MCEvent();
 620         fESDEvent        = (AliESDEvent*)InputEvent();
 621         fReaderGammas    = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
 622         fSelectorNegPionIndex = fPionSelector->GetReconstructedNegPionIndex(); // Electrons from default Cut
 623         fSelectorPosPionIndex = fPionSelector->GetReconstructedPosPionIndex(); // Positrons from default Cut
 624
 625         fNumberOfESDTracks = fV0Reader->GetNumberOfPrimaryTracks();
 626         //AddTaskContainers(); //Add conatiner
 627
 628         for(Int_t iCut = 0; iCut<fnCuts; iCut++){
 629                 fiCut = iCut;
 630                 Int_t eventNotAccepted =
 631                         ((AliConversionCuts*)fGammaCutArray->At(iCut))
 632                         ->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
 633
 634                 if(eventNotAccepted){
 635                         //                      cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
 636                         fHistoNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
 637                         continue;
 638                 }
 639
 640                 if(eventQuality != 0){// Event Not Accepted
 641                         //                      cout << "event rejected due to: " <<eventQuality << endl;
 642                         fHistoNEvents[iCut]->Fill(eventQuality);
 643                         continue;
 644                 }
 645
 646                 fHistoNEvents[iCut]->Fill(eventQuality);
 647                 fHistoNGoodESDTracks[iCut]->Fill(fNumberOfESDTracks);
 648
 649                 if(fMCEvent){ // Process MC Particle
 650                         fMCStack = fMCEvent->Stack();
 651                         if(((AliConversionCuts*)fGammaCutArray->At(iCut))->GetSignalRejection() != 0){
 652                                 ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fGammaCutArray->At(iCut))->GetSignalRejection(), ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetAcceptedHeader(),
 653                                                                                                         fMCEvent);
 654                         }
 655                         ProcessMCParticles();
 656                 }
 657
 658 //              cout << "new event" << endl;
 659                 ProcessPhotonCandidates(); // Process this cuts gammas
 660                 ProcessPionCandidates(); // Process this cuts gammas
 661
 662
 663                 CalculateMesonCandidates();
 664                 CalculateBackground();
 665                 UpdateEventByEventData();
 666
 667                 fGoodGammas->Clear(); // delete this cuts good gammas
 668                 fGoodVirtualParticles->Clear(); // delete this cuts good gammas
 669         }
 670
 671         fSelectorNegPionIndex.clear();
 672         fSelectorPosPionIndex.clear();
 673
 674         PostData( 1, fOutputContainer );
 675 }
 676
 677 Bool_t AliAnalysisTaskEtaToPiPlPiMiGamma::Notify(){
 678         for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 679                 if( !((AliConversionCuts*)fGammaCutArray->At(iCut))->GetDoEtaShift() ){
 680                         fProfileEtaShift[iCut]->Fill(0.,0.);
 681                         continue; // No Eta Shift requested, continue
 682                 }
 683                 if( ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
 684                         ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
 685                         ((AliConversionCuts*)fGammaCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
 686                         ((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->SetEtaShift( ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetEtaShift() );
 687                         fProfileEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fGammaCutArray->At(iCut))->GetEtaShift()));
 688                         continue;
 689                 } else {
 690                         printf(" Eta t PiPlusPiMinus Gamma Task %s :: Eta Shift Manually Set to %f \n\n",
 691                         (((AliConversionCuts*)fGammaCutArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fGammaCutArray->At(iCut))->GetEtaShift());
 692                         ((AliConversionCuts*)fGammaCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
 693                         ((AliPrimaryPionCuts*)fPionCutArray->At(iCut))->SetEtaShift( ((AliConversionCuts*)fGammaCutArray->At(iCut))->GetEtaShift() );
 694                         fProfileEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fGammaCutArray->At(iCut))->GetEtaShift()));
 695                 }
 696         }
 697         return kTRUE;
 698 }
 699
 700
 701 void AliAnalysisTaskEtaToPiPlPiMiGamma::Terminate(const Option_t *){
 702 ///Grid
 703 }
 704
 705 //________________________________________________________________________
 706 void AliAnalysisTaskEtaToPiPlPiMiGamma::ProcessPhotonCandidates(){
 707         Int_t nV0 = 0;
 708         TList *GoodGammasStepOne = new TList();
 709         TList *GoodGammasStepTwo = new TList();
 710         // Loop over Photon Candidates allocated by ReaderV1
 711
 712         for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
 713                 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
 714                 if(!PhotonCandidate) continue;
 715
 716                 fIsFromMBHeader = kTRUE;
 717
 718                 if( fMCEvent && ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetSignalRejection() != 0 ){
 719                         Int_t isPosFromMBHeader
 720                                 = ((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
 721                         if(isPosFromMBHeader == 0 && ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
 722                         Int_t isNegFromMBHeader
 723                                 = ((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
 724                         if(isNegFromMBHeader == 0 && ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
 725                         if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
 726                 }
 727
 728                 if(!((AliConversionCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fESDEvent)) continue;
 729
 730                 if(!((AliConversionCuts*)fGammaCutArray->At(fiCut))->UseElecSharingCut() &&
 731                         !((AliConversionCuts*)fGammaCutArray->At(fiCut))->UseToCloseV0sCut()){ // if no post reader loop is required add to events good gammas
 732
 733                         fGoodGammas->Add(PhotonCandidate);
 734
 735                         if(fIsFromMBHeader){
 736                                 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
 737                                 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
 738                         }
 739
 740                         if(fMCEvent){
 741                                 ProcessTruePhotonCandidates(PhotonCandidate);
 742                         }
 743                 } else if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
 744                         ((AliConversionCuts*)fGammaCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
 745                         nV0++;
 746                         GoodGammasStepOne->Add(PhotonCandidate);
 747                 } else if(!((AliConversionCuts*)fGammaCutArray->At(fiCut))->UseElecSharingCut() &&
 748                                 ((AliConversionCuts*)fGammaCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
 749                         GoodGammasStepTwo->Add(PhotonCandidate);
 750                 }
 751         }
 752
 753
 754         if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->UseElecSharingCut()){
 755                 for(Int_t i = 0;i<GoodGammasStepOne->GetEntries();i++){
 756                         AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GoodGammasStepOne->At(i);
 757                         if(!PhotonCandidate) continue;
 758                         fIsFromMBHeader = kTRUE;
 759                         if(fMCEvent && ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetSignalRejection() != 0){
 760                                 Int_t isPosFromMBHeader
 761                                 = ((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack,fInputEvent);
 762                                 Int_t isNegFromMBHeader
 763                                 = ((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
 764                                 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
 765                         }
 766                         if(!((AliConversionCuts*)fGammaCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GoodGammasStepOne->GetEntries())) continue;
 767                         if(!((AliConversionCuts*)fGammaCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
 768                                 fGoodGammas->Add(PhotonCandidate);
 769                                 if(fIsFromMBHeader){
 770                                         fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
 771                                         fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
 772                                 }
 773                                 if(fMCEvent){
 774                                         ProcessTruePhotonCandidates(PhotonCandidate);
 775                                 }
 776                         }
 777                         else GoodGammasStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
 778                 }
 779         }
 780         if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->UseToCloseV0sCut()){
 781                 for(Int_t i = 0;i<GoodGammasStepTwo->GetEntries();i++){
 782                         AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GoodGammasStepTwo->At(i);
 783                         if(!PhotonCandidate) continue;
 784
 785                         if(fMCEvent && ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetSignalRejection() != 0){
 786                                 Int_t isPosFromMBHeader
 787                                 = ((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack,fInputEvent);
 788                                 Int_t isNegFromMBHeader
 789                                 = ((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
 790                                 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
 791                         }
 792
 793                         if(!((AliConversionCuts*)fGammaCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GoodGammasStepTwo,i)) continue;
 794                         fGoodGammas->Add(PhotonCandidate); // Add gamma to current cut TList
 795
 796                         if(fIsFromMBHeader){
 797                                 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt()); // Differences to old V0Reader in p_t due to conversion KF->TLorentzVector
 798                                 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
 799                         }
 800
 801                         if(fMCEvent){
 802                                 ProcessTruePhotonCandidates(PhotonCandidate);
 803                         }
 804                 }
 805         }
 806
 807         delete GoodGammasStepOne;
 808         GoodGammasStepOne = 0x0;
 809         delete GoodGammasStepTwo;
 810         GoodGammasStepTwo = 0x0;
 811 }
 812
 813 //________________________________________________________________________
 814 void AliAnalysisTaskEtaToPiPlPiMiGamma::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
 815 {
 816         // Process True Photons
 817         AliStack *MCStack = fMCEvent->Stack();
 818         TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(MCStack);
 819         TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(MCStack);
 820
 821         if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
 822         if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){  // Not Same Mother == Combinatorial Bck
 823                 return;
 824         }
 825
 826         else if (posDaughter->GetMother(0) == -1){
 827                 return;
 828         }
 829
 830         if(TMath::Abs(posDaughter->GetPdgCode())!=11 || TMath::Abs(negDaughter->GetPdgCode())!=11) return; //One Particle is not electron
 831         if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
 832         if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
 833
 834         TParticle *Photon = TruePhotonCandidate->GetMCParticle(MCStack);
 835         if(Photon->GetPdgCode() != 22) return; // Mother is no Photon
 836
 837         // True Photon
 838
 839         Int_t labelGamma = TruePhotonCandidate->GetMCParticleLabel(MCStack);
 840
 841         if( labelGamma < MCStack->GetNprimary() ){
 842                 if( fIsFromMBHeader ){
 843                 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
 844                 }
 845         }
 846
 847         if( IsEtaPiPlPiMiGammaDaughter(labelGamma) == kTRUE ) {
 848                 if( labelGamma < MCStack->GetNprimary() ) {
 849                         if( fIsFromMBHeader ){
 850                                 fHistoTrueConvGammaFromEtaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
 851                         }
 852                 }
 853         }
 854 }
 855
 856 //________________________________________________________________________
 857 void AliAnalysisTaskEtaToPiPlPiMiGamma::ProcessPionCandidates(){
 858
 859         Double_t magField = fInputEvent->GetMagneticField();
 860         if( magField  < 0.0 ){
 861                 magField =  1.0;
 862         } else {
 863                 magField =  -1.0;
 864         }
 865
 866         vector<Int_t> lGoodNegPionIndexPrev(0);
 867         vector<Int_t> lGoodPosPionIndexPrev(0);
 868
 869         for(UInt_t i = 0; i < fSelectorNegPionIndex.size(); i++){
 870                 AliESDtrack* negPionCandidate = fESDEvent->GetTrack(fSelectorNegPionIndex[i]);
 871                 if(! ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelected(negPionCandidate) ) continue;
 872                 lGoodNegPionIndexPrev.push_back(   fSelectorNegPionIndex[i] );
 873                 fHistoNegPionPt[fiCut]->Fill(negPionCandidate->Pt());
 874                 fHistoNegPionPhi[fiCut]->Fill(negPionCandidate->Phi());
 875                 if( fMCEvent ) {
 876                         Int_t labelNegPion = TMath::Abs( negPionCandidate->GetLabel() );
 877                         if( labelNegPion < fMCStack->GetNtrack() ){
 878                                 TParticle* negPion = fMCStack->Particle(labelNegPion);
 879                                 if( negPion->GetPdgCode() ==  -211 ){
 880                                         if( labelNegPion < fMCStack->GetNprimary() ){
 881                                                 fHistoTrueNegPionPt[fiCut]->Fill(negPionCandidate->Pt());    //primary negPion
 882                                         }
 883                                         if( IsEtaPiPlPiMiGammaDaughter(labelNegPion) == kTRUE ) {
 884                                                 if( labelNegPion < fMCStack->GetNprimary() ) {
 885                                                         fHistoTrueNegPionFromEtaPt[fiCut]->Fill(negPionCandidate->Pt());
 886                                                 }
 887                                         }
 888                                 }
 889                         }
 890                 }
 891         }
 892
 893         for(UInt_t i = 0; i < fSelectorPosPionIndex.size(); i++){
 894                 AliESDtrack* posPionCandidate = fESDEvent->GetTrack( fSelectorPosPionIndex[i] );
 895                 if(! ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelected(posPionCandidate) ) continue;
 896                 lGoodPosPionIndexPrev.push_back(   fSelectorPosPionIndex[i]  );
 897                 fHistoPosPionPt[fiCut]->Fill( posPionCandidate->Pt() );
 898                 fHistoPosPionPhi[fiCut]->Fill( posPionCandidate->Phi() );
 899
 900                 if( fMCEvent ) {
 901                         Int_t labelPosPion = TMath::Abs( posPionCandidate->GetLabel() );
 902                         if( labelPosPion < fMCStack->GetNtrack() ) {
 903                                 TParticle* posPion = fMCStack->Particle(labelPosPion);
 904                                 if( posPion->GetPdgCode() ==  211 ){
 905                                         if( labelPosPion < fMCStack->GetNprimary() ){
 906                                                 fHistoTruePosPionPt[fiCut]->Fill(posPionCandidate->Pt());
 907                                         }
 908                                         if( IsEtaPiPlPiMiGammaDaughter(labelPosPion) == kTRUE ) {
 909                                                 if( labelPosPion < fMCStack->GetNprimary() ){
 910                                                         fHistoTruePosPionFromEtaPt[fiCut]->Fill(posPionCandidate->Pt());
 911                                                 }
 912                                         }
 913                                 }
 914                         }
 915                 }
 916         }
 917
 918
 919         for(UInt_t i = 0; i < lGoodNegPionIndexPrev.size(); i++){
 920
 921                 AliESDtrack *negPionCandidate = fESDEvent->GetTrack(lGoodNegPionIndexPrev[i]);
 922                 AliKFParticle negPionCandidateKF( *negPionCandidate->GetConstrainedParam(), 211 );
 923
 924                 for(UInt_t j = 0; j < lGoodPosPionIndexPrev.size(); j++){
 925
 926                         AliESDtrack *posPionCandidate = fESDEvent->GetTrack(lGoodPosPionIndexPrev[j]);
 927                         AliKFParticle posPionCandidateKF( *posPionCandidate->GetConstrainedParam(), 211 );
 928
 929                         AliKFConversionPhoton* virtualPhoton = NULL;
 930                         virtualPhoton = new AliKFConversionPhoton(negPionCandidateKF,posPionCandidateKF);
 931                         AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
 932 //                      primaryVertexImproved+=*virtualPhoton;
 933                         virtualPhoton->SetProductionVertex(primaryVertexImproved);
 934                         virtualPhoton->SetTrackLabels( lGoodPosPionIndexPrev[j], lGoodNegPionIndexPrev[i]);
 935
 936
 937                         if( fMCEvent ) {
 938                                 Int_t labeln=TMath::Abs(negPionCandidate->GetLabel());
 939                                 Int_t labelp=TMath::Abs(posPionCandidate->GetLabel());
 940                                 TParticle *fNegativeMCParticle = fMCStack->Particle(labeln);
 941                                 TParticle *fPositiveMCParticle = fMCStack->Particle(labelp);
 942
 943                                 if( fPositiveMCParticle && fNegativeMCParticle) {
 944                                         virtualPhoton->SetMCLabelPositive(labelp);
 945                                         virtualPhoton->SetMCLabelNegative(labeln);
 946                                 }
 947                         }
 948
 949                         AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton); //To Apply PsiPairCut
 950                         fGoodVirtualParticles->Add(  vphoton );
 951                         delete virtualPhoton;
 952                         virtualPhoton=NULL;
 953
 954                 }
 955         }
 956 }
 957
 958 //_____________________________________________________________________________
 959 void AliAnalysisTaskEtaToPiPlPiMiGamma::ProcessMCParticles(){
 960
 961         // Loop over all primary MC particle
 962
 963         for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
 964
 965                 TParticle* particle = (TParticle *)fMCStack->Particle(i);
 966                 if (!particle) continue;
 967
 968                 Int_t isMCFromMBHeader = -1;
 969                 if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetSignalRejection() != 0){
 970                         isMCFromMBHeader
 971                                 = ((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
 972                         if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
 973                 }
 974
 975                 if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack,fInputEvent)){
 976
 977                         if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
 978                                 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
 979                                 if(particle->GetMother(0) >-1){
 980                                         if (fMCStack->Particle(particle->GetMother(0))->GetPdgCode() ==221 && fMCStack->Particle(particle->GetMother(0))->GetNDaughters()==3 ) fHistoMCGammaFromEtaPt[fiCut]->Fill(particle->Pt()); // All pos from eta
 981                                 }
 982                         }
 983
 984                         if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
 985                                 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
 986                         } // Converted MC Gamma
 987
 988                         if(((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelectedMC(i,fMCStack)){
 989                                 if( particle->GetPdgCode() == 211){
 990                                         fHistoMCAllPosPionsPt[fiCut]->Fill(particle->Pt()); // All pos pions
 991                                         if(particle->GetMother(0) >-1){
 992                                                 if (fMCStack->Particle(particle->GetMother(0))->GetPdgCode() ==221) fHistoMCPosPionsFromEtaPt[fiCut]->Fill(particle->Pt()); // All pos from eta
 993                                         }
 994                                 }
 995                                 if( particle->GetPdgCode() == -211){
 996                                         fHistoMCAllNegPionsPt[fiCut]->Fill(particle->Pt()); // All neg pions
 997                                         if(particle->GetMother(0) >-1){
 998                                                 if (fMCStack->Particle(particle->GetMother(0))->GetPdgCode() ==221) fHistoMCNegPionsFromEtaPt[fiCut]->Fill(particle->Pt()); // All pos from eta
 999                                         }
1000                                 }
1001                         }
1002
1003                         // \eta -> \gamma \gamma
1004
1005                         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC( particle,fMCStack,((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetEtaShift() ) ){
1006                                 Float_t weighted= 1;
1007                                 if( ((AliPrimaryPionCuts*) fPionCutArray->At(fiCut))->DoWeights() ) {
1008                                         if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1009                                                 if (particle->Pt()>0.005){
1010                                                         weighted= ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
1011                                                 }
1012                                         }
1013                                 }
1014                                 if(particle->GetPdgCode() == 221)fHistoMCEtaGGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Eta GG decay
1015                         }
1016
1017                         // \eta -> e+ e- \gamma
1018                         Int_t labelgamma          = -1;
1019                         Int_t labelelectron = -1;
1020                         Int_t labelpositron = -1;
1021
1022                         if( ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMCDalitz(particle,fMCStack,labelelectron,labelpositron,labelgamma,((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetEtaShift())){
1023                                 Float_t weighted= 1;
1024                                 if( ((AliPrimaryPionCuts*) fPionCutArray->At(fiCut))->DoWeights() ) {
1025                                         if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack,fInputEvent)){
1026                                                 if (particle->Pt()>0.005){
1027                                                         weighted= ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
1028                                                 }
1029                                         }
1030                                 }
1031                                 if(particle->GetPdgCode() == 221)fHistoMCEtaDalitzPt[fiCut]->Fill(particle->Pt(), weighted); // All MC Eta
1032                         }
1033
1034
1035                         // \eta -> pi+ pi- \gamma
1036                         Int_t labelGamma3Body     = -1;
1037                         Int_t labelNegPion = -1;
1038                         Int_t labelPosPion = -1;
1039
1040                         if( ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMCEtaPiPlPiMiGamma(particle,fMCStack,labelNegPion,labelPosPion,labelGamma3Body,((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetEtaShift())){
1041                                 Float_t weighted= 1;
1042                                 if( ((AliPrimaryPionCuts*) fPionCutArray->At(fiCut))->DoWeights() ) {
1043                                         if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack,fInputEvent)){
1044                                                 if (particle->Pt()>0.005){
1045                                                         weighted= ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
1046                                                 }
1047                                         }
1048                                 }
1049                                 if(particle->GetPdgCode() == 221)fHistoMCEtaPiPlPiMiGammaPt[fiCut]->Fill(particle->Pt(), weighted); // All MC Eta
1050
1051                                 TParticle *gamma    = fMCStack->Particle(labelGamma3Body);
1052                                 if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->PhotonIsSelectedMC(gamma,fMCStack,kFALSE) &&
1053                                 ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelectedMC(labelNegPion,fMCStack) &&
1054                                 ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->PionIsSelectedMC(labelPosPion,fMCStack) ) {
1055                                         if(particle->GetPdgCode() == 221)fHistoMCEtaPiPlPiMiGammaInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC EtaDalitz with gamma and e+e- in acc
1056                                 }
1057                         }
1058                 }
1059         }
1060 }
1061
1062
1063 //________________________________________________________________________
1064 void AliAnalysisTaskEtaToPiPlPiMiGamma::CalculateMesonCandidates(){
1065
1066         // Conversion Gammas
1067         if( fGoodGammas->GetEntries() > 0 && fGoodVirtualParticles->GetEntries() > 0 ){
1068
1069                 vector<Bool_t> lGoodVirtualParticle(fGoodVirtualParticles->GetEntries(), kFALSE);
1070
1071                 for(Int_t GammaIndex=0; GammaIndex<fGoodGammas->GetEntries(); GammaIndex++){
1072
1073                         AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(GammaIndex));
1074                         if (gamma==NULL) continue;
1075                         for(Int_t virtualParticleIndex=0;virtualParticleIndex<fGoodVirtualParticles->GetEntries();virtualParticleIndex++){
1076
1077                                 AliAODConversionPhoton *Vgamma=dynamic_cast<AliAODConversionPhoton*>(fGoodVirtualParticles->At(virtualParticleIndex));
1078                                 if (Vgamma==NULL) continue;
1079                                 //Check for same Electron ID
1080                                 if(gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelPositive() ||
1081                                 gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelNegative() ||
1082                                 gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelPositive() ||
1083                                 gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelNegative() ) continue;
1084
1085                                 AliAODConversionMother *etacand = new AliAODConversionMother(gamma,Vgamma);
1086                                 etacand->SetLabels(GammaIndex,virtualParticleIndex);
1087
1088
1089                                 if( ( ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(etacand,kTRUE,((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetEtaShift())) ){
1090
1091                                         //cout<< "Meson Accepted "<<endl;
1092
1093                                         Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
1094                                         Int_t mbin = 0;
1095                                         if( ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1096                                                 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1097                                         } else {
1098                                                 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
1099                                         }
1100
1101                                         AliESDtrack *posPionVgamma = 0;
1102                                         AliESDtrack *negPionVgamma = 0;
1103
1104                                         Double_t clsToFPos = -1.0;
1105                                         Double_t clsToFNeg = -1.0;
1106
1107                                         Float_t dcaToVertexXYPos = -1.0;
1108                                         Float_t dcaToVertexZPos  = -1.0;
1109                                         Float_t dcaToVertexXYNeg = -1.0;
1110                                         Float_t dcaToVertexZNeg  = -1.0;
1111
1112
1113                                         if ( fDoMesonQA ) {
1114
1115                                                 posPionVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
1116                                                 negPionVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
1117                                                 clsToFPos = ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->GetNFindableClustersTPC(posPionVgamma);
1118                                                 clsToFNeg = ((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->GetNFindableClustersTPC(negPionVgamma);
1119
1120                                                 Float_t bPos[2];
1121                                                 Float_t bCovPos[3];
1122                                                 posPionVgamma->GetImpactParameters(bPos,bCovPos);
1123                                                 if (bCovPos[0]<=0 || bCovPos[2]<=0) {
1124                                                         AliDebug(1, "Estimated b resolution lower or equal zero!");
1125                                                         bCovPos[0]=0; bCovPos[2]=0;
1126                                                 }
1127
1128                                                 Float_t bNeg[2];
1129                                                 Float_t bCovNeg[3];
1130                                                 posPionVgamma->GetImpactParameters(bNeg,bCovNeg);
1131                                                 if (bCovNeg[0]<=0 || bCovNeg[2]<=0) {
1132                                                         AliDebug(1, "Estimated b resolution lower or equal zero!");
1133                                                         bCovNeg[0]=0; bCovNeg[2]=0;
1134                                                 }
1135
1136                                                 dcaToVertexXYPos = bPos[0];
1137                                                 dcaToVertexZPos  = bPos[1];
1138                                                 dcaToVertexXYNeg = bNeg[0];
1139                                                 dcaToVertexZNeg  = bNeg[1];
1140                                         }
1141
1142                                         fHistoMotherInvMassPt[fiCut]->Fill(etacand->M(),etacand->Pt());
1143                                         Double_t sparesFill[4] = {etacand->M(),etacand->Pt(),(Double_t)zbin,(Double_t)mbin};
1144                                         fTHnSparseMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1145
1146                                         if ( fDoMesonQA ) {
1147                                                 if( lGoodVirtualParticle[virtualParticleIndex] == kFALSE ) {
1148
1149                                                         fHistoNegPionEta[fiCut]->Fill( negPionVgamma->Eta() );
1150                                                         fHistoPosPionEta[fiCut]->Fill( posPionVgamma->Eta() );
1151
1152                                                         fHistoNegPionClsTPC[fiCut]->Fill(clsToFNeg,negPionVgamma->Pt());
1153                                                         fHistoPosPionClsTPC[fiCut]->Fill(clsToFPos,posPionVgamma->Pt());
1154
1155                                                         fHistoPionDCAxy[fiCut]->Fill(  dcaToVertexXYNeg, negPionVgamma->Pt() );
1156                                                         fHistoPionDCAz[fiCut]->Fill(   dcaToVertexZNeg,  negPionVgamma->Pt() );
1157                                                         fHistoPionDCAxy[fiCut]->Fill(  dcaToVertexXYPos, posPionVgamma->Pt() );
1158                                                         fHistoPionDCAz[fiCut]->Fill(   dcaToVertexZPos,  posPionVgamma->Pt() );
1159
1160                                                         fHistoPionTPCdEdxNSigma[fiCut]->Fill( posPionVgamma->P(),((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(posPionVgamma, AliPID::kPion) );
1161                                                         fHistoPionTPCdEdxNSigma[fiCut]->Fill( negPionVgamma->P(),((AliPrimaryPionCuts*)fPionCutArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(negPionVgamma, AliPID::kPion) );
1162
1163                                                         fHistoPionTPCdEdx[fiCut]->Fill( posPionVgamma->P(), TMath::Abs(posPionVgamma->GetTPCsignal()));
1164                                                         fHistoPionTPCdEdx[fiCut]->Fill( negPionVgamma->P(), TMath::Abs(negPionVgamma->GetTPCsignal()));
1165
1166                                                         lGoodVirtualParticle[virtualParticleIndex] = kTRUE;
1167
1168                                                 }
1169                                         }
1170
1171
1172                                         if(fMCEvent){
1173                                                 ProcessTrueMesonCandidates(etacand,gamma,Vgamma);
1174                                         }
1175                                 }
1176                                 delete etacand;
1177                                 etacand=0x0;
1178                         }
1179                 }
1180         }
1181 }
1182
1183 //________________________________________________________________________
1184 void AliAnalysisTaskEtaToPiPlPiMiGamma::CalculateBackground(){
1185
1186         Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
1187         Int_t mbin = 0;
1188
1189
1190         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1191                 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1192         } else {
1193                 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
1194         }
1195
1196         Int_t method = 1;
1197         AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
1198         if( ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity() ) {
1199                 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
1200                         AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
1201                         if(fMoveParticleAccordingToVertex == kTRUE && method == 1){
1202                                 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
1203                         }
1204
1205                         for(Int_t iCurrent=0;iCurrent<fGoodVirtualParticles->GetEntries();iCurrent++){
1206                                 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualParticles->At(iCurrent));
1207
1208                                 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
1209                                         AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
1210
1211                                         if(fMoveParticleAccordingToVertex == kTRUE && method == 1 ){
1212                                                 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
1213                                         }
1214
1215                                         AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
1216
1217
1218                                         if( ( ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE, ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetEtaShift()))){
1219                                                 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1220                                                 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1221                                                 fTHnSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1222                                         }
1223                                         delete backgroundCandidate;
1224                                         backgroundCandidate = 0x0;
1225                                 }
1226                         }
1227                 }
1228         } else {
1229                 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
1230                         AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
1231                         if(previousEventV0s){
1232                                 if(fMoveParticleAccordingToVertex == kTRUE && method == 1){
1233                                         bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
1234                                 }
1235                                 for(Int_t iCurrent=0;iCurrent<fGoodVirtualParticles->GetEntries();iCurrent++){
1236
1237                                         AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualParticles->At(iCurrent));
1238
1239                                         for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
1240
1241                                                 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
1242
1243                                                 if(fMoveParticleAccordingToVertex == kTRUE && method ==1){
1244                                                         MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
1245                                                 }
1246
1247                                                 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
1248
1249                                                 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetEtaShift()))){
1250                                                         fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1251                                                         Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1252                                                         fTHnSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1253                                                 }
1254                                                 delete backgroundCandidate;
1255                                                 backgroundCandidate = 0x0;
1256                                         }
1257                                 }
1258                         }
1259                 }
1260         }
1261 }
1262
1263 //______________________________________________________________________
1264 void AliAnalysisTaskEtaToPiPlPiMiGamma::ProcessTrueMesonCandidates(AliAODConversionMother *EtaCandidate, AliAODConversionPhoton *TrueGammaCandidate, AliAODConversionPhoton *TrueVirtualParticleCandidate){
1265
1266         // Process True Mesons
1267
1268         AliStack *MCStack = fMCEvent->Stack();
1269
1270         if(     TrueGammaCandidate->GetV0Index()<fESDEvent->GetNumberOfV0s()    ){
1271
1272                 Bool_t isTrueEta = kFALSE;
1273                 Int_t gammaMCLabel = TrueGammaCandidate->GetMCParticleLabel(MCStack);
1274                 Int_t gammaMotherLabel = -1;
1275
1276                 if(gammaMCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1277                         // Daughters Gamma 0
1278                         TParticle * negativeMC = (TParticle*)TrueGammaCandidate->GetNegativeMCDaughter(MCStack);
1279                         TParticle * positiveMC = (TParticle*)TrueGammaCandidate->GetPositiveMCDaughter(MCStack);
1280                         TParticle * gammaMC = (TParticle*)MCStack->Particle(gammaMCLabel);
1281
1282                         if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){  // Electrons ...
1283                                 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1284                                         if(gammaMC->GetPdgCode() == 22){ // ... with Gamma Mother
1285                                                 gammaMotherLabel=gammaMC->GetFirstMother();
1286                                         }
1287                                 }
1288                         }
1289                 }
1290
1291                 Int_t virtualParticleMCLabel = TrueVirtualParticleCandidate->GetMCParticleLabel(MCStack);
1292                 Int_t virtualParticleMotherLabel = -1;
1293
1294                 Bool_t isPiPiDecay = kFALSE;
1295                 Bool_t isDalitz = kFALSE;
1296                 Bool_t isRealGamma = kFALSE;
1297
1298                 if(virtualParticleMCLabel != -1){ // if virtualParticleMCLabel==-1 particles don't have same mother
1299                         TParticle * negativeMC = (TParticle*)TrueVirtualParticleCandidate->GetNegativeMCDaughter(MCStack);
1300                         TParticle * positiveMC = (TParticle*)TrueVirtualParticleCandidate->GetPositiveMCDaughter(MCStack);
1301 //                      cout << "neg Part: label - " <<  TrueVirtualParticleCandidate->GetMCLabelNegative() <<" pdg-code - " << negativeMC->GetPdgCode() << endl;
1302 //                      cout << "pos Part: label - " <<  TrueVirtualParticleCandidate->GetMCLabelPositive() <<" pdg-code - " << positiveMC->GetPdgCode() << endl;
1303
1304                         TParticle * virtualParticleMotherMC = (TParticle*)MCStack->Particle(virtualParticleMCLabel);
1305 //                      cout << "pdg code same mother - " << virtualParticleMotherMC->GetPdgCode() << endl;
1306
1307                         if(TMath::Abs(negativeMC->GetPdgCode())==211 && TMath::Abs(positiveMC->GetPdgCode())==211){  // Pions ...
1308                                 virtualParticleMotherLabel=virtualParticleMCLabel;
1309                                 isPiPiDecay=kTRUE;
1310                         } else if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){  // Electrons ...
1311                                 if( virtualParticleMotherMC->GetPdgCode() != 22 ){
1312                                         virtualParticleMotherLabel=virtualParticleMCLabel;
1313                                         isDalitz = kTRUE;
1314                                 } else if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1315                                         virtualParticleMotherLabel=virtualParticleMotherMC->GetFirstMother();
1316                                         isRealGamma = kTRUE; //no virtual gamma
1317                                 }
1318                         }
1319                 }
1320
1321                 if(gammaMotherLabel >= 0 && ( gammaMotherLabel == virtualParticleMotherLabel) ){
1322                         if(((TParticle*)MCStack->Particle(virtualParticleMotherLabel))->GetPdgCode() == 221){
1323                                 isTrueEta=kTRUE;
1324                         }
1325                 }
1326
1327                 if( isTrueEta ){ // True Eta
1328                         if ( isPiPiDecay) { //real eta -> Pi+ Pi- Gamma
1329                                 Float_t weighted= 1;
1330                                 if( ((AliPrimaryPionCuts*) fPionCutArray->At(fiCut))->DoWeights() ) {
1331                                         if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
1332                                                 if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
1333                                                         weighted= ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
1334                                                 }
1335                                         }
1336                                 }
1337
1338                                 fHistoTrueMotherPiPlPiMiGammaInvMassPt[fiCut]->Fill(EtaCandidate->M(),EtaCandidate->Pt(),weighted);
1339                         } else if ( isRealGamma ){
1340                                 Float_t weighted= 1;
1341                                 if( ((AliPrimaryPionCuts*) fPionCutArray->At(fiCut))->DoWeights() ) {
1342                                         if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
1343                                                 if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
1344                                                         weighted= ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
1345                                                 }
1346                                         }
1347                                 }
1348
1349                                 fHistoTrueMotherGammaGammaInvMassPt[fiCut]->Fill(EtaCandidate->M(),EtaCandidate->Pt(),weighted);
1350                         } else if (isDalitz) {
1351                                 Float_t weighted= 1;
1352                                 if( ((AliPrimaryPionCuts*) fPionCutArray->At(fiCut))->DoWeights() ) {
1353                                         if(((AliConversionCuts*)fGammaCutArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
1354                                                 if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
1355                                                         weighted= ((AliConversionCuts*)fGammaCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
1356                                                 }
1357                                         }
1358                                 }
1359                                 fHistoTrueMotherDalitzInvMassPt[fiCut]->Fill(EtaCandidate->M(),EtaCandidate->Pt(),weighted);
1360                         }
1361                 }
1362         }
1363 }
1364
1365
1366 //________________________________________________________________________
1367 void AliAnalysisTaskEtaToPiPlPiMiGamma::UpdateEventByEventData(){
1368    //see header file for documentation
1369
1370         Int_t method = 1;
1371         if( method == 1 ) {
1372                 if(fGoodGammas->GetEntries() >0 ){
1373                         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1374                                 fBGHandler[fiCut]->AddEvent(fGoodGammas,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),0);
1375                         } else{ // means we use #V0s for multiplicity
1376                                 fBGHandler[fiCut]->AddEvent(fGoodGammas,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGoodGammas->GetEntries(),0);
1377                         }
1378                 }
1379         } else if ( method == 2 ){
1380                 if(fGoodVirtualParticles->GetEntries() > 0 ){
1381                         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1382                                 fBGHandler[fiCut]->AddEvent(fGoodVirtualParticles,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),0);
1383                         } else{ // means we use #V0s for multiplicity
1384                                 fBGHandler[fiCut]->AddEvent(fGoodVirtualParticles,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGoodVirtualParticles->GetEntries(),0);
1385                         }
1386                 }
1387         }
1388 }
1389
1390 //________________________________________________________________________
1391 void AliAnalysisTaskEtaToPiPlPiMiGamma::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
1392    //see header file for documentation
1393
1394    Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
1395    Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
1396    Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
1397
1398    Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
1399    particle->SetConversionPoint(movedPlace);
1400 }
1401
1402 //_____________________________________________________________________________________
1403 Bool_t AliAnalysisTaskEtaToPiPlPiMiGamma::IsEtaPiPlPiMiGammaDaughter( Int_t label ) const {
1404 //
1405 // Returns true if the particle comes from eta -> pi+ pi- gamma
1406 //
1407         Int_t motherLabel = fMCStack->Particle( label )->GetMother(0);
1408         if( motherLabel < 0 || motherLabel >= fMCStack->GetNtrack() ) return kFALSE;
1409
1410         TParticle* mother = fMCStack->Particle( motherLabel );
1411         if( mother->GetPdgCode() != 221 ) return kFALSE;
1412         if( IsPiPlPiMiGammaDecay( mother ) ) return kTRUE;
1413         return kFALSE;
1414 }
1415
1416 //_____________________________________________________________________________
1417 Bool_t AliAnalysisTaskEtaToPiPlPiMiGamma::IsPiPlPiMiGammaDecay(TParticle *fMCMother) const
1418 {
1419
1420         if( fMCMother->GetNDaughters() != 3 ) return kFALSE;
1421         if( fMCMother->GetPdgCode() != 221 ) return kFALSE;
1422
1423
1424         TParticle *posPion = 0x0;
1425         TParticle *negPion = 0x0;
1426         TParticle *gamma    = 0x0;
1427
1428         for(Int_t index= fMCMother->GetFirstDaughter();index<= fMCMother->GetLastDaughter();index++){
1429                 TParticle* temp = (TParticle*)fMCStack->Particle( index );
1430
1431                 switch( temp->GetPdgCode() ) {
1432                 case 211:
1433                         posPion =  temp;
1434                         break;
1435                 case -211:
1436                         negPion =  temp;
1437                         break;
1438                 case ::kGamma:
1439                         gamma    =  temp;
1440                         break;
1441                 }
1442         }
1443
1444         if( posPion && negPion && gamma) return kTRUE;
1445
1446         return kFALSE;
1447 }