PWGGA/GammaConv/AliAnalysisTaskEtaToPiPlPiMiGamma.cxx

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