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