[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 "AliAODTracklets.h"

#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliESDMuonTrack.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") {

  // open input file
  TFile *inFile = TFile::Open(inFileName, "READ");

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

  // open output file
  TFile *outFile = TFile::Open(outFileName, "RECREATE");
  outFile->cd();

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

  // connect to ESD
  TTree *t = (TTree*) inFile->Get("esdTree");
  AliESDEvent *esd = new AliESDEvent();
  esd->ReadFromTree(t);

  Int_t nEvents = t->GetEntries();

  // set arrays and pointers
  Float_t posF[3];
  Double_t pos[3];
  Double_t p[3];
  Double_t covVtx[6];
  Double_t covTr[21];
  Double_t pid[10];

  // loop over events and fill them
  for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
    t->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)->Charge()> 0) nPosTracks++;

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

    // fill the header
    header->SetRunNumber       (esd->GetRunNumber()       );
    header->SetBunchCrossNumber(esd->GetBunchCrossNumber());
    header->SetOrbitNumber     (esd->GetOrbitNumber()     );
    header->SetPeriodNumber    (esd->GetPeriodNumber()    );
    header->SetTriggerMask     (esd->GetTriggerMask()     ); 
    header->SetTriggerCluster  (esd->GetTriggerCluster()  );
    header->SetEventType       (esd->GetEventType()       );
    header->SetMagneticField   (esd->GetMagneticField()   );
    header->SetZDCN1Energy     (esd->GetZDCN1Energy()     );
    header->SetZDCP1Energy     (esd->GetZDCP1Energy()     );
    header->SetZDCN2Energy     (esd->GetZDCN2Energy()     );
    header->SetZDCP2Energy     (esd->GetZDCP2Energy()     );
    header->SetZDCEMEnergy     (esd->GetZDCEMEnergy()     );
    header->SetRefMultiplicity   (nTracks);
    header->SetRefMultiplicityPos(nPosTracks);
    header->SetRefMultiplicityNeg(nTracks - nPosTracks);
    header->SetMuonMagFieldScale(-999.); // FIXME
    header->SetCentrality(-999.);        // FIXME

    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);
    AliAODTrack *aodTrack;
    
    // 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();
      
    vtx->GetXYZ(pos); // position
    vtx->GetCovMatrix(covVtx); //covariance matrix

    AliAODVertex * primary = new(vertices[jVertices++])
      AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
         
    // Create vertices starting from the most complex objects
      
    // Cascades
    for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
      AliESDcascade *cascade = esd->GetCascade(nCascade);
      
      cascade->GetXYZ(pos[0], pos[1], pos[2]);
      cascade->GetPosCovXi(covVtx);
     
      // Add the cascade vertex
      AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos,
									covVtx,
									cascade->GetChi2Xi(), // = chi2/NDF since NDF = 2*2-3
									primary,
									nCascade,
									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 V0 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;
	
	v0->GetXYZ(pos[0], pos[1], pos[2]);
	v0->GetPosCov(covVtx);
	
	vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
								 covVtx,
								 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
								 vcascade,
								 indV0,
								 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;

	cascade->GetXYZ(pos[0], pos[1], pos[2]);
	cascade->GetPosCov(covVtx);
      
	vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
								 covVtx,
								 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
								 vcascade,
								 indV0,
								 AliAODVertex::kV0);
	vcascade->AddDaughter(vV0FromCascade);
      }

      // Add the positive tracks from the V0

      if (! usedTrack[posFromV0]) {

	usedTrack[posFromV0] = kTRUE;

	AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
	esdTrack->GetPxPyPz(p);
	esdTrack->GetXYZ(pos);
	esdTrack->GetCovarianceXYZPxPyPz(covTr);
	esdTrack->GetESDpid(pid);
	
	vV0FromCascade->AddDaughter(aodTrack =
				    new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(), 
					   p, 
					   kTRUE,
					   pos,
					   kFALSE,
					   covTr, 
					   (Short_t)esdTrack->Charge(),
					   esdTrack->GetITSClusterMap(), 
					   pid,
					   vV0FromCascade,
					   kTRUE,  // check if this is right
					   kFALSE, // check if this is right
					   AliAODTrack::kSecondary)
		);
	aodTrack->ConvertAliPIDtoAODPID();
      }
      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);
	esdTrack->GetPxPyPz(p);
	esdTrack->GetXYZ(pos);
	esdTrack->GetCovarianceXYZPxPyPz(covTr);
	esdTrack->GetESDpid(pid);
	
	vV0FromCascade->AddDaughter(aodTrack =
                new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(),
					   p,
					   kTRUE,
					   pos,
					   kFALSE,
					   covTr, 
					   (Short_t)esdTrack->Charge(),
					   esdTrack->GetITSClusterMap(), 
					   pid,
					   vV0FromCascade,
					   kTRUE,  // check if this is right
					   kFALSE, // check if this is right
					   AliAODTrack::kSecondary)
		);
	aodTrack->ConvertAliPIDtoAODPID();
      }
      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);
	esdTrack->GetPxPyPz(p);
	esdTrack->GetXYZ(pos);
	esdTrack->GetCovarianceXYZPxPyPz(covTr);
	esdTrack->GetESDpid(pid);

	vcascade->AddDaughter(aodTrack =
        	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(),
					   p,
					   kTRUE,
					   pos,
					   kFALSE,
					   covTr, 
					   (Short_t)esdTrack->Charge(),
					   esdTrack->GetITSClusterMap(), 
					   pid,
					   vcascade,
					   kTRUE,  // check if this is right
					   kFALSE, // check if this is right
					   AliAODTrack::kSecondary)
		);
 	aodTrack->ConvertAliPIDtoAODPID();
     }
      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);
      
      v0->GetXYZ(pos[0], pos[1], pos[2]);
      v0->GetPosCov(covVtx);

      AliAODVertex * vV0 = 
	new(vertices[jVertices++]) AliAODVertex(pos,
						covVtx,
						v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
						primary,
						nV0,
						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);
	esdTrack->GetPxPyPz(p);
	esdTrack->GetXYZ(pos);
	esdTrack->GetCovarianceXYZPxPyPz(covTr);
	esdTrack->GetESDpid(pid);
	
	vV0->AddDaughter(aodTrack =
        	new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(), 
					   p, 
					   kTRUE,
					   pos,
					   kFALSE,
					   covTr, 
					   (Short_t)esdTrack->Charge(),
					   esdTrack->GetITSClusterMap(), 
					   pid,
					   vV0,
					   kTRUE,  // check if this is right
					   kFALSE, // check if this is right
					   AliAODTrack::kSecondary)
		);
	aodTrack->ConvertAliPIDtoAODPID();
      }
      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);
	esdTrack->GetPxPyPz(p);
	esdTrack->GetXYZ(pos);
	esdTrack->GetCovarianceXYZPxPyPz(covTr);
	esdTrack->GetESDpid(pid);

	vV0->AddDaughter(aodTrack =
                new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(),
					   p,
					   kTRUE,
					   pos,
					   kFALSE,
					   covTr, 
					   (Short_t)esdTrack->Charge(),
					   esdTrack->GetITSClusterMap(), 
					   pid,
					   vV0,
					   kTRUE,  // check if this is right
					   kFALSE, // check if this is right
					   AliAODTrack::kSecondary)
		);
	aodTrack->ConvertAliPIDtoAODPID();
      }
      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 * esdTrack = esd->GetTrack(iTrack);

      Int_t ikink = esdTrack->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 * esdTrack1 = esd->GetTrack(jTrack);

	  Int_t jkink = esdTrack1->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);
	      esdTrack->GetPxPyPz(p);
	      esdTrack->GetXYZ(pos);
	      esdTrack->GetCovarianceXYZPxPyPz(covTr);
	      esdTrack->GetESDpid(pid);

	      mother = 
		new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(),
					   p,
					   kTRUE,
					   pos,
					   kFALSE,
					   covTr, 
					   (Short_t)esdTrack->Charge(),
					   esdTrack->GetITSClusterMap(), 
					   pid,
					   primary,
					   kTRUE, // check if this is right
					   kTRUE, // check if this is right
					   AliAODTrack::kPrimary);
	      primary->AddDaughter(mother);
	      mother->ConvertAliPIDtoAODPID();
	    }
	    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,
						    esdTrack->GetID(), // This is the track ID of the mother's track!
						    AliAODVertex::kKink);
	    // Add the daughter track

	    AliAODTrack * daughter = NULL;

	    if (!usedTrack[idaughter]) {
	
	      usedTrack[idaughter] = kTRUE;
	
	      AliESDtrack *esdTrack = esd->GetTrack(idaughter);
	      esdTrack->GetPxPyPz(p);
	      esdTrack->GetXYZ(pos);
	      esdTrack->GetCovarianceXYZPxPyPz(covTr);
	      esdTrack->GetESDpid(pid);

	      daughter = 
		new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
					   esdTrack->GetLabel(),
					   p,
					   kTRUE,
					   pos,
					   kFALSE,
					   covTr, 
					   (Short_t)esdTrack->Charge(),
					   esdTrack->GetITSClusterMap(), 
					   pid,
					   vkink,
					   kTRUE, // check if this is right
					   kTRUE, // check if this is right
					   AliAODTrack::kPrimary);
	      vkink->AddDaughter(daughter);
	      daughter->ConvertAliPIDtoAODPID();
	    }
	    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);
      esdTrack->GetPxPyPz(p);
      esdTrack->GetXYZ(pos);
      esdTrack->GetCovarianceXYZPxPyPz(covTr);
      esdTrack->GetESDpid(pid);

      Float_t impactXY, impactZ;

      esdTrack->GetImpactParameters(impactXY,impactZ);

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

    // muon tracks
    Int_t nMuTracks = esd->GetNumberOfMuonTracks();
    for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
      
      AliESDMuonTrack *esdMuTrack = esd->GetMuonTrack(nMuTrack);     
      p[0] = esdMuTrack->Px(); 
      p[1] = esdMuTrack->Py(); 
      p[2] = esdMuTrack->Pz();
      pos[0] = primary->GetX(); 
      pos[1] = primary->GetY(); 
      pos[2] = primary->GetZ();
      
      // has to be changed once the muon pid is provided by the ESD
      for (Int_t i = 0; i < 10; pid[i++] = 0.); pid[AliAODTrack::kMuon]=1.;
      
      primary->AddDaughter(aodTrack =
	  new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
					     0, // no label provided
					     p,
					     kTRUE,
					     pos,
					     kFALSE,
					     NULL, // no covariance matrix provided
					     esdMuTrack->Charge(),
					     0, // ITSClusterMap is set below
					     pid,
					     primary,
 					     kFALSE,  // muon tracks are not used to fit the primary vtx
					     kFALSE,  // not used for vertex fit
					     AliAODTrack::kPrimary)
	  );

      aodTrack->SetHitsPatternInTrigCh(esdMuTrack->GetHitsPatternInTrigCh());
      Int_t track2Trigger = esdMuTrack->GetMatchTrigger();
      aodTrack->SetMatchTrigger(track2Trigger);
      if (track2Trigger) 
	aodTrack->SetChi2MatchTrigger(esdMuTrack->GetChi2MatchTrigger());
      else 
	aodTrack->SetChi2MatchTrigger(0.);
    }
    
    // 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->E();
      cluster->GetPosition(posF);
      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,
					       pos,
					       NULL, // no covariance matrix provided
					       NULL, // no pid for clusters provided
					       prodVertex,
					       primTrack,
					       ttype);

    } // end of loop on calo clusters

    // tracklets
    const AliMultiplicity *mult = esd->GetMultiplicity();
    if (mult) {
      if (mult->GetNumberOfTracklets()>0) {
	aod->GetTracklets()->CreateContainer(mult->GetNumberOfTracklets());

	for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
	  aod->GetTracklets()->SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n));
	}
      }
    } else {
      Printf("ERROR: AliMultiplicity could not be retrieved from ESD");
    }

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