Line data Source code
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 : /// \class AliMUONLocalTriggerBoard
20 : /// A local trigger board has as input a bit pattern and returns
21 : /// the local trigger response after comparison w/ a LUT
22 : /// \todo Change member functions comments in capital letters to normal text
23 : ///
24 : /// \author Rachid Guernane (LPCCFd)
25 : //-----------------------------------------------------------------------------
26 :
27 : #include <cstdlib>
28 : #include "AliMUONLocalTriggerBoard.h"
29 : #include "AliMUONTriggerLut.h"
30 :
31 : #include "AliLog.h"
32 :
33 : #include <TBits.h>
34 : #include <Riostream.h>
35 :
36 : using std::endl;
37 : using std::cout;
38 : /// \cond CLASSIMP
39 18 : ClassImp(AliMUONLocalTriggerBoard)
40 : /// \endcond
41 :
42 : const Int_t AliMUONLocalTriggerBoard::fgkCircuitId[234] =
43 : {
44 : 111, 121, 131, 141, 151, 161, 171,
45 : 211, 212, 221, 222, 231, 232, 241, 242, 251, 252, 261, 262, 271,
46 : 311, 312, 321, 322, 331, 332, 341, 342, 351, 352, 361, 362, 371,
47 : 411, 412, 413, 421, 422, 423, 424, 431, 432, 433, 434, 441, 442, 451, 452, 461, 462, 471,
48 : 521, 522, 523, 524, 531, 532, 533, 534, 541, 542, 551, 552, 561, 562, 571,
49 : 611, 612, 613, 621, 622, 623, 624, 631, 632, 633, 634, 641, 642, 651, 652, 661, 662, 671,
50 : 711, 712, 721, 722, 731, 732, 741, 742, 751, 752, 761, 762, 771,
51 : 811, 812, 821, 822, 831, 832, 841, 842, 851, 852, 861, 862, 871,
52 : 911, 921, 931, 941, 951, 961, 971,
53 : -111, -121, -131, -141, -151, -161, -171,
54 : -211, -212, -221, -222, -231, -232, -241, -242, -251, -252, -261, -262, -271,
55 : -311, -312, -321, -322, -331, -332, -341, -342, -351, -352, -361, -362, -371,
56 : -411, -412, -413, -421, -422, -423, -424, -431, -432, -433, -434, -441, -442, -451, -452, -461, -462, -471,
57 : -521, -522, -523, -524, -531, -532, -533, -534, -541, -542, -551, -552, -561, -562, -571,
58 : -611, -612, -613, -621, -622, -623, -624, -631, -632, -633, -634, -641, -642, -651, -652, -661, -662, -671,
59 : -711, -712, -721, -722, -731, -732, -741, -742, -751, -752, -761, -762, -771,
60 : -811, -812, -821, -822, -831, -832, -841, -842, -851, -852, -861, -862, -871,
61 : -911, -921, -931, -941, -951, -961, -971
62 : };
63 :
64 : //___________________________________________
65 : AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard()
66 0 : : AliMUONTriggerBoard(),
67 0 : fMpLocalBoard(0x0),
68 0 : fStripX11(0),
69 0 : fStripY11(15),
70 0 : fDev(0),
71 0 : fTrigY(1),
72 0 : fOutput(0),
73 0 : fLUT(0x0),
74 0 : fCoinc44(0)
75 0 : {
76 : /// default constructor
77 : ///
78 :
79 0 : for (Int_t i=0; i<2; i++)
80 0 : for (Int_t j=0; j<4; j++)
81 : {
82 0 : fXY[i][j] = fXYU[i][j] = fXYD[i][j] = 0;
83 :
84 0 : fMask[i][j] = 0xFFFF;
85 : }
86 :
87 0 : for (Int_t i=0; i<5; i++) fMinDevStrip[i] = fMinDev[i] = fCoordY[i] = 0;
88 :
89 0 : for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = 0;
90 0 : }
91 :
92 : //___________________________________________
93 : AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(AliMpLocalBoard* mpLocalBoard)
94 1452 : : AliMUONTriggerBoard(mpLocalBoard->GetName(), mpLocalBoard->GetSlot()),
95 1452 : fMpLocalBoard(mpLocalBoard),
96 1452 : fStripX11(0),
97 1452 : fStripY11(15),
98 1452 : fDev(0),
99 1452 : fTrigY(1),
100 1452 : fOutput(0),
101 1452 : fLUT(0x0),
102 1452 : fCoinc44(0)
103 7260 : {
104 : /// Standard constructor
105 : ///
106 :
107 8712 : for (Int_t i=0; i<2; i++)
108 29040 : for (Int_t j=0; j<4; j++)
109 : {
110 11616 : fXY[i][j] = fXYU[i][j] = fXYD[i][j] = 0;
111 :
112 11616 : fMask[i][j] = 0xFFFF;
113 : }
114 :
115 17424 : for (Int_t i=0; i<5; i++) fMinDevStrip[i] = fMinDev[i] = fCoordY[i] = 0;
116 :
117 8712 : for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = 0;
118 2904 : }
119 :
120 : //___________________________________________
121 : AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(const AliMUONLocalTriggerBoard& right) :
122 22 : AliMUONTriggerBoard(right),
123 22 : fMpLocalBoard(right.fMpLocalBoard),
124 22 : fStripX11(right.fStripX11),
125 22 : fStripY11(right.fStripY11),
126 22 : fDev(right.fDev),
127 22 : fTrigY(right.fTrigY),
128 22 : fOutput(right.fOutput),
129 22 : fLUT(right.fLUT),
130 22 : fCoinc44(right.fCoinc44)
131 110 : {
132 : //
133 : /// Copy constructor
134 : //
135 132 : for (Int_t i=0; i<2; i++) {
136 440 : for (Int_t j=0; j<4; j++) {
137 176 : fXY[i][j] = right.fXY[i][j];
138 176 : fXYU[i][j] = right.fXYU[i][j];
139 176 : fXYD[i][j] = right.fXYD[i][j];
140 :
141 176 : fMask[i][j] = right.fMask[i][j];
142 : }
143 : }
144 :
145 132 : for (Int_t i=0; i<2; i++) {
146 44 : fLutLpt[i] = right.fLutLpt[i];
147 44 : fLutHpt[i] = right.fLutHpt[i];
148 : }
149 :
150 264 : for (Int_t i=0; i<5; i++) {
151 110 : fMinDevStrip[i] = right.fMinDevStrip[i];
152 110 : fMinDev[i] = right.fMinDev[i];
153 110 : fCoordY[i] = right.fCoordY[i];
154 : }
155 44 : }
156 :
157 : //___________________________________________
158 : AliMUONLocalTriggerBoard& AliMUONLocalTriggerBoard::operator=(const AliMUONLocalTriggerBoard& right)
159 : {
160 : /// Assigment operator;
161 : /// equal operator
162 :
163 0 : if (this == &right)
164 0 : return *this;
165 :
166 : // base class assignement
167 0 : AliMUONTriggerBoard::operator=(right);
168 :
169 0 : fMpLocalBoard = right.fMpLocalBoard;
170 0 : fStripX11 = right.fStripX11;
171 0 : fStripY11 = right.fStripY11;
172 0 : fDev = right.fDev;
173 0 : fTrigY = right.fTrigY;
174 0 : fOutput = right.fOutput;
175 0 : fLUT = right.fLUT;
176 0 : fCoinc44 = right.fCoinc44;
177 :
178 0 : for (Int_t i=0; i<2; i++) {
179 0 : for (Int_t j=0; j<4; j++) {
180 0 : fXY[i][j] = right.fXY[i][j];
181 0 : fXYU[i][j] = right.fXYU[i][j];
182 0 : fXYD[i][j] = right.fXYD[i][j];
183 :
184 0 : fMask[i][j] = right.fMask[i][j];
185 : }
186 : }
187 :
188 0 : for (Int_t i=0; i<2; i++) {
189 0 : fLutLpt[i] = right.fLutLpt[i];
190 0 : fLutHpt[i] = right.fLutHpt[i];
191 : }
192 :
193 0 : for (Int_t i=0; i<5; i++) {
194 0 : fMinDevStrip[i] = right.fMinDevStrip[i];
195 0 : fMinDev[i] = right.fMinDev[i];
196 0 : fCoordY[i] = right.fCoordY[i];
197 : }
198 :
199 0 : return *this;
200 0 : }
201 :
202 : //___________________________________________
203 : AliMUONLocalTriggerBoard::~AliMUONLocalTriggerBoard()
204 5852 : {
205 : /// Destructor
206 5874 : }
207 :
208 :
209 : //___________________________________________
210 : void AliMUONLocalTriggerBoard::Reset()
211 : {
212 : /// reset board
213 : ///
214 1214598 : for (Int_t i=0; i<2; i++)
215 3470280 : for (Int_t j=0; j<4; j++)
216 1388112 : fXY[i][j] = fXYU[i][j] = fXYD[i][j] = 0;
217 :
218 173514 : ResetResponse();
219 173514 : }
220 :
221 : //___________________________________________
222 : void AliMUONLocalTriggerBoard::ResetResponse()
223 : {
224 : /// reset board response
225 : //
226 347072 : fResponse = 0;
227 :
228 2082432 : for (Int_t i=0; i<5; i++) fMinDevStrip[i] = fMinDev[i] = fCoordY[i] = 0;
229 :
230 173536 : fOutput = 0;
231 :
232 173536 : fStripX11 = 0;
233 173536 : fStripY11 = 15;
234 173536 : fDev = 0;
235 173536 : fTrigY = 1;
236 :
237 1041216 : for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = 0;
238 173536 : }
239 :
240 :
241 : //___________________________________________
242 : void AliMUONLocalTriggerBoard::SetbitM(Int_t strip, Int_t cathode, Int_t chamber)
243 : {
244 : /// 0 .. LBS : N-1 .. MSB
245 425056 : UShort_t stripBit = ( (1<<strip) & 0xFFFF );
246 212528 : fXY[cathode][chamber] |= ( stripBit & fMask[cathode][chamber] );
247 212528 : }
248 :
249 :
250 : //___________________________________________
251 : void AliMUONLocalTriggerBoard::Pattern(const Option_t *option) const
252 : {
253 : /// print bit pattern
254 : ///
255 0 : TString op = option;
256 :
257 0 : if (op.Contains("X")) BP("X");
258 :
259 0 : if (op.Contains("Y")) BP("Y");
260 0 : }
261 :
262 :
263 : //___________________________________________
264 : void AliMUONLocalTriggerBoard::BP(const Option_t *option) const
265 : {
266 : /// Respect the old printout format
267 :
268 : const Int_t kModuleId[126] =
269 : {11,12,13,14,15,16,17, // right side of the chamber
270 : 21,22,23,24,25,26,27,
271 : 31,32,33,34,35,36,37,
272 : 41,42,43,44,45,46,47,
273 : 51,52,53,54,55,56,57,
274 : 61,62,63,64,65,66,67,
275 : 71,72,73,74,75,76,77,
276 : 81,82,83,84,85,86,87,
277 : 91,92,93,94,95,96,97,
278 : -11,-12,-13,-14,-15,-16,-17, // right side of chamber
279 : -21,-22,-23,-24,-25,-26,-27,
280 : -31,-32,-33,-34,-35,-36,-37,
281 : -41,-42,-43,-44,-45,-46,-47,
282 : -51,-52,-53,-54,-55,-56,-57,
283 : -61,-62,-63,-64,-65,-66,-67,
284 : -71,-72,-73,-74,-75,-76,-77,
285 : -81,-82,-83,-84,-85,-86,-87,
286 : -91,-92,-93,-94,-95,-96,-97};
287 :
288 : const Int_t kNstripY[126]=
289 : { 8, 8, 8, 8, 8, 8,16, // right side of the chamber
290 : 8, 8, 8, 8, 8, 8,16,
291 : 16,16,16,16,16, 8,16,
292 : 16,16,16,16,16, 8,16,
293 : 0, 8,16,16,16, 8,16,
294 : 16,16,16,16,16, 8,16,
295 : 16,16,16,16,16, 8,16,
296 : 8, 8, 8, 8, 8, 8,16,
297 : 8, 8, 8, 8, 8, 8,16,
298 : 8, 8, 8, 8, 8, 8,16, // left side of the chamber
299 : 8, 8, 8, 8, 8, 8,16,
300 : 16,16,16,16,16, 8,16,
301 : 16,16,16,16,16, 8,16,
302 : 0, 8,16,16,16, 8,16,
303 : 16,16,16,16,16, 8,16,
304 : 16,16,16,16,16, 8,16,
305 : 8, 8, 8, 8, 8, 8,16,
306 : 8, 8, 8, 8, 8, 8,16};
307 :
308 0 : TString op = option;
309 :
310 0 : TString nn = GetName();
311 :
312 0 : if (op.Contains("X"))
313 : {
314 0 : printf("-------- TRIGGER INPUT ---------\n");
315 0 : printf("--- warning: switchs not activated at this level ---\n");
316 0 : printf("===============================================================\n");
317 0 : printf(" 5432109876543210");
318 :
319 0 : const char *x[4] = {"XMC11","XMC12","XMC21","XMC22"};
320 0 : const char *s[4] = {" ",
321 : " ",
322 : " ",
323 : " "};
324 :
325 0 : for (Int_t ch=0; ch<4; ch++)
326 : {
327 0 : printf("\n %s%s", x[ch], s[ch]);
328 :
329 0 : UShort_t xy = fXY[0][ch];
330 :
331 0 : TBits w(16); w.Set(16,&xy);
332 :
333 0 : if (ch<2) cout << w;
334 : else
335 : {
336 0 : UShort_t xyd = fXYD[0][ch], xyu = fXYU[0][ch];
337 0 : TBits dw(16), uw(16); dw.Set(16,&xyd); uw.Set(16,&xyu);
338 :
339 0 : TBits ew(32);
340 :
341 0 : for (Int_t i=0;i<16;i++) ew[i+8] = w[i];
342 :
343 0 : for (Int_t i=0;i<8;i++)
344 : {
345 0 : ew[i] = dw[i+8]; // 8 MSB
346 0 : ew[i+24] = uw[i]; //
347 : }
348 :
349 0 : cout << ew;
350 0 : }
351 0 : }
352 :
353 0 : printf("\n ");
354 0 : printf("10987654321098765432109876543210\n");
355 0 : }
356 :
357 0 : if (op.Contains("Y"))
358 : {
359 0 : printf("---------------------------------------------------------------\n");
360 0 : printf(" ");
361 :
362 : /* OLD NUMBERING STYLE */
363 : /**/
364 : Int_t idCircuit = 0, absidModule = 0;
365 :
366 0 : if (!(nn.Contains("Int")))
367 : {
368 0 : idCircuit = fgkCircuitId[GetI()];
369 0 : absidModule = TMath::Abs(Int_t(idCircuit/10));
370 0 : }
371 :
372 : Int_t iModule=0;
373 :
374 0 : for (Int_t i=0; i<63; i++)
375 : {
376 0 : if (kModuleId[i]==absidModule)
377 : {
378 : iModule=i;
379 0 : break;
380 : }
381 : }
382 :
383 0 : Int_t nStrip = kNstripY[iModule];
384 0 : for (Int_t istrip=nStrip-1; istrip>=0; istrip--) {
385 0 : if (istrip>9) printf("%i",istrip-10*Int_t(istrip/10));
386 0 : if (istrip<10) printf("%i",istrip);
387 : }
388 : /**/
389 : /* */
390 :
391 0 : UShort_t xyval = 0;
392 :
393 0 : if (GetSwitch(1))
394 : {
395 0 : xyval = fXY[1][0];
396 0 : TBits v11(8); v11.Set(8,&xyval);
397 0 : printf("\n YMC11 ");
398 0 : cout << v11;
399 :
400 0 : xyval = fXY[1][1];
401 0 : TBits v12(8); v12.Set(8,&xyval);
402 0 : printf("\n YMC12 ");
403 0 : cout << v12;
404 :
405 0 : xyval = fXY[1][2];
406 0 : TBits v21(8); v21.Set(8,&xyval);
407 0 : printf("\n YMC21 ");
408 0 : cout << v21;
409 :
410 0 : xyval = fXY[1][3];
411 0 : TBits v22(8); v22.Set(8,&xyval);
412 0 : printf("\n YMC22 ");
413 0 : cout << v22 << endl;
414 0 : }
415 : else
416 : {
417 : xyval = fXY[1][0];
418 0 : TBits v11(16); v11.Set(16,&xyval);
419 0 : printf("\n YMC11 ");
420 0 : cout << v11;
421 :
422 0 : xyval = fXY[1][1];
423 0 : TBits v12(16); v12.Set(16,&xyval);
424 0 : printf("\n YMC12 ");
425 0 : cout << v12;
426 :
427 0 : xyval = fXY[1][2];
428 0 : TBits v21(16); v21.Set(16,&xyval);
429 0 : printf("\n YMC21 ");
430 0 : cout << v21;
431 :
432 0 : xyval = fXY[1][3];
433 0 : TBits v22(16); v22.Set(16,&xyval);
434 0 : printf("\n YMC22 ");
435 0 : cout << v22 << endl;
436 0 : }
437 :
438 : // tmp
439 0 : printf("---------------------------------------------------------------");
440 0 : printf("\n upper part of circuit %i",idCircuit);
441 0 : printf("\n UMC21 ");
442 0 : xyval = fXYU[1][2];
443 0 : TBits wu21(16); wu21.Set(16,&xyval);
444 0 : cout << wu21;
445 0 : printf("\n UMC22 ");
446 0 : xyval = fXYU[1][3];
447 0 : TBits wu22(16); wu22.Set(16,&xyval);
448 0 : cout << wu22;
449 0 : printf("\n lower part of circuit %i",idCircuit);
450 0 : printf("\n LMC21 ");
451 0 : xyval = fXYD[1][2];
452 0 : TBits wl21(16); wl21.Set(16,&xyval);
453 0 : cout << wl21;
454 0 : printf("\n LMC22 ");
455 0 : xyval = fXYD[1][3];
456 0 : TBits wl22(16); wl22.Set(16,&xyval);
457 0 : cout << wl22;
458 0 : printf("\n");
459 0 : printf("===============================================================\n");
460 0 : }
461 0 : }
462 :
463 : //___________________________________________
464 : void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[32], Int_t ch4q[32])
465 : {
466 : /// note : coinc44 = flag 0 or 1 (0 coincidence -> 3/4, 1 coincidence -> 4/4) \n
467 : ///--------------------------------------------------------- \n
468 : /// step # 1 : declustering, reduction DS, calculate sgle & dble \n
469 : ///---------------------------------------------------------
470 4790 : Int_t ch1e[19], ch2e[20], ch3e[35], ch4e[36];
471 2395 : Int_t sgleHit1[31], sgleHit2[63];
472 2395 : Int_t dbleHit1[31], dbleHit2[63];
473 :
474 : Int_t i;
475 : Int_t j;
476 : Int_t istrip;
477 :
478 153280 : for (i=0; i<31; i++) {
479 74245 : sgleHit1[i]=0;
480 74245 : dbleHit1[i]=0;
481 : }
482 306560 : for (i=0; i<63; i++) {
483 150885 : sgleHit2[i]=0;
484 150885 : dbleHit2[i]=0;
485 : }
486 :
487 : //--- inititialize che using chq
488 : //--- switch zero_down, zero_middle & zero_up added 30/05/07
489 : //--- fSwitch[7/8/9] = zero_down/zero_middle/zero_up
490 95800 : for (i=0; i<19; i++) {
491 52690 : if (i<1||i>16) ch1e[i]=0;
492 38320 : else ch1e[i]=ch1q[i-1];
493 : }
494 100590 : for (i=0; i<20; i++) {
495 57480 : if (i<2||i>17) ch2e[i]=0;
496 38320 : else ch2e[i]=ch2q[i-2];
497 : }
498 172440 : for (i=0; i<35; i++) {
499 91010 : if (i<1||i>32) ch3e[i]=0;
500 95800 : else if (i>=1 && i<=8) ch3e[i]=ch3q[i-1]&!GetSwitch(7);
501 95800 : else if (i>=9 && i<=24) ch3e[i]=ch3q[i-1]&!GetSwitch(8);
502 38320 : else if (i>=25 && i<=32) ch3e[i]=ch3q[i-1]&!GetSwitch(9);
503 : }
504 177230 : for (i=0; i<36; i++) {
505 95800 : if (i<2||i>33) ch4e[i]=0;
506 95800 : else if (i>=2 && i<=9) ch4e[i]=ch4q[i-2]&!GetSwitch(7);
507 95800 : else if (i>=10 && i<=25) ch4e[i]=ch4q[i-2]&!GetSwitch(8);
508 38320 : else if (i>=26 && i<=33) ch4e[i]=ch4q[i-2]&!GetSwitch(9);
509 : }
510 :
511 : //--- calculate dble & sgle first station
512 81430 : for (i=0; i<=15; i++) {
513 76640 : sgleHit1[2*i] = (!ch1e[i+1]|(ch1e[i]^ch1e[i+2])) &
514 38320 : (!ch2e[i+2] | (ch2e[i+1]^ch2e[i+3]));
515 :
516 76640 : dbleHit1[2*i] = ch1e[i+1]&!(ch1e[i+2]^ch1e[i]) &
517 38320 : (ch2e[i+2] | (!ch2e[i]&ch2e[i+1]) | (ch2e[i+3]&!ch2e[i+4]));
518 : }
519 :
520 76640 : for (i=0; i<=14; i++) {
521 71850 : sgleHit1[2*i+1] = (!ch1e[i+1]|!ch1e[i+2]|(ch1e[i]^ch1e[i+3])) &
522 35925 : (!ch2e[i+2] | !ch2e[i+3] | (ch2e[i+1]^ch2e[i+4]));
523 71850 : dbleHit1[2*i+1] = ch1e[i+1]&ch1e[i+2]&!(ch1e[i]^ch1e[i+3]) &
524 71850 : ((ch2e[i+2]&(!ch2e[i+1]|!ch2e[i])) |
525 35925 : (ch2e[i+3]&(ch2e[i+2]|!ch2e[i+4]|!ch2e[i+5])));
526 : }
527 :
528 : //--- calculate dble & sgle second station
529 158070 : for (i=0; i<=31; i++) {
530 153280 : sgleHit2[2*i] = (!ch3e[i+1]|(ch3e[i]^ch3e[i+2])) &
531 76640 : (!ch4e[i+2] | (ch4e[i+1]^ch4e[i+3]));
532 153280 : dbleHit2[2*i] = ch3e[i+1]&!(ch3e[i+2]^ch3e[i]) &
533 76640 : (ch4e[i+2] | (!ch4e[i]&ch4e[i+1]) | (ch4e[i+3]&!ch4e[i+4]));
534 : }
535 :
536 153280 : for (i=0; i<=30; i++) {
537 148490 : sgleHit2[2*i+1] = (!ch3e[i+1]|!ch3e[i+2]|(ch3e[i]^ch3e[i+3])) &
538 74245 : (!ch4e[i+2] | !ch4e[i+3] | (ch4e[i+1]^ch4e[i+4]));
539 148490 : dbleHit2[2*i+1] = ch3e[i+1]&ch3e[i+2]&!(ch3e[i]^ch3e[i+3]) &
540 148490 : ((ch4e[i+2]&(!ch4e[i+1]|!ch4e[i])) |
541 74245 : (ch4e[i+3]&((ch4e[i+2]|!ch4e[i+4])|!ch4e[i+5])));
542 : }
543 :
544 : //---
545 14370 : if(AliDebugLevel()==3||AliDebugLevel()==5) {
546 0 : printf("===============================================================\n");
547 0 : printf(" X plane after sgle and dble \n");
548 0 : printf(" 0987654321098765432109876543210");
549 0 : printf("\n SGLE1 ");
550 0 : for (istrip=30; istrip>=0; istrip--) printf("%i",(!sgleHit1[istrip]));
551 0 : printf("\n DBLE1 ");
552 0 : for (istrip=30; istrip>=0; istrip--) printf("%i",dbleHit1[istrip]);
553 0 : printf("\n SGLE2 ");
554 0 : for (istrip=62; istrip>=0; istrip--) printf("%i",(!sgleHit2[istrip]));
555 0 : printf("\n DBLE2 ");
556 0 : for (istrip=62; istrip>=0; istrip--) printf("%i",dbleHit2[istrip]);
557 0 : printf("\n 210987654321098765432109876543210987654321098765432109876543210\n");
558 0 : }
559 :
560 : //---------------------------------------------------------
561 : // step # 2 : coincidence 3/4
562 : //---------------------------------------------------------
563 2395 : Int_t rearImage[31][31];
564 153280 : for (i=0; i<31; i++) {
565 4751680 : for (j=0; j<31; j++) {
566 2301595 : rearImage[i][j]=0;
567 : }
568 : }
569 :
570 4790 : Int_t notOr1=!dbleHit1[30] & !dbleHit1[29] & !dbleHit1[28] & !dbleHit1[27] &
571 7185 : !dbleHit1[26] & !dbleHit1[25] & !dbleHit1[24] & !dbleHit1[23] &
572 7185 : !dbleHit1[22] & !dbleHit1[21] & !dbleHit1[20] & !dbleHit1[19] &
573 7185 : !dbleHit1[18] & !dbleHit1[17] & !dbleHit1[16] & !dbleHit1[15] &
574 7185 : !dbleHit1[14] & !dbleHit1[13] & !dbleHit1[12] & !dbleHit1[11] &
575 7185 : !dbleHit1[10] & !dbleHit1[9] & !dbleHit1[8] & !dbleHit1[7] &
576 7185 : !dbleHit1[6] & !dbleHit1[5] & !dbleHit1[4] & !dbleHit1[3] &
577 4790 : !dbleHit1[2] & !dbleHit1[1] & !dbleHit1[0] & !fCoinc44;
578 :
579 4790 : Int_t notOr2= !dbleHit2[62] & !dbleHit2[61] & !dbleHit2[60] & !dbleHit2[59] &
580 7185 : !dbleHit2[58] & !dbleHit2[57] & !dbleHit2[56] & !dbleHit2[55] &
581 7185 : !dbleHit2[54] & !dbleHit2[53] & !dbleHit2[52] & !dbleHit2[51] &
582 7185 : !dbleHit2[50] & !dbleHit2[49] & !dbleHit2[48] & !dbleHit2[47] &
583 7185 : !dbleHit2[46] & !dbleHit2[45] & !dbleHit2[44] & !dbleHit2[43] &
584 7185 : !dbleHit2[42] & !dbleHit2[41] & !dbleHit2[40] & !dbleHit2[39] &
585 7185 : !dbleHit2[38] & !dbleHit2[37] & !dbleHit2[36] & !dbleHit2[35] &
586 7185 : !dbleHit2[34] & !dbleHit2[33] & !dbleHit2[32] & !dbleHit2[31] &
587 7185 : !dbleHit2[30] & !dbleHit2[29] & !dbleHit2[28] & !dbleHit2[27] &
588 7185 : !dbleHit2[26] & !dbleHit2[25] & !dbleHit2[24] & !dbleHit2[23] &
589 7185 : !dbleHit2[22] & !dbleHit2[21] & !dbleHit2[20] & !dbleHit2[19] &
590 7185 : !dbleHit2[18] & !dbleHit2[17] & !dbleHit2[16] & !dbleHit2[15] &
591 7185 : !dbleHit2[14] & !dbleHit2[13] & !dbleHit2[12] & !dbleHit2[11] &
592 7185 : !dbleHit2[10] & !dbleHit2[9] & !dbleHit2[8] & !dbleHit2[7] &
593 7185 : !dbleHit2[6] & !dbleHit2[5] & !dbleHit2[4] & !dbleHit2[3] &
594 4790 : !dbleHit2[2] & !dbleHit2[1] & !dbleHit2[0] & !fCoinc44;
595 :
596 : // DS reduction
597 153280 : for (i=0; i<31; i++) {
598 74245 : sgleHit1[i] = !sgleHit1[i]¬Or1;
599 : }
600 306560 : for (i=0; i<63; i++) {
601 150885 : sgleHit2[i] = !sgleHit2[i]¬Or2;
602 : }
603 :
604 : // extract rearImage
605 153280 : for (i=0; i<31; i++){
606 74245 : Int_t tmpSgleHit2[31];
607 74245 : Int_t tmpDbleHit2[31];
608 4751680 : for (j=0; j<31; j++){
609 2301595 : tmpSgleHit2[j] = sgleHit2[i+j+1];
610 2301595 : tmpDbleHit2[j] = dbleHit2[i+j+1];
611 : }
612 :
613 4751680 : for (Int_t k=0; k<31; k++) {
614 4603190 : rearImage[i][k]=(sgleHit1[i]&tmpDbleHit2[k])|
615 2301595 : (dbleHit1[i]&(tmpSgleHit2[k]|tmpDbleHit2[k]));
616 : }
617 74245 : }
618 :
619 : //-----------
620 14370 : if(AliDebugLevel()==3||AliDebugLevel()==5) {
621 0 : printf("===============================================================\n");
622 0 : for (i=30; i>=0; i--) {
623 0 : printf("%i \t",i);
624 0 : for (istrip=30; istrip>=0; istrip--) printf("%i",rearImage[i][istrip]);
625 0 : printf("\n");
626 : }
627 : }
628 :
629 : //---------------------------------------------------------
630 : // step # 3 : calculate deviation
631 : //---------------------------------------------------------
632 2395 : Int_t dev[31][6];
633 153280 : for (i=0; i<31; i++) {
634 1039430 : for (j=0; j<6; j++) {
635 445470 : dev[i][j]=0;
636 : }
637 : }
638 :
639 153280 : for (i=0; i<31; i++){
640 74245 : Int_t leftDev[5], rightDev[5];
641 : Int_t orL1, andL1, andL2, orR1, orR2, andR1, andR2, andR3;
642 :
643 : // calculate Left deviation
644 74245 : orL1=rearImage[i][16]|rearImage[i][18]|rearImage[i][20]|rearImage[i][22];
645 74245 : andL1=!rearImage[i][17]&!rearImage[i][19]&!rearImage[i][21] & !orL1;
646 74245 : andL2=!rearImage[i][23]&!rearImage[i][24]&!rearImage[i][25]&!rearImage[i][26];
647 :
648 222735 : leftDev[0] = (rearImage[i][16]|!rearImage[i][17]) &
649 74245 : (rearImage[i][16]|rearImage[i][18]|(!rearImage[i][19]&
650 148490 : (rearImage[i][20]|!rearImage[i][21]))) &
651 148490 : (orL1|(!rearImage[i][23]&(rearImage[i][24]|!rearImage[i][25]))) &
652 148490 : (orL1|rearImage[i][24]|rearImage[i][26]|(!rearImage[i][27]&
653 74245 : (rearImage[i][28]|!rearImage[i][29])));
654 :
655 222735 : leftDev[1] = !rearImage[i][16] &
656 148490 : !(!rearImage[i][17]&!rearImage[i][18]&!rearImage[i][21]&!rearImage[i][22] &
657 148490 : (!rearImage[i][25]&!rearImage[i][26]&(rearImage[i][27]|rearImage[i][28]))) &
658 148490 : (rearImage[i][17]|rearImage[i][18] | (!rearImage[i][19]&!rearImage[i][20])) &
659 148490 : (rearImage[i][17]|rearImage[i][18]|rearImage[i][21]|rearImage[i][22] |
660 74245 : (!rearImage[i][23]&!rearImage[i][24]));
661 :
662 148490 : leftDev[2] = (!rearImage[i][16]&!rearImage[i][17]&!rearImage[i][18]) &
663 74245 : (rearImage[i][19]|rearImage[i][20]|rearImage[i][21]|rearImage[i][22] | andL2);
664 :
665 74245 : leftDev[3] = andL1;
666 :
667 74245 : leftDev[4] =
668 74245 : !rearImage[i][27]&!rearImage[i][28]&!rearImage[i][29]&!rearImage[i][30] &
669 74245 : andL1 & andL2;
670 :
671 : // calculate Right deviation
672 74245 : orR1=rearImage[i][8]|rearImage[i][10]|rearImage[i][12]|rearImage[i][14];
673 74245 : orR2=rearImage[i][8]|rearImage[i][9]|rearImage[i][10]|rearImage[i][11];
674 74245 : andR1=!rearImage[i][12]&!rearImage[i][13]&!rearImage[i][14]&!rearImage[i][15];
675 : andR2=
676 74245 : !rearImage[i][8]&!rearImage[i][9]&!rearImage[i][10]&!rearImage[i][11] & andR1;
677 74245 : andR3=!rearImage[i][4]&!rearImage[i][5]&!rearImage[i][6]&!rearImage[i][7];
678 :
679 148490 : rightDev[0] = !rearImage[i][15]&(rearImage[i][14]|!rearImage[i][13]) &
680 148490 : ((rearImage[i][12]|rearImage[i][14]|(!rearImage[i][11]&
681 148490 : (rearImage[i][10]|!rearImage[i][9]))) &
682 148490 : ((orR1|(!rearImage[i][7]&(rearImage[i][6]|!rearImage[i][5]))) &
683 148490 : (orR1|rearImage[i][4]|rearImage[i][6]|(!rearImage[i][3]&(rearImage[i][2]|
684 74245 : !rearImage[i][1])))));
685 :
686 222735 : rightDev[1] = !rearImage[i][15]&!rearImage[i][14] &
687 148490 : !(!rearImage[i][4]&!rearImage[i][5]&!rearImage[i][8]&!rearImage[i][9] &
688 148490 : (!rearImage[i][12]&!rearImage[i][13]&(rearImage[i][2]|rearImage[i][3]))) &
689 148490 : (rearImage[i][12]|rearImage[i][13] | (!rearImage[i][10]&!rearImage[i][11])) &
690 148490 : (rearImage[i][8]|rearImage[i][9]|rearImage[i][12]|rearImage[i][13] |
691 74245 : (!rearImage[i][6]&!rearImage[i][7]));
692 :
693 74245 : rightDev[2] = andR1 & (orR2 | andR3);
694 74245 : rightDev[3] = andR2;
695 74245 : rightDev[4] =
696 74245 : !rearImage[i][0]&!rearImage[i][1]&!rearImage[i][2]&!rearImage[i][3] &
697 74245 : andR2 & andR3 ;
698 :
699 : // compare Left & Right deviations
700 : Int_t tmpLeftDev=0, tmpRightDev=0;
701 890940 : for (j=0; j<5; j++){
702 371225 : tmpLeftDev = tmpLeftDev + Int_t(leftDev[j]<<j);
703 371225 : tmpRightDev = tmpRightDev + Int_t(rightDev[j]<<j);
704 : }
705 :
706 : // assign mimimum deviation do dev[][]
707 74245 : if (tmpLeftDev < tmpRightDev ){
708 132 : for (j=0; j<5; j++){ dev[i][j]=leftDev[j];}
709 12 : dev[i][5]=1;
710 12 : } else {
711 816563 : for (j=0; j<5; j++){ dev[i][j]=rightDev[j];}
712 74233 : dev[i][5]=0;
713 : }
714 74245 : }
715 :
716 : //---
717 14370 : if(AliDebugLevel()==3||AliDebugLevel()==5) {
718 0 : printf("===============================================================\n");
719 0 : for (i=30; i>=0; i--) {
720 0 : printf("%i \t",i);
721 0 : for (istrip=5; istrip>=0; istrip--) printf("%i",dev[i][istrip]);
722 0 : printf(" \n");
723 : }
724 : }
725 :
726 : //---------------------------------------------------------
727 : // step # 4 : sort deviation
728 : //---------------------------------------------------------
729 2395 : Int_t bga1[16], bga2[8], bga3[4], bga4[2], bga5;
730 2395 : Int_t tmpbga1[16][6], tmpbga2[8][6], tmpbga3[4][6], tmpbga4[2][6], tmpbga5[6];
731 2395 : Int_t tmpMax[6]={1,1,1,1,1,0};
732 :
733 114960 : for (i=0; i<15; i++) {
734 74245 : Sort2x5(dev[2*i],dev[2*i+1],tmpbga1[i],bga1[i]);
735 : }
736 2395 : Sort2x5(dev[30],tmpMax,tmpbga1[15],bga1[15]);
737 :
738 : //--
739 14370 : if(AliDebugLevel()==3||AliDebugLevel()==5) {
740 0 : printf("===============================================================\n");
741 0 : printf(" sorting : 1st level \n");
742 0 : for (i=15; i>=0; i--) {
743 0 : printf("\t %i \t",bga1[i]);
744 0 : for (j=5; j>=0; j--) printf("%i",tmpbga1[i][j]);
745 0 : printf(" \n");
746 : }
747 : }
748 :
749 43110 : for (i=0; i<8; i++) {
750 19160 : Sort2x5(tmpbga1[2*i],tmpbga1[2*i+1],tmpbga2[i],bga2[i]);
751 : }
752 :
753 : //--
754 14370 : if(AliDebugLevel()==3||AliDebugLevel()==5) {
755 0 : printf("===============================================================\n");
756 0 : printf(" sorting : 2nd level \n");
757 0 : for (i=7; i>=0; i--) {
758 0 : printf("\t %i \t",bga2[i]);
759 0 : for (j=5; j>=0; j--) printf("%i",tmpbga1[i][j]);
760 0 : printf(" \n");
761 : }
762 : }
763 :
764 23950 : for (i=0; i<4; i++) {
765 9580 : Sort2x5(tmpbga2[2*i],tmpbga2[2*i+1],tmpbga3[i],bga3[i]);
766 : }
767 :
768 : //--
769 14370 : if(AliDebugLevel()==3||AliDebugLevel()==5) {
770 0 : printf("===============================================================\n");
771 0 : printf(" sorting : 3rd level \n");
772 0 : for (i=3; i>=0; i--) {
773 0 : printf("\t %i \t",bga3[i]);
774 0 : for (j=5; j>=0; j--) printf("%i",tmpbga3[i][j]);
775 0 : printf(" \n");
776 : }
777 : }
778 :
779 14370 : for (i=0; i<2; i++) {
780 4790 : Sort2x5(tmpbga3[2*i],tmpbga3[2*i+1],tmpbga4[i],bga4[i]);
781 : }
782 :
783 : //--
784 14370 : if(AliDebugLevel()==3||AliDebugLevel()==5) {
785 0 : printf("===============================================================\n");
786 0 : printf(" sorting : 4th level \n");
787 0 : for (i=1; i>=0; i--) {
788 0 : printf("\t %i \t",bga4[i]);
789 0 : for (j=5; j>=0; j--) printf("%i",tmpbga4[i][j]);
790 0 : printf(" \n");
791 : }
792 : }
793 :
794 2395 : Sort2x5(tmpbga4[0],tmpbga4[1],tmpbga5,bga5);
795 :
796 : // coding from 6 to 5 bits
797 2395 : fMinDev[4] = tmpbga5[5] | tmpbga5[4];
798 23950 : for (i=0; i<4; i++) {
799 9580 : fMinDev[i]=tmpbga5[i] & !tmpbga5[4];
800 : }
801 :
802 : // find address of strip with minimum deviation
803 2395 : fMinDevStrip[4]=bga5;
804 4790 : if (bga5<=1) fMinDevStrip[3]=bga4[bga5];
805 :
806 2395 : Int_t tmpAd=fMinDevStrip[3]+fMinDevStrip[4]*2;
807 4790 : if (tmpAd<=3) fMinDevStrip[2]=bga3[tmpAd];
808 :
809 2395 : tmpAd=fMinDevStrip[2]+fMinDevStrip[3]*2+fMinDevStrip[4]*4;
810 4790 : if (tmpAd<=7) fMinDevStrip[1]=bga2[tmpAd];
811 :
812 2395 : tmpAd=fMinDevStrip[1]+fMinDevStrip[2]*2+fMinDevStrip[3]*4+fMinDevStrip[4]*8;
813 4790 : if (tmpAd<=15) fMinDevStrip[0]=bga1[tmpAd];
814 :
815 14370 : if(AliDebugLevel()==3||AliDebugLevel()==5) {
816 0 : printf("===============================================================\n");
817 0 : printf("minDevStrip = ");
818 0 : for (i=4; i>=0; i--) printf("%i",fMinDevStrip[i]);
819 0 : printf(" minDev = ");
820 0 : for (i=4; i>=0; i--) printf("%i",fMinDev[i]);
821 0 : printf(" \n");
822 0 : printf("===============================================================\n");
823 0 : }
824 :
825 2395 : }
826 :
827 : //___________________________________________
828 : void AliMUONLocalTriggerBoard::Sort2x5(Int_t dev1[6], Int_t dev2[6],
829 : Int_t minDev[6], Int_t &dev1GTdev2)
830 : {
831 : /// returns minimun between dev1 and dev2
832 : Int_t tmpDev1=0, tmpDev2=0;
833 :
834 965185 : for (Int_t j=0; j<5; j++)
835 : {
836 371225 : tmpDev1 += Int_t(dev1[j]<<j);
837 371225 : tmpDev2 += Int_t(dev2[j]<<j);
838 : }
839 :
840 74245 : if (tmpDev1<=tmpDev2)
841 : {
842 1018276 : for (Int_t j=0; j<=5; j++) minDev[j]=dev1[j];
843 72734 : dev1GTdev2=0;
844 72734 : }
845 : else
846 : {
847 21154 : for (Int_t j=0; j<=5; j++) minDev[j]=dev2[j];
848 1511 : dev1GTdev2=1;
849 : }
850 74245 : }
851 :
852 : //___________________________________________
853 : void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], Int_t y4[16],
854 : Int_t y3u[16], Int_t y3d[16], Int_t y4u[16], Int_t y4d[16])
855 : {
856 : /// note : resMid = 1 -> cancel \n
857 : ///---------------------------------------------------------\n
858 : /// step # 1 : prehandling Y \n
859 : ///---------------------------------------------------------
860 : Int_t i;
861 : Int_t istrip;
862 :
863 83825 : for (i=0; i<16; i++)
864 : {
865 38320 : y3[i]=y3[i]&!GetSwitch(8);
866 38320 : y4[i]=y4[i]&!GetSwitch(8);
867 : }
868 :
869 : // 10/29/04 fZeroAllYLSB added
870 : // for (i=0; i<8; i++)
871 : // {
872 : // y1[i] = y1[i]&!fSwitch[6];
873 : // y2[i] = y2[i]&!fSwitch[6];
874 : // y3[i] = y3[i]&!fSwitch[6];
875 : // y4[i] = y4[i]&!fSwitch[6];
876 : // }
877 :
878 2395 : Int_t ch1[16], ch2[16], ch3[16], ch4[16];
879 :
880 2395 : Int_t tmpy3to16[16], tmpy4to16[16];
881 2395 : Int_t tmpy3uto16[16], tmpy3dto16[16], tmpy4uto16[16], tmpy4dto16[16];
882 43110 : for (i=0; i<8; i++){
883 19160 : ch1[2*i] = (y1[i]&GetSwitch(1)) | (y1[2*i]&!GetSwitch(1));
884 19160 : ch1[2*i+1] = (y1[i]&GetSwitch(1)) | (y1[2*i+1]&!GetSwitch(1));
885 :
886 19160 : ch2[2*i] = (y2[i]&GetSwitch(1)) | (y2[2*i]&!GetSwitch(1));
887 19160 : ch2[2*i+1] = (y2[i]&GetSwitch(1)) | (y2[2*i+1]&!GetSwitch(1));
888 :
889 19160 : tmpy3to16[2*i ] = (y3[i]&GetSwitch(1)) | (y3[2*i ]&!GetSwitch(1));
890 19160 : tmpy3to16[2*i+1] = (y3[i]&GetSwitch(1)) | (y3[2*i+1]&!GetSwitch(1));
891 :
892 19160 : tmpy4to16[2*i ] = (y4[i]&GetSwitch(1)) | (y4[2*i ]&!GetSwitch(1));
893 19160 : tmpy4to16[2*i+1] = (y4[i]&GetSwitch(1)) | (y4[2*i+1]&!GetSwitch(1));
894 :
895 19160 : tmpy3uto16[2*i ] = (y3u[i]&GetSwitch(2)) | (y3u[2*i ]&!GetSwitch(2));
896 19160 : tmpy3uto16[2*i+1] = (y3u[i]&GetSwitch(2)) | (y3u[2*i+1]&!GetSwitch(2));
897 :
898 19160 : tmpy4uto16[2*i ] = (y4u[i]&GetSwitch(2)) | (y4u[2*i ]&!GetSwitch(2));
899 19160 : tmpy4uto16[2*i+1] = (y4u[i]&GetSwitch(2)) | (y4u[2*i+1]&!GetSwitch(2));
900 :
901 19160 : tmpy3dto16[2*i ] = (y3d[i]&GetSwitch(0)) | (y3d[2*i ]&!GetSwitch(0));
902 19160 : tmpy3dto16[2*i+1] = (y3d[i]&GetSwitch(0)) | (y3d[2*i+1]&!GetSwitch(0));
903 :
904 19160 : tmpy4dto16[2*i ] = (y4d[i]&GetSwitch(0)) | (y4d[2*i ]&!GetSwitch(0));
905 19160 : tmpy4dto16[2*i+1] = (y4d[i]&GetSwitch(0)) | (y4d[2*i+1]&!GetSwitch(0));
906 : }
907 :
908 81430 : for (i=0; i<16; i++) ch3[i] = ch4[i] = 0;
909 :
910 3811 : if (GetSwitch(3)==0&&GetSwitch(4)==0){
911 17782 : for (i=0; i<16; i++){
912 8368 : ch3[i] = tmpy3to16[i];
913 8368 : ch4[i] = tmpy4to16[i];
914 : }
915 : }
916 3811 : if (GetSwitch(3)==0&&GetSwitch(4)==1){
917 30362 : for (i=0; i<16; i++){
918 14288 : ch3[i] = tmpy3dto16[i]|tmpy3to16[i];
919 14288 : ch4[i] = tmpy4dto16[i]|tmpy4to16[i];
920 : }
921 : }
922 3374 : if (GetSwitch(3)==1&&GetSwitch(4)==0){
923 30294 : for (i=0; i<16; i++){
924 14256 : ch3[i] = tmpy3uto16[i]|tmpy3to16[i];
925 14256 : ch4[i] = tmpy4uto16[i]|tmpy4to16[i];
926 : }
927 : }
928 3374 : if (GetSwitch(3)==1&&GetSwitch(4)==1){
929 2992 : for (i=0; i<16; i++){
930 1408 : ch3[i] = tmpy3dto16[i]|tmpy3to16[i]|tmpy3uto16[i];
931 1408 : ch4[i] = tmpy4dto16[i]|tmpy4to16[i]|tmpy4uto16[i];
932 : }
933 : }
934 :
935 : // debug
936 14370 : if(AliDebugLevel()==4||AliDebugLevel()==5) {
937 0 : printf("===============================================================\n");
938 0 : printf(" Y plane after PreHandling x2m x2u x2d orMud %i %i %i %i %i \n",
939 0 : GetSwitch(1),GetSwitch(2), GetSwitch(0),GetSwitch(3),GetSwitch(4));
940 0 : printf(" ");
941 0 : for (istrip=15; istrip>=0; istrip--) {
942 0 : if (istrip>9) printf("%i",istrip-10*Int_t(istrip/10));
943 0 : if (istrip<10) printf("%i",istrip);
944 : }
945 0 : printf("\n YMC11 ");
946 0 : for (istrip=15; istrip>=0; istrip--) printf("%i",ch1[istrip]);
947 0 : printf("\n YMC12 ");
948 0 : for (istrip=15; istrip>=0; istrip--) printf("%i",ch2[istrip]);
949 0 : printf("\n YMC21 ");
950 0 : for (istrip=15; istrip>=0; istrip--) printf("%i",ch3[istrip]);
951 0 : printf("\n YMC22 ");
952 0 : for (istrip=15; istrip>=0; istrip--) printf("%i",ch4[istrip]);
953 0 : printf(" \n");
954 0 : }
955 : //debug
956 :
957 : //---------------------------------------------------------
958 : // step # 2 : calculate sgle and dble, apply DS reduction
959 : //---------------------------------------------------------
960 2395 : Int_t sgle1[16], dble1[16];
961 2395 : Int_t sgle2[16], dble2[16];
962 :
963 : // Calculate simple and double hits
964 81430 : for (i=0; i<16; i++) {
965 38320 : dble1[i] = ch1[i] & ch2[i];
966 38320 : dble2[i] = ch3[i] & ch4[i];
967 :
968 38320 : sgle1[i] = (ch1[i]|ch2[i]);
969 38320 : sgle2[i] = (ch3[i]|ch4[i]);
970 : }
971 :
972 : //debug
973 14370 : if(AliDebugLevel()==4||AliDebugLevel()==5) {
974 0 : printf("===============================================================\n");
975 0 : printf(" Y plane after sgle dble \n");
976 0 : printf(" ");
977 0 : for (istrip=15; istrip>=0; istrip--) {
978 0 : if (istrip>9) printf("%i",istrip-10*Int_t(istrip/10));
979 0 : if (istrip<10) printf("%i",istrip);
980 : }
981 0 : printf("\n SGLE1 ");
982 0 : for (istrip=15; istrip>=0; istrip--) printf("%i",sgle1[istrip]);
983 0 : printf("\n DBLE1 ");
984 0 : for (istrip=15; istrip>=0; istrip--) printf("%i",dble1[istrip]);
985 0 : printf("\n SGLE2 ");
986 0 : for (istrip=15; istrip>=0; istrip--) printf("%i",sgle2[istrip]);
987 0 : printf("\n DBLE2 ");
988 0 : for (istrip=15; istrip>=0; istrip--) printf("%i",dble2[istrip]);
989 0 : printf(" \n");
990 0 : }
991 : //debug
992 :
993 : // DS Reduction
994 : Int_t notOr1, notOr2;
995 :
996 4790 : notOr1=!dble1[15] & !dble1[14] & !dble1[13] & !dble1[12] &
997 7185 : !dble1[11] & !dble1[10] & !dble1[9] & !dble1[8] &
998 7185 : !dble1[7] & !dble1[6] & !dble1[5] & !dble1[4] &
999 4790 : !dble1[3] & !dble1[2] & !dble1[1] & !dble1[0];
1000 :
1001 4790 : notOr2=!dble2[15] & !dble2[14] & !dble2[13] & !dble2[12] &
1002 7185 : !dble2[11] & !dble2[10] & !dble2[9] & !dble2[8] &
1003 7185 : !dble2[7] & !dble2[6] & !dble2[5] & !dble2[4] &
1004 4790 : !dble2[3] & !dble2[2] & !dble2[1] & !dble2[0];
1005 :
1006 81430 : for (i=0; i<16; i++) {
1007 38320 : sgle1[i] = sgle1[i] & notOr1 & !fCoinc44;
1008 38320 : sgle2[i] = sgle2[i] & notOr2 & !fCoinc44;
1009 : }
1010 :
1011 : //---------------------------------------------------------
1012 : // step # 3 : 3/4 coincidence
1013 : //---------------------------------------------------------
1014 2395 : Int_t frontImage[16];
1015 :
1016 71850 : for (i=1; i<15; i++) {
1017 100590 : frontImage[i] = ((dble1[i] | sgle1[i]) &
1018 67060 : (dble2[i+1] | dble2[i] | dble2[i-1])) |
1019 33530 : (dble1[i] & (sgle2[i+1] | sgle2[i] | sgle2[i-1]));
1020 : }
1021 7185 : frontImage[0] = ((dble1[0] | sgle1[0]) &
1022 4790 : (dble2[1] | dble2[0])) | (dble1[0] & (sgle2[1] | sgle2[0]));
1023 :
1024 7185 : frontImage[15] = ((dble1[15] | sgle1[15]) &
1025 4790 : (dble2[15] | dble2[14])) | (dble1[15] & (sgle2[15] | sgle2[14]));
1026 :
1027 :
1028 : //debug
1029 14370 : if(AliDebugLevel()==4||AliDebugLevel()==5) {
1030 0 : printf("===============================================================\n");
1031 0 : printf(" Y plane frontImage\n");
1032 0 : printf(" ");
1033 0 : for (istrip=15; istrip>=0; istrip--) {
1034 0 : if (istrip>9) printf("%i",istrip-10*Int_t(istrip/10));
1035 0 : if (istrip<10) printf("%i",istrip);
1036 : }
1037 0 : printf("\n ");
1038 0 : for (istrip=15; istrip>=0; istrip--) printf("%i",frontImage[istrip]);
1039 0 : printf("\n");
1040 0 : }
1041 : //debug
1042 :
1043 : //---------------------------------------------------------
1044 : // step # 4 : Y position
1045 : //---------------------------------------------------------
1046 : Int_t or1, or2, and1, and2, and3;
1047 :
1048 2395 : or1 = frontImage[7]|frontImage[5]|frontImage[3]|frontImage[1];
1049 2395 : or2 = frontImage[7]|frontImage[6]|frontImage[5]|frontImage[4];
1050 2395 : and1 = !frontImage[3]&!frontImage[2]&!frontImage[1]&!frontImage[0];
1051 2395 : and2 = !frontImage[7]&!frontImage[6]&!frontImage[5]&!frontImage[4] & and1;
1052 2395 : and3 = !frontImage[11]&!frontImage[10]&!frontImage[9]&!frontImage[8];
1053 :
1054 7185 : fCoordY[0] = !frontImage[0]&(frontImage[1]|!frontImage[2]) &
1055 4790 : (frontImage[3]|frontImage[1]|(!frontImage[4]&(frontImage[5]|!frontImage[6]))) &
1056 4790 : (or1|(!frontImage[8]&(frontImage[9]|!frontImage[10]))) &
1057 2395 : (or1|frontImage[11]|frontImage[9]|(!frontImage[12]&(frontImage[13]|!frontImage[14])));
1058 :
1059 7185 : fCoordY[1] = !frontImage[0]&!frontImage[1] &
1060 7185 : !(!frontImage[11]&!frontImage[10]&!frontImage[7]&!frontImage[6] &
1061 7185 : !frontImage[3]&!frontImage[2]&(frontImage[13]|frontImage[12])) &
1062 4790 : (frontImage[3]|frontImage[2] | (!frontImage[5]&!frontImage[4])) &
1063 4790 : (frontImage[7]|frontImage[6]|frontImage[3]|frontImage[2] |
1064 2395 : (!frontImage[9]&!frontImage[8]));
1065 :
1066 2395 : fCoordY[2] = and1 & (or2 | and3);
1067 :
1068 2395 : fCoordY[3] = and2;
1069 :
1070 4790 : fCoordY[4] = !frontImage[15]&!frontImage[14]&!frontImage[13]&!frontImage[12] &
1071 2395 : and2 & and3 ;
1072 2395 : }
1073 :
1074 : //___________________________________________
1075 : void AliMUONLocalTriggerBoard::LocalTrigger()
1076 : {
1077 : /// L0 trigger after LUT
1078 : ///
1079 : Int_t deviation=0;
1080 : Int_t iStripY=0;
1081 : Int_t iStripX=0;
1082 4790 : Bool_t xOutput = IsTrigX();
1083 2395 : Bool_t yOutput = IsTrigY();
1084 :
1085 2395 : if (xOutput) {
1086 17688 : for (Int_t i=0; i<5; i++) iStripX += static_cast<int>( fMinDevStrip[i] << i );
1087 14740 : for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
1088 1474 : fDev = deviation;
1089 1474 : fStripX11 = iStripX;
1090 1474 : }
1091 2395 : if (yOutput) {
1092 23450 : for (Int_t i=0; i<4; i++) iStripY += static_cast<int>( fCoordY[i] << i );
1093 2345 : fStripY11 = iStripY;
1094 2345 : fTrigY = fCoordY[4];
1095 2345 : }
1096 :
1097 : // cout << " Local Trigger " << " " << fNumber << " " <<
1098 : // xOutput << " " << yOutput << " " << fDev << " " << fStripX11 << " " <<
1099 : // fTrigY << " " << fStripY11 << "\n";
1100 :
1101 3869 : if (xOutput && yOutput){ // trigger in X and Y
1102 1425 : fOutput =1;
1103 :
1104 : Int_t sign = 0;
1105 1425 : if ( !fMinDev[4] && deviation ) sign=-1;
1106 1425 : if ( !fMinDev[4] && !deviation ) sign= 0;
1107 1425 : if ( fMinDev[4] == 1 ) sign=+1;
1108 :
1109 1425 : deviation *= sign;
1110 :
1111 : // calculate deviation in [0;+30]
1112 1425 : deviation += 15;
1113 :
1114 : // GET LUT OUTPUT FOR icirc/istripX1/deviation/istripY
1115 1425 : fLUT->GetLutOutput(GetNumber(), fStripX11, deviation, fStripY11, fLutLpt, fLutHpt);
1116 1425 : }
1117 :
1118 7185 : fResponse = fLutLpt[0] +
1119 4790 : static_cast<int>(fLutLpt[1]<<1) +
1120 4790 : static_cast<int>(fLutHpt[0]<<2) +
1121 2395 : static_cast<int>(fLutHpt[1]<<3);
1122 :
1123 2395 : }
1124 :
1125 : //___________________________________________
1126 : Int_t AliMUONLocalTriggerBoard::GetI() const
1127 : {
1128 : /// old numbering
1129 : ///
1130 :
1131 0 : const Int_t kMaxfields = 2; char **fields = new char*[kMaxfields];
1132 :
1133 0 : for (Int_t i = 0; i < kMaxfields; i++)
1134 0 : fields[i] = new char[1];
1135 :
1136 0 : char s[100]; strncpy(s, GetName(), 99);
1137 :
1138 : Int_t numlines = 0;
1139 :
1140 0 : for (char *token = strtok(s, "B");
1141 0 : token != NULL;
1142 0 : token = strtok(NULL, " "))
1143 : {
1144 0 : delete [] fields[numlines];
1145 0 : fields[numlines] = new char[strlen(token)+1];
1146 0 : strcpy(fields[numlines++], token);
1147 : }
1148 :
1149 0 : TString l(fields[0]);
1150 :
1151 0 : char copy = l[0];
1152 :
1153 0 : Int_t lL = atoi(&l[4]), cC = atoi(&l[2]), sS = (copy=='R') ? +1 : -1;
1154 :
1155 0 : const char *b[4] = {"12", "34", "56", "78"};
1156 :
1157 : Int_t ib = 0;
1158 :
1159 0 : for (Int_t i=0; i<4; i++) if (!strcmp(fields[1],b[i])) {ib = i; break;} ib++;
1160 :
1161 : // lL=1 ON TOP
1162 0 : lL -= 9; lL = abs(lL); lL++;
1163 :
1164 0 : Int_t code = 100 * lL + 10 * cC + ib;
1165 :
1166 0 : code *= sS;
1167 :
1168 : Int_t ic = 0;
1169 :
1170 0 : for (Int_t i=0; i<234; i++) if (fgkCircuitId[i] == code) {ic = i; break;}
1171 :
1172 0 : delete [] fields;
1173 :
1174 : return ic;
1175 0 : }
1176 :
1177 : //___________________________________________
1178 : void AliMUONLocalTriggerBoard::Mask(Int_t index, UShort_t mask)
1179 : {
1180 : /// set mask
1181 : ///
1182 23232 : if ( index >= 0 && index < 2*4 )
1183 : {
1184 11616 : Int_t i = index/4;
1185 11616 : Int_t j = index%4;
1186 11616 : fMask[i][j]=mask;
1187 11616 : }
1188 : else
1189 : {
1190 0 : AliError(Form("Index %d out of bounds (max %d)",index,8));
1191 : }
1192 11616 : }
1193 :
1194 : //___________________________________________
1195 : void AliMUONLocalTriggerBoard::Scan(Option_t *option) const
1196 : {
1197 : /// full dump
1198 : ///
1199 0 : TString op = option;
1200 :
1201 0 : if (op.Contains("CONF")) Conf();
1202 :
1203 0 : if (op.Contains("BITP")) Pattern();
1204 :
1205 0 : if (op.Contains("RESPI")) Resp("I");
1206 :
1207 0 : if (op.Contains("RESPF")) Resp("F");
1208 :
1209 0 : if (op.Contains("RESPO")) Resp("O");
1210 :
1211 0 : if (op.Contains("ALL"))
1212 : {
1213 0 : Conf();
1214 0 : Pattern();
1215 0 : Resp("I");
1216 0 : Resp("F");
1217 : }
1218 0 : }
1219 :
1220 : //___________________________________________
1221 : void AliMUONLocalTriggerBoard::Conf() const
1222 : {
1223 : /// board switches
1224 : ///
1225 0 : cout << "Switch(" << GetName() << ")"
1226 0 : << " x2d = " << GetSwitch(0)
1227 0 : << " x2m = " << GetSwitch(1)
1228 0 : << " x2u = " << GetSwitch(2)
1229 0 : << " OR[0] = " << GetSwitch(3)
1230 0 : << " OR[1] = " << GetSwitch(4)
1231 0 : << " EN-Y = " << GetSwitch(5)
1232 0 : << " ZERO-ALLY-LSB = " << GetSwitch(6)
1233 0 : << " ZERO-down = " << GetSwitch(7)
1234 0 : << " ZERO-middle = " << GetSwitch(8)
1235 0 : << " ZERO-up = " << GetSwitch(9)
1236 0 : << " trans. conn. " << GetTC()
1237 0 : << " Slot = " << fSlot
1238 0 : << endl;
1239 0 : }
1240 :
1241 : //___________________________________________
1242 : void AliMUONLocalTriggerBoard::Resp(Option_t *option) const
1243 : {
1244 : /// board I/O
1245 : ///
1246 0 : TString op = option;
1247 :
1248 0 : if (op.Contains("I"))
1249 : {
1250 : // print Local trigger output before the LuT step
1251 0 : printf("===============================================================\n");
1252 0 : printf("-------- TRIGGER OUTPUT --------\n");
1253 0 : printf("minDevStrip = ");
1254 0 : for (Int_t i=4; i>=0; i--) printf("%i",fMinDevStrip[i]);
1255 0 : printf(" minDev = ");
1256 0 : for (Int_t i=4; i>=0; i--) printf("%i",fMinDev[i]);
1257 0 : printf(" coordY = ");
1258 0 : for (Int_t i=4; i>=0; i--) printf("%i",fCoordY[i]);
1259 0 : printf(" \n");
1260 : }
1261 0 : if (op.Contains("O")){
1262 0 : printf("-- Output --\n");
1263 0 : printf("Coinc44 %i\n", fCoinc44);
1264 0 : printf("StripX11 %i StripY11 %i Dev %i TrigY %i\n", fStripX11, fStripY11, fDev, fTrigY);
1265 0 : printf("LutLpt %i %i LutHpt %i %i\n", fLutLpt[0], fLutLpt[1], fLutHpt[0], fLutHpt[1]);
1266 0 : printf("Response %i\n", fOutput);
1267 : }
1268 :
1269 0 : }
1270 :
1271 : //___________________________________________
1272 : void AliMUONLocalTriggerBoard::Response()
1273 : {
1274 : /// algo
1275 : ///
1276 343200 : if ( IsNull() ) {
1277 169205 : fMinDev[4] = 1;
1278 2030460 : for (Int_t i=4; i>=0; i--) fCoordY[i] = 1;
1279 169205 : return; // Do nothing if strip pattern is null
1280 : }
1281 :
1282 2395 : Int_t xX1[16], xX2[16], xXX3[32], xXX4[32];
1283 :
1284 7185 : TBits x1(16), x2(16), x3(16), x4(16);
1285 :
1286 2395 : UShort_t xyv = 0;
1287 :
1288 2395 : xyv = fXY[0][0]; x1.Set(16,&xyv);
1289 2395 : xyv = fXY[0][1]; x2.Set(16,&xyv);
1290 2395 : xyv = fXY[0][2]; x3.Set(16,&xyv);
1291 2395 : xyv = fXY[0][3]; x4.Set(16,&xyv);
1292 :
1293 9580 : TBits x3u(16), x4u(16), x3d(16), x4d(16);
1294 :
1295 2395 : xyv = fXYU[0][2]; x3u.Set(16,&xyv);
1296 2395 : xyv = fXYU[0][3]; x4u.Set(16,&xyv);
1297 :
1298 2395 : xyv = fXYD[0][2]; x3d.Set(16,&xyv);
1299 2395 : xyv = fXYD[0][3]; x4d.Set(16,&xyv);
1300 :
1301 81430 : for (Int_t i=0;i<16;i++)
1302 : {
1303 76640 : xX1[i] = x1[i];
1304 76640 : xX2[i] = x2[i];
1305 :
1306 76640 : xXX3[i+8] = x3[i];
1307 76640 : xXX4[i+8] = x4[i];
1308 : }
1309 :
1310 43110 : for (Int_t i=0;i<8;i++)
1311 : {
1312 38320 : xXX3[i] = x3d[i+8];
1313 38320 : xXX4[i] = x4d[i+8];
1314 :
1315 38320 : xXX3[i+24] = x3u[i];
1316 38320 : xXX4[i+24] = x4u[i];
1317 : }
1318 :
1319 : // Int_t coinc44 = 0;
1320 :
1321 2395 : TrigX(xX1, xX2, xXX3, xXX4);
1322 :
1323 2395 : Int_t yY1[16], yY2[16], yY3[16], yY4[16];
1324 :
1325 2395 : Int_t yY3U[16], yY3D[16], yY4U[16], yY4D[16];
1326 :
1327 9580 : TBits y1(16), y2(16), y3(16), y4(16);
1328 :
1329 9580 : TBits y3u(16), y3d(16), y4u(16), y4d(16);
1330 :
1331 2395 : xyv = fXY[1][0]; y1.Set(16,&xyv);
1332 2395 : xyv = fXY[1][1]; y2.Set(16,&xyv);
1333 2395 : xyv = fXY[1][2]; y3.Set(16,&xyv);
1334 2395 : xyv = fXY[1][3]; y4.Set(16,&xyv);
1335 :
1336 2395 : xyv = fXYU[1][2]; y3u.Set(16,&xyv);
1337 2395 : xyv = fXYD[1][2]; y3d.Set(16,&xyv);
1338 2395 : xyv = fXYU[1][3]; y4u.Set(16,&xyv);
1339 2395 : xyv = fXYD[1][3]; y4d.Set(16,&xyv);
1340 :
1341 81430 : for (Int_t i=0;i<16;i++)
1342 : {
1343 76640 : yY1[i] = y1[i];
1344 76640 : yY2[i] = y2[i];
1345 76640 : yY3[i] = y3[i];
1346 76640 : yY4[i] = y4[i];
1347 :
1348 76640 : yY3U[i] = y3u[i];
1349 76640 : yY3D[i] = y3d[i];
1350 :
1351 76640 : yY4U[i] = y4u[i];
1352 76640 : yY4D[i] = y4d[i];
1353 : }
1354 :
1355 2395 : TrigY(yY1, yY2, yY3, yY4, yY3U, yY3D, yY4U, yY4D);
1356 :
1357 : // ASIGN fLutLpt, fLutHpt
1358 2395 : LocalTrigger();
1359 173995 : }
1360 :
1361 : //___________________________________________
1362 : Bool_t AliMUONLocalTriggerBoard::IsTrigY() const
1363 : {
1364 : /// Return the response of non-bending plane
1365 : Int_t iStripY = 0;
1366 : Bool_t output = kFALSE;
1367 :
1368 26587 : for (Int_t i=0; i<4; i++) iStripY += static_cast<int>( fCoordY[i] << i );
1369 :
1370 2467 : if (fCoordY[4]==1 && iStripY==15) output=kFALSE; // no trigger in Y
1371 : else output=kTRUE; // trigger in Y
1372 :
1373 2417 : return output;
1374 : }
1375 :
1376 : //___________________________________________
1377 : Bool_t AliMUONLocalTriggerBoard::IsTrigX() const
1378 : {
1379 : /// Return the response of bending plane
1380 :
1381 : Int_t deviation = 0;
1382 : Bool_t output = kFALSE;
1383 :
1384 26587 : for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
1385 :
1386 3346 : if (fMinDev[4]==1 && !deviation) output=kFALSE; // no trigger in X
1387 : else output=kTRUE; // trigger in X
1388 :
1389 2417 : return output;
1390 : }
1391 :
1392 : //___________________________________________
1393 : Bool_t AliMUONLocalTriggerBoard::IsNull() const
1394 : {
1395 : /// Check if board has fired strips in the first station
1396 1362651 : for (Int_t icath=0; icath<2; icath++){
1397 2380069 : for(Int_t ich=0; ich<2; ich++){
1398 683445 : if ( fXY[icath][ich] ) return kFALSE;
1399 : }
1400 : }
1401 169205 : return kTRUE;
1402 171600 : }
|
