[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
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():
31fd97b2	32	fEventNumberInFile(0),
	33	fBunchCrossNumber(0),
	34	fOrbitNumber(0),
e2afb3b6	35	fRunNumber(0),
001397cd	36	fTimeStamp(0),
001397cd	37	fEventType(0),
b647652d	38	fTriggerMask(0),
b647652d	39	fTriggerCluster(0),
e2afb3b6	40	fRecoVersion(0),
a866ac60	41	fMagneticField(0),
32a5cab4	42	fZDCN1Energy(0),
32a5cab4	43	fZDCP1Energy(0),
32a5cab4	44	fZDCN2Energy(0),
32a5cab4	45	fZDCP2Energy(0),
0ee00e25	46	fZDCEMEnergy(0),
878bc0c2	47	fZDCParticipants(0),
4a78b8c5	48	fT0zVertex(0),
15b965a7	49	fSPDVertex(),
15b965a7	50	fPrimaryVertex(),
32e449be	51	fSPDMult(),
6d45eaef	52	fT0timeStart(0),
e23730c7	53	fTracks("AliESDtrack",15000),
482070f2	54	fHLTConfMapTracks("AliESDHLTtrack",25000),
482070f2	55	fHLTHoughTracks("AliESDHLTtrack",15000),
672b5f43	56	fMuonTracks("AliESDMuonTrack",30),
561b7b31	57	fPmdTracks("AliESDPmdTrack",3000),
0ee00e25	58	fTrdTracks("AliESDTrdTrack",300),
51ad6848	59	fV0s("AliESDv0",200),
a2882fb4	60	fCascades("AliESDcascade",20),
51ad6848	61	fKinks("AliESDkink",4000),
85c60a8e	62	fCaloClusters("AliESDCaloCluster",10000),
	63	fEMCALClusters(0),
	64	fFirstEMCALCluster(-1),
64df000d	65	fEMCALTriggerPosition(0x0),
64df000d	66	fEMCALTriggerAmplitudes(0x0),
85c60a8e	67	fPHOSClusters(0),
85c60a8e	68	fFirstPHOSCluster(-1),
64df000d	69	fPHOSTriggerPosition(0x0),
64df000d	70	fPHOSTriggerAmplitudes(0x0),
dd735cf0	71	fESDFMD(0x0),
899ca440	72	fESDVZERO(0x0),
899ca440	73	fErrorLogs("AliRawDataErrorLog",5)
64df000d	74
9da38871	75	{
6d45eaef	76	for (Int_t i=0; i<24; i++) {
	77	fT0time[i] = 0;
	78	fT0amplitude[i] = 0;
	79	}
873f1f73	80	}
c028b974	81	//______________________________________________________________________________
	82	AliESD::AliESD(const AliESD& esd):
	83	TObject(esd),
31fd97b2	84	fEventNumberInFile(esd.fEventNumberInFile),
	85	fBunchCrossNumber(esd.fBunchCrossNumber),
	86	fOrbitNumber(esd.fOrbitNumber),
c028b974	87	fRunNumber(esd.fRunNumber),
001397cd	88	fTimeStamp(esd.fTimeStamp),
001397cd	89	fEventType(esd.fEventType),
c028b974	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),
fe12e09c	103	fSPDMult(esd.fSPDMult),
c028b974	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())),
c028b974	114	fCaloClusters(((TClonesArray)esd.fCaloClusters.Clone())),
	115	fEMCALClusters(esd.fEMCALClusters),
	116	fFirstEMCALCluster(esd.fFirstEMCALCluster),
64df000d	117	fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
64df000d	118	fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
c028b974	119	fPHOSClusters(esd.fPHOSClusters),
c028b974	120	fFirstPHOSCluster(esd.fFirstPHOSCluster),
64df000d	121	fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
64df000d	122	fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
dd735cf0	123	fESDFMD(esd.fESDFMD),
899ca440	124	fESDVZERO(esd.fESDVZERO),
899ca440	125	fErrorLogs(((TClonesArray)esd.fErrorLogs.Clone()))
c028b974	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
fe12e09c	133	//______________________________________________________________________________
	134	AliESD & AliESD::operator=(const AliESD& source) {
	135
	136	// Assignment operator
	137
	138	if(&source == this) return *this;
	139
31fd97b2	140	fEventNumberInFile = source.fEventNumberInFile;
	141	fBunchCrossNumber = source.fBunchCrossNumber;
	142	fOrbitNumber = source.fOrbitNumber;
fe12e09c	143	fRunNumber = source.fRunNumber;
001397cd	144	fTimeStamp = source.fTimeStamp;
001397cd	145	fEventType = source.fEventType;
fe12e09c	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());
fe12e09c	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;
dd735cf0	176	fESDVZERO = source.fESDVZERO;
64df000d	177	fEMCALTriggerPosition=source. fEMCALTriggerPosition;
	178	fEMCALTriggerAmplitudes=source.fEMCALTriggerAmplitudes;
	179	fPHOSTriggerPosition=source.fPHOSTriggerPosition;
	180	fPHOSTriggerAmplitudes=source.fPHOSTriggerAmplitudes;
899ca440	181	fErrorLogs = ((TClonesArray)source.fErrorLogs.Clone());
899ca440	182
fe12e09c	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
e2afb3b6	192
af7ba10c	193	//______________________________________________________________________________
	194	AliESD::~AliESD()
	195	{
	196	//
	197	// Standard destructor
	198	//
	199	fTracks.Delete();
8bbc564d	200	fHLTConfMapTracks.Delete();
8bbc564d	201	fHLTHoughTracks.Delete();
af7ba10c	202	fMuonTracks.Delete();
af7ba10c	203	fPmdTracks.Delete();
0ee00e25	204	fTrdTracks.Delete();
af7ba10c	205	fV0s.Delete();
af7ba10c	206	fCascades.Delete();
51ad6848	207	fKinks.Delete();
85c60a8e	208	fCaloClusters.Delete();
9da38871	209	delete fESDFMD;
dd735cf0	210	delete fESDVZERO;
64df000d	211	// fEMCALTriggerPosition->Delete();
	212	// fEMCALTriggerAmplitudes->Delete();
	213	// fPHOSTriggerPosition->Delete();
	214	// fPHOSTriggerAmplitudes->Delete();
	215	// delete fEMCALTriggerPosition;
	216	// delete fEMCALTriggerAmplitudes;
	217	// delete fPHOSTriggerPosition;
	218	// delete fPHOSTriggerAmplitudes;
899ca440	219	fErrorLogs.Delete();
64df000d	220
51ad6848	221	}
51ad6848	222
bf25155c	223	//______________________________________________________________________________
	224	void AliESD::Reset()
	225	{
31fd97b2	226	fEventNumberInFile=0;
	227	fBunchCrossNumber=0;
	228	fOrbitNumber=0;
bf25155c	229	fRunNumber=0;
001397cd	230	fTimeStamp = 0;
001397cd	231	fEventType = 0;
b647652d	232	fTriggerMask=0;
b647652d	233	fTriggerCluster=0;
bf25155c	234	fRecoVersion=0;
bf25155c	235	fMagneticField=0;
32a5cab4	236	fZDCN1Energy=0;
32a5cab4	237	fZDCP1Energy=0;
32a5cab4	238	fZDCN2Energy=0;
32a5cab4	239	fZDCP2Energy=0;
0ee00e25	240	fZDCEMEnergy=0;
bf25155c	241	fZDCParticipants=0;
bf25155c	242	fT0zVertex=0;
6d45eaef	243	fT0timeStart = 0;
15b965a7	244	new (&fSPDVertex) AliESDVertex();
15b965a7	245	new (&fPrimaryVertex) AliESDVertex();
32e449be	246	new (&fSPDMult) AliMultiplicity();
bf25155c	247	fTracks.Clear();
	248	fHLTConfMapTracks.Clear();
	249	fHLTHoughTracks.Clear();
	250	fMuonTracks.Clear();
	251	fPmdTracks.Clear();
0ee00e25	252	fTrdTracks.Clear();
bf25155c	253	fV0s.Clear();
bf25155c	254	fCascades.Clear();
85c60a8e	255	fCaloClusters.Clear();
	256	fEMCALClusters=0;
	257	fFirstEMCALCluster=-1;
	258	fPHOSClusters=0;
	259	fFirstPHOSCluster=-1;
9da38871	260	if (fESDFMD) fESDFMD->Clear();
64df000d	261	// fEMCALTriggerPosition->Clear();
	262	// fEMCALTriggerAmplitudes->Clear();
	263	// fPHOSTriggerPosition->Clear();
	264	// fPHOSTriggerAmplitudes->Clear();
899ca440	265	fErrorLogs.Clear();
bf25155c	266	}
af7ba10c	267
d6a49f20	268	Int_t AliESD::AddV0(const AliESDv0 *v) {
	269	//
	270	// Add V0
	271	//
	272	Int_t idx=fV0s.GetEntriesFast();
b75d63a7	273	new(fV0s[idx]) AliESDv0(*v);
d6a49f20	274	return idx;
	275	}
	276
af7ba10c	277	//______________________________________________________________________________
	278	void AliESD::Print(Option_t *) const
	279	{
	280	//
	281	// Print header information of the event
	282	//
5f7789fc	283	printf("ESD run information\n");
31fd97b2	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(),
ef278eae	288	GetRunNumber(),
b647652d	289	GetTriggerMask(),
ef278eae	290	GetMagneticField() );
8497bca0	291	printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
15b965a7	292	fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
	293	fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
	294	fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
32e449be	295	printf("SPD Multiplicity. Number of tracklets %d \n",
32e449be	296	fSPDMult.GetNumberOfTracklets());
ef278eae	297	printf("Event from reconstruction version %d \n",fRecoVersion);
ef278eae	298	printf("Number of tracks: \n");
85c60a8e	299	printf(" charged %d\n", GetNumberOfTracks());
482070f2	300	printf(" hlt CF %d\n", GetNumberOfHLTConfMapTracks());
482070f2	301	printf(" hlt HT %d\n", GetNumberOfHLTHoughTracks());
ef278eae	302	printf(" muon %d\n", GetNumberOfMuonTracks());
a2882fb4	303	printf(" pmd %d\n", GetNumberOfPmdTracks());
0ee00e25	304	printf(" trd %d\n", GetNumberOfTrdTracks());
ef278eae	305	printf(" v0 %d\n", GetNumberOfV0s());
667ee8bf	306	printf(" cascades %d\n", GetNumberOfCascades());
667ee8bf	307	printf(" kinks %d\n", GetNumberOfKinks());
667ee8bf	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"));
dd735cf0	312	printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
ef278eae	313	}
d75007f6	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	}