[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();
}

Bool_t  AliESD::RemoveTrack(Int_t /*i*/) {
  // ---------------------------------------------------------
  // Remove track
  // ---------------------------------------------------------

  // Check if this track comes from a reconstructed decay
  // if (yes) return kFALSE

  // Remap the indices of the daughters of recosntructed decays

  // Remove the track
  // delete fTracks->RemoveAt(i);

  // Compress the array with tracks
  // fTracks->Compress();

  return kTRUE;
}

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++) {
    AliESDtrack *t=GetTrack(i);
    const AliESDfriendTrack *f=t->GetFriendTrack();
    ev->AddTrack(f);

    t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"

  }
}
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
d64bd07d	216	Bool_t AliESD::RemoveTrack(Int_t /i/) {
	217	// ---------------------------------------------------------
	218	// Remove track
	219	// ---------------------------------------------------------
	220
	221	// Check if this track comes from a reconstructed decay
	222	// if (yes) return kFALSE
	223
	224	// Remap the indices of the daughters of recosntructed decays
	225
	226	// Remove the track
	227	// delete fTracks->RemoveAt(i);
	228
	229	// Compress the array with tracks
	230	// fTracks->Compress();
	231
	232	return kTRUE;
	233	}
	234
d6a49f20	235	Int_t AliESD::AddV0(const AliESDv0 *v) {
	236	//
	237	// Add V0
	238	//
af885e0f	239	Int_t idx=fV0s.GetEntriesFast();
	240	new(fV0s[idx]) AliESDv0(*v);
	241	return idx;
d6a49f20	242	}
d6a49f20	243
af7ba10c	244	//______________________________________________________________________________
	245	void AliESD::Print(Option_t *) const
	246	{
	247	//
	248	// Print header information of the event
	249	//
5f7789fc	250	printf("ESD run information\n");
4d422cad	251	printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
31fd97b2	252	GetEventNumberInFile(),
	253	GetBunchCrossNumber(),
	254	GetOrbitNumber(),
4d422cad	255	GetPeriodNumber(),
ef278eae	256	GetRunNumber(),
b647652d	257	GetTriggerMask(),
ef278eae	258	GetMagneticField() );
af885e0f	259	printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
	260	fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
	261	fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
	262	fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
9f57c1aa	263	printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
9f57c1aa	264	GetDiamondX(),GetDiamondY());
32e449be	265	printf("SPD Multiplicity. Number of tracklets %d \n",
af885e0f	266	fSPDMult.GetNumberOfTracklets());
af885e0f	267	printf("Event from reconstruction version %d \n",fRecoVersion);
ef278eae	268	printf("Number of tracks: \n");
85c60a8e	269	printf(" charged %d\n", GetNumberOfTracks());
af885e0f	270	printf(" hlt CF %d\n", GetNumberOfHLTConfMapTracks());
af885e0f	271	printf(" hlt HT %d\n", GetNumberOfHLTHoughTracks());
ef278eae	272	printf(" muon %d\n", GetNumberOfMuonTracks());
a2882fb4	273	printf(" pmd %d\n", GetNumberOfPmdTracks());
0ee00e25	274	printf(" trd %d\n", GetNumberOfTrdTracks());
ef278eae	275	printf(" v0 %d\n", GetNumberOfV0s());
667ee8bf	276	printf(" cascades %d\n", GetNumberOfCascades());
667ee8bf	277	printf(" kinks %d\n", GetNumberOfKinks());
667ee8bf	278	printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
	279	printf(" phos %d\n", GetNumberOfPHOSClusters());
	280	printf(" emcal %d\n", GetNumberOfEMCALClusters());
	281	printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
dd735cf0	282	printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
ef278eae	283	}
d75007f6	284
	285	void AliESD::SetESDfriend(const AliESDfriend *ev) {
	286	//
	287	// Attaches the complementary info to the ESD
	288	//
	289	if (!ev) return;
	290
	291	Int_t ntrk=ev->GetNumberOfTracks();
af885e0f	292
d75007f6	293	for (Int_t i=0; i<ntrk; i++) {
	294	const AliESDfriendTrack *f=ev->GetTrack(i);
	295	GetTrack(i)->SetFriendTrack(f);
	296	}
	297	}
	298
	299	void AliESD::GetESDfriend(AliESDfriend *ev) const {
	300	//
	301	// Extracts the complementary info from the ESD
	302	//
	303	if (!ev) return;
	304
	305	Int_t ntrk=GetNumberOfTracks();
	306
	307	for (Int_t i=0; i<ntrk; i++) {
80799a5f	308	AliESDtrack *t=GetTrack(i);
d75007f6	309	const AliESDfriendTrack *f=t->GetFriendTrack();
d75007f6	310	ev->AddTrack(f);
80799a5f	311
	312	t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
	313
d75007f6	314	}
d75007f6	315	}