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

Bool_t  AliESD::RemoveTrack(Int_t rm) {
  // ---------------------------------------------------------
  // Remove a track and references to it from ESD,
  // if this track does not come from a reconstructed decay
  // ---------------------------------------------------------
  Int_t last=GetNumberOfTracks()-1;
  if ((rm<0)||(rm>last)) return kFALSE;

  Int_t used=0;

  // Check if this track comes from a reconstructed decay
  Int_t nv0=GetNumberOfV0s();
  for (Int_t n=0; n<nv0; n++) {
    AliESDv0 *v0=GetV0(n);

    Int_t idx=v0->GetNindex();
    if (rm==idx) return kFALSE;
    if (idx==last) used++;

    idx=v0->GetPindex();
    if (rm==idx) return kFALSE;
    if (idx==last) used++;
  }

  Int_t ncs=GetNumberOfCascades();
  for (Int_t n=0; n<ncs; n++) {
    AliESDcascade *cs=GetCascade(n);

    Int_t idx=cs->GetIndex();
    if (rm==idx) return kFALSE;
    if (idx==last) used++;
  }

  Int_t nkn=GetNumberOfKinks();
  for (Int_t n=0; n<nkn; n++) {
    AliESDkink *kn=GetKink(n);

    Int_t idx=kn->GetIndex(0);
    if (rm==idx) return kFALSE;
    if (idx==last) used++;

    idx=kn->GetIndex(1);
    if (rm==idx) return kFALSE;
    if (idx==last) used++;
  }


  //Replace the removed track with the last track 
  TClonesArray &a=fTracks;
  delete a.RemoveAt(rm);

  if (rm==last) return kTRUE;

  AliESDtrack *t=GetTrack(last);
  t->SetID(rm);
  new (a[rm]) AliESDtrack(*t);
  delete a.RemoveAt(last);

  if (!used) return kTRUE;

  
  // Remap the indices of the daughters of reconstructed decays
  for (Int_t n=0; n<nv0; n++) {
    AliESDv0 *v0=GetV0(n);
    if (v0->GetIndex(0)==last) {
       v0->SetIndex(0,rm);
       used--;
       if (!used) return kTRUE;
    }
    if (v0->GetIndex(1)==last) {
       v0->SetIndex(1,rm);
       used--;
       if (!used) return kTRUE;
    }
  }

  for (Int_t n=0; n<ncs; n++) {
    AliESDcascade *cs=GetCascade(n);
    if (cs->GetIndex()==last) {
       cs->SetIndex(rm);
       used--;
       if (!used) return kTRUE;
    }
  }

  for (Int_t n=0; n<nkn; n++) {
    AliESDkink *kn=GetKink(n);
    if (kn->GetIndex(0)==last) {
       kn->SetIndex(rm,0);
       used--;
       if (!used) return kTRUE;
    }
    if (kn->GetIndex(1)==last) {
       kn->SetIndex(rm,1);
       used--;
       if (!used) return kTRUE;
    }
  }

  return kTRUE;
}

Bool_t AliESD::Clean(Float_t *cleanPars) {
  //
  // Remove the data which are not needed for the physics analysis.
  //
  // If track's transverse parameter is larger than dmax
  //                       OR
  //    track's longitudinal parameter is larger than zmax
  // an attempt to remove this track from ESD is made.
  //
  // The track gets removed if it does not come 
  // from a reconstructed decay
  //

  Float_t dmax=cleanPars[0], zmax=cleanPars[1];

  const AliESDVertex *vertex=GetVertex();
  Bool_t vtxOK=vertex->GetStatus(), rc=kFALSE;
  
  Int_t nTracks=GetNumberOfTracks();
  for (Int_t i=nTracks-1; i>=0; i--) {
    AliESDtrack *track=GetTrack(i);
    Float_t xy,z; track->GetImpactParameters(xy,z);
    if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
      if (RemoveTrack(i)) rc=kTRUE;
    }
  }

  return rc;
}

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++) {
    AliESDtrack *t=GetTrack(i);
    const AliESDfriendTrack *f=t->GetFriendTrack();
    ev->AddTrack(f);

    t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"

  }
}
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
b545009a	25	#include "AliESD.h"
b545009a	26	#include "AliESDfriend.h"
53203d32	27
	28	ClassImp(AliESD)
	29
	30	//______________________________________________________________________________
	31	AliESD::AliESD():
af885e0f	32	fEventNumberInFile(0),
	33	fBunchCrossNumber(0),
	34	fOrbitNumber(0),
	35	fPeriodNumber(0),
	36	fRunNumber(0),
	37	fTimeStamp(0),
	38	fEventType(0),
	39	fTriggerMask(0),
	40	fTriggerCluster(0),
	41	fRecoVersion(0),
	42	fMagneticField(0),
	43	fZDCN1Energy(0),
	44	fZDCP1Energy(0),
	45	fZDCN2Energy(0),
	46	fZDCP2Energy(0),
	47	fZDCEMEnergy(0),
	48	fZDCParticipants(0),
	49	fT0zVertex(0),
	50	fSPDVertex(),
	51	fPrimaryVertex(),
	52	fSPDMult(),
	53	fT0timeStart(0),
	54	fTracks("AliESDtrack",15000),
	55	fHLTConfMapTracks("AliESDHLTtrack",25000),
	56	fHLTHoughTracks("AliESDHLTtrack",15000),
	57	fMuonTracks("AliESDMuonTrack",30),
	58	fPmdTracks("AliESDPmdTrack",3000),
	59	fTrdTracks("AliESDTrdTrack",300),
	60	fV0s("AliESDv0",200),
	61	fCascades("AliESDcascade",20),
	62	fKinks("AliESDkink",4000),
	63	fCaloClusters("AliESDCaloCluster",10000),
85c60a8e	64	fEMCALClusters(0),
85c60a8e	65	fFirstEMCALCluster(-1),
af885e0f	66	fEMCALTriggerPosition(0x0),
af885e0f	67	fEMCALTriggerAmplitudes(0x0),
85c60a8e	68	fPHOSClusters(0),
af885e0f	69	fFirstPHOSCluster(-1),
	70	fPHOSTriggerPosition(0x0),
	71	fPHOSTriggerAmplitudes(0x0),
	72	fESDFMD(0x0),
	73	fESDVZERO(0x0),
	74	fErrorLogs("AliRawDataErrorLog",5)
	75
9da38871	76	{
af885e0f	77	for (Int_t i=0; i<24; i++) {
	78	fT0time[i] = 0;
	79	fT0amplitude[i] = 0;
	80	}
	81	for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
	82	for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
873f1f73	83	}
e149da78	84
c028b974	85	//______________________________________________________________________________
	86	AliESD::AliESD(const AliESD& esd):
	87	TObject(esd),
af885e0f	88	fEventNumberInFile(esd.fEventNumberInFile),
	89	fBunchCrossNumber(esd.fBunchCrossNumber),
	90	fOrbitNumber(esd.fOrbitNumber),
	91	fPeriodNumber(esd.fPeriodNumber),
	92	fRunNumber(esd.fRunNumber),
	93	fTimeStamp(esd.fTimeStamp),
	94	fEventType(esd.fEventType),
	95	fTriggerMask(esd.fTriggerMask),
	96	fTriggerCluster(esd.fTriggerCluster),
	97	fRecoVersion(esd.fRecoVersion),
	98	fMagneticField(esd.fMagneticField),
	99	fZDCN1Energy(esd.fZDCN1Energy),
	100	fZDCP1Energy(esd.fZDCP1Energy),
	101	fZDCN2Energy(esd.fZDCN2Energy),
	102	fZDCP2Energy(esd.fZDCP2Energy),
	103	fZDCEMEnergy(esd.fZDCEMEnergy),
	104	fZDCParticipants(esd.fZDCParticipants),
	105	fT0zVertex(esd.fT0zVertex),
	106	fSPDVertex(esd.fSPDVertex),
	107	fPrimaryVertex(esd.fPrimaryVertex),
	108	fSPDMult(esd.fSPDMult),
	109	fT0timeStart(esd.fT0timeStart),
	110	fTracks(((TClonesArray)esd.fTracks.Clone())),
	111	fHLTConfMapTracks(((TClonesArray)esd.fHLTConfMapTracks.Clone())),
	112	fHLTHoughTracks(((TClonesArray)esd.fHLTHoughTracks.Clone())),
	113	fMuonTracks(((TClonesArray)esd.fMuonTracks.Clone())),
	114	fPmdTracks(((TClonesArray)esd.fPmdTracks.Clone())),
	115	fTrdTracks(((TClonesArray)esd.fTrdTracks.Clone())),
	116	fV0s(((TClonesArray)esd.fV0s.Clone())),
	117	fCascades(((TClonesArray)esd.fCascades.Clone())),
	118	fKinks(((TClonesArray)esd.fKinks.Clone())),
	119	fCaloClusters(((TClonesArray)esd.fCaloClusters.Clone())),
c028b974	120	fEMCALClusters(esd.fEMCALClusters),
c028b974	121	fFirstEMCALCluster(esd.fFirstEMCALCluster),
af885e0f	122	fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
af885e0f	123	fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
c028b974	124	fPHOSClusters(esd.fPHOSClusters),
af885e0f	125	fFirstPHOSCluster(esd.fFirstPHOSCluster),
	126	fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
	127	fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
	128	fESDFMD(esd.fESDFMD),
	129	fESDVZERO(esd.fESDVZERO),
	130	fErrorLogs(((TClonesArray)esd.fErrorLogs.Clone()))
c028b974	131	{
af885e0f	132	for (Int_t i=0; i<24; i++) {
	133	fT0time[i] = esd.fT0time[i];
	134	fT0amplitude[i] = esd.fT0amplitude[i];
	135	}
	136	for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
	137	for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
c028b974	138	}
c028b974	139
af7ba10c	140	//______________________________________________________________________________
	141	AliESD::~AliESD()
	142	{
	143	//
	144	// Standard destructor
	145	//
af885e0f	146	fTracks.Delete();
8bbc564d	147	fHLTConfMapTracks.Delete();
8bbc564d	148	fHLTHoughTracks.Delete();
af885e0f	149	fMuonTracks.Delete();
af7ba10c	150	fPmdTracks.Delete();
0ee00e25	151	fTrdTracks.Delete();
af7ba10c	152	fV0s.Delete();
af7ba10c	153	fCascades.Delete();
51ad6848	154	fKinks.Delete();
85c60a8e	155	fCaloClusters.Delete();
af885e0f	156	delete fESDFMD;
af885e0f	157	delete fESDVZERO;
64df000d	158	// fEMCALTriggerPosition->Delete();
	159	// fEMCALTriggerAmplitudes->Delete();
	160	// fPHOSTriggerPosition->Delete();
	161	// fPHOSTriggerAmplitudes->Delete();
	162	// delete fEMCALTriggerPosition;
	163	// delete fEMCALTriggerAmplitudes;
	164	// delete fPHOSTriggerPosition;
	165	// delete fPHOSTriggerAmplitudes;
af885e0f	166	fErrorLogs.Delete();
64df000d	167
51ad6848	168	}
51ad6848	169
bf25155c	170	//______________________________________________________________________________
	171	void AliESD::Reset()
	172	{
af885e0f	173	fEventNumberInFile=0;
	174	fBunchCrossNumber=0;
	175	fOrbitNumber=0;
	176	fPeriodNumber=0;
	177	fRunNumber=0;
	178	fTimeStamp = 0;
	179	fEventType = 0;
	180	fTriggerMask=0;
	181	fTriggerCluster=0;
	182	fRecoVersion=0;
	183	fMagneticField=0;
	184	fZDCN1Energy=0;
	185	fZDCP1Energy=0;
	186	fZDCN2Energy=0;
	187	fZDCP2Energy=0;
	188	fZDCEMEnergy=0;
	189	fZDCParticipants=0;
	190	fT0zVertex=0;
	191	fT0timeStart = 0;
	192	new (&fSPDVertex) AliESDVertex();
	193	new (&fPrimaryVertex) AliESDVertex();
	194	new (&fSPDMult) AliMultiplicity();
	195	fTracks.Clear();
	196	fHLTConfMapTracks.Clear();
	197	fHLTHoughTracks.Clear();
	198	fMuonTracks.Clear();
	199	fPmdTracks.Clear();
	200	fTrdTracks.Clear();
	201	fV0s.Clear();
	202	fCascades.Clear();
	203	fCaloClusters.Clear();
85c60a8e	204	fEMCALClusters=0;
	205	fFirstEMCALCluster=-1;
	206	fPHOSClusters=0;
	207	fFirstPHOSCluster=-1;
af885e0f	208	if (fESDFMD) fESDFMD->Clear();
	209	// fEMCALTriggerPosition->Clear();
	210	// fEMCALTriggerAmplitudes->Clear();
	211	// fPHOSTriggerPosition->Clear();
	212	// fPHOSTriggerAmplitudes->Clear();
	213	fErrorLogs.Clear();
bf25155c	214	}
af7ba10c	215
7f68891d	216	Bool_t AliESD::RemoveTrack(Int_t rm) {
d64bd07d	217	// ---------------------------------------------------------
7f68891d	218	// Remove a track and references to it from ESD,
7f68891d	219	// if this track does not come from a reconstructed decay
d64bd07d	220	// ---------------------------------------------------------
7f68891d	221	Int_t last=GetNumberOfTracks()-1;
	222	if ((rm<0)\|\|(rm>last)) return kFALSE;
	223
	224	Int_t used=0;
d64bd07d	225
d64bd07d	226	// Check if this track comes from a reconstructed decay
7f68891d	227	Int_t nv0=GetNumberOfV0s();
	228	for (Int_t n=0; n<nv0; n++) {
	229	AliESDv0 *v0=GetV0(n);
	230
	231	Int_t idx=v0->GetNindex();
	232	if (rm==idx) return kFALSE;
	233	if (idx==last) used++;
	234
	235	idx=v0->GetPindex();
	236	if (rm==idx) return kFALSE;
	237	if (idx==last) used++;
	238	}
d64bd07d	239
7f68891d	240	Int_t ncs=GetNumberOfCascades();
	241	for (Int_t n=0; n<ncs; n++) {
	242	AliESDcascade *cs=GetCascade(n);
d64bd07d	243
7f68891d	244	Int_t idx=cs->GetIndex();
	245	if (rm==idx) return kFALSE;
	246	if (idx==last) used++;
	247	}
	248
	249	Int_t nkn=GetNumberOfKinks();
	250	for (Int_t n=0; n<nkn; n++) {
	251	AliESDkink *kn=GetKink(n);
d64bd07d	252
7f68891d	253	Int_t idx=kn->GetIndex(0);
	254	if (rm==idx) return kFALSE;
	255	if (idx==last) used++;
	256
	257	idx=kn->GetIndex(1);
	258	if (rm==idx) return kFALSE;
	259	if (idx==last) used++;
	260	}
	261
	262
	263	//Replace the removed track with the last track
	264	TClonesArray &a=fTracks;
	265	delete a.RemoveAt(rm);
	266
	267	if (rm==last) return kTRUE;
	268
	269	AliESDtrack *t=GetTrack(last);
	270	t->SetID(rm);
	271	new (a[rm]) AliESDtrack(*t);
	272	delete a.RemoveAt(last);
	273
	274	if (!used) return kTRUE;
	275
	276
	277	// Remap the indices of the daughters of reconstructed decays
	278	for (Int_t n=0; n<nv0; n++) {
	279	AliESDv0 *v0=GetV0(n);
	280	if (v0->GetIndex(0)==last) {
	281	v0->SetIndex(0,rm);
	282	used--;
	283	if (!used) return kTRUE;
	284	}
	285	if (v0->GetIndex(1)==last) {
	286	v0->SetIndex(1,rm);
	287	used--;
	288	if (!used) return kTRUE;
	289	}
	290	}
	291
	292	for (Int_t n=0; n<ncs; n++) {
	293	AliESDcascade *cs=GetCascade(n);
	294	if (cs->GetIndex()==last) {
	295	cs->SetIndex(rm);
	296	used--;
	297	if (!used) return kTRUE;
	298	}
	299	}
	300
	301	for (Int_t n=0; n<nkn; n++) {
	302	AliESDkink *kn=GetKink(n);
	303	if (kn->GetIndex(0)==last) {
	304	kn->SetIndex(rm,0);
	305	used--;
	306	if (!used) return kTRUE;
	307	}
	308	if (kn->GetIndex(1)==last) {
	309	kn->SetIndex(rm,1);
	310	used--;
	311	if (!used) return kTRUE;
	312	}
	313	}
d64bd07d	314
	315	return kTRUE;
	316	}
	317
7f68891d	318	Bool_t AliESD::Clean(Float_t *cleanPars) {
	319	//
	320	// Remove the data which are not needed for the physics analysis.
	321	//
	322	// If track's transverse parameter is larger than dmax
	323	// OR
	324	// track's longitudinal parameter is larger than zmax
	325	// an attempt to remove this track from ESD is made.
	326	//
	327	// The track gets removed if it does not come
	328	// from a reconstructed decay
	329	//
	330
	331	Float_t dmax=cleanPars[0], zmax=cleanPars[1];
	332
	333	const AliESDVertex *vertex=GetVertex();
	334	Bool_t vtxOK=vertex->GetStatus(), rc=kFALSE;
	335
	336	Int_t nTracks=GetNumberOfTracks();
	337	for (Int_t i=nTracks-1; i>=0; i--) {
	338	AliESDtrack *track=GetTrack(i);
	339	Float_t xy,z; track->GetImpactParameters(xy,z);
	340	if ((TMath::Abs(xy) > dmax) \|\| (vtxOK && (TMath::Abs(z) > zmax))) {
	341	if (RemoveTrack(i)) rc=kTRUE;
	342	}
	343	}
	344
	345	return rc;
	346	}
	347
d6a49f20	348	Int_t AliESD::AddV0(const AliESDv0 *v) {
	349	//
	350	// Add V0
	351	//
af885e0f	352	Int_t idx=fV0s.GetEntriesFast();
	353	new(fV0s[idx]) AliESDv0(*v);
	354	return idx;
d6a49f20	355	}
d6a49f20	356
af7ba10c	357	//______________________________________________________________________________
	358	void AliESD::Print(Option_t *) const
	359	{
	360	//
	361	// Print header information of the event
	362	//
5f7789fc	363	printf("ESD run information\n");
4d422cad	364	printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
31fd97b2	365	GetEventNumberInFile(),
	366	GetBunchCrossNumber(),
	367	GetOrbitNumber(),
4d422cad	368	GetPeriodNumber(),
ef278eae	369	GetRunNumber(),
b647652d	370	GetTriggerMask(),
ef278eae	371	GetMagneticField() );
af885e0f	372	printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
	373	fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
	374	fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
	375	fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
9f57c1aa	376	printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
9f57c1aa	377	GetDiamondX(),GetDiamondY());
32e449be	378	printf("SPD Multiplicity. Number of tracklets %d \n",
af885e0f	379	fSPDMult.GetNumberOfTracklets());
af885e0f	380	printf("Event from reconstruction version %d \n",fRecoVersion);
ef278eae	381	printf("Number of tracks: \n");
85c60a8e	382	printf(" charged %d\n", GetNumberOfTracks());
af885e0f	383	printf(" hlt CF %d\n", GetNumberOfHLTConfMapTracks());
af885e0f	384	printf(" hlt HT %d\n", GetNumberOfHLTHoughTracks());
ef278eae	385	printf(" muon %d\n", GetNumberOfMuonTracks());
a2882fb4	386	printf(" pmd %d\n", GetNumberOfPmdTracks());
0ee00e25	387	printf(" trd %d\n", GetNumberOfTrdTracks());
ef278eae	388	printf(" v0 %d\n", GetNumberOfV0s());
667ee8bf	389	printf(" cascades %d\n", GetNumberOfCascades());
667ee8bf	390	printf(" kinks %d\n", GetNumberOfKinks());
667ee8bf	391	printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
	392	printf(" phos %d\n", GetNumberOfPHOSClusters());
	393	printf(" emcal %d\n", GetNumberOfEMCALClusters());
	394	printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
dd735cf0	395	printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
ef278eae	396	}
d75007f6	397
	398	void AliESD::SetESDfriend(const AliESDfriend *ev) {
	399	//
	400	// Attaches the complementary info to the ESD
	401	//
	402	if (!ev) return;
	403
	404	Int_t ntrk=ev->GetNumberOfTracks();
af885e0f	405
d75007f6	406	for (Int_t i=0; i<ntrk; i++) {
	407	const AliESDfriendTrack *f=ev->GetTrack(i);
	408	GetTrack(i)->SetFriendTrack(f);
	409	}
	410	}
	411
	412	void AliESD::GetESDfriend(AliESDfriend *ev) const {
	413	//
	414	// Extracts the complementary info from the ESD
	415	//
	416	if (!ev) return;
	417
	418	Int_t ntrk=GetNumberOfTracks();
	419
	420	for (Int_t i=0; i<ntrk; i++) {
80799a5f	421	AliESDtrack *t=GetTrack(i);
d75007f6	422	const AliESDfriendTrack *f=t->GetFriendTrack();
d75007f6	423	ev->AddTrack(f);
80799a5f	424
	425	t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
	426
d75007f6	427	}
d75007f6	428	}