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