class to convert raw digits to sdigits
[u/mrichter/AliRoot.git] / PMD / AliPMDRawToSDigits.cxx
CommitLineData
1d9f57cc 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// //
18// Date : October 09 2006 //
19// converts raw to sdigit and digit //
20// //
21//-----------------------------------------------------//
22
23#include <Riostream.h>
24#include <TTree.h>
25#include <TObjArray.h>
26#include <TClonesArray.h>
27
28#include "AliDAQ.h"
29#include "AliLog.h"
30#include "AliRunLoader.h"
31#include "AliLoader.h"
32#include "AliRawReader.h"
33
34#include "AliPMDsdigit.h"
35#include "AliPMDdigit.h"
36#include "AliPMDRawToSDigits.h"
37#include "AliPMDRawStream.h"
38#include "AliPMDddldata.h"
39
40
41ClassImp(AliPMDRawToSDigits)
42
43AliPMDRawToSDigits::AliPMDRawToSDigits():
44 fSDigits(new TClonesArray("AliPMDsdigit", 1000)),
45 fDigits(new TClonesArray("AliPMDdigit", 1000)),
46 fNsdigit(0),
47 fNdigit(0)
48{
49 //
50// Constructor
51//
52
53}
54// ------------------------------------------------------------------------- //
55AliPMDRawToSDigits::AliPMDRawToSDigits(const AliPMDRawToSDigits & /*pmdr2sd*/):
56 TObject(/* pmdr2sd */),
57 fSDigits(NULL),
58 fDigits(NULL),
59 fNsdigit(0),
60 fNdigit(0)
61{
62 // copy constructor
63 AliFatal("Copy constructor not implemented");
64}
65// ------------------------------------------------------------------------- //
66
67
68AliPMDRawToSDigits &AliPMDRawToSDigits::operator=(const AliPMDRawToSDigits &/* pmdr2sd */)
69{
70 // assignment operator
71 AliFatal("Assignment operator not implemented");
72 return *this;
73}
74
75// ------------------------------------------------------------------------- //
76
77AliPMDRawToSDigits::~AliPMDRawToSDigits()
78{
79 // Destructor
80 if (fSDigits)
81 {
82 fSDigits->Delete();
83 delete fSDigits;
84 fSDigits=0;
85 }
86 if (fDigits)
87 {
88 fDigits->Delete();
89 delete fDigits;
90 fDigits=0;
91 }
92
93}
94// ------------------------------------------------------------------------- //
95
96void AliPMDRawToSDigits::Raw2SDigits(AliRunLoader *runLoader, AliRawReader *rawReader)
97{
98 // Converts RAW data to digits
99 //
100 TObjArray pmdddlcont;
101 AliLoader *pmdLoader = runLoader->GetLoader("PMDLoader");
102
103 TTree* treeS = pmdLoader->TreeS();
104 if (treeS == 0x0)
105 {
106 pmdLoader->MakeTree("S");
107 treeS = pmdLoader->TreeS();
108 }
109 Int_t bufsize = 16000;
110 if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
111 treeS->Branch("PMDSDigit", &fSDigits, bufsize);
112
113 const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
114 const Int_t kRow = 48;
115 const Int_t kCol = 96;
116
117 Int_t idet = 0;
118 Int_t iSMN = 0;
119 Int_t indexsmn = 0;
120
121 for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
122 {
123
124 if (indexDDL < 4)
125 {
126 iSMN = 6;
127 }
128 else if (indexDDL >= 4)
129 {
130 iSMN = 12;
131 }
132 Int_t ***precpvADC;
133 precpvADC = new int **[iSMN];
134 for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
135 for (Int_t i=0; i<iSMN;i++)
136 {
137 for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
138 }
139 for (Int_t i = 0; i < iSMN; i++)
140 {
141 for (Int_t j = 0; j < kRow; j++)
142 {
143 for (Int_t k = 0; k < kCol; k++)
144 {
145 precpvADC[i][j][k] = 0;
146 }
147 }
148 }
149
150 rawReader->Reset();
151 AliPMDRawStream pmdinput(rawReader);
152 rawReader->Select("PMD", indexDDL, indexDDL);
153
154 pmdinput.DdlData(indexDDL,&pmdddlcont);
155
156 Int_t ientries = pmdddlcont.GetEntries();
157 for (Int_t ient = 0; ient < ientries; ient++)
158 {
159 AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
160
161 Int_t det = pmdddl->GetDetector();
162 Int_t smn = pmdddl->GetSMN();
163 //Int_t mcm = pmdddl->GetMCM();
164 //Int_t chno = pmdddl->GetChannel();
165 Int_t row = pmdddl->GetRow();
166 Int_t col = pmdddl->GetColumn();
167 Int_t sig = pmdddl->GetSignal();
168
169
170 if (indexDDL < 4)
171 {
172 if (det != 0)
173 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
174 indexDDL, det));
175 indexsmn = smn - indexDDL * 6;
176 }
177 else if (indexDDL == 4)
178 {
179 if (det != 1)
180 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
181 indexDDL, det));
182 if (smn < 6)
183 {
184 indexsmn = smn;
185 }
186 else if (smn >= 18 && smn < 24)
187 {
188 indexsmn = smn - 12;
189 }
190 }
191 else if (indexDDL == 5)
192 {
193 if (det != 1)
194 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
195 indexDDL, det));
196 if (smn >= 6 && smn < 12)
197 {
198 indexsmn = smn - 6;
199 }
200 else if (smn >= 12 && smn < 18)
201 {
202 indexsmn = smn - 6;
203 }
204 }
205 precpvADC[indexsmn][row][col] = sig;
206 }
207
208 pmdddlcont.Clear();
209
210 // Add the sdigits here
211
212 Int_t ismn = 0;
213 for (Int_t indexsmn = 0; indexsmn < iSMN; indexsmn++)
214 {
215 if (indexDDL < 4)
216 {
217 ismn = indexsmn + indexDDL * 6;
218 idet = 0;
219 }
220 else if (indexDDL == 4)
221 {
222 if (indexsmn < 6)
223 {
224 ismn = indexsmn;
225 }
226 else if (indexsmn >= 6 && indexsmn < 12)
227 {
228 ismn = indexsmn + 12;
229 }
230 idet = 1;
231 }
232 else if (indexDDL == 5)
233 {
234 if (indexsmn < 6)
235 {
236 ismn = indexsmn + 6;
237 }
238 else if (indexsmn >= 6 && indexsmn < 12)
239 {
240 ismn = indexsmn + 6;
241 }
242 idet = 1;
243 }
244
245 for (Int_t irow = 0; irow < kRow; irow++)
246 {
247 for (Int_t icol = 0; icol < kCol; icol++)
248 {
249
250 Int_t trno = -99999;
251 Int_t sig1 = precpvADC[indexsmn][irow][icol];
252
253 // plug in a function to convert to adc to MeV
254 Float_t edep = 0.;
255 if (sig1 > 0)
256 {
257 AdcToMeV(sig1,edep);
258 AddSDigit(trno,idet,ismn,irow,icol,edep);
259 }
260 } // row
261 } // col
262
263 treeS->Fill();
264 ResetSDigit();
265 }
266 } // DDL Loop
267
268 pmdLoader->WriteSDigits("OVERWRITE");
269
270}
271// ------------------------------------------------------------------------- //
272void AliPMDRawToSDigits::Raw2Digits(AliRunLoader *runLoader, AliRawReader *rawReader)
273{
274 // Converts RAW data to digits
275 //
276 TObjArray pmdddlcont;
277
278 AliLoader *pmdLoader = runLoader->GetLoader("PMDLoader");
279
280 TTree* treeD = pmdLoader->TreeD();
281 if (treeD == 0x0)
282 {
283 pmdLoader->MakeTree("D");
284 treeD = pmdLoader->TreeD();
285 }
286 Int_t bufsize = 16000;
287 if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
288 treeD->Branch("PMDDigit", &fDigits, bufsize);
289
290 const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
291 const Int_t kRow = 48;
292 const Int_t kCol = 96;
293
294 Int_t idet = 0;
295 Int_t iSMN = 0;
296 Int_t indexsmn = 0;
297
298 for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
299 {
300
301 if (indexDDL < 4)
302 {
303 iSMN = 6;
304 }
305 else if (indexDDL >= 4)
306 {
307 iSMN = 12;
308 }
309 Int_t ***precpvADC;
310 precpvADC = new int **[iSMN];
311 for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
312 for (Int_t i=0; i<iSMN;i++)
313 {
314 for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
315 }
316 for (Int_t i = 0; i < iSMN; i++)
317 {
318 for (Int_t j = 0; j < kRow; j++)
319 {
320 for (Int_t k = 0; k < kCol; k++)
321 {
322 precpvADC[i][j][k] = 0;
323 }
324 }
325 }
326
327 rawReader->Reset();
328 AliPMDRawStream pmdinput(rawReader);
329 rawReader->Select("PMD", indexDDL, indexDDL);
330
331 //pmdinput.DdlData(&pmdddlcont);
332 pmdinput.DdlData(indexDDL,&pmdddlcont);
333
334
335 Int_t ientries = pmdddlcont.GetEntries();
336 for (Int_t ient = 0; ient < ientries; ient++)
337 {
338 AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
339
340 Int_t det = pmdddl->GetDetector();
341 Int_t smn = pmdddl->GetSMN();
342 //Int_t mcm = pmdddl->GetMCM();
343 //Int_t chno = pmdddl->GetChannel();
344 Int_t row = pmdddl->GetRow();
345 Int_t col = pmdddl->GetColumn();
346 Int_t sig = pmdddl->GetSignal();
347
348
349 if (indexDDL < 4)
350 {
351 if (det != 0)
352 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
353 indexDDL, det));
354 indexsmn = smn - indexDDL * 6;
355 }
356 else if (indexDDL == 4)
357 {
358 if (det != 1)
359 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
360 indexDDL, det));
361 if (smn < 6)
362 {
363 indexsmn = smn;
364 }
365 else if (smn >= 18 && smn < 24)
366 {
367 indexsmn = smn - 12;
368 }
369 }
370 else if (indexDDL == 5)
371 {
372 if (det != 1)
373 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
374 indexDDL, det));
375 if (smn >= 6 && smn < 12)
376 {
377 indexsmn = smn - 6;
378 }
379 else if (smn >= 12 && smn < 18)
380 {
381 indexsmn = smn - 6;
382 }
383 }
384 precpvADC[indexsmn][row][col] = sig;
385 }
386
387 pmdddlcont.Clear();
388
389 // Add the digits here
390
391 Int_t ismn = 0;
392 for (Int_t indexsmn = 0; indexsmn < iSMN; indexsmn++)
393 {
394 if (indexDDL < 4)
395 {
396 ismn = indexsmn + indexDDL * 6;
397 idet = 0;
398 }
399 else if (indexDDL == 4)
400 {
401 if (indexsmn < 6)
402 {
403 ismn = indexsmn;
404 }
405 else if (indexsmn >= 6 && indexsmn < 12)
406 {
407 ismn = indexsmn + 12;
408 }
409 idet = 1;
410 }
411 else if (indexDDL == 5)
412 {
413 if (indexsmn < 6)
414 {
415 ismn = indexsmn + 6;
416 }
417 else if (indexsmn >= 6 && indexsmn < 12)
418 {
419 ismn = indexsmn + 6;
420 }
421 idet = 1;
422 }
423
424 for (Int_t irow = 0; irow < kRow; irow++)
425 {
426 for (Int_t icol = 0; icol < kCol; icol++)
427 {
428 Int_t trno = -99999;
429 Int_t sig1 = precpvADC[indexsmn][irow][icol];
430
431 // plug in a function to convert to adc to MeV
432 if (sig1 > 0)
433 {
434 AddDigit(trno,idet,ismn,irow,icol,sig1);
435 }
436 } // row
437 } // col
438 treeD->Fill();
439 ResetDigit();
440 }
441
442 } // DDL Loop
443
444 pmdLoader->WriteDigits("OVERWRITE");
445
446}
447// ------------------------------------------------------------------------- //
448
449void AliPMDRawToSDigits::AdcToMeV(Int_t adc, Float_t &edep)
450{
451 // To be implemented, this is just for the test
452
453 const Float_t kConstant = 7.181;
454 // const Float_t kErConstant = 0.6899;
455 const Float_t kSlope = 35.93;
456 // const Float_t kErSlope = 0.306;
457
458
459
460 Float_t adc10bit = (Float_t) adc/4;
461 edep = (1000.0/kSlope)*(adc10bit - kConstant);
462}
463
464// ------------------------------------------------------------------------- //
465
466void AliPMDRawToSDigits::AddSDigit(Int_t trnumber, Int_t det, Int_t smnumber,
467 Int_t irow, Int_t icol, Float_t adc)
468{
469 // Add SDigit
470 //
471 if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
472 TClonesArray &lsdigits = *fSDigits;
473 new(lsdigits[fNsdigit++]) AliPMDsdigit(trnumber,det,smnumber,irow,icol,adc);
474}
475
476// ------------------------------------------------------------------------- //
477void AliPMDRawToSDigits::AddDigit(Int_t trnumber, Int_t det, Int_t smnumber,
478 Int_t irow, Int_t icol, Float_t adc)
479{
480 // Add Digit
481 //
482 if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
483 TClonesArray &ldigits = *fDigits;
484 new(ldigits[fNdigit++]) AliPMDdigit(trnumber,det,smnumber,irow,icol,adc);
485}
486
487// ------------------------------------------------------------------------- //
488void AliPMDRawToSDigits::ResetSDigit()
489{
490 // Clears SDigits
491 fNsdigit = 0;
492 if (fSDigits) fSDigits->Clear();
493}
494// ------------------------------------------------------------------------- //
495void AliPMDRawToSDigits::ResetDigit()
496{
497 // Clears SDigits
498 fNdigit = 0;
499 if (fDigits) fDigits->Clear();
500}