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