Removing unused forward declarations
[u/mrichter/AliRoot.git] / MUON / AliMUONRawData.cxx
CommitLineData
f6762c71 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////////////////////////////////////
17//
18// MUON Raw Data generator in ALICE-MUON
19//
c8b4255f 20// This class version 1 (further details could be found in Alice-note coming soon right in our direction)
21// Generates raw data for MUON tracker and finally for trigger
f6762c71 22// * a simple mapping is used (see below)
69be760c 23// * the bus patch id is calculated with an absolute number 0 - 999
c8b4255f 24// * one DDL per 1/2 chamber is created for both cathode.
25// For trigger there is no mapping (mapping could be found in AliMUONTriggerCircuit)
26// don't need for digits2raw but needed in raw2Reco
27// the position are given per local card
f6762c71 28////////////////////////////////////
c8b4255f 29
69be760c 30#include <TClonesArray.h>
f6762c71 31#include "AliMUONRawData.h"
32#include "AliMUONDigit.h"
69be760c 33#include "AliMUONTriggerDecision.h"
f6762c71 34#include "AliMUONConstants.h"
35#include "AliMUONData.h"
f6762c71 36#include "AliRun.h"
37#include "AliRunLoader.h"
38#include "AliLoader.h"
39#include "AliBitPacking.h"
69be760c 40#include "AliMUONDDLTracker.h"
41#include "AliMUONDDLTrigger.h"
42
c8b4255f 43#include "AliMUON.h"
44#include "AliMUONLocalTrigger.h"
45#include "AliMUONGlobalTrigger.h"
46#include "AliMUONTriggerCircuit.h"
f6762c71 47
48const Int_t AliMUONRawData::fgkDefaultPrintLevel = 0;
49
50ClassImp(AliMUONRawData) // Class implementation in ROOT context
51
52//__________________________________________________________________________
53AliMUONRawData::AliMUONRawData(AliLoader* loader)
69be760c 54 : TObject(),
55 fDebug(0)
f6762c71 56{
57 // Standard Constructor
58
f6762c71 59 fPrintLevel = fgkDefaultPrintLevel;
60
61 // initialize loader's
62 fLoader = loader;
63
64 // initialize container
65 fMUONData = new AliMUONData(fLoader,"MUON","MUON");
69be760c 66
67 // trigger decision, temp solution, local & global has to move to Digits Tree
68// fTrigDec = new AliMUONTriggerDecision(fLoader);
69// fTrigData = fTrigDec->GetMUONData();
70
71 // initialize array
72 fSubEventArray[0] = new TClonesArray("AliMUONSubEventTracker",1000);
73 fSubEventArray[1] = new TClonesArray("AliMUONSubEventTracker",1000);
74
75 // initialize array
76 fSubEventTrigArray[0] = new TClonesArray("AliMUONSubEventTrigger",1000);
77 fSubEventTrigArray[1] = new TClonesArray("AliMUONSubEventTrigger",1000);
78
79 // ddl pointer
80 fDDLTracker = new AliMUONDDLTracker();
81 fDDLTrigger= new AliMUONDDLTrigger();
f6762c71 82}
83
84//__________________________________________________________________________
85AliMUONRawData::AliMUONRawData()
86 : TObject(),
f6762c71 87 fMUONData(0),
88 fPrintLevel(fgkDefaultPrintLevel),
89 fDebug(0),
90 fLoader(0)
91{
92 // Default Constructor
93}
94
95//_______________________________________________________________________
96AliMUONRawData::AliMUONRawData (const AliMUONRawData& rhs)
97 : TObject(rhs)
98{
99// Protected copy constructor
100
101 Fatal("AliMUONRawData", "Not implemented.");
102}
103
104//_______________________________________________________________________
105AliMUONRawData &
106AliMUONRawData::operator=(const AliMUONRawData& rhs)
107{
108// Protected assignement operator
109
110 if (this == &rhs) return *this;
111
112 Fatal("operator=", "Not implemented.");
113
114 return *this;
115}
116
117//__________________________________________________________________________
118AliMUONRawData::~AliMUONRawData(void)
119{
120 if (fMUONData)
121 delete fMUONData;
69be760c 122 if (fSubEventArray[0])
123 fSubEventArray[0]->Delete(); //using delete cos allocating memory in copy ctor.
124 if (fSubEventArray[1])
125 fSubEventArray[1]->Delete();
126
127 if (fSubEventTrigArray[0])
128 fSubEventTrigArray[0]->Delete();
129 if (fSubEventTrigArray[1])
130 fSubEventTrigArray[1]->Delete();
131
132 if (fDDLTracker)
133 delete fDDLTracker;
134 if (fDDLTrigger)
135 delete fDDLTrigger;
136
f6762c71 137 return;
138}
139//____________________________________________________________________
140Int_t AliMUONRawData::WriteRawData()
141{
142 // convert digits of the current event to raw data
143
f6762c71 144 Int_t DDLId;
145 Char_t name[20];
146
147 fLoader->LoadDigits("READ");
69be760c 148
c8b4255f 149 fMUONData->SetTreeAddress("D,GLT");
f6762c71 150
f6762c71 151
c8b4255f 152 // tracking chambers
153
154 for (Int_t ich = 0; ich < AliMUONConstants::NTrackingCh(); ich++) {
155
f6762c71 156 // open files
98724670 157 DDLId = ich * 2 + 0x900;
f6762c71 158 sprintf(name, "MUON_%d.ddl",DDLId);
159 fFile1 = fopen(name,"w");
160
69be760c 161 DDLId = (ich * 2) + 1 + 0x900;
f6762c71 162 sprintf(name, "MUON_%d.ddl",DDLId);
163 fFile2 = fopen(name,"w");
164
69be760c 165 WriteTrackerDDL(ich);
f6762c71 166
167 // reset and close
168 fclose(fFile1);
169 fclose(fFile2);
170 fMUONData->ResetDigits();
171 }
69be760c 172
173 // trigger chambers
c8b4255f 174
69be760c 175 // open files
c8b4255f 176 DDLId = 0xA00;
177 sprintf(name, "MUTR_%d.ddl",DDLId);
178 fFile1 = fopen(name,"w");
69be760c 179
c8b4255f 180 DDLId = 0xA00 + 1;
181 sprintf(name, "MUTR_%d.ddl",DDLId);
182 fFile2 = fopen(name,"w");
69be760c 183
c8b4255f 184 WriteTriggerDDL();
185
186 // reset and close
187 fclose(fFile1);
188 fclose(fFile2);
189 fMUONData->ResetTrigger();
f6762c71 190
c8b4255f 191 fLoader->UnloadDigits();
69be760c 192
f6762c71 193 return kTRUE;
194}
195//____________________________________________________________________
69be760c 196Int_t AliMUONRawData::WriteTrackerDDL(Int_t iCh)
f6762c71 197{
69be760c 198 // resets
f6762c71 199 TClonesArray* muonDigits = 0;
69be760c 200 fSubEventArray[0]->Clear();
201 fSubEventArray[1]->Clear();
202
203 //
204 TArrayI nbInBus[2];
205
206 nbInBus[0].Set(5000);
207 nbInBus[1].Set(5000);
208
209 nbInBus[0].Reset();
210 nbInBus[1].Reset();
211
212 // DDL header
213 AliRawDataHeader header = fDDLTracker->GetHeader();
214 Int_t headerSize = fDDLTracker->GetHeaderSize();
f6762c71 215
216 // DDL event one per half chamber
69be760c 217 AliMUONSubEventTracker* subEvent;
f6762c71 218
219 // data format
220 Char_t parity = 0x4;
69be760c 221 UShort_t manuId = 0;
222 UChar_t channelId = 0;
223 UShort_t charge = 0;
224 Int_t busPatchId = 0;
f6762c71 225
226 UInt_t word;
69be760c 227 Int_t nEntries = 0;
228 Int_t* buffer = 0;
229 Int_t index;
230 Int_t indexDsp;
231 Int_t indexBlk;
f6762c71 232
233 Int_t nDigits;
69be760c 234 const AliMUONDigit* digit;
f6762c71 235
c8b4255f 236 if (fPrintLevel == 1)
69be760c 237 printf("WriteDDL chamber %d\n", iCh+1);
f6762c71 238
239 for (Int_t iCath = 0; iCath < 2; iCath++) {
240
f6762c71 241 fMUONData->ResetDigits();
242 fMUONData->GetCathode(iCath);
243 muonDigits = fMUONData->Digits(iCh);
244
245 nDigits = muonDigits->GetEntriesFast();
69be760c 246 if (fPrintLevel == 2)
f6762c71 247 printf("ndigits = %d\n",nDigits);
248
249 // open DDL file, on per 1/2 chamber
250
251 for (Int_t idig = 0; idig < nDigits; idig++) {
252
253 digit = (AliMUONDigit*) muonDigits->UncheckedAt(idig);
254
69be760c 255 // mapping
256 GetDummyMapping(iCh, iCath, digit, busPatchId, manuId, channelId, charge);
257
258 //packing word
259 AliBitPacking::PackWord((UInt_t)parity,word,29,31);
260 AliBitPacking::PackWord((UInt_t)manuId,word,18,28);
261 AliBitPacking::PackWord((UInt_t)channelId,word,12,17);
262 AliBitPacking::PackWord((UInt_t)charge,word,0,11);
263
264 // set sub Event
265 subEvent = new AliMUONSubEventTracker();
266 subEvent->AddData(word);
267 subEvent->SetBusPatchId(busPatchId);
268 if (digit->PadX() > 0) {
269 nbInBus[0][busPatchId]++;
270 AddData1(subEvent);
271 } else {
272 nbInBus[1][busPatchId]++;
273 AddData2(subEvent);
274 }
275 delete subEvent;
276 }
277 }
278 fSubEventArray[0]->Sort();
279 fSubEventArray[1]->Sort();
280
281 // gather datas from same bus patch
282 for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
283 nEntries = fSubEventArray[iDDL]->GetEntriesFast();
284
285 for (Int_t i = 0; i < nEntries; i++) {
286 AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(i);
287 busPatchId = temp->GetBusPatchId();
288
289 // add bus patch header, length and total length managed by subevent class
290 temp->SetTriggerWord(0xdeadbeef);
291 for (Int_t j = 0; j < nbInBus[iDDL][busPatchId]-1; j++) {
292 AliMUONSubEventTracker* temp1 = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(++i);
293 temp->AddData(temp1->GetData(0));
294 fSubEventArray[iDDL]->RemoveAt(i) ;
295 }
296 }
297 fSubEventArray[iDDL]->Compress();
298
299 if (fPrintLevel == 3) {
300 nEntries = fSubEventArray[iDDL]->GetEntriesFast();
301 for (Int_t i = 0; i < nEntries; i++) {
302 AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(i);
303 printf("busPatchid back %d\n",temp->GetBusPatchId());
304 for (Int_t j = 0; j < temp->GetLength(); j++) {
305 printf("manuId back %d, ",temp->GetManuId(j));
306 printf("channelId back %d, ",temp->GetChannelId(j));
307 printf("charge back %d\n",temp->GetCharge(j));
308 }
309 }
310 printf("\n");
311 }
312
313 }
314
315 Int_t iBusPatch;
316 Int_t iEntries;
317
318 for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
319
320
321 // filling buffer
322 nEntries = fSubEventArray[iDDL]->GetEntriesFast();
323 buffer = new Int_t [(2048+24)*50]; // 24 words in average for one buspatch and 2048 manu info at most
324
325 indexBlk = 0;
326 indexDsp = 0;
327 index = 0;
328 iBusPatch = 0;
329 iEntries = 0;
330
331 for (Int_t iBlock = 0; iBlock < 2; iBlock++) {
332
333 // block header
334 fDDLTracker->SetTotalBlkLength(0xFFFFFFFF);
335 memcpy(&buffer[index],fDDLTracker->GetBlkHeader(),32);
336 indexBlk = index;
337 index += 8;
338
339 for (Int_t iDsp = 0; iDsp < 5; iDsp++) {
340
341 // DSP header
342 fDDLTracker->SetTotalDspLength(0xEEEEEEEE);
343 memcpy(&buffer[index],fDDLTracker->GetDspHeader(),32);
344 indexDsp = index;
345 index += 8;
346
347 for (Int_t i = 0; i < 5; i++) {
348
349 iBusPatch = i + iBlock*25 + iDsp*5 + 50*(2*iCh + iDDL);
350
351 AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(iEntries);
352 if (nEntries > 0)
353 busPatchId = temp->GetBusPatchId();
354 else
355 busPatchId = -1;
356
357 if (busPatchId == iBusPatch) {
358 // add bus patch structure
359 memcpy(&buffer[index],temp->GetAddress(),16);
360 index+= 4;
361 for (Int_t j = 0; j < temp->GetLength(); j++)
362 buffer[index++] = temp->GetData(j);
363 if (iEntries < nEntries-1)
364 iEntries++;
365 } else {
366 buffer[index++] = 4; // total length
367 buffer[index++] = 0; // raw data length
368 buffer[index++] = iBusPatch; // bus patch
369 buffer[index++] = 0xdeadbeef; // trigger word
370 }
371 } // bus patch
372 buffer[indexDsp] = index - indexDsp;
373 buffer[indexDsp+1] = index - indexDsp -8;
374 if ((index - indexDsp) % 2 == 0)
375 buffer[indexDsp+7] = 0;
376 else
377 buffer[indexDsp+7] = 1;
378 } // dsp
379 buffer[indexBlk] = index - indexBlk;
380 buffer[indexBlk+1] = index - indexBlk -8;
381 }
382 if (iDDL == 0) {
383 // write DDL 1
384 header.fSize = index + headerSize;// total length in word
385 fwrite((char*)(&header),headerSize*4,1,fFile1);
386 fwrite(buffer,sizeof(int),index,fFile1);
387 }
388 if (iDDL == 1) {
389 // write DDL 2
390 header.fSize = index + headerSize;// total length in word
391 fwrite((char*)(&header),headerSize*4,1,fFile2);
392 fwrite(buffer,sizeof(int),index,fFile2);
393 }
394 delete[] buffer;
395 }
396
397 return kTRUE;
398}
399//____________________________________________________________________
400Int_t AliMUONRawData::WriteTriggerDDL()
401{
402
c8b4255f 403 // DDL event one per half chamber
404 AliMUONSubEventTrigger* subEvent = 0x0;
69be760c 405
69be760c 406
c8b4255f 407 // stored local id number
408 TArrayI isFired(256);
409 isFired.Reset();
69be760c 410
69be760c 411
c8b4255f 412 // DDL header
413 AliRawDataHeader header = fDDLTrigger->GetHeader();
414 Int_t headerSize = fDDLTrigger->GetHeaderSize();
415
416 TClonesArray* localTrigger;
417 TClonesArray* globalTrigger;
418 AliMUONGlobalTrigger* gloTrg;
419 AliMUONLocalTrigger* locTrg = 0x0;
420
421 fMUONData->GetTriggerD();
422
423 // global trigger for trigger pattern
424 globalTrigger = fMUONData->GlobalTrigger();
425 gloTrg = (AliMUONGlobalTrigger*)globalTrigger->UncheckedAt(0);
426 Int_t gloTrigPat = GetGlobalTriggerPattern(gloTrg);
427
428 // local trigger
429 localTrigger = fMUONData->LocalTrigger();
430
431 UInt_t word;
432 Int_t* buffer = 0;
433 Int_t index;
434 Int_t iEntries = 0;
435 Int_t iLocCard, locCard;
436 Char_t locDec, trigY, posY, devX, posX;
437 Int_t version = 1; // software version
438 Int_t eventType =1; // trigger type: 1 for physics ?
439 Int_t serialNb = 0xF; // serial nb of card: all bits on for the moment
440
441 Int_t nEntries = (Int_t) (localTrigger->GetEntries());// 234 local cards
442 // stored the local card id that's fired
443 for (Int_t i = 0; i < nEntries; i++) {
444 locTrg = (AliMUONLocalTrigger*)localTrigger->At(i);
445 isFired[locTrg->LoCircuit()] = 1;
446 }
447
448 if (!nEntries)
449 Error("AliMUONRawData::WriteTriggerDDL","No Trigger information available");
450
a0b2ac9a 451 buffer = new Int_t [680]; // [16(local)*5 words + 4 words]*8(reg) + 8 words = 680
c8b4255f 452
453 for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
454
455 index = 0;
456
457 // DDL enhanced header
458 word =0;
459 AliBitPacking::PackWord((UInt_t)iDDL+1,word,30,31); //see AliMUONDDLTrigger.h for details
460 AliBitPacking::PackWord((UInt_t)version,word,22,29);
461 AliBitPacking::PackWord((UInt_t)serialNb,word,18,21);
462 AliBitPacking::PackWord((UInt_t)eventType,word,14,17);
463
464 fDDLTrigger->SetDDLWord(word);
465 fDDLTrigger->SetGlobalOutput(gloTrigPat);
466 memcpy(&buffer[index],fDDLTrigger->GetEnhancedHeader(),24);
467 index += 6;
468
469 for (Int_t iReg = 0; iReg < 8; iReg++) {
470
471 subEvent = new AliMUONSubEventTrigger();
472
473 // Regional card header
474 word = 0;
475 AliBitPacking::PackWord((UInt_t)serialNb,word,27,31); //see AliMUONSubEventTrigger.h for details
476 AliBitPacking::PackWord((UInt_t)iReg,word,22,26);
477 AliBitPacking::PackWord((UInt_t)version,word,14,21);
478 subEvent->SetRegWord(word);
479 memcpy(&buffer[index++],subEvent->GetAddress(),4);
480
481 for (Int_t iLoc = 0; iLoc < 16; iLoc++) {
482
483 iLocCard = iLoc + iReg*16 + iDDL*128;
484
485 if (isFired[iLocCard]) {
486 locTrg = (AliMUONLocalTrigger*)localTrigger->At(iEntries);
487 locCard = locTrg->LoCircuit();
488 locDec = locTrg->GetLoDecision();
489 trigY = 0;
490 posY = locTrg->LoStripY();
491 posX = locTrg->LoStripX();
492 devX = locTrg->LoDev();
493 if (fPrintLevel == 4)
494 printf("loctrg %d, posX %d, posY %d, devX %d\n",
495 locTrg-> LoCircuit(),locTrg->LoStripX(),locTrg->LoStripY(),locTrg->LoDev());
496 } else { //no trigger (see PRR chpt 3.4)
497 locCard = -1;
498 locDec = 0;
499 trigY = 1;
500 posY = 15;
501 posX = 0;
502 devX = 0x8000;
503 }
504
505 //packing word
506 word = 0;
507 AliBitPacking::PackWord((UInt_t)(iLocCard % 16),word,19,22); //card id number in crate
508 AliBitPacking::PackWord((UInt_t)locDec,word,15,18);
509 AliBitPacking::PackWord((UInt_t)trigY,word,14,14);
510 AliBitPacking::PackWord((UInt_t)posY,word,10,13);
511 AliBitPacking::PackWord((UInt_t)devX,word,5,9);
512 AliBitPacking::PackWord((UInt_t)posX,word,0,4);
513
514 if (locCard == iLocCard) {
515 // add local cards structure
516 buffer[index++] = (locTrg->GetX1Pattern() | (locTrg->GetX2Pattern() << 16));
517 buffer[index++] = (locTrg->GetX3Pattern() | (locTrg->GetX4Pattern() << 16));
518 buffer[index++] = (locTrg->GetY1Pattern() | (locTrg->GetY2Pattern() << 16));
519 buffer[index++] = (locTrg->GetY3Pattern() | (locTrg->GetY4Pattern() << 16));
520 buffer[index++] = (Int_t)word; // data word
521 if (iEntries < nEntries-1)
522 iEntries++;
523 } else {
524 buffer[index++] = 0; // 4 words for x1, x2, y1, y2
525 buffer[index++] = 0;
526 buffer[index++] = 0;
527 buffer[index++] = 0;
528 buffer[index++] = (Int_t)word; // data word
529
530 }
531 } // local card
532 buffer[index++] = 0;// 2 words of regional input
533 buffer[index++] = 0;
534 buffer[index++] = 0;// regional output
535
536 delete subEvent;
537
538 } // Regional card
539
540 buffer[index++] = fDDLTrigger->GetEoD(); // End of DDL word
a0b2ac9a 541 buffer[index++] = fDDLTrigger->GetEoD(); // End of DDL word for 64 bits transfer purpose
c8b4255f 542
543
544 if (iDDL == 0) {
545 // write DDL 1
546 header.fSize = index + headerSize;// total length in word
547 fwrite((char*)(&header),headerSize*4,1,fFile1);
548 fwrite(buffer,sizeof(int),index,fFile1);
549 }
550 if (iDDL == 1) {
551 // write DDL 2
552 header.fSize = index + headerSize;// total length in word
553 fwrite((char*)(&header),headerSize*4,1,fFile2);
554 fwrite(buffer,sizeof(int),index,fFile2);
555 }
556 }
557 delete[] buffer;
69be760c 558
559 return kTRUE;
560}
561//____________________________________________________________________
562void AliMUONRawData::GetDummyMapping(Int_t iCh, Int_t iCath, const AliMUONDigit* digit,
563 Int_t &busPatchId, UShort_t &manuId, UChar_t &channelId, UShort_t &charge)
564{
565
566 Int_t offsetX = 0; // offet row
567 Int_t offsetY = 0; // offset columns
568 Int_t offsetCath = 0; //offset from one cathod to the other
569 Int_t maxChannel = 0; // maximum nb of channel in 1/2 chamber
570 Int_t id;
f6762c71 571 switch (iCh+1) {
572 case 1:
573 case 2:
574 case 3:
575 case 4:
576 offsetX = 512;
577 offsetY = 256;
578 offsetCath = 65536;
579 maxChannel = (offsetY * offsetX + 2* offsetY + offsetCath);
580 break;
581 case 5:
582 case 6:
583 case 7:
584 case 8:
585 case 9:
586 case 10:
587 offsetX = 1024;
588 offsetY = 0;
589 offsetCath = 65536;
590 maxChannel = (256 * offsetX + offsetX + offsetCath);
591 break;
592 }
593 // dummy mapping
594 // manu Id directly from a matrix 8*8, same segmentation for B and NB
595 // 50 buspatches for 1/2 chamber
f6762c71 596
69be760c 597 id = (TMath::Abs(digit->PadX()) * offsetX + digit->PadY() + offsetY +
598 offsetCath * iCath);
599 Int_t chPerBus = maxChannel/50;
600 busPatchId = id/chPerBus; // start at zero
601 if (digit->PadX() > 0)
602 busPatchId += 50*iCh*2;
603 else
604 busPatchId += 50*(2*iCh+1);
f6762c71 605 // 64 manu cards for one buspatch
69be760c 606 manuId = (id % chPerBus)/64; //start at zero
f6762c71 607 manuId &= 0x7FF; // 11 bits
608
609 // channel id
69be760c 610 channelId = (id % chPerBus) % 64; //start at zero
f6762c71 611 channelId &= 0x3F; // 6 bits
612
69be760c 613// id = (TMath::Abs(digit->PadX()) * offsetX + digit->PadY() + offsetY +
614// offsetCath * iCath);
615// busPatchId = id/50;
616
617// Int_t inBusId = id - (maxChannel/50 * busPatchId);// id channel in buspatch
618// Int_t manuPerBus = (maxChannel/(50*64)); // number of manus per buspatch
619
620// // 64 manu cards for one buspatch
621// manuId = inBusId/manuPerBus;
622// manuId &= 0x7FF; // 11 bits
623
624// // channel id
625// channelId = (inBusId % manuPerBus);
626// channelId &= 0x3F; // 6 bits
627
628 if (fPrintLevel == 2)
629 printf("id: %d, busPatchId %d, manuId: %d, channelId: %d, maxchannel: %d, chPerBus %d\n",
630 id, busPatchId, manuId, channelId, maxChannel, chPerBus);
f6762c71 631 // charge
632 charge = digit->Signal();
633 charge &= 0xFFF;
634
69be760c 635 if (fPrintLevel == 2)
f6762c71 636 printf("id: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady %d, charge %d\n",
637 id, busPatchId, manuId, channelId, digit->PadX(), digit->PadY(), digit->Signal());
f6762c71 638
f6762c71 639}
c8b4255f 640
641//____________________________________________________________________
642Int_t AliMUONRawData::GetGlobalTriggerPattern(AliMUONGlobalTrigger* gloTrg)
643{
644 Int_t gloTrigPat = 0;
645
646 if (gloTrg->SinglePlusLpt()) gloTrigPat|= 0x1;
647 if (gloTrg->SinglePlusHpt()) gloTrigPat|= 0x2;
648 if (gloTrg->SinglePlusApt()) gloTrigPat|= 0x4;
649
650 if (gloTrg->SingleMinusLpt()) gloTrigPat|= 0x8;
651 if (gloTrg->SingleMinusHpt()) gloTrigPat|= 0x10;
652 if (gloTrg->SingleMinusApt()) gloTrigPat|= 0x20;
653
654 if (gloTrg->SingleUndefLpt()) gloTrigPat|= 0x40;
655 if (gloTrg->SingleUndefHpt()) gloTrigPat|= 0x80;
656 if (gloTrg->SingleUndefApt()) gloTrigPat|= 0x100;
657
658 if (gloTrg->PairUnlikeLpt()) gloTrigPat|= 0x200;
659 if (gloTrg->PairUnlikeHpt()) gloTrigPat|= 0x400;
660 if (gloTrg->PairUnlikeApt()) gloTrigPat|= 0x800;
661
662 if (gloTrg->PairLikeLpt()) gloTrigPat|= 0x1000;
663 if (gloTrg->PairLikeHpt()) gloTrigPat|= 0x2000;
664 if (gloTrg->PairLikeApt()) gloTrigPat|= 0x4000;
665
666 return gloTrigPat;
667}