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