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