[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::RemoveKink(Int_t rm) {
  // ---------------------------------------------------------
  // Remove a kink candidate and references to it from ESD,
  // if this candidate does not come from a reconstructed decay
  // Not yet implemented...
  // ---------------------------------------------------------
  Int_t last=GetNumberOfKinks()-1;
  if ((rm<0)||(rm>last)) return kFALSE;

  return kTRUE;
}

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

  AliESDv0 *v0=GetV0(rm);
  Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();

  v0=GetV0(last);
  Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();

  Int_t used=0;

  // Check if this V0 comes from a reconstructed decay
  Int_t ncs=GetNumberOfCascades();
  for (Int_t n=0; n<ncs; n++) {
    AliESDcascade *cs=GetCascade(n);

    Int_t csIdxP=cs->GetPindex();
    Int_t csIdxN=cs->GetNindex();

    if (idxP==csIdxP)
       if (idxN==csIdxN) return kFALSE;

    if (csIdxP==lastIdxP)
       if (csIdxN==lastIdxN) used++;
  }

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

  if (rm==last) return kTRUE;

  //v0 is pointing to the last V0 candidate... 
  new (a[rm]) AliESDv0(*v0);
  delete a.RemoveAt(last);

  if (!used) return kTRUE;
  

  // Remap the indices of the daughters of reconstructed decays
  for (Int_t n=0; n<ncs; n++) {
    AliESDcascade *cs=GetCascade(n);


    Int_t csIdxP=cs->GetPindex();
    Int_t csIdxN=cs->GetNindex();

    if (csIdxP==lastIdxP)
      if (csIdxN==lastIdxN) {
         cs->AliESDv0::SetIndex(1,idxP);
         cs->AliESDv0::SetIndex(0,idxN);
         used--;
         if (!used) return kTRUE;
      }
  }

  return kTRUE;
}

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.
  //
  // 1) Cleaning the V0 candidates
  //    ---------------------------
  //    If the cosine of the V0 pointing angle "csp" and 
  //    the DCA between the daughter tracks "dca" does not satisfy 
  //    the conditions 
  //
  //     csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
  //
  //    an attempt to remove this V0 candidate from ESD is made.
  //
  //    The V0 candidate gets removed if it does not belong to any 
  //    recosntructed cascade decay
  //
  //    12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
  //
  // 2) Cleaning the tracks
  //    ----------------------
  //    If track's transverse parameter is larger than cleanPars[2]
  //                       OR
  //    track's longitudinal parameter is larger than cleanPars[3]
  //    an attempt to remove this track from ESD is made.
  //
  //    The track gets removed if it does not come 
  //    from a reconstructed decay
  //
  Bool_t rc=kFALSE;

  Float_t dcaMax=cleanPars[0];
  Float_t cspMin=cleanPars[1];

  Int_t nV0s=GetNumberOfV0s();
  for (Int_t i=nV0s-1; i>=0; i--) {
    AliESDv0 *v0=GetV0(i);

    Float_t dca=v0->GetDcaV0Daughters();
    Float_t csp=v0->GetV0CosineOfPointingAngle();
    Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
    if (csp > cspcut) continue;

    if (RemoveV0(i)) rc=kTRUE;
  }


  Float_t dmax=cleanPars[2], zmax=cleanPars[3];

  const AliESDVertex *vertex=GetVertex();
  Bool_t vtxOK=vertex->GetStatus();
  
  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
a023d8d8	216
	217	Bool_t AliESD::RemoveKink(Int_t rm) {
	218	// ---------------------------------------------------------
	219	// Remove a kink candidate and references to it from ESD,
	220	// if this candidate does not come from a reconstructed decay
	221	// Not yet implemented...
	222	// ---------------------------------------------------------
	223	Int_t last=GetNumberOfKinks()-1;
	224	if ((rm<0)\|\|(rm>last)) return kFALSE;
	225
	226	return kTRUE;
	227	}
	228
	229	Bool_t AliESD::RemoveV0(Int_t rm) {
	230	// ---------------------------------------------------------
	231	// Remove a V0 candidate and references to it from ESD,
	232	// if this candidate does not come from a reconstructed decay
	233	// ---------------------------------------------------------
	234	Int_t last=GetNumberOfV0s()-1;
	235	if ((rm<0)\|\|(rm>last)) return kFALSE;
	236
	237	AliESDv0 *v0=GetV0(rm);
	238	Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();
	239
	240	v0=GetV0(last);
	241	Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();
	242
	243	Int_t used=0;
	244
	245	// Check if this V0 comes from a reconstructed decay
	246	Int_t ncs=GetNumberOfCascades();
	247	for (Int_t n=0; n<ncs; n++) {
	248	AliESDcascade *cs=GetCascade(n);
	249
	250	Int_t csIdxP=cs->GetPindex();
	251	Int_t csIdxN=cs->GetNindex();
	252
	253	if (idxP==csIdxP)
	254	if (idxN==csIdxN) return kFALSE;
	255
	256	if (csIdxP==lastIdxP)
	257	if (csIdxN==lastIdxN) used++;
	258	}
	259
	260	//Replace the removed V0 with the last V0
	261	TClonesArray &a=fV0s;
	262	delete a.RemoveAt(rm);
	263
	264	if (rm==last) return kTRUE;
	265
	266	//v0 is pointing to the last V0 candidate...
	267	new (a[rm]) AliESDv0(*v0);
	268	delete a.RemoveAt(last);
	269
	270	if (!used) return kTRUE;
	271
	272
	273	// Remap the indices of the daughters of reconstructed decays
	274	for (Int_t n=0; n<ncs; n++) {
	275	AliESDcascade *cs=GetCascade(n);
	276
	277
	278	Int_t csIdxP=cs->GetPindex();
	279	Int_t csIdxN=cs->GetNindex();
280
281	if (csIdxP==lastIdxP)
282	if (csIdxN==lastIdxN) {
283	cs->AliESDv0::SetIndex(1,idxP);
284	cs->AliESDv0::SetIndex(0,idxN);
285	used--;
286	if (!used) return kTRUE;
287	}
288	}
289
290	return kTRUE;
291	}
292
7f68891d	293	Bool_t AliESD::RemoveTrack(Int_t rm) {
d64bd07d	294	// ---------------------------------------------------------
7f68891d	295	// Remove a track and references to it from ESD,
7f68891d	296	// if this track does not come from a reconstructed decay
d64bd07d	297	// ---------------------------------------------------------
7f68891d	298	Int_t last=GetNumberOfTracks()-1;
	299	if ((rm<0)\|\|(rm>last)) return kFALSE;
	300
	301	Int_t used=0;
d64bd07d	302
d64bd07d	303	// Check if this track comes from a reconstructed decay
7f68891d	304	Int_t nv0=GetNumberOfV0s();
	305	for (Int_t n=0; n<nv0; n++) {
	306	AliESDv0 *v0=GetV0(n);
	307
	308	Int_t idx=v0->GetNindex();
	309	if (rm==idx) return kFALSE;
	310	if (idx==last) used++;
	311
	312	idx=v0->GetPindex();
	313	if (rm==idx) return kFALSE;
	314	if (idx==last) used++;
	315	}
d64bd07d	316
7f68891d	317	Int_t ncs=GetNumberOfCascades();
	318	for (Int_t n=0; n<ncs; n++) {
	319	AliESDcascade *cs=GetCascade(n);
d64bd07d	320
7f68891d	321	Int_t idx=cs->GetIndex();
	322	if (rm==idx) return kFALSE;
	323	if (idx==last) used++;
	324	}
	325
	326	Int_t nkn=GetNumberOfKinks();
	327	for (Int_t n=0; n<nkn; n++) {
	328	AliESDkink *kn=GetKink(n);
d64bd07d	329
7f68891d	330	Int_t idx=kn->GetIndex(0);
	331	if (rm==idx) return kFALSE;
	332	if (idx==last) used++;
	333
	334	idx=kn->GetIndex(1);
	335	if (rm==idx) return kFALSE;
	336	if (idx==last) used++;
	337	}
	338
	339
	340	//Replace the removed track with the last track
	341	TClonesArray &a=fTracks;
	342	delete a.RemoveAt(rm);
	343
	344	if (rm==last) return kTRUE;
	345
	346	AliESDtrack *t=GetTrack(last);
	347	t->SetID(rm);
	348	new (a[rm]) AliESDtrack(*t);
	349	delete a.RemoveAt(last);
	350
	351	if (!used) return kTRUE;
7f68891d	352
a023d8d8	353
7f68891d	354	// Remap the indices of the daughters of reconstructed decays
	355	for (Int_t n=0; n<nv0; n++) {
	356	AliESDv0 *v0=GetV0(n);
	357	if (v0->GetIndex(0)==last) {
	358	v0->SetIndex(0,rm);
	359	used--;
	360	if (!used) return kTRUE;
	361	}
	362	if (v0->GetIndex(1)==last) {
	363	v0->SetIndex(1,rm);
	364	used--;
	365	if (!used) return kTRUE;
	366	}
	367	}
	368
	369	for (Int_t n=0; n<ncs; n++) {
	370	AliESDcascade *cs=GetCascade(n);
	371	if (cs->GetIndex()==last) {
	372	cs->SetIndex(rm);
	373	used--;
	374	if (!used) return kTRUE;
	375	}
	376	}
	377
	378	for (Int_t n=0; n<nkn; n++) {
	379	AliESDkink *kn=GetKink(n);
	380	if (kn->GetIndex(0)==last) {
	381	kn->SetIndex(rm,0);
	382	used--;
	383	if (!used) return kTRUE;
	384	}
	385	if (kn->GetIndex(1)==last) {
	386	kn->SetIndex(rm,1);
	387	used--;
	388	if (!used) return kTRUE;
	389	}
	390	}
d64bd07d	391
	392	return kTRUE;
	393	}
	394
a023d8d8	395
7f68891d	396	Bool_t AliESD::Clean(Float_t *cleanPars) {
	397	//
	398	// Remove the data which are not needed for the physics analysis.
	399	//
a023d8d8	400	// 1) Cleaning the V0 candidates
	401	// ---------------------------
	402	// If the cosine of the V0 pointing angle "csp" and
	403	// the DCA between the daughter tracks "dca" does not satisfy
	404	// the conditions
	405	//
	406	// csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
	407	//
	408	// an attempt to remove this V0 candidate from ESD is made.
	409	//
	410	// The V0 candidate gets removed if it does not belong to any
	411	// recosntructed cascade decay
	412	//
	413	// 12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
	414	//
	415	// 2) Cleaning the tracks
	416	// ----------------------
	417	// If track's transverse parameter is larger than cleanPars[2]
7f68891d	418	// OR
a023d8d8	419	// track's longitudinal parameter is larger than cleanPars[3]
a023d8d8	420	// an attempt to remove this track from ESD is made.
7f68891d	421	//
a023d8d8	422	// The track gets removed if it does not come
a023d8d8	423	// from a reconstructed decay
7f68891d	424	//
a023d8d8	425	Bool_t rc=kFALSE;
	426
	427	Float_t dcaMax=cleanPars[0];
	428	Float_t cspMin=cleanPars[1];
	429
	430	Int_t nV0s=GetNumberOfV0s();
	431	for (Int_t i=nV0s-1; i>=0; i--) {
	432	AliESDv0 *v0=GetV0(i);
	433
	434	Float_t dca=v0->GetDcaV0Daughters();
	435	Float_t csp=v0->GetV0CosineOfPointingAngle();
	436	Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
	437	if (csp > cspcut) continue;
	438
	439	if (RemoveV0(i)) rc=kTRUE;
	440	}
	441
7f68891d	442
a023d8d8	443	Float_t dmax=cleanPars[2], zmax=cleanPars[3];
7f68891d	444
7f68891d	445	const AliESDVertex *vertex=GetVertex();
a023d8d8	446	Bool_t vtxOK=vertex->GetStatus();
7f68891d	447
	448	Int_t nTracks=GetNumberOfTracks();
	449	for (Int_t i=nTracks-1; i>=0; i--) {
	450	AliESDtrack *track=GetTrack(i);
	451	Float_t xy,z; track->GetImpactParameters(xy,z);
	452	if ((TMath::Abs(xy) > dmax) \|\| (vtxOK && (TMath::Abs(z) > zmax))) {
	453	if (RemoveTrack(i)) rc=kTRUE;
	454	}
	455	}
	456
	457	return rc;
	458	}
	459
d6a49f20	460	Int_t AliESD::AddV0(const AliESDv0 *v) {
	461	//
	462	// Add V0
	463	//
af885e0f	464	Int_t idx=fV0s.GetEntriesFast();
	465	new(fV0s[idx]) AliESDv0(*v);
	466	return idx;
d6a49f20	467	}
d6a49f20	468
af7ba10c	469	//______________________________________________________________________________
	470	void AliESD::Print(Option_t *) const
	471	{
	472	//
	473	// Print header information of the event
	474	//
5f7789fc	475	printf("ESD run information\n");
4d422cad	476	printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
31fd97b2	477	GetEventNumberInFile(),
	478	GetBunchCrossNumber(),
	479	GetOrbitNumber(),
4d422cad	480	GetPeriodNumber(),
ef278eae	481	GetRunNumber(),
b647652d	482	GetTriggerMask(),
ef278eae	483	GetMagneticField() );
af885e0f	484	printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
	485	fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
	486	fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
	487	fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
9f57c1aa	488	printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
9f57c1aa	489	GetDiamondX(),GetDiamondY());
32e449be	490	printf("SPD Multiplicity. Number of tracklets %d \n",
af885e0f	491	fSPDMult.GetNumberOfTracklets());
af885e0f	492	printf("Event from reconstruction version %d \n",fRecoVersion);
ef278eae	493	printf("Number of tracks: \n");
85c60a8e	494	printf(" charged %d\n", GetNumberOfTracks());
af885e0f	495	printf(" hlt CF %d\n", GetNumberOfHLTConfMapTracks());
af885e0f	496	printf(" hlt HT %d\n", GetNumberOfHLTHoughTracks());
ef278eae	497	printf(" muon %d\n", GetNumberOfMuonTracks());
a2882fb4	498	printf(" pmd %d\n", GetNumberOfPmdTracks());
0ee00e25	499	printf(" trd %d\n", GetNumberOfTrdTracks());
ef278eae	500	printf(" v0 %d\n", GetNumberOfV0s());
667ee8bf	501	printf(" cascades %d\n", GetNumberOfCascades());
667ee8bf	502	printf(" kinks %d\n", GetNumberOfKinks());
667ee8bf	503	printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
	504	printf(" phos %d\n", GetNumberOfPHOSClusters());
	505	printf(" emcal %d\n", GetNumberOfEMCALClusters());
	506	printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
dd735cf0	507	printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
ef278eae	508	}
d75007f6	509
	510	void AliESD::SetESDfriend(const AliESDfriend *ev) {
	511	//
	512	// Attaches the complementary info to the ESD
	513	//
	514	if (!ev) return;
	515
	516	Int_t ntrk=ev->GetNumberOfTracks();
af885e0f	517
d75007f6	518	for (Int_t i=0; i<ntrk; i++) {
	519	const AliESDfriendTrack *f=ev->GetTrack(i);
	520	GetTrack(i)->SetFriendTrack(f);
	521	}
	522	}
	523
	524	void AliESD::GetESDfriend(AliESDfriend *ev) const {
	525	//
	526	// Extracts the complementary info from the ESD
	527	//
	528	if (!ev) return;
	529
	530	Int_t ntrk=GetNumberOfTracks();
	531
	532	for (Int_t i=0; i<ntrk; i++) {
80799a5f	533	AliESDtrack *t=GetTrack(i);
d75007f6	534	const AliESDfriendTrack *f=t->GetFriendTrack();
d75007f6	535	ev->AddTrack(f);
80799a5f	536
	537	t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
	538
d75007f6	539	}
d75007f6	540	}