MUON/AliMUONLocalTriggerBoard.cxx

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