New TOF geometry description (V5) -G. Cara Romeo and A. De Caro
[u/mrichter/AliRoot.git] / 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 "AliLog.h"
37 #include "AliRun.h"
38 #include "AliTOF.h"
39 #include "AliTOFGeometry.h"
40 #include "AliTOFSDigit.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 :TObject()
59 {
60   //
61   // Constructor of digit object
62   //
63
64   fSector = vol[0];
65   fPlate  = vol[1];
66   fStrip  = vol[2];
67   fPadx   = vol[3];
68   fPadz   = vol[4];
69   fNDigits = 1;
70   fTdc = new TArrayF(fNDigits);
71   (*fTdc)[0] = digit[0];
72   fAdc = new TArrayF(fNDigits);
73   (*fAdc)[0] = digit[1];
74   fTracks = new TArrayI(kMAXDIGITS*fNDigits);
75   (*fTracks)[0] = tracknum;
76   for (Int_t i = 1; i <kMAXDIGITS*fNDigits; i++) {
77     (*fTracks)[i] = -1;
78   }
79 }
80
81 ////////////////////////////////////////////////////////////////////////
82 AliTOFSDigit::AliTOFSDigit(const AliTOFSDigit & digit)
83 :TObject()
84 {
85   // 
86   // copy ctor for AliTOFSDigit object
87   //
88   fSector = digit.fSector;
89   fPlate  = digit.fPlate;
90   fStrip  = digit.fStrip;
91   fPadx   = digit.fPadx;
92   fPadz   = digit.fPadz;
93   fNDigits = digit.fNDigits;
94   fTdc = new TArrayF(*digit.fTdc);  
95   fAdc = new TArrayF(*digit.fAdc);
96   fTracks = new TArrayI(*digit.fTracks);
97 }
98
99 ////////////////////////////////////////////////////////////////////////
100 AliTOFSDigit::AliTOFSDigit(Int_t sector, Int_t plate, Int_t strip, Int_t padx,
101                            Int_t padz, Float_t tdc, Float_t adc)
102 {
103   //
104   // Constructor for sdigit
105   //
106   fSector = sector;
107   fPlate  = plate;
108   fStrip  = strip;
109   fPadx   = padx;
110   fPadz   = padz;  
111   fNDigits = 1;
112   fTdc = new TArrayF(fNDigits);
113   (*fTdc)[0] = tdc;   
114   fAdc = new TArrayF(fNDigits);
115   (*fAdc)[0] = adc;   
116   // no tracks were specified, set them to -1
117   fTracks = new TArrayI(kMAXDIGITS*fNDigits);
118   for (Int_t i = 0; i <kMAXDIGITS*fNDigits; i++) {
119     (*fTracks)[i] = -1;
120   }
121 }
122
123 ////////////////////////////////////////////////////////////////////////
124 void AliTOFSDigit::GetLocation(Int_t *Loc) const
125 {
126   //
127   // Get the coordinates of the digit
128   // in terms of Sector - Plate - Strip - Pad
129   //
130   
131   Loc[0]=fSector;
132   Loc[1]=fPlate;
133   Loc[2]=fStrip;
134   Loc[3]=fPadx;
135   Loc[4]=fPadz;
136 }
137
138 ////////////////////////////////////////////////////////////////////////
139 void AliTOFSDigit::Update(Float_t tdcbin, Int_t tdc, Int_t adc, Int_t track)
140 {
141   //
142   // Add charge and track
143   //
144   
145   Int_t sameTime = -1;
146   Float_t tdcwindow=((Float_t)AliTOFGeometry::TimeDiff())/tdcbin;
147   for (Int_t i = 0; i < fNDigits; i++) {
148     if (TMath::Abs(tdc-fTdc->At(i)) < tdcwindow) {
149       sameTime = i;
150       break;
151     }
152   }
153   
154   if (sameTime >= 0) {
155     (*fAdc)[sameTime] += static_cast<Float_t>(adc);
156     // update track - find the first -1  value and replace it by the
157     // track number
158     for (Int_t iTrack=0; iTrack<kMAXDIGITS; iTrack++) {
159       if ((*fTracks)[sameTime*kMAXDIGITS+iTrack] == -1) {
160         (*fTracks)[sameTime*kMAXDIGITS+iTrack] = track;
161         break;
162       }
163       // write warning about many tracks going to this pad
164       if (iTrack == kMAXDIGITS) {
165         AliWarning("Many hits in the padhit");
166         //      ToAliWarning(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 = AliTOFGeometry::TdcBinWidth();// [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           AliWarning("Many hits in the padhit");
225           //    ToAliWarning(PrintPad());
226         }
227       }
228     } else {
229       // add new time slot
230       fNDigits++;
231       fTdc->Set(fNDigits);
232       (*fTdc)[fNDigits-1] = tdc;
233       fAdc->Set(fNDigits);
234       (*fAdc)[fNDigits-1] = adc;
235       fTracks->Set(fNDigits*kMAXDIGITS);
236       (*fTracks)[(fNDigits-1)*kMAXDIGITS] = track;
237       for (Int_t i = 1; i <kMAXDIGITS; i++) {
238         (*fTracks)[(fNDigits-1)*kMAXDIGITS+i] = -1;
239       } // for (Int_t i = 1; i <kMAXDIGITS; i++)
240     } // if (sameTime >= 0)
241   } // end loop on sdig locations
242 }
243
244 ////////////////////////////////////////////////////////////////////////
245 AliTOFSDigit::~AliTOFSDigit()
246 {
247   //
248   // dtor
249   //
250   delete fTdc;
251   delete fAdc;
252   delete fTracks;
253 }
254
255 ////////////////////////////////////////////////////////////////////////
256
257 Int_t AliTOFSDigit::GetTotPad(AliTOFGeometry *tofGeom) const
258 {
259   //
260   // Get the "total" index of the pad inside a Sector
261   // starting from the digits data.
262   //
263   
264   Int_t pad = 2*fPadx + fPadz;
265   //Int_t pad = fPadx+AliTOFGeometry::NpadX()*fPadz;
266   Int_t before=0;
267   
268   switch(fPlate){ 
269   case 0:
270     //before = 0;
271     break;
272   case 1:
273     before = tofGeom->NStripC();
274     break;
275   case 2:
276     before = AliTOFGeometry::NStripB() +   tofGeom->NStripC();
277     break;
278   case 3:
279     before = AliTOFGeometry::NStripA() +   AliTOFGeometry::NStripB() + tofGeom->NStripC();
280     break;
281   case 4:
282     before = AliTOFGeometry::NStripA() + 2*AliTOFGeometry::NStripB() + tofGeom->NStripC();
283     break;
284   }
285   
286   Int_t strip = fStrip + before;
287   Int_t padTot = AliTOFGeometry::NpadXStrip()*strip + pad;
288   return padTot;
289 }