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