calibration classes added
[u/mrichter/AliRoot.git] / PMD / AliPMDDDLRawData.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 #include <Riostream.h>
17 #include <TClonesArray.h>
18 #include <TTree.h>
19 #include <TBranch.h>
20 #include <TMath.h>
21
22 #include "AliLog.h"
23 #include "AliRawDataHeader.h"
24 #include "AliBitPacking.h"
25 #include "AliPMDdigit.h"
26 #include "AliPMDRawStream.h"
27 #include "AliPMDDDLRawData.h"
28
29
30 ClassImp(AliPMDDDLRawData)
31
32 AliPMDDDLRawData::AliPMDDDLRawData():
33   fDigits(new TClonesArray("AliPMDdigit", 1000))
34 {
35   // Default Constructor
36   //
37
38 }
39 //____________________________________________________________________________
40
41 AliPMDDDLRawData::~AliPMDDDLRawData()
42 {
43   // Default Destructor
44   //
45
46 }
47
48 //____________________________________________________________________________
49 void AliPMDDDLRawData::WritePMDRawData(TTree *treeD)
50 {
51   // write digits into raw data format
52
53   ofstream outfile;
54
55   TBranch *branch = treeD->GetBranch("PMDDigit");
56   if (!branch)
57     {
58       AliError("PMD Digit branch not found");
59       return;
60     }
61   branch->SetAddress(&fDigits);  
62   
63   Int_t   nmodules = (Int_t) treeD->GetEntries();
64   AliDebug(1,Form("Number of modules inside treeD = %d",nmodules));
65
66   const Int_t kSize         = 4608;
67   const Int_t kDDL          = 6;
68   Int_t modulePerDDL        = 0;
69
70
71   AliRawDataHeader header;
72   UInt_t sizeRawData = 0;
73   Int_t  totword     = 0;
74
75   UInt_t buffer[kSize];
76
77   Char_t filename[80];
78
79   Int_t mmodule = 0;
80   for(Int_t iddl = 0; iddl < kDDL; iddl++)
81     {
82       sprintf(filename,"PMD_%d.ddl",AliPMDRawStream::kDDLOffset+iddl);
83 #ifndef __DECCXX
84       outfile.open(filename,ios::binary);
85 #else
86       outfile.open(filename);
87 #endif
88       
89       if (iddl < 4)
90         {
91           modulePerDDL = 6;
92           mmodule = 6*iddl;
93         }
94       else if (iddl == 4)
95         {
96           modulePerDDL = 12;
97           mmodule = 24;
98         }
99       else if (iddl == 5)
100         {
101           modulePerDDL = 12;
102           mmodule = 30;
103         }
104
105
106       // Write the Dummy Data Header into the file
107       Int_t bHPosition = outfile.tellp();
108       outfile.write((char*)(&header),sizeof(header));
109
110
111       for(Int_t ium = 0; ium < modulePerDDL; ium++)
112         {
113           
114           if (iddl == 4 && ium == 6) mmodule = 36;
115           if (iddl == 5 && ium == 6) mmodule = 42;
116
117           for (Int_t i = 0; i < kSize; i++)
118             {
119               buffer[i] = 0;
120             }
121           // Extract energy deposition per cell and pack it
122           // in a 32-bit word and returns all the total words
123           // per one unit-module
124           
125           GetUMDigitsData(treeD, mmodule, ium, iddl, totword, buffer);
126           
127           outfile.write((char*)buffer,totword*sizeof(UInt_t));
128
129           mmodule++;
130
131         }
132
133       // Write real data header
134       // take the pointer to the beginning of the data header
135       // write the total number of words per ddl and bring the
136       // pointer to the current file position and close it
137       UInt_t cFPosition = outfile.tellp();
138       sizeRawData = cFPosition - bHPosition - sizeof(header);
139       header.fSize = cFPosition - bHPosition;
140       header.SetAttribute(0);  // valid data
141       outfile.seekp(bHPosition);
142       outfile.write((char*)(&header),sizeof(header));
143       outfile.seekp(cFPosition);
144
145       outfile.close();
146     } // DDL Loop over
147
148
149 }
150 //____________________________________________________________________________
151 void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule, Int_t ium,
152                                        Int_t ddlno, Int_t & totword,
153                                        UInt_t *buffer)
154 {
155   // Retrives digits data UnitModule by UnitModule
156   UInt_t baseword;
157   UInt_t mcmno, chno;
158   UInt_t adc;
159   Int_t  det, smn, irow, icol;
160
161   treeD->GetEntry(imodule); 
162   Int_t nentries = fDigits->GetLast();
163   totword = nentries+1;
164
165   for (Int_t ient = 0; ient < totword; ient++)
166     {
167       fPMDdigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
168       
169       det    = fPMDdigit->GetDetector();
170       smn    = fPMDdigit->GetSMNumber();
171       irow   = fPMDdigit->GetRow();
172       icol   = fPMDdigit->GetColumn();
173       adc    = (UInt_t) fPMDdigit->GetADC();
174
175       TransformS2H(smn,irow,icol);
176       GetMCMCh(ddlno, ium, irow, icol, mcmno, chno);
177
178       baseword = 0;
179       AliBitPacking::PackWord(adc,baseword,0,11);
180       AliBitPacking::PackWord(chno,baseword,12,17);
181       AliBitPacking::PackWord(mcmno,baseword,18,28);
182       AliBitPacking::PackWord(0,baseword,29,30);
183       AliBitPacking::PackWord(1,baseword,31,31);
184       
185       buffer[ient] = baseword;
186       
187     }
188
189 }
190 //____________________________________________________________________________
191 void AliPMDDDLRawData::TransformS2H(Int_t smn, Int_t &irow, Int_t &icol)
192 {
193   // Does the Software to Hardware coordinate transformation
194   //
195   Int_t  irownew = 0;
196   Int_t  icolnew = 0;
197   Int_t  irownew1 = 0;
198   Int_t  icolnew1 = 0;
199
200   // First in digits we have all dimension 48x96
201   // Transform into the realistic one, i.e, For SM 1&2 96x48
202   // and for SM 3&4 48x96
203   // 
204   if(smn < 12)
205     {
206       irownew1 = icol;
207       icolnew1 = irow;
208     }
209   else if( smn >= 12 && smn < 24)
210     {
211       irownew1 = irow;
212       icolnew1 = icol;
213     }
214   // This is the transformation of Geant (0,0) to the Hardware (0,0)
215   // which is always at the top left corner. This may change in future.
216   // Then accordingly we have to transform it.
217   if(smn < 6)
218     {
219       irownew = 95 - irownew1;
220       icolnew = icolnew1;
221     }
222   else if(smn >= 6 && smn < 12)
223     {
224       irownew = irownew1;
225       icolnew = 47 - icolnew1;
226     }
227   else if(smn >= 12 && smn < 18)
228     {
229       irownew = 47 - irownew1;
230       icolnew = icolnew1;
231     }
232   else if(smn >= 18 && smn < 24)
233     {
234       irownew = irownew1;
235       icolnew = 95 - icolnew1;
236     }
237
238   irow = irownew;
239   icol = icolnew;
240
241 }
242
243
244 //____________________________________________________________________________
245
246 void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t um,
247                                 Int_t row, Int_t col,
248                                 UInt_t &mcmno, UInt_t &chno)
249 {
250   // This part will be modified once the final track layout on the PCB is
251   // designed. This will only change the coordinate of the individual cell
252
253   static const UInt_t kCh[16][4] = { {12, 13, 18, 19},
254                                      {11, 15, 17, 21},
255                                      {10, 14, 16, 22},
256                                      {8, 9, 20, 23},
257                                      {7, 4, 25, 24},
258                                      {6, 0, 30, 26},
259                                      {5, 1, 31, 27},
260                                      {3, 2, 29, 28},
261                                      {44, 45, 50, 51},
262                                      {43, 47, 49, 53},
263                                      {42, 46, 48, 54},
264                                      {40, 41, 52, 55},
265                                      {39, 36, 57, 56},
266                                      {38, 32, 62, 58},
267                                      {37, 33, 63, 59},
268                                      {35, 34, 61, 60} };
269   
270   if (ddlno == 0 || ddlno == 1)
271     {
272       // PRE plane, SU Mod = 1, 2
273       Int_t irownew = row%16;
274       Int_t icolnew = col%4;
275       Int_t irowdiv = row/16;
276       Int_t icoldiv = col/4;
277
278       mcmno = 72*um + 12*irowdiv + icoldiv;
279       chno  = kCh[irownew][icolnew];
280     }
281   else if (ddlno == 2 || ddlno == 3)
282     {
283       // PRE plane,  SU Mod = 3, 4
284       Int_t irownew = row%16;
285       Int_t icolnew = col%4;
286       Int_t irowdiv = row/16;
287       Int_t icoldiv = col/4;
288       
289       mcmno = 72*um + 24*irowdiv + icoldiv;
290       chno  = kCh[irownew][icolnew];
291     }
292   else if (ddlno == 4 || ddlno == 5)
293     {
294       // CPV plane,  SU Mod = 1, 3 : ddl = 4
295       // CPV plane,  SU Mod = 2, 4 : ddl = 5
296
297       Int_t irownew = row%16;
298       Int_t icolnew = col%4;
299       Int_t irowdiv = row/16;
300       Int_t icoldiv = col/4;
301
302       if(um < 6)
303         {
304           mcmno = 72*um + 12*irowdiv + icoldiv;
305         }
306       else if(um >= 6)
307         {
308           mcmno = 72*um + 24*irowdiv + icoldiv;
309         }
310       chno  = kCh[irownew][icolnew];
311     }
312
313 }
314 //____________________________________________________________________________
315