[u/mrichter/AliRoot.git] / STEER / AliESD.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//-----------------------------------------------------------------
//           Implementation of the ESD class
//   This is the class to deal with during the phisical analysis of data
//   This class is generated directly by the reconstruction methods
//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-----------------------------------------------------------------

#include "AliESD.h"
#include "AliESDfriend.h"

ClassImp(AliESD)

//______________________________________________________________________________
AliESD::AliESD():
  fEventNumberInFile(0),
  fBunchCrossNumber(0),
  fOrbitNumber(0),
  fPeriodNumber(0),
  fRunNumber(0),
  fTimeStamp(0),
  fEventType(0),
  fTriggerMask(0),
  fTriggerCluster(0),
  fRecoVersion(0),
  fMagneticField(0),
  fZDCN1Energy(0),
  fZDCP1Energy(0),
  fZDCN2Energy(0),
  fZDCP2Energy(0),
  fZDCEMEnergy(0),
  fZDCParticipants(0),
  fT0zVertex(0),
  fSPDVertex(),
  fPrimaryVertex(),
  fSPDMult(),
  fT0timeStart(0),
  fTracks("AliESDtrack",15000),
  fHLTConfMapTracks("AliESDHLTtrack",25000),
  fHLTHoughTracks("AliESDHLTtrack",15000),
  fMuonTracks("AliESDMuonTrack",30),
  fPmdTracks("AliESDPmdTrack",3000),
  fTrdTracks("AliESDTrdTrack",300),
  fV0s("AliESDv0",200),  
  fCascades("AliESDcascade",20),
  fKinks("AliESDkink",4000),
  fCaloClusters("AliESDCaloCluster",10000),
  fEMCALClusters(0), 
  fFirstEMCALCluster(-1),
  fEMCALTriggerPosition(0x0),
  fEMCALTriggerAmplitudes(0x0),
  fPHOSClusters(0), 
  fFirstPHOSCluster(-1),
  fPHOSTriggerPosition(0x0),
  fPHOSTriggerAmplitudes(0x0),
  fESDFMD(0x0),
  fESDVZERO(0x0),
  fErrorLogs("AliRawDataErrorLog",5)

{
  for (Int_t i=0; i<24; i++) {
    fT0time[i] = 0;
    fT0amplitude[i] = 0;
  }
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
}

//______________________________________________________________________________
AliESD::AliESD(const AliESD& esd):
  TObject(esd),
  fEventNumberInFile(esd.fEventNumberInFile),
  fBunchCrossNumber(esd.fBunchCrossNumber),
  fOrbitNumber(esd.fOrbitNumber),
  fPeriodNumber(esd.fPeriodNumber),
  fRunNumber(esd.fRunNumber),
  fTimeStamp(esd.fTimeStamp),
  fEventType(esd.fEventType),
  fTriggerMask(esd.fTriggerMask),
  fTriggerCluster(esd.fTriggerCluster),
  fRecoVersion(esd.fRecoVersion),
  fMagneticField(esd.fMagneticField),
  fZDCN1Energy(esd.fZDCN1Energy),
  fZDCP1Energy(esd.fZDCP1Energy),
  fZDCN2Energy(esd.fZDCN2Energy),
  fZDCP2Energy(esd.fZDCP2Energy),
  fZDCEMEnergy(esd.fZDCEMEnergy),
  fZDCParticipants(esd.fZDCParticipants),
  fT0zVertex(esd.fT0zVertex),
  fSPDVertex(esd.fSPDVertex),
  fPrimaryVertex(esd.fPrimaryVertex),
  fSPDMult(esd.fSPDMult),
  fT0timeStart(esd.fT0timeStart),
  fTracks(*((TClonesArray*)esd.fTracks.Clone())),
  fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
  fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
  fMuonTracks(*((TClonesArray*)esd.fMuonTracks.Clone())),
  fPmdTracks(*((TClonesArray*)esd.fPmdTracks.Clone())),
  fTrdTracks(*((TClonesArray*)esd.fTrdTracks.Clone())),
  fV0s(*((TClonesArray*)esd.fV0s.Clone())),  
  fCascades(*((TClonesArray*)esd.fCascades.Clone())),
  fKinks(*((TClonesArray*)esd.fKinks.Clone())),
  fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())),
  fEMCALClusters(esd.fEMCALClusters), 
  fFirstEMCALCluster(esd.fFirstEMCALCluster),
  fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
  fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
  fPHOSClusters(esd.fPHOSClusters), 
  fFirstPHOSCluster(esd.fFirstPHOSCluster),
  fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
  fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
  fESDFMD(esd.fESDFMD),
  fESDVZERO(esd.fESDVZERO),
  fErrorLogs(*((TClonesArray*)esd.fErrorLogs.Clone()))
{
  for (Int_t i=0; i<24; i++) {
    fT0time[i] = esd.fT0time[i];
    fT0amplitude[i] = esd.fT0amplitude[i];
  }
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
}

//______________________________________________________________________________
AliESD::~AliESD()
{
  //
  // Standard destructor
  //
  fTracks.Delete();
  fHLTConfMapTracks.Delete();
  fHLTHoughTracks.Delete();
  fMuonTracks.Delete();
  fPmdTracks.Delete();
  fTrdTracks.Delete();
  fV0s.Delete();
  fCascades.Delete();
  fKinks.Delete();
  fCaloClusters.Delete();
  delete fESDFMD;
  delete fESDVZERO;
//   fEMCALTriggerPosition->Delete();
//   fEMCALTriggerAmplitudes->Delete();
//   fPHOSTriggerPosition->Delete();
//   fPHOSTriggerAmplitudes->Delete();
//   delete fEMCALTriggerPosition;
//   delete fEMCALTriggerAmplitudes;
//   delete fPHOSTriggerPosition;
//   delete fPHOSTriggerAmplitudes;
  fErrorLogs.Delete();

}

//______________________________________________________________________________
void AliESD::Reset()
{
  fEventNumberInFile=0;
  fBunchCrossNumber=0;
  fOrbitNumber=0;
  fPeriodNumber=0;
  fRunNumber=0;
  fTimeStamp = 0;
  fEventType = 0;
  fTriggerMask=0;
  fTriggerCluster=0;
  fRecoVersion=0;
  fMagneticField=0;
  fZDCN1Energy=0;
  fZDCP1Energy=0;
  fZDCN2Energy=0;
  fZDCP2Energy=0;
  fZDCEMEnergy=0;
  fZDCParticipants=0;
  fT0zVertex=0;
  fT0timeStart = 0;
  new (&fSPDVertex) AliESDVertex();
  new (&fPrimaryVertex) AliESDVertex();
  new (&fSPDMult) AliMultiplicity();
  fTracks.Clear();
  fHLTConfMapTracks.Clear();
  fHLTHoughTracks.Clear();
  fMuonTracks.Clear();
  fPmdTracks.Clear();
  fTrdTracks.Clear();
  fV0s.Clear();
  fCascades.Clear();
  fCaloClusters.Clear();
  fEMCALClusters=0; 
  fFirstEMCALCluster=-1; 
  fPHOSClusters=0; 
  fFirstPHOSCluster=-1; 
  if (fESDFMD) fESDFMD->Clear();
//   fEMCALTriggerPosition->Clear();
//   fEMCALTriggerAmplitudes->Clear();
//   fPHOSTriggerPosition->Clear();
//   fPHOSTriggerAmplitudes->Clear();
  fErrorLogs.Clear();
}

Int_t AliESD::AddV0(const AliESDv0 *v) {
  //
  // Add V0
  //
    Int_t idx=fV0s.GetEntriesFast();
    new(fV0s[idx]) AliESDv0(*v);
    return idx;
}  

//______________________________________________________________________________
void AliESD::Print(Option_t *) const 
{
  //
  // Print header information of the event
  //
  printf("ESD run information\n");
  printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
	 GetEventNumberInFile(),
	 GetBunchCrossNumber(),
	 GetOrbitNumber(),
	 GetPeriodNumber(),
	 GetRunNumber(),
	 GetTriggerMask(),
	 GetMagneticField() );
    printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
	   fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
	   fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
	   fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
    printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
	   GetDiamondX(),GetDiamondY());
    printf("SPD Multiplicity. Number of tracklets %d \n",
           fSPDMult.GetNumberOfTracklets());
  printf("Event from reconstruction version %d \n",fRecoVersion);
  printf("Number of tracks: \n");
  printf("                 charged   %d\n", GetNumberOfTracks());
  printf("                 hlt CF    %d\n", GetNumberOfHLTConfMapTracks());
  printf("                 hlt HT    %d\n", GetNumberOfHLTHoughTracks());
  printf("                 muon      %d\n", GetNumberOfMuonTracks());
  printf("                 pmd       %d\n", GetNumberOfPmdTracks());
  printf("                 trd       %d\n", GetNumberOfTrdTracks());
  printf("                 v0        %d\n", GetNumberOfV0s());
  printf("                 cascades  %d\n", GetNumberOfCascades());
  printf("                 kinks     %d\n", GetNumberOfKinks());
  printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
  printf("                 phos      %d\n", GetNumberOfPHOSClusters());
  printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
  printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
  printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
}

void AliESD::SetESDfriend(const AliESDfriend *ev) {
  //
  // Attaches the complementary info to the ESD
  //
  if (!ev) return;

  Int_t ntrk=ev->GetNumberOfTracks();

  for (Int_t i=0; i<ntrk; i++) {
    const AliESDfriendTrack *f=ev->GetTrack(i);
    GetTrack(i)->SetFriendTrack(f);
  }
}

void AliESD::GetESDfriend(AliESDfriend *ev) const {
  //
  // Extracts the complementary info from the ESD
  //
  if (!ev) return;

  Int_t ntrk=GetNumberOfTracks();

  for (Int_t i=0; i<ntrk; i++) {
    const AliESDtrack *t=GetTrack(i);
    const AliESDfriendTrack *f=t->GetFriendTrack();
    ev->AddTrack(f);
  }
}
Commit	Line	Data
8a8d023f	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
acd84897	16	/* $Id$ */
8a8d023f	17
ae982df3	18	//-----------------------------------------------------------------
	19	// Implementation of the ESD class
	20	// This is the class to deal with during the phisical analysis of data
af7ba10c	21	// This class is generated directly by the reconstruction methods
ae982df3	22	// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
ae982df3	23	//-----------------------------------------------------------------
8a8d023f	24
b545009a	25	#include "AliESD.h"
b545009a	26	#include "AliESDfriend.h"
53203d32	27
	28	ClassImp(AliESD)
	29
	30	//______________________________________________________________________________
	31	AliESD::AliESD():
af885e0f	32	fEventNumberInFile(0),
	33	fBunchCrossNumber(0),
	34	fOrbitNumber(0),
	35	fPeriodNumber(0),
	36	fRunNumber(0),
	37	fTimeStamp(0),
	38	fEventType(0),
	39	fTriggerMask(0),
	40	fTriggerCluster(0),
	41	fRecoVersion(0),
	42	fMagneticField(0),
	43	fZDCN1Energy(0),
	44	fZDCP1Energy(0),
	45	fZDCN2Energy(0),
	46	fZDCP2Energy(0),
	47	fZDCEMEnergy(0),
	48	fZDCParticipants(0),
	49	fT0zVertex(0),
	50	fSPDVertex(),
	51	fPrimaryVertex(),
	52	fSPDMult(),
	53	fT0timeStart(0),
	54	fTracks("AliESDtrack",15000),
	55	fHLTConfMapTracks("AliESDHLTtrack",25000),
	56	fHLTHoughTracks("AliESDHLTtrack",15000),
	57	fMuonTracks("AliESDMuonTrack",30),
	58	fPmdTracks("AliESDPmdTrack",3000),
	59	fTrdTracks("AliESDTrdTrack",300),
	60	fV0s("AliESDv0",200),
	61	fCascades("AliESDcascade",20),
	62	fKinks("AliESDkink",4000),
	63	fCaloClusters("AliESDCaloCluster",10000),
85c60a8e	64	fEMCALClusters(0),
85c60a8e	65	fFirstEMCALCluster(-1),
af885e0f	66	fEMCALTriggerPosition(0x0),
af885e0f	67	fEMCALTriggerAmplitudes(0x0),
85c60a8e	68	fPHOSClusters(0),
af885e0f	69	fFirstPHOSCluster(-1),
	70	fPHOSTriggerPosition(0x0),
	71	fPHOSTriggerAmplitudes(0x0),
	72	fESDFMD(0x0),
	73	fESDVZERO(0x0),
	74	fErrorLogs("AliRawDataErrorLog",5)
	75
9da38871	76	{
af885e0f	77	for (Int_t i=0; i<24; i++) {
	78	fT0time[i] = 0;
	79	fT0amplitude[i] = 0;
	80	}
	81	for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
	82	for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
873f1f73	83	}
e149da78	84
c028b974	85	//______________________________________________________________________________
	86	AliESD::AliESD(const AliESD& esd):
	87	TObject(esd),
af885e0f	88	fEventNumberInFile(esd.fEventNumberInFile),
	89	fBunchCrossNumber(esd.fBunchCrossNumber),
	90	fOrbitNumber(esd.fOrbitNumber),
	91	fPeriodNumber(esd.fPeriodNumber),
	92	fRunNumber(esd.fRunNumber),
	93	fTimeStamp(esd.fTimeStamp),
	94	fEventType(esd.fEventType),
	95	fTriggerMask(esd.fTriggerMask),
	96	fTriggerCluster(esd.fTriggerCluster),
	97	fRecoVersion(esd.fRecoVersion),
	98	fMagneticField(esd.fMagneticField),
	99	fZDCN1Energy(esd.fZDCN1Energy),
	100	fZDCP1Energy(esd.fZDCP1Energy),
	101	fZDCN2Energy(esd.fZDCN2Energy),
	102	fZDCP2Energy(esd.fZDCP2Energy),
	103	fZDCEMEnergy(esd.fZDCEMEnergy),
	104	fZDCParticipants(esd.fZDCParticipants),
	105	fT0zVertex(esd.fT0zVertex),
	106	fSPDVertex(esd.fSPDVertex),
	107	fPrimaryVertex(esd.fPrimaryVertex),
	108	fSPDMult(esd.fSPDMult),
	109	fT0timeStart(esd.fT0timeStart),
	110	fTracks(((TClonesArray)esd.fTracks.Clone())),
	111	fHLTConfMapTracks(((TClonesArray)esd.fHLTConfMapTracks.Clone())),
	112	fHLTHoughTracks(((TClonesArray)esd.fHLTHoughTracks.Clone())),
	113	fMuonTracks(((TClonesArray)esd.fMuonTracks.Clone())),
	114	fPmdTracks(((TClonesArray)esd.fPmdTracks.Clone())),
	115	fTrdTracks(((TClonesArray)esd.fTrdTracks.Clone())),
	116	fV0s(((TClonesArray)esd.fV0s.Clone())),
	117	fCascades(((TClonesArray)esd.fCascades.Clone())),
	118	fKinks(((TClonesArray)esd.fKinks.Clone())),
	119	fCaloClusters(((TClonesArray)esd.fCaloClusters.Clone())),
c028b974	120	fEMCALClusters(esd.fEMCALClusters),
c028b974	121	fFirstEMCALCluster(esd.fFirstEMCALCluster),
af885e0f	122	fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
af885e0f	123	fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
c028b974	124	fPHOSClusters(esd.fPHOSClusters),
af885e0f	125	fFirstPHOSCluster(esd.fFirstPHOSCluster),
	126	fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
	127	fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
	128	fESDFMD(esd.fESDFMD),
	129	fESDVZERO(esd.fESDVZERO),
	130	fErrorLogs(((TClonesArray)esd.fErrorLogs.Clone()))
c028b974	131	{
af885e0f	132	for (Int_t i=0; i<24; i++) {
	133	fT0time[i] = esd.fT0time[i];
	134	fT0amplitude[i] = esd.fT0amplitude[i];
	135	}
	136	for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
	137	for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
c028b974	138	}
c028b974	139
af7ba10c	140	//______________________________________________________________________________
	141	AliESD::~AliESD()
	142	{
	143	//
	144	// Standard destructor
	145	//
af885e0f	146	fTracks.Delete();
8bbc564d	147	fHLTConfMapTracks.Delete();
8bbc564d	148	fHLTHoughTracks.Delete();
af885e0f	149	fMuonTracks.Delete();
af7ba10c	150	fPmdTracks.Delete();
0ee00e25	151	fTrdTracks.Delete();
af7ba10c	152	fV0s.Delete();
af7ba10c	153	fCascades.Delete();
51ad6848	154	fKinks.Delete();
85c60a8e	155	fCaloClusters.Delete();
af885e0f	156	delete fESDFMD;
af885e0f	157	delete fESDVZERO;
64df000d	158	// fEMCALTriggerPosition->Delete();
	159	// fEMCALTriggerAmplitudes->Delete();
	160	// fPHOSTriggerPosition->Delete();
	161	// fPHOSTriggerAmplitudes->Delete();
	162	// delete fEMCALTriggerPosition;
	163	// delete fEMCALTriggerAmplitudes;
	164	// delete fPHOSTriggerPosition;
	165	// delete fPHOSTriggerAmplitudes;
af885e0f	166	fErrorLogs.Delete();
64df000d	167
51ad6848	168	}
51ad6848	169
bf25155c	170	//______________________________________________________________________________
	171	void AliESD::Reset()
	172	{
af885e0f	173	fEventNumberInFile=0;
	174	fBunchCrossNumber=0;
	175	fOrbitNumber=0;
	176	fPeriodNumber=0;
	177	fRunNumber=0;
	178	fTimeStamp = 0;
	179	fEventType = 0;
	180	fTriggerMask=0;
	181	fTriggerCluster=0;
	182	fRecoVersion=0;
	183	fMagneticField=0;
	184	fZDCN1Energy=0;
	185	fZDCP1Energy=0;
	186	fZDCN2Energy=0;
	187	fZDCP2Energy=0;
	188	fZDCEMEnergy=0;
	189	fZDCParticipants=0;
	190	fT0zVertex=0;
	191	fT0timeStart = 0;
	192	new (&fSPDVertex) AliESDVertex();
	193	new (&fPrimaryVertex) AliESDVertex();
	194	new (&fSPDMult) AliMultiplicity();
	195	fTracks.Clear();
	196	fHLTConfMapTracks.Clear();
	197	fHLTHoughTracks.Clear();
	198	fMuonTracks.Clear();
	199	fPmdTracks.Clear();
	200	fTrdTracks.Clear();
	201	fV0s.Clear();
	202	fCascades.Clear();
	203	fCaloClusters.Clear();
85c60a8e	204	fEMCALClusters=0;
	205	fFirstEMCALCluster=-1;
	206	fPHOSClusters=0;
	207	fFirstPHOSCluster=-1;
af885e0f	208	if (fESDFMD) fESDFMD->Clear();
	209	// fEMCALTriggerPosition->Clear();
	210	// fEMCALTriggerAmplitudes->Clear();
	211	// fPHOSTriggerPosition->Clear();
	212	// fPHOSTriggerAmplitudes->Clear();
	213	fErrorLogs.Clear();
bf25155c	214	}
af7ba10c	215
d6a49f20	216	Int_t AliESD::AddV0(const AliESDv0 *v) {
	217	//
	218	// Add V0
	219	//
af885e0f	220	Int_t idx=fV0s.GetEntriesFast();
	221	new(fV0s[idx]) AliESDv0(*v);
	222	return idx;
d6a49f20	223	}
d6a49f20	224
af7ba10c	225	//______________________________________________________________________________
	226	void AliESD::Print(Option_t *) const
	227	{
	228	//
	229	// Print header information of the event
	230	//
5f7789fc	231	printf("ESD run information\n");
4d422cad	232	printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
31fd97b2	233	GetEventNumberInFile(),
	234	GetBunchCrossNumber(),
	235	GetOrbitNumber(),
4d422cad	236	GetPeriodNumber(),
ef278eae	237	GetRunNumber(),
b647652d	238	GetTriggerMask(),
ef278eae	239	GetMagneticField() );
af885e0f	240	printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
	241	fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
	242	fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
	243	fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
9f57c1aa	244	printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
9f57c1aa	245	GetDiamondX(),GetDiamondY());
32e449be	246	printf("SPD Multiplicity. Number of tracklets %d \n",
af885e0f	247	fSPDMult.GetNumberOfTracklets());
af885e0f	248	printf("Event from reconstruction version %d \n",fRecoVersion);
ef278eae	249	printf("Number of tracks: \n");
85c60a8e	250	printf(" charged %d\n", GetNumberOfTracks());
af885e0f	251	printf(" hlt CF %d\n", GetNumberOfHLTConfMapTracks());
af885e0f	252	printf(" hlt HT %d\n", GetNumberOfHLTHoughTracks());
ef278eae	253	printf(" muon %d\n", GetNumberOfMuonTracks());
a2882fb4	254	printf(" pmd %d\n", GetNumberOfPmdTracks());
0ee00e25	255	printf(" trd %d\n", GetNumberOfTrdTracks());
ef278eae	256	printf(" v0 %d\n", GetNumberOfV0s());
667ee8bf	257	printf(" cascades %d\n", GetNumberOfCascades());
667ee8bf	258	printf(" kinks %d\n", GetNumberOfKinks());
667ee8bf	259	printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
	260	printf(" phos %d\n", GetNumberOfPHOSClusters());
	261	printf(" emcal %d\n", GetNumberOfEMCALClusters());
	262	printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
dd735cf0	263	printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
ef278eae	264	}
d75007f6	265
	266	void AliESD::SetESDfriend(const AliESDfriend *ev) {
	267	//
	268	// Attaches the complementary info to the ESD
	269	//
	270	if (!ev) return;
	271
	272	Int_t ntrk=ev->GetNumberOfTracks();
af885e0f	273
d75007f6	274	for (Int_t i=0; i<ntrk; i++) {
	275	const AliESDfriendTrack *f=ev->GetTrack(i);
	276	GetTrack(i)->SetFriendTrack(f);
	277	}
	278	}
	279
	280	void AliESD::GetESDfriend(AliESDfriend *ev) const {
	281	//
	282	// Extracts the complementary info from the ESD
	283	//
	284	if (!ev) return;
	285
	286	Int_t ntrk=GetNumberOfTracks();
	287
	288	for (Int_t i=0; i<ntrk; i++) {
	289	const AliESDtrack *t=GetTrack(i);
	290	const AliESDfriendTrack *f=t->GetFriendTrack();
	291	ev->AddTrack(f);
	292	}
	293	}