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