[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),
  fV0MIs("AliESDV0MI",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())),
  fV0MIs(*((TClonesArray*)esd.fV0MIs.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());
  fV0MIs = *((TClonesArray*)source.fV0MIs.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();
  fV0MIs.Delete();
  fCaloClusters.Delete();
  delete fESDFMD;
}

void AliESD::UpdateV0PIDs()
{
  //
  //
  //
  Int_t nV0 = GetNumberOfV0MIs();
  for (Int_t i=0;i<nV0;i++){
    AliESDV0MI * v0 = GetV0MI(i);
    AliESDtrack* tp = GetTrack(v0->GetIndex(0));
    AliESDtrack* tm = GetTrack(v0->GetIndex(1));
    if (!tm || !tp){
      printf("BBBUUUUUUUGGGG\n");
    }
    Double_t pp[5],pm[5];
    tp->GetESDpid(pp);
    tm->GetESDpid(pm);
    v0->UpdatePID(pp,pm);    
  }
}

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

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