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