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