[u/mrichter/AliRoot.git] / STEER / CreateAODfromKineTree.C

#if !defined(__CINT__) || defined(__MAKECINT__)

#include <Riostream.h>
#include <TFile.h>
#include <TTree.h>
#include <TMath.h>

#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliHeader.h"
#include "AliStack.h"
#include "TParticle.h"

#include "AliAODEvent.h"
#include "AliAODHeader.h"
#include "AliAODVertex.h"
#include "AliAODTrack.h"
#include "AliAODCluster.h"

#endif

// function declarations
void SetVertexType(TParticle *part, AliAODVertex *vertex);
void SetChargeAndPID(Int_t pdgCode, AliAODTrack *track);
Int_t LoopOverSecondaries(TParticle *mother);
void CreateAODfromKineTree(const char *inFileName = "galice.root",
			   const char *outFileName = "AliAOD.root");

// global variables
AliAODEvent *aod = NULL;
AliStack *stack = NULL;

Int_t jVertices = 0;
Int_t jTracks = 0; 
Int_t jKinks = 0;
Int_t jV0s = 0;
Int_t jCascades = 0;
Int_t jMultis = 0;
Int_t nPos = 0;
Int_t nNeg = 0;

Int_t nGamma = 0;
Int_t nElectron = 0;
Int_t nPositron = 0;
Int_t nMuon = 0;
Int_t nAntiMuon = 0;
Int_t nProton = 0;
Int_t nAntiProton = 0;
Int_t nNeutron = 0;
Int_t nAntiNeutron = 0;
Int_t nPi0 = 0;
Int_t nPiMinus = 0;
Int_t nPiPlus = 0;
Int_t nK0 = 0;
Int_t nKPlus = 0;
Int_t nKMinus = 0;

// global arrays and pointers
Float_t p[3];
Float_t x[3];
Float_t *cov = NULL; // set to NULL because not provided
Float_t *pid = NULL; // set to NULL because not provided
AliAODVertex *primary = NULL; 
AliAODVertex *secondary = NULL;
AliAODTrack *currTrack = NULL;

void CreateAODfromKineTree(const char *inFileName,
			   const char *outFileName) {
  printf("This macro works only correctly in comiled mode!\n");
  /* This probem is due to CINT which gets confused if arrays are reused */

  // create an AliAOD object 
  aod = new AliAODEvent();
  aod->CreateStdContent();

  // open the file
  TFile *outFile = TFile::Open(outFileName, "RECREATE");

  // create the tree
  TTree *aodTree = new TTree("aodTree", "AliAOD tree");
  aodTree->Branch(aod->GetList());

  AliRunLoader *runLoader;
  delete gAlice;
  gAlice = NULL;
  runLoader = AliRunLoader::Open(inFileName);
  if (!runLoader) return;

  runLoader->LoadHeader();
  runLoader->LoadKinematics();

  Int_t nEvents = runLoader->GetNumberOfEvents();

  // loop over events and fill them
  for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
 
    cout << "Event " << iEvent+1 << "/" << nEvents;
    runLoader->GetEvent(iEvent);

    AliHeader *aliHeader = runLoader->GetHeader();
    stack = runLoader->Stack();
    Int_t nTracks = stack->GetNtrack();
    Int_t nPrims = stack->GetNprimary();

    nPos = 0;
    nNeg = 0;
 
    nGamma = 0;
    nElectron = 0;
    nPositron = 0;
    nMuon = 0;
    nAntiMuon = 0;
    nProton = 0;
    nAntiProton = 0;
    nNeutron = 0;
    nAntiNeutron = 0;
    nPi0 = 0;
    nPiMinus = 0;
    nPiPlus = 0;
    nK0 = 0;
    nKPlus = 0;
    nKMinus = 0;

    // Access to the header
    AliAODHeader *header = aod->GetHeader();

    // fill the header
    *header = AliAODHeader(aliHeader->GetRun(),
			   0, // bunchX number
			   0, // orbit number
			   0, // period number
			   nTracks,
			   nPos,
			   nNeg,
			   -999, // mag. field
			   -999., // muon mag. field
			   -999., // centrality
			   -999, // ZDCN1Energy
			   -999, // ZDCP1Energy
			   -999, // ZDCN2Energy
			   -999, // ZDCP2Energy
			   -999, // ZDCEMEnergy
			   0, // TriggerMask
			   0, // TriggerCluster
			   0); // EventType
  
    // Access to the AOD container of vertices
    TClonesArray &vertices = *(aod->GetVertices());
    jVertices=0;
    jKinks=0;
    jV0s=0;
    jCascades=0;
    jMultis=0;

    // Access to the AOD container of tracks
    TClonesArray &tracks = *(aod->GetTracks());
    jTracks=0; 
 
    aod->ResetStd(nTracks, 1);

    // track loop
    for (Int_t iTrack = 0; iTrack < nPrims; ++iTrack) {
								
      TParticle *part = stack->Particle(iTrack);

      //if (part->IsPrimary()) { // this will exclude 'funny' primaries, too
      if (kTRUE) { // this won't
	p[0] = part->Px(); p[1] = part->Py(); p[2] = part->Pz();
	x[0] = part->Vx(); x[1] = part->Vy(); x[2] = part->Vz();
	
	if (iTrack == 0) {
	  // add primary vertex
	  primary = new(vertices[jVertices++])
	    AliAODVertex(x, NULL, -999., NULL, AliAODVertex::kPrimary);
	}
	
	// add primary tracks
	primary->AddDaughter(new(tracks[jTracks++]) AliAODTrack(0, // ID,
								0, // Label
								p,
								kTRUE,
								x,
								kFALSE,
								cov, 
								(Short_t)-99,
								0, // no ITSClusterMap
								pid,
								primary,
					                        kFALSE,  // no fit performed
								kFALSE, // no fit preformed
								AliAODTrack::kPrimary));
	currTrack = (AliAODTrack*)tracks.Last();
	SetChargeAndPID(part->GetPdgCode(), currTrack);
	if (currTrack->Charge() != -99) {
	  if (currTrack->Charge() > 0) {
	    nPos++;
	  } else if (currTrack->Charge() < 0) {
	    nNeg++;
	  }	    
	}
	
	LoopOverSecondaries(part);
      } 
    } // end of track loop
    
    header->SetRefMultiplicityPos(nPos);
    header->SetRefMultiplicityNeg(nNeg);
    
    cout << ":: primaries: " << nPrims << " secondaries: " << tracks.GetEntriesFast()-nPrims << 
      " (pos: " << nPos << ", neg: " << nNeg << "), vertices: " << vertices.GetEntriesFast() << 
      " (kinks: " << jKinks << ", V0: " << jV0s << ", cascades: " << jCascades << 
      ", multi: " << jMultis << ")" << endl;
    /*
    cout << "  gamma: " << nGamma << " e-: " << nElectron << " e+: " << nPositron << " p: " << nProton << 
      " pBar: " << nAntiProton << " n: " << nNeutron << " nBar: " << nAntiNeutron << " pi0: " << nPi0 <<
      " pi+: " << nPiPlus << " pi-: " << nPiMinus << " K0: " << nK0 << " K+: " << nKPlus << 
      " K-: " << nKMinus << endl;
    */
    // fill the tree for this event
    aodTree->Fill();
  } // end of event loop

  aodTree->GetUserInfo()->Add(aod);
  
  // write the tree to the specified file
  outFile = aodTree->GetCurrentFile();
  outFile->cd();
  aodTree->Write();
  outFile->Close();

}


Int_t LoopOverSecondaries(TParticle *mother) {
  
  if (mother->GetNDaughters() > 0) {

    TClonesArray &vertices = *(aod->GetVertices());
    TClonesArray &tracks = *(aod->GetTracks());

    for (Int_t iDaughter = mother->GetFirstDaughter(); iDaughter <= mother->GetLastDaughter(); iDaughter++) {
      TParticle *part = stack->Particle(iDaughter);
      p[0] = part->Px(); 
      p[1] = part->Py(); 
      p[2] = part->Pz();
      x[0] = part->Vx(); 
      x[1] = part->Vy(); 
      x[2] = part->Vz();

      if (iDaughter == mother->GetFirstDaughter()) {
	// add secondary vertex
	secondary = new(vertices[jVertices++])
	  AliAODVertex(x, NULL, -999., tracks.Last(), AliAODVertex::kUndef);
	
	SetVertexType(part, secondary);
      }
	
      // add secondary tracks
      secondary->AddDaughter(new(tracks[jTracks++]) AliAODTrack(0, // ID
								0, // label
								p,
								kTRUE,
								x,
								kFALSE,
								cov, 
								(Short_t)-99,
								0, // no cluster map available
								pid,
								secondary,
								kFALSE, // no fit performed
					                        kFALSE, // no fit performed
								AliAODTrack::kSecondary));

      currTrack = (AliAODTrack*)tracks.Last();
      SetChargeAndPID(part->GetPdgCode(), currTrack);
      if (currTrack->Charge() != -99) {
	if (currTrack->Charge() > 0) {
	  nPos++;
	} else if (currTrack->Charge() < 0) {
	  nNeg++;
	}	    
      }

      LoopOverSecondaries(part);
    }
    return 1;
  } else {
    return 0;
  }
}


void SetChargeAndPID(Int_t pdgCode, AliAODTrack *track) {

  Float_t PID[10] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};

  switch (pdgCode) {

  case 22: // gamma
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    nGamma++;
    break;

  case 11: // e- 
    track->SetCharge(-1);
    PID[AliAODTrack::kElectron] = 1.;
    track->SetPID(PID);
    nElectron++;
    break;
    
  case -11: // e+
    track->SetCharge(+1);
    PID[AliAODTrack::kElectron] = 1.;
    track->SetPID(PID);
    nPositron++;
    break;
    
  case 13: // mu- 
    track->SetCharge(-1);
    PID[AliAODTrack::kMuon] = 1.;
    track->SetPID(PID);
    nMuon++;
    break;
    
  case -13: // mu+
    track->SetCharge(+1);
    PID[AliAODTrack::kMuon] = 1.;
    track->SetPID(PID);
    nAntiMuon++;
    break;
    
  case 111: // pi0
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    nPi0++;
    break;
    
  case 211: // pi+
    track->SetCharge(+1);
    PID[AliAODTrack::kPion] = 1.;
    track->SetPID(PID);
    nPiPlus++;
    break;
    
  case -211: // pi-
    track->SetCharge(-1);
    PID[AliAODTrack::kPion] = 1.;
    track->SetPID(PID);
    nPiMinus++;
    break;
    
  case 130: // K0L
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    nK0++;
    break;
    
  case 321: // K+
    track->SetCharge(+1);
    PID[AliAODTrack::kKaon] = 1.;
    track->SetPID(PID);
    nKPlus++;
    break;
    
  case -321: // K- 
    track->SetCharge(-1);
    PID[AliAODTrack::kKaon] = 1.;
    track->SetPID(PID);
    nKMinus++;
    break;
    
  case 2112: // n
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    nNeutron++;
    break;
    
  case 2212: // p
    track->SetCharge(+1);
    PID[AliAODTrack::kProton] = 1.;
    track->SetPID(PID);
    nProton++;
    break;
    
  case -2212: // anti-p
    track->SetCharge(-1);
    PID[AliAODTrack::kProton] = 1.;
    track->SetPID(PID);
    nAntiProton++;
    break;

  case 310: // K0S
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    nK0++;
    break;
    
  case 311: // K0
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    nK0++;
    break;
    
  case -311: // anti-K0
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    nK0++;
    break;
    
  case 221: // eta
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case 3122: // lambda
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case 3222: // Sigma+
    track->SetCharge(+1);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case 3212: // Sigma0
    track->SetCharge(-1);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case 3112: // Sigma-
    track->SetCharge(-1);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case 3322: // Xi0
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case 3312: // Xi-
    track->SetCharge(-1);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case 3334: // Omega-
    track->SetCharge(-1);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case -2112: // n-bar
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case -3122: // anti-Lambda
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case -3222: // anti-Sigma-
    track->SetCharge(-1);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case -3212: // anti-Sigma0
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case -3112: // anti-Sigma+
    track->SetCharge(+1);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case -3322: // anti-Xi0
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case -3312: // anti-Xi+
    track->SetCharge(+1);
    break;

  case -3334: // anti-Omega+
    track->SetCharge(+1);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case 411: // D+
    track->SetCharge(+1);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case -411: // D- 
    track->SetCharge(-1);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case 421: // D0
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  case -421: // anti-D0
    track->SetCharge(0);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
    break;

  default : // unknown
    track->SetCharge(-99);
    PID[AliAODTrack::kUnknown] = 1.;
    track->SetPID(PID);
 }

  return;
}


void SetVertexType(TParticle *part, AliAODVertex *vertex) {
  // this whole thing doesn't make much sense. but anyhow...

  TParticle *mother = stack->Particle(part->GetFirstMother());
  Int_t pdgMother = mother->GetPdgCode();
  Int_t pdgPart = part->GetPdgCode();
  
  // kinks
  if (mother->GetNDaughters() == 2) {
    Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
    Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();

    if (!(pdgMother == 22 || pdgMother == 111 || pdgMother == 130 || 
	  TMath::Abs(pdgMother) == 2112 || pdgMother == 310 || pdgMother == 221 || 
	  TMath::Abs(pdgMother) == 3122 || TMath::Abs(pdgMother) == 3322 || 
	  pdgMother == -3212 || TMath::Abs(pdgMother) == 421 || 
	  TMath::Abs(pdgMother) == 311) // not neutral
	&& (((firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || 
	      TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || 
	      firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || 
	      TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || 
	      TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // neutral
	     && !(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || 
		  TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || 
		  lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || 
		  TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || 
		  TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311)) // not neutral
	    || !((firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || 
		  TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || 
		  firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || 
		  TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || 
		  TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral
		 && (lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || 
		     TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || 
		     lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || 
		     TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || 
		     TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311)))) { // neutral
      
      vertex->SetType(AliAODVertex::kKink);
      jKinks++;
    }
  }

  // V0
  else if (mother->GetNDaughters() == 2) {
    Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
    Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();

    if ((pdgMother == 22 || pdgMother == 111 || pdgMother == 130 || 
	 TMath::Abs(pdgMother) == 2112 || pdgMother == 310 || 
	 pdgMother == 221 || TMath::Abs(pdgMother) == 3122 || 
	 TMath::Abs(pdgMother) == 3322 || pdgMother == -3212 || 
	 TMath::Abs(pdgMother) == 421 || TMath::Abs(pdgMother) == 311) // neutral
	&& !(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || 
	     TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || 
	     lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || 
	     TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || 
	     TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral
	&& !(firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || 
	     TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || 
	     firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || 
	     TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || 
	     TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311)) { // not neutral
      
      vertex->SetType(AliAODVertex::kV0);
      jV0s++;
    }
  }

  // Cascade
  else if (mother->GetNDaughters() == 2) {
    Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
    Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();
    
    if ((TMath::Abs(pdgMother) == 3334 || TMath::Abs(pdgMother) == 3312 || TMath::Abs(pdgMother) == 3322) &&
	(TMath::Abs(pdgPart) == 3122 || TMath::Abs(pdgPart) == 211 || TMath::Abs(pdgPart) == 321)
	&& ((!(firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || 
	       TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || 
	       firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || 
	       TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || 
	       TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral   
	     && TMath::Abs(lastPdgCode) == 3122) // labmda or anti-lambda
	    || ((!(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || 
		   TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || 
		   lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || 
		   TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || 
		   TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral
		 && TMath::Abs(firstPdgCode) == 3122)))) { // lambda or anti-lambda
      vertex->SetType(AliAODVertex::kCascade);
      jCascades++;
    }
  }

  // Multi
  else if (mother->GetNDaughters() > 2) {

    vertex->SetType(AliAODVertex::kMulti);
    jMultis++;
  }

  else {
    vertex->SetType(AliAODVertex::kUndef);
  }
}
//  LocalWords:  SetCharge
Commit	Line	Data
3a0584e6	1	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
	2
	3	#include <Riostream.h>
	4	#include <TFile.h>
	5	#include <TTree.h>
	6	#include <TMath.h>
	7
	8	#include "AliRun.h"
	9	#include "AliRunLoader.h"
	10	#include "AliHeader.h"
	11	#include "AliStack.h"
	12	#include "TParticle.h"
	13
	14	#include "AliAODEvent.h"
	15	#include "AliAODHeader.h"
	16	#include "AliAODVertex.h"
	17	#include "AliAODTrack.h"
	18	#include "AliAODCluster.h"
	19
	20	#endif
	21
	22	// function declarations
	23	void SetVertexType(TParticle part, AliAODVertex vertex);
	24	void SetChargeAndPID(Int_t pdgCode, AliAODTrack *track);
	25	Int_t LoopOverSecondaries(TParticle *mother);
	26	void CreateAODfromKineTree(const char *inFileName = "galice.root",
	27	const char *outFileName = "AliAOD.root");
	28
	29	// global variables
	30	AliAODEvent *aod = NULL;
	31	AliStack *stack = NULL;
	32
	33	Int_t jVertices = 0;
	34	Int_t jTracks = 0;
	35	Int_t jKinks = 0;
	36	Int_t jV0s = 0;
	37	Int_t jCascades = 0;
	38	Int_t jMultis = 0;
	39	Int_t nPos = 0;
	40	Int_t nNeg = 0;
	41
	42	Int_t nGamma = 0;
	43	Int_t nElectron = 0;
	44	Int_t nPositron = 0;
	45	Int_t nMuon = 0;
	46	Int_t nAntiMuon = 0;
	47	Int_t nProton = 0;
	48	Int_t nAntiProton = 0;
	49	Int_t nNeutron = 0;
	50	Int_t nAntiNeutron = 0;
	51	Int_t nPi0 = 0;
	52	Int_t nPiMinus = 0;
	53	Int_t nPiPlus = 0;
	54	Int_t nK0 = 0;
	55	Int_t nKPlus = 0;
	56	Int_t nKMinus = 0;
	57
994b4747	58	// global arrays and pointers
	59	Float_t p[3];
	60	Float_t x[3];
	61	Float_t *cov = NULL; // set to NULL because not provided
	62	Float_t *pid = NULL; // set to NULL because not provided
	63	AliAODVertex *primary = NULL;
	64	AliAODVertex *secondary = NULL;
	65	AliAODTrack *currTrack = NULL;
	66
3a0584e6	67	void CreateAODfromKineTree(const char *inFileName,
	68	const char *outFileName) {
	69	printf("This macro works only correctly in comiled mode!\n");
	70	/* This probem is due to CINT which gets confused if arrays are reused */
	71
	72	// create an AliAOD object
	73	aod = new AliAODEvent();
	74	aod->CreateStdContent();
	75
	76	// open the file
	77	TFile *outFile = TFile::Open(outFileName, "RECREATE");
	78
	79	// create the tree
4df44eca	80	TTree *aodTree = new TTree("aodTree", "AliAOD tree");
3a0584e6	81	aodTree->Branch(aod->GetList());
	82
	83	AliRunLoader *runLoader;
	84	delete gAlice;
	85	gAlice = NULL;
	86	runLoader = AliRunLoader::Open(inFileName);
	87	if (!runLoader) return;
	88
	89	runLoader->LoadHeader();
	90	runLoader->LoadKinematics();
	91
	92	Int_t nEvents = runLoader->GetNumberOfEvents();
	93
	94	// loop over events and fill them
	95	for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
	96
	97	cout << "Event " << iEvent+1 << "/" << nEvents;
	98	runLoader->GetEvent(iEvent);
	99
	100	AliHeader *aliHeader = runLoader->GetHeader();
	101	stack = runLoader->Stack();
	102	Int_t nTracks = stack->GetNtrack();
	103	Int_t nPrims = stack->GetNprimary();
	104
	105	nPos = 0;
	106	nNeg = 0;
	107
	108	nGamma = 0;
	109	nElectron = 0;
	110	nPositron = 0;
	111	nMuon = 0;
	112	nAntiMuon = 0;
	113	nProton = 0;
	114	nAntiProton = 0;
	115	nNeutron = 0;
	116	nAntiNeutron = 0;
	117	nPi0 = 0;
	118	nPiMinus = 0;
	119	nPiPlus = 0;
	120	nK0 = 0;
	121	nKPlus = 0;
	122	nKMinus = 0;
	123
3a0584e6	124	// Access to the header
	125	AliAODHeader *header = aod->GetHeader();
	126
a206f034	127	// fill the header
	128	*header = AliAODHeader(aliHeader->GetRun(),
	129	0, // bunchX number
	130	0, // orbit number
	131	0, // period number
	132	nTracks,
	133	nPos,
	134	nNeg,
	135	-999, // mag. field
	136	-999., // muon mag. field
	137	-999., // centrality
	138	-999, // ZDCN1Energy
	139	-999, // ZDCP1Energy
	140	-999, // ZDCN2Energy
	141	-999, // ZDCP2Energy
	142	-999, // ZDCEMEnergy
	143	0, // TriggerMask
	144	0, // TriggerCluster
	145	0); // EventType
	146
3a0584e6	147	// Access to the AOD container of vertices
	148	TClonesArray &vertices = *(aod->GetVertices());
	149	jVertices=0;
	150	jKinks=0;
	151	jV0s=0;
	152	jCascades=0;
	153	jMultis=0;
	154
	155	// Access to the AOD container of tracks
	156	TClonesArray &tracks = *(aod->GetTracks());
	157	jTracks=0;
	158
	159	aod->ResetStd(nTracks, 1);
	160
3a0584e6	161	// track loop
	162	for (Int_t iTrack = 0; iTrack < nPrims; ++iTrack) {
	163
	164	TParticle *part = stack->Particle(iTrack);
	165
	166	//if (part->IsPrimary()) { // this will exclude 'funny' primaries, too
	167	if (kTRUE) { // this won't
	168	p[0] = part->Px(); p[1] = part->Py(); p[2] = part->Pz();
	169	x[0] = part->Vx(); x[1] = part->Vy(); x[2] = part->Vz();
	170
	171	if (iTrack == 0) {
	172	// add primary vertex
	173	primary = new(vertices[jVertices++])
	174	AliAODVertex(x, NULL, -999., NULL, AliAODVertex::kPrimary);
	175	}
	176
	177	// add primary tracks
	178	primary->AddDaughter(new(tracks[jTracks++]) AliAODTrack(0, // ID,
	179	0, // Label
	180	p,
	181	kTRUE,
	182	x,
	183	kFALSE,
994b4747	184	cov,
3a0584e6	185	(Short_t)-99,
	186	0, // no ITSClusterMap
	187	pid,
	188	primary,
00946a1a	189	kFALSE, // no fit performed
3a0584e6	190	kFALSE, // no fit preformed
	191	AliAODTrack::kPrimary));
	192	currTrack = (AliAODTrack*)tracks.Last();
	193	SetChargeAndPID(part->GetPdgCode(), currTrack);
	194	if (currTrack->Charge() != -99) {
	195	if (currTrack->Charge() > 0) {
	196	nPos++;
	197	} else if (currTrack->Charge() < 0) {
	198	nNeg++;
	199	}
	200	}
	201
	202	LoopOverSecondaries(part);
	203	}
	204	} // end of track loop
	205
	206	header->SetRefMultiplicityPos(nPos);
	207	header->SetRefMultiplicityNeg(nNeg);
	208
	209	cout << ":: primaries: " << nPrims << " secondaries: " << tracks.GetEntriesFast()-nPrims <<
	210	" (pos: " << nPos << ", neg: " << nNeg << "), vertices: " << vertices.GetEntriesFast() <<
	211	" (kinks: " << jKinks << ", V0: " << jV0s << ", cascades: " << jCascades <<
	212	", multi: " << jMultis << ")" << endl;
	213	/*
	214	cout << " gamma: " << nGamma << " e-: " << nElectron << " e+: " << nPositron << " p: " << nProton <<
	215	" pBar: " << nAntiProton << " n: " << nNeutron << " nBar: " << nAntiNeutron << " pi0: " << nPi0 <<
	216	" pi+: " << nPiPlus << " pi-: " << nPiMinus << " K0: " << nK0 << " K+: " << nKPlus <<
	217	" K-: " << nKMinus << endl;
	218	*/
	219	// fill the tree for this event
	220	aodTree->Fill();
	221	} // end of event loop
	222
	223	aodTree->GetUserInfo()->Add(aod);
	224
	225	// write the tree to the specified file
	226	outFile = aodTree->GetCurrentFile();
	227	outFile->cd();
	228	aodTree->Write();
	229	outFile->Close();
	230
	231	}
	232
	233
	234	Int_t LoopOverSecondaries(TParticle *mother) {
	235
	236	if (mother->GetNDaughters() > 0) {
	237
	238	TClonesArray &vertices = *(aod->GetVertices());
	239	TClonesArray &tracks = *(aod->GetTracks());
	240
3a0584e6	241	for (Int_t iDaughter = mother->GetFirstDaughter(); iDaughter <= mother->GetLastDaughter(); iDaughter++) {
994b4747	242	TParticle *part = stack->Particle(iDaughter);
	243	p[0] = part->Px();
	244	p[1] = part->Py();
	245	p[2] = part->Pz();
	246	x[0] = part->Vx();
	247	x[1] = part->Vy();
	248	x[2] = part->Vz();
3a0584e6	249
	250	if (iDaughter == mother->GetFirstDaughter()) {
	251	// add secondary vertex
	252	secondary = new(vertices[jVertices++])
994b4747	253	AliAODVertex(x, NULL, -999., tracks.Last(), AliAODVertex::kUndef);
3a0584e6	254
994b4747	255	SetVertexType(part, secondary);
3a0584e6	256	}
	257
	258	// add secondary tracks
	259	secondary->AddDaughter(new(tracks[jTracks++]) AliAODTrack(0, // ID
	260	0, // label
994b4747	261	p,
3a0584e6	262	kTRUE,
994b4747	263	x,
3a0584e6	264	kFALSE,
994b4747	265	cov,
3a0584e6	266	(Short_t)-99,
3a0584e6	267	0, // no cluster map available
994b4747	268	pid,
3a0584e6	269	secondary,
3a0584e6	270	kFALSE, // no fit performed
00946a1a	271	kFALSE, // no fit performed
3a0584e6	272	AliAODTrack::kSecondary));
3a0584e6	273
994b4747	274	currTrack = (AliAODTrack*)tracks.Last();
	275	SetChargeAndPID(part->GetPdgCode(), currTrack);
	276	if (currTrack->Charge() != -99) {
	277	if (currTrack->Charge() > 0) {
3a0584e6	278	nPos++;
994b4747	279	} else if (currTrack->Charge() < 0) {
3a0584e6	280	nNeg++;
	281	}
	282	}
	283
994b4747	284	LoopOverSecondaries(part);
3a0584e6	285	}
	286	return 1;
	287	} else {
	288	return 0;
	289	}
	290	}
	291
	292
	293	void SetChargeAndPID(Int_t pdgCode, AliAODTrack *track) {
	294
	295	Float_t PID[10] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};
	296
	297	switch (pdgCode) {
2ca95bbe	298
3a0584e6	299	case 22: // gamma
3a0584e6	300	track->SetCharge(0);
2ca95bbe	301	PID[AliAODTrack::kUnknown] = 1.;
3a0584e6	302	track->SetPID(PID);
	303	nGamma++;
	304	break;
	305
2ca95bbe	306	case 11: // e-
3a0584e6	307	track->SetCharge(-1);
2ca95bbe	308	PID[AliAODTrack::kElectron] = 1.;
3a0584e6	309	track->SetPID(PID);
	310	nElectron++;
	311	break;
	312
2ca95bbe	313	case -11: // e+
3a0584e6	314	track->SetCharge(+1);
2ca95bbe	315	PID[AliAODTrack::kElectron] = 1.;
3a0584e6	316	track->SetPID(PID);
	317	nPositron++;
	318	break;
	319
2ca95bbe	320	case 13: // mu-
3a0584e6	321	track->SetCharge(-1);
2ca95bbe	322	PID[AliAODTrack::kMuon] = 1.;
3a0584e6	323	track->SetPID(PID);
	324	nMuon++;
	325	break;
	326
2ca95bbe	327	case -13: // mu+
3a0584e6	328	track->SetCharge(+1);
2ca95bbe	329	PID[AliAODTrack::kMuon] = 1.;
3a0584e6	330	track->SetPID(PID);
	331	nAntiMuon++;
	332	break;
	333
	334	case 111: // pi0
	335	track->SetCharge(0);
2ca95bbe	336	PID[AliAODTrack::kUnknown] = 1.;
3a0584e6	337	track->SetPID(PID);
	338	nPi0++;
	339	break;
	340
	341	case 211: // pi+
	342	track->SetCharge(+1);
2ca95bbe	343	PID[AliAODTrack::kPion] = 1.;
3a0584e6	344	track->SetPID(PID);
	345	nPiPlus++;
	346	break;
	347
	348	case -211: // pi-
	349	track->SetCharge(-1);
2ca95bbe	350	PID[AliAODTrack::kPion] = 1.;
3a0584e6	351	track->SetPID(PID);
	352	nPiMinus++;
	353	break;
	354
	355	case 130: // K0L
	356	track->SetCharge(0);
2ca95bbe	357	PID[AliAODTrack::kUnknown] = 1.;
3a0584e6	358	track->SetPID(PID);
	359	nK0++;
	360	break;
	361
	362	case 321: // K+
	363	track->SetCharge(+1);
2ca95bbe	364	PID[AliAODTrack::kKaon] = 1.;
3a0584e6	365	track->SetPID(PID);
	366	nKPlus++;
	367	break;
	368
	369	case -321: // K-
	370	track->SetCharge(-1);
2ca95bbe	371	PID[AliAODTrack::kKaon] = 1.;
3a0584e6	372	track->SetPID(PID);
	373	nKMinus++;
	374	break;
	375
2ca95bbe	376	case 2112: // n
3a0584e6	377	track->SetCharge(0);
2ca95bbe	378	PID[AliAODTrack::kUnknown] = 1.;
3a0584e6	379	track->SetPID(PID);
	380	nNeutron++;
	381	break;
	382
	383	case 2212: // p
	384	track->SetCharge(+1);
2ca95bbe	385	PID[AliAODTrack::kProton] = 1.;
3a0584e6	386	track->SetPID(PID);
	387	nProton++;
	388	break;
	389
	390	case -2212: // anti-p
	391	track->SetCharge(-1);
2ca95bbe	392	PID[AliAODTrack::kProton] = 1.;
3a0584e6	393	track->SetPID(PID);
	394	nAntiProton++;
	395	break;
	396
	397	case 310: // K0S
	398	track->SetCharge(0);
2ca95bbe	399	PID[AliAODTrack::kUnknown] = 1.;
	400	track->SetPID(PID);
	401	nK0++;
	402	break;
	403
	404	case 311: // K0
	405	track->SetCharge(0);
	406	PID[AliAODTrack::kUnknown] = 1.;
	407	track->SetPID(PID);
	408	nK0++;
	409	break;
	410
	411	case -311: // anti-K0
	412	track->SetCharge(0);
	413	PID[AliAODTrack::kUnknown] = 1.;
3a0584e6	414	track->SetPID(PID);
	415	nK0++;
	416	break;
	417
	418	case 221: // eta
	419	track->SetCharge(0);
2ca95bbe	420	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	421	track->SetPID(PID);
3a0584e6	422	break;
	423
	424	case 3122: // lambda
	425	track->SetCharge(0);
2ca95bbe	426	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	427	track->SetPID(PID);
3a0584e6	428	break;
	429
	430	case 3222: // Sigma+
	431	track->SetCharge(+1);
2ca95bbe	432	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	433	track->SetPID(PID);
3a0584e6	434	break;
	435
	436	case 3212: // Sigma0
	437	track->SetCharge(-1);
2ca95bbe	438	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	439	track->SetPID(PID);
3a0584e6	440	break;
	441
	442	case 3112: // Sigma-
	443	track->SetCharge(-1);
2ca95bbe	444	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	445	track->SetPID(PID);
3a0584e6	446	break;
	447
	448	case 3322: // Xi0
	449	track->SetCharge(0);
2ca95bbe	450	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	451	track->SetPID(PID);
3a0584e6	452	break;
	453
	454	case 3312: // Xi-
	455	track->SetCharge(-1);
2ca95bbe	456	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	457	track->SetPID(PID);
3a0584e6	458	break;
3a0584e6	459
2ca95bbe	460	case 3334: // Omega-
3a0584e6	461	track->SetCharge(-1);
2ca95bbe	462	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	463	track->SetPID(PID);
3a0584e6	464	break;
	465
	466	case -2112: // n-bar
	467	track->SetCharge(0);
2ca95bbe	468	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	469	track->SetPID(PID);
3a0584e6	470	break;
	471
	472	case -3122: // anti-Lambda
	473	track->SetCharge(0);
2ca95bbe	474	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	475	track->SetPID(PID);
3a0584e6	476	break;
	477
	478	case -3222: // anti-Sigma-
	479	track->SetCharge(-1);
2ca95bbe	480	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	481	track->SetPID(PID);
3a0584e6	482	break;
	483
	484	case -3212: // anti-Sigma0
	485	track->SetCharge(0);
2ca95bbe	486	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	487	track->SetPID(PID);
3a0584e6	488	break;
	489
	490	case -3112: // anti-Sigma+
	491	track->SetCharge(+1);
2ca95bbe	492	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	493	track->SetPID(PID);
3a0584e6	494	break;
	495
	496	case -3322: // anti-Xi0
	497	track->SetCharge(0);
2ca95bbe	498	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	499	track->SetPID(PID);
3a0584e6	500	break;
	501
	502	case -3312: // anti-Xi+
	503	track->SetCharge(+1);
	504	break;
	505
2ca95bbe	506	case -3334: // anti-Omega+
3a0584e6	507	track->SetCharge(+1);
2ca95bbe	508	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	509	track->SetPID(PID);
3a0584e6	510	break;
	511
	512	case 411: // D+
	513	track->SetCharge(+1);
2ca95bbe	514	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	515	track->SetPID(PID);
3a0584e6	516	break;
	517
	518	case -411: // D-
	519	track->SetCharge(-1);
2ca95bbe	520	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	521	track->SetPID(PID);
3a0584e6	522	break;
	523
	524	case 421: // D0
	525	track->SetCharge(0);
2ca95bbe	526	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	527	track->SetPID(PID);
3a0584e6	528	break;
	529
	530	case -421: // anti-D0
	531	track->SetCharge(0);
2ca95bbe	532	PID[AliAODTrack::kUnknown] = 1.;
2ca95bbe	533	track->SetPID(PID);
3a0584e6	534	break;
	535
	536	default : // unknown
	537	track->SetCharge(-99);
2ca95bbe	538	PID[AliAODTrack::kUnknown] = 1.;
	539	track->SetPID(PID);
	540	}
3a0584e6	541
	542	return;
	543	}
	544
	545
	546	void SetVertexType(TParticle part, AliAODVertex vertex) {
	547	// this whole thing doesn't make much sense. but anyhow...
	548
	549	TParticle *mother = stack->Particle(part->GetFirstMother());
	550	Int_t pdgMother = mother->GetPdgCode();
	551	Int_t pdgPart = part->GetPdgCode();
	552
	553	// kinks
	554	if (mother->GetNDaughters() == 2) {
	555	Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
	556	Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();
	557
	558	if (!(pdgMother == 22 \|\| pdgMother == 111 \|\| pdgMother == 130 \|\|
2ca95bbe	559	TMath::Abs(pdgMother) == 2112 \|\| pdgMother == 310 \|\| pdgMother == 221 \|\|
3a0584e6	560	TMath::Abs(pdgMother) == 3122 \|\| TMath::Abs(pdgMother) == 3322 \|\|
2ca95bbe	561	pdgMother == -3212 \|\| TMath::Abs(pdgMother) == 421 \|\|
2ca95bbe	562	TMath::Abs(pdgMother) == 311) // not neutral
3a0584e6	563	&& (((firstPdgCode == 22 \|\| firstPdgCode == 111 \|\| firstPdgCode == 130 \|\|
2ca95bbe	564	TMath::Abs(firstPdgCode) == 2112 \|\| firstPdgCode == 310 \|\|
3a0584e6	565	firstPdgCode == 221 \|\| TMath::Abs(firstPdgCode) == 3122 \|\|
3a0584e6	566	TMath::Abs(firstPdgCode) == 3322 \|\| firstPdgCode == -3212 \|\|
2ca95bbe	567	TMath::Abs(firstPdgCode) == 421 \|\| TMath::Abs(pdgMother) == 311) // neutral
3a0584e6	568	&& !(lastPdgCode == 22 \|\| lastPdgCode == 111 \|\| lastPdgCode == 130 \|\|
2ca95bbe	569	TMath::Abs(lastPdgCode) == 2112 \|\| lastPdgCode == 310 \|\|
3a0584e6	570	lastPdgCode == 221 \|\| TMath::Abs(lastPdgCode) == 3122 \|\|
3a0584e6	571	TMath::Abs(lastPdgCode) == 3322 \|\| lastPdgCode == -3212 \|\|
2ca95bbe	572	TMath::Abs(lastPdgCode) == 421 \|\| TMath::Abs(pdgMother) == 311)) // not neutral
3a0584e6	573	\|\| !((firstPdgCode == 22 \|\| firstPdgCode == 111 \|\| firstPdgCode == 130 \|\|
2ca95bbe	574	TMath::Abs(firstPdgCode) == 2112 \|\| firstPdgCode == 310 \|\|
3a0584e6	575	firstPdgCode == 221 \|\| TMath::Abs(firstPdgCode) == 3122 \|\|
3a0584e6	576	TMath::Abs(firstPdgCode) == 3322 \|\| firstPdgCode == -3212 \|\|
2ca95bbe	577	TMath::Abs(firstPdgCode) == 421 \|\| TMath::Abs(pdgMother) == 311) // not neutral
3a0584e6	578	&& (lastPdgCode == 22 \|\| lastPdgCode == 111 \|\| lastPdgCode == 130 \|\|
2ca95bbe	579	TMath::Abs(lastPdgCode) == 2112 \|\| lastPdgCode == 310 \|\|
3a0584e6	580	lastPdgCode == 221 \|\| TMath::Abs(lastPdgCode) == 3122 \|\|
3a0584e6	581	TMath::Abs(lastPdgCode) == 3322 \|\| lastPdgCode == -3212 \|\|
2ca95bbe	582	TMath::Abs(lastPdgCode) == 421 \|\| TMath::Abs(pdgMother) == 311)))) { // neutral
3a0584e6	583
	584	vertex->SetType(AliAODVertex::kKink);
	585	jKinks++;
	586	}
	587	}
	588
	589	// V0
	590	else if (mother->GetNDaughters() == 2) {
	591	Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
	592	Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();
	593
	594	if ((pdgMother == 22 \|\| pdgMother == 111 \|\| pdgMother == 130 \|\|
2ca95bbe	595	TMath::Abs(pdgMother) == 2112 \|\| pdgMother == 310 \|\|
3a0584e6	596	pdgMother == 221 \|\| TMath::Abs(pdgMother) == 3122 \|\|
3a0584e6	597	TMath::Abs(pdgMother) == 3322 \|\| pdgMother == -3212 \|\|
2ca95bbe	598	TMath::Abs(pdgMother) == 421 \|\| TMath::Abs(pdgMother) == 311) // neutral
3a0584e6	599	&& !(lastPdgCode == 22 \|\| lastPdgCode == 111 \|\| lastPdgCode == 130 \|\|
2ca95bbe	600	TMath::Abs(lastPdgCode) == 2112 \|\| lastPdgCode == 310 \|\|
3a0584e6	601	lastPdgCode == 221 \|\| TMath::Abs(lastPdgCode) == 3122 \|\|
3a0584e6	602	TMath::Abs(lastPdgCode) == 3322 \|\| lastPdgCode == -3212 \|\|
2ca95bbe	603	TMath::Abs(lastPdgCode) == 421 \|\| TMath::Abs(pdgMother) == 311) // not neutral
3a0584e6	604	&& !(firstPdgCode == 22 \|\| firstPdgCode == 111 \|\| firstPdgCode == 130 \|\|
2ca95bbe	605	TMath::Abs(firstPdgCode) == 2112 \|\| firstPdgCode == 310 \|\|
3a0584e6	606	firstPdgCode == 221 \|\| TMath::Abs(firstPdgCode) == 3122 \|\|
3a0584e6	607	TMath::Abs(firstPdgCode) == 3322 \|\| firstPdgCode == -3212 \|\|
2ca95bbe	608	TMath::Abs(firstPdgCode) == 421 \|\| TMath::Abs(pdgMother) == 311)) { // not neutral
3a0584e6	609
	610	vertex->SetType(AliAODVertex::kV0);
	611	jV0s++;
	612	}
	613	}
	614
	615	// Cascade
	616	else if (mother->GetNDaughters() == 2) {
	617	Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
	618	Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();
	619
2ca95bbe	620	if ((TMath::Abs(pdgMother) == 3334 \|\| TMath::Abs(pdgMother) == 3312 \|\| TMath::Abs(pdgMother) == 3322) &&
3a0584e6	621	(TMath::Abs(pdgPart) == 3122 \|\| TMath::Abs(pdgPart) == 211 \|\| TMath::Abs(pdgPart) == 321)
3a0584e6	622	&& ((!(firstPdgCode == 22 \|\| firstPdgCode == 111 \|\| firstPdgCode == 130 \|\|
2ca95bbe	623	TMath::Abs(firstPdgCode) == 2112 \|\| firstPdgCode == 310 \|\|
3a0584e6	624	firstPdgCode == 221 \|\| TMath::Abs(firstPdgCode) == 3122 \|\|
3a0584e6	625	TMath::Abs(firstPdgCode) == 3322 \|\| firstPdgCode == -3212 \|\|
2ca95bbe	626	TMath::Abs(firstPdgCode) == 421 \|\| TMath::Abs(pdgMother) == 311) // not neutral
3a0584e6	627	&& TMath::Abs(lastPdgCode) == 3122) // labmda or anti-lambda
3a0584e6	628	\|\| ((!(lastPdgCode == 22 \|\| lastPdgCode == 111 \|\| lastPdgCode == 130 \|\|
2ca95bbe	629	TMath::Abs(lastPdgCode) == 2112 \|\| lastPdgCode == 310 \|\|
3a0584e6	630	lastPdgCode == 221 \|\| TMath::Abs(lastPdgCode) == 3122 \|\|
3a0584e6	631	TMath::Abs(lastPdgCode) == 3322 \|\| lastPdgCode == -3212 \|\|
2ca95bbe	632	TMath::Abs(lastPdgCode) == 421 \|\| TMath::Abs(pdgMother) == 311) // not neutral
3a0584e6	633	&& TMath::Abs(firstPdgCode) == 3122)))) { // lambda or anti-lambda
	634	vertex->SetType(AliAODVertex::kCascade);
	635	jCascades++;
	636	}
	637	}
	638
	639	// Multi
	640	else if (mother->GetNDaughters() > 2) {
	641
	642	vertex->SetType(AliAODVertex::kMulti);
	643	jMultis++;
	644	}
	645
	646	else {
	647	vertex->SetType(AliAODVertex::kUndef);
	648	}
	649	}
	650	// LocalWords: SetCharge