AliWarnig suppression in AliTOF ctr
[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>
95ec17e6 21#include <TString.h>
22#include <TSystem.h>
28328eeb 23
ecee2a1a 24#include "AliLog.h"
a4e4efaa 25#include "AliRawDataHeader.h"
cff75ba7 26#include "AliBitPacking.h"
28328eeb 27#include "AliPMDdigit.h"
a4e4efaa 28#include "AliPMDRawStream.h"
28328eeb 29#include "AliPMDDDLRawData.h"
362c9d61 30#include "AliDAQ.h"
28328eeb 31
32ClassImp(AliPMDDDLRawData)
33
34AliPMDDDLRawData::AliPMDDDLRawData():
35 fDigits(new TClonesArray("AliPMDdigit", 1000))
36{
37 // Default Constructor
38 //
a4e4efaa 39
28328eeb 40}
41//____________________________________________________________________________
42
43AliPMDDDLRawData::~AliPMDDDLRawData()
44{
45 // Default Destructor
46 //
47
48}
49
50//____________________________________________________________________________
a4e4efaa 51void AliPMDDDLRawData::WritePMDRawData(TTree *treeD)
28328eeb 52{
53 // write digits into raw data format
54
55 ofstream outfile;
56
57 TBranch *branch = treeD->GetBranch("PMDDigit");
ecee2a1a 58 if (!branch)
59 {
60 AliError("PMD Digit branch not found");
61 return;
62 }
28328eeb 63 branch->SetAddress(&fDigits);
64
ecee2a1a 65 Int_t nmodules = (Int_t) treeD->GetEntries();
66 AliDebug(1,Form("Number of modules inside treeD = %d",nmodules));
28328eeb 67
362c9d61 68 const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
28328eeb 69 Int_t modulePerDDL = 0;
70
71
a4e4efaa 72 AliRawDataHeader header;
28328eeb 73 UInt_t sizeRawData = 0;
95ec17e6 74
75 const Int_t kSize = 1536;
28328eeb 76 UInt_t buffer[kSize];
77
95ec17e6 78 UInt_t busPatch[50][1536];
79
80 Int_t contentsBus[50];
81
28328eeb 82 Char_t filename[80];
83
95ec17e6 84
28328eeb 85 Int_t mmodule = 0;
86 for(Int_t iddl = 0; iddl < kDDL; iddl++)
87 {
362c9d61 88 strcpy(filename,AliDAQ::DdlFileName("PMD",iddl));
28328eeb 89#ifndef __DECCXX
90 outfile.open(filename,ios::binary);
91#else
92 outfile.open(filename);
93#endif
94
95 if (iddl < 4)
96 {
97 modulePerDDL = 6;
98 mmodule = 6*iddl;
28328eeb 99 }
100 else if (iddl == 4)
101 {
102 modulePerDDL = 12;
103 mmodule = 24;
28328eeb 104 }
105 else if (iddl == 5)
106 {
107 modulePerDDL = 12;
a4e4efaa 108 mmodule = 30;
28328eeb 109 }
110
28328eeb 111
95ec17e6 112
a4e4efaa 113 // Write the Dummy Data Header into the file
28328eeb 114 Int_t bHPosition = outfile.tellp();
a4e4efaa 115 outfile.write((char*)(&header),sizeof(header));
28328eeb 116
95ec17e6 117 for (Int_t ibus = 0; ibus < 50; ibus++)
118 {
119 contentsBus[ibus] = 0;
120 for (Int_t ich = 0; ich < 1536; ich++)
121 {
122 busPatch[ibus][ich] = 0;
123 }
124 }
28328eeb 125
126 for(Int_t ium = 0; ium < modulePerDDL; ium++)
127 {
95ec17e6 128 if (iddl == 4 && ium == 6) mmodule = 42;
a4e4efaa 129
28328eeb 130 // Extract energy deposition per cell and pack it
131 // in a 32-bit word and returns all the total words
132 // per one unit-module
133
95ec17e6 134 GetUMDigitsData(treeD, mmodule, iddl, contentsBus, busPatch);
28328eeb 135 mmodule++;
95ec17e6 136 }
28328eeb 137
95ec17e6 138
139
140 Int_t ij = 0;
141 Int_t dsp[10];
142 Int_t dspBus[10];
143 for (Int_t i = 0; i < 10; i++)
144 {
145 dsp[i] = 0;
146 dspBus[i] = 0;
147 for (Int_t ibus=0; ibus < 5; ibus++)
148 {
149 if (contentsBus[ij] > 0)
150 {
151 dsp[i] += contentsBus[ij];
152 dspBus[i]++;
153 }
154 ij++;
155 }
156 // Add the patch Bus header to the DSP contents
157 dsp[i] += 4*dspBus[i];
158 }
159
160 Int_t dspBlockARDL = 0;
161 Int_t dspBlockBRDL = 0;
162
163 for (Int_t i = 0; i < 5; i++)
164 {
165 Int_t ieven = 2*i;
166 Int_t iodd = 2*i + 1;
167 if (dsp[ieven] > 0)
168 {
169 dspBlockARDL += dsp[ieven];
170 dspBlockARDL += 8;
171 }
172 if (dsp[iodd] > 0)
173 {
174 dspBlockBRDL += dsp[iodd];
175 dspBlockBRDL += 8;
176 }
28328eeb 177 }
95ec17e6 178
179 // Start writing the DDL file
180 UInt_t dspRDL = 0;
181 UInt_t dspBlockHeader[8];
182 UInt_t dspHeader[8];
183 UInt_t patchBusHeader[4];
184 Int_t iskip[5];
185
186 for (Int_t iblock = 0; iblock < 2; iblock++)
187 {
188 // DSP Block Header
189
190 for (Int_t i=0; i<8; i++)
191 {
192 dspBlockHeader[i] = 0;
193 if (i == 1)
194 {
195 if (iblock == 0)
196 {
197 dspBlockHeader[1] = (UInt_t) dspBlockARDL;
198 }
199 else if (iblock == 1)
200 {
201 dspBlockHeader[1] = (UInt_t) dspBlockBRDL;
202 }
203 }
204 }
205
206 outfile.write((char*)(&dspBlockHeader),8*sizeof(UInt_t));
207
208 if (iblock == 0)
209 {
210 iskip[0] = 0;
211 iskip[1] = 10;
212 iskip[2] = 20;
213 iskip[3] = 30;
214 iskip[4] = 40;
215 }
216 else if (iblock == 1)
217 {
218 iskip[0] = 5;
219 iskip[1] = 15;
220 iskip[2] = 25;
221 iskip[3] = 35;
222 iskip[4] = 45;
223 }
28328eeb 224
95ec17e6 225 for (Int_t idsp = 0; idsp < 5; idsp++)
226 {
227 // DSP Header
228 Int_t dspno = 0;
229 if (iblock == 0)
230 {
231 dspno = 2*idsp;
232 dspRDL = (UInt_t) dsp[dspno];
233 }
234 else if (iblock == 1)
235 {
236 dspno = 2*idsp + 1;
237 dspRDL = (UInt_t) dsp[dspno];
238 }
239
240 for (Int_t i=0; i<8; i++)
241 {
242 dspHeader[i] = 0;
243 }
244 dspHeader[1] = dspRDL;
245 dspHeader[6] = dspno;
246 outfile.write((char*)(&dspHeader),8*sizeof(UInt_t));
247
248 for (Int_t ibus = 0; ibus < 5; ibus++)
249 {
250 // Patch Bus Header
251 Int_t busno = iskip[idsp] + ibus;
252 Int_t patchbusRDL = contentsBus[busno];
253
254 for (Int_t i=0; i<4; i++)
255 {
256 patchBusHeader[i] = 0;
257 }
258 patchBusHeader[1] = (UInt_t) patchbusRDL;
259 patchBusHeader[2] = (UInt_t) busno;
260
261 outfile.write((char*)(&patchBusHeader),4*sizeof(UInt_t));
262
263 for (Int_t iword = 0; iword < patchbusRDL; iword++)
264 {
265 buffer[iword] = busPatch[busno][iword];
266 }
267
268 outfile.write((char*)buffer,patchbusRDL*sizeof(UInt_t));
269
270 }
271 }
272 }
273
274
a4e4efaa 275 // Write real data header
276 // take the pointer to the beginning of the data header
28328eeb 277 // write the total number of words per ddl and bring the
278 // pointer to the current file position and close it
279 UInt_t cFPosition = outfile.tellp();
a4e4efaa 280 sizeRawData = cFPosition - bHPosition - sizeof(header);
95ec17e6 281
a4e4efaa 282 header.fSize = cFPosition - bHPosition;
283 header.SetAttribute(0); // valid data
28328eeb 284 outfile.seekp(bHPosition);
a4e4efaa 285 outfile.write((char*)(&header),sizeof(header));
28328eeb 286 outfile.seekp(cFPosition);
287
288 outfile.close();
289 } // DDL Loop over
290
291
292}
293//____________________________________________________________________________
95ec17e6 294void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule,
295 Int_t ddlno, Int_t *contentsBus,
296 UInt_t busPatch[][1536])
28328eeb 297{
e54787da 298 // Retrives digits data UnitModule by UnitModule
cff75ba7 299 UInt_t baseword;
28328eeb 300 UInt_t mcmno, chno;
301 UInt_t adc;
28328eeb 302 Int_t det, smn, irow, icol;
303
95ec17e6 304 const Int_t kMaxBus = 50;
305 Int_t totPatchBus, bPatchBus, ePatchBus;
306 Int_t ibus, totmcm, rows, cols, rowe, cole;
307 Int_t moduleno;
308 Int_t busno = 0;
309 Int_t patchBusNo[kMaxBus], mcmperBus[kMaxBus];
310 Int_t startRowBus[kMaxBus], startColBus[kMaxBus];
311 Int_t endRowBus[kMaxBus], endColBus[kMaxBus];
312
313 Int_t beginPatchBus = -1;
314 Int_t endPatchBus = -1;
315 for(Int_t i = 0; i < kMaxBus; i++)
316 {
317 patchBusNo[i] = -1;
318 mcmperBus[i] = -1;
319 startRowBus[i] = -1;
320 startColBus[i] = -1;
321 endRowBus[i] = -1;
322 endColBus[i] = -1;
323 }
324 Int_t modulePerDDL = 0;
325 if (ddlno < 4)
326 {
327 modulePerDDL = 6;
328 }
329 else if (ddlno == 4 || ddlno == 5)
330 {
331 modulePerDDL = 12;
332 }
333
334
335
336
337
338 TString fileName(gSystem->Getenv("ALICE_ROOT"));
339
340 if(ddlno == 0)
341 {
342 fileName += "/PMD/PMD_Mapping_ddl0.dat";
343 }
344 else if(ddlno == 1)
345 {
346 fileName += "/PMD/PMD_Mapping_ddl1.dat";
347 }
348 else if(ddlno == 2)
349 {
350 fileName += "/PMD/PMD_Mapping_ddl2.dat";
351 }
352 else if(ddlno == 3)
353 {
354 fileName += "/PMD/PMD_Mapping_ddl3.dat";
355 }
356 else if(ddlno == 4)
357 {
358 fileName += "/PMD/PMD_Mapping_ddl4.dat";
359 }
360 else if(ddlno == 5)
361 {
362 fileName += "/PMD/PMD_Mapping_ddl5.dat";
363 }
364
365 ifstream infile;
366 infile.open(fileName.Data(), ios::in); // ascii file
367 if(!infile)
368 AliError(Form("Could not read the mapping file for DDL No = %d",ddlno));
369
370 for (Int_t im = 0; im < modulePerDDL; im++)
371 {
372 infile >> moduleno;
373 infile >> totPatchBus >> bPatchBus >> ePatchBus;
374
375 if (moduleno == imodule)
376 {
377 beginPatchBus = bPatchBus;
378 endPatchBus = ePatchBus;
379 }
380
381 for(Int_t i=0; i<totPatchBus; i++)
382 {
383 infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
384
385 if (moduleno == imodule)
386 {
387 patchBusNo[ibus] = ibus;
388 mcmperBus[ibus] = totmcm;
389 startRowBus[ibus] = rows;
390 startColBus[ibus] = cols;
391 endRowBus[ibus] = rowe;
392 endColBus[ibus] = cole;
393 }
394 }
395
396 }
397
398 infile.close();
399
28328eeb 400 treeD->GetEntry(imodule);
401 Int_t nentries = fDigits->GetLast();
95ec17e6 402 Int_t totword = nentries+1;
28328eeb 403
404 for (Int_t ient = 0; ient < totword; ient++)
405 {
406 fPMDdigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
407
408 det = fPMDdigit->GetDetector();
409 smn = fPMDdigit->GetSMNumber();
410 irow = fPMDdigit->GetRow();
411 icol = fPMDdigit->GetColumn();
412 adc = (UInt_t) fPMDdigit->GetADC();
413
e54787da 414 TransformS2H(smn,irow,icol);
95ec17e6 415
416 GetMCMCh(ddlno, irow, icol, beginPatchBus, endPatchBus,
417 mcmperBus, startRowBus, startColBus,
418 endRowBus, endColBus, busno, mcmno, chno);
28328eeb 419
28328eeb 420 baseword = 0;
cff75ba7 421 AliBitPacking::PackWord(adc,baseword,0,11);
422 AliBitPacking::PackWord(chno,baseword,12,17);
423 AliBitPacking::PackWord(mcmno,baseword,18,28);
424 AliBitPacking::PackWord(0,baseword,29,30);
425 AliBitPacking::PackWord(1,baseword,31,31);
95ec17e6 426
427 Int_t jj = contentsBus[busno];
428 busPatch[busno][jj] = baseword;
429
430 contentsBus[busno]++;
28328eeb 431 }
432
e54787da 433}
95ec17e6 434
e54787da 435//____________________________________________________________________________
436void AliPMDDDLRawData::TransformS2H(Int_t smn, Int_t &irow, Int_t &icol)
437{
438 // Does the Software to Hardware coordinate transformation
439 //
95ec17e6 440
e54787da 441 Int_t irownew = 0;
442 Int_t icolnew = 0;
e54787da 443
444 // First in digits we have all dimension 48x96
95ec17e6 445 // Transform into the realistic one, i.e, For SM 0&1 96(row)x48(col)
446 // and for SM 2&3 48(row)x96(col)
e54787da 447 //
448 if(smn < 12)
449 {
95ec17e6 450 irownew = icol;
451 icolnew = irow;
e54787da 452 }
453 else if( smn >= 12 && smn < 24)
454 {
95ec17e6 455 irownew = irow;
456 icolnew = icol;
e54787da 457 }
458
95ec17e6 459 // In the new geometry always Geant (0,0) and Hardware (0,0) start
460 // from the top left corner
461
e54787da 462 irow = irownew;
463 icol = icolnew;
28328eeb 464
465}
e54787da 466
467
28328eeb 468//____________________________________________________________________________
e54787da 469
95ec17e6 470void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t row, Int_t col,
471 Int_t beginPatchBus, Int_t endPatchBus,
472 Int_t *mcmperBus,
473 Int_t *startRowBus, Int_t *startColBus,
474 Int_t *endRowBus, Int_t *endColBus,
475 Int_t & busno, UInt_t &mcmno, UInt_t &chno)
28328eeb 476{
477 // This part will be modified once the final track layout on the PCB is
478 // designed. This will only change the coordinate of the individual cell
a4e4efaa 479
480 static const UInt_t kCh[16][4] = { {12, 13, 18, 19},
481 {11, 15, 17, 21},
482 {10, 14, 16, 22},
483 {8, 9, 20, 23},
484 {7, 4, 25, 24},
485 {6, 0, 30, 26},
486 {5, 1, 31, 27},
487 {3, 2, 29, 28},
488 {44, 45, 50, 51},
489 {43, 47, 49, 53},
490 {42, 46, 48, 54},
491 {40, 41, 52, 55},
492 {39, 36, 57, 56},
493 {38, 32, 62, 58},
494 {37, 33, 63, 59},
495 {35, 34, 61, 60} };
28328eeb 496
95ec17e6 497 Int_t irownew = row%16;
498 Int_t icolnew = col%4;
499
500 chno = kCh[irownew][icolnew];
28328eeb 501
28328eeb 502
95ec17e6 503 for (Int_t ibus = beginPatchBus; ibus <= endPatchBus; ibus++)
504 {
505 Int_t srow = startRowBus[ibus];
506 Int_t erow = endRowBus[ibus];
507 Int_t scol = startColBus[ibus];
508 Int_t ecol = endColBus[ibus];
509 Int_t tmcm = mcmperBus[ibus];
510 if ((row >= srow && row <= erow) && (col >= scol && col <= ecol))
a4e4efaa 511 {
95ec17e6 512 busno = ibus;
28328eeb 513
95ec17e6 514 // Find out the MCM Number
515 //
516
517 if (ddlno == 0 || ddlno == 1)
518 {
519 // PRE plane, SU Mod = 0, 1
520 Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
521 if(rowdiff > 16)
522 {
523 Int_t midrow = srow + 16;
524 if(row >= srow && row < midrow)
525 {
526 mcmno = 12 + (col-scol)/4;
527 }
528 else if(row >= midrow && row < erow)
529 {
530 mcmno = (col-scol)/4;
531 }
532 }
533 else
534 {
535 mcmno = (col-scol)/4;
536 }
537 } // end of ddl 0 and 1
538 else if (ddlno == 2)
539 {
540 // PRE plane, SU Mod = 2
541
542 Int_t icolnew = (col - scol)/4;
543 mcmno = tmcm - 1 - icolnew;
544 }
545 else if (ddlno == 3)
546 {
547 // PRE plane, SU Mod = 3
548
549 Int_t icolnew = (col - scol)/4;
550 mcmno = tmcm - 1 - icolnew;
551 }
552 else if (ddlno == 4)
553 {
554 // CPV plane, SU Mod = 0, 3 : ddl = 4
555
556 if(ibus <= 20)
557 {
558 Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
559 if(rowdiff > 16)
560 {
561 Int_t midrow = srow + 16;
562 if(row >= srow && row < midrow)
563 {
564 mcmno = 12 + (col-scol)/4;
565 }
566 else if(row >= midrow && row < erow)
567 {
568 mcmno = (col-scol)/4;
569 }
570 }
571 else
572 {
573 mcmno = (col-scol)/4;
574 }
575 }
576 else if (ibus > 20)
577 {
578 Int_t icolnew = (col - scol)/4;
579 mcmno = tmcm - 1 - icolnew;
580 }
581 }
582 else if (ddlno == 5)
583 {
584 // CPV plane, SU Mod = 2, 1 : ddl = 5
585
586 if(ibus <= 20)
587 {
588 Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
589 if(rowdiff > 16)
590 {
591 Int_t midrow = srow + 16;
592 if(row >= srow && row < midrow)
593 {
594 mcmno = 12 + (col-scol)/4;
595 }
596 else if(row >= midrow && row < erow)
597 {
598 mcmno = (col-scol)/4;
599 }
600 }
601 else
602 {
603 mcmno = (col-scol)/4;
604 }
605 }
606 else if (ibus > 20)
607 {
608 Int_t icolnew = (col - scol)/4;
609 mcmno = tmcm - 1 - icolnew;
610 }
611 }
612 }
613 }
614
28328eeb 615}
616//____________________________________________________________________________
617