[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),
  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;
  }
}
//______________________________________________________________________________
AliESD::AliESD(const AliESD& esd):
  TObject(esd),
  fEventNumberInFile(esd.fEventNumberInFile),
  fBunchCrossNumber(esd.fBunchCrossNumber),
  fOrbitNumber(esd.fOrbitNumber),
  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];
  }
}

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

  // Assignment operator

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

  fEventNumberInFile = source.fEventNumberInFile;
  fBunchCrossNumber = source.fBunchCrossNumber;
  fOrbitNumber = source.fOrbitNumber;
  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;
  fEMCALTriggerPosition=source. fEMCALTriggerPosition;
  fEMCALTriggerAmplitudes=source.fEMCALTriggerAmplitudes;
  fPHOSTriggerPosition=source.fPHOSTriggerPosition;
  fPHOSTriggerAmplitudes=source.fPHOSTriggerAmplitudes;
  fErrorLogs = *((TClonesArray*)source.fErrorLogs.Clone());

  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;
//   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;
  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 Run # %d Trigger %lld Magnetic field %f \n",
	 GetEventNumberInFile(),
	 GetBunchCrossNumber(),
	 GetOrbitNumber(),
	 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
	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
	16	/* $Id$ */
	17
	18	//-----------------------------------------------------------------
	19	// Implementation of the ESD class
	20	// This is the class to deal with during the phisical analysis of data
	21	// This class is generated directly by the reconstruction methods
	22	// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
	23	//-----------------------------------------------------------------
	24
	25	#include "AliESD.h"
	26	#include "AliESDfriend.h"
	27
	28	ClassImp(AliESD)
	29
	30	//______________________________________________________________________________
	31	AliESD::AliESD():
	32	fEventNumberInFile(0),
	33	fBunchCrossNumber(0),
	34	fOrbitNumber(0),
	35	fRunNumber(0),
	36	fTimeStamp(0),
	37	fEventType(0),
	38	fTriggerMask(0),
	39	fTriggerCluster(0),
	40	fRecoVersion(0),
	41	fMagneticField(0),
	42	fZDCN1Energy(0),
	43	fZDCP1Energy(0),
	44	fZDCN2Energy(0),
	45	fZDCP2Energy(0),
	46	fZDCEMEnergy(0),
	47	fZDCParticipants(0),
	48	fT0zVertex(0),
	49	fSPDVertex(),
	50	fPrimaryVertex(),
	51	fSPDMult(),
	52	fT0timeStart(0),
	53	fTracks("AliESDtrack",15000),
	54	fHLTConfMapTracks("AliESDHLTtrack",25000),
	55	fHLTHoughTracks("AliESDHLTtrack",15000),
	56	fMuonTracks("AliESDMuonTrack",30),
	57	fPmdTracks("AliESDPmdTrack",3000),
	58	fTrdTracks("AliESDTrdTrack",300),
	59	fV0s("AliESDv0",200),
	60	fCascades("AliESDcascade",20),
	61	fKinks("AliESDkink",4000),
	62	fCaloClusters("AliESDCaloCluster",10000),
	63	fEMCALClusters(0),
	64	fFirstEMCALCluster(-1),
	65	fEMCALTriggerPosition(0x0),
	66	fEMCALTriggerAmplitudes(0x0),
	67	fPHOSClusters(0),
	68	fFirstPHOSCluster(-1),
	69	fPHOSTriggerPosition(0x0),
	70	fPHOSTriggerAmplitudes(0x0),
	71	fESDFMD(0x0),
	72	fESDVZERO(0x0),
	73	fErrorLogs("AliRawDataErrorLog",5)
	74
	75	{
	76	for (Int_t i=0; i<24; i++) {
	77	fT0time[i] = 0;
	78	fT0amplitude[i] = 0;
	79	}
	80	}
	81	//______________________________________________________________________________
	82	AliESD::AliESD(const AliESD& esd):
	83	TObject(esd),
	84	fEventNumberInFile(esd.fEventNumberInFile),
	85	fBunchCrossNumber(esd.fBunchCrossNumber),
	86	fOrbitNumber(esd.fOrbitNumber),
	87	fRunNumber(esd.fRunNumber),
	88	fTimeStamp(esd.fTimeStamp),
	89	fEventType(esd.fEventType),
	90	fTriggerMask(esd.fTriggerMask),
	91	fTriggerCluster(esd.fTriggerCluster),
	92	fRecoVersion(esd.fRecoVersion),
	93	fMagneticField(esd.fMagneticField),
	94	fZDCN1Energy(esd.fZDCN1Energy),
	95	fZDCP1Energy(esd.fZDCP1Energy),
	96	fZDCN2Energy(esd.fZDCN2Energy),
	97	fZDCP2Energy(esd.fZDCP2Energy),
	98	fZDCEMEnergy(esd.fZDCEMEnergy),
	99	fZDCParticipants(esd.fZDCParticipants),
	100	fT0zVertex(esd.fT0zVertex),
	101	fSPDVertex(esd.fSPDVertex),
	102	fPrimaryVertex(esd.fPrimaryVertex),
	103	fSPDMult(esd.fSPDMult),
	104	fT0timeStart(esd.fT0timeStart),
	105	fTracks(((TClonesArray)esd.fTracks.Clone())),
	106	fHLTConfMapTracks(((TClonesArray)esd.fHLTConfMapTracks.Clone())),
	107	fHLTHoughTracks(((TClonesArray)esd.fHLTHoughTracks.Clone())),
	108	fMuonTracks(((TClonesArray)esd.fMuonTracks.Clone())),
	109	fPmdTracks(((TClonesArray)esd.fPmdTracks.Clone())),
	110	fTrdTracks(((TClonesArray)esd.fTrdTracks.Clone())),
	111	fV0s(((TClonesArray)esd.fV0s.Clone())),
	112	fCascades(((TClonesArray)esd.fCascades.Clone())),
	113	fKinks(((TClonesArray)esd.fKinks.Clone())),
	114	fCaloClusters(((TClonesArray)esd.fCaloClusters.Clone())),
	115	fEMCALClusters(esd.fEMCALClusters),
	116	fFirstEMCALCluster(esd.fFirstEMCALCluster),
	117	fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
	118	fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
	119	fPHOSClusters(esd.fPHOSClusters),
	120	fFirstPHOSCluster(esd.fFirstPHOSCluster),
	121	fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
	122	fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
	123	fESDFMD(esd.fESDFMD),
	124	fESDVZERO(esd.fESDVZERO),
	125	fErrorLogs(((TClonesArray)esd.fErrorLogs.Clone()))
	126	{
	127	for (Int_t i=0; i<24; i++) {
	128	fT0time[i] = esd.fT0time[i];
	129	fT0amplitude[i] = esd.fT0amplitude[i];
	130	}
	131	}
	132
	133	//______________________________________________________________________________
	134	AliESD & AliESD::operator=(const AliESD& source) {
	135
	136	// Assignment operator
	137
	138	if(&source == this) return *this;
	139
	140	fEventNumberInFile = source.fEventNumberInFile;
	141	fBunchCrossNumber = source.fBunchCrossNumber;
	142	fOrbitNumber = source.fOrbitNumber;
	143	fRunNumber = source.fRunNumber;
	144	fTimeStamp = source.fTimeStamp;
	145	fEventType = source.fEventType;
	146	fTriggerMask = source.fTriggerMask;
	147	fTriggerCluster = source.fTriggerCluster;
	148	fRecoVersion = source.fRecoVersion;
	149	fMagneticField = source.fMagneticField;
	150	fZDCN1Energy = source.fZDCN1Energy;
	151	fZDCP1Energy = source.fZDCP1Energy;
	152	fZDCN2Energy = source.fZDCN2Energy;
	153	fZDCP2Energy = source.fZDCP2Energy;
	154	fZDCEMEnergy = source.fZDCEMEnergy;
	155	fZDCParticipants = source.fZDCParticipants;
	156	fT0zVertex = source.fT0zVertex;
	157	fSPDVertex = source.fSPDVertex;
	158	fPrimaryVertex = source.fPrimaryVertex;
	159	fSPDMult = source.fSPDMult;
	160	fT0timeStart = source.fT0timeStart;
	161	fTracks = ((TClonesArray)source.fTracks.Clone());
	162	fHLTConfMapTracks = ((TClonesArray)source.fHLTConfMapTracks.Clone());
	163	fHLTHoughTracks = ((TClonesArray)source.fHLTHoughTracks.Clone());
	164	fMuonTracks = ((TClonesArray)source.fMuonTracks.Clone());
	165	fPmdTracks = ((TClonesArray)source.fPmdTracks.Clone());
	166	fTrdTracks = ((TClonesArray)source.fTrdTracks.Clone());
	167	fV0s = ((TClonesArray)source.fV0s.Clone());
	168	fCascades = ((TClonesArray)source.fCascades.Clone());
	169	fKinks = ((TClonesArray)source.fKinks.Clone());
	170	fCaloClusters = ((TClonesArray)source.fCaloClusters.Clone());
	171	fEMCALClusters = source.fEMCALClusters;
	172	fFirstEMCALCluster = source.fFirstEMCALCluster;
	173	fPHOSClusters = source.fPHOSClusters;
	174	fFirstPHOSCluster = source.fFirstPHOSCluster;
	175	fESDFMD = source.fESDFMD;
	176	fESDVZERO = source.fESDVZERO;
	177	fEMCALTriggerPosition=source. fEMCALTriggerPosition;
	178	fEMCALTriggerAmplitudes=source.fEMCALTriggerAmplitudes;
	179	fPHOSTriggerPosition=source.fPHOSTriggerPosition;
	180	fPHOSTriggerAmplitudes=source.fPHOSTriggerAmplitudes;
	181	fErrorLogs = ((TClonesArray)source.fErrorLogs.Clone());
	182
	183	for (Int_t i=0; i<24; i++) {
	184	fT0time[i] = source.fT0time[i];
	185	fT0amplitude[i] = source.fT0amplitude[i];
	186	}
	187
	188	return *this;
	189
	190	}
	191
	192
	193	//______________________________________________________________________________
	194	AliESD::~AliESD()
	195	{
	196	//
	197	// Standard destructor
	198	//
	199	fTracks.Delete();
	200	fHLTConfMapTracks.Delete();
	201	fHLTHoughTracks.Delete();
	202	fMuonTracks.Delete();
	203	fPmdTracks.Delete();
	204	fTrdTracks.Delete();
	205	fV0s.Delete();
	206	fCascades.Delete();
	207	fKinks.Delete();
	208	fCaloClusters.Delete();
	209	delete fESDFMD;
	210	delete fESDVZERO;
	211	// fEMCALTriggerPosition->Delete();
	212	// fEMCALTriggerAmplitudes->Delete();
	213	// fPHOSTriggerPosition->Delete();
	214	// fPHOSTriggerAmplitudes->Delete();
	215	// delete fEMCALTriggerPosition;
	216	// delete fEMCALTriggerAmplitudes;
	217	// delete fPHOSTriggerPosition;
	218	// delete fPHOSTriggerAmplitudes;
	219	fErrorLogs.Delete();
	220
	221	}
	222
	223	//______________________________________________________________________________
	224	void AliESD::Reset()
	225	{
	226	fEventNumberInFile=0;
	227	fBunchCrossNumber=0;
	228	fOrbitNumber=0;
	229	fRunNumber=0;
	230	fTimeStamp = 0;
	231	fEventType = 0;
	232	fTriggerMask=0;
	233	fTriggerCluster=0;
	234	fRecoVersion=0;
	235	fMagneticField=0;
	236	fZDCN1Energy=0;
	237	fZDCP1Energy=0;
	238	fZDCN2Energy=0;
	239	fZDCP2Energy=0;
	240	fZDCEMEnergy=0;
	241	fZDCParticipants=0;
	242	fT0zVertex=0;
	243	fT0timeStart = 0;
	244	new (&fSPDVertex) AliESDVertex();
	245	new (&fPrimaryVertex) AliESDVertex();
	246	new (&fSPDMult) AliMultiplicity();
	247	fTracks.Clear();
	248	fHLTConfMapTracks.Clear();
	249	fHLTHoughTracks.Clear();
	250	fMuonTracks.Clear();
	251	fPmdTracks.Clear();
	252	fTrdTracks.Clear();
	253	fV0s.Clear();
	254	fCascades.Clear();
	255	fCaloClusters.Clear();
	256	fEMCALClusters=0;
	257	fFirstEMCALCluster=-1;
	258	fPHOSClusters=0;
	259	fFirstPHOSCluster=-1;
	260	if (fESDFMD) fESDFMD->Clear();
	261	// fEMCALTriggerPosition->Clear();
	262	// fEMCALTriggerAmplitudes->Clear();
	263	// fPHOSTriggerPosition->Clear();
	264	// fPHOSTriggerAmplitudes->Clear();
	265	fErrorLogs.Clear();
	266	}
	267
	268	Int_t AliESD::AddV0(const AliESDv0 *v) {
	269	//
	270	// Add V0
	271	//
	272	Int_t idx=fV0s.GetEntriesFast();
	273	new(fV0s[idx]) AliESDv0(*v);
	274	return idx;
	275	}
	276
	277	//______________________________________________________________________________
	278	void AliESD::Print(Option_t *) const
	279	{
	280	//
	281	// Print header information of the event
	282	//
	283	printf("ESD run information\n");
	284	printf("Event # in file %d Bunch crossing # %d Orbit # %d Run # %d Trigger %lld Magnetic field %f \n",
	285	GetEventNumberInFile(),
	286	GetBunchCrossNumber(),
	287	GetOrbitNumber(),
	288	GetRunNumber(),
	289	GetTriggerMask(),
	290	GetMagneticField() );
	291	printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
	292	fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
	293	fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
	294	fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
	295	printf("SPD Multiplicity. Number of tracklets %d \n",
	296	fSPDMult.GetNumberOfTracklets());
	297	printf("Event from reconstruction version %d \n",fRecoVersion);
	298	printf("Number of tracks: \n");
	299	printf(" charged %d\n", GetNumberOfTracks());
	300	printf(" hlt CF %d\n", GetNumberOfHLTConfMapTracks());
	301	printf(" hlt HT %d\n", GetNumberOfHLTHoughTracks());
	302	printf(" muon %d\n", GetNumberOfMuonTracks());
	303	printf(" pmd %d\n", GetNumberOfPmdTracks());
	304	printf(" trd %d\n", GetNumberOfTrdTracks());
	305	printf(" v0 %d\n", GetNumberOfV0s());
	306	printf(" cascades %d\n", GetNumberOfCascades());
	307	printf(" kinks %d\n", GetNumberOfKinks());
	308	printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
	309	printf(" phos %d\n", GetNumberOfPHOSClusters());
	310	printf(" emcal %d\n", GetNumberOfEMCALClusters());
	311	printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
	312	printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
	313	}
	314
	315	void AliESD::SetESDfriend(const AliESDfriend *ev) {
	316	//
	317	// Attaches the complementary info to the ESD
	318	//
	319	if (!ev) return;
	320
	321	Int_t ntrk=ev->GetNumberOfTracks();
	322
	323	for (Int_t i=0; i<ntrk; i++) {
	324	const AliESDfriendTrack *f=ev->GetTrack(i);
	325	GetTrack(i)->SetFriendTrack(f);
	326	}
	327	}
	328
	329	void AliESD::GetESDfriend(AliESDfriend *ev) const {
	330	//
	331	// Extracts the complementary info from the ESD
	332	//
	333	if (!ev) return;
	334
	335	Int_t ntrk=GetNumberOfTracks();
	336
	337	for (Int_t i=0; i<ntrk; i++) {
	338	const AliESDtrack *t=GetTrack(i);
	339	const AliESDfriendTrack *f=t->GetFriendTrack();
	340	ev->AddTrack(f);
	341	}
	342	}