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