[u/mrichter/AliRoot.git] / STEER / AliESD.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//-----------------------------------------------------------------
//           Implementation of the ESD class
//   This is the class to deal with during the phisical analysis of data
//   This class is generated directly by the reconstruction methods
//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-----------------------------------------------------------------

#include "AliESD.h"
#include "AliESDfriend.h"

ClassImp(AliESD)

//______________________________________________________________________________
AliESD::AliESD():
  fEventNumberInFile(0),
  fBunchCrossNumber(0),
  fOrbitNumber(0),
  fPeriodNumber(0),
  fRunNumber(0),
  fTimeStamp(0),
  fEventType(0),
  fTriggerMask(0),
  fTriggerCluster(0),
  fRecoVersion(0),
  fMagneticField(0),
  fZDCN1Energy(0),
  fZDCP1Energy(0),
  fZDCN2Energy(0),
  fZDCP2Energy(0),
  fZDCEMEnergy(0),
  fZDCParticipants(0),
  fT0zVertex(0),
  fSPDVertex(),
  fPrimaryVertex(),
  fSPDMult(),
  fT0timeStart(0),
  fTracks("AliESDtrack",15000),
  fHLTConfMapTracks("AliESDHLTtrack",25000),
  fHLTHoughTracks("AliESDHLTtrack",15000),
  fMuonTracks("AliESDMuonTrack",30),
  fPmdTracks("AliESDPmdTrack",3000),
  fTrdTracks("AliESDTrdTrack",300),
  fV0s("AliESDv0",200),  
  fCascades("AliESDcascade",20),
  fKinks("AliESDkink",4000),
  fCaloClusters("AliESDCaloCluster",10000),
  fEMCALClusters(0), 
  fFirstEMCALCluster(-1),
  fEMCALTriggerPosition(0x0),
  fEMCALTriggerAmplitudes(0x0),
  fPHOSClusters(0), 
  fFirstPHOSCluster(-1),
  fPHOSTriggerPosition(0x0),
  fPHOSTriggerAmplitudes(0x0),
  fESDFMD(0x0),
  fESDVZERO(0x0),
  fErrorLogs("AliRawDataErrorLog",5)

{
  for (Int_t i=0; i<24; i++) {
    fT0time[i] = 0;
    fT0amplitude[i] = 0;
  }
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
}
//______________________________________________________________________________
AliESD::AliESD(const AliESD& esd):
  TObject(esd),
  fEventNumberInFile(esd.fEventNumberInFile),
  fBunchCrossNumber(esd.fBunchCrossNumber),
  fOrbitNumber(esd.fOrbitNumber),
  fPeriodNumber(esd.fPeriodNumber),
  fRunNumber(esd.fRunNumber),
  fTimeStamp(esd.fTimeStamp),
  fEventType(esd.fEventType),
  fTriggerMask(esd.fTriggerMask),
  fTriggerCluster(esd.fTriggerCluster),
  fRecoVersion(esd.fRecoVersion),
  fMagneticField(esd.fMagneticField),
  fZDCN1Energy(esd.fZDCN1Energy),
  fZDCP1Energy(esd.fZDCP1Energy),
  fZDCN2Energy(esd.fZDCN2Energy),
  fZDCP2Energy(esd.fZDCP2Energy),
  fZDCEMEnergy(esd.fZDCEMEnergy),
  fZDCParticipants(esd.fZDCParticipants),
  fT0zVertex(esd.fT0zVertex),
  fSPDVertex(esd.fSPDVertex),
  fPrimaryVertex(esd.fPrimaryVertex),
  fSPDMult(esd.fSPDMult),
  fT0timeStart(esd.fT0timeStart),
  fTracks(*((TClonesArray*)esd.fTracks.Clone())),
  fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
  fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
  fMuonTracks(*((TClonesArray*)esd.fMuonTracks.Clone())),
  fPmdTracks(*((TClonesArray*)esd.fPmdTracks.Clone())),
  fTrdTracks(*((TClonesArray*)esd.fTrdTracks.Clone())),
  fV0s(*((TClonesArray*)esd.fV0s.Clone())),  
  fCascades(*((TClonesArray*)esd.fCascades.Clone())),
  fKinks(*((TClonesArray*)esd.fKinks.Clone())),
  fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())),
  fEMCALClusters(esd.fEMCALClusters), 
  fFirstEMCALCluster(esd.fFirstEMCALCluster),
  fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
  fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
  fPHOSClusters(esd.fPHOSClusters), 
  fFirstPHOSCluster(esd.fFirstPHOSCluster),
  fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
  fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
  fESDFMD(esd.fESDFMD),
  fESDVZERO(esd.fESDVZERO),
  fErrorLogs(*((TClonesArray*)esd.fErrorLogs.Clone()))
{
  for (Int_t i=0; i<24; i++) {
    fT0time[i] = esd.fT0time[i];
    fT0amplitude[i] = esd.fT0amplitude[i];
  }
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
}

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

  // Assignment operator

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

  fEventNumberInFile = source.fEventNumberInFile;
  fBunchCrossNumber = source.fBunchCrossNumber;
  fOrbitNumber = source.fOrbitNumber;
  fPeriodNumber = source.fPeriodNumber;
  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];
  }
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=source.fDiamondXY[i];
  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=source.fDiamondCovXY[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;
  fPeriodNumber=0;
  fRunNumber=0;
  fTimeStamp = 0;
  fEventType = 0;
  fTriggerMask=0;
  fTriggerCluster=0;
  fRecoVersion=0;
  fMagneticField=0;
  fZDCN1Energy=0;
  fZDCP1Energy=0;
  fZDCN2Energy=0;
  fZDCP2Energy=0;
  fZDCEMEnergy=0;
  fZDCParticipants=0;
  fT0zVertex=0;
  fT0timeStart = 0;
  new (&fSPDVertex) AliESDVertex();
  new (&fPrimaryVertex) AliESDVertex();
  new (&fSPDMult) AliMultiplicity();
  fTracks.Clear();
  fHLTConfMapTracks.Clear();
  fHLTHoughTracks.Clear();
  fMuonTracks.Clear();
  fPmdTracks.Clear();
  fTrdTracks.Clear();
  fV0s.Clear();
  fCascades.Clear();
  fCaloClusters.Clear();
  fEMCALClusters=0; 
  fFirstEMCALCluster=-1; 
  fPHOSClusters=0; 
  fFirstPHOSCluster=-1; 
  if (fESDFMD) fESDFMD->Clear();
//   fEMCALTriggerPosition->Clear();
//   fEMCALTriggerAmplitudes->Clear();
//   fPHOSTriggerPosition->Clear();
//   fPHOSTriggerAmplitudes->Clear();
  fErrorLogs.Clear();
}

Int_t AliESD::AddV0(const AliESDv0 *v) {
  //
  // Add V0
  //
    Int_t idx=fV0s.GetEntriesFast();
    new(fV0s[idx]) AliESDv0(*v);
    return idx;
}  

//______________________________________________________________________________
void AliESD::Print(Option_t *) const 
{
  //
  // Print header information of the event
  //
  printf("ESD run information\n");
  printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
	 GetEventNumberInFile(),
	 GetBunchCrossNumber(),
	 GetOrbitNumber(),
	 GetPeriodNumber(),
	 GetRunNumber(),
	 GetTriggerMask(),
	 GetMagneticField() );
    printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
	   fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
	   fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
	   fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
    printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
	   GetDiamondX(),GetDiamondY());
    printf("SPD Multiplicity. Number of tracklets %d \n",
           fSPDMult.GetNumberOfTracklets());
  printf("Event from reconstruction version %d \n",fRecoVersion);
  printf("Number of tracks: \n");
  printf("                 charged   %d\n", GetNumberOfTracks());
  printf("                 hlt CF    %d\n", GetNumberOfHLTConfMapTracks());
  printf("                 hlt HT    %d\n", GetNumberOfHLTHoughTracks());
  printf("                 muon      %d\n", GetNumberOfMuonTracks());
  printf("                 pmd       %d\n", GetNumberOfPmdTracks());
  printf("                 trd       %d\n", GetNumberOfTrdTracks());
  printf("                 v0        %d\n", GetNumberOfV0s());
  printf("                 cascades  %d\n", GetNumberOfCascades());
  printf("                 kinks     %d\n", GetNumberOfKinks());
  printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
  printf("                 phos      %d\n", GetNumberOfPHOSClusters());
  printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
  printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
  printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
}

void AliESD::SetESDfriend(const AliESDfriend *ev) {
  //
  // Attaches the complementary info to the ESD
  //
  if (!ev) return;

  Int_t ntrk=ev->GetNumberOfTracks();

  for (Int_t i=0; i<ntrk; i++) {
    const AliESDfriendTrack *f=ev->GetTrack(i);
    GetTrack(i)->SetFriendTrack(f);
  }
}

void AliESD::GetESDfriend(AliESDfriend *ev) const {
  //
  // Extracts the complementary info from the ESD
  //
  if (!ev) return;

  Int_t ntrk=GetNumberOfTracks();

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