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