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    char s[100]; strncpy(s, GetName(), 99);
1181
1182    Int_t numlines = 0;
1183
1184    for (char *token = strtok(s, "B");
1185         token != NULL;
1186         token = strtok(NULL, " "))
1187    {
1188       fields[numlines] = new char[strlen(token)+1];
1189       strcpy(fields[numlines++], token);
1190    }
1191
1192    TString l(fields[0]);
1193
1194    char copy = l[0];
1195
1196    Int_t lL = atoi(&l[4]), cC = atoi(&l[2]), sS = (copy=='R') ? +1 : -1;
1197
1198    const char *b[4] = {"12", "34", "56", "78"};
1199
1200    Int_t ib = 0;
1201
1202    for (Int_t i=0; i<4; i++) if (!strcmp(fields[1],b[i])) {ib = i; break;} ib++;
1203
1204 // lL=1 ON TOP
1205    lL -= 9; lL = abs(lL); lL++;
1206
1207    Int_t code = 100 * lL + 10 * cC + ib;
1208
1209    code *= sS;
1210
1211    Int_t ic = 0;
1212
1213    for (Int_t i=0; i<234; i++) if (fgkCircuitId[i] == code) {ic = i; break;}
1214
1215    delete [] fields;
1216
1217    return ic;
1218 }
1219
1220 //___________________________________________
1221 void AliMUONLocalTriggerBoard::Mask(Int_t index, UShort_t mask)
1222 {
1223 /// set mask
1224 ///
1225   if ( index >= 0 && index < 2*4 )
1226   {
1227     Int_t i = index/4;
1228     Int_t j = index%4;
1229     fMask[i][j]=mask;
1230   }
1231   else
1232   {
1233     AliError(Form("Index %d out of bounds (max %d)",index,8));
1234   }
1235 }
1236
1237 //___________________________________________
1238 void AliMUONLocalTriggerBoard::Scan(Option_t *option) const
1239 {
1240 /// full dump
1241 ///
1242     TString op = option;
1243
1244    if (op.Contains("CONF")) Conf();
1245
1246    if (op.Contains("BITP")) Pattern();
1247
1248    if (op.Contains("RESPI")) Resp("I");
1249
1250    if (op.Contains("RESPF")) Resp("F");
1251
1252    if (op.Contains("RESPO")) Resp("O");
1253
1254    if (op.Contains("ALL"))
1255    {
1256       Conf();
1257       Pattern();
1258       Resp("I");
1259       Resp("F");
1260    }
1261 }
1262
1263 //___________________________________________
1264 void AliMUONLocalTriggerBoard::Conf() const
1265 {
1266 /// board switches
1267 ///
1268    cout << "Switch(" << GetName() << ")"
1269         << " x2d = "           << GetSwitch(0)
1270         << " x2m = "           << GetSwitch(1)
1271         << " x2u = "           << GetSwitch(2)
1272         << " OR[0] = "         << GetSwitch(3)
1273         << " OR[1] = "         << GetSwitch(4)
1274         << " EN-Y = "          << GetSwitch(5)
1275         << " ZERO-ALLY-LSB = " << GetSwitch(6)
1276         << " ZERO-down = "     << GetSwitch(7)
1277         << " ZERO-middle = "   << GetSwitch(8)
1278         << " ZERO-up = "       << GetSwitch(9)
1279         << " trans. conn. "    << GetTC()
1280         << " Slot = "          << fSlot
1281         << endl;
1282 }
1283
1284 //___________________________________________
1285 void AliMUONLocalTriggerBoard::Resp(Option_t *option) const
1286 {
1287 /// board I/O
1288 ///
1289    TString op = option;
1290
1291    if (op.Contains("I"))
1292    {
1293 //    print Local trigger output before the LuT step
1294       printf("===============================================================\n");
1295       printf("-------- TRIGGER OUTPUT --------\n");
1296       printf("minDevStrip = ");
1297       for  (Int_t i=4; i>=0; i--) printf("%i",fMinDevStrip[i]);
1298       printf(" minDev = ");
1299       for  (Int_t i=4; i>=0; i--) printf("%i",fMinDev[i]);
1300       printf(" coordY = ");
1301       for  (Int_t i=4; i>=0; i--) printf("%i",fCoordY[i]);
1302       printf(" \n");
1303    }
1304    if (op.Contains("O")){
1305      printf("-- Output --\n");
1306      printf("Coinc44 %i\n", fCoinc44);
1307      printf("StripX11 %i  StripY11 %i  Dev %i  TrigY %i\n", fStripX11, fStripY11, fDev, fTrigY);
1308      printf("LutLpt %i %i  LutHpt %i %i\n", fLutLpt[0], fLutLpt[1], fLutHpt[0], fLutHpt[1]);
1309      printf("Response %i\n", fOutput);
1310    }
1311
1312 }
1313
1314 //___________________________________________
1315 void AliMUONLocalTriggerBoard::Response()
1316 {
1317 /// algo
1318 ///
1319   if ( IsNull() ) {
1320     fMinDev[4] = 1;
1321     for  (Int_t i=4; i>=0; i--) fCoordY[i] = 1;
1322     return; // Do nothing if strip pattern is null
1323   }
1324
1325    Int_t xX1[16], xX2[16], xXX3[32], xXX4[32];
1326
1327    TBits x1(16), x2(16), x3(16), x4(16);
1328
1329    UShort_t xyv = 0;
1330
1331    xyv = fXY[0][0]; x1.Set(16,&xyv);
1332    xyv = fXY[0][1]; x2.Set(16,&xyv);
1333    xyv = fXY[0][2]; x3.Set(16,&xyv);
1334    xyv = fXY[0][3]; x4.Set(16,&xyv);
1335
1336    TBits x3u(16), x4u(16), x3d(16), x4d(16);
1337
1338    xyv = fXYU[0][2]; x3u.Set(16,&xyv);
1339    xyv = fXYU[0][3]; x4u.Set(16,&xyv);
1340
1341    xyv = fXYD[0][2]; x3d.Set(16,&xyv);
1342    xyv = fXYD[0][3]; x4d.Set(16,&xyv);
1343
1344    for (Int_t i=0;i<16;i++)
1345    {
1346       xX1[i] = x1[i];
1347       xX2[i] = x2[i];
1348
1349       xXX3[i+8] = x3[i];
1350       xXX4[i+8] = x4[i];
1351    }
1352
1353    for (Int_t i=0;i<8;i++)
1354    {
1355       xXX3[i] = x3d[i+8];
1356       xXX4[i] = x4d[i+8];
1357
1358       xXX3[i+24] = x3u[i];
1359       xXX4[i+24] = x4u[i];
1360    }
1361
1362 //   Int_t coinc44 = 0;
1363
1364    TrigX(xX1, xX2, xXX3, xXX4);
1365
1366    Int_t yY1[16], yY2[16], yY3[16], yY4[16];
1367
1368    Int_t yY3U[16], yY3D[16], yY4U[16], yY4D[16];
1369
1370    TBits y1(16), y2(16), y3(16), y4(16);
1371
1372    TBits y3u(16), y3d(16), y4u(16), y4d(16);
1373
1374    xyv = fXY[1][0]; y1.Set(16,&xyv);
1375    xyv = fXY[1][1]; y2.Set(16,&xyv);
1376    xyv = fXY[1][2]; y3.Set(16,&xyv);
1377    xyv = fXY[1][3]; y4.Set(16,&xyv);
1378
1379    xyv = fXYU[1][2]; y3u.Set(16,&xyv);
1380    xyv = fXYD[1][2]; y3d.Set(16,&xyv);
1381    xyv = fXYU[1][3]; y4u.Set(16,&xyv);
1382    xyv = fXYD[1][3]; y4d.Set(16,&xyv);
1383
1384    for (Int_t i=0;i<16;i++)
1385    {
1386       yY1[i] = y1[i];
1387       yY2[i] = y2[i];
1388       yY3[i] = y3[i];
1389       yY4[i] = y4[i];
1390
1391       yY3U[i] = y3u[i];
1392       yY3D[i] = y3d[i];
1393
1394       yY4U[i] = y4u[i];
1395       yY4D[i] = y4d[i];
1396    }
1397
1398    TrigY(yY1, yY2, yY3, yY4, yY3U, yY3D, yY4U, yY4D);
1399
1400 // ASIGN fLutLpt, fLutHpt
1401    LocalTrigger();
1402 }
1403
1404 //___________________________________________
1405 Bool_t AliMUONLocalTriggerBoard::IsTrigY() const
1406 {
1407   /// Return the response of non-bending plane
1408   Int_t iStripY = 0;
1409   Bool_t output = kFALSE;
1410
1411   for (Int_t i=0; i<4; i++) iStripY   += static_cast<int>( fCoordY[i] << i );
1412
1413   if (fCoordY[4]==1 && iStripY==15) output=kFALSE; // no trigger in Y
1414   else output=kTRUE;                               // trigger in Y
1415
1416   return output;
1417 }
1418
1419 //___________________________________________
1420 Bool_t AliMUONLocalTriggerBoard::IsTrigX() const
1421 {
1422   /// Return the response of bending plane
1423
1424   Int_t deviation = 0;
1425   Bool_t output = kFALSE;
1426
1427   for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
1428
1429   if (fMinDev[4]==1 && !deviation) output=kFALSE;  // no trigger in X
1430   else output=kTRUE;                               // trigger in X
1431
1432   return output;
1433 }
1434
1435 //___________________________________________
1436 Bool_t AliMUONLocalTriggerBoard::IsNull() const
1437 {
1438   /// Check if board has fired strips in the first station
1439   for (Int_t icath=0; icath<2; icath++){
1440     for(Int_t ich=0; ich<2; ich++){
1441       if ( fXY[icath][ich] ) return kFALSE;
1442     }
1443   }
1444   return kTRUE;
1445 }