MUON/AliMUONLocalTriggerBoard.cxx

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