Trigger scalers added to ESD header.
[u/mrichter/AliRoot.git] / PMD / AliPMDRawStream.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 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 ///
20 /// This class provides access to PMD digits in raw data.
21 ///
22 /// It loops over all PMD digits in the raw data given by the AliRawReader.
23 /// The Next method goes to the next digit. If there are no digits left
24 /// it returns kFALSE.
25 /// Several getters provide information about the current digit.
26 ///
27 ///////////////////////////////////////////////////////////////////////////////
28
29 #include <Riostream.h>
30 #include <TObjArray.h>
31 #include <TString.h>
32 #include <TSystem.h>
33
34 #include "AliLog.h"
35 #include "AliPMDBlockHeader.h"
36 #include "AliPMDDspHeader.h"
37 #include "AliPMDPatchBusHeader.h"
38 #include "AliPMDddldata.h"
39 #include "AliPMDRawStream.h"
40 #include "AliRawReader.h"
41
42 ClassImp(AliPMDRawStream)
43
44
45 //_____________________________________________________________________________
46 AliPMDRawStream::AliPMDRawStream(AliRawReader* rawReader) :
47     fRawReader(rawReader),
48     fData(NULL),
49     fPosition(-1)
50 {
51 // create an object to read PMD raw digits
52
53   fRawReader->Reset();
54   fRawReader->Select("PMD");
55 }
56
57 //_____________________________________________________________________________
58 AliPMDRawStream::AliPMDRawStream(const AliPMDRawStream& stream) :
59   TObject(stream),
60   fRawReader(NULL),
61   fData(NULL),
62   fPosition(-1)
63 {
64 // copy constructor
65
66   AliFatal("Copy constructor not implemented");
67 }
68
69 //_____________________________________________________________________________
70 AliPMDRawStream& AliPMDRawStream::operator = (const AliPMDRawStream& 
71                                               /* stream */)
72 {
73 // assignment operator
74
75   AliFatal("operator = assignment operator not implemented");
76   return *this;
77 }
78
79 //_____________________________________________________________________________
80 AliPMDRawStream::~AliPMDRawStream()
81 {
82 // destructor
83
84 }
85
86
87 //_____________________________________________________________________________
88
89 Int_t AliPMDRawStream::DdlData(TObjArray *pmdddlcont)
90 {
91   // read the next raw digit
92   // returns kFALSE if there is no digit left
93   
94   Int_t iddl = -1;
95
96   AliPMDddldata *pmdddldata;
97
98   if (!fRawReader->ReadHeader()) return -1;
99
100   iddl           = fRawReader->GetDDLID();
101   Int_t dataSize = fRawReader->GetDataSize();
102   Int_t totaldataword = dataSize/4;
103
104
105   if (dataSize <= 0) return -1;
106
107   UInt_t data;
108
109   fRawReader->ReadNextData(fData);
110
111   fPosition = 0;
112
113
114   Int_t ibus;
115
116   const Int_t kNPatchBus = 51;
117
118   Int_t moduleNo[kNPatchBus], mcmperBus[kNPatchBus];
119   Int_t startRowBus[kNPatchBus], endRowBus[kNPatchBus];
120   Int_t startColBus[kNPatchBus], endColBus[kNPatchBus];
121
122   for (ibus = 0; ibus < kNPatchBus; ibus++)
123     {
124       moduleNo[ibus]    = -1;
125       mcmperBus[ibus]   = -1;
126       startRowBus[ibus] = -1;
127       endRowBus[ibus]   = -1;
128       startColBus[ibus] = -1;
129       endColBus[ibus]   = -1;
130     }
131
132   // open the ddl file info to know the module
133   TString ddlinfofileName(gSystem->Getenv("ALICE_ROOT"));
134   ddlinfofileName += "/PMD/PMD_ddl_info.dat";
135
136   ifstream infileddl;
137   infileddl.open(ddlinfofileName.Data(), ios::in); // ascii file
138   if(!infileddl) AliError("Could not read the ddl info file");
139
140   Int_t ddlno;
141   Int_t modno;
142   Int_t modulePerDDL;
143   Int_t moduleddl[6];
144
145   for(Int_t jddl = 0; jddl < 6; jddl++)
146     {
147       if (infileddl.eof()) break;
148       infileddl >> ddlno >> modulePerDDL;
149       moduleddl[jddl] = modulePerDDL;
150
151       if (modulePerDDL == 0) continue;
152       for (Int_t im = 0; im < modulePerDDL; im++)
153         {
154           infileddl >> modno;
155         }
156     }
157
158   infileddl.close();
159
160   if (iddl == 0)
161     {
162       modulePerDDL = moduleddl[iddl];
163       Ddl0Mapping(modulePerDDL, moduleNo, mcmperBus, startRowBus, 
164                   endRowBus, startColBus, endColBus);
165
166     }
167   else if (iddl == 1)
168     {
169       modulePerDDL = moduleddl[iddl];
170       Ddl1Mapping(modulePerDDL, moduleNo, mcmperBus, startRowBus, 
171                   endRowBus, startColBus, endColBus);
172       
173     }
174   else if (iddl == 2)
175     {
176       modulePerDDL = moduleddl[iddl];
177       Ddl2Mapping(modulePerDDL, moduleNo, mcmperBus, startRowBus, 
178                   endRowBus, startColBus, endColBus);
179     }
180   else if (iddl == 3)
181     {
182       modulePerDDL = moduleddl[iddl];
183       Ddl3Mapping(modulePerDDL, moduleNo, mcmperBus, startRowBus, 
184                   endRowBus, startColBus, endColBus);
185     }
186   else if (iddl == 4)
187     {
188       modulePerDDL = moduleddl[iddl];
189       Ddl4Mapping(modulePerDDL, moduleNo, mcmperBus, startRowBus, 
190                   endRowBus, startColBus, endColBus);
191     }
192   else if (iddl == 5)
193     {
194       modulePerDDL = moduleddl[iddl];
195       Ddl5Mapping(modulePerDDL, moduleNo, mcmperBus, startRowBus, 
196                   endRowBus, startColBus, endColBus);
197   }
198
199
200   AliPMDBlockHeader    blockHeader;
201   AliPMDDspHeader      dspHeader;
202   AliPMDPatchBusHeader pbusHeader;
203
204   const Int_t kblHLen   = blockHeader.GetHeaderLength();
205   const Int_t kdspHLen  = dspHeader.GetHeaderLength();
206   const Int_t kpbusHLen = pbusHeader.GetHeaderLength();
207   
208   Int_t parity;
209   Int_t idet, ismn;
210   Int_t irow = -1;
211   Int_t icol = -1;
212
213   Int_t blHeaderWord[8];
214   Int_t dspHeaderWord[10];
215   Int_t pbusHeaderWord[4];
216
217   Int_t blRawDataLength  = 0;
218   Int_t dspRawDataLength = 0;
219   Int_t iwordddl         = 2;
220
221
222
223   for (Int_t iblock = 0; iblock < 2; iblock++)
224     {
225       for (Int_t i = 0; i < kblHLen; i++)
226         {
227             iwordddl++;
228
229             blHeaderWord[i] = (Int_t) GetNextWord();
230         }
231
232       blockHeader.SetHeader(blHeaderWord);
233       blRawDataLength = blockHeader.GetRawDataLength();
234
235       if (iwordddl == totaldataword) break;
236
237       Int_t iwordblk = 0;
238
239       for (Int_t idsp = 0; idsp < 5; idsp++)
240         {
241           for (Int_t i = 0; i < kdspHLen; i++)
242             {
243                 iwordddl++;
244                 iwordblk++;
245                 dspHeaderWord[i] = (Int_t) GetNextWord();
246             }
247           dspHeader.SetHeader(dspHeaderWord);
248           dspRawDataLength = dspHeader.GetRawDataLength();
249
250           if (iwordddl == totaldataword) break;
251
252           Int_t iworddsp = 0;
253
254           for (ibus = 0; ibus < 5; ibus++)
255             {
256               for (Int_t i = 0; i < kpbusHLen; i++)
257                 {
258                     iwordddl++;
259                     iwordblk++;
260                     iworddsp++;
261                     pbusHeaderWord[i] = (Int_t) GetNextWord();
262                 }
263
264               pbusHeader.SetHeader(pbusHeaderWord);
265               Int_t rawdatalength = pbusHeader.GetRawDataLength();
266               Int_t pbusid = pbusHeader.GetPatchBusId();
267
268               if (pbusid < 0 || pbusid > 50) return -1;
269
270               Int_t imodule = moduleNo[pbusid];
271
272               if (iwordddl == totaldataword) break;
273
274               for (Int_t iword = 0; iword < rawdatalength; iword++)
275                 {
276                     iwordddl++;
277                     iwordblk++;
278                     iworddsp++;
279                     data = 0;
280                     data = GetNextWord();
281
282                   Int_t isig =  data & 0x0FFF;
283                   Int_t ich  = (data >> 12) & 0x003F;
284                   Int_t imcm = (data >> 18) & 0x07FF;
285                   Int_t ibit = (data >> 31) & 0x0001;
286
287                   if (imcm == 0)
288                     {
289                       AliWarning(Form("FEE address WRONG:: Module %d Patch Bus %d MCM %d",imodule,pbusid,imcm));
290                       return -1;
291                     }
292
293                   parity = ComputeParity(data);
294
295                   if (ibit != parity)
296                     {
297                       AliWarning(Form("Parity Error:: Patch Bus %d Module %d",pbusid,imodule));
298                       fRawReader->AddMajorErrorLog(kParityError);
299                       return -1;
300                     }
301
302                   ConvertDDL2SMN(iddl, imodule, ismn, idet);
303
304                   GetRowCol(imodule, pbusid, imcm, ich, 
305                             startRowBus, endRowBus,
306                             startColBus, endColBus,
307                             irow, icol);
308
309
310                   TransformH2S(ismn, irow, icol);
311
312                   pmdddldata = new AliPMDddldata();
313
314                   pmdddldata->SetDetector(idet);
315                   pmdddldata->SetSMN(ismn);
316                   pmdddldata->SetModule(imodule);
317                   pmdddldata->SetPatchBusId(pbusid);
318                   pmdddldata->SetMCM(imcm);
319                   pmdddldata->SetChannel(ich);
320                   pmdddldata->SetRow(irow);
321                   pmdddldata->SetColumn(icol);
322                   pmdddldata->SetSignal(isig);
323                   pmdddldata->SetParityBit(ibit);
324                   
325                   pmdddlcont->Add(pmdddldata);
326
327                 } // data word loop
328
329
330               if (iwordddl == totaldataword) break;
331
332               if (dspHeader.GetPaddingWord() == 1)
333               {
334                   if (iworddsp == dspRawDataLength-1) break; // raw data
335               }
336               else
337               {
338                   if (iworddsp == dspRawDataLength) break; // raw data
339               }
340
341
342             } // patch bus loop
343
344
345           if (dspHeader.GetPaddingWord() == 1)
346           {
347               iwordddl++;
348               iwordblk++;
349               iworddsp++;
350               data = GetNextWord();
351           }
352           if (iwordddl == totaldataword) break;
353
354           if (iwordblk == blRawDataLength) break; // for raw data
355
356
357         } // end of DSP
358
359     } // end of BLOCK
360   
361   return iddl;
362 }
363 //_____________________________________________________________________________
364 void AliPMDRawStream::GetRowCol(Int_t imodule, Int_t pbusid,
365                                 UInt_t mcmno, UInt_t chno,
366                                 Int_t startRowBus[], Int_t endRowBus[],
367                                 Int_t startColBus[], Int_t endColBus[],
368                                 Int_t &row, Int_t &col) const
369 {
370   // decode: ddlno, patchbusid, mcmno, chno -> um, row, col
371
372   UInt_t iCh[64];
373
374   static const UInt_t kChDdl01[64] = { 9, 6, 5, 10, 1, 2, 0, 3,
375                                        13, 7, 4, 11, 8, 14, 12, 15,
376                                        16, 19, 17, 23, 20, 27, 24, 18,
377                                        28, 31, 29, 30, 21, 26, 25, 22,
378                                        41, 38, 37, 42, 33, 34, 32, 35,
379                                        45, 39, 36, 43, 40, 46, 44, 47,
380                                        48, 51, 49, 55, 52, 59, 56, 50,
381                                        60, 63, 61, 62, 53, 58, 57, 54 };
382     
383   static const UInt_t kChDdl23[64] = { 54, 57, 58, 53, 62, 61, 63, 60,
384                                        50, 56, 59, 52, 55, 49, 51, 48,
385                                        47, 44, 46, 40, 43, 36, 39, 45,
386                                        35, 32, 34, 33, 42, 37, 38, 41,
387                                        22, 25, 26, 21, 30, 29, 31, 28,
388                                        18, 24, 27, 20, 23, 17, 19, 16,
389                                        15, 12, 14, 8, 11, 4, 7, 13,
390                                        3, 0, 2, 1, 10, 5, 6, 9 };
391   
392   static const UInt_t kChDdl41[64] = { 53, 58, 57, 54, 61, 62, 60, 63,
393                                        49, 59, 56, 55, 52, 50, 48, 51,
394                                        44, 47, 45, 43, 40, 39, 36, 46,
395                                        32, 35, 33, 34, 41, 38, 37, 42,
396                                        21, 26, 25, 22, 29, 30, 28, 31,
397                                        17, 27, 24, 23, 20, 18, 16, 19,
398                                        12, 15, 13, 11, 8, 7, 4, 14,
399                                        0, 3, 1, 2, 9, 6, 5, 10 };
400   
401   static const UInt_t kChDdl42[64] = { 10, 5, 6, 9, 2, 1, 3, 0,
402                                        14, 4, 7, 8, 11, 13, 15, 12,
403                                        19, 16, 18, 20, 23, 24, 27, 17,
404                                        31, 28, 30, 29, 22, 25, 26, 21,
405                                        42, 37, 38, 41, 34, 33, 35, 32,
406                                        46, 36, 39, 40, 43, 45, 47, 44,
407                                        51, 48, 50, 52, 55, 56, 59, 49,
408                                        63, 60, 62, 61, 54, 57, 58, 53 };
409   
410   static const UInt_t kChDdl51[64] = { 10, 5, 6, 9, 2, 1, 3, 0,
411                                        14, 4, 7, 8, 11, 13, 15, 12,
412                                        19, 16, 18, 20, 23, 24, 27, 17,
413                                        31, 28, 30, 29, 22, 25, 26, 21,
414                                        42, 37, 38, 41, 34, 33, 35, 32,
415                                        46, 36, 39, 40, 43, 45, 47, 44,
416                                        51, 48, 50, 52, 55, 56, 59, 49,
417                                        63, 60, 62, 61, 54, 57, 58, 53 };
418   
419   static const UInt_t kChDdl52[64] = { 53, 58, 57, 54, 61, 62, 60, 63,
420                                        49, 59, 56, 55, 52, 50, 48, 51,
421                                        44, 47, 45, 43, 40, 39, 36, 46,
422                                        32, 35, 33, 34, 41, 38, 37, 42,
423                                        21, 26, 25, 22, 29, 30, 28, 31,
424                                        17, 27, 24, 23, 20, 18, 16, 19,
425                                        12, 15, 13, 11, 8, 7, 4, 14,
426                                        0, 3, 1, 2, 9, 6, 5, 10 };
427   
428   for (Int_t i = 0; i < 64; i++)
429     {
430       if(imodule < 6)                    iCh[i] = kChDdl01[i];
431       if(imodule >= 6 && imodule <= 11)  iCh[i] = kChDdl01[i];
432       if(imodule >= 12 && imodule <= 17) iCh[i] = kChDdl23[i];
433       if(imodule >= 18 && imodule <= 23) iCh[i] = kChDdl23[i];
434       if(imodule >= 24 && imodule <= 29) iCh[i] = kChDdl41[i];
435       if(imodule >= 42 && imodule <= 47) iCh[i] = kChDdl42[i];
436       if(imodule >= 36 && imodule <= 41) iCh[i] = kChDdl51[i];
437       if(imodule >= 30 && imodule <= 35) iCh[i] = kChDdl52[i];
438     }
439   
440   
441   Int_t rowcol  = iCh[chno];
442   Int_t irownew = rowcol/4;
443   Int_t icolnew = rowcol%4;
444
445
446   if (imodule < 6 )
447     {
448       row = startRowBus[pbusid] + irownew;
449       col = startColBus[pbusid] + (mcmno-1)*4 + icolnew;
450     }
451   else if (imodule >= 6 && imodule < 12)
452     {
453       row = endRowBus[pbusid] - (15 - irownew);
454       col = startColBus[pbusid] + (mcmno-1)*4 + icolnew;
455       
456     }
457   else if (imodule >= 12 && imodule < 18 )
458     {
459       row = startRowBus[pbusid] + irownew;
460       col = endColBus[pbusid] - (mcmno-1)*4 - (3 - icolnew);
461     }
462   else if (imodule >= 18 && imodule < 24)
463     {
464       row = endRowBus[pbusid] - (15 - irownew);
465       col = endColBus[pbusid] - (mcmno-1)*4 - (3 - icolnew);
466     }
467   else if (imodule >= 24 && imodule < 30)
468     {
469       Int_t rowdiff = endRowBus[pbusid] - startRowBus[pbusid];
470       if(rowdiff > 16)
471         {
472           if (mcmno <= 12)
473             {
474               // Add 16 to skip the 1st 15 rows
475               row = startRowBus[pbusid] + irownew + 16;
476               col = startColBus[pbusid] + (mcmno-1)*4 + icolnew;
477             }
478           else if(mcmno > 12)
479             {
480               row = startRowBus[pbusid] + irownew;
481               col = startColBus[pbusid] + (mcmno-12-1)*4 + icolnew;
482             }
483         }
484       else if (rowdiff < 16)
485         {
486           row = startRowBus[pbusid] + irownew;
487           col = startColBus[pbusid] + (mcmno-1)*4 + icolnew;
488         }
489     }
490   else if (imodule >= 42 && imodule < 48)
491     {
492       Int_t rowdiff = endRowBus[pbusid] - startRowBus[pbusid];
493
494       if (mcmno <= 12)
495         {
496           col = endColBus[pbusid] - (mcmno-1)*4 - (3 - icolnew); 
497           
498           if(rowdiff > 16)
499             row = endRowBus[pbusid] - (15 - irownew) - 16 ;
500           else
501             row = endRowBus[pbusid] - (15 - irownew) ;
502         }
503       else if(mcmno > 12)
504         {
505           row = endRowBus[pbusid] - (15 - irownew)  ;
506           col = endColBus[pbusid] - (mcmno - 12 - 1)*4 - (3 - icolnew);
507         }
508     }
509
510
511
512   else if (imodule >= 30 && imodule < 36)
513     {
514       if (mcmno > 12)
515         {
516           // Subtract 16 to skip the 1st 15 rows
517           row = endRowBus[pbusid] - 16 -(15 - irownew);
518           col = startColBus[pbusid] + (mcmno-12 -1)*4 + icolnew;
519         }
520       else
521         {
522           row = endRowBus[pbusid]  - (15 - irownew) ;
523           col = startColBus[pbusid] + (mcmno -1)*4 + icolnew;
524         }
525
526     }
527       
528   else if (imodule >= 36 && imodule < 42)
529     {
530       if(mcmno > 12)
531         {
532           // Add 16 to skip the 1st 15 rows
533           row = startRowBus[pbusid] + irownew + 16;
534           col = endColBus[pbusid] - (mcmno - 12 - 1)*4 - (3 - icolnew);
535         }
536       else 
537         {
538           row = startRowBus[pbusid] + irownew ;
539           col = endColBus[pbusid] - (mcmno - 1)*4 - (3 - icolnew); 
540         }
541     }
542
543
544 }
545 //_____________________________________________________________________________
546 void AliPMDRawStream::ConvertDDL2SMN(Int_t iddl, Int_t imodule,
547                                      Int_t &smn, Int_t &detector) const
548 {
549   // This converts the DDL number (0 to 5), Module Number (0-47)
550   // to Serial module number in one detector (SMN : 0-23) and
551   // detector number (0:PRE plane, 1:CPV plane)
552   if (iddl < 4)
553     {
554       smn = imodule;
555       detector = 0;
556     }
557   else
558     {
559       smn = imodule - 24;
560       detector = 1;
561     }
562 }
563 //_____________________________________________________________________________
564
565 void AliPMDRawStream::TransformH2S(Int_t smn, Int_t &row, Int_t &col) const
566 {
567   // This does the transformation of the hardware coordinate to
568   // software 
569   // i.e., For SuperModule 0 &1, instead of 96x48(hardware),
570   // it is 48x96 (software)
571   // For Supermodule 3 & 4, 48x96
572
573   Int_t irownew  = 0;
574   Int_t icolnew  = 0;
575
576   if(smn < 12)
577     {
578       irownew = col;
579       icolnew = row;
580     }
581   else if(smn >= 12 && smn < 24)
582     {
583       irownew = row;
584       icolnew = col;
585     }
586
587   row = irownew;
588   col = icolnew;
589 }
590 //_____________________________________________________________________________
591 Int_t AliPMDRawStream::ComputeParity(UInt_t data)
592 {
593 // Calculate the parity bit
594
595   Int_t count = 0;
596   for(Int_t j = 0; j<29; j++)
597     {
598       if (data & 0x01 ) count++;
599       data >>= 1;
600     }
601   
602   Int_t parity = count%2;
603
604   return parity;
605 }
606
607 //_____________________________________________________________________________
608 UInt_t AliPMDRawStream::GetNextWord()
609 {
610     // Returns the next 32 bit word
611     // inside the raw data payload.
612
613     if (!fData || fPosition < 0) AliFatal("Raw data payload buffer is not yet initialized !");
614
615     UInt_t word = 0;
616     word |= fData[fPosition++];
617     word |= fData[fPosition++] << 8;
618     word |= fData[fPosition++] << 16;
619     word |= fData[fPosition++] << 24;
620
621     return word;
622 }
623
624 //_____________________________________________________________________________
625 void AliPMDRawStream::Ddl0Mapping(Int_t modulePerDDL, 
626                                   Int_t moduleNo[],    Int_t mcmperBus[],
627                                   Int_t startRowBus[], Int_t endRowBus[],
628                                   Int_t startColBus[], Int_t endColBus[])
629 {
630   // DDL0 Mapping 
631
632   Int_t moduleno, totPatchBus, bPatchBus, ePatchBus;
633   Int_t ibus, totmcm, rows, rowe, cols, cole;
634
635   TString fileName(gSystem->Getenv("ALICE_ROOT"));
636   fileName += "/PMD/PMD_Mapping_ddl0.dat";
637
638   ifstream infile;
639   infile.open(fileName.Data(), ios::in); // ascii file
640   if(!infile)
641     AliError("Could not read the mapping file for DDL No = 0");
642
643   for (Int_t im = 0; im < modulePerDDL; im++)
644     {
645       infile >> moduleno;
646       infile >> totPatchBus >> bPatchBus >> ePatchBus;
647       
648       if (totPatchBus == 0) continue;
649
650       for(Int_t i=0; i<totPatchBus; i++)
651         {
652           infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
653           
654           moduleNo[ibus]     = moduleno;
655           mcmperBus[ibus]    = totmcm;
656           startRowBus[ibus]  = rows;
657           startColBus[ibus]  = cols;
658           endRowBus[ibus]    = rowe;
659           endColBus[ibus]    = cole;
660           
661         }
662       
663     }
664   
665   infile.close();
666
667 }
668
669 //_____________________________________________________________________________
670 void AliPMDRawStream::Ddl1Mapping(Int_t modulePerDDL,
671                                   Int_t moduleNo[],    Int_t mcmperBus[],
672                                   Int_t startRowBus[], Int_t endRowBus[],
673                                   Int_t startColBus[], Int_t endColBus[])
674 {
675   // DDL1 Mapping 
676
677   Int_t moduleno, totPatchBus, bPatchBus, ePatchBus;
678   Int_t ibus, totmcm, rows, rowe, cols, cole;
679
680   TString fileName(gSystem->Getenv("ALICE_ROOT"));
681   fileName += "/PMD/PMD_Mapping_ddl1.dat";
682
683   ifstream infile;
684   infile.open(fileName.Data(), ios::in); // ascii file
685   if(!infile)
686     AliError("Could not read the mapping file for DDL No = 1");
687
688   for (Int_t im = 0; im < modulePerDDL; im++)
689     {
690       infile >> moduleno;
691       infile >> totPatchBus >> bPatchBus >> ePatchBus;
692
693       if (totPatchBus == 0) continue;
694
695       for(Int_t i=0; i<totPatchBus; i++)
696         {
697           infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
698           
699           moduleNo[ibus]     = moduleno;
700           mcmperBus[ibus]    = totmcm;
701           startRowBus[ibus]  = rows;
702           startColBus[ibus]  = cols;
703           endRowBus[ibus]    = rowe;
704           endColBus[ibus]    = cole;
705           
706         }
707       
708     }
709   
710   infile.close();
711
712 }
713
714 //_____________________________________________________________________________
715 void AliPMDRawStream::Ddl2Mapping(Int_t modulePerDDL,
716                                   Int_t moduleNo[],    Int_t mcmperBus[],
717                                   Int_t startRowBus[], Int_t endRowBus[],
718                                   Int_t startColBus[], Int_t endColBus[])
719 {
720   // DDL2 Mapping 
721
722   Int_t moduleno, totPatchBus, bPatchBus, ePatchBus;
723   Int_t ibus, totmcm, rows, rowe, cols, cole;
724
725
726   TString fileName(gSystem->Getenv("ALICE_ROOT"));
727   fileName += "/PMD/PMD_Mapping_ddl2.dat";
728
729   ifstream infile;
730   infile.open(fileName.Data(), ios::in); // ascii file
731   if(!infile)
732     AliError("Could not read the mapping file for DDL No = 2");
733
734   for (Int_t im = 0; im < modulePerDDL; im++)
735     {
736       infile >> moduleno;
737       infile >> totPatchBus >> bPatchBus >> ePatchBus;
738
739       if (totPatchBus == 0) continue;
740
741       for(Int_t i=0; i<totPatchBus; i++)
742         {
743           infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
744           
745           moduleNo[ibus]     = moduleno;
746           mcmperBus[ibus]    = totmcm;
747           startRowBus[ibus]  = rows;
748           startColBus[ibus]  = cols;
749           endRowBus[ibus]    = rowe;
750           endColBus[ibus]    = cole;
751           
752         }
753       
754     }
755   
756   infile.close();
757
758 }
759
760 //_____________________________________________________________________________
761 void AliPMDRawStream::Ddl3Mapping(Int_t modulePerDDL,
762                                   Int_t moduleNo[],    Int_t mcmperBus[],
763                                   Int_t startRowBus[], Int_t endRowBus[],
764                                   Int_t startColBus[], Int_t endColBus[])
765 {
766   // DDL3 Mapping 
767
768   Int_t moduleno, totPatchBus, bPatchBus, ePatchBus;
769   Int_t ibus, totmcm, rows, rowe, cols, cole;
770
771   TString fileName(gSystem->Getenv("ALICE_ROOT"));
772   fileName += "/PMD/PMD_Mapping_ddl3.dat";
773
774   ifstream infile;
775   infile.open(fileName.Data(), ios::in); // ascii file
776   if(!infile)
777     AliError("Could not read the mapping file for DDL No = 3");
778
779   for (Int_t im = 0; im < modulePerDDL; im++)
780     {
781       infile >> moduleno;
782       infile >> totPatchBus >> bPatchBus >> ePatchBus;
783
784       if (totPatchBus == 0) continue;
785
786       for(Int_t i=0; i<totPatchBus; i++)
787         {
788           infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
789           
790           moduleNo[ibus]     = moduleno;
791           mcmperBus[ibus]    = totmcm;
792           startRowBus[ibus]  = rows;
793           startColBus[ibus]  = cols;
794           endRowBus[ibus]    = rowe;
795           endColBus[ibus]    = cole;
796           
797         }
798       
799     }
800   
801   infile.close();
802
803 }
804
805 //_____________________________________________________________________________
806 void AliPMDRawStream::Ddl4Mapping(Int_t modulePerDDL,
807                                   Int_t moduleNo[],    Int_t mcmperBus[],
808                                   Int_t startRowBus[], Int_t endRowBus[],
809                                   Int_t startColBus[], Int_t endColBus[])
810 {
811   // DDL4 Mapping 
812
813   Int_t moduleno, totPatchBus, bPatchBus, ePatchBus;
814   Int_t ibus, totmcm, rows, rowe, cols, cole;
815
816   TString fileName(gSystem->Getenv("ALICE_ROOT"));
817   fileName += "/PMD/PMD_Mapping_ddl4.dat";
818
819   ifstream infile;
820   infile.open(fileName.Data(), ios::in); // ascii file
821   if(!infile)
822     AliError("Could not read the mapping file for DDL No = 4");
823
824   for (Int_t im = 0; im < modulePerDDL; im++)
825     {
826       infile >> moduleno;
827       infile >> totPatchBus >> bPatchBus >> ePatchBus;
828
829       if (totPatchBus == 0) continue;
830
831       for(Int_t i=0; i<totPatchBus; i++)
832         {
833           infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
834           
835           moduleNo[ibus]     = moduleno;
836           mcmperBus[ibus]    = totmcm;
837           startRowBus[ibus]  = rows;
838           startColBus[ibus]  = cols;
839           endRowBus[ibus]    = rowe;
840           endColBus[ibus]    = cole;
841           
842         }
843       
844     }
845   
846   infile.close();
847         
848 }
849
850 //_____________________________________________________________________________
851 void AliPMDRawStream::Ddl5Mapping(Int_t modulePerDDL,
852                                   Int_t moduleNo[],    Int_t mcmperBus[],
853                                   Int_t startRowBus[], Int_t endRowBus[],
854                                   Int_t startColBus[], Int_t endColBus[])
855 {
856   // DDL5 Mapping 
857
858   Int_t moduleno, totPatchBus, bPatchBus, ePatchBus;
859   Int_t ibus, totmcm, rows, rowe, cols, cole;
860
861
862   TString fileName(gSystem->Getenv("ALICE_ROOT"));
863   fileName += "/PMD/PMD_Mapping_ddl5.dat";
864
865   ifstream infile;
866   infile.open(fileName.Data(), ios::in); // ascii file
867   if(!infile)
868     AliError("Could not read the mapping file for DDL No = 5");
869
870   for (Int_t im = 0; im < modulePerDDL; im++)
871     {
872       infile >> moduleno;
873       infile >> totPatchBus >> bPatchBus >> ePatchBus;
874
875       if (totPatchBus == 0) continue;
876
877       for(Int_t i=0; i<totPatchBus; i++)
878         {
879           infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
880           
881           moduleNo[ibus]     = moduleno;
882           mcmperBus[ibus]    = totmcm;
883           startRowBus[ibus]  = rows;
884           startColBus[ibus]  = cols;
885           endRowBus[ibus]    = rowe;
886           endColBus[ibus]    = cole;
887           
888         }
889       
890     }
891   
892   infile.close();
893         
894 }
895
896