PWG2/RESONANCES/AliRsnEvent.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 //-------------------------------------------------------------------------
  17 //                      Class AliRsnEvent
  18 //                     -------------------
  19 //           Simple collection of reconstructed tracks
  20 //           selected from an ESD event
  21 //           to be used for analysis.
  22 //           .........................................
  23 //
  24 // author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
  25 //-------------------------------------------------------------------------
  26
  27 #include <Riostream.h>
  28
  29 #include <TString.h>
  30 #include <TObjArray.h>
  31 #include <TClonesArray.h>
  32
  33 #include "AliRsnDaughter.h"
  34 #include "AliRsnEvent.h"
  35
  36 ClassImp(AliRsnEvent)
  37
  38 //--------------------------------------------------------------------------------------------------------
  39 AliRsnEvent::AliRsnEvent() :
  40  fPVx(0.0),
  41  fPVy(0.0),
  42  fPVz(0.0),
  43  fMultiplicity(-1),
  44  fPosNoPID(0x0),
  45  fNegNoPID(0x0)
  46 {
  47 //
  48 // Default constructor
  49 //
  50         Int_t i;
  51         for (i = 0; i < AliPID::kSPECIES; i++) {
  52                 fPos[i] = NULL;
  53                 fNeg[i] = NULL;
  54         }
  55 }
  56 //--------------------------------------------------------------------------------------------------------
  57 AliRsnEvent::AliRsnEvent(const AliRsnEvent &event) :
  58  TObject((TObject)event),
  59  fPVx(event.fPVx),
  60  fPVy(event.fPVy),
  61  fPVz(event.fPVz),
  62  fMultiplicity(event.fMultiplicity),
  63  fPosNoPID(0x0),
  64  fNegNoPID(0x0)
  65 {
  66 //
  67 // Copy constructor.
  68 // Creates new instances of all collections to store a copy of all objects.
  69 //
  70         // clone tracks collections
  71         Int_t i;
  72         for (i = 0; i < AliPID::kSPECIES; i++) {
  73                 fPos[i] = 0;
  74                 fNeg[i] = 0;
  75                 if (event.fPos[i]) fPos[i] = (TClonesArray*)event.fPos[i]->Clone();
  76                 if (event.fNeg[i]) fNeg[i] = (TClonesArray*)event.fNeg[i]->Clone();
  77         }
  78         fPosNoPID = (TClonesArray*)event.fPosNoPID->Clone();
  79         fNegNoPID = (TClonesArray*)event.fNegNoPID->Clone();
  80 }
  81 //--------------------------------------------------------------------------------------------------------
  82 AliRsnEvent& AliRsnEvent::operator=(const AliRsnEvent &event)
  83 {
  84 //
  85 // Assignment operator.
  86 // Creates new instances of all collections to store a copy of all objects.
  87 //
  88         fPVx = event.fPVx;
  89         fPVy = event.fPVy;
  90         fPVz = event.fPVz;
  91         fMultiplicity = event.fMultiplicity;
  92
  93         // clone tracks collections
  94         Int_t i;
  95         for (i = 0; i < AliPID::kSPECIES; i++) {
  96                 fPos[i] = 0;
  97                 fNeg[i] = 0;
  98                 if (event.fPos[i]) fPos[i] = (TClonesArray*)event.fPos[i]->Clone();
  99                 if (event.fNeg[i]) fNeg[i] = (TClonesArray*)event.fNeg[i]->Clone();
 100         }
 101         fPosNoPID = (TClonesArray*)event.fPosNoPID->Clone();
 102         fNegNoPID = (TClonesArray*)event.fNegNoPID->Clone();
 103
 104         return (*this);
 105 }
 106 //--------------------------------------------------------------------------------------------------------
 107 void AliRsnEvent::AddTrack(AliRsnDaughter track)
 108 {
 109 //
 110 // Stores a track into the correct array
 111 //
 112         // if sign is zero, track is not stored
 113         Char_t sign = track.GetSign();
 114         if (!sign) return;
 115
 116         // if PDG code is assigned, track is stored in the corresponding collection
 117         // otherwise, it is stored in the array of unidentified particles with that sign
 118         Int_t index, iarray, pdg = track.GetPDG();
 119         if (pdg != 0) {
 120                 iarray = PDG2Enum(pdg);
 121                 if (iarray < AliPID::kElectron || iarray > AliPID::kProton) return;
 122                 TClonesArray &array = (sign > 0) ? *fPos[iarray] : *fNeg[iarray];
 123                 index = array.GetEntries();
 124                 new(array[index]) AliRsnDaughter(track);
 125         }
 126         else {
 127                 TClonesArray &array = (sign > 0) ? *fPosNoPID : *fNegNoPID;
 128                 index = array.GetEntries();
 129                 new(array[index]) AliRsnDaughter(track);
 130         }
 131 }
 132 //--------------------------------------------------------------------------------------------------------
 133 void AliRsnEvent::Clear(Option_t *option)
 134 {
 135 //
 136 // Clears list of tracks and references.
 137 // If the string "DELETE" is specified, the collection classes
 138 // are also cleared from heap.
 139 //
 140         // evaluate option
 141         TString opt(option);
 142         Bool_t deleteCollections = opt.Contains("DELETE", TString::kIgnoreCase);
 143
 144         Int_t i;
 145         for (i = 0; i < AliPID::kSPECIES; i++) {
 146                 if (fPos[i]) fPos[i]->Delete();
 147                 if (fNeg[i]) fNeg[i]->Delete();
 148                 if (deleteCollections) {
 149                         delete fPos[i];
 150                         delete fNeg[i];
 151                         fPos[i] = 0;
 152                         fNeg[i] = 0;
 153                 }
 154         }
 155         if (fPosNoPID) fPosNoPID->Delete();
 156         if (fNegNoPID) fNegNoPID->Delete();
 157         if (deleteCollections) {
 158                 delete fPosNoPID;
 159                 delete fNegNoPID;
 160                 fPosNoPID = 0;
 161                 fNegNoPID = 0;
 162         }
 163 }
 164 //--------------------------------------------------------------------------------------------------------
 165 void AliRsnEvent::ComputeMultiplicity()
 166 {
 167 //
 168 // Computes multiplicity.
 169 //
 170         fMultiplicity = 0;
 171         Int_t i;
 172         for (i = 0; i < AliPID::kSPECIES; i++) {
 173                 fMultiplicity += (Int_t)fPos[i]->GetEntries();
 174                 fMultiplicity += (Int_t)fNeg[i]->GetEntries();
 175         }
 176         if (fPosNoPID) fMultiplicity += fPosNoPID->GetEntries();
 177         if (fNegNoPID) fMultiplicity += fNegNoPID->GetEntries();
 178 }
 179 //--------------------------------------------------------------------------------------------------------
 180 TClonesArray* AliRsnEvent::GetTracks(Char_t sign, AliPID::EParticleType type)
 181 {
 182 //
 183 // Returns the particle collection specified in argument
 184 //
 185         Int_t itype = (Int_t)type;
 186         if (itype >= 0 && itype < AliPID::kSPECIES) {
 187                 if (sign == '+') return fPos[type]; else return fNeg[type];
 188         }
 189         else if (type == AliPID::kUnknown) {
 190                 if (sign == '+') return fPosNoPID; else return fNegNoPID;
 191         }
 192         else {
 193                 return NULL;
 194         }
 195 }
 196 //--------------------------------------------------------------------------------------------------------
 197 void AliRsnEvent::Init()
 198 {
 199 //
 200 // Action 1: define default values for some data members (including pointers).
 201 // Action 2: if 'ntracks' > 0 allocates memory to store tracks.
 202 //
 203         Int_t i;
 204         for (i = 0; i < AliPID::kSPECIES; i++) {
 205                 fPos[i] = new TClonesArray("AliRsnDaughter", 0);
 206                 fNeg[i] = new TClonesArray("AliRsnDaughter", 0);
 207                 fPos[i]->BypassStreamer(kFALSE);
 208                 fNeg[i]->BypassStreamer(kFALSE);
 209         }
 210         fPosNoPID = new TClonesArray("AliRsnDaughter", 0);
 211         fNegNoPID = new TClonesArray("AliRsnDaughter", 0);
 212         fPosNoPID->BypassStreamer(kFALSE);
 213         fNegNoPID->BypassStreamer(kFALSE);
 214 }
 215 //--------------------------------------------------------------------------------------------------------
 216 Int_t AliRsnEvent::PDG2Enum(Int_t pdgcode)
 217 {
 218 //
 219 // Converts a PDG code into the correct slot in the EParticleType enumeration in AliPID
 220 //
 221         Int_t i;
 222         for (i = 0; i < AliPID::kSPECIES; i++) {
 223                 if (AliPID::ParticleCode((AliPID::EParticleType)i) == TMath::Abs(pdgcode)) {
 224                         return i;
 225                 }
 226         }
 227
 228         return -1;
 229 }
 230 //--------------------------------------------------------------------------------------------------------
 231 void AliRsnEvent::PrintTracks()
 232 {
 233 //
 234 // Print data for particles stored in this event
 235 //
 236         cout << endl;
 237
 238         AliRsnDaughter *track = 0;
 239
 240         Int_t type;
 241         for (type = 0; type < AliPID::kSPECIES; type++) {
 242                 TObjArrayIter iterPos(fPos[type]);
 243                 cout << "Positive " << AliPID::ParticleName(type) << "s" << endl;
 244                 if (!fPos[type]) cout << "NOT INITIALIZED" << endl;
 245                 while ( (track = (AliRsnDaughter*)iterPos.Next()) ) {
 246                         cout << "Index, Sign, PDG = ";
 247                         cout << track->GetIndex() << " ";
 248                         cout << (Int_t)track->GetSign() << " ";
 249                         cout << track->GetPDG() << endl;
 250                 }
 251                 TObjArrayIter iterNeg(fNeg[type]);
 252                 cout << "Negative " << AliPID::ParticleName(type) << "s" << endl;
 253                 if (!fNeg[type]) cout << "NOT INITIALIZED" << endl;
 254                 while ( (track = (AliRsnDaughter*)iterNeg.Next()) ) {
 255                         cout << "Index, Sign, PDG = ";
 256                         cout << track->GetIndex() << " ";
 257                         cout << (Int_t)track->GetSign() << " ";
 258                         cout << track->GetPDG() << endl;
 259                 }
 260         }
 261 }
 262 //--------------------------------------------------------------------------------------------------------