[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),
  fEMCALTriggerPosition(0x0),
  fEMCALTriggerAmplitudes(0x0),
  fPHOSClusters(0), 
  fFirstPHOSCluster(-1),
  fPHOSTriggerPosition(0x0),
  fPHOSTriggerAmplitudes(0x0),
  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),
  fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
  fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
  fPHOSClusters(esd.fPHOSClusters), 
  fFirstPHOSCluster(esd.fFirstPHOSCluster),
  fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
  fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
  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;
  fEMCALTriggerPosition=source. fEMCALTriggerPosition;
  fEMCALTriggerAmplitudes=source.fEMCALTriggerAmplitudes;
  fPHOSTriggerPosition=source.fPHOSTriggerPosition;
  fPHOSTriggerAmplitudes=source.fPHOSTriggerAmplitudes;
  
  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;

}

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