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