]>
Commit | Line | Data |
---|---|---|
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 | // | |
ce6a659c | 18 | // MUON Raw Data generator and reader in ALICE-MUON |
19 | // This class version 1 (further details could be found in Alice-note) | |
20 | // Digits2Raw: | |
c8b4255f | 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) | |
ce6a659c | 26 | // Ch. Finck july 04 |
27 | // Raw2Digits: | |
28 | // Using still dummy mapping (inverse) for tracker | |
29 | // Indranil Das (Adapted for runloader: Ch. Finck) july 05 | |
f6762c71 | 30 | //////////////////////////////////// |
c8b4255f | 31 | |
69be760c | 32 | #include <TClonesArray.h> |
f6762c71 | 33 | #include "AliMUONRawData.h" |
34 | #include "AliMUONDigit.h" | |
1195fa7b | 35 | |
f1501d74 | 36 | #include "AliMUON.h" |
37 | #include "AliMUONChamber.h" | |
f6762c71 | 38 | #include "AliMUONConstants.h" |
39 | #include "AliMUONData.h" | |
f6762c71 | 40 | #include "AliLoader.h" |
41 | #include "AliBitPacking.h" | |
1197ff51 | 42 | #include "AliRawReader.h" |
1195fa7b | 43 | |
44 | #include "AliMUONSubEventTrigger.h" | |
69be760c | 45 | #include "AliMUONDDLTracker.h" |
46 | #include "AliMUONDDLTrigger.h" | |
47 | ||
c8b4255f | 48 | #include "AliMUONLocalTrigger.h" |
49 | #include "AliMUONGlobalTrigger.h" | |
f1501d74 | 50 | |
51 | #include "AliMUONGeometrySegmentation.h" | |
8c343c7c | 52 | #include "AliLog.h" |
f1501d74 | 53 | #include "AliRun.h" |
f6762c71 | 54 | |
f6762c71 | 55 | |
f6762c71 | 56 | |
ce6a659c | 57 | ClassImp(AliMUONRawData) // Class implementation in ROOT context |
f6762c71 | 58 | //__________________________________________________________________________ |
1197ff51 | 59 | AliMUONRawData::AliMUONRawData(AliLoader* loader) |
60 | : TObject() | |
f6762c71 | 61 | { |
62 | // Standard Constructor | |
63 | ||
f6762c71 | 64 | // initialize loader's |
65 | fLoader = loader; | |
66 | ||
67 | // initialize container | |
68 | fMUONData = new AliMUONData(fLoader,"MUON","MUON"); | |
69be760c | 69 | |
69be760c | 70 | // initialize array |
71 | fSubEventArray[0] = new TClonesArray("AliMUONSubEventTracker",1000); | |
72 | fSubEventArray[1] = new TClonesArray("AliMUONSubEventTracker",1000); | |
73 | ||
69be760c | 74 | |
75 | // ddl pointer | |
76 | fDDLTracker = new AliMUONDDLTracker(); | |
ce6a659c | 77 | fDDLTrigger = new AliMUONDDLTrigger(); |
f6762c71 | 78 | } |
79 | ||
80 | //__________________________________________________________________________ | |
81 | AliMUONRawData::AliMUONRawData() | |
82 | : TObject(), | |
f6762c71 | 83 | fMUONData(0), |
ce6a659c | 84 | fLoader(0), |
85 | fFile1(0x0), | |
86 | fFile2(0x0), | |
87 | fDDLTracker(0), | |
88 | fDDLTrigger(0) | |
89 | ||
f6762c71 | 90 | { |
91 | // Default Constructor | |
92 | } | |
93 | ||
94 | //_______________________________________________________________________ | |
95 | AliMUONRawData::AliMUONRawData (const AliMUONRawData& rhs) | |
96 | : TObject(rhs) | |
97 | { | |
98 | // Protected copy constructor | |
99 | ||
8c343c7c | 100 | AliFatal("Not implemented."); |
f6762c71 | 101 | } |
102 | ||
103 | //_______________________________________________________________________ | |
104 | AliMUONRawData & | |
105 | AliMUONRawData::operator=(const AliMUONRawData& rhs) | |
106 | { | |
107 | // Protected assignement operator | |
108 | ||
109 | if (this == &rhs) return *this; | |
110 | ||
8c343c7c | 111 | AliFatal("Not implemented."); |
f6762c71 | 112 | |
113 | return *this; | |
114 | } | |
115 | ||
116 | //__________________________________________________________________________ | |
117 | AliMUONRawData::~AliMUONRawData(void) | |
118 | { | |
119 | if (fMUONData) | |
120 | delete fMUONData; | |
69be760c | 121 | if (fSubEventArray[0]) |
122 | fSubEventArray[0]->Delete(); //using delete cos allocating memory in copy ctor. | |
123 | if (fSubEventArray[1]) | |
124 | fSubEventArray[1]->Delete(); | |
125 | ||
69be760c | 126 | if (fDDLTracker) |
127 | delete fDDLTracker; | |
128 | if (fDDLTrigger) | |
129 | delete fDDLTrigger; | |
130 | ||
f6762c71 | 131 | return; |
132 | } | |
133 | //____________________________________________________________________ | |
1197ff51 | 134 | Int_t AliMUONRawData::Digits2Raw() |
f6762c71 | 135 | { |
136 | // convert digits of the current event to raw data | |
137 | ||
1195fa7b | 138 | Int_t idDDL; |
f6762c71 | 139 | Char_t name[20]; |
140 | ||
141 | fLoader->LoadDigits("READ"); | |
69be760c | 142 | |
c8b4255f | 143 | fMUONData->SetTreeAddress("D,GLT"); |
f6762c71 | 144 | |
f6762c71 | 145 | |
c8b4255f | 146 | // tracking chambers |
147 | ||
148 | for (Int_t ich = 0; ich < AliMUONConstants::NTrackingCh(); ich++) { | |
149 | ||
f6762c71 | 150 | // open files |
1195fa7b | 151 | idDDL = ich * 2 + 0x900; |
152 | sprintf(name, "MUON_%d.ddl",idDDL); | |
f6762c71 | 153 | fFile1 = fopen(name,"w"); |
154 | ||
1195fa7b | 155 | idDDL = (ich * 2) + 1 + 0x900; |
156 | sprintf(name, "MUON_%d.ddl",idDDL); | |
f6762c71 | 157 | fFile2 = fopen(name,"w"); |
158 | ||
69be760c | 159 | WriteTrackerDDL(ich); |
f6762c71 | 160 | |
161 | // reset and close | |
162 | fclose(fFile1); | |
163 | fclose(fFile2); | |
164 | fMUONData->ResetDigits(); | |
165 | } | |
69be760c | 166 | |
167 | // trigger chambers | |
c8b4255f | 168 | |
69be760c | 169 | // open files |
1195fa7b | 170 | idDDL = 0xA00; |
171 | sprintf(name, "MUTR_%d.ddl",idDDL); | |
c8b4255f | 172 | fFile1 = fopen(name,"w"); |
69be760c | 173 | |
1195fa7b | 174 | idDDL = 0xA00 + 1; |
175 | sprintf(name, "MUTR_%d.ddl",idDDL); | |
c8b4255f | 176 | fFile2 = fopen(name,"w"); |
69be760c | 177 | |
c8b4255f | 178 | WriteTriggerDDL(); |
179 | ||
180 | // reset and close | |
181 | fclose(fFile1); | |
182 | fclose(fFile2); | |
183 | fMUONData->ResetTrigger(); | |
f6762c71 | 184 | |
c8b4255f | 185 | fLoader->UnloadDigits(); |
69be760c | 186 | |
f6762c71 | 187 | return kTRUE; |
188 | } | |
189 | //____________________________________________________________________ | |
69be760c | 190 | Int_t AliMUONRawData::WriteTrackerDDL(Int_t iCh) |
f6762c71 | 191 | { |
69be760c | 192 | // resets |
f6762c71 | 193 | TClonesArray* muonDigits = 0; |
69be760c | 194 | fSubEventArray[0]->Clear(); |
195 | fSubEventArray[1]->Clear(); | |
196 | ||
197 | // | |
198 | TArrayI nbInBus[2]; | |
199 | ||
200 | nbInBus[0].Set(5000); | |
201 | nbInBus[1].Set(5000); | |
202 | ||
203 | nbInBus[0].Reset(); | |
204 | nbInBus[1].Reset(); | |
205 | ||
206 | // DDL header | |
207 | AliRawDataHeader header = fDDLTracker->GetHeader(); | |
208 | Int_t headerSize = fDDLTracker->GetHeaderSize(); | |
f6762c71 | 209 | |
210 | // DDL event one per half chamber | |
69be760c | 211 | AliMUONSubEventTracker* subEvent; |
f6762c71 | 212 | |
213 | // data format | |
214 | Char_t parity = 0x4; | |
69be760c | 215 | UShort_t manuId = 0; |
216 | UChar_t channelId = 0; | |
217 | UShort_t charge = 0; | |
218 | Int_t busPatchId = 0; | |
f6762c71 | 219 | |
220 | UInt_t word; | |
69be760c | 221 | Int_t nEntries = 0; |
222 | Int_t* buffer = 0; | |
223 | Int_t index; | |
224 | Int_t indexDsp; | |
225 | Int_t indexBlk; | |
f1501d74 | 226 | Int_t padX; |
227 | Int_t padY; | |
228 | Int_t cathode = 0; | |
229 | Int_t detElemId; | |
f6762c71 | 230 | Int_t nDigits; |
69be760c | 231 | const AliMUONDigit* digit; |
f6762c71 | 232 | |
ae11cbee | 233 | // AliMUON *pMUON; |
234 | // AliMUONChamber* iChamber = 0x0; | |
235 | // AliMUONGeometrySegmentation* segmentation2[2]; | |
f1501d74 | 236 | |
ae11cbee | 237 | // pMUON = (AliMUON*) gAlice->GetModule("MUON"); |
238 | // iChamber = &(pMUON->Chamber(iCh)); | |
f6762c71 | 239 | |
ae11cbee | 240 | // segmentation2[0]=iChamber->SegmentationModel2(1); // cathode 0 |
241 | // segmentation2[1]=iChamber->SegmentationModel2(2); // cathode 1 | |
f1501d74 | 242 | |
243 | AliDebug(1, Form("WriteDDL chamber %d\n", iCh+1)); | |
244 | ||
935b9895 | 245 | // for (Int_t iCath = 0; iCath < 2; iCath++) { |
f6762c71 | 246 | |
f6762c71 | 247 | fMUONData->ResetDigits(); |
935b9895 | 248 | fMUONData->GetDigits(); |
f6762c71 | 249 | muonDigits = fMUONData->Digits(iCh); |
250 | ||
251 | nDigits = muonDigits->GetEntriesFast(); | |
1197ff51 | 252 | AliDebug(2,Form("ndigits = %d\n",nDigits)); |
f6762c71 | 253 | |
254 | // open DDL file, on per 1/2 chamber | |
255 | ||
256 | for (Int_t idig = 0; idig < nDigits; idig++) { | |
257 | ||
258 | digit = (AliMUONDigit*) muonDigits->UncheckedAt(idig); | |
259 | ||
f1501d74 | 260 | padX = digit->PadX(); |
261 | padY = digit->PadY(); | |
262 | charge = digit->Signal(); | |
263 | charge &= 0xFFF; | |
264 | cathode = digit->Cathode(); | |
265 | detElemId = digit->DetElemId(); | |
266 | ||
69be760c | 267 | // mapping |
ae11cbee | 268 | // if (detElemId == 0) { |
269 | // AliWarning("\ndetElemId = 0, old segmentation !\n"); | |
935b9895 | 270 | GetDummyMapping(iCh, cathode, digit, busPatchId, manuId, channelId); |
ae11cbee | 271 | // } else { |
272 | // // mapping (not far from real one) | |
273 | // AliMUONSegmentManuIndex* connect = segmentation2[iCath]->GetMpConnection(detElemId, padX, padY); | |
274 | // if (connect != 0x0) { | |
275 | // busPatchId = connect->GetBusPatchId(); | |
276 | // manuId = connect->GetManuId(); | |
277 | // channelId = connect->GetManuChannelId(); | |
278 | // AliDebug(3,Form("busPatchId %d, manuId: %d, channelId: %d\n", busPatchId, manuId, channelId)); | |
279 | // } else { | |
280 | // busPatchId = 0; | |
281 | // manuId = 0; | |
282 | // channelId = 0; | |
283 | // } | |
284 | ||
285 | // } | |
69be760c | 286 | //packing word |
287 | AliBitPacking::PackWord((UInt_t)parity,word,29,31); | |
288 | AliBitPacking::PackWord((UInt_t)manuId,word,18,28); | |
289 | AliBitPacking::PackWord((UInt_t)channelId,word,12,17); | |
290 | AliBitPacking::PackWord((UInt_t)charge,word,0,11); | |
291 | ||
292 | // set sub Event | |
293 | subEvent = new AliMUONSubEventTracker(); | |
294 | subEvent->AddData(word); | |
295 | subEvent->SetBusPatchId(busPatchId); | |
296 | if (digit->PadX() > 0) { | |
297 | nbInBus[0][busPatchId]++; | |
298 | AddData1(subEvent); | |
299 | } else { | |
300 | nbInBus[1][busPatchId]++; | |
301 | AddData2(subEvent); | |
302 | } | |
303 | delete subEvent; | |
304 | } | |
935b9895 | 305 | // } |
69be760c | 306 | fSubEventArray[0]->Sort(); |
307 | fSubEventArray[1]->Sort(); | |
308 | ||
309 | // gather datas from same bus patch | |
310 | for (Int_t iDDL = 0; iDDL < 2; iDDL++) { | |
311 | nEntries = fSubEventArray[iDDL]->GetEntriesFast(); | |
312 | ||
313 | for (Int_t i = 0; i < nEntries; i++) { | |
314 | AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(i); | |
315 | busPatchId = temp->GetBusPatchId(); | |
316 | ||
317 | // add bus patch header, length and total length managed by subevent class | |
318 | temp->SetTriggerWord(0xdeadbeef); | |
319 | for (Int_t j = 0; j < nbInBus[iDDL][busPatchId]-1; j++) { | |
320 | AliMUONSubEventTracker* temp1 = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(++i); | |
321 | temp->AddData(temp1->GetData(0)); | |
322 | fSubEventArray[iDDL]->RemoveAt(i) ; | |
323 | } | |
324 | } | |
325 | fSubEventArray[iDDL]->Compress(); | |
326 | ||
1197ff51 | 327 | if (AliLog::GetGlobalDebugLevel() == 3) { |
69be760c | 328 | nEntries = fSubEventArray[iDDL]->GetEntriesFast(); |
329 | for (Int_t i = 0; i < nEntries; i++) { | |
330 | AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(i); | |
331 | printf("busPatchid back %d\n",temp->GetBusPatchId()); | |
332 | for (Int_t j = 0; j < temp->GetLength(); j++) { | |
333 | printf("manuId back %d, ",temp->GetManuId(j)); | |
334 | printf("channelId back %d, ",temp->GetChannelId(j)); | |
335 | printf("charge back %d\n",temp->GetCharge(j)); | |
336 | } | |
337 | } | |
338 | printf("\n"); | |
339 | } | |
340 | ||
935b9895 | 341 | } |
69be760c | 342 | |
343 | Int_t iBusPatch; | |
344 | Int_t iEntries; | |
c8f4be1a | 345 | Int_t length; |
69be760c | 346 | |
347 | for (Int_t iDDL = 0; iDDL < 2; iDDL++) { | |
348 | ||
349 | ||
350 | // filling buffer | |
351 | nEntries = fSubEventArray[iDDL]->GetEntriesFast(); | |
352 | buffer = new Int_t [(2048+24)*50]; // 24 words in average for one buspatch and 2048 manu info at most | |
353 | ||
354 | indexBlk = 0; | |
355 | indexDsp = 0; | |
356 | index = 0; | |
357 | iBusPatch = 0; | |
358 | iEntries = 0; | |
359 | ||
360 | for (Int_t iBlock = 0; iBlock < 2; iBlock++) { | |
361 | ||
362 | // block header | |
c8f4be1a | 363 | // fDDLTracker->SetTotalBlkLength(0xFFFFFFFF); |
364 | length = fDDLTracker->GetBlkHeaderLength(); | |
365 | memcpy(&buffer[index],fDDLTracker->GetBlkHeader(),length*4); | |
69be760c | 366 | indexBlk = index; |
c8f4be1a | 367 | index += length; |
69be760c | 368 | |
369 | for (Int_t iDsp = 0; iDsp < 5; iDsp++) { | |
370 | ||
371 | // DSP header | |
c8f4be1a | 372 | // fDDLTracker->SetTotalDspLength(0xEEEEEEEE); |
373 | length = fDDLTracker->GetDspHeaderLength(); | |
374 | memcpy(&buffer[index],fDDLTracker->GetDspHeader(),length*4); | |
69be760c | 375 | indexDsp = index; |
c8f4be1a | 376 | index += length; |
69be760c | 377 | |
378 | for (Int_t i = 0; i < 5; i++) { | |
379 | ||
380 | iBusPatch = i + iBlock*25 + iDsp*5 + 50*(2*iCh + iDDL); | |
381 | ||
382 | AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(iEntries); | |
383 | if (nEntries > 0) | |
384 | busPatchId = temp->GetBusPatchId(); | |
385 | else | |
386 | busPatchId = -1; | |
387 | ||
388 | if (busPatchId == iBusPatch) { | |
389 | // add bus patch structure | |
c8f4be1a | 390 | length = temp->GetHeaderLength(); |
391 | memcpy(&buffer[index],temp->GetAddress(),length*4); | |
392 | index += length; | |
69be760c | 393 | for (Int_t j = 0; j < temp->GetLength(); j++) |
394 | buffer[index++] = temp->GetData(j); | |
395 | if (iEntries < nEntries-1) | |
396 | iEntries++; | |
397 | } else { | |
398 | buffer[index++] = 4; // total length | |
399 | buffer[index++] = 0; // raw data length | |
400 | buffer[index++] = iBusPatch; // bus patch | |
401 | buffer[index++] = 0xdeadbeef; // trigger word | |
402 | } | |
403 | } // bus patch | |
c8f4be1a | 404 | buffer[indexDsp] = index - indexDsp; // dsp length |
405 | buffer[indexDsp+1] = index - indexDsp - fDDLTracker->GetDspHeaderLength(); | |
69be760c | 406 | if ((index - indexDsp) % 2 == 0) |
407 | buffer[indexDsp+7] = 0; | |
408 | else | |
409 | buffer[indexDsp+7] = 1; | |
410 | } // dsp | |
c8f4be1a | 411 | buffer[indexBlk] = index - indexBlk; // block length |
412 | buffer[indexBlk+1] = index - indexBlk - fDDLTracker->GetBlkHeaderLength(); | |
69be760c | 413 | } |
414 | if (iDDL == 0) { | |
415 | // write DDL 1 | |
4b7579fc | 416 | header.fSize = (index + headerSize) * 4;// total length in bytes |
69be760c | 417 | fwrite((char*)(&header),headerSize*4,1,fFile1); |
418 | fwrite(buffer,sizeof(int),index,fFile1); | |
419 | } | |
420 | if (iDDL == 1) { | |
421 | // write DDL 2 | |
4b7579fc | 422 | header.fSize = (index + headerSize) * 4;// total length in bytes |
69be760c | 423 | fwrite((char*)(&header),headerSize*4,1,fFile2); |
424 | fwrite(buffer,sizeof(int),index,fFile2); | |
425 | } | |
426 | delete[] buffer; | |
427 | } | |
428 | ||
429 | return kTRUE; | |
430 | } | |
431 | //____________________________________________________________________ | |
432 | Int_t AliMUONRawData::WriteTriggerDDL() | |
433 | { | |
434 | ||
c8b4255f | 435 | // DDL event one per half chamber |
436 | AliMUONSubEventTrigger* subEvent = 0x0; | |
69be760c | 437 | |
69be760c | 438 | |
c8b4255f | 439 | // stored local id number |
440 | TArrayI isFired(256); | |
441 | isFired.Reset(); | |
69be760c | 442 | |
69be760c | 443 | |
c8b4255f | 444 | // DDL header |
445 | AliRawDataHeader header = fDDLTrigger->GetHeader(); | |
446 | Int_t headerSize = fDDLTrigger->GetHeaderSize(); | |
c8f4be1a | 447 | Int_t length; |
c8b4255f | 448 | TClonesArray* localTrigger; |
449 | TClonesArray* globalTrigger; | |
450 | AliMUONGlobalTrigger* gloTrg; | |
451 | AliMUONLocalTrigger* locTrg = 0x0; | |
452 | ||
453 | fMUONData->GetTriggerD(); | |
454 | ||
455 | // global trigger for trigger pattern | |
456 | globalTrigger = fMUONData->GlobalTrigger(); | |
457 | gloTrg = (AliMUONGlobalTrigger*)globalTrigger->UncheckedAt(0); | |
458 | Int_t gloTrigPat = GetGlobalTriggerPattern(gloTrg); | |
459 | ||
460 | // local trigger | |
461 | localTrigger = fMUONData->LocalTrigger(); | |
462 | ||
463 | UInt_t word; | |
464 | Int_t* buffer = 0; | |
465 | Int_t index; | |
466 | Int_t iEntries = 0; | |
467 | Int_t iLocCard, locCard; | |
e516b01d | 468 | Char_t locDec, trigY, posY, devX, posX,regOut; |
c8b4255f | 469 | Int_t version = 1; // software version |
c8f4be1a | 470 | Int_t eventType = 1; // trigger type: 1 for physics ? |
c8b4255f | 471 | Int_t serialNb = 0xF; // serial nb of card: all bits on for the moment |
c8f4be1a | 472 | Int_t globalFlag = 1; // set to 2 if global info present in DDL else set to 1 |
c8b4255f | 473 | |
474 | Int_t nEntries = (Int_t) (localTrigger->GetEntries());// 234 local cards | |
475 | // stored the local card id that's fired | |
476 | for (Int_t i = 0; i < nEntries; i++) { | |
477 | locTrg = (AliMUONLocalTrigger*)localTrigger->At(i); | |
478 | isFired[locTrg->LoCircuit()] = 1; | |
479 | } | |
480 | ||
481 | if (!nEntries) | |
8c343c7c | 482 | AliError("No Trigger information available"); |
c8b4255f | 483 | |
c8f4be1a | 484 | buffer = new Int_t [672]; // [16(local)*5 words + 3 words]*8(reg) + 8 words = 672 |
c8b4255f | 485 | |
486 | for (Int_t iDDL = 0; iDDL < 2; iDDL++) { | |
487 | ||
488 | index = 0; | |
489 | ||
490 | // DDL enhanced header | |
c8f4be1a | 491 | word = 0; |
492 | AliBitPacking::PackWord((UInt_t)iDDL+1,word,28,31); //see AliMUONDDLTrigger.h for details | |
493 | AliBitPacking::PackWord((UInt_t)serialNb,word,24,27); | |
494 | AliBitPacking::PackWord((UInt_t)version,word,16,23); | |
495 | AliBitPacking::PackWord((UInt_t)eventType,word,12,15); | |
496 | ||
497 | if (iDDL == 0) // suppose global info in DDL one | |
498 | globalFlag = 2; | |
499 | else | |
500 | globalFlag = 1; | |
501 | AliBitPacking::PackWord((UInt_t)globalFlag,word,8,11); | |
c8b4255f | 502 | fDDLTrigger->SetDDLWord(word); |
c8f4be1a | 503 | |
504 | if (iDDL == 0) | |
505 | fDDLTrigger->SetGlobalOutput(gloTrigPat);// no global input for the moment.... | |
506 | else | |
507 | fDDLTrigger->SetGlobalOutput(0); | |
508 | length = fDDLTrigger->GetHeaderLength(); | |
509 | memcpy(&buffer[index],fDDLTrigger->GetEnhancedHeader(),length*4); | |
510 | index += length; | |
c8b4255f | 511 | |
512 | for (Int_t iReg = 0; iReg < 8; iReg++) { | |
513 | ||
514 | subEvent = new AliMUONSubEventTrigger(); | |
515 | ||
516 | // Regional card header | |
517 | word = 0; | |
e516b01d | 518 | regOut = 0; |
519 | AliBitPacking::PackWord((UInt_t)serialNb,word,24,28); //see AliMUONSubEventTrigger.h for details | |
520 | AliBitPacking::PackWord((UInt_t)version,word,16,23); | |
521 | AliBitPacking::PackWord((UInt_t)iReg,word,12,15); | |
522 | AliBitPacking::PackWord((UInt_t)regOut,word,0,7); // whenever regional output will be implemented | |
523 | ||
c8b4255f | 524 | subEvent->SetRegWord(word); |
525 | memcpy(&buffer[index++],subEvent->GetAddress(),4); | |
526 | ||
e516b01d | 527 | buffer[index++] = 0;// 2 words of regional input |
528 | buffer[index++] = 0; | |
529 | ||
c8b4255f | 530 | for (Int_t iLoc = 0; iLoc < 16; iLoc++) { |
531 | ||
532 | iLocCard = iLoc + iReg*16 + iDDL*128; | |
533 | ||
534 | if (isFired[iLocCard]) { | |
535 | locTrg = (AliMUONLocalTrigger*)localTrigger->At(iEntries); | |
536 | locCard = locTrg->LoCircuit(); | |
537 | locDec = locTrg->GetLoDecision(); | |
538 | trigY = 0; | |
539 | posY = locTrg->LoStripY(); | |
540 | posX = locTrg->LoStripX(); | |
541 | devX = locTrg->LoDev(); | |
1197ff51 | 542 | AliDebug(4,Form("loctrg %d, posX %d, posY %d, devX %d\n", |
ce6a659c | 543 | locTrg->LoCircuit(),locTrg->LoStripX(),locTrg->LoStripY(),locTrg->LoDev())); |
c8b4255f | 544 | } else { //no trigger (see PRR chpt 3.4) |
545 | locCard = -1; | |
546 | locDec = 0; | |
547 | trigY = 1; | |
548 | posY = 15; | |
549 | posX = 0; | |
550 | devX = 0x8000; | |
551 | } | |
552 | ||
553 | //packing word | |
554 | word = 0; | |
555 | AliBitPacking::PackWord((UInt_t)(iLocCard % 16),word,19,22); //card id number in crate | |
556 | AliBitPacking::PackWord((UInt_t)locDec,word,15,18); | |
557 | AliBitPacking::PackWord((UInt_t)trigY,word,14,14); | |
558 | AliBitPacking::PackWord((UInt_t)posY,word,10,13); | |
559 | AliBitPacking::PackWord((UInt_t)devX,word,5,9); | |
560 | AliBitPacking::PackWord((UInt_t)posX,word,0,4); | |
561 | ||
562 | if (locCard == iLocCard) { | |
563 | // add local cards structure | |
564 | buffer[index++] = (locTrg->GetX1Pattern() | (locTrg->GetX2Pattern() << 16)); | |
565 | buffer[index++] = (locTrg->GetX3Pattern() | (locTrg->GetX4Pattern() << 16)); | |
566 | buffer[index++] = (locTrg->GetY1Pattern() | (locTrg->GetY2Pattern() << 16)); | |
567 | buffer[index++] = (locTrg->GetY3Pattern() | (locTrg->GetY4Pattern() << 16)); | |
568 | buffer[index++] = (Int_t)word; // data word | |
569 | if (iEntries < nEntries-1) | |
570 | iEntries++; | |
571 | } else { | |
572 | buffer[index++] = 0; // 4 words for x1, x2, y1, y2 | |
573 | buffer[index++] = 0; | |
574 | buffer[index++] = 0; | |
575 | buffer[index++] = 0; | |
576 | buffer[index++] = (Int_t)word; // data word | |
577 | ||
578 | } | |
579 | } // local card | |
c8b4255f | 580 | |
581 | delete subEvent; | |
582 | ||
583 | } // Regional card | |
584 | ||
585 | buffer[index++] = fDDLTrigger->GetEoD(); // End of DDL word | |
a0b2ac9a | 586 | buffer[index++] = fDDLTrigger->GetEoD(); // End of DDL word for 64 bits transfer purpose |
c8b4255f | 587 | |
588 | ||
589 | if (iDDL == 0) { | |
590 | // write DDL 1 | |
4b7579fc | 591 | header.fSize = (index + headerSize) * 4;// total length in bytes |
c8b4255f | 592 | fwrite((char*)(&header),headerSize*4,1,fFile1); |
593 | fwrite(buffer,sizeof(int),index,fFile1); | |
594 | } | |
595 | if (iDDL == 1) { | |
596 | // write DDL 2 | |
4b7579fc | 597 | header.fSize = (index + headerSize) * 4;// total length in bytes |
c8b4255f | 598 | fwrite((char*)(&header),headerSize*4,1,fFile2); |
599 | fwrite(buffer,sizeof(int),index,fFile2); | |
600 | } | |
601 | } | |
602 | delete[] buffer; | |
69be760c | 603 | |
604 | return kTRUE; | |
605 | } | |
606 | //____________________________________________________________________ | |
607 | void AliMUONRawData::GetDummyMapping(Int_t iCh, Int_t iCath, const AliMUONDigit* digit, | |
f1501d74 | 608 | Int_t &busPatchId, UShort_t &manuId, UChar_t &channelId) |
69be760c | 609 | { |
1195fa7b | 610 | // Dummy mapping for tracker |
69be760c | 611 | |
612 | Int_t offsetX = 0; // offet row | |
613 | Int_t offsetY = 0; // offset columns | |
614 | Int_t offsetCath = 0; //offset from one cathod to the other | |
615 | Int_t maxChannel = 0; // maximum nb of channel in 1/2 chamber | |
616 | Int_t id; | |
f6762c71 | 617 | switch (iCh+1) { |
618 | case 1: | |
619 | case 2: | |
620 | case 3: | |
621 | case 4: | |
622 | offsetX = 512; | |
623 | offsetY = 256; | |
624 | offsetCath = 65536; | |
625 | maxChannel = (offsetY * offsetX + 2* offsetY + offsetCath); | |
626 | break; | |
627 | case 5: | |
628 | case 6: | |
629 | case 7: | |
630 | case 8: | |
631 | case 9: | |
632 | case 10: | |
633 | offsetX = 1024; | |
634 | offsetY = 0; | |
635 | offsetCath = 65536; | |
636 | maxChannel = (256 * offsetX + offsetX + offsetCath); | |
637 | break; | |
638 | } | |
639 | // dummy mapping | |
640 | // manu Id directly from a matrix 8*8, same segmentation for B and NB | |
641 | // 50 buspatches for 1/2 chamber | |
f6762c71 | 642 | |
69be760c | 643 | id = (TMath::Abs(digit->PadX()) * offsetX + digit->PadY() + offsetY + |
644 | offsetCath * iCath); | |
645 | Int_t chPerBus = maxChannel/50; | |
646 | busPatchId = id/chPerBus; // start at zero | |
647 | if (digit->PadX() > 0) | |
648 | busPatchId += 50*iCh*2; | |
649 | else | |
650 | busPatchId += 50*(2*iCh+1); | |
f6762c71 | 651 | // 64 manu cards for one buspatch |
69be760c | 652 | manuId = (id % chPerBus)/64; //start at zero |
f6762c71 | 653 | manuId &= 0x7FF; // 11 bits |
654 | ||
655 | // channel id | |
69be760c | 656 | channelId = (id % chPerBus) % 64; //start at zero |
f6762c71 | 657 | channelId &= 0x3F; // 6 bits |
658 | ||
f1501d74 | 659 | |
660 | AliDebug(2,Form("id: %d, busPatchId %d, manuId: %d, channelId: %d, maxchannel: %d, chPerBus %d\n", | |
661 | id, busPatchId, manuId, channelId, maxChannel, chPerBus)); | |
f6762c71 | 662 | |
f1501d74 | 663 | AliDebug(2,Form("id: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady %d, charge %d\n", |
664 | id, busPatchId, manuId, channelId, digit->PadX(), digit->PadY(), digit->Signal())); | |
f6762c71 | 665 | |
f6762c71 | 666 | } |
c8b4255f | 667 | |
668 | //____________________________________________________________________ | |
1195fa7b | 669 | Int_t AliMUONRawData::GetGlobalTriggerPattern(const AliMUONGlobalTrigger* gloTrg) |
c8b4255f | 670 | { |
1195fa7b | 671 | // global trigger pattern calculation |
672 | ||
c8b4255f | 673 | Int_t gloTrigPat = 0; |
674 | ||
675 | if (gloTrg->SinglePlusLpt()) gloTrigPat|= 0x1; | |
676 | if (gloTrg->SinglePlusHpt()) gloTrigPat|= 0x2; | |
677 | if (gloTrg->SinglePlusApt()) gloTrigPat|= 0x4; | |
678 | ||
679 | if (gloTrg->SingleMinusLpt()) gloTrigPat|= 0x8; | |
680 | if (gloTrg->SingleMinusHpt()) gloTrigPat|= 0x10; | |
681 | if (gloTrg->SingleMinusApt()) gloTrigPat|= 0x20; | |
682 | ||
683 | if (gloTrg->SingleUndefLpt()) gloTrigPat|= 0x40; | |
684 | if (gloTrg->SingleUndefHpt()) gloTrigPat|= 0x80; | |
685 | if (gloTrg->SingleUndefApt()) gloTrigPat|= 0x100; | |
686 | ||
687 | if (gloTrg->PairUnlikeLpt()) gloTrigPat|= 0x200; | |
688 | if (gloTrg->PairUnlikeHpt()) gloTrigPat|= 0x400; | |
689 | if (gloTrg->PairUnlikeApt()) gloTrigPat|= 0x800; | |
690 | ||
691 | if (gloTrg->PairLikeLpt()) gloTrigPat|= 0x1000; | |
692 | if (gloTrg->PairLikeHpt()) gloTrigPat|= 0x2000; | |
693 | if (gloTrg->PairLikeApt()) gloTrigPat|= 0x4000; | |
694 | ||
695 | return gloTrigPat; | |
696 | } | |
1197ff51 | 697 | |
698 | //____________________________________________________________________ | |
ce6a659c | 699 | Int_t AliMUONRawData::Raw2Digits(AliRawReader* rawReader) |
1197ff51 | 700 | { |
ce6a659c | 701 | |
702 | // generate digits | |
703 | ReadTrackerDDL(rawReader); | |
704 | ||
705 | // generate trigger | |
706 | ReadTriggerDDL(rawReader); | |
707 | ||
708 | return kTRUE; | |
1197ff51 | 709 | |
710 | } | |
711 | ||
712 | //____________________________________________________________________ | |
ce6a659c | 713 | Int_t AliMUONRawData::ReadTrackerDDL(AliRawReader* rawReader) |
1197ff51 | 714 | { |
1197ff51 | 715 | |
ce6a659c | 716 | AliMUONSubEventTracker* subEventTracker = new AliMUONSubEventTracker(); |
717 | AliMUONDigit* digit = new AliMUONDigit(); | |
718 | ||
719 | ||
720 | //Read Header Size of DDL,Block,DSP and BusPatch. | |
721 | ||
722 | Int_t ddlHeaderSize = fDDLTracker->GetHeaderSize(); | |
723 | Int_t blockHeaderSize = fDDLTracker->GetBlkHeaderLength(); | |
724 | Int_t dspHeaderSize = fDDLTracker->GetDspHeaderLength(); | |
725 | Int_t buspatchHeaderSize = subEventTracker->GetHeaderLength(); | |
726 | ||
727 | // Each DDL is made with 2 Blocks each of which consists of 5 DSP and each of DSP has at most 5 buspatches. | |
728 | // This information is used to calculate the size of headers (DDL,Block and DSP) which has no interesting data. | |
729 | ||
730 | const Int_t blankDDLSize = ddlHeaderSize + 2*blockHeaderSize + 2*5*dspHeaderSize + 2*5*5*buspatchHeaderSize; | |
731 | const Int_t blankBlockSize = blockHeaderSize + 5*dspHeaderSize + 5*5*buspatchHeaderSize; | |
732 | const Int_t blankDspSize = dspHeaderSize + 5*buspatchHeaderSize; | |
733 | ||
734 | Int_t totalDDLSize, totalBlockSize, totalDspSize , totalBusPatchSize, dataSize; | |
735 | ||
736 | ||
737 | for(Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++){ // loops over tracking chambers | |
738 | ||
739 | UShort_t charge; | |
740 | Int_t padX, padY,iCath; | |
741 | ||
742 | for(Int_t iDDL = 0; iDDL < 2; iDDL++){ // DDL loop | |
743 | ||
744 | //rawReader = new AliRawReaderFile(iEvent); | |
745 | rawReader->Select(0X9,(2*iCh)+iDDL,(2*iCh)+iDDL); //Select the DDL file to be read | |
746 | ||
747 | rawReader->ReadHeader(); | |
748 | ||
749 | totalDDLSize = (rawReader->GetDataSize()+sizeof(AliRawDataHeader))/4; // 4 is multipiled to convert byte 2 word | |
750 | ||
751 | if(totalDDLSize>blankDDLSize){ // Compare the DDL header with an empty DDL header size to read the file | |
752 | ||
753 | ||
754 | Int_t totalDataWord = rawReader->GetDataSize()/4 ; | |
755 | UInt_t *buffer = new UInt_t[totalDataWord]; | |
756 | for(Int_t i=0;i<totalDataWord;i++){ | |
757 | UInt_t& temp = buffer[i]; | |
758 | rawReader->ReadNextInt(temp); // takes the whole result into buffer variable for future analysis | |
759 | } | |
760 | ||
761 | Char_t parity; | |
762 | Int_t buspatchId; | |
763 | UChar_t channelId; | |
764 | UShort_t manuId;//,charge; | |
765 | Int_t id;//,padX, padY,iCath; | |
766 | Int_t indexDsp, indexBusPatch, index = 0; | |
767 | ||
768 | ||
769 | for(Int_t iBlock = 0; iBlock < 2 ;iBlock++){ // loop over 2 blocks | |
770 | totalBlockSize = buffer[index]; | |
771 | ||
772 | if(totalBlockSize > blankBlockSize){ // compare block header | |
773 | index += blockHeaderSize; | |
774 | ||
775 | for(Int_t iDsp = 0; iDsp < 5 ;iDsp++){ //DSP loop | |
776 | totalDspSize = buffer[index]; | |
777 | indexDsp = index; | |
778 | ||
779 | if(totalDspSize > blankDspSize){ // Compare DSP Header | |
780 | index += dspHeaderSize; | |
781 | ||
782 | for(Int_t iBusPatch = 0; iBusPatch < 5 ; iBusPatch++){ | |
783 | totalBusPatchSize = buffer[index]; | |
784 | indexBusPatch = index; | |
785 | buspatchId = buffer[index+2]; | |
786 | ||
787 | if(totalBusPatchSize > buspatchHeaderSize){ //Check Buspatch header | |
788 | index += buspatchHeaderSize; | |
789 | dataSize = totalBusPatchSize - buspatchHeaderSize; | |
790 | ||
791 | if(dataSize>0) { | |
792 | ||
793 | for(Int_t iData = 0; iData < dataSize ;iData++) { | |
794 | ||
795 | subEventTracker->SetData(buffer[index++],iData); //Set to extract data | |
796 | parity = subEventTracker->GetParity(iData); | |
797 | manuId = subEventTracker->GetManuId(iData); | |
798 | channelId = subEventTracker->GetChannelId(iData); | |
799 | charge = subEventTracker->GetCharge(iData); | |
800 | digit->AddSignal(charge); // set charge | |
801 | ||
802 | GetInvDummyMapping(iCh,buspatchId,manuId,channelId,digit); // Get Back the hits at pads | |
803 | padX = digit->PadX(); | |
804 | padY = digit->PadY(); | |
805 | iCath = digit->Cathode(); | |
806 | id = digit->DetElemId(); | |
807 | ||
808 | // fill digits | |
809 | fMUONData->AddDigit(iCh, *digit); | |
810 | ||
811 | } // data loop | |
812 | } // dataSize test | |
813 | } // testing buspatch | |
814 | ||
815 | index = indexBusPatch + totalBusPatchSize; | |
816 | ||
817 | } //buspatch loop | |
818 | ||
819 | ||
820 | } // dsp test | |
821 | ||
822 | index = indexDsp + totalDspSize; | |
823 | ||
824 | } // dsp loop | |
825 | ||
826 | } //block test | |
827 | ||
828 | index = totalBlockSize; | |
829 | ||
830 | } //block loop | |
831 | ||
832 | delete []buffer; | |
833 | } //loop checking the header size of DDL | |
834 | ||
835 | //delete rawReader; | |
836 | } // DDL loop | |
837 | ||
838 | } // Chamber loop | |
839 | ||
840 | delete subEventTracker; | |
841 | delete digit; | |
842 | ||
843 | return kTRUE; | |
1197ff51 | 844 | } |
845 | ||
846 | //____________________________________________________________________ | |
ce6a659c | 847 | void AliMUONRawData:: GetInvDummyMapping(Int_t iCh, Int_t buspatchId, UShort_t manuId, |
848 | UChar_t channelId, AliMUONDigit* digit ) | |
1197ff51 | 849 | { |
ce6a659c | 850 | Int_t offsetX = 0; // offet row |
851 | Int_t offsetY = 0; // offset columns | |
852 | Int_t offsetCath = 0; //offset from one cathod to the other | |
853 | Int_t maxChannel = 0; // maximum nb of channel in 1/2 chamber | |
854 | //Int_t id; | |
855 | Bool_t flag; | |
856 | switch (iCh+1) { | |
857 | case 1: | |
858 | case 2: | |
859 | case 3: | |
860 | case 4: | |
861 | offsetX = 512; | |
862 | offsetY = 256; | |
863 | offsetCath = 65536; | |
864 | maxChannel = (offsetY * offsetX + 2* offsetY + offsetCath); | |
865 | break; | |
866 | case 5: | |
867 | case 6: | |
868 | case 7: | |
869 | case 8: | |
870 | case 9: | |
871 | case 10: | |
872 | offsetX = 1024; | |
873 | offsetY = 0; | |
874 | offsetCath = 65536; | |
875 | maxChannel = (256 * offsetX + offsetX + offsetCath); | |
876 | break; | |
877 | } | |
878 | // dummy mapping | |
879 | // manu Id directly from a matrix 8*8, same segmentation for B and NB | |
880 | // 50 buspatches for 1/2 chamber | |
881 | ||
882 | if(buspatchId >= 50*(2*iCh + 1)){ // condn to find the sign of padX | |
883 | buspatchId = buspatchId - 50*(2*iCh + 1); | |
884 | flag = kTRUE; | |
885 | } | |
886 | else{ | |
887 | buspatchId = buspatchId - 50*2*iCh; | |
888 | flag = kFALSE; | |
889 | } | |
890 | ||
891 | Int_t chPerBus = maxChannel/50; | |
892 | ||
893 | Int_t id = buspatchId*chPerBus + 64*manuId + channelId; | |
894 | Int_t iCath, padX,padY; | |
895 | if(id >= (offsetY + offsetCath)) // find cathode plane | |
896 | iCath = 1; | |
897 | else | |
898 | iCath = 0; | |
899 | ||
900 | if(iCh<4) | |
901 | padX = TMath::Nint((Float_t)(id - offsetY - offsetCath*iCath)/offsetX); | |
902 | else | |
903 | padX = (id - offsetY - offsetCath*iCath)/offsetX; | |
904 | ||
905 | padY = id - (padX*offsetX + offsetY + offsetCath*iCath); | |
906 | ||
907 | if(flag) //Detect the sign of padX | |
908 | padX = -padX; | |
909 | else | |
910 | padX = padX; | |
911 | ||
912 | digit->SetPadX(padX); | |
913 | digit->SetPadY(padY); | |
914 | digit->SetCathode(iCath); | |
915 | digit->SetDetElemId(id); | |
916 | ||
1197ff51 | 917 | return; |
918 | } | |
919 | ||
920 | //____________________________________________________________________ | |
ce6a659c | 921 | Int_t AliMUONRawData::ReadTriggerDDL(AliRawReader* rawReader) |
922 | { | |
923 | AliMUONSubEventTrigger* subEventTrigger = new AliMUONSubEventTrigger(); | |
924 | AliMUONGlobalTrigger* globalTrigger = 0x0; | |
925 | AliMUONLocalTrigger* localTrigger = new AliMUONLocalTrigger(); | |
926 | ||
927 | ||
928 | //Int_t ddlHeaderSize = fDDLTrigger->GetHeaderSize(); // we dont need this, as size of ddl data is same for triger and no trigger | |
929 | ||
930 | Int_t ddlEnhanceHeaderSize = fDDLTrigger->GetHeaderLength(); | |
931 | Int_t regHeaderLength = subEventTrigger->GetRegHeaderLength() ; | |
932 | ||
933 | Int_t loCircuit, loStripX, loDev, loStripY, loLpt, loHpt; | |
934 | Char_t loDecision; | |
935 | ||
936 | UShort_t X1Pattern, X2Pattern, X3Pattern, X4Pattern; | |
937 | UShort_t Y1Pattern, Y2Pattern, Y3Pattern, Y4Pattern; | |
938 | ||
939 | ||
940 | for(Int_t iDDL = 0; iDDL < 2; iDDL++){ //DDL loop | |
941 | ||
942 | rawReader->Select(0XA,iDDL,iDDL); //Select the DDL file to be read | |
943 | ||
944 | rawReader->ReadHeader(); | |
945 | ||
946 | Int_t totalDataWord = rawReader->GetDataSize()/4 ; | |
947 | UInt_t *buffer = new UInt_t[totalDataWord]; | |
948 | for(Int_t i=0;i<totalDataWord;i++){ | |
949 | UInt_t& temp = buffer[i]; | |
950 | rawReader->ReadNextInt(temp); // takes the whole result into buffer variable for future analysis | |
951 | } | |
952 | ||
953 | // rawReader->ReadNext((UChar_t*)buffer, totalDataWord); // method is protected ???? | |
954 | ||
955 | Int_t index = 0; | |
956 | ||
957 | // fill DDL header informations | |
958 | memcpy(fDDLTrigger->GetEnhancedHeader(), &buffer[index], ddlEnhanceHeaderSize*4); | |
959 | ||
960 | // fill global trigger information | |
961 | globalTrigger = GetGlobalTriggerPattern(fDDLTrigger->GetGlobalOuput()); | |
962 | fMUONData->AddGlobalTrigger(*globalTrigger); | |
963 | ||
964 | index += ddlEnhanceHeaderSize; | |
965 | ||
966 | for (Int_t iReg = 0; iReg < 8; iReg++) { //loop over regeonal card | |
967 | ||
968 | ||
969 | subEventTrigger->SetRegWord(buffer[index]); //read regional data | |
970 | ||
971 | index += regHeaderLength; | |
972 | ||
973 | for (Int_t iLoc = 0; iLoc < 16; iLoc++) { //loop over local card | |
974 | ||
975 | Int_t iLocIndex = index; | |
976 | ||
977 | for(Int_t iData = 0; iData < 5 ;iData++ ){ | |
978 | subEventTrigger->SetLocalData(buffer[index++],5*iLoc+iData); //read local data | |
979 | } | |
980 | ||
981 | if(buffer[iLocIndex] > 0) { | |
982 | ||
983 | loCircuit = (Int_t)subEventTrigger->GetLocalId(iLoc)+ 16*iReg + 128*iDDL; | |
984 | loStripX = (Int_t)subEventTrigger->GetXPos(iLoc); | |
985 | loStripY = (Int_t)subEventTrigger->GetYPos(iLoc); | |
986 | loDev = (Int_t)subEventTrigger->GetXDev(iLoc); | |
987 | ||
988 | // fill local trigger | |
989 | localTrigger->SetLoCircuit(loCircuit); | |
990 | localTrigger->SetLoStripX(loStripX ); | |
991 | localTrigger->SetLoStripY(loStripY); | |
992 | localTrigger->SetLoDev(loDev); | |
993 | ||
994 | loDecision = subEventTrigger->GetLocalDec(iLoc); | |
995 | loLpt = loDecision & 0x3; | |
996 | loHpt = (loDecision >> 2) & 0x3; | |
997 | ||
998 | // fill local trigger | |
999 | localTrigger->SetLoLpt(loLpt); | |
1000 | localTrigger->SetLoHpt(loHpt); | |
1001 | ||
1002 | ||
1003 | X1Pattern = subEventTrigger->GetX1(iLoc); | |
1004 | X2Pattern = subEventTrigger->GetX2(iLoc); | |
1005 | X3Pattern = subEventTrigger->GetX3(iLoc); | |
1006 | X4Pattern = subEventTrigger->GetX4(iLoc); | |
1007 | ||
1008 | Y1Pattern = subEventTrigger->GetY1(iLoc); | |
1009 | Y2Pattern = subEventTrigger->GetY2(iLoc); | |
1010 | Y3Pattern = subEventTrigger->GetY3(iLoc); | |
1011 | Y4Pattern = subEventTrigger->GetY4(iLoc); | |
1012 | ||
1013 | // fill local trigger | |
1014 | localTrigger->SetX1Pattern(X1Pattern); | |
1015 | localTrigger->SetX2Pattern(X2Pattern); | |
1016 | localTrigger->SetX3Pattern(X3Pattern); | |
1017 | localTrigger->SetX4Pattern(X4Pattern); | |
1018 | ||
1019 | localTrigger->SetY1Pattern(Y1Pattern); | |
1020 | localTrigger->SetY2Pattern(Y2Pattern); | |
1021 | localTrigger->SetY3Pattern(Y3Pattern); | |
1022 | localTrigger->SetY4Pattern(Y4Pattern); | |
1023 | fMUONData->AddLocalTrigger(*localTrigger); | |
1024 | ||
1025 | } | |
1026 | ||
1027 | } // local card loop | |
1028 | ||
1029 | } // regeinal card loop | |
1030 | ||
1031 | delete [] buffer; | |
1032 | //delete rawReader; | |
1033 | } // DDL loop | |
1034 | ||
1035 | ||
1036 | delete subEventTrigger; | |
1037 | delete globalTrigger; | |
1038 | delete localTrigger; | |
1039 | ||
1040 | return kTRUE; | |
1041 | ||
1042 | } | |
1043 | //____________________________________________________________________ | |
1044 | AliMUONGlobalTrigger* AliMUONRawData::GetGlobalTriggerPattern(Int_t gloTrigPat) | |
1197ff51 | 1045 | { |
ce6a659c | 1046 | // global trigger pattern calculation |
1047 | ||
1048 | Int_t globalSinglePlus[3]; // tot num of single plus | |
1049 | Int_t globalSingleMinus[3]; // tot num of single minus | |
1050 | Int_t globalSingleUndef[3]; // tot num of single undefined | |
1051 | Int_t globalPairUnlike[3]; // tot num of unlike-sign pairs | |
1052 | Int_t globalPairLike[3]; // tot num of like-sign pairs | |
1053 | ||
1054 | ||
1055 | for (Int_t i = 0; i < 3; i++) { | |
1056 | globalSinglePlus[i] = gloTrigPat & (0x1 << i); | |
1057 | globalSingleMinus[i] = gloTrigPat & (0x1 << i+3); | |
1058 | globalSingleUndef[i] = gloTrigPat & (0x1 << i+6); | |
1059 | globalPairUnlike[i] = gloTrigPat & (0x1 << i+9); | |
1060 | globalPairLike[i] = gloTrigPat & (0x1 << i+12); | |
1061 | } | |
1062 | ||
1063 | return (new AliMUONGlobalTrigger(globalSinglePlus, globalSingleMinus, | |
1064 | globalSingleUndef, globalPairUnlike, | |
1065 | globalPairLike)); | |
1197ff51 | 1066 | |
1067 | } |