[u/mrichter/AliRoot.git] / PWG4 / GammaConv / AliAnalysisTaskGCPartToPWG4Part.cxx

#include <iostream>
#include "TChain.h"
#include "TTree.h"
#include "TH1F.h"
#include "TCanvas.h"
#include "TString.h"

#include "AliAnalysisTask.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisTaskGCPartToPWG4Part.h"

#include "AliESDEvent.h"
#include "AliESDCaloCluster.h"
#include "AliESDInputHandler.h"

#include "AliAODPWG4ParticleCorrelation.h"
#include "AliAODEvent.h"
#include "AliAODHandler.h"
#include "AliAODCaloCluster.h"
#include "AliGammaConversionAODObject.h"
#include "AliAODConversionParticle.h"
#include "AliAODJet.h"

#include "AliAODInputHandler.h"

#include "AliAODMCParticle.h"

#include "AliMCAnalysisUtils.h"


#include "AliAODMCHeader.h"
// Gamma - jet correlation analysis task
// Authors: Svein Lindal


using namespace std;

ClassImp(AliAnalysisTaskGCPartToPWG4Part)

//________________________________________________________________________
AliAnalysisTaskGCPartToPWG4Part::AliAnalysisTaskGCPartToPWG4Part() 
: AliAnalysisTaskSE(), 
  fDeltaAODFileName(""),
  fAODBranchName("GammaConv_gamma"),
  fAODPWG4Particles(NULL),
  fAnaUtils(NULL)
{
  // Dummy Constructor
}

//________________________________________________________________________________
AliAnalysisTaskGCPartToPWG4Part::~AliAnalysisTaskGCPartToPWG4Part() {

  if(fAODPWG4Particles)
    fAODPWG4Particles = NULL;
  delete fAODPWG4Particles;

  if(fAnaUtils)
    delete fAnaUtils;
  fAnaUtils = NULL;

}


//________________________________________________________________________
AliAnalysisTaskGCPartToPWG4Part::AliAnalysisTaskGCPartToPWG4Part(const char *name) : 
  AliAnalysisTaskSE(name), 
  fDeltaAODFileName(""),
  fAODBranchName("GammaConv_gamma"),
  fAODPWG4Particles(NULL),
  fAnaUtils(NULL)
{
  // Constructor
  DefineInput(0, TChain::Class());
  // Output slot #0 id reserved by the base class for AOD

  // Output slot #1 writes into a TH1 container
  DefineOutput(1, TList::Class());

  fAnaUtils = new AliMCAnalysisUtils();
}


//________________________________________________________________________
void AliAnalysisTaskGCPartToPWG4Part::UserCreateOutputObjects() {
  fAODPWG4Particles = new TClonesArray("AliAODPWG4ParticleCorrelation", 0);
  fAODPWG4Particles->SetName("ConversionGamma");
  AddAODBranch("TClonesArray", &fAODPWG4Particles);

}

//________________________________________________________________________
void AliAnalysisTaskGCPartToPWG4Part::UserExec(Option_t *) 
{
  
  //AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);

  //Clear stuff for new event
  CleanUp();

  ///Get AOD event
  AliAODEvent * aodEvent = GetAODEvent();
  if(!aodEvent) {
    AliError("No AOD event!!");
    return;
  }
  

  ProcessConvGamma(aodEvent);


  //PostData(1, fOutputList);
        
}


//___________________________________________________________________________________________
void AliAnalysisTaskGCPartToPWG4Part::ProcessConvGamma( const AliAODEvent * const aodEvent ) {
  
  TClonesArray * tracks = aodEvent->GetTracks();
  if(!tracks) {
    cout << "No tracks!!!"<<endl;
    return;
  }


  TClonesArray * convGamma = GetConversionGammas(aodEvent);
  if(!convGamma) {
    AliError(Form("No branch by name %s found in file %s", fAODBranchName.Data(), fDeltaAODFileName.Data()));
    return;
  }


  TClonesArray * arrayMC = dynamic_cast<TClonesArray*>(aodEvent->GetList()->FindObject(AliAODMCParticle::StdBranchName()));  
  for (Int_t iPhot = 0; iPhot < convGamma->GetEntriesFast(); iPhot++) {
    
    AliAODPWG4Particle * photon = dynamic_cast<AliAODPWG4Particle*>(convGamma->At(iPhot));
    if(photon) {
      AliGammaConversionAODObject * aodO = dynamic_cast<AliGammaConversionAODObject*>(convGamma->At(iPhot));
    } else {
      
      AliAODConversionParticle * convParticle = dynamic_cast<AliAODConversionParticle*>(convGamma->At(iPhot));
      if (convParticle) {
        AliAODPWG4ParticleCorrelation * photon = AddToAOD(convParticle, fAODPWG4Particles, "ConvGamma");
      } else {
	AliError(Form("ERROR: Could not receive ga %d\n", iPhot));
	continue;
      }
    }
  }

}


//////_________________________________________________________________________________________
Int_t AliAnalysisTaskGCPartToPWG4Part::CheckTag(AliAODPWG4ParticleCorrelation * particle, TClonesArray * tracks, TClonesArray * arrayMC, AliAODMCHeader * mcHeader) {


  for (int imc = 0; imc < arrayMC->GetEntriesFast(); imc++) {
  //for (int imc = 0; imc < 20; imc++) {

    
    AliAODMCParticle * mParticle = dynamic_cast<AliAODMCParticle*>(arrayMC->At(imc));
    //    cout << mParticle->GetPdgCode() << " " <<mParticle->GetStatus() << endl;

   
    //if( mParticle->GetPdgCode() == 34) cout<< "BALLE"<<endl;// && mParticle->GetMother() < 10) {

    if( mParticle->GetPdgCode() == 22 ) { //&& mParticle->GetMother() < 10) {
      AliAODMCParticle * mother = dynamic_cast<AliAODMCParticle*>(arrayMC->At(mParticle->GetMother()));
      //if (TMath::Abs(mother->GetPdgCode()) < 22 && TMath::Abs(mother->GetPdgCode()) != 11) cout  <<"KKKKKKKKK"<< mother->GetPdgCode() <<endl;
	
      for (int id = 0; id < mParticle->GetNDaughters(); id++) {
  	int idaughter = mParticle->GetDaughter(id);
  	if(idaughter>0 && idaughter < arrayMC->GetEntriesFast()) {
  	  AliAODMCParticle * dmParticle = dynamic_cast<AliAODMCParticle*>(arrayMC->At(mParticle->GetDaughter(id)));
  	  //cout  << dmParticle->GetPdgCode() << endl; 
  	}
      }
    }
  }


  Int_t tag = 0;

  Int_t l1 = particle->GetTrackLabel(0);
  Int_t l2 = particle->GetTrackLabel(1);
  
  AliAODTrack * track1 = NULL;
  AliAODTrack * track2 = NULL;


  for(int i = 0; i < tracks->GetEntriesFast(); i++) {
    
    AliAODTrack * track = (AliAODTrack*)tracks->At(i);
    if (track->GetID() == l1) {
      track1 = track;
    } else if (track->GetID() == l2) {
      track2 = track; 
    }
    
    if(track1 && track2) break;
  }


  if(!track1 || !track2) return tag;
  if(track1->GetLabel() < 0 || track2->GetLabel() < 0) {
    //cout << "error balla"<< endl; 
  
  } else { 

    AliAODMCParticle * mcPart1 = dynamic_cast<AliAODMCParticle*>(arrayMC->At(track1->GetLabel()));
    AliAODMCParticle * mcPart2 = dynamic_cast<AliAODMCParticle*>(arrayMC->At(track2->GetLabel()));
    
    if (mcPart1 && mcPart2) {

      if(mcPart1->GetMother() == mcPart2->GetMother()) {
	
	AliAODMCParticle * photon = dynamic_cast<AliAODMCParticle*>(arrayMC->At(mcPart1->GetMother()));
	Int_t motherIndex = photon->GetMother();
	tag= fAnaUtils->CheckOriginInAOD(&motherIndex, 1, arrayMC);

	AliAODMCParticle * mother = dynamic_cast<AliAODMCParticle*>(arrayMC->At(motherIndex));
	

	if (photon->GetPdgCode() == 22 ) {

	  if (TMath::Abs(mother->GetPdgCode()) < 22 && TMath::Abs(mother->GetPdgCode()) != 11) {
	    
	    fAnaUtils->SetTagBit(tag, AliMCAnalysisUtils::kMCPhoton);
	    fAnaUtils->SetTagBit(tag, AliMCAnalysisUtils::kMCPrompt);
	    
	    cout  <<"KKKKKKKKK "<< mother->GetPdgCode() << " " << mother->GetStatus() << " mi " << motherIndex << " daught: " << mother->GetNDaughters() << endl;
	    cout << photon->GetStatus() << " " << photon->Pt() << " headerpt:" << mcHeader->GetPtHard() << " " <<mcPart1->GetMother() << endl;
	    
	  }
	} else {
	  cout << "FAKE "<< photon->PdgCode() << " " << photon->Pt() << " " <<  photon->GetStatus() << endl;
	}


	Int_t parentId = mother->GetMother();
	AliAODMCParticle * gp = dynamic_cast<AliAODMCParticle*>(arrayMC->At(parentId));


	if(! mother->IsPrimary()) {
	  //cout << mother->GetPdgCode() << " " << mother->GetStatus() <<endl;
	  //	  cout << "other one? " << mother->PdgCode() << " " << gp->PdgCode() << " " << gp->GetStatus() << endl;
	  //	cout << "yeay3  " <<  mother->GetPdgCode() << endl;
 
	} else { //if (mother->IsPhysicalPrimary() ){
	  
	  
	  if(mother->GetStatus() < 10) {
	    //cout << "yeay4  " <<  mother->GetPdgCode() << endl;
 	    // cout << "pion? " << gp->PdgCode() << " " << gp->GetStatus() << endl;
	    //cout << "???" << mother->PdgCode() << " " << mother->GetStatus() << " " << gp->PdgCode() << " " << gp->GetStatus() << endl;
	  } else {
	    //cout << "yeay5  " <<  mother->GetPdgCode() << endl;
	    //cout << "other? " << mother->PdgCode() << " " << mother->GetStatus() << " " << gp->PdgCode() << " " << gp->GetStatus() << endl;
	  }
	  
	  
	  // } else {
	  //   cout << "MI: " << mother->GetPdgCode() << " " << mother->GetStatus() <<endl;
	}
	
      }
    }
  }
  //cout << "REturn tag " << tag << endl;
  return tag;
}


///__________________________________________________________________________________
AliAODPWG4ParticleCorrelation * AliAnalysisTaskGCPartToPWG4Part::AddToAOD(AliGammaConversionAODObject * aodO, TClonesArray * branch, TString detector) {
  new((*branch)[branch->GetEntriesFast()]) AliAODPWG4ParticleCorrelation(aodO->Px(), aodO->Py(), aodO->Pz(), aodO->E());
  AliAODPWG4ParticleCorrelation * photon = dynamic_cast<AliAODPWG4ParticleCorrelation*>(branch->Last());
  photon->SetTagged(aodO->IsTagged());
  photon->SetTrackLabel(aodO->GetLabel1(), aodO->GetLabel2());
  photon->SetDetector(detector);
  return photon;
}

///__________________________________________________________________________________
AliAODPWG4ParticleCorrelation * AliAnalysisTaskGCPartToPWG4Part::AddToAOD(AliAODConversionParticle * aodO, TClonesArray * branch, TString detector) {
  new((*branch)[branch->GetEntriesFast()]) AliAODPWG4ParticleCorrelation(aodO->Px(), aodO->Py(), aodO->Pz(), aodO->E());
  AliAODPWG4ParticleCorrelation * photon = dynamic_cast<AliAODPWG4ParticleCorrelation*>(branch->Last());
  photon->SetTrackLabel(aodO->GetLabel1(), aodO->GetLabel2());
  photon->SetDetector(detector);
  return photon;
}


//_____________________________________________________________________
void AliAnalysisTaskGCPartToPWG4Part::Terminate(Option_t *) {
  // Draw result to the screen
  // Called once at the end of the query
}

//_____________________________________________________________________
AliAODEvent * AliAnalysisTaskGCPartToPWG4Part::GetAODEvent() {
  //Get the AOD event from whereever it might be
  AliAODEvent * aodEvent = dynamic_cast<AliAODEvent*>(InputEvent());
  if(!aodEvent) {
    aodEvent = AODEvent();
  }
  
  return aodEvent;

}

//_____________________________________________________________________
TClonesArray * AliAnalysisTaskGCPartToPWG4Part::GetConversionGammas(const AliAODEvent * aodEvent) {

  //Get Conversion gamma branch of AOD. First try standard AOD
  TClonesArray * convGamma = dynamic_cast<TClonesArray*>(aodEvent->FindListObject(fAODBranchName.Data()));
  

  //If it's there, send it back
  if(convGamma)  return convGamma;


  //If AOD not in standard file have to locate it in delta AOD
  if( !(fDeltaAODFileName.Length() > 0)  ) return NULL;
  
  AliAODHandler * aodHandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()); 
  if(aodHandler) {
    AliAODExtension * gExt = dynamic_cast<AliAODExtension*>(aodHandler->GetExtensions()->FindObject(fDeltaAODFileName));
    if(gExt) {
      AliAODEvent * gcEvent = gExt->GetAOD();
      return dynamic_cast<TClonesArray*>(gcEvent->FindListObject("GammaConv_gamma"));
    }
  }  
  return NULL;
}

//_________________________________________________________________________
void AliAnalysisTaskGCPartToPWG4Part::CleanUp() {
  fAODPWG4Particles->Delete();
}
Commit	Line	Data
e0b4c21c	1	#include <iostream>
	2	#include "TChain.h"
	3	#include "TTree.h"
	4	#include "TH1F.h"
	5	#include "TCanvas.h"
	6	#include "TString.h"
	7
	8	#include "AliAnalysisTask.h"
	9	#include "AliAnalysisManager.h"
	10	#include "AliAnalysisTaskGCPartToPWG4Part.h"
	11
	12	#include "AliESDEvent.h"
	13	#include "AliESDCaloCluster.h"
	14	#include "AliESDInputHandler.h"
	15
	16	#include "AliAODPWG4ParticleCorrelation.h"
	17	#include "AliAODEvent.h"
	18	#include "AliAODHandler.h"
	19	#include "AliAODCaloCluster.h"
	20	#include "AliGammaConversionAODObject.h"
	21	#include "AliAODConversionParticle.h"
	22	#include "AliAODJet.h"
	23
	24	#include "AliAODInputHandler.h"
	25
e6637b75	26	#include "AliAODMCParticle.h"
	27
	28	#include "AliMCAnalysisUtils.h"
	29
f50e7d42	30
f50e7d42	31	#include "AliAODMCHeader.h"
e0b4c21c	32	// Gamma - jet correlation analysis task
	33	// Authors: Svein Lindal
	34
	35
	36	using namespace std;
	37
	38	ClassImp(AliAnalysisTaskGCPartToPWG4Part)
	39
	40	//________________________________________________________________________
	41	AliAnalysisTaskGCPartToPWG4Part::AliAnalysisTaskGCPartToPWG4Part()
	42	: AliAnalysisTaskSE(),
e6637b75	43	fDeltaAODFileName(""),
	44	fAODBranchName("GammaConv_gamma"),
	45	fAODPWG4Particles(NULL),
	46	fAnaUtils(NULL)
e0b4c21c	47	{
	48	// Dummy Constructor
	49	}
	50
	51	//________________________________________________________________________________
	52	AliAnalysisTaskGCPartToPWG4Part::~AliAnalysisTaskGCPartToPWG4Part() {
	53
	54	if(fAODPWG4Particles)
	55	fAODPWG4Particles = NULL;
	56	delete fAODPWG4Particles;
	57
e6637b75	58	if(fAnaUtils)
	59	delete fAnaUtils;
	60	fAnaUtils = NULL;
	61
e0b4c21c	62	}
	63
	64
	65
	66	//________________________________________________________________________
	67	AliAnalysisTaskGCPartToPWG4Part::AliAnalysisTaskGCPartToPWG4Part(const char *name) :
	68	AliAnalysisTaskSE(name),
e6637b75	69	fDeltaAODFileName(""),
	70	fAODBranchName("GammaConv_gamma"),
	71	fAODPWG4Particles(NULL),
	72	fAnaUtils(NULL)
e0b4c21c	73	{
	74	// Constructor
	75	DefineInput(0, TChain::Class());
	76	// Output slot #0 id reserved by the base class for AOD
	77
	78	// Output slot #1 writes into a TH1 container
	79	DefineOutput(1, TList::Class());
e6637b75	80
e6637b75	81	fAnaUtils = new AliMCAnalysisUtils();
e0b4c21c	82	}
	83
	84
	85
	86	//________________________________________________________________________
	87	void AliAnalysisTaskGCPartToPWG4Part::UserCreateOutputObjects() {
	88	fAODPWG4Particles = new TClonesArray("AliAODPWG4ParticleCorrelation", 0);
	89	fAODPWG4Particles->SetName("ConversionGamma");
	90	AddAODBranch("TClonesArray", &fAODPWG4Particles);
	91
	92	}
	93
	94	//________________________________________________________________________
	95	void AliAnalysisTaskGCPartToPWG4Part::UserExec(Option_t *)
	96	{
	97
	98	//AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
	99
	100	//Clear stuff for new event
	101	CleanUp();
	102
	103	///Get AOD event
	104	AliAODEvent * aodEvent = GetAODEvent();
	105	if(!aodEvent) {
	106	AliError("No AOD event!!");
	107	return;
	108	}
	109
	110
	111	ProcessConvGamma(aodEvent);
f50e7d42	112
e0b4c21c	113
	114	//PostData(1, fOutputList);
	115
	116	}
	117
	118
	119
f50e7d42	120
e0b4c21c	121	//___________________________________________________________________________________________
	122	void AliAnalysisTaskGCPartToPWG4Part::ProcessConvGamma( const AliAODEvent * const aodEvent ) {
	123
	124	TClonesArray * tracks = aodEvent->GetTracks();
	125	if(!tracks) {
	126	cout << "No tracks!!!"<<endl;
	127	return;
	128	}
	129
	130
	131	TClonesArray * convGamma = GetConversionGammas(aodEvent);
	132	if(!convGamma) {
	133	AliError(Form("No branch by name %s found in file %s", fAODBranchName.Data(), fDeltaAODFileName.Data()));
	134	return;
	135	}
f50e7d42	136
f50e7d42	137
d7a5bf22	138	TClonesArray * arrayMC = dynamic_cast<TClonesArray*>(aodEvent->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
d7a5bf22	139	for (Int_t iPhot = 0; iPhot < convGamma->GetEntriesFast(); iPhot++) {
e0b4c21c	140
d7a5bf22	141	AliAODPWG4Particle * photon = dynamic_cast<AliAODPWG4Particle*>(convGamma->At(iPhot));
	142	if(photon) {
	143	AliGammaConversionAODObject * aodO = dynamic_cast<AliGammaConversionAODObject*>(convGamma->At(iPhot));
	144	} else {
e0b4c21c	145
d7a5bf22	146	AliAODConversionParticle * convParticle = dynamic_cast<AliAODConversionParticle*>(convGamma->At(iPhot));
	147	if (convParticle) {
	148	AliAODPWG4ParticleCorrelation * photon = AddToAOD(convParticle, fAODPWG4Particles, "ConvGamma");
	149	} else {
	150	AliError(Form("ERROR: Could not receive ga %d\n", iPhot));
	151	continue;
	152	}
f50e7d42	153	}
e6637b75	154	}
f50e7d42	155
e6637b75	156	}
e6637b75	157
f50e7d42	158
e6637b75	159	//////_________________________________________________________________________________________
f50e7d42	160	Int_t AliAnalysisTaskGCPartToPWG4Part::CheckTag(AliAODPWG4ParticleCorrelation * particle, TClonesArray * tracks, TClonesArray * arrayMC, AliAODMCHeader * mcHeader) {
	161
	162
f50e7d42	163	for (int imc = 0; imc < arrayMC->GetEntriesFast(); imc++) {
	164	//for (int imc = 0; imc < 20; imc++) {
	165
	166
	167
	168	AliAODMCParticle * mParticle = dynamic_cast<AliAODMCParticle*>(arrayMC->At(imc));
	169	// cout << mParticle->GetPdgCode() << " " <<mParticle->GetStatus() << endl;
	170
	171
	172	//if( mParticle->GetPdgCode() == 34) cout<< "BALLE"<<endl;// && mParticle->GetMother() < 10) {
	173
	174	if( mParticle->GetPdgCode() == 22 ) { //&& mParticle->GetMother() < 10) {
	175	AliAODMCParticle * mother = dynamic_cast<AliAODMCParticle*>(arrayMC->At(mParticle->GetMother()));
	176	//if (TMath::Abs(mother->GetPdgCode()) < 22 && TMath::Abs(mother->GetPdgCode()) != 11) cout <<"KKKKKKKKK"<< mother->GetPdgCode() <<endl;
	177
	178	for (int id = 0; id < mParticle->GetNDaughters(); id++) {
	179	int idaughter = mParticle->GetDaughter(id);
	180	if(idaughter>0 && idaughter < arrayMC->GetEntriesFast()) {
	181	AliAODMCParticle * dmParticle = dynamic_cast<AliAODMCParticle*>(arrayMC->At(mParticle->GetDaughter(id)));
	182	//cout << dmParticle->GetPdgCode() << endl;
	183	}
	184	}
	185	}
	186	}
	187
	188
	189
	190
	191
	192
	193
	194
	195
	196
	197
e6637b75	198
	199	Int_t tag = 0;
	200
	201	Int_t l1 = particle->GetTrackLabel(0);
	202	Int_t l2 = particle->GetTrackLabel(1);
	203
	204	AliAODTrack * track1 = NULL;
	205	AliAODTrack * track2 = NULL;
	206
	207
	208	for(int i = 0; i < tracks->GetEntriesFast(); i++) {
	209
	210	AliAODTrack * track = (AliAODTrack*)tracks->At(i);
	211	if (track->GetID() == l1) {
	212	track1 = track;
	213	} else if (track->GetID() == l2) {
	214	track2 = track;
	215	}
	216
	217	if(track1 && track2) break;
	218	}
	219
	220
b2d693ff	221	if(!track1 \|\| !track2) return tag;
e6637b75	222	if(track1->GetLabel() < 0 \|\| track2->GetLabel() < 0) {
	223	//cout << "error balla"<< endl;
	224
	225	} else {
	226
	227	AliAODMCParticle * mcPart1 = dynamic_cast<AliAODMCParticle*>(arrayMC->At(track1->GetLabel()));
	228	AliAODMCParticle * mcPart2 = dynamic_cast<AliAODMCParticle*>(arrayMC->At(track2->GetLabel()));
	229
	230	if (mcPart1 && mcPart2) {
f50e7d42	231
e6637b75	232	if(mcPart1->GetMother() == mcPart2->GetMother()) {
e6637b75	233
f50e7d42	234	AliAODMCParticle * photon = dynamic_cast<AliAODMCParticle*>(arrayMC->At(mcPart1->GetMother()));
	235	Int_t motherIndex = photon->GetMother();
	236	tag= fAnaUtils->CheckOriginInAOD(&motherIndex, 1, arrayMC);
	237
e6637b75	238	AliAODMCParticle * mother = dynamic_cast<AliAODMCParticle*>(arrayMC->At(motherIndex));
e6637b75	239
f50e7d42	240
	241	if (photon->GetPdgCode() == 22 ) {
	242
	243	if (TMath::Abs(mother->GetPdgCode()) < 22 && TMath::Abs(mother->GetPdgCode()) != 11) {
	244
	245	fAnaUtils->SetTagBit(tag, AliMCAnalysisUtils::kMCPhoton);
	246	fAnaUtils->SetTagBit(tag, AliMCAnalysisUtils::kMCPrompt);
	247
	248	cout <<"KKKKKKKKK "<< mother->GetPdgCode() << " " << mother->GetStatus() << " mi " << motherIndex << " daught: " << mother->GetNDaughters() << endl;
	249	cout << photon->GetStatus() << " " << photon->Pt() << " headerpt:" << mcHeader->GetPtHard() << " " <<mcPart1->GetMother() << endl;
	250
	251	}
	252	} else {
	253	cout << "FAKE "<< photon->PdgCode() << " " << photon->Pt() << " " << photon->GetStatus() << endl;
	254	}
	255
	256
e6637b75	257
f50e7d42	258
	259
	260
	261	Int_t parentId = mother->GetMother();
	262	AliAODMCParticle * gp = dynamic_cast<AliAODMCParticle*>(arrayMC->At(parentId));
	263
	264
e6637b75	265
e6637b75	266
e6637b75	267	if(! mother->IsPrimary()) {
f50e7d42	268	//cout << mother->GetPdgCode() << " " << mother->GetStatus() <<endl;
	269	// cout << "other one? " << mother->PdgCode() << " " << gp->PdgCode() << " " << gp->GetStatus() << endl;
	270	// cout << "yeay3 " << mother->GetPdgCode() << endl;
	271
	272	} else { //if (mother->IsPhysicalPrimary() ){
	273
	274
	275	if(mother->GetStatus() < 10) {
	276	//cout << "yeay4 " << mother->GetPdgCode() << endl;
	277	// cout << "pion? " << gp->PdgCode() << " " << gp->GetStatus() << endl;
	278	//cout << "???" << mother->PdgCode() << " " << mother->GetStatus() << " " << gp->PdgCode() << " " << gp->GetStatus() << endl;
	279	} else {
	280	//cout << "yeay5 " << mother->GetPdgCode() << endl;
	281	//cout << "other? " << mother->PdgCode() << " " << mother->GetStatus() << " " << gp->PdgCode() << " " << gp->GetStatus() << endl;
	282	}
	283
	284
	285	// } else {
	286	// cout << "MI: " << mother->GetPdgCode() << " " << mother->GetStatus() <<endl;
e6637b75	287	}
f50e7d42	288
e6637b75	289	}
e0b4c21c	290	}
e0b4c21c	291	}
e6637b75	292	//cout << "REturn tag " << tag << endl;
e6637b75	293	return tag;
e0b4c21c	294	}
e0b4c21c	295
e6637b75	296
e0b4c21c	297	///__________________________________________________________________________________
	298	AliAODPWG4ParticleCorrelation * AliAnalysisTaskGCPartToPWG4Part::AddToAOD(AliGammaConversionAODObject * aodO, TClonesArray * branch, TString detector) {
	299	new((*branch)[branch->GetEntriesFast()]) AliAODPWG4ParticleCorrelation(aodO->Px(), aodO->Py(), aodO->Pz(), aodO->E());
	300	AliAODPWG4ParticleCorrelation * photon = dynamic_cast<AliAODPWG4ParticleCorrelation*>(branch->Last());
	301	photon->SetTagged(aodO->IsTagged());
	302	photon->SetTrackLabel(aodO->GetLabel1(), aodO->GetLabel2());
	303	photon->SetDetector(detector);
	304	return photon;
	305	}
	306
	307	///__________________________________________________________________________________
	308	AliAODPWG4ParticleCorrelation * AliAnalysisTaskGCPartToPWG4Part::AddToAOD(AliAODConversionParticle * aodO, TClonesArray * branch, TString detector) {
	309	new((*branch)[branch->GetEntriesFast()]) AliAODPWG4ParticleCorrelation(aodO->Px(), aodO->Py(), aodO->Pz(), aodO->E());
	310	AliAODPWG4ParticleCorrelation * photon = dynamic_cast<AliAODPWG4ParticleCorrelation*>(branch->Last());
	311	photon->SetTrackLabel(aodO->GetLabel1(), aodO->GetLabel2());
	312	photon->SetDetector(detector);
	313	return photon;
	314	}
	315
	316
	317
	318
	319	//_____________________________________________________________________
	320	void AliAnalysisTaskGCPartToPWG4Part::Terminate(Option_t *) {
	321	// Draw result to the screen
	322	// Called once at the end of the query
	323	}
	324
	325	//_____________________________________________________________________
	326	AliAODEvent * AliAnalysisTaskGCPartToPWG4Part::GetAODEvent() {
	327	//Get the AOD event from whereever it might be
	328	AliAODEvent * aodEvent = dynamic_cast<AliAODEvent*>(InputEvent());
	329	if(!aodEvent) {
	330	aodEvent = AODEvent();
	331	}
	332
	333	return aodEvent;
	334
	335	}
	336
	337	//_____________________________________________________________________
	338	TClonesArray * AliAnalysisTaskGCPartToPWG4Part::GetConversionGammas(const AliAODEvent * aodEvent) {
	339
	340	//Get Conversion gamma branch of AOD. First try standard AOD
	341	TClonesArray * convGamma = dynamic_cast<TClonesArray*>(aodEvent->FindListObject(fAODBranchName.Data()));
	342
	343
	344	//If it's there, send it back
	345	if(convGamma) return convGamma;
	346
	347
	348	//If AOD not in standard file have to locate it in delta AOD
	349	if( !(fDeltaAODFileName.Length() > 0) ) return NULL;
	350
	351	AliAODHandler * aodHandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
	352	if(aodHandler) {
	353	AliAODExtension * gExt = dynamic_cast<AliAODExtension*>(aodHandler->GetExtensions()->FindObject(fDeltaAODFileName));
	354	if(gExt) {
	355	AliAODEvent * gcEvent = gExt->GetAOD();
	356	return dynamic_cast<TClonesArray*>(gcEvent->FindListObject("GammaConv_gamma"));
	357	}
	358	}
	359	return NULL;
	360	}
361
362	//_________________________________________________________________________
363	void AliAnalysisTaskGCPartToPWG4Part::CleanUp() {
364	fAODPWG4Particles->Delete();
365	}
366
367