ac8cfb8b1b70d4681c81f725e6d01748e63a29f2
[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       fNumber(0),
61       fCrate(0),
62       fTC(kTRUE),
63       fStripX11(0),
64       fStripY11(0),
65       fDev(0),
66       fOutput(0),
67       fLUT(0x0)      
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] = fLutApt[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 {
100 //* constructor
101 //*
102    
103    for (Int_t i=0; i<2; i++) 
104       for (Int_t j=0; j<4; j++) 
105       {
106          fXY[i][j] = fXYU[i][j] = fXYD[i][j] = 0;
107
108          fMask[i][j] = 0xFFFF;
109       }
110
111    for (Int_t i=0; i<10; i++) fSwitch[i] = 0;
112
113    for (Int_t i=0; i<5; i++) fMinDevStrip[i] = fMinDev[i] = fCoordY[i] = 0;
114
115    for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = fLutApt[i] = 0;
116 }
117
118 //______________________________________________________________________________
119 AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(const AliMUONLocalTriggerBoard& right) 
120     : AliMUONTriggerBoard(right),
121       fNumber(right.fNumber),
122       fCrate(right.fCrate),
123       fTC(right.fTC),
124       fStripX11(right.fStripX11),
125       fStripY11(right.fStripY11),
126       fDev(right.fDev),
127       fOutput(right.fOutput),
128       fLUT(right.fLUT)
129 {  
130 /// Protected copy constructor (not implemented)
131
132   AliFatal("Copy constructor not provided.");
133 }
134
135 //______________________________________________________________________________
136 AliMUONLocalTriggerBoard& 
137 AliMUONLocalTriggerBoard::operator=(const AliMUONLocalTriggerBoard& right)
138 {
139 /// Protected assignement operator (not implemented)
140
141   // check assignement to self
142   if (this == &right) return *this;
143
144   AliFatal("Assignement operator not provided.");
145     
146   return *this;  
147 }    
148
149 //___________________________________________
150 void AliMUONLocalTriggerBoard::Reset()
151 {
152 //* reset board
153 //*
154    for (Int_t i=0; i<2; i++) 
155       for (Int_t j=0; j<4; j++) 
156          fXY[i][j] = fXYU[i][j] = fXYD[i][j] = 0;
157
158    fResponse = 0;
159
160    for (Int_t i=0; i<5; i++) fMinDevStrip[i] = fMinDev[i] = fCoordY[i] = 0;
161
162    fOutput = 0;
163    
164    fStripX11 = fStripY11 = fDev = 0;
165
166    for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = fLutApt[i] = 0;
167 }
168
169 //___________________________________________
170 void AliMUONLocalTriggerBoard::Setbit(Int_t strip, Int_t cathode, Int_t chamber)
171 {
172 // 0 .. LBS   :   N-1 .. MSB
173    TBits w, m;
174
175    UShort_t xy = fXY[cathode][chamber], mask = fMask[cathode][chamber];
176
177    w.Set(16,&xy);
178    m.Set(16,&mask);
179
180    Int_t s = strip - int(strip / 16) * 16;
181
182    w.SetBitNumber(s);
183    
184    w &= m;
185
186    UShort_t value;
187
188    w.Get(&value);
189
190    fXY[cathode][chamber] = value;
191 }
192
193 //___________________________________________
194 void AliMUONLocalTriggerBoard::SetbitM(Int_t strip, Int_t cathode, Int_t chamber)
195 {
196 // 0 .. LBS   :   N-1 .. MSB
197    TBits w, m;
198
199    UShort_t xy = fXY[cathode][chamber], mask = fMask[cathode][chamber];
200
201    w.Set(16,&xy);
202    m.Set(16,&mask);
203
204    w.SetBitNumber(strip);
205    
206    w &= m;
207
208    UShort_t value;
209
210    w.Get(&value);
211
212    fXY[cathode][chamber] = value;
213 }
214
215 //___________________________________________
216 void AliMUONLocalTriggerBoard::Pattern(Option_t *option) const
217 {
218 //* print bit pattern
219 //*
220    TString op = option;
221    
222    if (op.Contains("X")) BP("X");
223
224    if (op.Contains("Y")) BP("Y");
225 }
226
227
228 //___________________________________________
229 void AliMUONLocalTriggerBoard::BP(Option_t *option) const
230 {
231 // RESPECT THE OLD PRINTOUT FORMAT
232   
233   const Int_t kModuleId[126] = 
234   {11,12,13,14,15,16,17,         // right side of the chamber
235   21,22,23,24,25,26,27,
236   31,32,33,34,35,36,37,
237   41,42,43,44,45,46,47,
238   51,52,53,54,55,56,57,
239   61,62,63,64,65,66,67,
240   71,72,73,74,75,76,77,
241   81,82,83,84,85,86,87,
242   91,92,93,94,95,96,97,   
243   -11,-12,-13,-14,-15,-16,-17,  // right side of chamber
244   -21,-22,-23,-24,-25,-26,-27,
245   -31,-32,-33,-34,-35,-36,-37,
246   -41,-42,-43,-44,-45,-46,-47,
247   -51,-52,-53,-54,-55,-56,-57,
248   -61,-62,-63,-64,-65,-66,-67,
249   -71,-72,-73,-74,-75,-76,-77,
250   -81,-82,-83,-84,-85,-86,-87,
251   -91,-92,-93,-94,-95,-96,-97};
252
253   const Int_t kNstripY[126]=
254   { 8, 8, 8, 8, 8, 8,16,  // right side of the chamber
255   8, 8, 8, 8, 8, 8,16,
256   16,16,16,16,16, 8,16,
257   16,16,16,16,16, 8,16,
258   0, 8,16,16,16, 8,16,
259   16,16,16,16,16, 8,16,
260   16,16,16,16,16, 8,16,
261   8, 8, 8, 8, 8, 8,16,
262   8, 8, 8, 8, 8, 8,16,  
263   8, 8, 8, 8, 8, 8,16,  // left side of the chamber
264   8, 8, 8, 8, 8, 8,16,
265   16,16,16,16,16, 8,16,
266   16,16,16,16,16, 8,16,
267   0, 8,16,16,16, 8,16,
268   16,16,16,16,16, 8,16,
269   16,16,16,16,16, 8,16,
270   8, 8, 8, 8, 8, 8,16,
271   8, 8, 8, 8, 8, 8,16};
272
273    TString op = option;
274         
275    TString nn = GetName();
276
277    if (op.Contains("X"))
278    {
279       printf("-------- TRIGGER INPUT ---------\n");
280       printf("===============================================================\n");
281       printf("                            5432109876543210");
282
283       char *x[4] = {"XMC11","XMC12","XMC21","XMC22"};
284       char *s[4] = {"                      ",
285                     "                      ",
286                     "              ",
287                     "              "};
288       
289       for (Int_t ch=0; ch<4; ch++)
290       { 
291          printf("\n %s%s", x[ch], s[ch]);
292
293          UShort_t xy = fXY[0][ch];
294
295          TBits w(16); w.Set(16,&xy);
296
297          if (ch<2) cout << w;
298          else
299          {
300             UShort_t xyd = fXYD[0][ch], xyu = fXYU[0][ch];
301             TBits dw(16), uw(16); dw.Set(16,&xyd); uw.Set(16,&xyu); 
302
303             TBits ew(32);
304          
305             for (Int_t i=0;i<16;i++) ew[i+8] = w[i];
306
307             for (Int_t i=0;i<8;i++) 
308             {
309                ew[i]    = dw[i+8]; // 8 MSB
310                ew[i+24] = uw[i];   // 
311             }
312
313             cout << ew;
314          }
315       }
316    
317       printf("\n                    ");
318       printf("10987654321098765432109876543210\n");
319    }
320
321    if (op.Contains("Y"))
322    {
323       printf("---------------------------------------------------------------\n");
324       printf("                            ");
325
326 /*    OLD NUMBERING STYLE    */
327 /**/
328       Int_t idCircuit = 0, absidModule = 0;
329
330       if (!(nn.Contains("Int"))) 
331       { 
332         idCircuit   = fgkCircuitId[GetI()];
333         absidModule = TMath::Abs(Int_t(idCircuit/10));
334       }
335                 
336       Int_t iModule=0;
337
338       for (Int_t i=0; i<63; i++) 
339       {
340         if (kModuleId[i]==absidModule) 
341          { 
342             iModule=i;
343             break;
344          }
345       }
346
347       Int_t nStrip = kNstripY[iModule];
348       for (Int_t istrip=nStrip-1; istrip>=0; istrip--) {
349          if (istrip>9)  printf("%i",istrip-10*Int_t(istrip/10));
350          if (istrip<10) printf("%i",istrip);
351       }
352 /**/
353 /*                           */
354
355       UShort_t xyval = 0;
356
357       if (fSwitch[1])
358       {
359          xyval = fXY[1][0];
360          TBits v11(8); v11.Set(8,&xyval);
361          printf("\n YMC11                      ");
362          cout << v11;         
363
364          xyval = fXY[1][1];
365          TBits v12(8); v12.Set(8,&xyval);
366          printf("\n YMC12                      ");
367          cout << v12;
368
369          xyval = fXY[1][2];
370          TBits v21(8); v21.Set(8,&xyval);
371          printf("\n YMC21                      ");         
372          cout << v21;
373
374          xyval = fXY[1][3];
375          TBits v22(8); v22.Set(8,&xyval);
376          printf("\n YMC22                      ");
377          cout << v22 << endl;
378       }
379       else
380       {
381          xyval = fXY[1][0];
382          TBits v11(16); v11.Set(16,&xyval);
383          printf("\n YMC11                      ");
384          cout << v11;         
385
386          xyval = fXY[1][1];
387          TBits v12(16); v12.Set(16,&xyval);
388          printf("\n YMC12                      ");
389          cout << v12;
390
391          xyval = fXY[1][2];
392          TBits v21(16); v21.Set(16,&xyval);
393          printf("\n YMC21                      ");         
394          cout << v21;
395
396          xyval = fXY[1][3];
397          TBits v22(16); v22.Set(16,&xyval);
398          printf("\n YMC22                      ");
399          cout << v22 << endl;
400       }
401
402 //    tmp
403       printf("---------------------------------------------------------------");
404       printf("\n upper part of circuit %i",idCircuit);
405       printf("\n UMC21                      ");
406       xyval = fXYU[1][2];
407       TBits wu21(16); wu21.Set(16,&xyval);
408       cout << wu21;
409       printf("\n UMC22                      ");
410       xyval = fXYU[1][3];
411       TBits wu22(16); wu22.Set(16,&xyval);
412       cout << wu22;
413       printf("\n lower part of circuit %i",idCircuit);
414       printf("\n LMC21                      ");
415       xyval = fXYD[1][2];
416       TBits wl21(16); wl21.Set(16,&xyval);
417       cout << wl21;
418       printf("\n LMC22                      ");
419       xyval = fXYD[1][3];
420       TBits wl22(16); wl22.Set(16,&xyval);
421       cout << wl22;
422       printf("\n");
423       printf("===============================================================\n");
424    }
425 }
426
427 //___________________________________________
428 void AliMUONLocalTriggerBoard::Conf() const
429 {
430 //* board switches
431 //*
432    cout << "Switch(" << GetName() << ")" 
433         << " x2d = "           << fSwitch[0] 
434         << " x2m = "           << fSwitch[1] 
435         << " x2u = "           << fSwitch[2] 
436         << " OR[0] = "         << fSwitch[3] 
437         << " OR[1] = "         << fSwitch[4] 
438         << " EN-Y = "          << fSwitch[5] 
439         << " ZERO-ALLY-LSB = " << fSwitch[6] 
440         << " ZERO-down = "     << fSwitch[7] 
441         << " ZERO-middle = "   << fSwitch[8] 
442         << " ZERO-up = "       << fSwitch[9] 
443         << " trans. conn. "    << fTC 
444         << " Slot = "          << fSlot 
445         << endl;
446 }
447
448 //___________________________________________
449 void AliMUONLocalTriggerBoard::Module(char *mod)
450 {
451 //* get module from name
452 //*
453    const Int_t kMaxfields = 2; char **fields = new char*[kMaxfields];
454
455    char s[100]; strcpy(s, GetName());
456
457    Int_t numlines = 0;
458
459    for (char *token = strtok(s, "B");
460         token != NULL;
461         token = strtok(NULL, " "))
462    {
463       fields[numlines] = new char[strlen(token)+1];
464       strcpy(fields[numlines++],token);
465    }
466  
467    strcpy(mod,fields[0]);
468 }
469
470 //___________________________________________
471 void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[32], Int_t ch4q[32], 
472                                      Int_t coinc44)
473 {
474 // note : coinc44 = flag 0 or 1 (0 coincidence -> 3/4, 1 coincidence -> 4/4)
475 //---------------------------------------------------------
476 // step # 1 : declustering, reduction DS, calculate sgle & dble
477 //---------------------------------------------------------
478    Int_t ch1e[19], ch2e[20], ch3e[35], ch4e[36]; 
479    Int_t sgleHit1[31], sgleHit2[63];
480    Int_t dbleHit1[31], dbleHit2[63];
481
482    Int_t i;
483    Int_t j;
484    Int_t istrip;
485
486    for (i=0; i<31; i++) {
487       sgleHit1[i]=0;
488       dbleHit1[i]=0;
489    }
490    for (i=0; i<63; i++) {
491       sgleHit2[i]=0;
492       dbleHit2[i]=0;
493    }
494
495 //--- inititialize che using chq 
496    for (i=0; i<19; i++) {
497       if (i<1||i>16)  ch1e[i]=0; 
498       else            ch1e[i]=ch1q[i-1]; 
499    }
500    for (i=0; i<20; i++) {
501       if (i<2||i>17) ch2e[i]=0; 
502       else           ch2e[i]=ch2q[i-2]; 
503    }
504    for (i=0; i<35; i++) {
505       if (i<1||i>32) ch3e[i]=0; 
506       else           ch3e[i]=ch3q[i-1];
507    }
508    for (i=0; i<36; i++) {
509       if (i<2||i>33) ch4e[i]=0; 
510       else           ch4e[i]=ch4q[i-2];
511    }
512
513
514 //--- calculate dble & sgle first station
515    for (i=0; i<=15; i++) {                   
516       sgleHit1[2*i] = (!ch1e[i+1]|(ch1e[i]^ch1e[i+2])) & 
517          (!ch2e[i+2] | (ch2e[i+1]^ch2e[i+3]));
518
519       dbleHit1[2*i] = ch1e[i+1]&!(ch1e[i+2]^ch1e[i]) & 
520          (ch2e[i+2] | (!ch2e[i]&ch2e[i+1]) | (ch2e[i+3]&!ch2e[i+4]));
521    }
522
523    for (i=0; i<=14; i++) {               
524       sgleHit1[2*i+1] = (!ch1e[i+1]|!ch1e[i+2]|(ch1e[i]^ch1e[i+3])) & 
525          (!ch2e[i+2] | !ch2e[i+3] | (ch2e[i+1]^ch2e[i+4]));
526       dbleHit1[2*i+1] = ch1e[i+1]&ch1e[i+2]&!(ch1e[i]^ch1e[i+3]) & 
527          (ch2e[i+2]&(!ch2e[i+1]|!ch2e[i]) | 
528           ch2e[i+3]&(ch2e[i+2]|!ch2e[i+4]|!ch2e[i+5]));
529    }
530
531 //--- calculate dble & sgle second station
532    for (i=0; i<=31; i++) {               
533       sgleHit2[2*i] = (!ch3e[i+1]|(ch3e[i]^ch3e[i+2])) & 
534          (!ch4e[i+2] | (ch4e[i+1]^ch4e[i+3]));
535       dbleHit2[2*i] = ch3e[i+1]&!(ch3e[i+2]^ch3e[i]) & 
536          (ch4e[i+2] | (!ch4e[i]&ch4e[i+1]) | (ch4e[i+3]&!ch4e[i+4]));
537    }
538   
539    for (i=0; i<=30; i++) {               
540       sgleHit2[2*i+1] = (!ch3e[i+1]|!ch3e[i+2]|(ch3e[i]^ch3e[i+3])) & 
541          (!ch4e[i+2] | !ch4e[i+3] | (ch4e[i+1]^ch4e[i+4]));
542       dbleHit2[2*i+1] = ch3e[i+1]&ch3e[i+2]&!(ch3e[i]^ch3e[i+3]) & 
543          (ch4e[i+2]&(!ch4e[i+1]|!ch4e[i]) | 
544           ch4e[i+3]&(ch4e[i+2]|!ch4e[i+4]|!ch4e[i+5]));
545    }
546
547 //--- 
548    if(AliDebugLevel()==3||AliDebugLevel()==5) {
549       printf("===============================================================\n");
550       printf(" X plane after sgle and dble \n");
551       printf("                       0987654321098765432109876543210");
552       printf("\n SGLE1                 ");
553       for (istrip=30; istrip>=0; istrip--) printf("%i",(!sgleHit1[istrip]));
554       printf("\n DBLE1                 ");
555       for (istrip=30; istrip>=0; istrip--) printf("%i",dbleHit1[istrip]);
556       printf("\n SGLE2 ");
557       for (istrip=62; istrip>=0; istrip--) printf("%i",(!sgleHit2[istrip]));
558       printf("\n DBLE2 ");
559       for (istrip=62; istrip>=0; istrip--) printf("%i",dbleHit2[istrip]);
560       printf("\n       210987654321098765432109876543210987654321098765432109876543210\n");
561    }
562   
563 //---------------------------------------------------------
564 // step # 2 : coincidence 3/4
565 //---------------------------------------------------------
566    Int_t rearImage[31][31];
567    for (i=0; i<31; i++) {
568       for (j=0; j<31; j++) {
569          rearImage[i][j]=0;
570       }
571    }
572
573    Int_t notOr1=!dbleHit1[30] & !dbleHit1[29] & !dbleHit1[28] & !dbleHit1[27] & 
574       !dbleHit1[26] & !dbleHit1[25] & !dbleHit1[24] & !dbleHit1[23] &
575       !dbleHit1[22] & !dbleHit1[21] & !dbleHit1[20] & !dbleHit1[19] & 
576       !dbleHit1[18] & !dbleHit1[17] & !dbleHit1[16] & !dbleHit1[15] & 
577       !dbleHit1[14] & !dbleHit1[13] & !dbleHit1[12] & !dbleHit1[11] & 
578       !dbleHit1[10] & !dbleHit1[9]  & !dbleHit1[8]  & !dbleHit1[7]  & 
579       !dbleHit1[6]  & !dbleHit1[5]  & !dbleHit1[4]  & !dbleHit1[3]  & 
580       !dbleHit1[2]  & !dbleHit1[1]  & !dbleHit1[0]  & !coinc44;
581
582    Int_t notOr2= !dbleHit2[62] & !dbleHit2[61] & !dbleHit2[60] & !dbleHit2[59] & 
583       !dbleHit2[58] & !dbleHit2[57] & !dbleHit2[56] & !dbleHit2[55] & 
584       !dbleHit2[54] & !dbleHit2[53] & !dbleHit2[52] & !dbleHit2[51] & 
585       !dbleHit2[50] & !dbleHit2[49] & !dbleHit2[48] & !dbleHit2[47] & 
586       !dbleHit2[46] & !dbleHit2[45] & !dbleHit2[44] & !dbleHit2[43] & 
587       !dbleHit2[42] & !dbleHit2[41] & !dbleHit2[40] & !dbleHit2[39] & 
588       !dbleHit2[38] & !dbleHit2[37] & !dbleHit2[36] & !dbleHit2[35] & 
589       !dbleHit2[34] & !dbleHit2[33] & !dbleHit2[32] & !dbleHit2[31] &
590       !dbleHit2[30] & !dbleHit2[29] & !dbleHit2[28] & !dbleHit2[27] & 
591       !dbleHit2[26] & !dbleHit2[25] & !dbleHit2[24] & !dbleHit2[23] & 
592       !dbleHit2[22] & !dbleHit2[21] & !dbleHit2[20] & !dbleHit2[19] & 
593       !dbleHit2[18] & !dbleHit2[17] & !dbleHit2[16] & !dbleHit2[15] & 
594       !dbleHit2[14] & !dbleHit2[13] & !dbleHit2[12] & !dbleHit2[11] & 
595       !dbleHit2[10] & !dbleHit2[9]  & !dbleHit2[8]  & !dbleHit2[7]  & 
596       !dbleHit2[6]  & !dbleHit2[5]  & !dbleHit2[4]  & !dbleHit2[3]  & 
597       !dbleHit2[2]  & !dbleHit2[1]  & !dbleHit2[0]  & !coinc44; 
598
599 // DS reduction
600    for (i=0; i<31; i++) {
601       sgleHit1[i] = !sgleHit1[i]&notOr1;
602    }
603    for (i=0; i<63; i++) {
604       sgleHit2[i] = !sgleHit2[i]&notOr2;
605    }
606
607 // extract rearImage
608    for (i=0; i<31; i++){
609       Int_t tmpSgleHit2[31];
610       Int_t tmpDbleHit2[31];
611       for (j=0; j<31; j++){
612          tmpSgleHit2[j] = sgleHit2[i+j+1];
613          tmpDbleHit2[j] = dbleHit2[i+j+1];
614       }
615
616       for (Int_t k=0; k<31; k++) {
617          rearImage[i][k]=(sgleHit1[i]&tmpDbleHit2[k])|
618             (dbleHit1[i]&(tmpSgleHit2[k]|tmpDbleHit2[k]));
619       }
620    }
621
622    //-----------
623    if(AliDebugLevel()==3||AliDebugLevel()==5) {
624       printf("===============================================================\n");
625       for (i=30; i>=0; i--) {
626          printf("%i \t",i);
627          for (istrip=31; istrip>=0; istrip--) printf("%i",rearImage[i][istrip]);
628          printf("\n");   
629       }
630    }
631
632 //---------------------------------------------------------
633 // step # 3 : calculate deviation
634 //--------------------------------------------------------- 
635    Int_t dev[31][6];
636    for (i=0; i<31; i++) {
637       for (j=0; j<6; j++) {
638          dev[i][j]=0;
639       }
640    }
641
642    for (i=0; i<31; i++){
643       Int_t leftDev[5], rightDev[5]; 
644       Int_t orL1, andL1, andL2, orR1, orR2, andR1, andR2, andR3;
645
646 // calculate Left deviation
647       orL1=rearImage[i][16]|rearImage[i][18]|rearImage[i][20]|rearImage[i][22];
648       andL1=!rearImage[i][17]&!rearImage[i][19]&!rearImage[i][21] & !orL1; 
649       andL2=!rearImage[i][23]&!rearImage[i][24]&!rearImage[i][25]&!rearImage[i][26];
650  
651       leftDev[0] = (rearImage[i][16]|!rearImage[i][17]) & 
652          (rearImage[i][16]|rearImage[i][18]|!rearImage[i][19]&
653           (rearImage[i][20]|!rearImage[i][21])) &
654          (orL1|!rearImage[i][23]&(rearImage[i][24]|!rearImage[i][25])) & 
655          (orL1|rearImage[i][24]|rearImage[i][26]|!rearImage[i][27]&
656           (rearImage[i][28]|!rearImage[i][29]));
657                                 
658       leftDev[1] = !rearImage[i][16] & 
659          !(!rearImage[i][17]&!rearImage[i][18]&!rearImage[i][21]&!rearImage[i][22] & 
660            (!rearImage[i][25]&!rearImage[i][26]&(rearImage[i][27]|rearImage[i][28]))) &
661          (rearImage[i][17]|rearImage[i][18] | !rearImage[i][19]&!rearImage[i][20]) &
662          (rearImage[i][17]|rearImage[i][18]|rearImage[i][21]|rearImage[i][22] | 
663           !rearImage[i][23]&!rearImage[i][24]);
664                                 
665       leftDev[2] = (!rearImage[i][16]&!rearImage[i][17]&!rearImage[i][18]) & 
666          (rearImage[i][19]|rearImage[i][20]|rearImage[i][21]|rearImage[i][22] | andL2);
667                 
668       leftDev[3] = andL1;
669                 
670       leftDev[4] = 
671          !rearImage[i][27]&!rearImage[i][28]&!rearImage[i][29]&!rearImage[i][30] & 
672          andL1 & andL2;
673
674       // calculate Right deviation
675       orR1=rearImage[i][8]|rearImage[i][10]|rearImage[i][12]|rearImage[i][14];
676       orR2=rearImage[i][8]|rearImage[i][9]|rearImage[i][10]|rearImage[i][11];
677       andR1=!rearImage[i][12]&!rearImage[i][13]&!rearImage[i][14]&!rearImage[i][15];
678       andR2=
679          !rearImage[i][8]&!rearImage[i][9]&!rearImage[i][10]&!rearImage[i][11] & andR1;
680       andR3=!rearImage[i][4]&!rearImage[i][5]&!rearImage[i][6]&!rearImage[i][7]; 
681                 
682       rightDev[0] = !rearImage[i][15]&(rearImage[i][14]|!rearImage[i][13]) & 
683          ((rearImage[i][12]|rearImage[i][14]|!rearImage[i][11]&
684            (rearImage[i][10]|!rearImage[i][9])) &
685           ((orR1|!rearImage[i][7]&(rearImage[i][6]|!rearImage[i][5])) & 
686            (orR1|rearImage[i][4]|rearImage[i][6]|!rearImage[i][3]&(rearImage[i][2]|
687                                                                    !rearImage[i][1]))));
688                                 
689       rightDev[1] = !rearImage[i][15]&!rearImage[i][14] & 
690          !(!rearImage[i][4]&!rearImage[i][5]&!rearImage[i][8]&!rearImage[i][9] &
691            (!rearImage[i][12]&!rearImage[i][13]&(rearImage[i][2]|rearImage[i][3]))) &
692          (rearImage[i][12]|rearImage[i][13] | !rearImage[i][10]&!rearImage[i][11]) & 
693          (rearImage[i][8]|rearImage[i][9]|rearImage[i][12]|rearImage[i][13] | 
694           !rearImage[i][6]&!rearImage[i][7]);
695                 
696       rightDev[2] = andR1 & (orR2 | andR3); 
697       rightDev[3] = andR2;              
698       rightDev[4] = 
699          !rearImage[i][0]&!rearImage[i][1]&!rearImage[i][2]&!rearImage[i][3] & 
700          andR2 & andR3 ;
701
702       // compare Left & Right deviations
703       Int_t tmpLeftDev=0, tmpRightDev=0;
704       for (j=0; j<5; j++){
705          tmpLeftDev  = tmpLeftDev + Int_t(leftDev[j]<<j); 
706          tmpRightDev = tmpRightDev + Int_t(rightDev[j]<<j); 
707       }
708
709       // assign mimimum deviation do dev[][]
710       if (tmpLeftDev < tmpRightDev ){
711          for (j=0; j<5; j++){ dev[i][j]=leftDev[j];}
712          dev[i][5]=1;
713       } else {
714          for (j=0; j<5; j++){ dev[i][j]=rightDev[j];}
715          dev[i][5]=0;
716       }
717    }
718   
719 //---
720    if(AliDebugLevel()==3||AliDebugLevel()==5) {
721       printf("===============================================================\n");
722       for (i=30; i>=0; i--) {
723          printf("%i \t",i);
724          for (istrip=5; istrip>=0; istrip--) printf("%i",dev[i][istrip]);
725          printf(" \n");
726       }
727    }
728
729 //---------------------------------------------------------
730 // step # 4 : sort deviation
731 //--------------------------------------------------------- 
732    Int_t bga1[16], bga2[8], bga3[4], bga4[2], bga5;
733    Int_t tmpbga1[16][6], tmpbga2[8][6], tmpbga3[4][6], tmpbga4[2][6], tmpbga5[6];
734    Int_t tmpMax[6]={1,1,1,1,1,0};
735
736    for (i=0; i<15; i++) {
737       Sort2x5(dev[2*i],dev[2*i+1],tmpbga1[i],bga1[i]);
738    }  
739    Sort2x5(dev[30],tmpMax,tmpbga1[15],bga1[15]);
740
741 //--    
742    if(AliDebugLevel()==3||AliDebugLevel()==5) {
743       printf("===============================================================\n");
744       printf(" sorting : 1st level \n");
745       for (i=15; i>=0; i--) {
746          printf("\t %i \t",bga1[i]);    
747          for (j=5; j>=0; j--) printf("%i",tmpbga1[i][j]); 
748          printf(" \n");
749       }
750    }
751
752    for (i=0; i<8; i++) {  
753       Sort2x5(tmpbga1[2*i],tmpbga1[2*i+1],tmpbga2[i],bga2[i]);
754    }
755
756 //--    
757    if(AliDebugLevel()==3||AliDebugLevel()==5) {
758       printf("===============================================================\n");
759       printf(" sorting : 2nd level \n");
760       for (i=7; i>=0; i--) {
761          printf("\t %i \t",bga2[i]);    
762          for (j=5; j>=0; j--) printf("%i",tmpbga1[i][j]);       
763          printf(" \n");
764       }
765    }
766   
767    for (i=0; i<4; i++) {  
768       Sort2x5(tmpbga2[2*i],tmpbga2[2*i+1],tmpbga3[i],bga3[i]);
769    }
770
771 //--    
772    if(AliDebugLevel()==3||AliDebugLevel()==5) {
773       printf("===============================================================\n");
774       printf(" sorting : 3rd level \n");
775       for (i=3; i>=0; i--) {
776          printf("\t %i \t",bga3[i]);    
777          for (j=5; j>=0; j--) printf("%i",tmpbga3[i][j]); 
778          printf(" \n");
779       }
780    }
781
782    for (i=0; i<2; i++) {  
783       Sort2x5(tmpbga3[2*i],tmpbga3[2*i+1],tmpbga4[i],bga4[i]);
784    }
785
786 //--    
787    if(AliDebugLevel()==3||AliDebugLevel()==5) {
788       printf("===============================================================\n");
789       printf(" sorting : 4th level \n");
790       for (i=1; i>=0; i--) {
791          printf("\t %i \t",bga4[i]);    
792          for (j=5; j>=0; j--) printf("%i",tmpbga4[i][j]);
793          printf(" \n");
794       }
795    }
796   
797    Sort2x5(tmpbga4[0],tmpbga4[1],tmpbga5,bga5);
798
799    // coding from 6 to 5 bits 
800    fMinDev[4] = tmpbga5[5] | tmpbga5[4];
801    for (i=0; i<4; i++) { 
802       fMinDev[i]=tmpbga5[i] & !tmpbga5[4];
803    }
804
805    // find address of strip with minimum deviation 
806    fMinDevStrip[4]=bga5;
807    if (bga5<=1) fMinDevStrip[3]=bga4[bga5];
808
809    Int_t tmpAd=fMinDevStrip[3]+fMinDevStrip[4]*2;
810    if (tmpAd<=3) fMinDevStrip[2]=bga3[tmpAd];
811
812    tmpAd=fMinDevStrip[2]+fMinDevStrip[3]*2+fMinDevStrip[4]*4;
813    if (tmpAd<=7) fMinDevStrip[1]=bga2[tmpAd];
814
815    tmpAd=fMinDevStrip[1]+fMinDevStrip[2]*2+fMinDevStrip[3]*4+fMinDevStrip[4]*8;
816    if (tmpAd<=15) fMinDevStrip[0]=bga1[tmpAd];
817
818    if(AliDebugLevel()==3||AliDebugLevel()==5) {
819       printf("===============================================================\n");
820       printf("minDevStrip = ");
821       for  (i=4; i>=0; i--) printf("%i",fMinDevStrip[i]);
822       printf(" minDev = ");
823       for  (i=4; i>=0; i--) printf("%i",fMinDev[i]); 
824       printf(" \n");
825       printf("===============================================================\n");
826    }
827
828 }
829
830 //___________________________________________
831 void AliMUONLocalTriggerBoard::Sort2x5(Int_t dev1[6], Int_t dev2[6],
832                                        Int_t minDev[6], Int_t &dev1GTdev2)
833
834 // returns minimun between dev1 and dev2
835    Int_t tmpDev1=0, tmpDev2=0;
836
837    for (Int_t j=0; j<5; j++)
838    {
839       tmpDev1 += Int_t(dev1[j]<<j); 
840       tmpDev2 += Int_t(dev2[j]<<j); 
841    }
842
843    if (tmpDev1<=tmpDev2)
844    {
845       for (Int_t j=0; j<=5; j++) minDev[j]=dev1[j];
846       dev1GTdev2=0;
847    } 
848    else 
849    {
850       for (Int_t j=0; j<=5; j++) minDev[j]=dev2[j];
851       dev1GTdev2=1;   
852    }
853 }
854
855 //___________________________________________
856 void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], Int_t y4[16],
857                                      Int_t y3u[16], Int_t y3d[16], Int_t y4u[16], Int_t y4d[16],
858                                      Int_t coinc44)
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 & !coinc44;
1010       sgle2[i] = sgle2[i] & notOr2 & !coinc44;
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, fLutApt);
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(" Apt : ");
1247       for (Int_t i=1; i>=0; i--) printf("%i", fLutApt[i]);
1248       printf("\n");
1249       printf("-------------------------------------------\n");
1250    }      
1251 }
1252
1253 //___________________________________________
1254 void AliMUONLocalTriggerBoard::Response()
1255 {
1256 //* algo
1257 //*
1258    Int_t xX1[16], xX2[16], xXX3[32], xXX4[32];
1259
1260    TBits x1(16), x2(16), x3(16), x4(16);
1261
1262    UShort_t xyv = 0;
1263
1264    xyv = fXY[0][0]; x1.Set(16,&xyv);
1265    xyv = fXY[0][1]; x2.Set(16,&xyv);
1266    xyv = fXY[0][2]; x3.Set(16,&xyv);
1267    xyv = fXY[0][3]; x4.Set(16,&xyv);
1268
1269    TBits x3u(16), x4u(16), x3d(16), x4d(16);
1270
1271    xyv = fXYU[0][2]; x3u.Set(16,&xyv);
1272    xyv = fXYU[0][3]; x4u.Set(16,&xyv);
1273
1274    xyv = fXYD[0][2]; x3d.Set(16,&xyv);
1275    xyv = fXYD[0][3]; x4d.Set(16,&xyv);
1276
1277    for (Int_t i=0;i<16;i++)
1278    {
1279       xX1[i] = x1[i];
1280       xX2[i] = x2[i];
1281       
1282       xXX3[i+8] = x3[i];
1283       xXX4[i+8] = x4[i];  
1284    }
1285
1286    for (Int_t i=0;i<8;i++)
1287    {
1288       xXX3[i] = x3d[i+8];
1289       xXX4[i] = x4d[i+8];
1290
1291       xXX3[i+24] = x3u[i];
1292       xXX4[i+24] = x4u[i];
1293    }
1294    
1295    Int_t coinc44 = 0;
1296    
1297    TrigX(xX1, xX2, xXX3, xXX4, coinc44);   
1298
1299    Int_t yY1[16], yY2[16], yY3[16], yY4[16];
1300    
1301    Int_t yY3U[16], yY3D[16], yY4U[16], yY4D[16];
1302
1303    TBits y1(16), y2(16), y3(16), y4(16);
1304
1305    TBits y3u(16), y3d(16), y4u(16), y4d(16);
1306
1307    xyv = fXY[1][0]; y1.Set(16,&xyv);
1308    xyv = fXY[1][1]; y2.Set(16,&xyv);
1309    xyv = fXY[1][2]; y3.Set(16,&xyv);
1310    xyv = fXY[1][3]; y4.Set(16,&xyv);
1311
1312    xyv = fXYU[1][2]; y3u.Set(16,&xyv);
1313    xyv = fXYD[1][2]; y3d.Set(16,&xyv);
1314    xyv = fXYU[1][3]; y4u.Set(16,&xyv);
1315    xyv = fXYD[1][3]; y4d.Set(16,&xyv);
1316
1317    for (Int_t i=0;i<16;i++)
1318    {
1319       yY1[i] = y1[i];
1320       yY2[i] = y2[i];
1321       yY3[i] = y3[i];
1322       yY4[i] = y4[i];
1323       
1324       yY3U[i] = y3u[i];
1325       yY3D[i] = y3d[i];
1326       
1327       yY4U[i] = y4u[i];
1328       yY4D[i] = y4d[i];
1329    }
1330
1331    TrigY(yY1, yY2, yY3, yY4, yY3U, yY3D, yY4U, yY4D, coinc44);
1332    
1333 // ASIGN fLutLpt, fLutHpt, fLutApt
1334    LocalTrigger(); 
1335
1336    fResponse = fLutApt[0]                      + 
1337                static_cast<int>(fLutApt[1]<<1) + 
1338                static_cast<int>(fLutLpt[0]<<2) + 
1339                static_cast<int>(fLutLpt[1]<<3) + 
1340                static_cast<int>(fLutHpt[0]<<4) + 
1341                static_cast<int>(fLutHpt[1]<<5);
1342 }
1343
1344 ClassImp(AliMUONLocalTriggerBoard)
1345