[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;

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("AOD", "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;

    // create the header
    aod->AddHeader(new AliAODHeader(aliHeader->GetRun(),
				    0, // bunchX number
				    0, // orbit 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 header
    AliAODHeader *header = aod->GetHeader();

    // 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);

    Float_t p[3];
    Float_t x[3];
    Float_t *covTr = NULL;
    Float_t *pid = NULL;
    AliAODVertex *primary = NULL; 
    AliAODTrack* currTrack = NULL;
    // 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,
								covTr, 
								(Short_t)-99,
								0, // no ITSClusterMap
								pid,
								primary,
								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());

    Float_t pSec[3];
    Float_t xSec[3];
    Float_t *covSec = NULL;
    Float_t *pidSec = NULL;
    AliAODVertex *secondary = NULL;
    AliAODTrack* currTrackSec = NULL;
    
    for (Int_t iDaughter = mother->GetFirstDaughter(); iDaughter <= mother->GetLastDaughter(); iDaughter++) {
      TParticle *partSec = stack->Particle(iDaughter);

      pSec[0] = partSec->Px(); pSec[1] = partSec->Py(); pSec[2] = partSec->Pz();
      xSec[0] = partSec->Vx(); xSec[1] = partSec->Vy(); xSec[2] = partSec->Vz();

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

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

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