method Ranmar is removed
[u/mrichter/AliRoot.git] / PMD / AliPMDRawToSDigits.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 //-----------------------------------------------------//
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
41 ClassImp(AliPMDRawToSDigits)
42
43 AliPMDRawToSDigits::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 // ------------------------------------------------------------------------- //
55 AliPMDRawToSDigits::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
68 AliPMDRawToSDigits &AliPMDRawToSDigits::operator=(const AliPMDRawToSDigits &/* pmdr2sd */)
69 {
70   // assignment operator
71   AliFatal("Assignment operator not implemented");
72   return *this;
73 }
74
75 // ------------------------------------------------------------------------- //
76
77 AliPMDRawToSDigits::~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
96 void 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 // ------------------------------------------------------------------------- //
272 void 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
449 void 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
466 void 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 // ------------------------------------------------------------------------- //
477 void 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 // ------------------------------------------------------------------------- //
488 void AliPMDRawToSDigits::ResetSDigit()
489 {
490   // Clears SDigits
491   fNsdigit = 0;
492   if (fSDigits) fSDigits->Clear();
493 }
494 // ------------------------------------------------------------------------- //
495 void AliPMDRawToSDigits::ResetDigit()
496 {
497   // Clears SDigits
498   fNdigit = 0;
499   if (fDigits) fDigits->Clear();
500 }