PMD DDL raw data
[u/mrichter/AliRoot.git] / PMD / AliPMDDDLRawData.cxx
CommitLineData
28328eeb 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 "AliPMDdigit.h"
23#include "AliPMDDDLRawData.h"
24
25
26ClassImp(AliPMDDDLRawData)
27
28AliPMDDDLRawData::AliPMDDDLRawData():
29 fDigits(new TClonesArray("AliPMDdigit", 1000))
30{
31 // Default Constructor
32 //
33}
34//____________________________________________________________________________
35
36AliPMDDDLRawData::~AliPMDDDLRawData()
37{
38 // Default Destructor
39 //
40
41}
42
43//____________________________________________________________________________
44void AliPMDDDLRawData::WritePMDRawData(TTree *treeD, Int_t evtno)
45{
46 // write digits into raw data format
47
48 ofstream outfile;
49
50 TBranch *branch = treeD->GetBranch("PMDDigit");
51 if (!branch) return;
52 branch->SetAddress(&fDigits);
53
54 Int_t nmodules = (Int_t) treeD->GetEntries();
55 // cout << " nmodules = " << nmodules << endl;
56
57 const Int_t kSize = 4608;
58 const Int_t kDDL = 6;
59 Int_t modulePerDDL = 0;
60
61
62 UInt_t sizeRawData = 0;
63 UInt_t magicWord = 0x123456;
64 UInt_t detectorID = 0;
65 UInt_t ddlID = 0;
66 Int_t flag = 0;
67 Int_t version = 1;
68 UInt_t mHSize = 3*sizeof(UInt_t);
69 Int_t totword = 0;
70
71 UInt_t miniHeader[3];
72 UInt_t buffer[kSize];
73
74 Char_t filename[80];
75
76 Int_t mmodule = 0;
77 for(Int_t iddl = 0; iddl < kDDL; iddl++)
78 {
79 sprintf(filename,"Ev%dPMDddl%d.dat",evtno,iddl);
80#ifndef __DECCXX
81 outfile.open(filename,ios::binary);
82#else
83 outfile.open(filename);
84#endif
85
86 if (iddl < 4)
87 {
88 modulePerDDL = 6;
89 mmodule = 6*iddl;
90 detectorID = 0;
91 }
92 else if (iddl == 4)
93 {
94 modulePerDDL = 12;
95 mmodule = 24;
96 detectorID = 1;
97 }
98 else if (iddl == 5)
99 {
100 modulePerDDL = 12;
101 mmodule = 36;
102 detectorID = 1;
103 }
104
105 miniHeader[0] = sizeRawData;
106 PackWord(0,23,magicWord,miniHeader[1]);
107 PackWord(24,31,detectorID,miniHeader[1]);
108 ddlID = iddl;
109 PackWord(0,15,ddlID,miniHeader[2]);
110 PackWord(16,23,flag,miniHeader[2]);
111 PackWord(24,31,version,miniHeader[2]);
112
113
114 // Write the Dummy Mini Header into the file
115 Int_t bHPosition = outfile.tellp();
116 outfile.write((char*)(miniHeader),mHSize);
117
118
119 for(Int_t ium = 0; ium < modulePerDDL; ium++)
120 {
121
122 for (Int_t i = 0; i < kSize; i++)
123 {
124 buffer[i] = 0;
125 }
126 // Extract energy deposition per cell and pack it
127 // in a 32-bit word and returns all the total words
128 // per one unit-module
129
130 GetUMDigitsData(treeD, mmodule, ium, iddl, totword, buffer);
131
132 outfile.write((char*)buffer,totword*sizeof(UInt_t));
133
134 mmodule++;
135
136 }
137
138 // Write real mini header
139 // take the pointer to the beginning of the mini header
140 // write the total number of words per ddl and bring the
141 // pointer to the current file position and close it
142 UInt_t cFPosition = outfile.tellp();
143 sizeRawData = cFPosition - bHPosition - mHSize;
144 outfile.seekp(bHPosition);
145 outfile.write((char*)(&sizeRawData),sizeof(UInt_t));
146 outfile.seekp(cFPosition);
147
148 outfile.close();
149 } // DDL Loop over
150
151
152}
153//____________________________________________________________________________
154
155void AliPMDDDLRawData::ReadPMDRawData(Int_t evtno)
156{
157 // reads the raw data
158 ifstream infile;
159
160 Char_t filename[80];
161
162 const Int_t kDDL = 6;
163 Int_t imodule = 0;
164
165 for(Int_t iddl = 0; iddl < kDDL; iddl++)
166 {
167 sprintf(filename,"Ev%dPMDddl%d.dat",evtno,iddl);
168#ifndef __DECCXX
169 infile.open(filename,ios::binary);
170#else
171 infile.open(filename);
172#endif
173
174 Int_t ium;
175 Int_t irow;
176 Int_t icol;
177 UInt_t baseword;
178 UInt_t miniHeader[3];
179 UInt_t sizeRawData;
180 UInt_t mHSize = 3*sizeof(UInt_t);
181
182 infile.read((char*)(miniHeader), mHSize);
183
184 sizeRawData = miniHeader[0];
185 Int_t totword = sizeRawData/4;
186
187 UInt_t adc;
188 UInt_t chno;
189 UInt_t mcmno;
190
191 for (Int_t iword = 0; iword < totword; iword++)
192 {
193 infile.read((char*)(&baseword),sizeof(UInt_t));
194
195 UnpackWord(0,11,adc,baseword);
196 UnpackWord(12,17,chno,baseword);
197 UnpackWord(18,28,mcmno,baseword);
198
199 GetRowCol(iddl, mcmno, chno, ium, irow, icol);
200 if (iddl < 4)
201 {
202 imodule = iddl*6 + ium;
203 }
204 else if (iddl == 4)
205 {
206 imodule = 24 + ium;
207 }
208 else if (iddl == 5)
209 {
210 imodule = 36 + ium;
211 }
212
213 fprintf(fpw3,"%d %d %d %d %d %d\n",imodule,irow,icol,mcmno,chno,adc);
214
215 }
216
217 } // ddl loop
218}
219//____________________________________________________________________________
220void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule, Int_t ium,
221 Int_t ddlno, Int_t & totword,
222 UInt_t *buffer)
223{
224
225 UInt_t dataword, baseword;
226
227 UInt_t mcmno, chno;
228 UInt_t adc;
229 Int_t irownew = 0;
230 Int_t icolnew = 0;
231 Int_t det, smn, irow, icol;
232
233
234 treeD->GetEntry(imodule);
235 Int_t nentries = fDigits->GetLast();
236 totword = nentries+1;
237
238 for (Int_t ient = 0; ient < totword; ient++)
239 {
240 fPMDdigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
241
242 det = fPMDdigit->GetDetector();
243 smn = fPMDdigit->GetSMNumber();
244 irow = fPMDdigit->GetRow();
245 icol = fPMDdigit->GetColumn();
246 adc = (UInt_t) fPMDdigit->GetADC();
247
248 if(smn < 12)
249 {
250 irownew = icol;
251 icolnew = irow;
252 }
253 else if( smn >= 12 && smn < 24)
254 {
255 irownew = irow;
256 icolnew = icol;
257 }
258
259
260
261 GetMCMCh(ddlno, ium, irownew, icolnew, mcmno, chno);
262
263 fprintf(fpw2,"%d %d %d %d %d %d\n",imodule,irownew,icolnew,mcmno,chno,adc);
264
265 baseword = 0;
266 dataword = adc;
267 PackWord(0, 11,dataword,baseword);
268 dataword = chno;
269 PackWord(12,17,dataword,baseword);
270 dataword = mcmno;
271 PackWord(18,28,dataword,baseword);
272 dataword = 0;
273 PackWord(29,29,dataword,baseword);
274 dataword = 0;
275 PackWord(30,30,dataword,baseword);
276 dataword = 1;
277 PackWord(31,31,dataword,baseword);
278
279 buffer[ient] = baseword;
280
281
282
283 // fprintf(fpw1,"%d %d %d %d %d\n",det,smn,irow,icol,adc);
284
285 }
286
287
288}
289//____________________________________________________________________________
290void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t um,
291 Int_t row, Int_t col,
292 UInt_t &mcmno, UInt_t &chno)
293{
294 // This part will be modified once the final track layout on the PCB is
295 // designed. This will only change the coordinate of the individual cell
296 UInt_t ch[16][4] = { {3, 2, 29, 28},
297 {5, 1, 31, 27},
298 {6, 0, 30, 26},
299 {7, 4, 25, 24},
300 {8, 9, 20, 23},
301 {10, 14, 16, 22},
302 {11, 15, 17, 21},
303 {12, 13, 18, 19},
304 {35, 34, 61, 60},
305 {37, 33, 63, 59},
306 {38, 32, 62, 58},
307 {39, 36, 57, 56},
308 {40, 41, 52, 55},
309 {42, 46, 48, 54},
310 {43, 47, 49, 53},
311 {44, 45, 50, 51} };
312
313 if (ddlno == 0 || ddlno == 1)
314 {
315 // PRE plane, SU Mod = 1, 2
316 Int_t irownew = row%16;
317 Int_t icolnew = col%4;
318 Int_t irowdiv = row/16;
319 Int_t icoldiv = col/4;
320
321 mcmno = 72*um + 6*icoldiv + irowdiv;
322 chno = ch[irownew][icolnew];
323 }
324 else if (ddlno == 2 || ddlno == 3)
325 {
326 // PRE plane, SU Mod = 3, 4
327 Int_t irownew = row%16;
328 Int_t icolnew = col%4;
329 Int_t irowdiv = row/16;
330 Int_t icoldiv = col/4;
331
332 mcmno = 72*um + 3*icoldiv + irowdiv;
333 chno = ch[irownew][icolnew];
334 }
335 else if (ddlno == 4)
336 {
337 // CPV plane, SU Mod = 1, 2
338 Int_t irownew = row%16;
339 Int_t icolnew = col%4;
340 Int_t irowdiv = row/16;
341 Int_t icoldiv = col/4;
342
343 mcmno = 72*um + 6*icoldiv + irowdiv;
344 chno = ch[irownew][icolnew];
345 }
346 else if (ddlno == 5)
347 {
348 // CPV plane, SU Mod = 3, 4
349 Int_t irownew = row%16;
350 Int_t icolnew = col%4;
351 Int_t irowdiv = row/16;
352 Int_t icoldiv = col/4;
353
354 mcmno = 72*um + 3*icoldiv + irowdiv;
355 chno = ch[irownew][icolnew];
356 }
357
358}
359//____________________________________________________________________________
360
361void AliPMDDDLRawData::GetRowCol(Int_t ddlno, UInt_t mcmno, UInt_t chno,
362 Int_t &um, Int_t &row, Int_t &col)
363{
364 UInt_t ch[64] = { 9, 5, 1, 0, 13, 4, 8, 12,
365 16, 17, 20, 24, 28, 29, 21, 25,
366 22, 26, 30, 31, 18, 27, 23, 19,
367 15, 14, 11, 7, 3, 2, 10, 6,
368 41, 37, 33, 32, 45, 36, 40, 44,
369 48, 49, 52, 56, 60, 61, 53, 57,
370 54, 58, 62, 63, 50, 59, 55, 51,
371 47, 46, 43, 39, 35, 34, 42, 38 };
372
373 if (ddlno == 1 || ddlno == 2)
374 {
375 um = mcmno/72;
376 Int_t mcmnonew = mcmno - 72*um;
377 Int_t rowcol = ch[chno];
378 Int_t irownew = rowcol/4;
379 Int_t icolnew = rowcol%4;
380
381 Int_t remmcm = mcmnonew%6;
382 Int_t divmcm = mcmnonew/6;
383
384 row = 16*remmcm + irownew;
385 col = 4*divmcm + icolnew;
386 }
387 else if (ddlno == 3 || ddlno == 4)
388 {
389 um = mcmno/72;
390 Int_t mcmnonew = mcmno - 72*um;
391 Int_t rowcol = ch[chno];
392 Int_t irownew = rowcol/4;
393 Int_t icolnew = rowcol%4;
394
395 Int_t remmcm = mcmnonew%3;
396 Int_t divmcm = mcmnonew/3;
397
398 row = 16*remmcm + irownew;
399 col = 4*divmcm + icolnew;
400 }
401 else if (ddlno == 4)
402 {
403 um = mcmno/144;
404 Int_t mcmnonew = mcmno - 72*um;
405 Int_t rowcol = ch[chno];
406 Int_t irownew = rowcol/4;
407 Int_t icolnew = rowcol%4;
408
409 Int_t remmcm = mcmnonew%6;
410 Int_t divmcm = mcmnonew/6;
411
412 row = 16*remmcm + irownew;
413 col = 4*divmcm + icolnew;
414 }
415 else if (ddlno == 5)
416 {
417 um = mcmno/144;
418 Int_t mcmnonew = mcmno - 72*um;
419 Int_t rowcol = ch[chno];
420 Int_t irownew = rowcol/4;
421 Int_t icolnew = rowcol%4;
422
423 Int_t remmcm = mcmnonew%3;
424 Int_t divmcm = mcmnonew/3;
425
426 row = 16*remmcm + irownew;
427 col = 4*divmcm + icolnew;
428 }
429
430
431}
432//____________________________________________________________________________
433
434void AliPMDDDLRawData::PackWord(UInt_t startbit, UInt_t stopbit,
435 UInt_t dataword, UInt_t &packedword)
436{
437 UInt_t bitLength = stopbit - startbit + 1;
438 UInt_t bitContent = (UInt_t) (TMath::Power(2,bitLength) - 1);
439 if(bitContent < dataword)
440 {
441 cout << " *** ERROR *** bitContent is less than the dataword" << endl;
442 return;
443 }
444 UInt_t packedBits = 0;
445 if (packedword != 0)
446 packedBits = (UInt_t) (TMath::Log(packedword)/TMath::Log(2));
447
448 UInt_t counter;
449 if (packedBits <= stopbit)
450 {
451 counter = 31 - stopbit;
452 }
453 else
454 {
455 counter = 31 - packedBits;
456 }
457 UInt_t dummyword = 0xFFFFFFFF;
458 dummyword >>= counter;
459 UInt_t lword = dataword << startbit;
460 UInt_t nword = lword | packedword;
461 packedword = dummyword & nword;
462
463
464}
465//____________________________________________________________________________
466void AliPMDDDLRawData::UnpackWord(UInt_t startbit, UInt_t stopbit,
467 UInt_t &dataword, UInt_t packedword)
468{
469 UInt_t bitLength = stopbit - startbit + 1;
470 UInt_t bitContent = (UInt_t) (TMath::Power(2,bitLength) - 1);
471 bitContent <<= startbit;
472 dataword = packedword & bitContent;
473 dataword >>= startbit;
474
475}
476//____________________________________________________________________________
477