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