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