TOF/AliTOFSDigit.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 //  TOF sdigit: member variables
  20 //  fSector  : TOF sector
  21 //  fPlate   : TOF plate
  22 //  fStrip   : strips number
  23 //  fPadx    : pad number along x
  24 //  fPadz    : pad number along z
  25 //  fTdc     : TArrayF of TDC values
  26 //  fAdc     : TArrayF of ADC values
  27 //
  28 //  Getters, setters and member functions  defined here
  29 //
  30 //*-- Authors: F. Pierella, A. Seganti, D. Vicinanza
  31
  32 #include <Riostream.h>
  33 #include "TArrayF.h"
  34 #include "TArrayI.h"
  35
  36 #include "AliRun.h"
  37 #include "AliTOF.h"
  38 #include "AliTOFGeometry.h"
  39 #include "AliTOFSDigit.h"
  40
  41 ClassImp(AliTOFSDigit)
  42
  43 ////////////////////////////////////////////////////////////////////////
  44   AliTOFSDigit::AliTOFSDigit()
  45 {
  46   //
  47   // default ctor
  48   //
  49   fNDigits = 0;
  50   fTdc = 0;
  51   fAdc = 0;
  52   fTracks = 0;
  53 }
  54
  55 ////////////////////////////////////////////////////////////////////////
  56 AliTOFSDigit::AliTOFSDigit(Int_t tracknum, Int_t *vol,Float_t *digit)
  57 :TObject()
  58 {
  59   //
  60   // Constructor of digit object
  61   //
  62
  63   fSector = vol[0];
  64   fPlate  = vol[1];
  65   fStrip  = vol[2];
  66   fPadx   = vol[3];
  67   fPadz   = vol[4];
  68   fNDigits = 1;
  69   fTdc = new TArrayF(fNDigits);
  70   (*fTdc)[0] = digit[0];
  71   fAdc = new TArrayF(fNDigits);
  72   (*fAdc)[0] = digit[1];
  73   fTracks = new TArrayI(kMAXDIGITS*fNDigits);
  74   (*fTracks)[0] = tracknum;
  75   for (Int_t i = 1; i <kMAXDIGITS*fNDigits; i++) {
  76     (*fTracks)[i] = -1;
  77   }
  78 }
  79
  80 ////////////////////////////////////////////////////////////////////////
  81 AliTOFSDigit::AliTOFSDigit(const AliTOFSDigit & digit)
  82 :TObject()
  83 {
  84   //
  85   // copy ctor for AliTOFSDigit object
  86   //
  87   fSector = digit.fSector;
  88   fPlate  = digit.fPlate;
  89   fStrip  = digit.fStrip;
  90   fPadx   = digit.fPadx;
  91   fPadz   = digit.fPadz;
  92   fNDigits = digit.fNDigits;
  93   fTdc = new TArrayF(*digit.fTdc);
  94   fAdc = new TArrayF(*digit.fAdc);
  95   fTracks = new TArrayI(*digit.fTracks);
  96 }
  97
  98 ////////////////////////////////////////////////////////////////////////
  99 AliTOFSDigit::AliTOFSDigit(Int_t sector, Int_t plate, Int_t strip, Int_t padx,
 100                            Int_t padz, Float_t tdc, Float_t adc)
 101 {
 102   //
 103   // Constructor for sdigit
 104   //
 105   fSector = sector;
 106   fPlate  = plate;
 107   fStrip  = strip;
 108   fPadx   = padx;
 109   fPadz   = padz;
 110   fNDigits = 1;
 111   fTdc = new TArrayF(fNDigits);
 112   (*fTdc)[0] = tdc;
 113   fAdc = new TArrayF(fNDigits);
 114   (*fAdc)[0] = adc;
 115   // no tracks were specified, set them to -1
 116   fTracks = new TArrayI(kMAXDIGITS*fNDigits);
 117   for (Int_t i = 0; i <kMAXDIGITS*fNDigits; i++) {
 118     (*fTracks)[i] = -1;
 119   }
 120 }
 121
 122 ////////////////////////////////////////////////////////////////////////
 123 void AliTOFSDigit::GetLocation(Int_t *Loc) const
 124 {
 125   //
 126   // Get the coordinates of the digit
 127   // in terms of Sector - Plate - Strip - Pad
 128   //
 129
 130   Loc[0]=fSector;
 131   Loc[1]=fPlate;
 132   Loc[2]=fStrip;
 133   Loc[3]=fPadx;
 134   Loc[4]=fPadz;
 135 }
 136
 137 ////////////////////////////////////////////////////////////////////////
 138 void AliTOFSDigit::Update(Float_t tdcbin, Int_t tdc, Int_t adc, Int_t track)
 139 {
 140   //
 141   // Add charge and track
 142   //
 143
 144   Int_t sameTime = -1;
 145   Float_t tdcwindow=((Float_t)AliTOFGeometry::TimeDiff())/tdcbin;
 146   for (Int_t i = 0; i < fNDigits; i++) {
 147     if (TMath::Abs(tdc-fTdc->At(i)) < tdcwindow) {
 148       sameTime = i;
 149       break;
 150     }
 151   }
 152
 153   if (sameTime >= 0) {
 154     (*fAdc)[sameTime] += static_cast<Float_t>(adc);
 155     // update track - find the first -1  value and replace it by the
 156     // track number
 157     for (Int_t iTrack=0; iTrack<kMAXDIGITS; iTrack++) {
 158       if ((*fTracks)[sameTime*kMAXDIGITS+iTrack] == -1) {
 159         (*fTracks)[sameTime*kMAXDIGITS+iTrack] = track;
 160         break;
 161       }
 162       // write warning about many tracks going to this pad
 163       if (iTrack == kMAXDIGITS) {
 164         cerr<<"WARNING: AliTOFSDigit::Update  Many hits in the padhit"<<endl;
 165         cerr<<"         ";
 166         //      PrintPad();
 167       }
 168     }
 169   } else {
 170     // add new time slot
 171     fNDigits++;
 172     fTdc->Set(fNDigits);
 173     (*fTdc)[fNDigits-1] = tdc;
 174     fAdc->Set(fNDigits);
 175     (*fAdc)[fNDigits-1] = adc;
 176     fTracks->Set(fNDigits*kMAXDIGITS);
 177     (*fTracks)[(fNDigits-1)*kMAXDIGITS] = track;
 178     for (Int_t i = 1; i <kMAXDIGITS; i++) {
 179       (*fTracks)[(fNDigits-1)*kMAXDIGITS+i] = -1;
 180     }
 181   }
 182
 183 }
 184
 185 ////////////////////////////////////////////////////////////////////////
 186 void AliTOFSDigit::Update(AliTOFSDigit* sdig)
 187 {
 188
 189   //
 190   // Perform the sum with sdig
 191   //
 192
 193   // start loop on all sdig locations
 194   Int_t nlocations=sdig->GetNDigits();
 195
 196   for (Int_t j = 0; j < nlocations; j++) {
 197     Float_t tdcbin=50.; // [ps] hardwired for the time being
 198     Int_t tdc=(Int_t)sdig->GetTdc(j);
 199     Int_t adc=(Int_t)sdig->GetAdc(j);
 200     // getting here only the first track number
 201     Int_t track=GetTrack(j,0);
 202
 203
 204     Int_t sameTime = -1;
 205     Float_t tdcwindow=((Float_t)AliTOFGeometry::TimeDiff())/tdcbin;
 206     for (Int_t i = 0; i < fNDigits; i++) {
 207       if (TMath::Abs(tdc-fTdc->At(i)) < tdcwindow) {
 208         sameTime = i;
 209         break;
 210       }
 211     }
 212
 213     if (sameTime >= 0) {
 214       (*fAdc)[sameTime] += static_cast<Float_t>(adc);
 215       // update track - find the first -1  value and replace it by the
 216       // track number
 217       for (Int_t iTrack=0; iTrack<kMAXDIGITS; iTrack++) {
 218         if ((*fTracks)[sameTime*kMAXDIGITS+iTrack] == -1) {
 219           (*fTracks)[sameTime*kMAXDIGITS+iTrack] = track;
 220           break;
 221         }
 222         // write warning about many tracks going to this pad
 223         if (iTrack == kMAXDIGITS) {
 224           cerr<<"WARNING: AliTOFSDigit::Update  Many hits in the padhit"<<endl;
 225           cerr<<"         ";
 226           //    PrintPad();
 227         }
 228       }
 229     } else {
 230       // add new time slot
 231       fNDigits++;
 232       fTdc->Set(fNDigits);
 233       (*fTdc)[fNDigits-1] = tdc;
 234       fAdc->Set(fNDigits);
 235       (*fAdc)[fNDigits-1] = adc;
 236       fTracks->Set(fNDigits*kMAXDIGITS);
 237       (*fTracks)[(fNDigits-1)*kMAXDIGITS] = track;
 238       for (Int_t i = 1; i <kMAXDIGITS; i++) {
 239         (*fTracks)[(fNDigits-1)*kMAXDIGITS+i] = -1;
 240       } // for (Int_t i = 1; i <kMAXDIGITS; i++)
 241     } // if (sameTime >= 0)
 242   } // end loop on sdig locations
 243 }
 244
 245 ////////////////////////////////////////////////////////////////////////
 246 AliTOFSDigit::~AliTOFSDigit()
 247 {
 248   //
 249   // dtor
 250   //
 251   delete fTdc;
 252   delete fAdc;
 253   delete fTracks;
 254 }
 255
 256 ////////////////////////////////////////////////////////////////////////
 257
 258 Int_t AliTOFSDigit::GetTotPad() const
 259 {
 260   //
 261   // Get the "total" index of the pad inside a Sector
 262   // starting from the digits data.
 263   //
 264
 265   Int_t pad = fPadx+AliTOFGeometry::NpadX()*(fPadz-1);
 266   Int_t before=0;
 267
 268   switch(fPlate){
 269   case 1: before = 0;
 270     break;
 271   case 2: before = AliTOFGeometry::NStripC();
 272     break;
 273   case 3: before = AliTOFGeometry::NStripB() + AliTOFGeometry::NStripC();
 274     break;
 275   case 4: before = AliTOFGeometry::NStripA() + AliTOFGeometry::NStripB() + AliTOFGeometry::NStripC();
 276     break;
 277   case 5: before = AliTOFGeometry::NStripA() + 2*AliTOFGeometry::NStripB() + AliTOFGeometry::NStripC();
 278     break;
 279   }
 280
 281   Int_t strip = fStrip+before;
 282   Int_t padTot = AliTOFGeometry::NpadX()*AliTOFGeometry::NpadZ()*(strip-1)+pad;
 283   return padTot;
 284 }
 285