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 ( TString(GetName()).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    for (i=0; i<16; i++) ch3[i] = ch4[i] = 0;
 985
 986    if (GetSwitch(3)==0&&GetSwitch(4)==0){
 987       for (i=0; i<16; i++){
 988          ch3[i] = tmpy3to16[i];
 989          ch4[i] = tmpy4to16[i];
 990       }
 991    }
 992    if (GetSwitch(3)==0&&GetSwitch(4)==1){
 993       for (i=0; i<16; i++){
 994          ch3[i] = tmpy3dto16[i]|tmpy3to16[i];
 995          ch4[i] = tmpy4dto16[i]|tmpy4to16[i];
 996       }
 997    }
 998    if (GetSwitch(3)==1&&GetSwitch(4)==0){
 999       for (i=0; i<16; i++){
1000          ch3[i] = tmpy3uto16[i]|tmpy3to16[i];
1001          ch4[i] = tmpy4uto16[i]|tmpy4to16[i];
1002       }
1003    }
1004    if (GetSwitch(3)==1&&GetSwitch(4)==1){
1005       for (i=0; i<16; i++){
1006          ch3[i] = tmpy3dto16[i]|tmpy3to16[i]|tmpy3uto16[i];
1007          ch4[i] = tmpy4dto16[i]|tmpy4to16[i]|tmpy4uto16[i];
1008       }
1009    }
1010
1011 // debug
1012    if(AliDebugLevel()==4||AliDebugLevel()==5) {
1013       printf("===============================================================\n");
1014       printf(" Y plane after PreHandling x2m x2u x2d orMud %i %i %i %i %i \n",
1015              GetSwitch(1),GetSwitch(2), GetSwitch(0),GetSwitch(3),GetSwitch(4));
1016       printf("                            ");
1017       for (istrip=15; istrip>=0; istrip--) {
1018          if (istrip>9)  printf("%i",istrip-10*Int_t(istrip/10));
1019          if (istrip<10) printf("%i",istrip);
1020       }
1021       printf("\n YMC11                      ");
1022       for (istrip=15; istrip>=0; istrip--) printf("%i",ch1[istrip]);
1023       printf("\n YMC12                      ");
1024       for (istrip=15; istrip>=0; istrip--) printf("%i",ch2[istrip]);
1025       printf("\n YMC21                      ");
1026       for (istrip=15; istrip>=0; istrip--) printf("%i",ch3[istrip]);
1027       printf("\n YMC22                      ");
1028       for (istrip=15; istrip>=0; istrip--) printf("%i",ch4[istrip]);
1029       printf(" \n");
1030    }
1031 //debug
1032
1033 //---------------------------------------------------------
1034 // step # 2 : calculate sgle and dble, apply DS reduction
1035 //---------------------------------------------------------
1036    Int_t sgle1[16], dble1[16];
1037    Int_t sgle2[16], dble2[16];
1038
1039    // Calculate simple and double hits
1040    for (i=0; i<16; i++) {
1041       dble1[i] = ch1[i] & ch2[i];
1042       dble2[i] = ch3[i] & ch4[i];
1043
1044       sgle1[i] = (ch1[i]|ch2[i]);
1045       sgle2[i] = (ch3[i]|ch4[i]);
1046    }
1047
1048    //debug
1049    if(AliDebugLevel()==4||AliDebugLevel()==5) {
1050       printf("===============================================================\n");
1051       printf(" Y plane after sgle dble \n");
1052       printf("                            ");
1053       for (istrip=15; istrip>=0; istrip--) {
1054          if (istrip>9)  printf("%i",istrip-10*Int_t(istrip/10));
1055          if (istrip<10) printf("%i",istrip);
1056       }
1057       printf("\n SGLE1                      ");
1058       for (istrip=15; istrip>=0; istrip--) printf("%i",sgle1[istrip]);
1059       printf("\n DBLE1                      ");
1060       for (istrip=15; istrip>=0; istrip--) printf("%i",dble1[istrip]);
1061       printf("\n SGLE2                      ");
1062       for (istrip=15; istrip>=0; istrip--) printf("%i",sgle2[istrip]);
1063       printf("\n DBLE2                      ");
1064       for (istrip=15; istrip>=0; istrip--) printf("%i",dble2[istrip]);
1065       printf(" \n");
1066    }
1067    //debug
1068
1069    // DS Reduction
1070    Int_t notOr1, notOr2;
1071
1072    notOr1=!dble1[15] & !dble1[14] & !dble1[13] & !dble1[12] &
1073       !dble1[11] & !dble1[10] & !dble1[9]  & !dble1[8]  &
1074       !dble1[7]  & !dble1[6]  & !dble1[5]  & !dble1[4]  &
1075       !dble1[3]  & !dble1[2]  & !dble1[1]  & !dble1[0];
1076
1077    notOr2=!dble2[15] & !dble2[14] & !dble2[13] & !dble2[12] &
1078       !dble2[11] & !dble2[10] & !dble2[9]  & !dble2[8]  &
1079       !dble2[7]  & !dble2[6]  & !dble2[5]  & !dble2[4]  &
1080       !dble2[3]  & !dble2[2]  & !dble2[1]  & !dble2[0];
1081
1082    for (i=0; i<16; i++) {
1083       sgle1[i] = sgle1[i] & notOr1 & !fCoinc44;
1084       sgle2[i] = sgle2[i] & notOr2 & !fCoinc44;
1085    }
1086
1087 //---------------------------------------------------------
1088 // step # 3 : 3/4 coincidence
1089 //---------------------------------------------------------
1090    Int_t frontImage[16];
1091
1092    for (i=1; i<15; i++) {
1093      frontImage[i] = ((dble1[i] | sgle1[i]) &
1094                       (dble2[i+1] | dble2[i] | dble2[i-1])) |
1095         (dble1[i] & (sgle2[i+1] | sgle2[i] | sgle2[i-1]));
1096    }
1097    frontImage[0] = ((dble1[0] | sgle1[0]) &
1098                     (dble2[1] | dble2[0])) | (dble1[0] & (sgle2[1] | sgle2[0]));
1099
1100    frontImage[15] = ((dble1[15] | sgle1[15]) &
1101                      (dble2[15] | dble2[14])) | (dble1[15] & (sgle2[15] | sgle2[14]));
1102
1103
1104 //debug
1105    if(AliDebugLevel()==4||AliDebugLevel()==5) {
1106       printf("===============================================================\n");
1107       printf(" Y plane frontImage\n");
1108       printf("                            ");
1109       for (istrip=15; istrip>=0; istrip--) {
1110          if (istrip>9)  printf("%i",istrip-10*Int_t(istrip/10));
1111          if (istrip<10) printf("%i",istrip);
1112       }
1113       printf("\n                            ");
1114       for (istrip=15; istrip>=0; istrip--) printf("%i",frontImage[istrip]);
1115       printf("\n");
1116    }
1117 //debug
1118
1119 //---------------------------------------------------------
1120 // step # 4 : Y position
1121 //---------------------------------------------------------
1122    Int_t or1, or2, and1, and2, and3;
1123
1124    or1  = frontImage[7]|frontImage[5]|frontImage[3]|frontImage[1];
1125    or2  = frontImage[7]|frontImage[6]|frontImage[5]|frontImage[4];
1126    and1 = !frontImage[3]&!frontImage[2]&!frontImage[1]&!frontImage[0];
1127    and2 = !frontImage[7]&!frontImage[6]&!frontImage[5]&!frontImage[4] & and1;
1128    and3 = !frontImage[11]&!frontImage[10]&!frontImage[9]&!frontImage[8];
1129
1130    fCoordY[0] = !frontImage[0]&(frontImage[1]|!frontImage[2]) &
1131      (frontImage[3]|frontImage[1]|(!frontImage[4]&(frontImage[5]|!frontImage[6]))) &
1132      (or1|(!frontImage[8]&(frontImage[9]|!frontImage[10]))) &
1133      (or1|frontImage[11]|frontImage[9]|(!frontImage[12]&(frontImage[13]|!frontImage[14])));
1134
1135    fCoordY[1] = !frontImage[0]&!frontImage[1] &
1136       !(!frontImage[11]&!frontImage[10]&!frontImage[7]&!frontImage[6] &
1137         !frontImage[3]&!frontImage[2]&(frontImage[13]|frontImage[12])) &
1138      (frontImage[3]|frontImage[2] | (!frontImage[5]&!frontImage[4])) &
1139       (frontImage[7]|frontImage[6]|frontImage[3]|frontImage[2] |
1140        (!frontImage[9]&!frontImage[8]));
1141
1142    fCoordY[2] = and1 & (or2 | and3);
1143
1144    fCoordY[3] = and2;
1145
1146    fCoordY[4] = !frontImage[15]&!frontImage[14]&!frontImage[13]&!frontImage[12] &
1147       and2 & and3 ;
1148 }
1149
1150 //___________________________________________
1151 void AliMUONLocalTriggerBoard::LocalTrigger()
1152 {
1153 /// L0 trigger after LUT
1154 ///
1155     Int_t deviation=0;
1156     Int_t iStripY=0;
1157     Int_t iStripX=0;
1158     Bool_t xOutput = IsTrigX();
1159     Bool_t yOutput = IsTrigY();
1160
1161    if (xOutput) {
1162       for (Int_t i=0; i<5; i++) iStripX += static_cast<int>( fMinDevStrip[i] << i );
1163       for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
1164       fDev      = deviation;
1165       fStripX11 = iStripX;
1166    }
1167    if (yOutput) {
1168      for (Int_t i=0; i<4; i++) iStripY   += static_cast<int>( fCoordY[i] << i );
1169       fStripY11 = iStripY;
1170       fTrigY    = fCoordY[4];
1171    }
1172
1173 //   cout << " Local Trigger " << " " << fNumber << " " <<
1174 //       xOutput << " " << yOutput << " " << fDev << " " << fStripX11 << " " <<
1175 //       fTrigY << " " << fStripY11 << "\n";
1176
1177    if (xOutput && yOutput){ // trigger in X and Y
1178        fOutput =1;
1179
1180        Int_t sign = 0;
1181        if ( !fMinDev[4] &&  deviation ) sign=-1;
1182        if ( !fMinDev[4] && !deviation ) sign= 0;
1183        if (  fMinDev[4] == 1 )          sign=+1;
1184
1185        deviation *= sign;
1186
1187 //    calculate deviation in [0;+30]
1188        deviation += 15;
1189
1190 //    GET LUT OUTPUT FOR icirc/istripX1/deviation/istripY
1191        fLUT->GetLutOutput(GetNumber(), fStripX11, deviation, fStripY11, fLutLpt, fLutHpt);
1192    }
1193
1194    fResponse = fLutLpt[0]              +
1195        static_cast<int>(fLutLpt[1]<<1) +
1196        static_cast<int>(fLutHpt[0]<<2) +
1197        static_cast<int>(fLutHpt[1]<<3);
1198
1199 }
1200
1201 //___________________________________________
1202 Int_t AliMUONLocalTriggerBoard::GetI() const
1203 {
1204 /// old numbering
1205 ///
1206
1207    const Int_t kMaxfields = 2; char **fields = new char*[kMaxfields];
1208
1209    if ( TString(GetName()).Length() > 100 ) {
1210      AliErrorStream() << "Name too long: " << GetName() << endl;
1211      return 0;
1212    }
1213
1214    char s[100]; strcpy(s, GetName());
1215
1216    Int_t numlines = 0;
1217
1218    for (char *token = strtok(s, "B");
1219         token != NULL;
1220         token = strtok(NULL, " "))
1221    {
1222       fields[numlines] = new char[strlen(token)+1];
1223       strcpy(fields[numlines++], token);
1224    }
1225
1226    TString l(fields[0]);
1227
1228    char copy = l[0];
1229
1230    Int_t lL = atoi(&l[4]), cC = atoi(&l[2]), sS = (copy=='R') ? +1 : -1;
1231
1232    const char *b[4] = {"12", "34", "56", "78"};
1233
1234    Int_t ib = 0;
1235
1236    for (Int_t i=0; i<4; i++) if (!strcmp(fields[1],b[i])) {ib = i; break;} ib++;
1237
1238 // lL=1 ON TOP
1239    lL -= 9; lL = abs(lL); lL++;
1240
1241    Int_t code = 100 * lL + 10 * cC + ib;
1242
1243    code *= sS;
1244
1245    Int_t ic = 0;
1246
1247    for (Int_t i=0; i<234; i++) if (fgkCircuitId[i] == code) {ic = i; break;}
1248
1249    delete [] fields;
1250
1251    return ic;
1252 }
1253
1254 //___________________________________________
1255 void AliMUONLocalTriggerBoard::Mask(Int_t index, UShort_t mask)
1256 {
1257 /// set mask
1258 ///
1259   if ( index >= 0 && index < 2*4 )
1260   {
1261     Int_t i = index/4;
1262     Int_t j = index%4;
1263     fMask[i][j]=mask;
1264   }
1265   else
1266   {
1267     AliError(Form("Index %d out of bounds (max %d)",index,8));
1268   }
1269 }
1270
1271 //___________________________________________
1272 void AliMUONLocalTriggerBoard::Scan(Option_t *option) const
1273 {
1274 /// full dump
1275 ///
1276     TString op = option;
1277
1278    if (op.Contains("CONF")) Conf();
1279
1280    if (op.Contains("BITP")) Pattern();
1281
1282    if (op.Contains("RESPI")) Resp("I");
1283
1284    if (op.Contains("RESPF")) Resp("F");
1285
1286    if (op.Contains("RESPO")) Resp("O");
1287
1288    if (op.Contains("ALL"))
1289    {
1290       Conf();
1291       Pattern();
1292       Resp("I");
1293       Resp("F");
1294    }
1295 }
1296
1297 //___________________________________________
1298 void AliMUONLocalTriggerBoard::Conf() const
1299 {
1300 /// board switches
1301 ///
1302    cout << "Switch(" << GetName() << ")"
1303         << " x2d = "           << GetSwitch(0)
1304         << " x2m = "           << GetSwitch(1)
1305         << " x2u = "           << GetSwitch(2)
1306         << " OR[0] = "         << GetSwitch(3)
1307         << " OR[1] = "         << GetSwitch(4)
1308         << " EN-Y = "          << GetSwitch(5)
1309         << " ZERO-ALLY-LSB = " << GetSwitch(6)
1310         << " ZERO-down = "     << GetSwitch(7)
1311         << " ZERO-middle = "   << GetSwitch(8)
1312         << " ZERO-up = "       << GetSwitch(9)
1313         << " trans. conn. "    << GetTC()
1314         << " Slot = "          << fSlot
1315         << endl;
1316 }
1317
1318 //___________________________________________
1319 void AliMUONLocalTriggerBoard::Resp(Option_t *option) const
1320 {
1321 /// board I/O
1322 ///
1323    TString op = option;
1324
1325    if (op.Contains("I"))
1326    {
1327 //    print Local trigger output before the LuT step
1328       printf("===============================================================\n");
1329       printf("-------- TRIGGER OUTPUT --------\n");
1330       printf("minDevStrip = ");
1331       for  (Int_t i=4; i>=0; i--) printf("%i",fMinDevStrip[i]);
1332       printf(" minDev = ");
1333       for  (Int_t i=4; i>=0; i--) printf("%i",fMinDev[i]);
1334       printf(" coordY = ");
1335       for  (Int_t i=4; i>=0; i--) printf("%i",fCoordY[i]);
1336       printf(" \n");
1337    }
1338    if (op.Contains("O")){
1339      printf("-- Output --\n");
1340      printf("Coinc44 %i\n", fCoinc44);
1341      printf("StripX11 %i  StripY11 %i  Dev %i  TrigY %i\n", fStripX11, fStripY11, fDev, fTrigY);
1342      printf("LutLpt %i %i  LutHpt %i %i\n", fLutLpt[0], fLutLpt[1], fLutHpt[0], fLutHpt[1]);
1343      printf("Response %i\n", fOutput);
1344    }
1345
1346 }
1347
1348 //___________________________________________
1349 void AliMUONLocalTriggerBoard::Response()
1350 {
1351 /// algo
1352 ///
1353   if ( IsNull() ) {
1354     fMinDev[4] = 1;
1355     for  (Int_t i=4; i>=0; i--) fCoordY[i] = 1;
1356     return; // Do nothing if strip pattern is null
1357   }
1358
1359    Int_t xX1[16], xX2[16], xXX3[32], xXX4[32];
1360
1361    TBits x1(16), x2(16), x3(16), x4(16);
1362
1363    UShort_t xyv = 0;
1364
1365    xyv = fXY[0][0]; x1.Set(16,&xyv);
1366    xyv = fXY[0][1]; x2.Set(16,&xyv);
1367    xyv = fXY[0][2]; x3.Set(16,&xyv);
1368    xyv = fXY[0][3]; x4.Set(16,&xyv);
1369
1370    TBits x3u(16), x4u(16), x3d(16), x4d(16);
1371
1372    xyv = fXYU[0][2]; x3u.Set(16,&xyv);
1373    xyv = fXYU[0][3]; x4u.Set(16,&xyv);
1374
1375    xyv = fXYD[0][2]; x3d.Set(16,&xyv);
1376    xyv = fXYD[0][3]; x4d.Set(16,&xyv);
1377
1378    for (Int_t i=0;i<16;i++)
1379    {
1380       xX1[i] = x1[i];
1381       xX2[i] = x2[i];
1382
1383       xXX3[i+8] = x3[i];
1384       xXX4[i+8] = x4[i];
1385    }
1386
1387    for (Int_t i=0;i<8;i++)
1388    {
1389       xXX3[i] = x3d[i+8];
1390       xXX4[i] = x4d[i+8];
1391
1392       xXX3[i+24] = x3u[i];
1393       xXX4[i+24] = x4u[i];
1394    }
1395
1396 //   Int_t coinc44 = 0;
1397
1398    TrigX(xX1, xX2, xXX3, xXX4);
1399
1400    Int_t yY1[16], yY2[16], yY3[16], yY4[16];
1401
1402    Int_t yY3U[16], yY3D[16], yY4U[16], yY4D[16];
1403
1404    TBits y1(16), y2(16), y3(16), y4(16);
1405
1406    TBits y3u(16), y3d(16), y4u(16), y4d(16);
1407
1408    xyv = fXY[1][0]; y1.Set(16,&xyv);
1409    xyv = fXY[1][1]; y2.Set(16,&xyv);
1410    xyv = fXY[1][2]; y3.Set(16,&xyv);
1411    xyv = fXY[1][3]; y4.Set(16,&xyv);
1412
1413    xyv = fXYU[1][2]; y3u.Set(16,&xyv);
1414    xyv = fXYD[1][2]; y3d.Set(16,&xyv);
1415    xyv = fXYU[1][3]; y4u.Set(16,&xyv);
1416    xyv = fXYD[1][3]; y4d.Set(16,&xyv);
1417
1418    for (Int_t i=0;i<16;i++)
1419    {
1420       yY1[i] = y1[i];
1421       yY2[i] = y2[i];
1422       yY3[i] = y3[i];
1423       yY4[i] = y4[i];
1424
1425       yY3U[i] = y3u[i];
1426       yY3D[i] = y3d[i];
1427
1428       yY4U[i] = y4u[i];
1429       yY4D[i] = y4d[i];
1430    }
1431
1432    TrigY(yY1, yY2, yY3, yY4, yY3U, yY3D, yY4U, yY4D);
1433
1434 // ASIGN fLutLpt, fLutHpt
1435    LocalTrigger();
1436 }
1437
1438 //___________________________________________
1439 Bool_t AliMUONLocalTriggerBoard::IsTrigY() const
1440 {
1441   /// Return the response of non-bending plane
1442   Int_t iStripY = 0;
1443   Bool_t output = kFALSE;
1444
1445   for (Int_t i=0; i<4; i++) iStripY   += static_cast<int>( fCoordY[i] << i );
1446
1447   if (fCoordY[4]==1 && iStripY==15) output=kFALSE; // no trigger in Y
1448   else output=kTRUE;                               // trigger in Y
1449
1450   return output;
1451 }
1452
1453 //___________________________________________
1454 Bool_t AliMUONLocalTriggerBoard::IsTrigX() const
1455 {
1456   /// Return the response of bending plane
1457
1458   Int_t deviation = 0;
1459   Bool_t output = kFALSE;
1460
1461   for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
1462
1463   if (fMinDev[4]==1 && !deviation) output=kFALSE;  // no trigger in X
1464   else output=kTRUE;                               // trigger in X
1465
1466   return output;
1467 }
1468
1469 //___________________________________________
1470 Bool_t AliMUONLocalTriggerBoard::IsNull() const
1471 {
1472   /// Check if board has fired strips in the first station
1473   for (Int_t icath=0; icath<2; icath++){
1474     for(Int_t ich=0; ich<2; ich++){
1475       if ( fXY[icath][ich] ) return kFALSE;
1476     }
1477   }
1478   return kTRUE;
1479 }