[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),
  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),
  fPHOSClusters(0), 
  fFirstPHOSCluster(-1),
  fESDFMD(0x0),
  fESDVZERO(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),
  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),
  fPHOSClusters(esd.fPHOSClusters), 
  fFirstPHOSCluster(esd.fFirstPHOSCluster),
  fESDFMD(esd.fESDFMD),
  fESDVZERO(esd.fESDVZERO)
{
  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;
  fTimeStamp   = source.fTimeStamp;
  fEventType   = source.fEventType;
  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;
  fESDVZERO = source.fESDVZERO;

  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;
  delete fESDVZERO;
}

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

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