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