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

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

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

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

#include "AliESD.h"
#include "AliESDtrack.h"
#include "AliESDVertex.h"
#include "AliESDv0.h"
#include "AliESDcascade.h"
#include "AliESDCaloCluster.h"

#endif

void CreateAODfromESD(const char *inFileName = "AliESDs.root",
		      const char *outFileName = "AliAOD.root") {

  // create an AliAOD object 
  AliAODEvent *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());

  // connect to ESD
  TFile *inFile = TFile::Open(inFileName, "READ");
  TTree *t = (TTree*) inFile->Get("esdTree");
  TBranch *b = t->GetBranch("ESD");
  AliESD *esd = 0;
  b->SetAddress(&esd);

  Int_t nEvents = b->GetEntries();

  // loop over events and fill them
  for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
    b->GetEntry(iEvent);

    // Multiplicity information needed by the header (to be revised!)
    Int_t nTracks   = esd->GetNumberOfTracks();
    Int_t nPosTracks = 0;
    for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) 
      if (esd->GetTrack(iTrack)->GetSign()> 0) nPosTracks++;

    // create the header
    aod->AddHeader(new AliAODHeader(esd->GetRunNumber(),
				    esd->GetBunchCrossNumber(),
				    esd->GetOrbitNumber(),
				    nTracks,
				    nPosTracks,
				    nTracks-nPosTracks,
				    esd->GetMagneticField(),
				    -999., // fill muon magnetic field
				    -999., // centrality; to be filled, still
				    esd->GetZDCN1Energy(),
				    esd->GetZDCP1Energy(),
				    esd->GetZDCN2Energy(),
				    esd->GetZDCP2Energy(),
				    esd->GetZDCEMEnergy(),
				    esd->GetTriggerMask(),
				    esd->GetTriggerCluster(),
				    esd->GetEventType()));

    Int_t nV0s      = esd->GetNumberOfV0s();
    Int_t nCascades = esd->GetNumberOfCascades();
    Int_t nKinks    = esd->GetNumberOfKinks();
    Int_t nVertices = nV0s + nCascades + nKinks;
    
    aod->ResetStd(nTracks, nVertices);
    

    // Array to take into account the tracks already added to the AOD
    Bool_t * usedTrack = NULL;
    if (nTracks>0) {
      usedTrack = new Bool_t[nTracks];
      for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
    }
    // Array to take into account the V0s already added to the AOD
    Bool_t * usedV0 = NULL;
    if (nV0s>0) {
      usedV0 = new Bool_t[nV0s];
      for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
    }
    // Array to take into account the kinks already added to the AOD
    Bool_t * usedKink = NULL;
    if (nKinks>0) {
      usedKink = new Bool_t[nKinks];
      for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
    }

    // Access to the AOD container of vertices
    TClonesArray &vertices = *(aod->GetVertices());
    Int_t jVertices=0;

    // Access to the AOD container of tracks
    TClonesArray &tracks = *(aod->GetTracks());
    Int_t jTracks=0; 
  
    // Add primary vertex. The primary tracks will be defined
    // after the loops on the composite objects (V0, cascades, kinks)
    const AliESDVertex *vtx = esd->GetPrimaryVertex();
      
    Double_t pos[3];
    vtx->GetXYZ(pos); // position
    Double_t covVtx[6]; // We have to give changing names to the variables (like cov?, x?, and p?) because CINT doesn't recognize blocks correctly.
    vtx->GetCovMatrix(covVtx); //covariance matrix

    AliAODVertex * primary = new(vertices[jVertices++])
      AliAODVertex(pos, covVtx, vtx->GetChi2(), NULL, AliAODVertex::kPrimary);
         
    // Create vertices starting from the most complex objects
      
    // Cascades
    for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
      AliESDcascade *cascade = esd->GetCascade(nCascade);
      
      Double_t posXi[3];
      cascade->GetXYZ(posXi[0], posXi[1], posXi[2]);
      Double_t covXi[6];
      cascade->GetPosCovXi(covXi);
     
      // Add the cascade vertex
      AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(posXi,
									covXi,
									cascade->GetChi2Xi(),
									primary,
									AliAODVertex::kCascade);

      primary->AddDaughter(vcascade);

      // Add the V0 from the cascade. The ESD class have to be optimized...
      // Now we have to search for the corresponding Vo in the list of V0s
      // using the indeces of the positive and negative tracks

      Int_t posFromV0 = cascade->GetPindex();
      Int_t negFromV0 = cascade->GetNindex();


      AliESDv0 * v0 = 0x0;
      Int_t indV0 = -1;

      for (Int_t iV0=0; iV0<nV0s; ++iV0) {

	v0 = esd->GetV0(iV0);
	Int_t posV0 = v0->GetPindex();
	Int_t negV0 = v0->GetNindex();

	if (posV0==posFromV0 && negV0==negFromV0) {
	  indV0 = iV0;
	  break;
	}
      }

      AliAODVertex * vV0FromCascade = 0x0;

      if (indV0>-1 && !usedV0[indV0] ) {
	
	// the V0 exists in the array of V0s and is not used

	usedV0[indV0] = kTRUE;
	
	Double_t posV0[3];
	v0->GetXYZ(posV0[0], posV0[1], posV0[2]);
	Double_t covV0_1[6];
	v0->GetPosCov(covV0_1);
	
	vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(posV0,
								 covV0_1,
								 v0->GetChi2V0(),
								 vcascade,
								 AliAODVertex::kV0);
      } else {

	// the V0 doesn't exist in the array of V0s or was used
	cerr << "Error: event " << iEvent << " cascade " << nCascade
	     << " The V0 " << indV0 
	     << " doesn't exist in the array of V0s or was used!" << endl;

	Double_t posV0_2[3];
	cascade->GetXYZ(posV0_2[0], posV0_2[1], posV0_2[2]);
	Double_t covV0_2[6];
	cascade->GetPosCov(covV0_2);
      
	vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(posV0_2,
								 covV0_2,
								 v0->GetChi2V0(),
								 vcascade,
								 AliAODVertex::kV0);
	vcascade->AddDaughter(vV0FromCascade);
      }

      // Add the positive tracks from the V0

      if (! usedTrack[posFromV0]) {

	usedTrack[posFromV0] = kTRUE;

	AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
	
	Double_t p1[3];
	esdTrack->GetPxPyPz(p1);
	
	Double_t x1[3];
	esdTrack->GetXYZ(x1);
	
	Double_t covV0PosTr[21];
	esdTrack->GetCovarianceXYZPxPyPz(covV0PosTr);
	
	Double_t pid1[10];
	esdTrack->GetESDpid(pid1);
	
	vV0FromCascade->AddDaughter(
				    new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(), 
					   p1, 
					   kTRUE,
					   x1,
					   kFALSE,
					   covV0PosTr, 
					   (Short_t)esdTrack->GetSign(),
					   esdTrack->GetITSClusterMap(), 
					   pid1,
					   vV0FromCascade,
					   kFALSE, // check if this is right
					   AliAODTrack::kSecondary)
		);
      }
      else {
	cerr << "Error: event " << iEvent << " cascade " << nCascade
	     << " track " << posFromV0 << " has already been used!" << endl;
      }

      // Add the negative tracks from the V0

      if (!usedTrack[negFromV0]) {
	
	usedTrack[negFromV0] = kTRUE;
	
	AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
	
	Double_t p2[3];
	esdTrack->GetPxPyPz(p2);
	
	Double_t x2[3];
	esdTrack->GetXYZ(x2);
	
	Double_t covV0NegTr[21];
	esdTrack->GetCovarianceXYZPxPyPz(covV0NegTr);
	
	Double_t pid2[10];
	esdTrack->GetESDpid(pid2);
	
	vV0FromCascade->AddDaughter(
                new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(),
					   p2,
					   kTRUE,
					   x2,
					   kFALSE,
					   covV0NegTr, 
					   (Short_t)esdTrack->GetSign(),
					   esdTrack->GetITSClusterMap(), 
					   pid2,
					   vV0FromCascade,
					   kFALSE, // check if this is right
					   AliAODTrack::kSecondary)
		);
      }
      else {
	cerr << "Error: event " << iEvent << " cascade " << nCascade
	     << " track " << negFromV0 << " has already been used!" << endl;
      }

      // Add the bachelor track from the cascade

      Int_t bachelor = cascade->GetBindex();
      
      if(!usedTrack[bachelor]) {
      
	usedTrack[bachelor] = kTRUE;
	
	AliESDtrack *esdTrack = esd->GetTrack(bachelor);
	
	Double_t p3[3];
	esdTrack->GetPxPyPz(p3);
	
	Double_t x3[3];
	esdTrack->GetXYZ(x3);
	
	Double_t covXiTr[21];
	esdTrack->GetCovarianceXYZPxPyPz(covXiTr);
	
	Double_t pid3[10];
	esdTrack->GetESDpid(pid3);

	vcascade->AddDaughter(
        	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(),
					   p3,
					   kTRUE,
					   x3,
					   kFALSE,
					   covXiTr, 
					   (Short_t)esdTrack->GetSign(),
					   esdTrack->GetITSClusterMap(), 
					   pid3,
					   vcascade,
					   kFALSE, // check if this is right
					   AliAODTrack::kSecondary)
		);
      }
      else {
	cerr << "Error: event " << iEvent << " cascade " << nCascade
	     << " track " << bachelor << " has already been used!" << endl;
      }

      // Add the primary track of the cascade (if any)

    } // end of the loop on cascades
    
    // V0s
        
    for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {

      if (usedV0[nV0]) continue; // skip if aready added to the AOD

      AliESDv0 *v0 = esd->GetV0(nV0);
      
      Double_t posV0_3[3];
      v0->GetXYZ(posV0_3[0], posV0_3[1], posV0_3[2]);
      Double_t covV0_3[6];
      v0->GetPosCov(covV0_3);

      AliAODVertex * vV0 = 
	new(vertices[jVertices++]) AliAODVertex(posV0_3,
						covV0_3,
						v0->GetChi2V0(),
						primary,
						AliAODVertex::kV0);
      primary->AddDaughter(vV0);

      Int_t posFromV0 = v0->GetPindex();
      Int_t negFromV0 = v0->GetNindex();
      
      // Add the positive tracks from the V0

      if (!usedTrack[posFromV0]) {
	
	usedTrack[posFromV0] = kTRUE;

	AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
      
	Double_t p4[3];
	esdTrack->GetPxPyPz(p4);
	
	Double_t x4[3];
	esdTrack->GetXYZ(x4);
	
	Double_t covV0PosTr_2[21];
	esdTrack->GetCovarianceXYZPxPyPz(covV0PosTr_2);
	
	Double_t pid4[10];
	esdTrack->GetESDpid(pid4);
	
	vV0->AddDaughter(
        	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(), 
					   p4, 
					   kTRUE,
					   x4,
					   kFALSE,
					   covV0PosTr_2, 
					   (Short_t)esdTrack->GetSign(),
					   esdTrack->GetITSClusterMap(), 
					   pid4,
					   vV0,
					   kFALSE, // check if this is right
					   AliAODTrack::kSecondary)
		);
      }
      else {
	cerr << "Error: event " << iEvent << " V0 " << nV0
	     << " track " << posFromV0 << " has already been used!" << endl;
      }

      // Add the negative tracks from the V0

      if (!usedTrack[negFromV0]) {

	usedTrack[negFromV0] = kTRUE;

	AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
      
	Double_t p5[3];
	esdTrack->GetPxPyPz(p5);
	
	Double_t x5[3];
	esdTrack->GetXYZ(x5);
	
	Double_t covV0NegTr_2[21];
	esdTrack->GetCovarianceXYZPxPyPz(covV0NegTr_2);
	
	Double_t pid5[10];
	esdTrack->GetESDpid(pid5);

	vV0->AddDaughter(
                new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(),
					   p5,
					   kTRUE,
					   x5,
					   kFALSE,
					   covV0NegTr_2, 
					   (Short_t)esdTrack->GetSign(),
					   esdTrack->GetITSClusterMap(), 
					   pid5,
					   vV0,
					   kFALSE, // check if this is right
					   AliAODTrack::kSecondary)
		);
      }
      else {
	cerr << "Error: event " << iEvent << " V0 " << nV0
	     << " track " << negFromV0 << " has already been used!" << endl;
      }

    } // end of the loop on V0s
    
    // Kinks: it is a big mess the access to the information in the kinks
    // The loop is on the tracks in order to find the mother and daugther of each kink


    for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {


      AliESDtrack * track = esd->GetTrack(iTrack);


      Int_t ikink = track->GetKinkIndex(0);

      if (ikink) {
	// Negative kink index: mother, positive: daughter

	// Search for the second track of the kink

	for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {

	  AliESDtrack * track1 = esd->GetTrack(jTrack);

	  Int_t jkink = track1->GetKinkIndex(0);

	  if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {

	    // The two tracks are from the same kink
	  
	    if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks

	    Int_t imother = -1;
	    Int_t idaughter = -1;

	    if (ikink<0 && jkink>0) {

	      imother = iTrack;
	      idaughter = jTrack;
	    }
	    else if (ikink>0 && jkink<0) {

	      imother = jTrack;
	      idaughter = iTrack;
	    }
	    else {
	      cerr << "Error: Wrong combination of kink indexes: "
	      << ikink << " " << jkink << endl;
	      continue;
	    }

	    // Add the mother track

	    AliAODTrack * mother = NULL;

	    if (!usedTrack[imother]) {
	
	      usedTrack[imother] = kTRUE;
	
	      AliESDtrack *esdTrack = esd->GetTrack(imother);
	
	      Double_t p6[3];
	      esdTrack->GetPxPyPz(p6);
	      
	      Double_t x6[3];
	      esdTrack->GetXYZ(x6);
	      
	      Double_t covKinkMother[21];
	      esdTrack->GetCovarianceXYZPxPyPz(covKinkMother);
	      
	      Double_t pid6[10];
	      esdTrack->GetESDpid(pid6);

	      mother = 
		new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(),
					   p6,
					   kTRUE,
					   x6,
					   kFALSE,
					   covKinkMother, 
					   (Short_t)esdTrack->GetSign(),
					   esdTrack->GetITSClusterMap(), 
					   pid6,
					   primary,
					   kTRUE, // check if this is right
					   AliAODTrack::kPrimary);
	      primary->AddDaughter(mother);
	    }
	    else {
	      cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
	      << " track " << imother << " has already been used!" << endl;
	    }

	    // Add the kink vertex
	    AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1);

	    AliAODVertex * vkink = 
	    new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
						    NULL,
						    0.,
						    mother,
						    AliAODVertex::kKink);
	    // Add the daughter track

	    AliAODTrack * daughter = NULL;

	    if (!usedTrack[idaughter]) {
	
	      usedTrack[idaughter] = kTRUE;
	
	      AliESDtrack *esdTrack = esd->GetTrack(idaughter);
	
	      Double_t p7[3];
	      esdTrack->GetPxPyPz(p7);
	      
	      Double_t x7[3];
	      esdTrack->GetXYZ(x7);
	      
	      Double_t covKinkDaughter[21];
	      esdTrack->GetCovarianceXYZPxPyPz(covKinkDaughter);
	      
	      Double_t pid7[10];
	      esdTrack->GetESDpid(pid7);

	      daughter = 
		new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(),
					   p7,
					   kTRUE,
					   x7,
					   kFALSE,
					   covKinkDaughter, 
					   (Short_t)esdTrack->GetSign(),
					   esdTrack->GetITSClusterMap(), 
					   pid7,
					   vkink,
					   kTRUE, // check if this is right
					   AliAODTrack::kPrimary);
	      vkink->AddDaughter(daughter);
	    }
	    else {
	      cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
	      << " track " << idaughter << " has already been used!" << endl;
	    }


	  }
	}

      }      

    }

    
    // Tracks (primary and orphan)
      
    for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
	

      if (usedTrack[nTrack]) continue;

      AliESDtrack *esdTrack = esd->GetTrack(nTrack);
      
      Double_t p8[3];
      esdTrack->GetPxPyPz(p8);
      
      Double_t x8[3];
      esdTrack->GetXYZ(x8);
      
      Double_t covTr[21];
      esdTrack->GetCovarianceXYZPxPyPz(covTr);
 	
      Double_t pid8[10];
      esdTrack->GetESDpid(pid8);

      Float_t impactXY, impactZ;

      esdTrack->GetImpactParameters(impactXY,impactZ);

      if (impactXY<3) {
	// track inside the beam pipe
      
	primary->AddDaughter(
	    new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					 esdTrack->GetLabel(),
					 p8,
					 kTRUE,
					 x8,
					 kFALSE,
					 covTr, 
					 (Short_t)esdTrack->GetSign(),
					 esdTrack->GetITSClusterMap(), 
					 pid8,
					 primary,
					 kTRUE, // check if this is right
					 AliAODTrack::kPrimary)
	    );
      }
      else {
	// outside the beam pipe: orphan track
	    new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					 esdTrack->GetLabel(),
					 p8,
					 kTRUE,
					 x8,
					 kFALSE,
					 covTr, 
					 (Short_t)esdTrack->GetSign(),
					 esdTrack->GetITSClusterMap(), 
					 pid8,
					 NULL,
					 kFALSE, // check if this is right
					 AliAODTrack::kOrphan);
      }	
    } // end of loop on tracks


    // Access to the AOD container of clusters
    TClonesArray &clusters = *(aod->GetClusters());
    Int_t jClusters=0;

    // Calo Clusters
    Int_t nClusters    = esd->GetNumberOfCaloClusters();

    for (Int_t iClust=0; iClust<nClusters; ++iClust) {

      AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);

      Int_t id = cluster->GetID();
      Int_t label = -1;
      Float_t energy = cluster->GetClusterEnergy();
      Float_t x9[3];
      cluster->GetGlobalPosition(x9);
      Float_t * covMatrix = NULL;
      Float_t * pid9 = NULL; 
      AliAODVertex *prodVertex = primary;
      AliAODTrack *primTrack = NULL;
      Char_t ttype=AliAODCluster::kUndef;

      if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral;
      else if (cluster->IsEMCAL()) {

	if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster)
	  ttype = AliAODCluster::kEMCALPseudoCluster;
	else
	  ttype = AliAODCluster::kEMCALClusterv1;

      }
      
      new(clusters[jClusters++]) AliAODCluster(id,
					       label,
					       energy,
					       x9,
					       covMatrix,
					       pid9,
					       prodVertex,
					       primTrack,
					       ttype);

    } // end of loop on calo clusters


    delete [] usedTrack;
    delete [] usedV0;
    delete [] usedKink;

    // fill the tree for this event
    aodTree->Fill();
  } // end of event loop
  
  aodTree->GetUserInfo()->Add(aod);

  // close ESD file
  inFile->Close();
  
  // write the tree to the specified file
  outFile = aodTree->GetCurrentFile();
  outFile->cd();
  aodTree->Write();
  outFile->Close();

}
Commit	Line	Data
e985a35a	1	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
e985a35a	2
cf22b3fc	3	#include <Riostream.h>
	4	#include <TFile.h>
	5	#include <TTree.h>
	6	#include <TMath.h>
df9db588	7
df9db588	8	#include "AliAODEvent.h"
31fd97b2	9	#include "AliAODHeader.h"
cf22b3fc	10	#include "AliAODVertex.h"
cf22b3fc	11	#include "AliAODTrack.h"
a9255000	12	#include "AliAODCluster.h"
cf22b3fc	13
df9db588	14	#include "AliESD.h"
	15	#include "AliESDtrack.h"
	16	#include "AliESDVertex.h"
	17	#include "AliESDv0.h"
31fd97b2	18	#include "AliESDcascade.h"
cf22b3fc	19	#include "AliESDCaloCluster.h"
df9db588	20
e985a35a	21	#endif
e985a35a	22
cf22b3fc	23	void CreateAODfromESD(const char *inFileName = "AliESDs.root",
cf22b3fc	24	const char *outFileName = "AliAOD.root") {
df9db588	25
	26	// create an AliAOD object
	27	AliAODEvent *aod = new AliAODEvent();
	28	aod->CreateStdContent();
	29
	30	// open the file
	31	TFile *outFile = TFile::Open(outFileName, "RECREATE");
	32
	33	// create the tree
	34	TTree *aodTree = new TTree("AOD", "AliAOD tree");
	35	aodTree->Branch(aod->GetList());
	36
	37	// connect to ESD
	38	TFile *inFile = TFile::Open(inFileName, "READ");
	39	TTree t = (TTree) inFile->Get("esdTree");
	40	TBranch *b = t->GetBranch("ESD");
	41	AliESD *esd = 0;
	42	b->SetAddress(&esd);
	43
	44	Int_t nEvents = b->GetEntries();
	45
	46	// loop over events and fill them
	47	for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
	48	b->GetEntry(iEvent);
	49
	50	// Multiplicity information needed by the header (to be revised!)
	51	Int_t nTracks = esd->GetNumberOfTracks();
	52	Int_t nPosTracks = 0;
	53	for (Int_t iTrack=0; iTrack<nTracks; ++iTrack)
	54	if (esd->GetTrack(iTrack)->GetSign()> 0) nPosTracks++;
	55
	56	// create the header
31fd97b2	57	aod->AddHeader(new AliAODHeader(esd->GetRunNumber(),
	58	esd->GetBunchCrossNumber(),
	59	esd->GetOrbitNumber(),
df9db588	60	nTracks,
	61	nPosTracks,
	62	nTracks-nPosTracks,
	63	esd->GetMagneticField(),
4773afc9	64	-999., // fill muon magnetic field
df9db588	65	-999., // centrality; to be filled, still
4773afc9	66	esd->GetZDCN1Energy(),
	67	esd->GetZDCP1Energy(),
	68	esd->GetZDCN2Energy(),
	69	esd->GetZDCP2Energy(),
	70	esd->GetZDCEMEnergy(),
df9db588	71	esd->GetTriggerMask(),
	72	esd->GetTriggerCluster(),
	73	esd->GetEventType()));
	74
	75	Int_t nV0s = esd->GetNumberOfV0s();
	76	Int_t nCascades = esd->GetNumberOfCascades();
	77	Int_t nKinks = esd->GetNumberOfKinks();
	78	Int_t nVertices = nV0s + nCascades + nKinks;
	79
	80	aod->ResetStd(nTracks, nVertices);
	81
	82
	83	// Array to take into account the tracks already added to the AOD
	84	Bool_t * usedTrack = NULL;
	85	if (nTracks>0) {
	86	usedTrack = new Bool_t[nTracks];
	87	for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
	88	}
	89	// Array to take into account the V0s already added to the AOD
	90	Bool_t * usedV0 = NULL;
	91	if (nV0s>0) {
	92	usedV0 = new Bool_t[nV0s];
	93	for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
	94	}
cf22b3fc	95	// Array to take into account the kinks already added to the AOD
	96	Bool_t * usedKink = NULL;
	97	if (nKinks>0) {
	98	usedKink = new Bool_t[nKinks];
	99	for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
	100	}
df9db588	101
	102	// Access to the AOD container of vertices
	103	TClonesArray &vertices = *(aod->GetVertices());
	104	Int_t jVertices=0;
	105
	106	// Access to the AOD container of tracks
	107	TClonesArray &tracks = *(aod->GetTracks());
	108	Int_t jTracks=0;
	109
	110	// Add primary vertex. The primary tracks will be defined
	111	// after the loops on the composite objects (V0, cascades, kinks)
	112	const AliESDVertex *vtx = esd->GetPrimaryVertex();
	113
	114	Double_t pos[3];
	115	vtx->GetXYZ(pos); // position
31fd97b2	116	Double_t covVtx[6]; // We have to give changing names to the variables (like cov?, x?, and p?) because CINT doesn't recognize blocks correctly.
31fd97b2	117	vtx->GetCovMatrix(covVtx); //covariance matrix
df9db588	118
df9db588	119	AliAODVertex * primary = new(vertices[jVertices++])
31fd97b2	120	AliAODVertex(pos, covVtx, vtx->GetChi2(), NULL, AliAODVertex::kPrimary);
df9db588	121
	122	// Create vertices starting from the most complex objects
	123
	124	// Cascades
	125	for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
	126	AliESDcascade *cascade = esd->GetCascade(nCascade);
	127
	128	Double_t posXi[3];
	129	cascade->GetXYZ(posXi[0], posXi[1], posXi[2]);
	130	Double_t covXi[6];
	131	cascade->GetPosCovXi(covXi);
	132
	133	// Add the cascade vertex
	134	AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(posXi,
	135	covXi,
	136	cascade->GetChi2Xi(),
	137	primary,
	138	AliAODVertex::kCascade);
	139
	140	primary->AddDaughter(vcascade);
	141
	142	// Add the V0 from the cascade. The ESD class have to be optimized...
	143	// Now we have to search for the corresponding Vo in the list of V0s
	144	// using the indeces of the positive and negative tracks
	145
	146	Int_t posFromV0 = cascade->GetPindex();
	147	Int_t negFromV0 = cascade->GetNindex();
	148
	149
	150	AliESDv0 * v0 = 0x0;
	151	Int_t indV0 = -1;
	152
	153	for (Int_t iV0=0; iV0<nV0s; ++iV0) {
	154
	155	v0 = esd->GetV0(iV0);
31fd97b2	156	Int_t posV0 = v0->GetPindex();
31fd97b2	157	Int_t negV0 = v0->GetNindex();
df9db588	158
31fd97b2	159	if (posV0==posFromV0 && negV0==negFromV0) {
df9db588	160	indV0 = iV0;
	161	break;
	162	}
	163	}
	164
	165	AliAODVertex * vV0FromCascade = 0x0;
	166
cf22b3fc	167	if (indV0>-1 && !usedV0[indV0] ) {
df9db588	168
cf22b3fc	169	// the V0 exists in the array of V0s and is not used
cf22b3fc	170
df9db588	171	usedV0[indV0] = kTRUE;
	172
	173	Double_t posV0[3];
	174	v0->GetXYZ(posV0[0], posV0[1], posV0[2]);
31fd97b2	175	Double_t covV0_1[6];
31fd97b2	176	v0->GetPosCov(covV0_1);
cf22b3fc	177
df9db588	178	vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(posV0,
31fd97b2	179	covV0_1,
df9db588	180	v0->GetChi2V0(),
	181	vcascade,
	182	AliAODVertex::kV0);
	183	} else {
	184
cf22b3fc	185	// the V0 doesn't exist in the array of V0s or was used
	186	cerr << "Error: event " << iEvent << " cascade " << nCascade
	187	<< " The V0 " << indV0
	188	<< " doesn't exist in the array of V0s or was used!" << endl;
	189
31fd97b2	190	Double_t posV0_2[3];
	191	cascade->GetXYZ(posV0_2[0], posV0_2[1], posV0_2[2]);
	192	Double_t covV0_2[6];
	193	cascade->GetPosCov(covV0_2);
df9db588	194
31fd97b2	195	vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(posV0_2,
31fd97b2	196	covV0_2,
df9db588	197	v0->GetChi2V0(),
	198	vcascade,
	199	AliAODVertex::kV0);
	200	vcascade->AddDaughter(vV0FromCascade);
	201	}
	202
	203	// Add the positive tracks from the V0
	204
cf22b3fc	205	if (! usedTrack[posFromV0]) {
	206
	207	usedTrack[posFromV0] = kTRUE;
df9db588	208
df9db588	209	AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
cf22b3fc	210
31fd97b2	211	Double_t p1[3];
31fd97b2	212	esdTrack->GetPxPyPz(p1);
df9db588	213
31fd97b2	214	Double_t x1[3];
31fd97b2	215	esdTrack->GetXYZ(x1);
df9db588	216
31fd97b2	217	Double_t covV0PosTr[21];
31fd97b2	218	esdTrack->GetCovarianceXYZPxPyPz(covV0PosTr);
cf22b3fc	219
31fd97b2	220	Double_t pid1[10];
31fd97b2	221	esdTrack->GetESDpid(pid1);
df9db588	222
df9db588	223	vV0FromCascade->AddDaughter(
cf22b3fc	224	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
df9db588	225	esdTrack->GetLabel(),
31fd97b2	226	p1,
	227	kTRUE,
	228	x1,
df9db588	229	kFALSE,
31fd97b2	230	covV0PosTr,
df9db588	231	(Short_t)esdTrack->GetSign(),
df9db588	232	esdTrack->GetITSClusterMap(),
31fd97b2	233	pid1,
df9db588	234	vV0FromCascade,
4773afc9	235	kFALSE, // check if this is right
df9db588	236	AliAODTrack::kSecondary)
	237	);
	238	}
cf22b3fc	239	else {
	240	cerr << "Error: event " << iEvent << " cascade " << nCascade
	241	<< " track " << posFromV0 << " has already been used!" << endl;
	242	}
df9db588	243
	244	// Add the negative tracks from the V0
	245
cf22b3fc	246	if (!usedTrack[negFromV0]) {
	247
	248	usedTrack[negFromV0] = kTRUE;
	249
df9db588	250	AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
cf22b3fc	251
31fd97b2	252	Double_t p2[3];
31fd97b2	253	esdTrack->GetPxPyPz(p2);
df9db588	254
31fd97b2	255	Double_t x2[3];
31fd97b2	256	esdTrack->GetXYZ(x2);
df9db588	257
31fd97b2	258	Double_t covV0NegTr[21];
31fd97b2	259	esdTrack->GetCovarianceXYZPxPyPz(covV0NegTr);
df9db588	260
31fd97b2	261	Double_t pid2[10];
31fd97b2	262	esdTrack->GetESDpid(pid2);
cf22b3fc	263
df9db588	264	vV0FromCascade->AddDaughter(
	265	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
	266	esdTrack->GetLabel(),
31fd97b2	267	p2,
df9db588	268	kTRUE,
31fd97b2	269	x2,
df9db588	270	kFALSE,
31fd97b2	271	covV0NegTr,
df9db588	272	(Short_t)esdTrack->GetSign(),
df9db588	273	esdTrack->GetITSClusterMap(),
31fd97b2	274	pid2,
df9db588	275	vV0FromCascade,
4773afc9	276	kFALSE, // check if this is right
df9db588	277	AliAODTrack::kSecondary)
	278	);
	279	}
cf22b3fc	280	else {
	281	cerr << "Error: event " << iEvent << " cascade " << nCascade
	282	<< " track " << negFromV0 << " has already been used!" << endl;
	283	}
df9db588	284
	285	// Add the bachelor track from the cascade
	286
	287	Int_t bachelor = cascade->GetBindex();
df9db588	288
cf22b3fc	289	if(!usedTrack[bachelor]) {
	290
	291	usedTrack[bachelor] = kTRUE;
	292
	293	AliESDtrack *esdTrack = esd->GetTrack(bachelor);
	294
31fd97b2	295	Double_t p3[3];
31fd97b2	296	esdTrack->GetPxPyPz(p3);
df9db588	297
31fd97b2	298	Double_t x3[3];
31fd97b2	299	esdTrack->GetXYZ(x3);
df9db588	300
31fd97b2	301	Double_t covXiTr[21];
31fd97b2	302	esdTrack->GetCovarianceXYZPxPyPz(covXiTr);
df9db588	303
31fd97b2	304	Double_t pid3[10];
31fd97b2	305	esdTrack->GetESDpid(pid3);
df9db588	306
	307	vcascade->AddDaughter(
	308	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
	309	esdTrack->GetLabel(),
31fd97b2	310	p3,
df9db588	311	kTRUE,
31fd97b2	312	x3,
df9db588	313	kFALSE,
31fd97b2	314	covXiTr,
df9db588	315	(Short_t)esdTrack->GetSign(),
df9db588	316	esdTrack->GetITSClusterMap(),
31fd97b2	317	pid3,
df9db588	318	vcascade,
4773afc9	319	kFALSE, // check if this is right
df9db588	320	AliAODTrack::kSecondary)
	321	);
	322	}
cf22b3fc	323	else {
	324	cerr << "Error: event " << iEvent << " cascade " << nCascade
	325	<< " track " << bachelor << " has already been used!" << endl;
	326	}
df9db588	327
	328	// Add the primary track of the cascade (if any)
	329
cf22b3fc	330	} // end of the loop on cascades
df9db588	331
	332	// V0s
	333
	334	for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
	335
	336	if (usedV0[nV0]) continue; // skip if aready added to the AOD
	337
	338	AliESDv0 *v0 = esd->GetV0(nV0);
	339
31fd97b2	340	Double_t posV0_3[3];
	341	v0->GetXYZ(posV0_3[0], posV0_3[1], posV0_3[2]);
	342	Double_t covV0_3[6];
	343	v0->GetPosCov(covV0_3);
df9db588	344
df9db588	345	AliAODVertex * vV0 =
31fd97b2	346	new(vertices[jVertices++]) AliAODVertex(posV0_3,
31fd97b2	347	covV0_3,
df9db588	348	v0->GetChi2V0(),
	349	primary,
	350	AliAODVertex::kV0);
	351	primary->AddDaughter(vV0);
	352
	353	Int_t posFromV0 = v0->GetPindex();
	354	Int_t negFromV0 = v0->GetNindex();
31fd97b2	355
df9db588	356	// Add the positive tracks from the V0
df9db588	357
cf22b3fc	358	if (!usedTrack[posFromV0]) {
	359
	360	usedTrack[posFromV0] = kTRUE;
df9db588	361
	362	AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
	363
31fd97b2	364	Double_t p4[3];
31fd97b2	365	esdTrack->GetPxPyPz(p4);
df9db588	366
31fd97b2	367	Double_t x4[3];
31fd97b2	368	esdTrack->GetXYZ(x4);
df9db588	369
31fd97b2	370	Double_t covV0PosTr_2[21];
31fd97b2	371	esdTrack->GetCovarianceXYZPxPyPz(covV0PosTr_2);
cf22b3fc	372
31fd97b2	373	Double_t pid4[10];
31fd97b2	374	esdTrack->GetESDpid(pid4);
df9db588	375
	376	vV0->AddDaughter(
	377	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
	378	esdTrack->GetLabel(),
31fd97b2	379	p4,
	380	kTRUE,
	381	x4,
df9db588	382	kFALSE,
31fd97b2	383	covV0PosTr_2,
df9db588	384	(Short_t)esdTrack->GetSign(),
df9db588	385	esdTrack->GetITSClusterMap(),
31fd97b2	386	pid4,
df9db588	387	vV0,
4773afc9	388	kFALSE, // check if this is right
df9db588	389	AliAODTrack::kSecondary)
	390	);
	391	}
cf22b3fc	392	else {
	393	cerr << "Error: event " << iEvent << " V0 " << nV0
	394	<< " track " << posFromV0 << " has already been used!" << endl;
	395	}
df9db588	396
	397	// Add the negative tracks from the V0
	398
cf22b3fc	399	if (!usedTrack[negFromV0]) {
	400
	401	usedTrack[negFromV0] = kTRUE;
df9db588	402
	403	AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
	404
31fd97b2	405	Double_t p5[3];
31fd97b2	406	esdTrack->GetPxPyPz(p5);
df9db588	407
31fd97b2	408	Double_t x5[3];
31fd97b2	409	esdTrack->GetXYZ(x5);
df9db588	410
31fd97b2	411	Double_t covV0NegTr_2[21];
31fd97b2	412	esdTrack->GetCovarianceXYZPxPyPz(covV0NegTr_2);
df9db588	413
31fd97b2	414	Double_t pid5[10];
31fd97b2	415	esdTrack->GetESDpid(pid5);
df9db588	416
	417	vV0->AddDaughter(
	418	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
	419	esdTrack->GetLabel(),
31fd97b2	420	p5,
df9db588	421	kTRUE,
31fd97b2	422	x5,
df9db588	423	kFALSE,
31fd97b2	424	covV0NegTr_2,
df9db588	425	(Short_t)esdTrack->GetSign(),
df9db588	426	esdTrack->GetITSClusterMap(),
31fd97b2	427	pid5,
df9db588	428	vV0,
4773afc9	429	kFALSE, // check if this is right
df9db588	430	AliAODTrack::kSecondary)
	431	);
	432	}
cf22b3fc	433	else {
	434	cerr << "Error: event " << iEvent << " V0 " << nV0
	435	<< " track " << negFromV0 << " has already been used!" << endl;
	436	}
df9db588	437
cf22b3fc	438	} // end of the loop on V0s
df9db588	439
cf22b3fc	440	// Kinks: it is a big mess the access to the information in the kinks
	441	// The loop is on the tracks in order to find the mother and daugther of each kink
	442
	443
	444	for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
	445
	446
	447	AliESDtrack * track = esd->GetTrack(iTrack);
	448
	449
	450	Int_t ikink = track->GetKinkIndex(0);
	451
	452	if (ikink) {
	453	// Negative kink index: mother, positive: daughter
	454
	455	// Search for the second track of the kink
	456
	457	for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {
	458
	459	AliESDtrack * track1 = esd->GetTrack(jTrack);
	460
	461	Int_t jkink = track1->GetKinkIndex(0);
	462
	463	if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
	464
	465	// The two tracks are from the same kink
	466
	467	if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
	468
	469	Int_t imother = -1;
	470	Int_t idaughter = -1;
	471
	472	if (ikink<0 && jkink>0) {
	473
	474	imother = iTrack;
	475	idaughter = jTrack;
	476	}
	477	else if (ikink>0 && jkink<0) {
	478
	479	imother = jTrack;
	480	idaughter = iTrack;
	481	}
	482	else {
	483	cerr << "Error: Wrong combination of kink indexes: "
	484	<< ikink << " " << jkink << endl;
	485	continue;
	486	}
	487
	488	// Add the mother track
	489
	490	AliAODTrack * mother = NULL;
	491
	492	if (!usedTrack[imother]) {
	493
	494	usedTrack[imother] = kTRUE;
	495
	496	AliESDtrack *esdTrack = esd->GetTrack(imother);
	497
31fd97b2	498	Double_t p6[3];
31fd97b2	499	esdTrack->GetPxPyPz(p6);
cf22b3fc	500
31fd97b2	501	Double_t x6[3];
31fd97b2	502	esdTrack->GetXYZ(x6);
cf22b3fc	503
31fd97b2	504	Double_t covKinkMother[21];
31fd97b2	505	esdTrack->GetCovarianceXYZPxPyPz(covKinkMother);
cf22b3fc	506
31fd97b2	507	Double_t pid6[10];
	508	esdTrack->GetESDpid(pid6);
	509
cf22b3fc	510	mother =
	511	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
	512	esdTrack->GetLabel(),
31fd97b2	513	p6,
cf22b3fc	514	kTRUE,
31fd97b2	515	x6,
cf22b3fc	516	kFALSE,
31fd97b2	517	covKinkMother,
cf22b3fc	518	(Short_t)esdTrack->GetSign(),
cf22b3fc	519	esdTrack->GetITSClusterMap(),
31fd97b2	520	pid6,
cf22b3fc	521	primary,
4773afc9	522	kTRUE, // check if this is right
cf22b3fc	523	AliAODTrack::kPrimary);
	524	primary->AddDaughter(mother);
	525	}
	526	else {
	527	cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
	528	<< " track " << imother << " has already been used!" << endl;
	529	}
	530
	531	// Add the kink vertex
	532	AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1);
	533
	534	AliAODVertex * vkink =
	535	new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
	536	NULL,
	537	0.,
	538	mother,
	539	AliAODVertex::kKink);
	540	// Add the daughter track
	541
	542	AliAODTrack * daughter = NULL;
	543
	544	if (!usedTrack[idaughter]) {
	545
	546	usedTrack[idaughter] = kTRUE;
	547
	548	AliESDtrack *esdTrack = esd->GetTrack(idaughter);
	549
31fd97b2	550	Double_t p7[3];
31fd97b2	551	esdTrack->GetPxPyPz(p7);
cf22b3fc	552
31fd97b2	553	Double_t x7[3];
31fd97b2	554	esdTrack->GetXYZ(x7);
cf22b3fc	555
31fd97b2	556	Double_t covKinkDaughter[21];
31fd97b2	557	esdTrack->GetCovarianceXYZPxPyPz(covKinkDaughter);
cf22b3fc	558
31fd97b2	559	Double_t pid7[10];
	560	esdTrack->GetESDpid(pid7);
	561
cf22b3fc	562	daughter =
	563	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
	564	esdTrack->GetLabel(),
31fd97b2	565	p7,
cf22b3fc	566	kTRUE,
31fd97b2	567	x7,
cf22b3fc	568	kFALSE,
31fd97b2	569	covKinkDaughter,
cf22b3fc	570	(Short_t)esdTrack->GetSign(),
cf22b3fc	571	esdTrack->GetITSClusterMap(),
31fd97b2	572	pid7,
cf22b3fc	573	vkink,
4773afc9	574	kTRUE, // check if this is right
cf22b3fc	575	AliAODTrack::kPrimary);
	576	vkink->AddDaughter(daughter);
	577	}
	578	else {
	579	cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
	580	<< " track " << idaughter << " has already been used!" << endl;
	581	}
	582
	583
	584	}
	585	}
	586
	587	}
df9db588	588
df9db588	589	}
cf22b3fc	590
df9db588	591
cf22b3fc	592	// Tracks (primary and orphan)
df9db588	593
	594	for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
	595
	596
	597	if (usedTrack[nTrack]) continue;
	598
	599	AliESDtrack *esdTrack = esd->GetTrack(nTrack);
	600
31fd97b2	601	Double_t p8[3];
31fd97b2	602	esdTrack->GetPxPyPz(p8);
df9db588	603
31fd97b2	604	Double_t x8[3];
31fd97b2	605	esdTrack->GetXYZ(x8);
df9db588	606
31fd97b2	607	Double_t covTr[21];
	608	esdTrack->GetCovarianceXYZPxPyPz(covTr);
	609
	610	Double_t pid8[10];
	611	esdTrack->GetESDpid(pid8);
cf22b3fc	612
	613	Float_t impactXY, impactZ;
	614
	615	esdTrack->GetImpactParameters(impactXY,impactZ);
	616
	617	if (impactXY<3) {
	618	// track inside the beam pipe
df9db588	619
cf22b3fc	620	primary->AddDaughter(
cf22b3fc	621	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
df9db588	622	esdTrack->GetLabel(),
31fd97b2	623	p8,
df9db588	624	kTRUE,
31fd97b2	625	x8,
df9db588	626	kFALSE,
31fd97b2	627	covTr,
df9db588	628	(Short_t)esdTrack->GetSign(),
df9db588	629	esdTrack->GetITSClusterMap(),
31fd97b2	630	pid8,
df9db588	631	primary,
4773afc9	632	kTRUE, // check if this is right
df9db588	633	AliAODTrack::kPrimary)
cf22b3fc	634	);
	635	}
	636	else {
	637	// outside the beam pipe: orphan track
	638	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
	639	esdTrack->GetLabel(),
31fd97b2	640	p8,
cf22b3fc	641	kTRUE,
31fd97b2	642	x8,
cf22b3fc	643	kFALSE,
31fd97b2	644	covTr,
cf22b3fc	645	(Short_t)esdTrack->GetSign(),
cf22b3fc	646	esdTrack->GetITSClusterMap(),
31fd97b2	647	pid8,
cf22b3fc	648	NULL,
4773afc9	649	kFALSE, // check if this is right
cf22b3fc	650	AliAODTrack::kOrphan);
	651	}
	652	} // end of loop on tracks
	653
	654
4773afc9	655	// Access to the AOD container of clusters
a9255000	656	TClonesArray &clusters = *(aod->GetClusters());
cf22b3fc	657	Int_t jClusters=0;
cf22b3fc	658
4773afc9	659	// Calo Clusters
cf22b3fc	660	Int_t nClusters = esd->GetNumberOfCaloClusters();
	661
	662	for (Int_t iClust=0; iClust<nClusters; ++iClust) {
	663
	664	AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
	665
	666	Int_t id = cluster->GetID();
	667	Int_t label = -1;
	668	Float_t energy = cluster->GetClusterEnergy();
31fd97b2	669	Float_t x9[3];
31fd97b2	670	cluster->GetGlobalPosition(x9);
cf22b3fc	671	Float_t * covMatrix = NULL;
31fd97b2	672	Float_t * pid9 = NULL;
cf22b3fc	673	AliAODVertex *prodVertex = primary;
cf22b3fc	674	AliAODTrack *primTrack = NULL;
a9255000	675	Char_t ttype=AliAODCluster::kUndef;
cf22b3fc	676
a9255000	677	if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral;
cf22b3fc	678	else if (cluster->IsEMCAL()) {
	679
	680	if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster)
a9255000	681	ttype = AliAODCluster::kEMCALPseudoCluster;
cf22b3fc	682	else
a9255000	683	ttype = AliAODCluster::kEMCALClusterv1;
cf22b3fc	684
cf22b3fc	685	}
df9db588	686
a9255000	687	new(clusters[jClusters++]) AliAODCluster(id,
cf22b3fc	688	label,
cf22b3fc	689	energy,
31fd97b2	690	x9,
cf22b3fc	691	covMatrix,
31fd97b2	692	pid9,
cf22b3fc	693	prodVertex,
	694	primTrack,
	695	ttype);
	696
4773afc9	697	} // end of loop on calo clusters
cf22b3fc	698
	699
	700	delete [] usedTrack;
	701	delete [] usedV0;
	702	delete [] usedKink;
	703
df9db588	704	// fill the tree for this event
df9db588	705	aodTree->Fill();
cf22b3fc	706	} // end of event loop
df9db588	707
	708	aodTree->GetUserInfo()->Add(aod);
	709
	710	// close ESD file
	711	inFile->Close();
	712
	713	// write the tree to the specified file
	714	outFile = aodTree->GetCurrentFile();
	715	outFile->cd();
	716	aodTree->Write();
	717	outFile->Close();
	718
	719	}