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