]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PMD/AliPMDDDLRawData.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ZDC automatic scripts updates (Marco Leoncino) + updates in QA config
[u/mrichter/AliRoot.git] / PMD / AliPMDDDLRawData.cxx
CommitLineData
28328eeb 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#include <Riostream.h>
17#include <TClonesArray.h>
18#include <TTree.h>
19#include <TBranch.h>
20#include <TMath.h>
95ec17e6 21#include <TString.h>
22#include <TSystem.h>
28328eeb 23
ecee2a1a 24#include "AliLog.h"
f7ee745b 25#include "AliRawDataHeaderSim.h"
cff75ba7 26#include "AliBitPacking.h"
28328eeb 27#include "AliPMDdigit.h"
0a666212 28#include "AliPMDBlockHeader.h"
29#include "AliPMDDspHeader.h"
30#include "AliPMDPatchBusHeader.h"
a4e4efaa 31#include "AliPMDRawStream.h"
ab0cde47 32#include "AliPMDddlinfoData.h"
33#include "AliPMDMappingData.h"
28328eeb 34#include "AliPMDDDLRawData.h"
362c9d61 35#include "AliDAQ.h"
08f92f14 36#include "AliFstream.h"
ab0cde47 37#include "AliCDBManager.h"
38#include "AliCDBStorage.h"
39#include "AliCDBEntry.h"
28328eeb 40
41ClassImp(AliPMDDDLRawData)
42
43AliPMDDDLRawData::AliPMDDDLRawData():
ab0cde47 44 fDdlinfo(GetDdlinfoData()),
45 fMapData(GetMappingData()),
28328eeb 46 fDigits(new TClonesArray("AliPMDdigit", 1000))
47{
48 // Default Constructor
49 //
a4e4efaa 50
28328eeb 51}
a48edddd 52//____________________________________________________________________________
53AliPMDDDLRawData::AliPMDDDLRawData(const AliPMDDDLRawData& ddlraw):
54 TObject(ddlraw),
ab0cde47 55 fDdlinfo(ddlraw.fDdlinfo),
56 fMapData(ddlraw.fMapData),
a48edddd 57 fDigits(ddlraw.fDigits)
58{
59 //Copy Constructor
60}
61//____________________________________________________________________________
62AliPMDDDLRawData & AliPMDDDLRawData::operator=(const AliPMDDDLRawData& ddlraw)
63{
64 //Assignment operator
65 if(this != &ddlraw)
66 {
ab0cde47 67 fDdlinfo = ddlraw.fDdlinfo;
68 fMapData = ddlraw.fMapData;
69 fDigits = ddlraw.fDigits;
a48edddd 70 }
71 return *this;
72}
28328eeb 73//____________________________________________________________________________
74
75AliPMDDDLRawData::~AliPMDDDLRawData()
76{
77 // Default Destructor
78 //
79
80}
81
82//____________________________________________________________________________
a4e4efaa 83void AliPMDDDLRawData::WritePMDRawData(TTree *treeD)
28328eeb 84{
85 // write digits into raw data format
86
08f92f14 87 AliFstream *outfile;
28328eeb 88
89 TBranch *branch = treeD->GetBranch("PMDDigit");
ecee2a1a 90 if (!branch)
91 {
92 AliError("PMD Digit branch not found");
93 return;
94 }
28328eeb 95 branch->SetAddress(&fDigits);
96
ecee2a1a 97 Int_t nmodules = (Int_t) treeD->GetEntries();
98 AliDebug(1,Form("Number of modules inside treeD = %d",nmodules));
28328eeb 99
362c9d61 100 const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
28328eeb 101
102
f7ee745b 103 AliRawDataHeaderSim header;
6d8de07c 104 // UInt_t sizeRawData = 0; //coverity (8443) fix satya (1/9/2014)
95ec17e6 105
40f4a63f 106 const Int_t kbusSize = 51;
95ec17e6 107 const Int_t kSize = 1536;
28328eeb 108 UInt_t buffer[kSize];
109
40f4a63f 110 UInt_t busPatch[kbusSize][1536];
95ec17e6 111
40f4a63f 112 Int_t contentsBus[kbusSize];
95ec17e6 113
0eb2bde4 114 Char_t filename[80];
28328eeb 115
ab0cde47 116 Int_t modulePerDDL = 0;
28328eeb 117 Int_t mmodule = 0;
08cf9354 118 Int_t ddlno;
ab0cde47 119 Int_t modulenoddl[12] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
08cf9354 120
28328eeb 121 for(Int_t iddl = 0; iddl < kDDL; iddl++)
122 {
ab0cde47 123 ddlno = iddl;
124 modulePerDDL = fDdlinfo->GetNoOfModulePerDdl(iddl);
08cf9354 125 if (modulePerDDL == 0) continue;
ab0cde47 126 for (Int_t im = 0; im < 12; im++)
08cf9354 127 {
ab0cde47 128 modulenoddl[im] = fDdlinfo->GetModulesPerDdl(iddl,im);;
08cf9354 129 }
130
0eb2bde4 131 strncpy(filename,AliDAQ::DdlFileName("PMD",iddl),79);
08f92f14 132
133 outfile = new AliFstream(filename);
28328eeb 134
a4e4efaa 135 // Write the Dummy Data Header into the file
08f92f14 136 Int_t bHPosition = outfile->Tellp();
137 outfile->WriteBuffer((char*)(&header),sizeof(header));
28328eeb 138
40f4a63f 139 for (Int_t ibus = 0; ibus < kbusSize; ibus++)
95ec17e6 140 {
141 contentsBus[ibus] = 0;
40f4a63f 142 for (Int_t ich = 0; ich < kSize; ich++)
95ec17e6 143 {
144 busPatch[ibus][ich] = 0;
145 }
146 }
28328eeb 147
ab0cde47 148 for(Int_t ium = 0; ium < 12; ium++)
28328eeb 149 {
28328eeb 150 // Extract energy deposition per cell and pack it
151 // in a 32-bit word and returns all the total words
152 // per one unit-module
153
08cf9354 154 mmodule = modulenoddl[ium];
ab0cde47 155 if(mmodule == -1) continue;
156 GetUMDigitsData(treeD, mmodule, iddl, contentsBus, busPatch);
95ec17e6 157 }
28328eeb 158
95ec17e6 159 Int_t ij = 0;
160 Int_t dsp[10];
161 Int_t dspBus[10];
162 for (Int_t i = 0; i < 10; i++)
163 {
164 dsp[i] = 0;
165 dspBus[i] = 0;
166 for (Int_t ibus=0; ibus < 5; ibus++)
167 {
40f4a63f 168 ij++;
95ec17e6 169 if (contentsBus[ij] > 0)
170 {
171 dsp[i] += contentsBus[ij];
95ec17e6 172 }
080bdcd5 173 dspBus[i]++;
95ec17e6 174 }
175 // Add the patch Bus header to the DSP contents
176 dsp[i] += 4*dspBus[i];
177 }
178
0a666212 179 Int_t dspBlockARDL = 0;
180 Int_t dspBlockBRDL = 0;
722ccc67 181 Int_t remainder = 0;
182
0a666212 183
95ec17e6 184 for (Int_t i = 0; i < 5; i++)
185 {
186 Int_t ieven = 2*i;
187 Int_t iodd = 2*i + 1;
188 if (dsp[ieven] > 0)
189 {
190 dspBlockARDL += dsp[ieven];
722ccc67 191 remainder = dsp[ieven]%2;
0a666212 192 if (remainder == 1)
193 {
194 dspBlockARDL++;
195 }
95ec17e6 196 }
197 if (dsp[iodd] > 0)
198 {
199 dspBlockBRDL += dsp[iodd];
722ccc67 200 remainder = dsp[iodd]%2;
0a666212 201 if (remainder == 1)
202 {
722ccc67 203 dspBlockBRDL++;
0a666212 204 }
95ec17e6 205 }
28328eeb 206 }
722ccc67 207
91e6e2a0 208 dspBlockARDL += 50;
209 dspBlockBRDL += 50;
210
95ec17e6 211 // Start writing the DDL file
0a666212 212
213 AliPMDBlockHeader blHeader;
214 AliPMDDspHeader dspHeader;
215 AliPMDPatchBusHeader pbusHeader;
216
217 const Int_t kblHLen = blHeader.GetHeaderLength();
218 const Int_t kdspHLen = dspHeader.GetHeaderLength();
219 const Int_t kpbusHLen = pbusHeader.GetHeaderLength();
220
95ec17e6 221 UInt_t dspRDL = 0;
0a666212 222 UInt_t dspBlockHeaderWord[8];
223 UInt_t dspHeaderWord[10];
224 UInt_t patchBusHeaderWord[4];
40f4a63f 225 Int_t iskip[5];
722ccc67 226 UInt_t ddlEndWord[2] = {0xDEADFACE, 0xDEADFACE};
227
95ec17e6 228 for (Int_t iblock = 0; iblock < 2; iblock++)
229 {
230 // DSP Block Header
231
0a666212 232 for (Int_t i=0; i<kblHLen; i++)
95ec17e6 233 {
0a666212 234 dspBlockHeaderWord[i] = 0;
235 }
236 if (iblock == 0)
237 {
238 dspBlockHeaderWord[1] = (UInt_t) (dspBlockARDL + kblHLen);
239 dspBlockHeaderWord[2] = (UInt_t) dspBlockARDL;
240 }
241 else if (iblock == 1)
242 {
243 dspBlockHeaderWord[1] = (UInt_t) (dspBlockBRDL + kblHLen);
244 dspBlockHeaderWord[2] = (UInt_t) dspBlockBRDL;
95ec17e6 245 }
246
08f92f14 247 outfile->WriteBuffer((char*)dspBlockHeaderWord,kblHLen*sizeof(UInt_t));
95ec17e6 248
249 if (iblock == 0)
250 {
251 iskip[0] = 0;
252 iskip[1] = 10;
253 iskip[2] = 20;
254 iskip[3] = 30;
255 iskip[4] = 40;
256 }
257 else if (iblock == 1)
258 {
259 iskip[0] = 5;
260 iskip[1] = 15;
261 iskip[2] = 25;
262 iskip[3] = 35;
263 iskip[4] = 45;
264 }
28328eeb 265
95ec17e6 266 for (Int_t idsp = 0; idsp < 5; idsp++)
267 {
268 // DSP Header
269 Int_t dspno = 0;
270 if (iblock == 0)
271 {
272 dspno = 2*idsp;
273 dspRDL = (UInt_t) dsp[dspno];
274 }
275 else if (iblock == 1)
276 {
277 dspno = 2*idsp + 1;
278 dspRDL = (UInt_t) dsp[dspno];
279 }
280
0a666212 281 for (Int_t i=0; i<kdspHLen; i++)
95ec17e6 282 {
0a666212 283 dspHeaderWord[i] = 0;
95ec17e6 284 }
722ccc67 285 remainder = dspRDL%2;
0a666212 286 if (remainder == 1) dspRDL++;
287
288 dspHeaderWord[1] = dspRDL + kdspHLen;
289 dspHeaderWord[2] = dspRDL;
290 dspHeaderWord[3] = dspno;
291 if (remainder == 1) dspHeaderWord[8] = 1; // setting the padding word
722ccc67 292
293
08f92f14 294 outfile->WriteBuffer((char*)dspHeaderWord,kdspHLen*sizeof(UInt_t));
0a666212 295
95ec17e6 296 for (Int_t ibus = 0; ibus < 5; ibus++)
297 {
298 // Patch Bus Header
722ccc67 299
40f4a63f 300 Int_t busno = iskip[idsp] + ibus + 1;
95ec17e6 301 Int_t patchbusRDL = contentsBus[busno];
0a666212 302
303 if (patchbusRDL > 0)
95ec17e6 304 {
0a666212 305 patchBusHeaderWord[0] = 0;
306 patchBusHeaderWord[1] = (UInt_t) (patchbusRDL + kpbusHLen);
307 patchBusHeaderWord[2] = (UInt_t) patchbusRDL;
308 patchBusHeaderWord[3] = (UInt_t) busno;
95ec17e6 309 }
0a666212 310 else if (patchbusRDL == 0)
311 {
312 patchBusHeaderWord[0] = 0;
313 patchBusHeaderWord[1] = (UInt_t) kpbusHLen;
314 patchBusHeaderWord[2] = (UInt_t) 0;
315 patchBusHeaderWord[3] = (UInt_t) busno;
316 }
317
318
08f92f14 319 outfile->WriteBuffer((char*)patchBusHeaderWord,4*sizeof(UInt_t));
95ec17e6 320
95ec17e6 321 for (Int_t iword = 0; iword < patchbusRDL; iword++)
322 {
323 buffer[iword] = busPatch[busno][iword];
324 }
325
08f92f14 326 outfile->WriteBuffer((char*)buffer,patchbusRDL*sizeof(UInt_t));
0a666212 327
328 } // End of patch bus loop
329
330
331 // Adding a padding word if the total words odd
332 if (remainder == 1)
333 {
334 UInt_t paddingWord = dspHeader.GetDefaultPaddingWord();
08f92f14 335 outfile->WriteBuffer((char*)(&paddingWord),sizeof(UInt_t));
95ec17e6 336 }
337 }
338 }
0a666212 339
722ccc67 340 // Write two extra word at the end of each DDL file
341 outfile->WriteBuffer((char*)ddlEndWord,2*sizeof(UInt_t));
342
a4e4efaa 343 // Write real data header
344 // take the pointer to the beginning of the data header
28328eeb 345 // write the total number of words per ddl and bring the
346 // pointer to the current file position and close it
08f92f14 347 UInt_t cFPosition = outfile->Tellp();
6d8de07c 348 //sizeRawData = cFPosition - bHPosition - sizeof(header); // coverity (8443) fix satya (1/9/2014)
95ec17e6 349
a4e4efaa 350 header.fSize = cFPosition - bHPosition;
351 header.SetAttribute(0); // valid data
08f92f14 352 outfile->Seekp(bHPosition);
353 outfile->WriteBuffer((char*)(&header),sizeof(header));
354 outfile->Seekp(cFPosition);
28328eeb 355
08f92f14 356 delete outfile;
28328eeb 357 } // DDL Loop over
358
28328eeb 359}
360//____________________________________________________________________________
ab0cde47 361
95ec17e6 362void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule,
ab0cde47 363 Int_t ddlno, Int_t *contentsBus,
95ec17e6 364 UInt_t busPatch[][1536])
28328eeb 365{
08cf9354 366 // Retrieves digits data UnitModule by UnitModule
93622f4a 367
be8b7039 368 const Int_t kMaxBus = 51;
369
370 UInt_t baseword = 0;
371 UInt_t mcmno = 0, chno = 0;
372 UInt_t adc = 0;
373 Int_t det = 0, smn = 0, irow = 0, icol = 0;
f564dd5a 374 UInt_t parity = 0;
a0a6a406 375
95ec17e6 376 Int_t busno = 0;
377 Int_t patchBusNo[kMaxBus], mcmperBus[kMaxBus];
378 Int_t startRowBus[kMaxBus], startColBus[kMaxBus];
379 Int_t endRowBus[kMaxBus], endColBus[kMaxBus];
380
381 Int_t beginPatchBus = -1;
382 Int_t endPatchBus = -1;
383 for(Int_t i = 0; i < kMaxBus; i++)
384 {
385 patchBusNo[i] = -1;
386 mcmperBus[i] = -1;
387 startRowBus[i] = -1;
388 startColBus[i] = -1;
389 endRowBus[i] = -1;
390 endColBus[i] = -1;
391 }
08cf9354 392
ab0cde47 393 // Fetch the DDL mapping info from the mapping database
95ec17e6 394
ab0cde47 395 DdlMapping(ddlno, imodule, beginPatchBus, endPatchBus,
396 patchBusNo, mcmperBus, startRowBus, endRowBus,
397 startColBus, endColBus);
95ec17e6 398
ab0cde47 399 // Read if some chains are off from the ddlinfo database
08cf9354 400
401 Int_t srowoff1[2][24], erowoff1[2][24];
402 Int_t scoloff1[2][24], ecoloff1[2][24];
403 Int_t srowoff2[2][24], erowoff2[2][24];
404 Int_t scoloff2[2][24], ecoloff2[2][24];
405
ab0cde47 406 for (Int_t idet = 0; idet < 2; idet++)
08cf9354 407 {
ab0cde47 408 for (Int_t im = 0; im < 24; im++)
409 {
410 srowoff1[idet][im] = fDdlinfo->GetStartRowA(idet,im);
411 erowoff1[idet][im] = fDdlinfo->GetEndRowA(idet,im);
412 scoloff1[idet][im] = fDdlinfo->GetStartColA(idet,im);
413 ecoloff1[idet][im] = fDdlinfo->GetEndColA(idet,im);
414 srowoff2[idet][im] = fDdlinfo->GetStartRowB(idet,im);
415 erowoff2[idet][im] = fDdlinfo->GetEndRowB(idet,im);
416 scoloff2[idet][im] = fDdlinfo->GetStartColB(idet,im);
417 ecoloff2[idet][im] = fDdlinfo->GetEndColB(idet,im);
418 }
08cf9354 419 }
420
28328eeb 421 treeD->GetEntry(imodule);
422 Int_t nentries = fDigits->GetLast();
95ec17e6 423 Int_t totword = nentries+1;
28328eeb 424
be8b7039 425 AliPMDdigit *pmddigit = 0x0;
a48edddd 426
28328eeb 427 for (Int_t ient = 0; ient < totword; ient++)
428 {
0a666212 429 pmddigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
28328eeb 430
0a666212 431 det = pmddigit->GetDetector();
432 smn = pmddigit->GetSMNumber();
433 irow = pmddigit->GetRow();
434 icol = pmddigit->GetColumn();
f564dd5a 435 Float_t aadc = pmddigit->GetADC();
436 if (aadc < 0.) aadc = 0.;
437 adc = (UInt_t) aadc;
28328eeb 438
e54787da 439 TransformS2H(smn,irow,icol);
08cf9354 440
441 // remove the non-existence channels
442
443 //printf("%d %d %d %d\n",det,smn,irow,icol);
444 //printf("--- %d %d %d %d\n",srowoff[det][smn],erowoff[det][smn],
445 // scoloff[det][smn],ecoloff[det][smn]);
446
447 if (irow >= srowoff1[det][smn] && irow <= erowoff1[det][smn])
448 {
449 if (icol >= scoloff1[det][smn] && icol <= ecoloff1[det][smn])
450 {
451 continue;
452 }
453 }
454 if (irow >= srowoff2[det][smn] && irow <= erowoff2[det][smn])
455 {
456 if (icol >= scoloff2[det][smn] && icol <= ecoloff2[det][smn])
457 {
458 continue;
459 }
460 }
461
95ec17e6 462
08cf9354 463 GetMCMCh(imodule, irow, icol, beginPatchBus, endPatchBus,
95ec17e6 464 mcmperBus, startRowBus, startColBus,
465 endRowBus, endColBus, busno, mcmno, chno);
28328eeb 466
28328eeb 467 baseword = 0;
cff75ba7 468 AliBitPacking::PackWord(adc,baseword,0,11);
469 AliBitPacking::PackWord(chno,baseword,12,17);
470 AliBitPacking::PackWord(mcmno,baseword,18,28);
471 AliBitPacking::PackWord(0,baseword,29,30);
a98f9d26 472 parity = ComputeParity(baseword); // generate the parity bit
473 AliBitPacking::PackWord(parity,baseword,31,31);
95ec17e6 474
475 Int_t jj = contentsBus[busno];
476 busPatch[busno][jj] = baseword;
477
478 contentsBus[busno]++;
28328eeb 479 }
480
e54787da 481}
95ec17e6 482
e54787da 483//____________________________________________________________________________
484void AliPMDDDLRawData::TransformS2H(Int_t smn, Int_t &irow, Int_t &icol)
485{
486 // Does the Software to Hardware coordinate transformation
487 //
95ec17e6 488
e54787da 489 Int_t irownew = 0;
490 Int_t icolnew = 0;
e54787da 491
492 // First in digits we have all dimension 48x96
95ec17e6 493 // Transform into the realistic one, i.e, For SM 0&1 96(row)x48(col)
494 // and for SM 2&3 48(row)x96(col)
e54787da 495 //
496 if(smn < 12)
497 {
95ec17e6 498 irownew = icol;
499 icolnew = irow;
e54787da 500 }
501 else if( smn >= 12 && smn < 24)
502 {
95ec17e6 503 irownew = irow;
504 icolnew = icol;
e54787da 505 }
506
507 irow = irownew;
508 icol = icolnew;
28328eeb 509
510}
e54787da 511
512
28328eeb 513//____________________________________________________________________________
e54787da 514
08cf9354 515void AliPMDDDLRawData::GetMCMCh(Int_t imodule, Int_t row, Int_t col,
95ec17e6 516 Int_t beginPatchBus, Int_t endPatchBus,
517 Int_t *mcmperBus,
518 Int_t *startRowBus, Int_t *startColBus,
519 Int_t *endRowBus, Int_t *endColBus,
520 Int_t & busno, UInt_t &mcmno, UInt_t &chno)
28328eeb 521{
9ac124a2 522 // This converts row col to hardware channel number
523 // This is the final version of mapping supplied by Mriganka
524
40f4a63f 525 UInt_t iCh[16][4];
526
40f4a63f 527 static const UInt_t kChDdl01[16][4] = { {6, 4, 5, 7},
528 {10, 2, 1, 9},
529 {12, 0, 3, 11},
530 {14, 8, 13, 15},
531 {16, 18, 23, 17},
532 {20, 28, 31, 19},
533 {22, 30, 29, 21},
534 {24, 26, 27, 25},
535 {38, 36, 37, 39},
536 {42, 34, 33, 41},
537 {44, 32, 35, 43},
538 {46, 40, 45, 47},
539 {48, 50, 55, 49},
540 {52, 60, 63, 51},
541 {54, 62, 61, 53},
542 {56, 58, 59, 57} };
543
544
545 static const UInt_t kChDdl23[16][4] = { {57, 59, 58, 56},
546 {53, 61, 62, 54},
547 {51, 63, 60, 52},
548 {49, 55, 50, 48},
549 {47, 45, 40, 46},
550 {43, 35, 32, 44},
551 {41, 33, 34, 42},
552 {39, 37, 36, 38},
553 {25, 27, 26, 24},
554 {21, 29, 30, 22},
555 {19, 31, 28, 20},
556 {17, 23, 18, 16},
557 {15, 13, 8, 14},
558 {11, 3, 0, 12},
559 {9, 1, 2, 10},
560 {7, 5, 4, 6} };
561
562
563 static const UInt_t kChDdl41[16][4] = { {56, 58, 59, 57},
564 {54, 62, 61, 53},
565 {52, 60, 63, 51},
566 {48, 50, 55, 49},
567 {46, 40, 45, 47},
568 {44, 32, 35, 43},
569 {42, 34, 33, 41},
570 {38, 36, 37, 39},
571 {24, 26, 27, 25},
572 {22, 30, 29, 21},
573 {20, 28, 31, 19},
574 {16, 18, 23, 17},
575 {14, 8, 13, 15},
576 {12, 0, 3, 11},
577 {10, 2, 1, 9},
578 {6, 4, 5, 7} };
579
580
581 static const UInt_t kChDdl42[16][4] = { {7, 5, 4, 6},
582 {9, 1, 2, 10},
583 {11, 3, 0, 12},
584 {15, 13, 8, 14},
585 {17, 23, 18, 16},
586 {19, 31, 28, 20},
587 {21, 29, 30, 22},
588 {25, 27, 26, 24},
589 {39, 37, 36, 38},
590 {41, 33, 34, 42},
591 {43, 35, 32, 44},
592 {47, 45, 40, 46},
593 {49, 55, 50, 48},
594 {51, 63, 60, 52},
595 {53, 61, 62, 54},
596 {57, 59, 58, 56} };
597
598
599 static const UInt_t kChDdl51[16][4] = { {7, 5, 4, 6},
600 {9, 1, 2, 10},
601 {11, 3, 0, 12},
602 {15, 13, 8, 14},
603 {17, 23, 18, 16},
604 {19, 31, 28, 20},
605 {21, 29, 30, 22},
606 {25, 27, 26, 24},
607 {39, 37, 36, 38},
608 {41, 33, 34, 42},
609 {43, 35, 32, 44},
610 {47, 45, 40, 46},
611 {49, 55, 50, 48},
612 {51, 63, 60, 52},
613 {53, 61, 62, 54},
614 {57, 59, 58, 56} };
615
616
617
618 static const UInt_t kChDdl52[16][4] = { {56, 58, 59, 57},
619 {54, 62, 61, 53},
620 {52, 60, 63, 51},
621 {48, 50, 55, 49},
622 {46, 40, 45, 47},
623 {44, 32, 35, 43},
624 {42, 34, 33, 41},
625 {38, 36, 37, 39},
626 {24, 26, 27, 25},
627 {22, 30, 29, 21},
628 {20, 28, 31, 19},
629 {16, 18, 23, 17},
630 {14, 8, 13, 15},
631 {12, 0, 3, 11},
632 {10, 2, 1, 9},
633 {6, 4, 5, 7} };
634
635
636 for (Int_t i = 0; i < 16; i++)
08cf9354 637 {
40f4a63f 638 for (Int_t j = 0; j < 4; j++)
08cf9354 639 {
40f4a63f 640
08cf9354 641 if(imodule < 6) iCh[i][j] = kChDdl01[i][j];
642 if(imodule >= 6 && imodule <= 11) iCh[i][j] = kChDdl01[i][j];
643 if(imodule >= 12 && imodule <= 17) iCh[i][j] = kChDdl23[i][j];
644 if(imodule >= 18 && imodule <= 23) iCh[i][j] = kChDdl23[i][j];
645
646 if(imodule >= 24 && imodule <= 29) iCh[i][j] = kChDdl41[i][j];
647 if(imodule >= 42 && imodule <= 47) iCh[i][j] = kChDdl42[i][j];
648 if(imodule >= 36 && imodule <= 41) iCh[i][j] = kChDdl51[i][j];
649 if(imodule >= 30 && imodule <= 35) iCh[i][j] = kChDdl52[i][j];
650
651 }
652 }
40f4a63f 653
654
95ec17e6 655 Int_t irownew = row%16;
656 Int_t icolnew = col%4;
657
40f4a63f 658 chno = iCh[irownew][icolnew];
a0a6a406 659
660
95ec17e6 661 for (Int_t ibus = beginPatchBus; ibus <= endPatchBus; ibus++)
662 {
663 Int_t srow = startRowBus[ibus];
664 Int_t erow = endRowBus[ibus];
665 Int_t scol = startColBus[ibus];
666 Int_t ecol = endColBus[ibus];
667 Int_t tmcm = mcmperBus[ibus];
08cf9354 668
95ec17e6 669 if ((row >= srow && row <= erow) && (col >= scol && col <= ecol))
a4e4efaa 670 {
95ec17e6 671 busno = ibus;
a0a6a406 672
95ec17e6 673 // Find out the MCM Number
674 //
08cf9354 675
676 if (imodule < 6) mcmno = (col-scol)/4 + 1;
677 if (imodule >= 6 && imodule < 12) mcmno = (col-scol)/4 + 1;
678
679 if (imodule >= 12 && imodule < 18)
95ec17e6 680 {
08cf9354 681 icolnew = (col - scol)/4;
682 mcmno = tmcm - icolnew;
683 }
684 if (imodule >= 18 && imodule < 24)
95ec17e6 685 {
00284d65 686 icolnew = (col - scol)/4;
40f4a63f 687 mcmno = tmcm - icolnew;
08cf9354 688 }
689
690 // DDL = 4
691 if (imodule >= 24 && imodule < 30)
95ec17e6 692 {
08cf9354 693
694 //if (tmcm == 24)
695 Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
696 if(rowdiff > 16)
95ec17e6 697 {
a0a6a406 698 Int_t midrow = srow + 16;
699 if(row >= srow && row < midrow)
95ec17e6 700 {
40f4a63f 701 mcmno = 12 + (col-scol)/4 + 1;
95ec17e6 702 }
93622f4a 703 else if(row >= midrow && row <= erow)
08cf9354 704
95ec17e6 705 {
40f4a63f 706 mcmno = (col-scol)/4 + 1;
95ec17e6 707 }
708 }
08cf9354 709 else if (rowdiff < 16)
95ec17e6 710 {
08cf9354 711 mcmno = (col-scol)/4 + 1;
712 }
713
714 }
715 if (imodule >= 42 && imodule < 48)
716 {
717 Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
718 if(rowdiff > 16)
719 {
720 Int_t midrow = srow + 16;
721 if (row >= midrow && row <= erow)
95ec17e6 722 {
08cf9354 723 mcmno = 12 + (ecol -col)/4 + 1;
95ec17e6 724 }
08cf9354 725 else if (row >= srow && row < midrow)
95ec17e6 726 {
40f4a63f 727 mcmno = (ecol - col)/4 + 1;
728 }
95ec17e6 729 }
08cf9354 730 else if (rowdiff < 16)
731 {
732 mcmno = (ecol - col)/4 + 1;
733 }
734 }
735
736 // DDL = 5
737 if (imodule >= 30 && imodule < 36)
93622f4a 738 {
40f4a63f 739 // CPV plane, SU Mod = 1, 2 : ddl = 5
93622f4a 740
08cf9354 741 //if(tmcm == 24)
742 Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
743 if(rowdiff > 16)
93622f4a 744 {
745 Int_t midrow = srow + 16;
746 if(row >= srow && row < midrow)
747 {
40f4a63f 748 mcmno = 12 + (col-scol)/4 + 1;
93622f4a 749 }
750 else if(row >= midrow && row <= erow)
751 {
40f4a63f 752 mcmno = (col-scol)/4 + 1;
93622f4a 753 }
754 }
08cf9354 755 else if(rowdiff < 16)
756 {
757 mcmno = (col-scol)/4 + 1;
758 }
93622f4a 759
08cf9354 760 }
761 if (imodule >= 36 && imodule < 42)
762 {
763 Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
764 if(rowdiff > 16)
93622f4a 765 {
08cf9354 766 Int_t midrow = srow + 16;
767 if (row >= midrow && row <= erow)
93622f4a 768 {
08cf9354 769 mcmno = 12 + (ecol - col)/4 + 1;
93622f4a 770 }
08cf9354 771 else if (row >= srow && row < midrow)
93622f4a 772 {
40f4a63f 773 mcmno = (ecol - col)/4 + 1;
774 }
93622f4a 775 }
08cf9354 776 else if (rowdiff < 16)
777 {
778 mcmno = (ecol - col)/4 + 1;
779 }
93622f4a 780 }
08cf9354 781
93622f4a 782 }
95ec17e6 783 }
a0a6a406 784}
785
28328eeb 786//____________________________________________________________________________
787
f564dd5a 788UInt_t AliPMDDDLRawData::ComputeParity(UInt_t baseword)
a98f9d26 789{
790 // Generate the parity bit
791
f564dd5a 792 UInt_t count = 0;
a98f9d26 793 for(Int_t j=0; j<29; j++)
794 {
795 if (baseword & 0x01 ) count++;
796 baseword >>= 1;
797 }
f564dd5a 798 UInt_t parity = count%2;
a98f9d26 799 return parity;
800}
ab0cde47 801//____________________________________________________________________________
802void AliPMDDDLRawData::DdlMapping(Int_t iddl, Int_t imodule,
803 Int_t &beginPatchBus, Int_t &endPatchBus,
804 Int_t patchBusNo[], Int_t mcmperBus[],
805 Int_t startRowBus[], Int_t endRowBus[],
806 Int_t startColBus[], Int_t endColBus[])
807{
808 // DDL Mapping fetching from mapping database
809
810 beginPatchBus = fMapData->GetBeginPatchBus(iddl,imodule);
811 endPatchBus = fMapData->GetEndPatchBus(iddl,imodule);
812
813 for(Int_t ibus = beginPatchBus; ibus < endPatchBus+1; ibus++)
814 {
815 patchBusNo[ibus] = ibus;
816 mcmperBus[ibus] = fMapData->GetMcmperBus(iddl,ibus);
817 startRowBus[ibus] = fMapData->GetStartRowBus(iddl,ibus);
818 startColBus[ibus] = fMapData->GetStartColBus(iddl,ibus);
819 endRowBus[ibus] = fMapData->GetEndRowBus(iddl,ibus);
820 endColBus[ibus] = fMapData->GetEndColBus(iddl,ibus);
821 }
a98f9d26 822
ab0cde47 823}
824//____________________________________________________________________________
825
826AliPMDddlinfoData* AliPMDDDLRawData::GetDdlinfoData() const
827{
828 // The run number will be centralized in AliCDBManager,
829 // you don't need to set it here!
830 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Ddlinfo");
831
832 if(!entry) AliFatal("ddlinfo object retrieval failed!");
833
834 AliPMDddlinfoData *ddlinfo = 0;
835 if (entry) ddlinfo = (AliPMDddlinfoData*) entry->GetObject();
836
837 if (!ddlinfo) AliFatal("No ddl info data from database !");
838
839 return ddlinfo;
840}
841//____________________________________________________________________________
842AliPMDMappingData* AliPMDDDLRawData::GetMappingData() const
843{
844 // The run number will be centralized in AliCDBManager,
845 // you don't need to set it here!
846 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Mapping");
847
848 if(!entry) AliFatal("Mapping object retrieval failed!");
849
850 AliPMDMappingData *mapda = 0;
851 if (entry) mapda = (AliPMDMappingData*) entry->GetObject();
852
853 if (!mapda) AliFatal("No mapping data from database !");
854
855 return mapda;
856}
a98f9d26 857//____________________________________________________________________________