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