[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)

{
  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)
{
  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;
  
  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()
{
  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();
}

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