TOF/AliTOFSDigit.cxx

   1 //_________________________________________________________________________
   2 //  TOF digit: member variables
   3 //  fSector  : TOF sector
   4 //  fPlate   : TOF plate
   5 //  fStrip   : strips number
   6 //  fPadx    : pad number along x
   7 //  fPadz    : pad number along z
   8 //  fTdc     : TArrayF of TDC values
   9 //  fAdc     : TArrayF of ADC values
  10 //
  11 //  Getters, setters and member functions  defined here
  12 //
  13 //*-- Authors: F. Pierella, A. Seganti, D. Vicinanza
  14
  15
  16 /**************************************************************************
  17  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  18  *                                                                        *
  19  * Author: The ALICE Off-line Project.                                    *
  20  * Contributors are mentioned in the code where appropriate.              *
  21  *                                                                        *
  22  * Permission to use, copy, modify and distribute this software and its   *
  23  * documentation strictly for non-commercial purposes is hereby granted   *
  24  * without fee, provided that the above copyright notice appears in all   *
  25  * copies and that both the copyright notice and this permission notice   *
  26  * appear in the supporting documentation. The authors make no claims     *
  27  * about the suitability of this software for any purpose. It is          *
  28  * provided "as is" without express or implied warranty.                  *
  29  **************************************************************************/
  30
  31 #include <iostream.h>
  32
  33 #include "TArrayF.h"
  34 #include "TArrayI.h"
  35
  36 #include "AliTOF.h"
  37 #include "AliTOFSDigit.h"
  38 #include "AliTOFConstants.h"
  39 #include "AliRun.h"
  40 #include "AliMC.h"
  41
  42 ClassImp(AliTOFSDigit)
  43
  44 ////////////////////////////////////////////////////////////////////////
  45 AliTOFSDigit::AliTOFSDigit()
  46 {
  47 //
  48 // default ctor
  49 //
  50   fNDigits = 0;
  51   fTdc = 0;
  52   fAdc = 0;
  53   fTracks = 0;
  54 }
  55
  56 ////////////////////////////////////////////////////////////////////////
  57 AliTOFSDigit::AliTOFSDigit(Int_t tracknum, Int_t *vol,Float_t *digit)
  58 {
  59 //
  60 // Constructor of digit object
  61 //
  62   fSector = vol[0];
  63   fPlate  = vol[1];
  64   fStrip  = vol[2];
  65   fPadx   = vol[3];
  66   fPadz   = vol[4];
  67   fNDigits = 1;
  68   fTdc = new TArrayF(fNDigits);
  69   (*fTdc)[0] = digit[0];
  70   fAdc = new TArrayF(fNDigits);
  71   (*fAdc)[0] = digit[1];
  72   fTracks = new TArrayI(kMAXDIGITS*fNDigits);
  73   (*fTracks)[0] = tracknum;
  74   for (Int_t i = 1; i <kMAXDIGITS*fNDigits; i++) {
  75     (*fTracks)[i] = -1;
  76   }
  77 }
  78
  79 ////////////////////////////////////////////////////////////////////////
  80 AliTOFSDigit::AliTOFSDigit(const AliTOFSDigit & digit)
  81 {
  82   //
  83   // copy ctor for AliTOFSDigit object
  84   //
  85   fSector = digit.fSector;
  86   fPlate  = digit.fPlate;
  87   fStrip  = digit.fStrip;
  88   fPadx   = digit.fPadx;
  89   fPadz   = digit.fPadz;
  90   fNDigits = digit.fNDigits;
  91   fTdc = new TArrayF(*digit.fTdc);
  92   fAdc = new TArrayF(*digit.fAdc);
  93   fTracks = new TArrayI(*digit.fTracks);
  94 }
  95
  96 ////////////////////////////////////////////////////////////////////////
  97 AliTOFSDigit::AliTOFSDigit(Int_t sector, Int_t plate, Int_t strip, Int_t padx,
  98 Int_t padz, Float_t tdc, Float_t adc)
  99 {
 100 //
 101 // Constructor for sdigit
 102 //
 103   fSector = sector;
 104   fPlate  = plate;
 105   fStrip  = strip;
 106   fPadx   = padx;
 107   fPadz   = padz;
 108   fNDigits = 1;
 109   fTdc = new TArrayF(fNDigits);
 110   (*fTdc)[0] = tdc;
 111   fAdc = new TArrayF(fNDigits);
 112   (*fAdc)[0] = tdc;
 113 // no tracks were specified, set them to -1
 114   fTracks = new TArrayI(kMAXDIGITS*fNDigits);
 115   for (Int_t i = 0; i <kMAXDIGITS*fNDigits; i++) {
 116     (*fTracks)[i] = -1;
 117   }
 118 }
 119
 120 ////////////////////////////////////////////////////////////////////////
 121 void AliTOFSDigit::GetLocation(Int_t *Loc) const
 122 {
 123 //
 124 // Get the coordinates of the digit
 125 // in terms of Sector - Plate - Strip - Pad
 126 //
 127
 128    Loc[0]=fSector;
 129    Loc[1]=fPlate;
 130    Loc[2]=fStrip;
 131    Loc[3]=fPadx;
 132    Loc[4]=fPadz;
 133 }
 134
 135 ////////////////////////////////////////////////////////////////////////
 136 void AliTOFSDigit::Update(Int_t tdc, Int_t adc, Int_t track)
 137 {
 138 //
 139 // Add charge and track
 140 //
 141
 142   Int_t sameTime = -1;
 143
 144   for (Int_t i = 0; i < fNDigits; i++) {
 145     if (TMath::Abs(tdc-fTdc->At(i)) < AliTOFConstants::fgkTimeDiff) {
 146       sameTime = i;
 147       break;
 148     }
 149   }
 150
 151   if (sameTime >= 0) {
 152     (*fAdc)[sameTime] += static_cast<Float_t>(adc);
 153 // update track - find the first -1  value and replace it by the
 154 // track number
 155     for (Int_t iTrack=0; iTrack<kMAXDIGITS; iTrack++) {
 156       if ((*fTracks)[sameTime*kMAXDIGITS+iTrack] == -1) {
 157         (*fTracks)[sameTime*kMAXDIGITS+iTrack] = track;
 158         break;
 159       }
 160 // write warning about many tracks going to this pad
 161       if (iTrack == kMAXDIGITS) {
 162         cerr<<"WARNING: AliTOFSDigit::Update  Many hits in the padhit"<<endl;
 163         cerr<<"         ";
 164 //      PrintPad();
 165       }
 166     }
 167   } else {
 168 // add new time slot
 169     fNDigits++;
 170     fTdc->Set(fNDigits);
 171     (*fTdc)[fNDigits-1] = tdc;
 172     fAdc->Set(fNDigits);
 173     (*fAdc)[fNDigits-1] = adc;
 174     fTracks->Set(fNDigits*kMAXDIGITS);
 175     (*fTracks)[(fNDigits-1)*kMAXDIGITS] = track;
 176     for (Int_t i = 1; i <kMAXDIGITS; i++) {
 177       (*fTracks)[(fNDigits-1)*kMAXDIGITS+i] = -1;
 178     }
 179   }
 180
 181 }
 182 ////////////////////////////////////////////////////////////////////////
 183 AliTOFSDigit::~AliTOFSDigit()
 184 {
 185 //
 186 // dtor
 187 //
 188   delete fTdc;
 189   delete fAdc;
 190   delete fTracks;
 191 }
 192
 193 ////////////////////////////////////////////////////////////////////////
 194
 195 Int_t AliTOFSDigit::GetTotPad() const
 196 {
 197 //
 198 // Get the "total" index of the pad inside a Sector
 199 // starting from the digits data.
 200 //
 201
 202   AliTOF* tof;
 203
 204   if(gAlice){
 205      tof =(AliTOF*) gAlice->GetDetector("TOF");
 206   }else{
 207      printf("AliTOFSDigit::GetTotPad - No AliRun object present, exiting");
 208      return 0;
 209   }
 210
 211   Int_t pad = fPadx+tof->GetNpadX()*(fPadz-1);
 212   Int_t before=0;
 213
 214   switch(fPlate){
 215   case 1: before = 0;
 216           break;
 217   case 2: before = tof->GetNStripC();
 218           break;
 219   case 3: before = tof->GetNStripB() + tof->GetNStripC();
 220           break;
 221   case 4: before = tof->GetNStripA() + tof->GetNStripB() + tof->GetNStripC();
 222           break;
 223   case 5: before = tof->GetNStripA() + 2*tof->GetNStripB() + tof->GetNStripC();
 224           break;
 225   }
 226
 227   Int_t strip = fStrip+before;
 228   Int_t padTot = tof->GetPadXStr()*(strip-1)+pad;
 229   return padTot;
 230 }
 231
 232 ////////////////////////////////////////////////////////////////////////
 233 //void AliTOFSDigit::AddTrack(Int_t track)
 234 //{
 235 //
 236 // Add a new and different track to the digit -- but to which digit??
 237 // do not implemet this function
 238 //
 239 ////////////////////////////////////////////////////////////////////////
 240
 241 // Overloading of Streaming, Sum and Comparison operators
 242
 243 ////////////////////////////////////////////////////////////////////////
 244 /*
 245 Bool_t AliTOFSDigit::operator==(AliTOFSDigit const &digit) const
 246 {
 247 //
 248 // Overloading of Comparison operator
 249 //
 250  if (fSector==digit.fSector &&
 251      fPlate==digit.fPlate &&
 252      fStrip==digit.fStrip &&
 253      fPadx==digit.fPadx &&
 254      fPadz==digit.fPadz &&
 255      fTdc==digit.fTdc &&
 256      fAdc==digit.fAdc) return kTRUE;
 257      else return kFALSE;
 258 }
 259 */
 260 ////////////////////////////////////////////////////////////////////////
 261 /*
 262 ostream& operator << (ostream& out, const AliTOFSDigit &digit)
 263 {
 264 //
 265 // Output streamer: output of the digit data
 266 //
 267 out << "Sector " << digit.fSector << ", Plate " << digit.fPlate << ", Strip " << digit.fStrip << endl;
 268 out << "Padx" << digit.fPadx << ", Padz " << digit.fPadz << endl;
 269 out << "TDC " << digit.fTdc->At(0) << ", ADC "<< digit.fAdc->At(0) << endl;
 270 return out;
 271 }
 272 */