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       const char *x[4] = {"XMC11","XMC12","XMC21","XMC22"};
 276       const 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 = IsTrigX();
1059     Bool_t yOutput = IsTrigY();
1060
1061    if (xOutput) {
1062       for (Int_t i=0; i<5; i++) iStripX += static_cast<int>( fMinDevStrip[i] << i );
1063       for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
1064       fDev      = deviation;
1065       fStripX11 = iStripX;
1066    }
1067    if (yOutput) {
1068      for (Int_t i=0; i<4; i++) iStripY   += static_cast<int>( fCoordY[i] << i );
1069       fStripY11 = iStripY;
1070       fTrigY    = fCoordY[4];
1071    }
1072
1073 //   cout << " Local Trigger " << " " << fNumber << " " <<
1074 //       xOutput << " " << yOutput << " " << fDev << " " << fStripX11 << " " <<
1075 //       fTrigY << " " << fStripY11 << "\n";
1076
1077    if (xOutput && yOutput){ // trigger in X and Y
1078        fOutput =1;
1079
1080        Int_t sign = 0;
1081        if ( !fMinDev[4] &&  deviation ) sign=-1;
1082        if ( !fMinDev[4] && !deviation ) sign= 0;
1083        if (  fMinDev[4] == 1 )          sign=+1;
1084
1085        deviation *= sign;
1086
1087 //    calculate deviation in [0;+30]
1088        deviation += 15;
1089
1090 //    GET LUT OUTPUT FOR icirc/istripX1/deviation/istripY
1091        fLUT->GetLutOutput(GetNumber(), fStripX11, deviation, fStripY11, fLutLpt, fLutHpt);
1092    }
1093
1094    fResponse = fLutLpt[0]              +
1095        static_cast<int>(fLutLpt[1]<<1) +
1096        static_cast<int>(fLutHpt[0]<<2) +
1097        static_cast<int>(fLutHpt[1]<<3);
1098
1099 }
1100
1101 //___________________________________________
1102 Int_t AliMUONLocalTriggerBoard::GetI() const
1103 {
1104 /// old numbering
1105 ///
1106    const Int_t kMaxfields = 2; char **fields = new char*[kMaxfields];
1107
1108    char s[100]; strcpy(s, GetName());
1109
1110    Int_t numlines = 0;
1111
1112    for (char *token = strtok(s, "B");
1113         token != NULL;
1114         token = strtok(NULL, " "))
1115    {
1116       fields[numlines] = new char[strlen(token)+1];
1117       strcpy(fields[numlines++], token);
1118    }
1119
1120    TString l(fields[0]);
1121
1122    char copy = l[0];
1123
1124    Int_t lL = atoi(&l[4]), cC = atoi(&l[2]), sS = (copy=='R') ? +1 : -1;
1125
1126    const char *b[4] = {"12", "34", "56", "78"};
1127
1128    Int_t ib = 0;
1129
1130    for (Int_t i=0; i<4; i++) if (!strcmp(fields[1],b[i])) {ib = i; break;} ib++;
1131
1132 // lL=1 ON TOP
1133    lL -= 9; lL = abs(lL); lL++;
1134
1135    Int_t code = 100 * lL + 10 * cC + ib;
1136
1137    code *= sS;
1138
1139    Int_t ic = 0;
1140
1141    for (Int_t i=0; i<234; i++) if (fgkCircuitId[i] == code) {ic = i; break;}
1142
1143    return ic;
1144 }
1145
1146 //___________________________________________
1147 void AliMUONLocalTriggerBoard::Mask(Int_t index, UShort_t mask)
1148 {
1149 /// set mask
1150 ///
1151   if ( index >= 0 && index < 2*4 )
1152   {
1153     Int_t i = index/4;
1154     Int_t j = index - i*4;
1155     fMask[i][j]=mask;
1156   }
1157   else
1158   {
1159     AliError(Form("Index %d out of bounds (max %d)",index,8));
1160   }
1161 }
1162
1163 //___________________________________________
1164 void AliMUONLocalTriggerBoard::Scan(Option_t *option) const
1165 {
1166 /// full dump
1167 ///
1168     TString op = option;
1169
1170    if (op.Contains("CONF")) Conf();
1171
1172    if (op.Contains("BITP")) Pattern();
1173
1174    if (op.Contains("RESPI")) Resp("I");
1175
1176    if (op.Contains("RESPF")) Resp("F");
1177
1178    if (op.Contains("ALL"))
1179    {
1180       Conf();
1181       Pattern();
1182       Resp("I");
1183       Resp("F");
1184    }
1185 }
1186
1187 //___________________________________________
1188 void AliMUONLocalTriggerBoard::Conf() const
1189 {
1190 /// board switches
1191 ///
1192    cout << "Switch(" << GetName() << ")"
1193         << " x2d = "           << GetSwitch(0)
1194         << " x2m = "           << GetSwitch(1)
1195         << " x2u = "           << GetSwitch(2)
1196         << " OR[0] = "         << GetSwitch(3)
1197         << " OR[1] = "         << GetSwitch(4)
1198         << " EN-Y = "          << GetSwitch(5)
1199         << " ZERO-ALLY-LSB = " << GetSwitch(6)
1200         << " ZERO-down = "     << GetSwitch(7)
1201         << " ZERO-middle = "   << GetSwitch(8)
1202         << " ZERO-up = "       << GetSwitch(9)
1203         << " trans. conn. "    << GetTC()
1204         << " Slot = "          << fSlot
1205         << endl;
1206 }
1207
1208 //___________________________________________
1209 void AliMUONLocalTriggerBoard::Resp(Option_t *option) const
1210 {
1211 /// board I/O
1212 ///
1213    TString op = option;
1214
1215    if (op.Contains("I"))
1216    {
1217 //    print Local trigger output before the LuT step
1218       printf("===============================================================\n");
1219       printf("-------- TRIGGER OUTPUT --------\n");
1220       printf("minDevStrip = ");
1221       for  (Int_t i=4; i>=0; i--) printf("%i",fMinDevStrip[i]);
1222       printf(" minDev = ");
1223       for  (Int_t i=4; i>=0; i--) printf("%i",fMinDev[i]);
1224       printf(" coordY = ");
1225       for  (Int_t i=4; i>=0; i--) printf("%i",fCoordY[i]);
1226       printf(" \n");
1227    }
1228
1229 }
1230
1231 //___________________________________________
1232 void AliMUONLocalTriggerBoard::Response()
1233 {
1234 /// algo
1235 ///
1236    Int_t xX1[16], xX2[16], xXX3[32], xXX4[32];
1237
1238    TBits x1(16), x2(16), x3(16), x4(16);
1239
1240    UShort_t xyv = 0;
1241
1242    xyv = fXY[0][0]; x1.Set(16,&xyv);
1243    xyv = fXY[0][1]; x2.Set(16,&xyv);
1244    xyv = fXY[0][2]; x3.Set(16,&xyv);
1245    xyv = fXY[0][3]; x4.Set(16,&xyv);
1246
1247    TBits x3u(16), x4u(16), x3d(16), x4d(16);
1248
1249    xyv = fXYU[0][2]; x3u.Set(16,&xyv);
1250    xyv = fXYU[0][3]; x4u.Set(16,&xyv);
1251
1252    xyv = fXYD[0][2]; x3d.Set(16,&xyv);
1253    xyv = fXYD[0][3]; x4d.Set(16,&xyv);
1254
1255    for (Int_t i=0;i<16;i++)
1256    {
1257       xX1[i] = x1[i];
1258       xX2[i] = x2[i];
1259
1260       xXX3[i+8] = x3[i];
1261       xXX4[i+8] = x4[i];
1262    }
1263
1264    for (Int_t i=0;i<8;i++)
1265    {
1266       xXX3[i] = x3d[i+8];
1267       xXX4[i] = x4d[i+8];
1268
1269       xXX3[i+24] = x3u[i];
1270       xXX4[i+24] = x4u[i];
1271    }
1272
1273 //   Int_t coinc44 = 0;
1274
1275    TrigX(xX1, xX2, xXX3, xXX4);
1276
1277    Int_t yY1[16], yY2[16], yY3[16], yY4[16];
1278
1279    Int_t yY3U[16], yY3D[16], yY4U[16], yY4D[16];
1280
1281    TBits y1(16), y2(16), y3(16), y4(16);
1282
1283    TBits y3u(16), y3d(16), y4u(16), y4d(16);
1284
1285    xyv = fXY[1][0]; y1.Set(16,&xyv);
1286    xyv = fXY[1][1]; y2.Set(16,&xyv);
1287    xyv = fXY[1][2]; y3.Set(16,&xyv);
1288    xyv = fXY[1][3]; y4.Set(16,&xyv);
1289
1290    xyv = fXYU[1][2]; y3u.Set(16,&xyv);
1291    xyv = fXYD[1][2]; y3d.Set(16,&xyv);
1292    xyv = fXYU[1][3]; y4u.Set(16,&xyv);
1293    xyv = fXYD[1][3]; y4d.Set(16,&xyv);
1294
1295    for (Int_t i=0;i<16;i++)
1296    {
1297       yY1[i] = y1[i];
1298       yY2[i] = y2[i];
1299       yY3[i] = y3[i];
1300       yY4[i] = y4[i];
1301
1302       yY3U[i] = y3u[i];
1303       yY3D[i] = y3d[i];
1304
1305       yY4U[i] = y4u[i];
1306       yY4D[i] = y4d[i];
1307    }
1308
1309    TrigY(yY1, yY2, yY3, yY4, yY3U, yY3D, yY4U, yY4D);
1310
1311 // ASIGN fLutLpt, fLutHpt
1312    LocalTrigger();
1313 }
1314
1315 //___________________________________________
1316 Bool_t AliMUONLocalTriggerBoard::IsTrigY() const
1317 {
1318   /// Return the response of non-bending plane
1319   Int_t iStripY = 0;
1320   Bool_t output = kFALSE;
1321
1322   for (Int_t i=0; i<4; i++) iStripY   += static_cast<int>( fCoordY[i] << i );
1323
1324   if (fCoordY[4]==1 && iStripY==15) output=kFALSE; // no trigger in Y
1325   else output=kTRUE;                               // trigger in Y
1326
1327   return output;
1328 }
1329
1330 //___________________________________________
1331 Bool_t AliMUONLocalTriggerBoard::IsTrigX() const
1332 {
1333   /// Return the response of bending plane
1334
1335   Int_t deviation = 0;
1336   Bool_t output = kFALSE;
1337
1338   for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
1339
1340   if (fMinDev[4]==1 && !deviation) output=kFALSE;  // no trigger in X
1341   else output=kTRUE;                               // trigger in X
1342
1343   return output;
1344 }