Unused variable i 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 sdigits
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   const Int_t kSMN = 48;
117
118   Int_t idet = 0;
119   Int_t indexsmn = 0;
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++)
126     {
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++)
132         {
133           for (Int_t k = 0; k < kCol; k++)
134             {
135               precpvADC[i][j][k] = 0;
136             }
137         }
138     }
139   
140   for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
141     {
142
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           
162           if (indexDDL < 4)
163             {
164               if (det != 0)
165                 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
166                               indexDDL, det));
167               indexsmn = smn;
168             }
169           else if (indexDDL == 4 || indexDDL == 5)
170             {
171               if (det != 1)
172                 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
173                               indexDDL, det));
174               indexsmn = smn + 24;
175             }
176
177           precpvADC[indexsmn][row][col] = sig;
178         }
179       
180       pmdddlcont.Clear();
181       
182     } // DDL Loop
183       
184   // Add the sdigits here
185   
186   for ( indexsmn = 0; indexsmn < kSMN; indexsmn++)
187     {
188
189       if (indexsmn < 23)
190         {
191           idet = 0;
192           ismn = indexsmn;
193         }
194       else if (indexsmn > 23)
195         {
196           idet = 0;
197           ismn = indexsmn - 24;
198         }
199       for (Int_t irow = 0; irow < kRow; irow++)
200         {
201           for (Int_t icol = 0; icol < kCol; icol++)
202             {
203
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)
210                 {
211                   AdcToMeV(sig1,edep);
212                   AddSDigit(trno,idet,ismn,irow,icol,edep);
213                 }
214             } // row
215         }     // col
216       
217       treeS->Fill();
218       ResetSDigit();
219     }
220
221   pmdLoader->WriteSDigits("OVERWRITE");
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;
237   
238 }
239 // ------------------------------------------------------------------------- //
240 void AliPMDRawToSDigits::Raw2Digits(AliRunLoader *runLoader, AliRawReader *rawReader)
241 {
242   // Converts RAW data to digits
243   //
244   TObjArray pmdddlcont;
245   
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); 
257   
258   const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
259   const Int_t kRow = 48;
260   const Int_t kCol = 96;
261   const Int_t kSMN = 48;
262   
263   Int_t idet = 0;
264   Int_t ismn = 0;
265   Int_t indexsmn = 0;
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++)
271     {
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++)
277         {
278           for (Int_t k = 0; k < kCol; k++)
279             {
280               precpvADC[i][j][k] = 0;
281             }
282         }
283     }
284   for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
285     {    
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));
313               indexsmn = smn ;
314             }
315           else if (indexDDL == 4 || indexDDL == 5)
316             {
317               if (det != 1)
318                 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
319                               indexDDL, det));
320               indexsmn = smn + 24;
321             }         
322           precpvADC[indexsmn][row][col] = sig;
323         }
324       
325       pmdddlcont.Clear();
326     } // DDL Loop  
327       
328   // Add the digits here
329   for (indexsmn = 0; indexsmn < kSMN; indexsmn++)
330     {
331       if (indexsmn < 23)
332         {
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++)
344             {
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)
350                 {
351                   AddDigit(trno,idet,ismn,irow,icol,sig1);
352                 }
353             } // row
354         }     // col
355       treeD->Fill();
356       ResetDigit();
357     }     
358   
359   pmdLoader->WriteDigits("OVERWRITE");
360
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;
375 }
376 // ------------------------------------------------------------------------- //
377
378 void AliPMDRawToSDigits::AdcToMeV(Int_t adc, Float_t &edep)
379 {
380   // To be implemented, this is just for the test
381
382   const Float_t kConstant   = 7.181;
383   //  const Float_t kErConstant = 0.6899;
384   const Float_t kSlope      = 35.93;
385   //  const Float_t kErSlope    = 0.306;
386
387
388
389   Float_t adc10bit = (Float_t) adc/4;
390   edep     = (1000.0/kSlope)*(adc10bit - kConstant);
391 }
392
393 // ------------------------------------------------------------------------- //
394
395 void 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 // ------------------------------------------------------------------------- //
406 void 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 // ------------------------------------------------------------------------- //
417 void AliPMDRawToSDigits::ResetSDigit()
418 {
419   // Clears SDigits
420   fNsdigit = 0;
421   if (fSDigits) fSDigits->Clear();
422 }
423 // ------------------------------------------------------------------------- //
424 void AliPMDRawToSDigits::ResetDigit()
425 {
426   // Clears SDigits
427   fNdigit = 0;
428   if (fDigits) fDigits->Clear();
429 }