Removing dollar from the comment string used for metadata of the OCDB entry (this...
[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{
93622f4a 98 // Converts RAW data to sdigits
1d9f57cc 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;
93622f4a 116 const Int_t kSMN = 48;
1d9f57cc 117
118 Int_t idet = 0;
1d9f57cc 119 Int_t indexsmn = 0;
93622f4a 120 Int_t ismn = 0;
121
122 Int_t ***precpvADC;
123 precpvADC = new int **[kSMN];
124 for (Int_t i=0; i<kSMN; i++) precpvADC[i] = new int *[kRow];
125 for (Int_t i=0; i<kSMN;i++)
1d9f57cc 126 {
93622f4a 127 for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
128 }
129 for (Int_t i = 0; i < kSMN; i++)
130 {
131 for (Int_t j = 0; j < kRow; j++)
1d9f57cc 132 {
93622f4a 133 for (Int_t k = 0; k < kCol; k++)
1d9f57cc 134 {
93622f4a 135 precpvADC[i][j][k] = 0;
1d9f57cc 136 }
137 }
93622f4a 138 }
139
140 for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
141 {
142
1d9f57cc 143 rawReader->Reset();
144 AliPMDRawStream pmdinput(rawReader);
145 rawReader->Select("PMD", indexDDL, indexDDL);
146
147 pmdinput.DdlData(indexDDL,&pmdddlcont);
148
149 Int_t ientries = pmdddlcont.GetEntries();
150 for (Int_t ient = 0; ient < ientries; ient++)
151 {
152 AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
153
154 Int_t det = pmdddl->GetDetector();
155 Int_t smn = pmdddl->GetSMN();
156 //Int_t mcm = pmdddl->GetMCM();
157 //Int_t chno = pmdddl->GetChannel();
158 Int_t row = pmdddl->GetRow();
159 Int_t col = pmdddl->GetColumn();
160 Int_t sig = pmdddl->GetSignal();
161
1d9f57cc 162 if (indexDDL < 4)
163 {
164 if (det != 0)
165 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
166 indexDDL, det));
93622f4a 167 indexsmn = smn;
1d9f57cc 168 }
93622f4a 169 else if (indexDDL == 4 || indexDDL == 5)
1d9f57cc 170 {
171 if (det != 1)
172 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
173 indexDDL, det));
93622f4a 174 indexsmn = smn + 24;
1d9f57cc 175 }
93622f4a 176
1d9f57cc 177 precpvADC[indexsmn][row][col] = sig;
178 }
179
180 pmdddlcont.Clear();
181
93622f4a 182 } // DDL Loop
183
184 // Add the sdigits here
185
186 for ( indexsmn = 0; indexsmn < kSMN; indexsmn++)
187 {
1d9f57cc 188
03ce36df 189 if (indexsmn <= 23)
1d9f57cc 190 {
93622f4a 191 idet = 0;
192 ismn = indexsmn;
193 }
194 else if (indexsmn > 23)
195 {
03ce36df 196 idet = 1;
93622f4a 197 ismn = indexsmn - 24;
198 }
199 for (Int_t irow = 0; irow < kRow; irow++)
200 {
201 for (Int_t icol = 0; icol < kCol; icol++)
1d9f57cc 202 {
1d9f57cc 203
93622f4a 204 Int_t trno = -99999;
205 Int_t sig1 = precpvADC[indexsmn][irow][icol];
206
207 // plug in a function to convert to adc to MeV
208 Float_t edep = 0.;
209 if (sig1 > 0)
1d9f57cc 210 {
93622f4a 211 AdcToMeV(sig1,edep);
212 AddSDigit(trno,idet,ismn,irow,icol,edep);
213 }
214 } // row
215 } // col
216
217 treeS->Fill();
218 ResetSDigit();
219 }
1d9f57cc 220
221 pmdLoader->WriteSDigits("OVERWRITE");
93622f4a 222
223 // Delete all the pointers
224
225 for (Int_t i = 0; i < kSMN; i++)
226 {
227 for (Int_t j = 0; j < kRow; j++)
228 {
229 delete [] precpvADC[i][j];
230 }
231 }
232 for (Int_t j = 0; j < kSMN; j++)
233 {
234 delete [] precpvADC[j];
235 }
236 delete [] precpvADC;
1d9f57cc 237
238}
239// ------------------------------------------------------------------------- //
240void AliPMDRawToSDigits::Raw2Digits(AliRunLoader *runLoader, AliRawReader *rawReader)
241{
242 // Converts RAW data to digits
243 //
244 TObjArray pmdddlcont;
93622f4a 245
1d9f57cc 246 AliLoader *pmdLoader = runLoader->GetLoader("PMDLoader");
247
248 TTree* treeD = pmdLoader->TreeD();
249 if (treeD == 0x0)
250 {
251 pmdLoader->MakeTree("D");
252 treeD = pmdLoader->TreeD();
253 }
254 Int_t bufsize = 16000;
255 if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
256 treeD->Branch("PMDDigit", &fDigits, bufsize);
93622f4a 257
1d9f57cc 258 const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
259 const Int_t kRow = 48;
260 const Int_t kCol = 96;
93622f4a 261 const Int_t kSMN = 48;
262
1d9f57cc 263 Int_t idet = 0;
93622f4a 264 Int_t ismn = 0;
1d9f57cc 265 Int_t indexsmn = 0;
93622f4a 266
267 Int_t ***precpvADC;
268 precpvADC = new int **[kSMN];
269 for (Int_t i=0; i<kSMN; i++) precpvADC[i] = new int *[kRow];
270 for (Int_t i=0; i<kSMN;i++)
1d9f57cc 271 {
93622f4a 272 for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
273 }
274 for (Int_t i = 0; i < kSMN; i++)
275 {
276 for (Int_t j = 0; j < kRow; j++)
1d9f57cc 277 {
93622f4a 278 for (Int_t k = 0; k < kCol; k++)
1d9f57cc 279 {
93622f4a 280 precpvADC[i][j][k] = 0;
1d9f57cc 281 }
282 }
93622f4a 283 }
284 for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
285 {
1d9f57cc 286 rawReader->Reset();
287 AliPMDRawStream pmdinput(rawReader);
288 rawReader->Select("PMD", indexDDL, indexDDL);
289
290 //pmdinput.DdlData(&pmdddlcont);
291 pmdinput.DdlData(indexDDL,&pmdddlcont);
292
293
294 Int_t ientries = pmdddlcont.GetEntries();
295 for (Int_t ient = 0; ient < ientries; ient++)
296 {
297 AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
298
299 Int_t det = pmdddl->GetDetector();
300 Int_t smn = pmdddl->GetSMN();
301 //Int_t mcm = pmdddl->GetMCM();
302 //Int_t chno = pmdddl->GetChannel();
303 Int_t row = pmdddl->GetRow();
304 Int_t col = pmdddl->GetColumn();
305 Int_t sig = pmdddl->GetSignal();
306
307
308 if (indexDDL < 4)
309 {
310 if (det != 0)
311 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
312 indexDDL, det));
93622f4a 313 indexsmn = smn ;
1d9f57cc 314 }
93622f4a 315 else if (indexDDL == 4 || indexDDL == 5)
1d9f57cc 316 {
317 if (det != 1)
318 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
319 indexDDL, det));
93622f4a 320 indexsmn = smn + 24;
1d9f57cc 321 }
322 precpvADC[indexsmn][row][col] = sig;
323 }
324
325 pmdddlcont.Clear();
93622f4a 326 } // DDL Loop
1d9f57cc 327
93622f4a 328 // Add the digits here
329 for (indexsmn = 0; indexsmn < kSMN; indexsmn++)
330 {
03ce36df 331 if (indexsmn <= 23)
1d9f57cc 332 {
93622f4a 333 ismn = indexsmn;
334 idet = 0;
335 }
336 else if (indexsmn > 23)
337 {
338 ismn = indexsmn -24;
339 idet = 1;
340 }
341 for (Int_t irow = 0; irow < kRow; irow++)
342 {
343 for (Int_t icol = 0; icol < kCol; icol++)
1d9f57cc 344 {
93622f4a 345 Int_t trno = -99999;
346 Int_t sig1 = precpvADC[indexsmn][irow][icol];
347
348 // plug in a function to convert to adc to MeV
349 if (sig1 > 0)
1d9f57cc 350 {
93622f4a 351 AddDigit(trno,idet,ismn,irow,icol,sig1);
1d9f57cc 352 }
93622f4a 353 } // row
354 } // col
355 treeD->Fill();
356 ResetDigit();
357 }
1d9f57cc 358
359 pmdLoader->WriteDigits("OVERWRITE");
360
93622f4a 361 // Delete all the pointers
362
363 for (Int_t i = 0; i < kSMN; i++)
364 {
365 for (Int_t j = 0; j < kRow; j++)
366 {
367 delete [] precpvADC[i][j];
368 }
369 }
370 for (Int_t j = 0; j < kSMN; j++)
371 {
372 delete [] precpvADC[j];
373 }
374 delete [] precpvADC;
1d9f57cc 375}
376// ------------------------------------------------------------------------- //
377
378void AliPMDRawToSDigits::AdcToMeV(Int_t adc, Float_t &edep)
379{
380 // To be implemented, this is just for the test
381
03ce36df 382 const Float_t kConstant = 9.0809;
383 // const Float_t kErConstant = 1.6763;
384 const Float_t kSlope = 128.348;
385 // const Float_t kErSlope = 0.4703;
1d9f57cc 386
387
388
03ce36df 389 Float_t adc12bit = (Float_t) adc;
390 edep = (1000.0/kSlope)*(adc12bit - kConstant);
1d9f57cc 391}
392
03ce36df 393//------------------------------------------------------------------------- //
1d9f57cc 394
395void AliPMDRawToSDigits::AddSDigit(Int_t trnumber, Int_t det, Int_t smnumber,
396 Int_t irow, Int_t icol, Float_t adc)
397{
398 // Add SDigit
399 //
400 if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
401 TClonesArray &lsdigits = *fSDigits;
402 new(lsdigits[fNsdigit++]) AliPMDsdigit(trnumber,det,smnumber,irow,icol,adc);
403}
404
405// ------------------------------------------------------------------------- //
406void AliPMDRawToSDigits::AddDigit(Int_t trnumber, Int_t det, Int_t smnumber,
407 Int_t irow, Int_t icol, Float_t adc)
408{
409 // Add Digit
410 //
411 if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
412 TClonesArray &ldigits = *fDigits;
413 new(ldigits[fNdigit++]) AliPMDdigit(trnumber,det,smnumber,irow,icol,adc);
414}
415
416// ------------------------------------------------------------------------- //
417void AliPMDRawToSDigits::ResetSDigit()
418{
419 // Clears SDigits
420 fNsdigit = 0;
421 if (fSDigits) fSDigits->Clear();
422}
423// ------------------------------------------------------------------------- //
424void AliPMDRawToSDigits::ResetDigit()
425{
426 // Clears SDigits
427 fNdigit = 0;
428 if (fDigits) fDigits->Clear();
429}