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