]>
Commit | Line | Data |
---|---|---|
f9720615 | 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 | // Pre-Trigger simulation // | |
21 | // // | |
22 | // Authors: F. Reidt (Felix.Reidt@cern.ch) // | |
23 | // // | |
24 | //////////////////////////////////////////////////////////////////////////// | |
25 | ||
26 | #include "TFile.h" | |
27 | #include "TROOT.h" | |
28 | ||
29 | #include "TClonesArray.h" | |
30 | ||
31 | #include "AliRun.h" | |
32 | #include "AliRunLoader.h" | |
33 | ||
c93255fe | 34 | #include "AliTOFdigit.h" |
35 | #include "AliRawReader.h" // needed for AliTOFTrigger's raw digit support | |
36 | #include "AliTOFTrigger.h" | |
f9720615 | 37 | |
38 | #include "AliTRDptrgParam.h" | |
39 | ||
40 | #include "AliTRDptrgTLMU.h" | |
c93255fe | 41 | #include "AliLog.h" |
f9720615 | 42 | |
43 | ClassImp(AliTRDptrgTLMU) | |
44 | ||
45 | //______________________________________________________________________________ | |
46 | AliTRDptrgTLMU::AliTRDptrgTLMU(AliRunLoader *rl) | |
47 | : TObject(), | |
48 | fRunLoader(rl), | |
49 | fParam(0x0), | |
50 | fOperatingMode(kDigits), | |
51 | fInputMask(0x0), | |
52 | fCMatrices(0x0), | |
53 | fMultiplicity(0x0), | |
54 | fOutput(0x0) | |
55 | { | |
56 | // default ctor | |
57 | ||
58 | for (Int_t i = 0; i < 18; i++) { | |
e51605d9 | 59 | this->fTOFinputBits[i] = 0; |
f9720615 | 60 | } |
e51605d9 | 61 | |
62 | this->LoadParams(); | |
f9720615 | 63 | } |
64 | ||
65 | //______________________________________________________________________________ | |
66 | AliTRDptrgTLMU::AliTRDptrgTLMU(AliRunLoader *rl, AliTRDptrgParam *param, | |
67 | AliTRDptrgOperatingMode_t operatingMode) | |
68 | : TObject(), | |
69 | fRunLoader(rl), | |
70 | fParam(param), | |
71 | fOperatingMode(operatingMode), | |
72 | fInputMask(0x0), | |
73 | fCMatrices(0x0), | |
74 | fMultiplicity(0x0), | |
75 | fOutput(0x0) | |
76 | { | |
77 | // recommended ctor | |
78 | ||
79 | for (Int_t i = 0; i < 18; i++) { | |
e51605d9 | 80 | this->fTOFinputBits[i] = 0; |
f9720615 | 81 | } |
82 | ||
83 | this->LoadParams(); | |
84 | } | |
85 | ||
86 | //______________________________________________________________________________ | |
87 | AliTRDptrgTLMU::~AliTRDptrgTLMU() | |
88 | { | |
89 | // destructor | |
90 | ||
91 | this->fCMatrices = 0x0; | |
92 | this->fMultiplicity = 0x0; | |
93 | this->fOutput = 0x0; | |
94 | } | |
95 | ||
96 | //______________________________________________________________________________ | |
97 | Int_t* AliTRDptrgTLMU::Simulate() | |
98 | { | |
99 | // starts a simulation | |
100 | ||
101 | if (this->fOperatingMode == kDigits) { | |
102 | this->LoadDigits(); | |
103 | } | |
104 | else if (this->fOperatingMode == kHits) { | |
105 | return 0x0; // TODO | |
106 | } | |
107 | ||
108 | // which super modules are active? - needed for fast coincidence processing: | |
109 | // M(sm | coincidence condition)>=2 | |
110 | UInt_t temp = 0x1; | |
111 | UInt_t sm = 0x0; | |
112 | for (Int_t iSM = 0; iSM < 18; iSM++) { | |
113 | if (this->Or(iSM)) { | |
114 | sm |= temp; | |
115 | } | |
116 | temp <<= 1; | |
117 | } | |
118 | AliDebug(4, Form("Active supermodules: 0x%x", sm)); | |
119 | ||
120 | // get multiplicity | |
121 | UInt_t multiplicity = this->GetMultiplicitySum(); | |
122 | AliDebug(4, Form("TOF/TLMU multiplicity: %d", multiplicity)); | |
123 | ||
124 | Int_t* result = new Int_t[9]; | |
125 | result[0] = 8; | |
126 | for (Int_t iResult = 0; iResult < 8; iResult++) { | |
127 | result[iResult + 1] = 0; | |
128 | ||
129 | // coincidence matrix | |
130 | if (this->fOutput[iResult][0] != -1) { | |
131 | for (Int_t iLine = 0; iLine < 18; iLine++) { | |
e51605d9 | 132 | AliDebug(5, Form("Entry: %d, matrix: %d, line: %d, output: 0x%x", |
133 | iResult, this->fOutput[iResult][0], iLine, sm & | |
134 | this->fCMatrices[this->fOutput[iResult][0]][iLine])); | |
f9720615 | 135 | if (this->GetBitVectorMultiplicity( |
e51605d9 | 136 | sm & this->fCMatrices[this->fOutput[iResult][0]][iLine]) > 1) { |
f9720615 | 137 | result[iResult + 1] = 1; |
138 | break; | |
139 | } | |
140 | } | |
141 | } | |
142 | ||
143 | // multiplicity conditions | |
144 | if (this->fOutput[iResult][1] != -1) { | |
e51605d9 | 145 | AliDebug(5, Form("Entry: %d, slice: %d", iResult, |
f9720615 | 146 | this->fOutput[iResult][1])); |
147 | if ((this->fMultiplicity[this->fOutput[iResult][1]][0] < multiplicity) && | |
148 | (this->fMultiplicity[this->fOutput[iResult][1]][1] >= multiplicity)) { | |
149 | result[iResult + 1] = 1; | |
150 | } | |
151 | } | |
152 | AliDebug(4, Form("TLMU result[%d] = %d", iResult, result[iResult + 1])); | |
153 | } | |
154 | ||
155 | return result; | |
156 | } | |
157 | ||
158 | //______________________________________________________________________________ | |
159 | Int_t AliTRDptrgTLMU::LoadDigits() | |
160 | { | |
161 | // loads Digits (for usage with aquired data) | |
162 | this->GetInputBits(); // get bits from AliTOFTrigger | |
163 | return 0; | |
164 | } | |
165 | ||
166 | ||
167 | //______________________________________________________________________________ | |
168 | Bool_t AliTRDptrgTLMU::LoadParams() | |
169 | { | |
170 | // load AliTRDprtgParam content | |
171 | ||
172 | if (this->fParam == 0x0) { | |
173 | // no parameter object assigned | |
174 | AliWarning("no parameter object assigned - using default settings!"); | |
175 | ||
e51605d9 | 176 | UInt_t* imask = 0x0; |
177 | imask = new UInt_t[18]; | |
178 | for (Int_t i = 0; i < 18; i++) { | |
179 | imask[i] = 0xFFFFFFFF; | |
180 | } | |
181 | ||
182 | this->fInputMask = imask; | |
183 | ||
184 | // TLMU Coincidence Matrices | |
185 | this->fCMatrices = new UInt_t*[3]; | |
186 | this->fCMatrices[0] = new UInt_t[18]; | |
187 | this->fCMatrices[1] = new UInt_t[18]; | |
188 | this->fCMatrices[2] = new UInt_t[18]; | |
189 | ||
190 | // Matrix 0: Back-To-Back | |
191 | // Matrix 1: Back-To-Back +/-1 | |
192 | // Matrix 2: Back-To-Back +/-2 | |
193 | for (UInt_t iMatrix = 0; iMatrix < 3; iMatrix++) { | |
194 | for (UInt_t iSlice = 0; iSlice < 18; iSlice++) { | |
195 | if (iMatrix == 0) { | |
196 | if (iSlice < 9) { | |
197 | this->fCMatrices[iMatrix][iSlice] = 0x201 << iSlice; | |
198 | // Back-To-Back | |
199 | AliDebug(5, Form("fCMatrices[%d][%d]=0x%x",iMatrix,iSlice, | |
200 | this->fCMatrices[iMatrix][iSlice])); | |
201 | } | |
202 | // because of symmetrie the other slices are not necessary | |
203 | } | |
204 | else if (iMatrix == 1) { | |
205 | // Back-To-Back +/- 1 | |
206 | if (iSlice < 8) { | |
207 | this->fCMatrices[iMatrix][iSlice] = 0x381 << iSlice; | |
208 | } | |
209 | else if (iSlice == 8) { | |
210 | this->fCMatrices[iMatrix][iSlice] = 0x30101; | |
211 | } | |
212 | else if (iSlice == 9) { | |
213 | this->fCMatrices[iMatrix][iSlice] = 0x20203; | |
214 | } | |
215 | else { | |
216 | this->fCMatrices[iMatrix][iSlice] = 0x407 << (iSlice - 10); | |
217 | } | |
218 | AliDebug(5, Form("fCMatrices[%d][%d]=0x%x",iMatrix,iSlice, | |
219 | this->fCMatrices[iMatrix][iSlice])); | |
220 | } | |
221 | else if (iMatrix == 2) { | |
222 | // Back-To-Back +/-2 | |
223 | if (iSlice < 7 ) { | |
224 | this->fCMatrices[iMatrix][iSlice] = 0xF81 << iSlice; | |
225 | } | |
226 | else if (iSlice == 7) { | |
227 | this->fCMatrices[iMatrix][iSlice] = 0x3C081; | |
228 | } | |
229 | else if (iSlice == 8) { | |
230 | this->fCMatrices[iMatrix][iSlice] = 0x38103; | |
231 | } | |
232 | else if (iSlice == 9) { | |
233 | this->fCMatrices[iMatrix][iSlice] = 0x30207; | |
234 | } | |
235 | else if (iSlice == 10) { | |
236 | this->fCMatrices[iMatrix][iSlice] = 0x2040F; | |
237 | } | |
238 | else { | |
239 | this->fCMatrices[iMatrix][iSlice] = 0x81F << (iSlice - 11); | |
240 | } | |
241 | AliDebug(5, Form("fCMatrices[%d][%d]=0x%x",iMatrix,iSlice, | |
242 | this->fCMatrices[iMatrix][iSlice])); | |
243 | } | |
244 | } | |
245 | } | |
246 | ||
247 | // Mulitplicity | |
248 | this->fMultiplicity = new UInt_t*[9]; | |
249 | for (Int_t i = 0; i < 9; i++) { | |
250 | this->fMultiplicity[i] = new UInt_t[2]; | |
251 | } | |
252 | this->fMultiplicity[0][0] = 0; | |
253 | this->fMultiplicity[0][1] = 10; | |
254 | this->fMultiplicity[1][0] = 10; | |
255 | this->fMultiplicity[1][1] = 25; | |
256 | this->fMultiplicity[2][0] = 25; | |
257 | this->fMultiplicity[2][1] = 50; | |
258 | this->fMultiplicity[3][0] = 50; | |
259 | this->fMultiplicity[3][1] = 100; | |
260 | this->fMultiplicity[4][0] = 100; | |
261 | this->fMultiplicity[4][1] = 200; | |
262 | this->fMultiplicity[5][0] = 200; | |
263 | this->fMultiplicity[5][1] = 350; | |
264 | this->fMultiplicity[6][0] = 350; | |
265 | this->fMultiplicity[6][1] = 400; | |
266 | this->fMultiplicity[7][0] = 400; | |
267 | this->fMultiplicity[7][1] = 576; | |
268 | this->fMultiplicity[8][0] = 100; | |
269 | this->fMultiplicity[8][1] = 576; | |
270 | ||
271 | // TLMU output | |
272 | this->fOutput = new Int_t*[8]; | |
273 | for (Int_t i = 0; i < 9; i++) { | |
274 | this->fOutput[i] = new Int_t[2]; | |
275 | this->fOutput[i][0] = -1; | |
276 | this->fOutput[i][1] = -1; | |
277 | } | |
278 | this->fOutput[0][0] = 0; | |
279 | this->fOutput[1][0] = 1; | |
280 | this->fOutput[2][0] = 2; | |
281 | this->fOutput[3][1] = 0; | |
282 | this->fOutput[4][1] = 1; | |
283 | this->fOutput[5][1] = 2; | |
284 | this->fOutput[6][1] = 3; | |
285 | this->fOutput[7][1] = 8; | |
286 | ||
287 | ||
f9720615 | 288 | } |
289 | else { | |
290 | // parameter object assigned | |
291 | ||
292 | this->fInputMask = this->fParam->GetTLMUInputMask(); | |
293 | // input mask for TOF-bits (18x32=576) | |
294 | ||
295 | this->fCMatrices = this->fParam->GetTLMUcmatrices(); | |
296 | // get coincidence matrices | |
297 | ||
298 | this->fMultiplicity = this->fParam->GetTLMUmultiplicity(); | |
299 | // get multiplicity slices | |
300 | ||
301 | this->fOutput = this->fParam->GetTLMUoutput(); | |
302 | // get output signal assignment | |
303 | } | |
304 | ||
305 | return false; | |
306 | } | |
307 | ||
308 | //______________________________________________________________________________ | |
309 | void AliTRDptrgTLMU::GetInputBits() { | |
310 | // Gets TOF-to-TRD input bits from AliTOFTrigger as Bool_t array | |
311 | ||
312 | AliTOFTrigger *toftrig = new AliTOFTrigger(); // create AliTOFTrigger | |
b5d772e9 | 313 | toftrig->CreateLTMMatrix(); // Generate LTMMatrix from AliTOFdigits |
f9720615 | 314 | |
315 | // prepare map | |
316 | Bool_t** map = 0x0; | |
317 | map = new Bool_t*[72]; | |
318 | for (Int_t i=0; i < 72; i++) | |
319 | map[i] = new Bool_t[8]; | |
320 | ||
321 | // initialise map | |
322 | for (Int_t i=0; i < 72; i++) | |
323 | for (Int_t j=0; j < 8; j++) | |
e51605d9 | 324 | map[i][j] = kFALSE; |
f9720615 | 325 | |
326 | // get 576 TOF-to-TRD bits | |
327 | toftrig->GetTRDmap(map); | |
328 | ||
e51605d9 | 329 | //* DEBUG output |
f9720615 | 330 | // used to determine the correct bit assignment |
e51605d9 | 331 | AliDebug(5, "AliTOFTrigger->GetTRDmap(map):"); |
f9720615 | 332 | for (Int_t i=0; i < 72; i++) { |
e51605d9 | 333 | AliDebug(5, Form("%d %d%d%d%d%d%d%d%d", i, map[i][0], map[i][1], map[i][2], |
334 | map[i][3], map[i][4], map[i][5], map[i][6], map[i][7])); | |
f9720615 | 335 | } |
336 | //*/ // end of DEBUG output | |
e51605d9 | 337 | |
338 | // initialise fTOFinputBits | |
339 | for (Int_t i=0; i < 18; i++) { | |
340 | this->fTOFinputBits[i] = 0; | |
341 | } | |
342 | ||
f9720615 | 343 | |
344 | // transform Bool_t array to UInt_t bitvectors according to | |
345 | // http://www.physi.uni-heidelberg.de/~schicker/cbtof/cbtof_docu.pdf | |
346 | // chapter 1.4 and 2.1 to a supermodule based structured | |
347 | // integer (bit) array | |
348 | Int_t supermodule = -1; | |
349 | UInt_t tempA = 0x00000001; | |
350 | UInt_t tempC = 0x00010000; | |
351 | for (Int_t iLTM = 0; iLTM < (kNLTM / 2); iLTM++) { | |
352 | if (!(iLTM % 2)) { // renew temp vectors, update supermodule | |
353 | tempA = 0x00000001; | |
354 | tempC = 0x00010000; | |
355 | supermodule++; | |
356 | } | |
e51605d9 | 357 | // AliDebug(5, Form("(%2d,0x%8x,0x%8x)", iLTM, tempA, tempC)); |
f9720615 | 358 | for (Int_t iLTMchan = 0; iLTMchan < 8; iLTMchan++) { |
359 | // A-side | |
360 | if (map[iLTM][iLTMchan]) { | |
e51605d9 | 361 | this->fTOFinputBits[supermodule] |= tempA; |
f9720615 | 362 | } |
363 | // C-side | |
364 | if (map[iLTM + 36][iLTMchan]) { | |
e51605d9 | 365 | this->fTOFinputBits[supermodule] |= tempC; |
f9720615 | 366 | } |
367 | // change temp vectors | |
368 | tempA <<= 1; | |
369 | tempC <<= 1; | |
370 | } | |
371 | } | |
372 | ||
373 | // handle input mask | |
374 | for (Int_t iSM = 0; iSM < 18; iSM++) { | |
375 | AliDebug(5, Form("fInputTOFinputBits[%d]=0x%x", iSM, | |
e51605d9 | 376 | this->fTOFinputBits[iSM])); |
377 | this->fTOFinputBits[iSM] &= this->fInputMask[iSM]; | |
f9720615 | 378 | } |
379 | } | |
380 | ||
381 | ||
382 | //______________________________________________________________________________ | |
383 | Int_t AliTRDptrgTLMU::BackToBack(Int_t iSM, Int_t range) { | |
384 | // Check whether there is an back-to-back particle trace | |
385 | ||
386 | // get the counterpart of supermodule iSM | |
387 | Int_t counterPart = -1; | |
388 | if (iSM >= 9) { | |
389 | counterPart = iSM - 9; | |
390 | } | |
391 | else { | |
392 | counterPart = iSM + 9; | |
393 | } | |
394 | ||
395 | if (this->Or(iSM)) { // is there are active bits in supermodule iSM | |
396 | Int_t result = 0; | |
397 | for (Int_t i = counterPart - range; i <= counterPart + range; i++) { | |
f9720615 | 398 | // check whether there are active bits in supermodule i (counterParts) |
399 | if ((i >= 0) && (i < 18)) { | |
400 | if (Or(i)) { | |
401 | result++; | |
402 | } | |
403 | } | |
404 | else { | |
405 | if (i < 0) { | |
406 | if (Or(17 - i)) { | |
407 | result++; | |
408 | } | |
409 | } | |
410 | if (i > 17) { | |
411 | if (Or(i - 18)) { | |
412 | result++; | |
413 | } | |
414 | } | |
415 | } | |
416 | } | |
417 | AliDebug(5, Form("BackToBack of %d and %d+-%d\n: %d", iSM, counterPart, | |
418 | range, result)); | |
419 | return result; // return whether there was a possible back-to-back trace | |
420 | } | |
421 | else { | |
422 | AliDebug(5, Form("BackToBack unsuccessful, not hit in sm%d", iSM)); | |
423 | return 0; // iSM did not recognize anything | |
424 | } | |
425 | } | |
426 | ||
427 | //______________________________________________________________________________ | |
428 | Int_t AliTRDptrgTLMU::Coincidence(Int_t iSM1, Int_t iSM2) { | |
429 | // checks whether there is an coincidence in iSM1 and iSM2 | |
430 | ||
431 | if (this->Or(iSM1) && this->Or(iSM2)) { | |
432 | return 1; | |
433 | } | |
434 | else | |
435 | return 0; | |
436 | } | |
437 | ||
438 | //______________________________________________________________________________ | |
439 | inline Int_t AliTRDptrgTLMU::Or(Int_t iSM) { | |
440 | // returns 1 if one or more bits are active in supermodule iSM | |
441 | ||
442 | if ((iSM >= 0) && (iSM < 18)) { | |
e51605d9 | 443 | if (this->fTOFinputBits[iSM] > 0) |
f9720615 | 444 | return 1; |
445 | else | |
446 | return 0; | |
447 | } | |
448 | else { | |
449 | return -1; | |
450 | } | |
451 | } | |
452 | ||
453 | //______________________________________________________________________________ | |
454 | Int_t AliTRDptrgTLMU::GetMultiplicity(Int_t iSM) { | |
e51605d9 | 455 | // counts how many bits equal one are in class member fTOFinputBits[iSM] |
f9720615 | 456 | // (32bits from TOF to TRD of supermodule iSM) |
457 | ||
e51605d9 | 458 | UInt_t temp = this->fTOFinputBits[iSM]; |
f9720615 | 459 | UInt_t mask = 0x01; |
460 | Int_t multiplicity = 0; | |
461 | ||
f9720615 | 462 | for (int iBit = 0; iBit < 32; iBit++) { |
463 | if ((mask & temp) != 0x0) { // is the bit equal one? | |
464 | multiplicity++; | |
465 | } | |
466 | mask <<= 1; // rotate mask to the left after each iteration | |
467 | } | |
468 | AliDebug(5, Form("Multiplicity of supermodule %d: %d", iSM, multiplicity)); | |
469 | return multiplicity; | |
470 | } | |
471 | ||
472 | //______________________________________________________________________________ | |
473 | Int_t AliTRDptrgTLMU::GetMultiplicitySum() { | |
474 | // returns the multiplicity of the whole detector (all 576bit TOF to TRD bits) | |
475 | Int_t sum = 0; | |
476 | ||
477 | for (Int_t i = 0; i < 18; i++) { | |
478 | sum += this->GetMultiplicity(i); | |
479 | } | |
480 | AliDebug(5, Form("Whole multiplicity: %d", sum)); | |
481 | return sum; | |
482 | } | |
483 | ||
484 | //______________________________________________________________________________ | |
485 | UInt_t AliTRDptrgTLMU::GetBitVectorMultiplicity(UInt_t BitVector) { | |
486 | // returns the multiplicity of a given bit vector | |
487 | ||
488 | UInt_t result = 0; | |
489 | UInt_t temp = 0x01; | |
490 | for (UInt_t iBit = 0; iBit < 32; iBit++) { | |
491 | if (BitVector & temp) { | |
492 | result++; | |
493 | } | |
494 | temp <<= 1; | |
495 | } | |
496 | ||
497 | return result; | |
498 | } |