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