- Disentangle masks effect from trigger chamber efficiency estimation.
[u/mrichter/AliRoot.git] / MUON / AliMUONLocalTriggerBoard.cxx
index a5d05a4..423789b 100644 (file)
 
 /* $Id$ */
 
-//_________________________________________________________________________
-// Implementation of local trigger board objects
-// A local trigger board has as input a bit pattern and returns 
-// the local trigger response after comparison w/ a LUT
-//
-//*-- Author: Rachid Guernane (LPCCFd)
-
+//-----------------------------------------------------------------------------
+/// \class AliMUONLocalTriggerBoard
+/// A local trigger board has as input a bit pattern and returns 
+/// the local trigger response after comparison w/ a LUT
+/// \todo Change member functions comments in capital letters to normal text
+///
+/// \author Rachid Guernane (LPCCFd)
+//-----------------------------------------------------------------------------
+
+#include <cstdlib>
 #include "AliMUONLocalTriggerBoard.h"
 #include "AliMUONTriggerLut.h"
-#include "AliMUONTriggerConstants.h"
+
 #include "AliLog.h"
 
 #include <TBits.h>
-
 #include <Riostream.h>
 
+/// \cond CLASSIMP
+ClassImp(AliMUONLocalTriggerBoard)
+/// \endcond
+
+const Int_t AliMUONLocalTriggerBoard::fgkCircuitId[234] = 
+{
+  111,  121,  131,  141,  151,  161,  171,
+  211,  212,  221,  222,  231,  232,  241,  242,  251,  252,  261,  262,  271,
+  311,  312,  321,  322,  331,  332,  341,  342,  351,  352,  361,  362,  371,
+  411,  412,  413,  421,  422,  423,  424,  431,  432,  433,  434,  441,  442,  451,  452,  461,  462,  471,
+  521,  522,  523,  524,  531,  532,  533,  534,  541,  542,  551,  552,  561,  562,  571, 
+  611,  612,  613,  621,  622,  623,  624,  631,  632,  633,  634,  641,  642,  651,  652,  661,  662,  671,
+  711,  712,  721,  722,  731,  732,  741,  742,  751,  752,  761,  762,  771,
+  811,  812,  821,  822,  831,  832,  841,  842,  851,  852,  861,  862,  871,
+  911,  921,  931,  941,  951,  961,  971,
+  -111, -121, -131, -141, -151, -161, -171,
+  -211, -212, -221, -222, -231, -232, -241, -242, -251, -252, -261, -262, -271,
+  -311, -312, -321, -322, -331, -332, -341, -342, -351, -352, -361, -362, -371,
+  -411, -412, -413, -421, -422, -423, -424, -431, -432, -433, -434, -441, -442, -451, -452, -461, -462, -471,
+  -521, -522, -523, -524, -531, -532, -533, -534, -541, -542, -551, -552, -561, -562, -571, 
+  -611, -612, -613, -621, -622, -623, -624, -631, -632, -633, -634, -641, -642, -651, -652, -661, -662, -671,
+  -711, -712, -721, -722, -731, -732, -741, -742, -751, -752, -761, -762, -771,
+  -811, -812, -821, -822, -831, -832, -841, -842, -851, -852, -861, -862, -871,
+  -911, -921, -931, -941, -951, -961, -971 
+};
+
 //___________________________________________
 AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard()
-: AliMUONTriggerBoard()
+    : AliMUONTriggerBoard(),
+      fMpLocalBoard(0x0),
+      fStripX11(0),
+      fStripY11(15),
+      fDev(0),
+      fTrigY(1),
+      fOutput(0),
+      fLUT(0x0),
+      fCoinc44(0)
 {
-   fNumber = 0;
-
+/// default constructor
+///
+   
    for (Int_t i=0; i<2; i++) 
       for (Int_t j=0; j<4; j++) 
       {
@@ -45,27 +82,25 @@ AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard()
          fMask[i][j] = 0xFFFF;
       }
 
-   for (Int_t i=0; i<10; i++) fSwitch[i] = 0;
-
-   fTC = kTRUE;
-
-   fLUT = 0x0;
-
    for (Int_t i=0; i<5; i++) fMinDevStrip[i] = fMinDev[i] = fCoordY[i] = 0;
 
-   fOutput = 0;
-   
-   fStripX11 = fStripY11 = fDev = 0;
-
-   for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = fLutApt[i] = 0;
+   for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = 0;
 }
 
 //___________________________________________
-AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(const char *name, Int_t a,
-                                                   AliMUONTriggerLut* lut) 
-: AliMUONTriggerBoard(name, a)
+AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(AliMpLocalBoard* mpLocalBoard)
+    : AliMUONTriggerBoard(mpLocalBoard->GetName(), mpLocalBoard->GetSlot()),
+      fMpLocalBoard(mpLocalBoard),
+      fStripX11(0),
+      fStripY11(15),
+      fDev(0),
+      fTrigY(1),
+      fOutput(0),
+      fLUT(0x0),
+      fCoinc44(0)
 {
-   fNumber = 0;
+/// Standard constructor
+///
    
    for (Int_t i=0; i<2; i++) 
       for (Int_t j=0; j<4; j++) 
@@ -75,66 +110,147 @@ AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(const char *name, Int_t a,
          fMask[i][j] = 0xFFFF;
       }
 
-   for (Int_t i=0; i<10; i++) fSwitch[i] = 0;
-
-   fTC = kTRUE;
+   for (Int_t i=0; i<5; i++) fMinDevStrip[i] = fMinDev[i] = fCoordY[i] = 0;
 
-   fLUT = lut;
+   for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = 0;
+}
 
-   for (Int_t i=0; i<5; i++) fMinDevStrip[i] = fMinDev[i] = fCoordY[i] = 0;
+//___________________________________________
+AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(const AliMUONLocalTriggerBoard& right) :
+  AliMUONTriggerBoard(right),
+  fMpLocalBoard(right.fMpLocalBoard),
+  fStripX11(right.fStripX11),
+  fStripY11(right.fStripY11),
+  fDev(right.fDev),
+  fTrigY(right.fTrigY),
+  fOutput(right.fOutput),
+  fLUT(right.fLUT),
+  fCoinc44(right.fCoinc44)
+{
+  //
+  /// Copy constructor
+  //
+  for (Int_t i=0; i<2; i++) {
+    for (Int_t j=0; j<4; j++) {
+      fXY[i][j]  = right.fXY[i][j];
+      fXYU[i][j] = right.fXYU[i][j];
+      fXYD[i][j] = right.fXYD[i][j];
+
+      fMask[i][j] = right.fMask[i][j];
+    }
+  }
 
-   fOutput = 0;
-   
-   fStripX11 = fStripY11 = fDev = 0;
+  for (Int_t i=0; i<2; i++) {
+    fLutLpt[i] = right.fLutLpt[i];
+    fLutHpt[i] = right.fLutHpt[i];
+  }
 
-   for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = fLutApt[i] = 0;
+  for (Int_t i=0; i<5; i++) {
+    fMinDevStrip[i] = right.fMinDevStrip[i];
+    fMinDev[i] = right.fMinDev[i];
+    fCoordY[i] = right.fCoordY[i];
+  }
 }
 
-//______________________________________________________________________________
-AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(const AliMUONLocalTriggerBoard& right) 
-  : AliMUONTriggerBoard(right) 
-{  
-/// Protected copy constructor (not implemented)
+//___________________________________________
+AliMUONLocalTriggerBoard& AliMUONLocalTriggerBoard::operator=(const AliMUONLocalTriggerBoard& right)
+{
+/// Assigment operator;
+/// equal operator
+
+  if (this == &right)
+    return *this;
+
+  // base class assignement
+  AliMUONTriggerBoard::operator=(right);
+
+  fMpLocalBoard = right.fMpLocalBoard;
+  fStripX11 = right.fStripX11;
+  fStripY11 = right.fStripY11;
+  fDev      = right.fDev;
+  fTrigY    = right.fTrigY;
+  fOutput   = right.fOutput;
+  fLUT      = right.fLUT;
+  fCoinc44  = right.fCoinc44;
+
+  for (Int_t i=0; i<2; i++) {
+    for (Int_t j=0; j<4; j++) {
+      fXY[i][j]  = right.fXY[i][j];
+      fXYU[i][j] = right.fXYU[i][j];
+      fXYD[i][j] = right.fXYD[i][j];
+
+      fMask[i][j] = right.fMask[i][j];
+    }
+  }
+
+  for (Int_t i=0; i<2; i++) {
+    fLutLpt[i] = right.fLutLpt[i];
+    fLutHpt[i] = right.fLutHpt[i];
+  }
+
+  for (Int_t i=0; i<5; i++) {
+    fMinDevStrip[i] = right.fMinDevStrip[i];
+    fMinDev[i] = right.fMinDev[i];
+    fCoordY[i] = right.fCoordY[i];
+  }
 
-  AliFatal("Copy constructor not provided.");
+  return *this;  
 }
 
-//______________________________________________________________________________
-AliMUONLocalTriggerBoard& 
-AliMUONLocalTriggerBoard::operator=(const AliMUONLocalTriggerBoard& right)
+//___________________________________________
+AliMUONLocalTriggerBoard::~AliMUONLocalTriggerBoard()
 {
-/// Protected assignement operator (not implemented)
+/// Destructor
+}
 
-  // check assignement to self
-  if (this == &right) return *this;
 
-  AliFatal("Assignement operator not provided.");
-    
-  return *this;  
-}    
+//___________________________________________
+Int_t AliMUONLocalTriggerBoard::GetNumber() const 
+{
+/// return board number for notified boards
+
+    if (fMpLocalBoard->IsNotified())
+       return fMpLocalBoard->GetId();
+    else 
+       return 0;
+}
 
 //___________________________________________
 void AliMUONLocalTriggerBoard::Reset()
 {
+/// reset board
+///
    for (Int_t i=0; i<2; i++) 
       for (Int_t j=0; j<4; j++) 
          fXY[i][j] = fXYU[i][j] = fXYD[i][j] = 0;
 
-   fResponse = 0;
+   ResetResponse();
+}
 
-   for (Int_t i=0; i<5; i++) fMinDevStrip[i] = fMinDev[i] = fCoordY[i] = 0;
+//___________________________________________
+void AliMUONLocalTriggerBoard::ResetResponse()
+{
+/// reset board response
+//
+  fResponse = 0;
 
-   fOutput = 0;
+  for (Int_t i=0; i<5; i++) fMinDevStrip[i] = fMinDev[i] = fCoordY[i] = 0;
+
+  fOutput = 0;
    
-   fStripX11 = fStripY11 = fDev = 0;
+  fStripX11 = 0;
+  fStripY11 = 15;
+  fDev = 0;
+  fTrigY = 1;
 
-   for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = fLutApt[i] = 0;
+  for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = 0;
 }
 
+
 //___________________________________________
 void AliMUONLocalTriggerBoard::Setbit(Int_t strip, Int_t cathode, Int_t chamber)
 {
-// 0 .. LBS   :   N-1 .. MSB
+/// 0 .. LBS   :   N-1 .. MSB
    TBits w, m;
 
    UShort_t xy = fXY[cathode][chamber], mask = fMask[cathode][chamber];
@@ -158,7 +274,7 @@ void AliMUONLocalTriggerBoard::Setbit(Int_t strip, Int_t cathode, Int_t chamber)
 //___________________________________________
 void AliMUONLocalTriggerBoard::SetbitM(Int_t strip, Int_t cathode, Int_t chamber)
 {
-// 0 .. LBS   :   N-1 .. MSB
+/// 0 .. LBS   :   N-1 .. MSB
    TBits w, m;
 
    UShort_t xy = fXY[cathode][chamber], mask = fMask[cathode][chamber];
@@ -166,8 +282,6 @@ void AliMUONLocalTriggerBoard::SetbitM(Int_t strip, Int_t cathode, Int_t chamber
    w.Set(16,&xy);
    m.Set(16,&mask);
 
-//    Int_t s = strip - int(strip / 16) * 16;
-
    w.SetBitNumber(strip);
    
    w &= m;
@@ -179,9 +293,12 @@ void AliMUONLocalTriggerBoard::SetbitM(Int_t strip, Int_t cathode, Int_t chamber
    fXY[cathode][chamber] = value;
 }
 
+
 //___________________________________________
-void AliMUONLocalTriggerBoard::Pattern(Option_t *option)
+void AliMUONLocalTriggerBoard::Pattern(const Option_t *option) const
 {
+/// print bit pattern
+///
    TString op = option;
    
    if (op.Contains("X")) BP("X");
@@ -191,22 +308,63 @@ void AliMUONLocalTriggerBoard::Pattern(Option_t *option)
 
 
 //___________________________________________
-void AliMUONLocalTriggerBoard::BP(Option_t *option)
+void AliMUONLocalTriggerBoard::BP(const Option_t *option) const
 {
-// RESPECT THE OLD PRINTOUT FORMAT
+/// Respect the old printout format
+  
+  const Int_t kModuleId[126] = 
+  {11,12,13,14,15,16,17,         // right side of the chamber
+  21,22,23,24,25,26,27,
+  31,32,33,34,35,36,37,
+  41,42,43,44,45,46,47,
+  51,52,53,54,55,56,57,
+  61,62,63,64,65,66,67,
+  71,72,73,74,75,76,77,
+  81,82,83,84,85,86,87,
+  91,92,93,94,95,96,97,   
+  -11,-12,-13,-14,-15,-16,-17,  // right side of chamber
+  -21,-22,-23,-24,-25,-26,-27,
+  -31,-32,-33,-34,-35,-36,-37,
+  -41,-42,-43,-44,-45,-46,-47,
+  -51,-52,-53,-54,-55,-56,-57,
+  -61,-62,-63,-64,-65,-66,-67,
+  -71,-72,-73,-74,-75,-76,-77,
+  -81,-82,-83,-84,-85,-86,-87,
+  -91,-92,-93,-94,-95,-96,-97};
+
+  const Int_t kNstripY[126]=
+  { 8, 8, 8, 8, 8, 8,16,  // right side of the chamber
+  8, 8, 8, 8, 8, 8,16,
+  16,16,16,16,16, 8,16,
+  16,16,16,16,16, 8,16,
+  0, 8,16,16,16, 8,16,
+  16,16,16,16,16, 8,16,
+  16,16,16,16,16, 8,16,
+  8, 8, 8, 8, 8, 8,16,
+  8, 8, 8, 8, 8, 8,16,  
+  8, 8, 8, 8, 8, 8,16,  // left side of the chamber
+  8, 8, 8, 8, 8, 8,16,
+  16,16,16,16,16, 8,16,
+  16,16,16,16,16, 8,16,
+  0, 8,16,16,16, 8,16,
+  16,16,16,16,16, 8,16,
+  16,16,16,16,16, 8,16,
+  8, 8, 8, 8, 8, 8,16,
+  8, 8, 8, 8, 8, 8,16};
 
    TString op = option;
-
-       TString nn = GetName();
+       
+   TString nn = GetName();
 
    if (op.Contains("X"))
    {
       printf("-------- TRIGGER INPUT ---------\n");
+      printf("--- warning: switchs not activated at this level ---\n");
       printf("===============================================================\n");
       printf("                            5432109876543210");
 
-      char *x[4] = {"XMC11","XMC12","XMC21","XMC22"};
-      char *s[4] = {"                      ",
+      const char *x[4] = {"XMC11","XMC12","XMC21","XMC22"};
+      const char *s[4] = {"                      ",
                     "                      ",
                     "              ",
                     "              "};
@@ -252,24 +410,24 @@ void AliMUONLocalTriggerBoard::BP(Option_t *option)
 /**/
       Int_t idCircuit = 0, absidModule = 0;
 
-               if (!(nn.Contains("Int"))) 
-               {
-                       idCircuit   = AliMUONTriggerConstants::CircuitId(GetI());
-                       absidModule = TMath::Abs(Int_t(idCircuit/10));
-               }
+      if (!(nn.Contains("Int"))) 
+      {        
+       idCircuit   = fgkCircuitId[GetI()];
+       absidModule = TMath::Abs(Int_t(idCircuit/10));
+      }
                
       Int_t iModule=0;
 
       for (Int_t i=0; i<63; i++) 
       {
-         if (AliMUONTriggerConstants::ModuleId(i)==absidModule) 
+       if (kModuleId[i]==absidModule) 
          { 
             iModule=i;
             break;
          }
       }
 
-      Int_t nStrip = AliMUONTriggerConstants::NstripY(iModule);
+      Int_t nStrip = kNstripY[iModule];
       for (Int_t istrip=nStrip-1; istrip>=0; istrip--) {
          if (istrip>9)  printf("%i",istrip-10*Int_t(istrip/10));
          if (istrip<10) printf("%i",istrip);
@@ -279,7 +437,7 @@ void AliMUONLocalTriggerBoard::BP(Option_t *option)
 
       UShort_t xyval = 0;
 
-      if (fSwitch[1])
+      if (GetSwitch(1))
       {
          xyval = fXY[1][0];
          TBits v11(8); v11.Set(8,&xyval);
@@ -350,52 +508,12 @@ void AliMUONLocalTriggerBoard::BP(Option_t *option)
 }
 
 //___________________________________________
-void AliMUONLocalTriggerBoard::Conf()
-{
-   cout << "Switch(" << GetName() << ")" 
-        << " x2d = "           << fSwitch[0] 
-        << " x2m = "           << fSwitch[1] 
-        << " x2u = "           << fSwitch[2] 
-        << " OR[0] = "         << fSwitch[3] 
-        << " OR[1] = "         << fSwitch[4] 
-        << " EN-Y = "          << fSwitch[5] 
-        << " ZERO-ALLY-LSB = " << fSwitch[6] 
-        << " ZERO-down = "     << fSwitch[7] 
-        << " ZERO-middle = "   << fSwitch[8] 
-        << " ZERO-up = "       << fSwitch[9] 
-        << " trans. conn. "    << fTC 
-        << " Slot = "          << fSlot 
-        << endl;
-}
-
-//___________________________________________
-void AliMUONLocalTriggerBoard::Module(char *mod)
-{
-   const Int_t maxfields = 2; char **fields = new char*[maxfields];
-
-   char s[100]; strcpy(s, GetName());
-
-   Int_t numlines = 0;
-
-   for (char *token = strtok(s, "B");
-        token != NULL;
-        token = strtok(NULL, " "))
-   {
-      fields[numlines] = new char[strlen(token)+1];
-      strcpy(fields[numlines++],token);
-   }
-   strcpy(mod,fields[0]);
-}
-
-//___________________________________________
-void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[32], Int_t ch4q[32], 
-                                     Int_t coinc44)
+void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[32], Int_t ch4q[32])
 {
-// note : coinc44 = flag 0 or 1 (0 coincidence -> 3/4, 1 coincidence -> 4/4)
-//---------------------------------------------------------
-// step # 1 : declustering, reduction DS, calculate sgle & dble
-//---------------------------------------------------------
+/// note : coinc44 = flag 0 or 1 (0 coincidence -> 3/4, 1 coincidence -> 4/4) \n
+///---------------------------------------------------------                  \n
+/// step # 1 : declustering, reduction DS, calculate sgle & dble              \n 
+///---------------------------------------------------------
    Int_t ch1e[19], ch2e[20], ch3e[35], ch4e[36]; 
    Int_t sgleHit1[31], sgleHit2[63];
    Int_t dbleHit1[31], dbleHit2[63];
@@ -414,6 +532,8 @@ void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[
    }
 
 //--- inititialize che using chq 
+//--- switch zero_down, zero_middle & zero_up added 30/05/07
+//--- fSwitch[7/8/9] = zero_down/zero_middle/zero_up
    for (i=0; i<19; i++) {
       if (i<1||i>16)  ch1e[i]=0; 
       else            ch1e[i]=ch1q[i-1]; 
@@ -424,14 +544,17 @@ void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[
    }
    for (i=0; i<35; i++) {
       if (i<1||i>32) ch3e[i]=0; 
-      else           ch3e[i]=ch3q[i-1];
+      else if (i>=1 && i<=8)   ch3e[i]=ch3q[i-1]&!GetSwitch(7);
+      else if (i>=9 && i<=24)  ch3e[i]=ch3q[i-1]&!GetSwitch(8);
+      else if (i>=25 && i<=32) ch3e[i]=ch3q[i-1]&!GetSwitch(9);
    }
    for (i=0; i<36; i++) {
       if (i<2||i>33) ch4e[i]=0; 
-      else           ch4e[i]=ch4q[i-2];
+      else if (i>=2 && i<=9)   ch4e[i]=ch4q[i-2]&!GetSwitch(7);
+      else if (i>=10 && i<=25) ch4e[i]=ch4q[i-2]&!GetSwitch(8);
+      else if (i>=26 && i<=33) ch4e[i]=ch4q[i-2]&!GetSwitch(9);
    }
 
-
 //--- calculate dble & sgle first station
    for (i=0; i<=15; i++) {                   
       sgleHit1[2*i] = (!ch1e[i+1]|(ch1e[i]^ch1e[i+2])) & 
@@ -445,8 +568,8 @@ void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[
       sgleHit1[2*i+1] = (!ch1e[i+1]|!ch1e[i+2]|(ch1e[i]^ch1e[i+3])) & 
          (!ch2e[i+2] | !ch2e[i+3] | (ch2e[i+1]^ch2e[i+4]));
       dbleHit1[2*i+1] = ch1e[i+1]&ch1e[i+2]&!(ch1e[i]^ch1e[i+3]) & 
-         (ch2e[i+2]&(!ch2e[i+1]|!ch2e[i]) | 
-          ch2e[i+3]&(ch2e[i+2]|!ch2e[i+4]|!ch2e[i+5]));
+       ((ch2e[i+2]&(!ch2e[i+1]|!ch2e[i])) | 
+          (ch2e[i+3]&(ch2e[i+2]|!ch2e[i+4]|!ch2e[i+5])));
    }
 
 //--- calculate dble & sgle second station
@@ -461,8 +584,8 @@ void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[
       sgleHit2[2*i+1] = (!ch3e[i+1]|!ch3e[i+2]|(ch3e[i]^ch3e[i+3])) & 
          (!ch4e[i+2] | !ch4e[i+3] | (ch4e[i+1]^ch4e[i+4]));
       dbleHit2[2*i+1] = ch3e[i+1]&ch3e[i+2]&!(ch3e[i]^ch3e[i+3]) & 
-         (ch4e[i+2]&(!ch4e[i+1]|!ch4e[i]) | 
-          ch4e[i+3]&(ch4e[i+2]|!ch4e[i+4]|!ch4e[i+5]));
+       ((ch4e[i+2]&(!ch4e[i+1]|!ch4e[i])) | 
+          (ch4e[i+3]&((ch4e[i+2]|!ch4e[i+4])|!ch4e[i+5])));
    }
 
 //--- 
@@ -498,7 +621,7 @@ void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[
       !dbleHit1[14] & !dbleHit1[13] & !dbleHit1[12] & !dbleHit1[11] & 
       !dbleHit1[10] & !dbleHit1[9]  & !dbleHit1[8]  & !dbleHit1[7]  & 
       !dbleHit1[6]  & !dbleHit1[5]  & !dbleHit1[4]  & !dbleHit1[3]  & 
-      !dbleHit1[2]  & !dbleHit1[1]  & !dbleHit1[0]  & !coinc44;
+      !dbleHit1[2]  & !dbleHit1[1]  & !dbleHit1[0]  & !fCoinc44;
 
    Int_t notOr2= !dbleHit2[62] & !dbleHit2[61] & !dbleHit2[60] & !dbleHit2[59] & 
       !dbleHit2[58] & !dbleHit2[57] & !dbleHit2[56] & !dbleHit2[55] & 
@@ -515,7 +638,7 @@ void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[
       !dbleHit2[14] & !dbleHit2[13] & !dbleHit2[12] & !dbleHit2[11] & 
       !dbleHit2[10] & !dbleHit2[9]  & !dbleHit2[8]  & !dbleHit2[7]  & 
       !dbleHit2[6]  & !dbleHit2[5]  & !dbleHit2[4]  & !dbleHit2[3]  & 
-      !dbleHit2[2]  & !dbleHit2[1]  & !dbleHit2[0]  & !coinc44;        
+      !dbleHit2[2]  & !dbleHit2[1]  & !dbleHit2[0]  & !fCoinc44;       
 
 // DS reduction
    for (i=0; i<31; i++) {
@@ -570,18 +693,18 @@ void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[
       andL2=!rearImage[i][23]&!rearImage[i][24]&!rearImage[i][25]&!rearImage[i][26];
  
       leftDev[0] = (rearImage[i][16]|!rearImage[i][17]) & 
-         (rearImage[i][16]|rearImage[i][18]|!rearImage[i][19]&
-          (rearImage[i][20]|!rearImage[i][21])) &
-         (orL1|!rearImage[i][23]&(rearImage[i][24]|!rearImage[i][25])) & 
-         (orL1|rearImage[i][24]|rearImage[i][26]|!rearImage[i][27]&
-          (rearImage[i][28]|!rearImage[i][29]));
+        (rearImage[i][16]|rearImage[i][18]|(!rearImage[i][19]&
+        (rearImage[i][20]|!rearImage[i][21]))) &
+        (orL1|(!rearImage[i][23]&(rearImage[i][24]|!rearImage[i][25]))) & 
+        (orL1|rearImage[i][24]|rearImage[i][26]|(!rearImage[i][27]&
+        (rearImage[i][28]|!rearImage[i][29])));
                                
       leftDev[1] = !rearImage[i][16] & 
          !(!rearImage[i][17]&!rearImage[i][18]&!rearImage[i][21]&!rearImage[i][22] & 
-           (!rearImage[i][25]&!rearImage[i][26]&(rearImage[i][27]|rearImage[i][28]))) &
-         (rearImage[i][17]|rearImage[i][18] | !rearImage[i][19]&!rearImage[i][20]) &
+         (!rearImage[i][25]&!rearImage[i][26]&(rearImage[i][27]|rearImage[i][28]))) &
+        (rearImage[i][17]|rearImage[i][18] | (!rearImage[i][19]&!rearImage[i][20])) &
          (rearImage[i][17]|rearImage[i][18]|rearImage[i][21]|rearImage[i][22] | 
-          !rearImage[i][23]&!rearImage[i][24]);
+        (!rearImage[i][23]&!rearImage[i][24]));
                                
       leftDev[2] = (!rearImage[i][16]&!rearImage[i][17]&!rearImage[i][18]) & 
          (rearImage[i][19]|rearImage[i][20]|rearImage[i][21]|rearImage[i][22] | andL2);
@@ -601,18 +724,18 @@ void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[
       andR3=!rearImage[i][4]&!rearImage[i][5]&!rearImage[i][6]&!rearImage[i][7]; 
                
       rightDev[0] = !rearImage[i][15]&(rearImage[i][14]|!rearImage[i][13]) & 
-         ((rearImage[i][12]|rearImage[i][14]|!rearImage[i][11]&
-           (rearImage[i][10]|!rearImage[i][9])) &
-          ((orR1|!rearImage[i][7]&(rearImage[i][6]|!rearImage[i][5])) & 
-           (orR1|rearImage[i][4]|rearImage[i][6]|!rearImage[i][3]&(rearImage[i][2]|
-                                                                   !rearImage[i][1]))));
+         ((rearImage[i][12]|rearImage[i][14]|(!rearImage[i][11]&
+         (rearImage[i][10]|!rearImage[i][9]))) &
+         ((orR1|(!rearImage[i][7]&(rearImage[i][6]|!rearImage[i][5]))) & 
+          (orR1|rearImage[i][4]|rearImage[i][6]|(!rearImage[i][3]&(rearImage[i][2]|
+                                                                  !rearImage[i][1])))));
                                
       rightDev[1] = !rearImage[i][15]&!rearImage[i][14] & 
          !(!rearImage[i][4]&!rearImage[i][5]&!rearImage[i][8]&!rearImage[i][9] &
            (!rearImage[i][12]&!rearImage[i][13]&(rearImage[i][2]|rearImage[i][3]))) &
-         (rearImage[i][12]|rearImage[i][13] | !rearImage[i][10]&!rearImage[i][11]) & 
+        (rearImage[i][12]|rearImage[i][13] | (!rearImage[i][10]&!rearImage[i][11])) & 
          (rearImage[i][8]|rearImage[i][9]|rearImage[i][12]|rearImage[i][13] | 
-          !rearImage[i][6]&!rearImage[i][7]);
+          (!rearImage[i][6]&!rearImage[i][7]));
                
       rightDev[2] = andR1 & (orR2 | andR3); 
       rightDev[3] = andR2;             
@@ -752,7 +875,7 @@ void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[
 void AliMUONLocalTriggerBoard::Sort2x5(Int_t dev1[6], Int_t dev2[6],
                                        Int_t minDev[6], Int_t &dev1GTdev2)
 { 
-// returns minimun between dev1 and dev2
+/// returns minimun between dev1 and dev2
    Int_t tmpDev1=0, tmpDev2=0;
 
    for (Int_t j=0; j<5; j++)
@@ -775,20 +898,19 @@ void AliMUONLocalTriggerBoard::Sort2x5(Int_t dev1[6], Int_t dev2[6],
 
 //___________________________________________
 void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], Int_t y4[16],
-                                     Int_t y3u[16], Int_t y3d[16], Int_t y4u[16], Int_t y4d[16],
-                                     Int_t coinc44)
+                                     Int_t y3u[16], Int_t y3d[16], Int_t y4u[16], Int_t y4d[16])
 {
-// note : resMid = 1 -> cancel 
-//---------------------------------------------------------
-// step # 1 : prehandling Y
-//--------------------------------------------------------- 
+/// note : resMid = 1 -> cancel                             \n
+///---------------------------------------------------------\n
+/// step # 1 : prehandling Y                                \n
+///--------------------------------------------------------- 
    Int_t i;
    Int_t istrip;
 
    for (i=0; i<16; i++)
    {
-      y3[i]=y3[i]&!fSwitch[8];
-      y4[i]=y4[i]&!fSwitch[8];
+     y3[i]=y3[i]&!GetSwitch(8);
+     y4[i]=y4[i]&!GetSwitch(8);
    }
 
 // 10/29/04 fZeroAllYLSB added
@@ -805,50 +927,52 @@ void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], I
    Int_t tmpy3to16[16], tmpy4to16[16];
    Int_t tmpy3uto16[16], tmpy3dto16[16], tmpy4uto16[16], tmpy4dto16[16];
    for (i=0; i<8; i++){
-      ch1[2*i]   = y1[i]&fSwitch[1] | y1[2*i]&!fSwitch[1];             
-      ch1[2*i+1] = y1[i]&fSwitch[1] | y1[2*i+1]&!fSwitch[1];
+      ch1[2*i]   = (y1[i]&GetSwitch(1)) | (y1[2*i]&!GetSwitch(1));             
+      ch1[2*i+1] = (y1[i]&GetSwitch(1)) | (y1[2*i+1]&!GetSwitch(1));
 
-      ch2[2*i]   = y2[i]&fSwitch[1] | y2[2*i]&!fSwitch[1];             
-      ch2[2*i+1] = y2[i]&fSwitch[1] | y2[2*i+1]&!fSwitch[1];
+      ch2[2*i]   = (y2[i]&GetSwitch(1)) | (y2[2*i]&!GetSwitch(1));             
+      ch2[2*i+1] = (y2[i]&GetSwitch(1)) | (y2[2*i+1]&!GetSwitch(1));
 
-      tmpy3to16[2*i  ] = y3[i]&fSwitch[1] | y3[2*i  ]&!fSwitch[1];             
-      tmpy3to16[2*i+1] = y3[i]&fSwitch[1] | y3[2*i+1]&!fSwitch[1];
+      tmpy3to16[2*i  ] = (y3[i]&GetSwitch(1)) | (y3[2*i  ]&!GetSwitch(1));             
+      tmpy3to16[2*i+1] = (y3[i]&GetSwitch(1)) | (y3[2*i+1]&!GetSwitch(1));
 
-      tmpy4to16[2*i  ] = y4[i]&fSwitch[1] | y4[2*i  ]&!fSwitch[1];
-      tmpy4to16[2*i+1] = y4[i]&fSwitch[1] | y4[2*i+1]&!fSwitch[1];
+      tmpy4to16[2*i  ] = (y4[i]&GetSwitch(1)) | (y4[2*i  ]&!GetSwitch(1));
+      tmpy4to16[2*i+1] = (y4[i]&GetSwitch(1)) | (y4[2*i+1]&!GetSwitch(1));
 
-      tmpy3uto16[2*i  ] = y3u[i]&fSwitch[2] | y3u[2*i  ]&!fSwitch[2]; 
-      tmpy3uto16[2*i+1] = y3u[i]&fSwitch[2] | y3u[2*i+1]&!fSwitch[2];
+      tmpy3uto16[2*i  ] = (y3u[i]&GetSwitch(2)) | (y3u[2*i  ]&!GetSwitch(2)); 
+      tmpy3uto16[2*i+1] = (y3u[i]&GetSwitch(2)) | (y3u[2*i+1]&!GetSwitch(2));
 
-      tmpy4uto16[2*i  ] = y4u[i]&fSwitch[2] | y4u[2*i  ]&!fSwitch[2]; 
-      tmpy4uto16[2*i+1] = y4u[i]&fSwitch[2] | y4u[2*i+1]&!fSwitch[2];
+      tmpy4uto16[2*i  ] = (y4u[i]&GetSwitch(2)) | (y4u[2*i  ]&!GetSwitch(2)); 
+      tmpy4uto16[2*i+1] = (y4u[i]&GetSwitch(2)) | (y4u[2*i+1]&!GetSwitch(2));
 
-      tmpy3dto16[2*i  ] = y3d[i]&fSwitch[0] | y3d[2*i  ]&!fSwitch[0]; 
-      tmpy3dto16[2*i+1] = y3d[i]&fSwitch[0] | y3d[2*i+1]&!fSwitch[0];
+      tmpy3dto16[2*i  ] = (y3d[i]&GetSwitch(0)) | (y3d[2*i  ]&!GetSwitch(0)); 
+      tmpy3dto16[2*i+1] = (y3d[i]&GetSwitch(0)) | (y3d[2*i+1]&!GetSwitch(0));
     
-      tmpy4dto16[2*i  ] = y4d[i]&fSwitch[0] | y4d[2*i  ]&!fSwitch[0]; 
-      tmpy4dto16[2*i+1] = y4d[i]&fSwitch[0] | y4d[2*i+1]&!fSwitch[0];
+      tmpy4dto16[2*i  ] = (y4d[i]&GetSwitch(0)) | (y4d[2*i  ]&!GetSwitch(0)); 
+      tmpy4dto16[2*i+1] = (y4d[i]&GetSwitch(0)) | (y4d[2*i+1]&!GetSwitch(0));
    }
   
-   if (fSwitch[3]==0&&fSwitch[4]==0){
+   for (i=0; i<16; i++) ch3[i] = ch4[i] = 0;
+
+   if (GetSwitch(3)==0&&GetSwitch(4)==0){
       for (i=0; i<16; i++){
          ch3[i] = tmpy3to16[i];
          ch4[i] = tmpy4to16[i];
       }
    }
-   if (fSwitch[3]==0&&fSwitch[4]==1){
+   if (GetSwitch(3)==0&&GetSwitch(4)==1){
       for (i=0; i<16; i++){
          ch3[i] = tmpy3dto16[i]|tmpy3to16[i];
          ch4[i] = tmpy4dto16[i]|tmpy4to16[i];
       }
    }
-   if (fSwitch[3]==1&&fSwitch[4]==0){
+   if (GetSwitch(3)==1&&GetSwitch(4)==0){
       for (i=0; i<16; i++){
          ch3[i] = tmpy3uto16[i]|tmpy3to16[i];
          ch4[i] = tmpy4uto16[i]|tmpy4to16[i];
       }
    }
-   if (fSwitch[3]==1&&fSwitch[4]==1){
+   if (GetSwitch(3)==1&&GetSwitch(4)==1){
       for (i=0; i<16; i++){
          ch3[i] = tmpy3dto16[i]|tmpy3to16[i]|tmpy3uto16[i];
          ch4[i] = tmpy4dto16[i]|tmpy4to16[i]|tmpy4uto16[i];
@@ -859,7 +983,7 @@ void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], I
    if(AliDebugLevel()==4||AliDebugLevel()==5) {
       printf("===============================================================\n");  
       printf(" Y plane after PreHandling x2m x2u x2d orMud %i %i %i %i %i \n",
-             fSwitch[1],fSwitch[2], fSwitch[0],fSwitch[3],fSwitch[4]);
+             GetSwitch(1),GetSwitch(2), GetSwitch(0),GetSwitch(3),GetSwitch(4));
       printf("                            ");
       for (istrip=15; istrip>=0; istrip--) {
          if (istrip>9)  printf("%i",istrip-10*Int_t(istrip/10));
@@ -927,8 +1051,8 @@ void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], I
       !dble2[3]  & !dble2[2]  & !dble2[1]  & !dble2[0];
 
    for (i=0; i<16; i++) {
-      sgle1[i] = sgle1[i] & notOr1 & !coinc44;
-      sgle2[i] = sgle2[i] & notOr2 & !coinc44;
+      sgle1[i] = sgle1[i] & notOr1 & !fCoinc44;
+      sgle2[i] = sgle2[i] & notOr2 & !fCoinc44;
    }
 
 //---------------------------------------------------------
@@ -937,15 +1061,15 @@ void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], I
    Int_t frontImage[16];
 
    for (i=1; i<15; i++) {
-      frontImage[i] = (dble1[i] | sgle1[i]) & 
-         (dble2[i+1] | dble2[i] | dble2[i-1]) |
-         dble1[i] & (sgle2[i+1] | sgle2[i] | sgle2[i-1]);
+     frontImage[i] = ((dble1[i] | sgle1[i]) & 
+                     (dble2[i+1] | dble2[i] | dble2[i-1])) |
+       (dble1[i] & (sgle2[i+1] | sgle2[i] | sgle2[i-1]));
    }
-   frontImage[0] = (dble1[0] | sgle1[0]) & 
-      (dble2[1] | dble2[0]) | dble1[0] & (sgle2[1] | sgle2[0]);
+   frontImage[0] = ((dble1[0] | sgle1[0]) & 
+                   (dble2[1] | dble2[0])) | (dble1[0] & (sgle2[1] | sgle2[0]));
 
-   frontImage[15] = (dble1[15] | sgle1[15]) & 
-      (dble2[15] | dble2[14]) | dble1[15] & (sgle2[15] | sgle2[14]);
+   frontImage[15] = ((dble1[15] | sgle1[15]) & 
+                    (dble2[15] | dble2[14])) | (dble1[15] & (sgle2[15] | sgle2[14]));
 
 
 //debug
@@ -975,16 +1099,16 @@ void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], I
    and3 = !frontImage[11]&!frontImage[10]&!frontImage[9]&!frontImage[8]; 
  
    fCoordY[0] = !frontImage[0]&(frontImage[1]|!frontImage[2]) & 
-      (frontImage[3]|frontImage[1]|!frontImage[4]&(frontImage[5]|!frontImage[6])) &
-      (or1|!frontImage[8]&(frontImage[9]|!frontImage[10])) & 
-      (or1|frontImage[11]|frontImage[9]|!frontImage[12]&(frontImage[13]|!frontImage[14]));
+     (frontImage[3]|frontImage[1]|(!frontImage[4]&(frontImage[5]|!frontImage[6]))) &
+     (or1|(!frontImage[8]&(frontImage[9]|!frontImage[10]))) & 
+     (or1|frontImage[11]|frontImage[9]|(!frontImage[12]&(frontImage[13]|!frontImage[14])));
  
    fCoordY[1] = !frontImage[0]&!frontImage[1] & 
       !(!frontImage[11]&!frontImage[10]&!frontImage[7]&!frontImage[6] & 
         !frontImage[3]&!frontImage[2]&(frontImage[13]|frontImage[12])) &
-      (frontImage[3]|frontImage[2] | !frontImage[5]&!frontImage[4]) & 
+     (frontImage[3]|frontImage[2] | (!frontImage[5]&!frontImage[4])) & 
       (frontImage[7]|frontImage[6]|frontImage[3]|frontImage[2] | 
-       !frontImage[9]&!frontImage[8]);
+       (!frontImage[9]&!frontImage[8]));
                
    fCoordY[2] = and1 & (or2 | and3);
                
@@ -997,59 +1121,63 @@ void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], I
 //___________________________________________
 void AliMUONLocalTriggerBoard::LocalTrigger()
 {
-   Int_t deviation=0, iStripY=0;
-
-   for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
-   for (Int_t i=0; i<4; i++) iStripY   += static_cast<int>( fCoordY[i] << i );
-
-   if (fMinDev[4]==1 && !deviation) fOutput=0;     // No trigger
-   else 
-   {
-      if (fCoordY[4]==1 && iStripY==15) fOutput=0; // No trigger
-      else 
-         fOutput=1;
+/// L0 trigger after LUT
+///
+    Int_t deviation=0;
+    Int_t iStripY=0;
+    Int_t iStripX=0;
+    Bool_t xOutput = IsTrigX();
+    Bool_t yOutput = IsTrigY();
+
+   if (xOutput) {
+      for (Int_t i=0; i<5; i++) iStripX += static_cast<int>( fMinDevStrip[i] << i );
+      for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
+      fDev      = deviation;
+      fStripX11 = iStripX;
+   }
+   if (yOutput) {
+     for (Int_t i=0; i<4; i++) iStripY   += static_cast<int>( fCoordY[i] << i );
+      fStripY11 = iStripY;
+      fTrigY    = fCoordY[4];
    }
   
-   if (fOutput) 
-   { 
-      for (Int_t i=0; i<5; i++) fStripX11 += static_cast<int>( fMinDevStrip[i] << i );
-
-      fDev      = deviation;
-
-               fStripY11 = iStripY;
-               
-               if ( fSwitch[1] && 
-                         (fSwitch[0] || fSwitch[2]) && 
-                         !(!fSwitch[0] && fSwitch[4]) && 
-                         !(!fSwitch[2] && fSwitch[3]) ) fStripY11 /= 2;
-
-      Int_t sign = 0;
-
-      if ( !fMinDev[4] &&  deviation ) sign=-1;
-      if ( !fMinDev[4] && !deviation ) sign= 0;
-      if (  fMinDev[4]==1)             sign=+1;    
-
-      fDev *= sign; 
-
+//   cout << " Local Trigger " << " " << fNumber << " " << 
+//       xOutput << " " << yOutput << " " << fDev << " " << fStripX11 << " " <<
+//       fTrigY << " " << fStripY11 << "\n";
+
+   if (xOutput && yOutput){ // trigger in X and Y
+       fOutput =1;
+
+       Int_t sign = 0;
+       if ( !fMinDev[4] &&  deviation ) sign=-1;
+       if ( !fMinDev[4] && !deviation ) sign= 0;
+       if (  fMinDev[4] == 1 )          sign=+1;    
+       
+       deviation *= sign; 
+       
 //    calculate deviation in [0;+30]
-      fDev += 15;
-
-      Int_t icirc = GetI();
+       deviation += 15;
+       
+//    GET LUT OUTPUT FOR icirc/istripX1/deviation/istripY
+       fLUT->GetLutOutput(GetNumber(), fStripX11, deviation, fStripY11, fLutLpt, fLutHpt);
+   }
 
-//    LEFT SHIFT OF ZERO-ALLY-LSB BOARDS TO ACCESS TO LUT
-               if (GetSwitch(6)) fStripY11 -= 8;
+   fResponse = fLutLpt[0]              + 
+       static_cast<int>(fLutLpt[1]<<1) + 
+       static_cast<int>(fLutHpt[0]<<2) + 
+       static_cast<int>(fLutHpt[1]<<3);  
 
-//    GET LUT OUTPUT FOR icirc/istripX1/deviation/istripY
-      fLUT->GetLutOutput(icirc, fStripX11, fDev, fStripY11, fLutLpt, fLutHpt, fLutApt);
-   }  
 }
 
 //___________________________________________
-Int_t AliMUONLocalTriggerBoard::GetI()
+Int_t AliMUONLocalTriggerBoard::GetI() const
 {
-   const Int_t maxfields = 2; char **fields = new char*[maxfields];
+/// old numbering
+///
 
-   char s[100]; strcpy(s, GetName());
+   const Int_t kMaxfields = 2; char **fields = new char*[kMaxfields];
+
+   char s[100]; strncpy(s, GetName(), 99);
 
    Int_t numlines = 0;
 
@@ -1065,24 +1193,26 @@ Int_t AliMUONLocalTriggerBoard::GetI()
 
    char copy = l[0];
 
-   Int_t L = atoi(&l[4]), C = atoi(&l[2]), S = (copy=='R') ? +1 : -1;
+   Int_t lL = atoi(&l[4]), cC = atoi(&l[2]), sS = (copy=='R') ? +1 : -1;
 
-   char *b[4] = {"12", "34", "56", "78"};
+   const char *b[4] = {"12", "34", "56", "78"};
 
    Int_t ib = 0;
 
    for (Int_t i=0; i<4; i++) if (!strcmp(fields[1],b[i])) {ib = i; break;} ib++;
 
-// L=1 ON TOP
-   L -= 9; L = abs(L); L++;
+// lL=1 ON TOP
+   lL -= 9; lL = abs(lL); lL++;
 
-   Int_t code = 100 * L + 10 * C + ib;
+   Int_t code = 100 * lL + 10 * cC + ib;
 
-   code *= S;
+   code *= sS;
 
    Int_t ic = 0;
 
-   for (Int_t i=0; i<234; i++) if (AliMUONTriggerConstants::CircuitId(i) == code) {ic = i; break;}
+   for (Int_t i=0; i<234; i++) if (fgkCircuitId[i] == code) {ic = i; break;}
+   
+   delete [] fields;
 
    return ic;
 }
@@ -1090,10 +1220,12 @@ Int_t AliMUONLocalTriggerBoard::GetI()
 //___________________________________________
 void AliMUONLocalTriggerBoard::Mask(Int_t index, UShort_t mask)
 {
+/// set mask
+///
   if ( index >= 0 && index < 2*4 )
   {
     Int_t i = index/4;
-    Int_t j = index - i*4;
+    Int_t j = index%4;
     fMask[i][j]=mask;
   }
   else
@@ -1103,9 +1235,11 @@ void AliMUONLocalTriggerBoard::Mask(Int_t index, UShort_t mask)
 }
 
 //___________________________________________
-void AliMUONLocalTriggerBoard::Scan(Option_t *option)
+void AliMUONLocalTriggerBoard::Scan(Option_t *option) const
 {
-   TString op = option;
+/// full dump
+///
+    TString op = option;
 
    if (op.Contains("CONF")) Conf();
 
@@ -1115,6 +1249,8 @@ void AliMUONLocalTriggerBoard::Scan(Option_t *option)
 
    if (op.Contains("RESPF")) Resp("F"); 
 
+   if (op.Contains("RESPO")) Resp("O");
+
    if (op.Contains("ALL"))
    {
       Conf();
@@ -1125,8 +1261,31 @@ void AliMUONLocalTriggerBoard::Scan(Option_t *option)
 }
 
 //___________________________________________
-void AliMUONLocalTriggerBoard::Resp(Option_t *option)
+void AliMUONLocalTriggerBoard::Conf() const
 {
+/// board switches
+///
+   cout << "Switch(" << GetName() << ")" 
+        << " x2d = "           << GetSwitch(0) 
+        << " x2m = "           << GetSwitch(1) 
+        << " x2u = "           << GetSwitch(2) 
+        << " OR[0] = "         << GetSwitch(3) 
+        << " OR[1] = "         << GetSwitch(4) 
+        << " EN-Y = "          << GetSwitch(5) 
+        << " ZERO-ALLY-LSB = " << GetSwitch(6) 
+        << " ZERO-down = "     << GetSwitch(7) 
+        << " ZERO-middle = "   << GetSwitch(8) 
+        << " ZERO-up = "       << GetSwitch(9) 
+        << " trans. conn. "    << GetTC() 
+        << " Slot = "          << fSlot 
+        << endl;
+}
+
+//___________________________________________
+void AliMUONLocalTriggerBoard::Resp(Option_t *option) const
+{
+/// board I/O
+///
    TString op = option;
 
    if (op.Contains("I"))
@@ -1142,43 +1301,28 @@ void AliMUONLocalTriggerBoard::Resp(Option_t *option)
       for  (Int_t i=4; i>=0; i--) printf("%i",fCoordY[i]); 
       printf(" \n");
    }
+   if (op.Contains("O")){
+     printf("-- Output --\n");
+     printf("Coinc44 %i\n", fCoinc44);
+     printf("StripX11 %i  StripY11 %i  Dev %i  TrigY %i\n", fStripX11, fStripY11, fDev, fTrigY);
+     printf("LutLpt %i %i  LutHpt %i %i\n", fLutLpt[0], fLutLpt[1], fLutHpt[0], fLutHpt[1]);
+     printf("Response %i\n", fOutput);
+   }
 
-   if (op.Contains("F"))
-   {
-      Int_t icirc = GetI();
-      Int_t idCircuit = AliMUONTriggerConstants::CircuitId(icirc);
-
-      Int_t deviation = 0, iStripY = 0;
-
-      for (Int_t i=0; i<4; i++) iStripY   += static_cast<int>( fCoordY[i] << i );
-
-      for (Int_t i=0; i<4; i++) deviation += Int_t(fMinDev[i]<<i);   
-
-      Float_t pt = 0.; //triggerCircuit->PtCal(fStripX11, fDev, fStripY11);
-      printf("-------------------------------------------\n");
-      printf(" Local Trigger info for circuit Id %i (number %i ) \n", idCircuit, icirc);
-      printf(" istripX1 signDev deviation istripY = %i %i %i %i \n", fStripX11, fMinDev[4], deviation, iStripY);
-      printf(" pt = %f  (GeV/c) \n", pt);
-      printf("-------------------------------------------\n");
-      printf(" Local Trigger Lut Output = Lpt : ");
-      for (Int_t i=1; i>=0; i--) printf("%i", fLutLpt[i]);
-      printf(" Hpt : ");
-      for (Int_t i=1; i>=0; i--) printf("%i", fLutHpt[i]);
-      printf(" Apt : ");
-      for (Int_t i=1; i>=0; i--) printf("%i", fLutApt[i]);
-      printf("\n");
-      printf("-------------------------------------------\n");
-   }      
-//    else
-//    {
-      
-//    }
 }
 
 //___________________________________________
 void AliMUONLocalTriggerBoard::Response()
 {
-   Int_t X1[16], X2[16], XX3[32], XX4[32];
+/// algo
+///
+  if ( IsNull() ) {
+    fMinDev[4] = 1;
+    for  (Int_t i=4; i>=0; i--) fCoordY[i] = 1;
+    return; // Do nothing if strip pattern is null
+  }
+
+   Int_t xX1[16], xX2[16], xXX3[32], xXX4[32];
 
    TBits x1(16), x2(16), x3(16), x4(16);
 
@@ -1199,29 +1343,29 @@ void AliMUONLocalTriggerBoard::Response()
 
    for (Int_t i=0;i<16;i++)
    {
-      X1[i] = x1[i];
-      X2[i] = x2[i];
+      xX1[i] = x1[i];
+      xX2[i] = x2[i];
       
-      XX3[i+8] = x3[i];
-      XX4[i+8] = x4[i];  
+      xXX3[i+8] = x3[i];
+      xXX4[i+8] = x4[i];  
    }
 
    for (Int_t i=0;i<8;i++)
    {
-      XX3[i] = x3d[i+8];
-      XX4[i] = x4d[i+8];
+      xXX3[i] = x3d[i+8];
+      xXX4[i] = x4d[i+8];
 
-      XX3[i+24] = x3u[i];
-      XX4[i+24] = x4u[i];
+      xXX3[i+24] = x3u[i];
+      xXX4[i+24] = x4u[i];
    }
    
-   Int_t coinc44 = 0;
+//   Int_t coinc44 = 0;
    
-   TrigX(X1, X2, XX3, XX4, coinc44);   
+   TrigX(xX1, xX2, xXX3, xXX4);   
 
-   Int_t Y1[16], Y2[16], Y3[16], Y4[16];
+   Int_t yY1[16], yY2[16], yY3[16], yY4[16];
    
-   Int_t Y3U[16], Y3D[16], Y4U[16], Y4D[16];
+   Int_t yY3U[16], yY3D[16], yY4U[16], yY4D[16];
 
    TBits y1(16), y2(16), y3(16), y4(16);
 
@@ -1239,30 +1383,63 @@ void AliMUONLocalTriggerBoard::Response()
 
    for (Int_t i=0;i<16;i++)
    {
-      Y1[i] = y1[i];
-      Y2[i] = y2[i];
-      Y3[i] = y3[i];
-      Y4[i] = y4[i];
+      yY1[i] = y1[i];
+      yY2[i] = y2[i];
+      yY3[i] = y3[i];
+      yY4[i] = y4[i];
       
-      Y3U[i] = y3u[i];
-      Y3D[i] = y3d[i];
+      yY3U[i] = y3u[i];
+      yY3D[i] = y3d[i];
       
-      Y4U[i] = y4u[i];
-      Y4D[i] = y4d[i];
+      yY4U[i] = y4u[i];
+      yY4D[i] = y4d[i];
    }
 
-   TrigY(Y1, Y2, Y3, Y4, Y3U, Y3D, Y4U, Y4D, coinc44);
+   TrigY(yY1, yY2, yY3, yY4, yY3U, yY3D, yY4U, yY4D);
    
-// ASIGN fLutLpt, fLutHpt, fLutApt
-   LocalTrigger(); 
-
-   fResponse = fLutApt[0]                      + 
-               static_cast<int>(fLutApt[1]<<1) + 
-               static_cast<int>(fLutLpt[0]<<2) + 
-               static_cast<int>(fLutLpt[1]<<3) + 
-               static_cast<int>(fLutHpt[0]<<4) + 
-               static_cast<int>(fLutHpt[1]<<5);
+// ASIGN fLutLpt, fLutHpt
+   LocalTrigger();
 }
 
-ClassImp(AliMUONLocalTriggerBoard)
+//___________________________________________
+Bool_t AliMUONLocalTriggerBoard::IsTrigY() const
+{
+  /// Return the response of non-bending plane
+  Int_t iStripY = 0;
+  Bool_t output = kFALSE;
+
+  for (Int_t i=0; i<4; i++) iStripY   += static_cast<int>( fCoordY[i] << i );
+
+  if (fCoordY[4]==1 && iStripY==15) output=kFALSE; // no trigger in Y
+  else output=kTRUE;                               // trigger in Y
+   
+  return output;
+}
+
+//___________________________________________
+Bool_t AliMUONLocalTriggerBoard::IsTrigX() const
+{
+  /// Return the response of bending plane
+
+  Int_t deviation = 0;
+  Bool_t output = kFALSE;
 
+  for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
+
+  if (fMinDev[4]==1 && !deviation) output=kFALSE;  // no trigger in X
+  else output=kTRUE;                               // trigger in X
+
+  return output;
+}
+
+//___________________________________________
+Bool_t AliMUONLocalTriggerBoard::IsNull() const
+{
+  /// Check if board has fired strips in the first station
+  for (Int_t icath=0; icath<2; icath++){
+    for(Int_t ich=0; ich<2; ich++){
+      if ( fXY[icath][ich] ) return kFALSE;
+    }
+  }
+  return kTRUE;
+}