]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - PMD/AliPMDRawStream.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
cosmetics
[u/mrichter/AliRoot.git] / PMD / AliPMDRawStream.cxx
... / ...
CommitLineData
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
46ClassImp(AliPMDRawStream)
47
48
49//_____________________________________________________________________________
50AliPMDRawStream::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//_____________________________________________________________________________
63AliPMDRawStream::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//_____________________________________________________________________________
76AliPMDRawStream& AliPMDRawStream::operator = (const AliPMDRawStream&
77 /* stream */)
78{
79// assignment operator
80
81 AliFatal("operator = assignment operator not implemented");
82 return *this;
83}
84
85//_____________________________________________________________________________
86AliPMDRawStream::~AliPMDRawStream()
87{
88// destructor
89
90}
91
92
93//_____________________________________________________________________________
94
95Int_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//_____________________________________________________________________________
341void 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//_____________________________________________________________________________
523void 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
542void 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//_____________________________________________________________________________
568Int_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//_____________________________________________________________________________
585UInt_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//_____________________________________________________________________________
602void 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//_____________________________________________________________________________
623void 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//_____________________________________________________________________________
646void 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//_____________________________________________________________________________
668void 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//_____________________________________________________________________________
690void 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//_____________________________________________________________________________
713void 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
735AliPMDMappingData* 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