STEER/AliESD.cxx

   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   fEventNumber(0),
  33   fRunNumber(0),
  34   fTriggerMask(0),
  35   fTriggerCluster(0),
  36   fRecoVersion(0),
  37   fMagneticField(0),
  38   fZDCN1Energy(0),
  39   fZDCP1Energy(0),
  40   fZDCN2Energy(0),
  41   fZDCP2Energy(0),
  42   fZDCEMEnergy(0),
  43   fZDCParticipants(0),
  44   fT0zVertex(0),
  45   fSPDVertex(),
  46   fPrimaryVertex(),
  47   fSPDMult(),
  48   fT0timeStart(0),
  49   fTracks("AliESDtrack",15000),
  50   fHLTConfMapTracks("AliESDHLTtrack",25000),
  51   fHLTHoughTracks("AliESDHLTtrack",15000),
  52   fMuonTracks("AliESDMuonTrack",30),
  53   fPmdTracks("AliESDPmdTrack",3000),
  54   fTrdTracks("AliESDTrdTrack",300),
  55   fV0s("AliESDv0",200),
  56   fCascades("AliESDcascade",20),
  57   fKinks("AliESDkink",4000),
  58   fCaloClusters("AliESDCaloCluster",10000),
  59   fEMCALClusters(0),
  60   fFirstEMCALCluster(-1),
  61   fPHOSClusters(0),
  62   fFirstPHOSCluster(-1),
  63   fESDFMD(0x0)
  64 {
  65   for (Int_t i=0; i<24; i++) {
  66     fT0time[i] = 0;
  67     fT0amplitude[i] = 0;
  68   }
  69 }
  70 //______________________________________________________________________________
  71 AliESD::AliESD(const AliESD& esd):
  72   TObject(esd),
  73   fEventNumber(esd.fEventNumber),
  74   fRunNumber(esd.fRunNumber),
  75   fTriggerMask(esd.fTriggerMask),
  76   fTriggerCluster(esd.fTriggerCluster),
  77   fRecoVersion(esd.fRecoVersion),
  78   fMagneticField(esd.fMagneticField),
  79   fZDCN1Energy(esd.fZDCN1Energy),
  80   fZDCP1Energy(esd.fZDCP1Energy),
  81   fZDCN2Energy(esd.fZDCN2Energy),
  82   fZDCP2Energy(esd.fZDCP2Energy),
  83   fZDCEMEnergy(esd.fZDCEMEnergy),
  84   fZDCParticipants(esd.fZDCParticipants),
  85   fT0zVertex(esd.fT0zVertex),
  86   fSPDVertex(esd.fSPDVertex),
  87   fPrimaryVertex(esd.fPrimaryVertex),
  88   fSPDMult(esd.fSPDMult),
  89   fT0timeStart(esd.fT0timeStart),
  90   fTracks(*((TClonesArray*)esd.fTracks.Clone())),
  91   fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
  92   fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
  93   fMuonTracks(*((TClonesArray*)esd.fMuonTracks.Clone())),
  94   fPmdTracks(*((TClonesArray*)esd.fPmdTracks.Clone())),
  95   fTrdTracks(*((TClonesArray*)esd.fTrdTracks.Clone())),
  96   fV0s(*((TClonesArray*)esd.fV0s.Clone())),
  97   fCascades(*((TClonesArray*)esd.fCascades.Clone())),
  98   fKinks(*((TClonesArray*)esd.fKinks.Clone())),
  99   fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())),
 100   fEMCALClusters(esd.fEMCALClusters),
 101   fFirstEMCALCluster(esd.fFirstEMCALCluster),
 102   fPHOSClusters(esd.fPHOSClusters),
 103   fFirstPHOSCluster(esd.fFirstPHOSCluster),
 104   fESDFMD(esd.fESDFMD)
 105 {
 106   for (Int_t i=0; i<24; i++) {
 107     fT0time[i] = esd.fT0time[i];
 108     fT0amplitude[i] = esd.fT0amplitude[i];
 109   }
 110 }
 111
 112 //______________________________________________________________________________
 113 AliESD & AliESD::operator=(const AliESD& source) {
 114
 115   // Assignment operator
 116
 117   if(&source == this) return *this;
 118
 119   fEventNumber = source.fEventNumber;
 120   fRunNumber = source.fRunNumber;
 121   fTriggerMask = source.fTriggerMask;
 122   fTriggerCluster = source.fTriggerCluster;
 123   fRecoVersion = source.fRecoVersion;
 124   fMagneticField = source.fMagneticField;
 125   fZDCN1Energy = source.fZDCN1Energy;
 126   fZDCP1Energy = source.fZDCP1Energy;
 127   fZDCN2Energy = source.fZDCN2Energy;
 128   fZDCP2Energy = source.fZDCP2Energy;
 129   fZDCEMEnergy = source.fZDCEMEnergy;
 130   fZDCParticipants = source.fZDCParticipants;
 131   fT0zVertex = source.fT0zVertex;
 132   fSPDVertex = source.fSPDVertex;
 133   fPrimaryVertex = source.fPrimaryVertex;
 134   fSPDMult = source.fSPDMult;
 135   fT0timeStart = source.fT0timeStart;
 136   fTracks = *((TClonesArray*)source.fTracks.Clone());
 137   fHLTConfMapTracks = *((TClonesArray*)source.fHLTConfMapTracks.Clone());
 138   fHLTHoughTracks = *((TClonesArray*)source.fHLTHoughTracks.Clone());
 139   fMuonTracks = *((TClonesArray*)source.fMuonTracks.Clone());
 140   fPmdTracks = *((TClonesArray*)source.fPmdTracks.Clone());
 141   fTrdTracks = *((TClonesArray*)source.fTrdTracks.Clone());
 142   fV0s = *((TClonesArray*)source.fV0s.Clone());
 143   fCascades = *((TClonesArray*)source.fCascades.Clone());
 144   fKinks = *((TClonesArray*)source.fKinks.Clone());
 145   fCaloClusters = *((TClonesArray*)source.fCaloClusters.Clone());
 146   fEMCALClusters = source.fEMCALClusters;
 147   fFirstEMCALCluster = source.fFirstEMCALCluster;
 148   fPHOSClusters = source.fPHOSClusters;
 149   fFirstPHOSCluster = source.fFirstPHOSCluster;
 150   fESDFMD = source.fESDFMD;
 151
 152   for (Int_t i=0; i<24; i++) {
 153     fT0time[i] = source.fT0time[i];
 154     fT0amplitude[i] = source.fT0amplitude[i];
 155   }
 156
 157   return *this;
 158
 159 }
 160
 161
 162 //______________________________________________________________________________
 163 AliESD::~AliESD()
 164 {
 165   //
 166   // Standard destructor
 167   //
 168   fTracks.Delete();
 169   fHLTConfMapTracks.Delete();
 170   fHLTHoughTracks.Delete();
 171   fMuonTracks.Delete();
 172   fPmdTracks.Delete();
 173   fTrdTracks.Delete();
 174   fV0s.Delete();
 175   fCascades.Delete();
 176   fKinks.Delete();
 177   fCaloClusters.Delete();
 178   delete fESDFMD;
 179 }
 180
 181 //______________________________________________________________________________
 182 void AliESD::Reset()
 183 {
 184   fEventNumber=0;
 185   fRunNumber=0;
 186   fTriggerMask=0;
 187   fTriggerCluster=0;
 188   fRecoVersion=0;
 189   fMagneticField=0;
 190   fZDCN1Energy=0;
 191   fZDCP1Energy=0;
 192   fZDCN2Energy=0;
 193   fZDCP2Energy=0;
 194   fZDCEMEnergy=0;
 195   fZDCParticipants=0;
 196   fT0zVertex=0;
 197   fT0timeStart = 0;
 198   new (&fSPDVertex) AliESDVertex();
 199   new (&fPrimaryVertex) AliESDVertex();
 200   new (&fSPDMult) AliMultiplicity();
 201   fTracks.Clear();
 202   fHLTConfMapTracks.Clear();
 203   fHLTHoughTracks.Clear();
 204   fMuonTracks.Clear();
 205   fPmdTracks.Clear();
 206   fTrdTracks.Clear();
 207   fV0s.Clear();
 208   fCascades.Clear();
 209   fCaloClusters.Clear();
 210   fEMCALClusters=0;
 211   fFirstEMCALCluster=-1;
 212   fPHOSClusters=0;
 213   fFirstPHOSCluster=-1;
 214   if (fESDFMD) fESDFMD->Clear();
 215 }
 216
 217 Int_t AliESD::AddV0(const AliESDv0 *v) {
 218   //
 219   // Add V0
 220   //
 221     Int_t idx=fV0s.GetEntriesFast();
 222     AliESDv0 *v0=new(fV0s[idx]) AliESDv0(*v);
 223     v0->SetID(idx);
 224     return idx;
 225 }
 226
 227 //______________________________________________________________________________
 228 void AliESD::Print(Option_t *) const
 229 {
 230   //
 231   // Print header information of the event
 232   //
 233   printf("ESD run information\n");
 234   printf("Event # %d Run # %d Trigger %lld Magnetic field %f \n",
 235          GetEventNumber(),
 236          GetRunNumber(),
 237          GetTriggerMask(),
 238          GetMagneticField() );
 239     printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
 240            fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
 241            fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
 242            fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
 243     printf("SPD Multiplicity. Number of tracklets %d \n",
 244            fSPDMult.GetNumberOfTracklets());
 245   printf("Event from reconstruction version %d \n",fRecoVersion);
 246   printf("Number of tracks: \n");
 247   printf("                 charged   %d\n", GetNumberOfTracks());
 248   printf("                 hlt CF    %d\n", GetNumberOfHLTConfMapTracks());
 249   printf("                 hlt HT    %d\n", GetNumberOfHLTHoughTracks());
 250   printf("                 muon      %d\n", GetNumberOfMuonTracks());
 251   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
 252   printf("                 trd       %d\n", GetNumberOfTrdTracks());
 253   printf("                 v0        %d\n", GetNumberOfV0s());
 254   printf("                 cascades  %d\n", GetNumberOfCascades());
 255   printf("                 kinks     %d\n", GetNumberOfKinks());
 256   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
 257   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
 258   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
 259   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
 260 }
 261
 262 void AliESD::SetESDfriend(const AliESDfriend *ev) {
 263   //
 264   // Attaches the complementary info to the ESD
 265   //
 266   if (!ev) return;
 267
 268   Int_t ntrk=ev->GetNumberOfTracks();
 269
 270   for (Int_t i=0; i<ntrk; i++) {
 271     const AliESDfriendTrack *f=ev->GetTrack(i);
 272     GetTrack(i)->SetFriendTrack(f);
 273   }
 274 }
 275
 276 void AliESD::GetESDfriend(AliESDfriend *ev) const {
 277   //
 278   // Extracts the complementary info from the ESD
 279   //
 280   if (!ev) return;
 281
 282   Int_t ntrk=GetNumberOfTracks();
 283
 284   for (Int_t i=0; i<ntrk; i++) {
 285     const AliESDtrack *t=GetTrack(i);
 286     const AliESDfriendTrack *f=t->GetFriendTrack();
 287     ev->AddTrack(f);
 288   }
 289 }