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