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