[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():
  fEventNumber(0),
  fRunNumber(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),
  fPHOSClusters(0), 
  fFirstPHOSCluster(-1),
  fESDFMD(0x0)
{
  for (Int_t i=0; i<24; i++) {
    fT0time[i] = 0;
    fT0amplitude[i] = 0;
  }
}
//______________________________________________________________________________
AliESD::AliESD(const AliESD& esd):
  TObject(esd),
  fEventNumber(esd.fEventNumber),
  fRunNumber(esd.fRunNumber),
  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),
  fPHOSClusters(esd.fPHOSClusters), 
  fFirstPHOSCluster(esd.fFirstPHOSCluster),
  fESDFMD(esd.fESDFMD)
{
  for (Int_t i=0; i<24; i++) {
    fT0time[i] = esd.fT0time[i];
    fT0amplitude[i] = esd.fT0amplitude[i];
  }
}

//______________________________________________________________________________
AliESD & AliESD::operator=(const AliESD& source) {

  // Assignment operator

  if(&source == this) return *this;

  fEventNumber = source.fEventNumber;
  fRunNumber = source.fRunNumber;
  fTriggerMask = source.fTriggerMask;
  fTriggerCluster = source.fTriggerCluster;
  fRecoVersion = source.fRecoVersion;
  fMagneticField = source.fMagneticField;
  fZDCN1Energy = source.fZDCN1Energy;
  fZDCP1Energy = source.fZDCP1Energy;
  fZDCN2Energy = source.fZDCN2Energy;
  fZDCP2Energy = source.fZDCP2Energy;
  fZDCEMEnergy = source.fZDCEMEnergy;
  fZDCParticipants = source.fZDCParticipants;
  fT0zVertex = source.fT0zVertex;
  fSPDVertex = source.fSPDVertex;
  fPrimaryVertex = source.fPrimaryVertex;
  fSPDMult = source.fSPDMult;
  fT0timeStart = source.fT0timeStart;
  fTracks = *((TClonesArray*)source.fTracks.Clone());
  fHLTConfMapTracks = *((TClonesArray*)source.fHLTConfMapTracks.Clone());
  fHLTHoughTracks = *((TClonesArray*)source.fHLTHoughTracks.Clone());
  fMuonTracks = *((TClonesArray*)source.fMuonTracks.Clone());
  fPmdTracks = *((TClonesArray*)source.fPmdTracks.Clone());
  fTrdTracks = *((TClonesArray*)source.fTrdTracks.Clone());
  fV0s = *((TClonesArray*)source.fV0s.Clone());
  fCascades = *((TClonesArray*)source.fCascades.Clone());
  fKinks = *((TClonesArray*)source.fKinks.Clone());
  fCaloClusters = *((TClonesArray*)source.fCaloClusters.Clone());
  fEMCALClusters = source.fEMCALClusters;
  fFirstEMCALCluster = source.fFirstEMCALCluster;
  fPHOSClusters = source.fPHOSClusters;
  fFirstPHOSCluster = source.fFirstPHOSCluster;
  fESDFMD = source.fESDFMD;

  for (Int_t i=0; i<24; i++) {
    fT0time[i] = source.fT0time[i];
    fT0amplitude[i] = source.fT0amplitude[i];
  }

  return *this;

}


//______________________________________________________________________________
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;
}

//______________________________________________________________________________
void AliESD::Reset()
{
  fEventNumber=0;
  fRunNumber=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();
}

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

//______________________________________________________________________________
void AliESD::Print(Option_t *) const 
{
  //
  // Print header information of the event
  //
  printf("ESD run information\n");
  printf("Event # %d Run # %d Trigger %lld Magnetic field %f \n",
	 GetEventNumber(),
	 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("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"));
}

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
8a8d023f	25	#include "AliESD.h"
d75007f6	26	#include "AliESDfriend.h"
8a8d023f	27
	28	ClassImp(AliESD)
	29
af7ba10c	30	//______________________________________________________________________________
e2afb3b6	31	AliESD::AliESD():
	32	fEventNumber(0),
	33	fRunNumber(0),
b647652d	34	fTriggerMask(0),
b647652d	35	fTriggerCluster(0),
e2afb3b6	36	fRecoVersion(0),
a866ac60	37	fMagneticField(0),
32a5cab4	38	fZDCN1Energy(0),
32a5cab4	39	fZDCP1Energy(0),
32a5cab4	40	fZDCN2Energy(0),
32a5cab4	41	fZDCP2Energy(0),
0ee00e25	42	fZDCEMEnergy(0),
878bc0c2	43	fZDCParticipants(0),
4a78b8c5	44	fT0zVertex(0),
15b965a7	45	fSPDVertex(),
15b965a7	46	fPrimaryVertex(),
32e449be	47	fSPDMult(),
6d45eaef	48	fT0timeStart(0),
e23730c7	49	fTracks("AliESDtrack",15000),
482070f2	50	fHLTConfMapTracks("AliESDHLTtrack",25000),
482070f2	51	fHLTHoughTracks("AliESDHLTtrack",15000),
672b5f43	52	fMuonTracks("AliESDMuonTrack",30),
561b7b31	53	fPmdTracks("AliESDPmdTrack",3000),
0ee00e25	54	fTrdTracks("AliESDTrdTrack",300),
51ad6848	55	fV0s("AliESDv0",200),
a2882fb4	56	fCascades("AliESDcascade",20),
51ad6848	57	fKinks("AliESDkink",4000),
85c60a8e	58	fCaloClusters("AliESDCaloCluster",10000),
	59	fEMCALClusters(0),
	60	fFirstEMCALCluster(-1),
	61	fPHOSClusters(0),
	62	fFirstPHOSCluster(-1),
9da38871	63	fESDFMD(0x0)
9da38871	64	{
6d45eaef	65	for (Int_t i=0; i<24; i++) {
	66	fT0time[i] = 0;
	67	fT0amplitude[i] = 0;
	68	}
873f1f73	69	}
c028b974	70	//______________________________________________________________________________
	71	AliESD::AliESD(const AliESD& esd):
	72	TObject(esd),
	73	fEventNumber(esd.fEventNumber),
	74	fRunNumber(esd.fRunNumber),
	75	fTriggerMask(esd.fTriggerMask),
	76	fTriggerCluster(esd.fTriggerCluster),
	77	fRecoVersion(esd.fRecoVersion),
	78	fMagneticField(esd.fMagneticField),
	79	fZDCN1Energy(esd.fZDCN1Energy),
	80	fZDCP1Energy(esd.fZDCP1Energy),
	81	fZDCN2Energy(esd.fZDCN2Energy),
	82	fZDCP2Energy(esd.fZDCP2Energy),
	83	fZDCEMEnergy(esd.fZDCEMEnergy),
	84	fZDCParticipants(esd.fZDCParticipants),
	85	fT0zVertex(esd.fT0zVertex),
	86	fSPDVertex(esd.fSPDVertex),
	87	fPrimaryVertex(esd.fPrimaryVertex),
fe12e09c	88	fSPDMult(esd.fSPDMult),
c028b974	89	fT0timeStart(esd.fT0timeStart),
	90	fTracks(((TClonesArray)esd.fTracks.Clone())),
	91	fHLTConfMapTracks(((TClonesArray)esd.fHLTConfMapTracks.Clone())),
	92	fHLTHoughTracks(((TClonesArray)esd.fHLTHoughTracks.Clone())),
	93	fMuonTracks(((TClonesArray)esd.fMuonTracks.Clone())),
	94	fPmdTracks(((TClonesArray)esd.fPmdTracks.Clone())),
	95	fTrdTracks(((TClonesArray)esd.fTrdTracks.Clone())),
	96	fV0s(((TClonesArray)esd.fV0s.Clone())),
	97	fCascades(((TClonesArray)esd.fCascades.Clone())),
	98	fKinks(((TClonesArray)esd.fKinks.Clone())),
c028b974	99	fCaloClusters(((TClonesArray)esd.fCaloClusters.Clone())),
	100	fEMCALClusters(esd.fEMCALClusters),
	101	fFirstEMCALCluster(esd.fFirstEMCALCluster),
	102	fPHOSClusters(esd.fPHOSClusters),
	103	fFirstPHOSCluster(esd.fFirstPHOSCluster),
	104	fESDFMD(esd.fESDFMD)
	105	{
	106	for (Int_t i=0; i<24; i++) {
	107	fT0time[i] = esd.fT0time[i];
	108	fT0amplitude[i] = esd.fT0amplitude[i];
	109	}
	110	}
	111
fe12e09c	112	//______________________________________________________________________________
	113	AliESD & AliESD::operator=(const AliESD& source) {
	114
	115	// Assignment operator
	116
	117	if(&source == this) return *this;
	118
	119	fEventNumber = source.fEventNumber;
	120	fRunNumber = source.fRunNumber;
	121	fTriggerMask = source.fTriggerMask;
	122	fTriggerCluster = source.fTriggerCluster;
	123	fRecoVersion = source.fRecoVersion;
	124	fMagneticField = source.fMagneticField;
	125	fZDCN1Energy = source.fZDCN1Energy;
	126	fZDCP1Energy = source.fZDCP1Energy;
	127	fZDCN2Energy = source.fZDCN2Energy;
	128	fZDCP2Energy = source.fZDCP2Energy;
	129	fZDCEMEnergy = source.fZDCEMEnergy;
	130	fZDCParticipants = source.fZDCParticipants;
	131	fT0zVertex = source.fT0zVertex;
	132	fSPDVertex = source.fSPDVertex;
	133	fPrimaryVertex = source.fPrimaryVertex;
	134	fSPDMult = source.fSPDMult;
	135	fT0timeStart = source.fT0timeStart;
	136	fTracks = ((TClonesArray)source.fTracks.Clone());
	137	fHLTConfMapTracks = ((TClonesArray)source.fHLTConfMapTracks.Clone());
	138	fHLTHoughTracks = ((TClonesArray)source.fHLTHoughTracks.Clone());
	139	fMuonTracks = ((TClonesArray)source.fMuonTracks.Clone());
	140	fPmdTracks = ((TClonesArray)source.fPmdTracks.Clone());
	141	fTrdTracks = ((TClonesArray)source.fTrdTracks.Clone());
	142	fV0s = ((TClonesArray)source.fV0s.Clone());
	143	fCascades = ((TClonesArray)source.fCascades.Clone());
	144	fKinks = ((TClonesArray)source.fKinks.Clone());
fe12e09c	145	fCaloClusters = ((TClonesArray)source.fCaloClusters.Clone());
	146	fEMCALClusters = source.fEMCALClusters;
	147	fFirstEMCALCluster = source.fFirstEMCALCluster;
	148	fPHOSClusters = source.fPHOSClusters;
	149	fFirstPHOSCluster = source.fFirstPHOSCluster;
	150	fESDFMD = source.fESDFMD;
	151
	152	for (Int_t i=0; i<24; i++) {
	153	fT0time[i] = source.fT0time[i];
	154	fT0amplitude[i] = source.fT0amplitude[i];
	155	}
	156
	157	return *this;
	158
	159	}
	160
e2afb3b6	161
af7ba10c	162	//______________________________________________________________________________
	163	AliESD::~AliESD()
	164	{
	165	//
	166	// Standard destructor
	167	//
	168	fTracks.Delete();
8bbc564d	169	fHLTConfMapTracks.Delete();
8bbc564d	170	fHLTHoughTracks.Delete();
af7ba10c	171	fMuonTracks.Delete();
af7ba10c	172	fPmdTracks.Delete();
0ee00e25	173	fTrdTracks.Delete();
af7ba10c	174	fV0s.Delete();
af7ba10c	175	fCascades.Delete();
51ad6848	176	fKinks.Delete();
85c60a8e	177	fCaloClusters.Delete();
9da38871	178	delete fESDFMD;
51ad6848	179	}
51ad6848	180
bf25155c	181	//______________________________________________________________________________
	182	void AliESD::Reset()
	183	{
	184	fEventNumber=0;
	185	fRunNumber=0;
b647652d	186	fTriggerMask=0;
b647652d	187	fTriggerCluster=0;
bf25155c	188	fRecoVersion=0;
bf25155c	189	fMagneticField=0;
32a5cab4	190	fZDCN1Energy=0;
32a5cab4	191	fZDCP1Energy=0;
32a5cab4	192	fZDCN2Energy=0;
32a5cab4	193	fZDCP2Energy=0;
0ee00e25	194	fZDCEMEnergy=0;
bf25155c	195	fZDCParticipants=0;
bf25155c	196	fT0zVertex=0;
6d45eaef	197	fT0timeStart = 0;
15b965a7	198	new (&fSPDVertex) AliESDVertex();
15b965a7	199	new (&fPrimaryVertex) AliESDVertex();
32e449be	200	new (&fSPDMult) AliMultiplicity();
bf25155c	201	fTracks.Clear();
	202	fHLTConfMapTracks.Clear();
	203	fHLTHoughTracks.Clear();
	204	fMuonTracks.Clear();
	205	fPmdTracks.Clear();
0ee00e25	206	fTrdTracks.Clear();
bf25155c	207	fV0s.Clear();
bf25155c	208	fCascades.Clear();
85c60a8e	209	fCaloClusters.Clear();
	210	fEMCALClusters=0;
	211	fFirstEMCALCluster=-1;
	212	fPHOSClusters=0;
	213	fFirstPHOSCluster=-1;
9da38871	214	if (fESDFMD) fESDFMD->Clear();
bf25155c	215	}
af7ba10c	216
d6a49f20	217	Int_t AliESD::AddV0(const AliESDv0 *v) {
	218	//
	219	// Add V0
	220	//
	221	Int_t idx=fV0s.GetEntriesFast();
	222	AliESDv0 v0=new(fV0s[idx]) AliESDv0(v);
	223	v0->SetID(idx);
	224	return idx;
	225	}
	226
af7ba10c	227	//______________________________________________________________________________
	228	void AliESD::Print(Option_t *) const
	229	{
	230	//
	231	// Print header information of the event
	232	//
5f7789fc	233	printf("ESD run information\n");
b647652d	234	printf("Event # %d Run # %d Trigger %lld Magnetic field %f \n",
ef278eae	235	GetEventNumber(),
ef278eae	236	GetRunNumber(),
b647652d	237	GetTriggerMask(),
ef278eae	238	GetMagneticField() );
8497bca0	239	printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
15b965a7	240	fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
	241	fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
	242	fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
32e449be	243	printf("SPD Multiplicity. Number of tracklets %d \n",
32e449be	244	fSPDMult.GetNumberOfTracklets());
ef278eae	245	printf("Event from reconstruction version %d \n",fRecoVersion);
ef278eae	246	printf("Number of tracks: \n");
85c60a8e	247	printf(" charged %d\n", GetNumberOfTracks());
482070f2	248	printf(" hlt CF %d\n", GetNumberOfHLTConfMapTracks());
482070f2	249	printf(" hlt HT %d\n", GetNumberOfHLTHoughTracks());
ef278eae	250	printf(" muon %d\n", GetNumberOfMuonTracks());
a2882fb4	251	printf(" pmd %d\n", GetNumberOfPmdTracks());
0ee00e25	252	printf(" trd %d\n", GetNumberOfTrdTracks());
ef278eae	253	printf(" v0 %d\n", GetNumberOfV0s());
667ee8bf	254	printf(" cascades %d\n", GetNumberOfCascades());
667ee8bf	255	printf(" kinks %d\n", GetNumberOfKinks());
667ee8bf	256	printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
	257	printf(" phos %d\n", GetNumberOfPHOSClusters());
	258	printf(" emcal %d\n", GetNumberOfEMCALClusters());
	259	printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
ef278eae	260	}
d75007f6	261
	262	void AliESD::SetESDfriend(const AliESDfriend *ev) {
	263	//
	264	// Attaches the complementary info to the ESD
	265	//
	266	if (!ev) return;
	267
	268	Int_t ntrk=ev->GetNumberOfTracks();
	269
	270	for (Int_t i=0; i<ntrk; i++) {
	271	const AliESDfriendTrack *f=ev->GetTrack(i);
	272	GetTrack(i)->SetFriendTrack(f);
	273	}
	274	}
	275
	276	void AliESD::GetESDfriend(AliESDfriend *ev) const {
	277	//
	278	// Extracts the complementary info from the ESD
	279	//
	280	if (!ev) return;
	281
	282	Int_t ntrk=GetNumberOfTracks();
	283
	284	for (Int_t i=0; i<ntrk; i++) {
	285	const AliESDtrack *t=GetTrack(i);
	286	const AliESDfriendTrack *f=t->GetFriendTrack();
	287	ev->AddTrack(f);
	288	}
	289	}