Fixing FORWARD_NULL defects reported by Coverity
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerElectronics.cxx
index c03bad9..388c344 100644 (file)
 
 /* $Id$ */
 
-//*-- Author: Rachid Guernane (LPCCFd)
+//-----------------------------------------------------------------------------
+// Class AliMUONTriggerElectronics
+//--------------------------------
+// Manager class for muon trigger electronics
+// Client of trigger board classes
+// Debugged by Ph. Crochet & Ch. Finck
+// Interfaced with new mapping Ch. Finck
+//
+// Author: Rachid Guernane (LPCCFd)
+//-----------------------------------------------------------------------------
 
-#include "AliMUONTriggerElectronics.h"
-#include "AliMUONTriggerCrate.h"
-#include "AliMUONConstants.h"
-#include "AliMUONLocalTriggerBoard.h"
-#include "AliMUONRegionalTriggerBoard.h"
-#include "AliMUONGlobalTriggerBoard.h"
-#include "AliMUONLocalTrigger.h"
-#include "AliMUONGlobalTrigger.h"
 #include "AliLoader.h"
-#include "AliRun.h"
-#include "AliMUON.h" 
-#include "AliMUONData.h" 
-#include "AliMUONDigit.h"
 #include "AliLog.h"
-#include "AliLoader.h"
-#include "AliMUONTriggerConstants.h"
-#include "AliMpTriggerSegmentation.h"
-#include "AliMUONSegmentation.h"
+#include "AliMUONCalibrationData.h"
+#include "AliMUONVDigit.h"
+#include "AliMUONVDigitStore.h"
+#include "AliMUONGlobalTrigger.h"
+#include "AliMUONGlobalTriggerBoard.h"
+#include "AliMUONLocalTrigger.h"
+#include "AliMUONLocalTriggerBoard.h"
+#include "AliMUONRegionalTrigger.h"
+#include "AliMUONRegionalTriggerBoard.h"
+#include "AliMUONTriggerCrate.h"
+#include "AliMUONTriggerCrateStore.h"
+#include "AliMUONTriggerElectronics.h"
+#include "AliMUONTriggerCrateConfig.h"
+#include "AliMUONRegionalTriggerConfig.h"
+#include "AliMUONGlobalCrateConfig.h"
+#include "AliMUONVTriggerStore.h"
+#include "AliMUONVCalibParam.h"
+#include "AliMpCathodType.h"
+#include "AliMpCDB.h"
+#include "AliMpDEManager.h"
+#include "AliMpSegmentation.h"
 #include "AliMpVSegmentation.h"
+#include "AliMpCathodType.h"
+#include "AliMpTriggerCrate.h"
+#include "AliMpLocalBoard.h"
+#include "AliMpDDLStore.h"
+#include "AliMpExMap.h"
+#include "AliMpIntPair.h"
 
-#include "TBits.h"
+#include "AliLog.h"
+#include "AliLoader.h"
+#include "AliRun.h"
+#include <TBits.h>
+#include <TSystem.h>
 
-#include "Riostream.h"
-#include "TSystem.h"
+#include "AliCodeTimer.h"
 
-const Int_t AliMUONTriggerElectronics::fgkNCrates = 16;
 
+/// \cond CLASSIMP
 ClassImp(AliMUONTriggerElectronics)
+/// \endcond
 
 //___________________________________________
-AliMUONTriggerElectronics::AliMUONTriggerElectronics(AliMUONData *Data) 
-: TTask("AliMUONTriggerElectronics",
-        "From trigger digits to Local and Global Trigger objects"),
-  fCrates(new TClonesArray("AliMUONTriggerCrate", fgkNCrates)),
-  fGlobalTriggerBoard(new AliMUONGlobalTriggerBoard),
-  fNCrates(0),
-  fMUONData(Data)
+AliMUONTriggerElectronics::AliMUONTriggerElectronics(AliMUONCalibrationData* calibData) 
+: TObject(),
+  fCrates(new AliMUONTriggerCrateStore),
+  fGlobalTriggerBoard(new AliMUONGlobalTriggerBoard)
 {
-  if (!fMUONData)
-  {  
-    AliFatal("NO MUON TRIGGER DATA");
+ /// CONSTRUCTOR
+///
+
+  for (Int_t i = 0; i < 2; ++i) {
+    fCopyXInput[i] = new TList();
+    fCopyXInput[i]->SetOwner();
+    fCopyYInput[i] = new TList();
+    fCopyYInput[i]->SetOwner();
   }
-    
-  for (Int_t i=0;i<16;i++) 
+
+  // force loading of mapping if not already done
+  if ( !AliMpDDLStore::Instance(kFALSE) )
   {
-    fRegional[i] = 0;
-    for (Int_t j=0;j<16;j++) fLocal[i][j] = 0;
+    AliMpCDB::LoadDDLStore();
   }
-   
-   fGlobal       = 0; 
-
-       fCrateMap = new char*[234];
-       for (Int_t i=0;i<234;i++) fBoardMap[i] = 0;
-       
-   SetDataSource();
-   Factory();
-
-       AliWarning("ZERO-ALLY-LSB TO BE CHECKED!!!");
-       AliWarning("AliMUONLocalTriggerBoard Y_pos DIVIDED BY 2 TO BE CONSISTENT W/ AliMUONTrackReconstructor!!!");
+  
+  SetCopyInput();
+  
+  Factory(calibData);
+  LoadMasks(calibData); 
 }
 
 //___________________________________________
 AliMUONTriggerElectronics::~AliMUONTriggerElectronics()
 {
+/// DESTRUCTOR
+///
   delete fGlobalTriggerBoard;
   delete fCrates;
+  for (Int_t i = 0; i < 2; ++i) {
+    delete fCopyXInput[i];
+    delete fCopyYInput[i];
+  }
 
-  for (Int_t i=0;i<234;i++) if (fCrateMap[i]) {delete [] fCrateMap[i]; fCrateMap[i] = NULL;}
 }
 
 //___________________________________________
-void AliMUONTriggerElectronics::Factory()
+void AliMUONTriggerElectronics::SetCopyInput()
 {  
-   ifstream myInputFile(gSystem->ExpandPathName(fSourceFileName.Data()), ios::in);
-
-   string sLine, sValue;
-
-   if ( !myInputFile ) 
-   {
-      AliError("TRIGGER ELECTRONICS CONFIGURATION FILE COULD NOT BE OPENED");
-   }
-   else
-   {
-      while (getline(myInputFile,sLine))
-      {
-         if (sLine.empty()) continue; // Ignore empty lines
-         else
-         {
-            const Int_t maxfields = 15; char **fields = new char*[maxfields];
-            
-            char s[100]; 
-         
-            if (sLine.find("Board",0) != string::npos) 
-            {   
-               strcpy(s,sLine.c_str());
-               
-               Int_t numlines = 0;
-
-               for (char *token = strtok(s, " ");
-                    token != NULL;
-                    token = strtok(NULL, " "))
-               {
-                  fields[numlines] = new char[strlen(token)+1];
-                  strcpy(fields[numlines++],token);
-               }
-
-               char str[10]; strcpy(str, fields[6]); strcat(str, fields[7]);
-
-               AliMUONTriggerCrate *crate = Crate(str); 
-
-//                                     cout << " Manipulating crate " << str << endl;
-
-
-
-               if (!crate) 
-               {
-                  AddCrate(str); crate = Crate(str);
-                  
-                  AliMUONRegionalTriggerBoard *rboard = new AliMUONRegionalTriggerBoard();
-                  crate->AddBoard(rboard, 0);
-               }               
-
-//             CONVENTION: SLOT 0 HOLDS THE REGIONAL BOARD
-               Int_t sl = atoi(fields[10]);
-
-               AliMUONLocalTriggerBoard *board = new AliMUONLocalTriggerBoard(fields[4], sl);
-
-                                       if (strcmp(fields[1],"nn")) 
-                                       {
-                                               Int_t sboard = atoi(fields[1]);
-
-                                               board->SetNumber(sboard);
-
-                                               fCrateMap[sboard-1] = new char[strlen(str)+1]; strcpy(fCrateMap[sboard-1], str);
-//                                             cout << " fCrateMap[" << sboard-1 << "]: " << fCrateMap[sboard-1] << endl;
-                                               
-                                               fBoardMap[sboard-1] = sl;
-                                       }
-
-                                       board->SetCrate(str);
-
-               crate->AddBoard(board, sl);
-
-               while (getline(myInputFile,sLine)) if (sLine.find("transv",0) != string::npos) break;
-
-               strcpy(s,sLine.c_str());
-
-               for (char *token = strtok(s, " ");
-                    token != NULL;
-                    token = strtok(NULL, " ")) if (!strcmp(token,"NONE")) board->SetTC(kFALSE);
-
-               while (getline(myInputFile,sLine)) if (sLine.find("Switch",0) != string::npos) break;
-
-               while (getline(myInputFile,sLine)) if (!sLine.empty()) break;   
-
-               strcpy(s,sLine.c_str());
-
-               Int_t lines = 0;
-
-               for (char *token = strtok(s, " ");
-                    token != NULL;
-                    token = strtok(NULL, " ")) board->SetSwitch(lines++, atoi(token));
-
-               for (Int_t i = 0; i<numlines; i++) 
-                  if (fields[i]) {delete [] fields[i]; fields[i] = 0;}
-               
-               delete [] fields; fields = 0;
-            }
-         }
+  /// set list of copy input
+  
+    for (Int_t iDDL = 0; iDDL < 2; ++iDDL) { 
+    
+      for(Int_t iReg = 0; iReg < 8; ++iReg){   //reg loop
+      
+       AliMpTriggerCrate* crateMapping = AliMpDDLStore::Instance()->GetTriggerCrate(iDDL, iReg);
+      
+       for(Int_t iLocal = 0; iLocal < crateMapping->GetNofLocalBoards(); ++iLocal) { 
+        
+         Int_t localBoardFromId = crateMapping->GetLocalBoardId(iLocal);
+         if (!localBoardFromId) continue; //empty slot, should not happen
+        
+          AliMpLocalBoard* localBoardFrom = AliMpDDLStore::Instance()->GetLocalBoard(localBoardFromId);
+         Int_t localBoardToId;
+         if ((localBoardToId = localBoardFrom->GetInputXto())) {
+             AliMpLocalBoard* localBoardTo = AliMpDDLStore::Instance()->GetLocalBoard(localBoardToId);
+             TString crateFrom = localBoardFrom->GetCrate();
+             Int_t   slotFrom  = localBoardFrom->GetSlot();
+             TString crateTo   = localBoardTo->GetCrate();
+             Int_t   slotTo    = localBoardTo->GetSlot();
+          
+             fCopyXInput[0]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateFrom), slotFrom));
+             fCopyXInput[1]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateTo), slotTo));
+             AliDebug(3, Form("copy xInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom, 
+                              crateTo.Data(), slotTo));
+         }
+        
+         if ((localBoardToId = localBoardFrom->GetInputYto())) {
+             AliMpLocalBoard* localBoardTo = AliMpDDLStore::Instance()->GetLocalBoard(localBoardToId);
+             TString crateFrom = localBoardFrom->GetCrate();
+             Int_t   slotFrom  = localBoardFrom->GetSlot();
+             TString crateTo   = localBoardTo->GetCrate();
+             Int_t   slotTo    = localBoardTo->GetSlot();
+          
+             fCopyYInput[0]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateFrom), slotFrom));
+             fCopyYInput[1]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateTo), slotTo));
+             AliDebug(3, Form("copy yInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom, 
+                              crateTo.Data(), slotTo));
+          
+         }
+       }
       }
-   }
+    }
 }
 
 //___________________________________________
-void AliMUONTriggerElectronics::Feed()
-{
-       for (Int_t ichamber=10; ichamber<14; ichamber++) 
-       {
-      TClonesArray *MuonDigits = fMUONData->Digits(ichamber);
-      Int_t ndigits = MuonDigits->GetEntriesFast();
-
-      for (Int_t digit=0; digit<ndigits; digit++)
-               {
-                       AliMUONDigit *mdig = static_cast<AliMUONDigit*>(MuonDigits->UncheckedAt(digit));
-
-                       Int_t ix = mdig->PadX(), iy = mdig->PadY();
-
-//       GET THE SUM OF THE CODED CHARGE 
-//       SEE CODING CONVENTION IN AliMUONChamberTrigger::DisIntegration        
-                       Int_t schg = 0;
-                       for (Int_t ichg=0; ichg<10; ichg++) schg += mdig->TrackCharge(ichg);
-      
-//       APPLY CONDITION ON SOFT BACKGROUND    
-                       Int_t tchg = schg - (Int_t(schg/10))*10;        
-
-                       if (schg<=10 || tchg>0) 
-                       {
-                               Int_t cathode = mdig->Cathode();
-
-//          Now identify local board from (ix,iy)
-                               char name[10]; BoardName(ix,iy,name);
-
-                               for (Int_t i=0;i<fgkNCrates;i++)
-                               {            
-                                       AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-            
-                                       TObjArray *boards = cr->Boards();
-            
-                                       AliMUONLocalTriggerBoard *b = (AliMUONLocalTriggerBoard*)boards->FindObject(name);
-
-                                       if (b) 
-                                       {
-                                               Int_t digitindex = digit;
-
-//                Y STRIP IS FIRED ONCE BUT ALL BOARDS FROM THE SAME MODULE ARE FED
-                                               if (cathode)
-                                               {       
-                                                       if (b->GetSwitch(6)) iy += 8;
-
-                                                       char M1[20]; b->Module(M1);
-
-                                                       for (Int_t j=0;j<fgkNCrates;j++)
-                                                       {            
-                                                               AliMUONTriggerCrate *ca = (AliMUONTriggerCrate*)fCrates->UncheckedAt(j);
-            
-                                                               TObjArray *bs = ca->Boards();
-
-                                                               for (Int_t k=1; k<bs->GetEntries()-1; k++)
-                                                               {                                                                       
-                                                                       AliMUONLocalTriggerBoard *h = (AliMUONLocalTriggerBoard*)bs->At(k);
-
-                                                                       if (h)
-                                                                       {
-                                                                               char M2[20]; h->Module(M2);
-                                                                               
-                                                                               if (!strcmp(M1,M2)) h->Setbit(iy,cathode,ichamber-10);
-                                                                       }
-                                                               }
-                                                       }
-                                               }
-                                               else
-                                                       b->Setbit(iy,cathode,ichamber-10);
-
-                                               DigitFiredCircuit(b->GetI(), cathode, ichamber, digitindex);
-                                       }
-                               }
-                       }
-               }
-       }
-
-// Particular case of the columns with 22 local boards (2R(L) 3R(L))   
-       AliMUONTriggerCrate *crate = 0x0; TObjArray *bs = 0x0;
-
-       char *scratess[4] = {  "2R",   "2L",   "3L",   "3R"}; 
-       char *scratesd[4] = {"2-3R", "2-3L", "2-3L", "2-3R"}; 
-       Int_t    slotf[4] = {     2,      2,     10,     10}; 
-       Int_t    slotd[4] = {     1,      1,      9,      9}; 
-
-       for (Int_t i=0; i<4; i++)
-       {
-      crate = (AliMUONTriggerCrate*)fCrates->FindObject(scratess[i]); 
-      bs = crate->Boards();
-      AliMUONLocalTriggerBoard *desybb = (AliMUONLocalTriggerBoard*)bs->At(14);
-      AliMUONLocalTriggerBoard *fromcb = (AliMUONLocalTriggerBoard*)bs->At(15);
-      AliMUONLocalTriggerBoard *desxbb = (AliMUONLocalTriggerBoard*)bs->At(16);
-
-      crate = (AliMUONTriggerCrate*)fCrates->FindObject(scratesd[i]); 
-      bs = crate->Boards();
-      AliMUONLocalTriggerBoard *frombb = (AliMUONLocalTriggerBoard*)bs->At(slotf[i]);
-      AliMUONLocalTriggerBoard *desycb = (AliMUONLocalTriggerBoard*)bs->At(slotd[i]);
-
-      UShort_t cX[2];
-
-//    COPY X3-4 FROM BOARD  2 OF CRATE 2-3 TO BOARD 16 OF CRATE 2
-//    COPY X3-4 FROM BOARD 10 OF CRATE 2-3 TO BOARD 16 OF CRATE 3
-      frombb->GetX34(cX); desxbb->SetX34(cX);
-
-//    COPY X3-4 FROM BOARD 15 OF CRATE 2 TO BOARD 1 OF CRATE 2-3
-//    COPY X3-4 FROM BOARD 15 OF CRATE 3 TO BOARD 9 OF CRATE 2-3
-      fromcb->GetX34(cX); desycb->SetX34(cX);
-
-      UShort_t cY[4];
-
-      desybb->GetY(cY); frombb->SetY(cY);
-       }
+void AliMUONTriggerElectronics::Factory(AliMUONCalibrationData* calibData)
+{  
+ /// BUILD ALL ELECTRONICS
+ ///
 
-// FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
-   for (Int_t i=0; i<fgkNCrates; i++)
-       {            
-               AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-               
-               TObjArray *boards = cr->Boards();
-               
-               for (Int_t j=1; j<boards->GetEntries()-1; j++)
-               {
-                       TObject *o = boards->At(j);
-                       
-                       if (!o) break;
-                       
-                       AliMUONLocalTriggerBoard *currboard = (AliMUONLocalTriggerBoard*)o;
-                       
-                       AliMUONLocalTriggerBoard *neighbour = (AliMUONLocalTriggerBoard*)boards->At(j+1);
-                       
-                       UShort_t cXY[2][4];
-                       
-                       if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
-                       
-//       LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
-                       if (j<boards->GetEntries()-2)  
-                       {
-                               AliMUONLocalTriggerBoard *nextboard = (AliMUONLocalTriggerBoard*)boards->At(j+2);
-                               
-                               currboard->GetXY(cXY); neighbour->SetXYD(cXY);
-                               nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
-                               
-                               if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
-                       }
-               }
-       }
+    fCrates->ReadFromFile(calibData);
 }
 
 //___________________________________________
-void AliMUONTriggerElectronics::FeedM()
+void AliMUONTriggerElectronics::Feed(const AliMUONVDigitStore& digitStore)
 {
-       for (Int_t ichamber=10; ichamber<14; ichamber++) 
-       {
-      TClonesArray *MuonDigits = fMUONData->Digits(ichamber);
-      Int_t ndigits = MuonDigits->GetEntriesFast();
-
-//             cout << " ichamber: " << ichamber << " ndigits: " << ndigits << endl;
-
-      for (Int_t digit=0; digit<ndigits; digit++)
-               {
-                       AliMUONDigit *mdig = static_cast<AliMUONDigit*>(MuonDigits->UncheckedAt(digit));
-
-//       CHECKME ! The TrackCharge is not ok with new digitizerV3 !
-//                     for (Int_t ichg=0; ichg<10; ichg++) schg += mdig->TrackCharge(ichg);
-//       assert(schg==mdig->Signal());
-                       Int_t schg = mdig->Signal();
-         
-//       APPLY CONDITION ON SOFT BACKGROUND    
-                       Int_t tchg = schg - (Int_t(schg/10))*10;        
-
-                       if (schg<=10 || tchg>0) 
-                       {
-//                             mdig->Print();
-
-                               Int_t digitindex = digit;
-                               Int_t detElemId  = mdig->DetElemId();
-                               Int_t cathode    = mdig->Cathode();
-
-                               const AliMpVSegmentation *seg = ((AliMUON*)gAlice->GetDetector("MUON"))->GetSegmentation()->GetMpSegmentation(detElemId,cathode);
-
-                               Int_t ix = mdig->PadX(), iy = mdig->PadY();
-                               
-                               AliDebug(3,Form("cathode %d ix %d iy %d ",cathode,ix,iy));
+  /// FILL INPUTS
+  ///
+
+  AliCodeTimerAuto("",0);
+  
+  TIter next(digitStore.CreateTriggerIterator());
+  AliMUONVDigit* mdig;
+  
+  while ( ( mdig = static_cast<AliMUONVDigit*>(next()) ) )
+  {      
+    //       CHECKME ! The TrackCharge is not ok with new digitizerV3 !
+    //                 for (Int_t ichg=0; ichg<10; ichg++) schg += mdig->TrackCharge(ichg);
+    Int_t ichamber = AliMpDEManager::GetChamberId(mdig->DetElemId());
+    Int_t schg = (Int_t)(mdig->Charge() + 0.5);
+    
+    //       APPLY CONDITION ON SOFT BACKGROUND        
+    Int_t tchg = schg - (Int_t(schg/10))*10;   
+    
+    if (schg<=10 || tchg>0) 
+    {
+      Int_t detElemId  = mdig->DetElemId();
+      Int_t cathode    = mdig->Cathode();
+    
+      const AliMpVSegmentation* seg = 
+         AliMpSegmentation::Instance()
+         ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
+  
+      Int_t ix = mdig->PadX(), iy = mdig->PadY();
+      
+      AliDebug(3,Form("cathode %d ix %d iy %d ",cathode,ix,iy));
 
-                               AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
-                               
-                               for (Int_t i=0; i<pad.GetNofLocations(); i++) 
-                               {
-                                       AliMpIntPair location = pad.GetLocation(i);
-                                       
-                                       Int_t nboard = location.GetFirst();
-
-                                       Int_t ibitxy = location.GetSecond();
-
-
-                                       AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->FindObject(fCrateMap[nboard-1]); 
-
-                                       TObjArray *boards = cr->Boards();
-
-                                       AliMUONLocalTriggerBoard *b = (AliMUONLocalTriggerBoard*)boards->At(fBoardMap[nboard-1]);
-
-//                                     if (b && nboard && b->GetNumber()==nboard) 
-                                       if (b) 
-                                       {
-                                               if (cathode && b->GetSwitch(6)) ibitxy += 8;
-                                               
-//                                             cout << " nboard:\t" << nboard << " ibitxy:\t" << ibitxy << " schg:\t" << schg << " crate:\t" << fCrateMap[nboard-1] << endl;
-
-                                               b->SetbitM(ibitxy,cathode,ichamber-10);
-                                               
-                                               DigitFiredCircuit(b->GetI(), cathode, ichamber, digitindex);
-                                       }
-
-
-//                                     for (Int_t j=0; j<fgkNCrates; j++)
-//                                     {            
-//                                             AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(j);
-                                               
-//                                             TObjArray *boards = cr->Boards();
-                                               
-//                                             for (Int_t k=1; k<boards->GetEntries()-1; k++)
-//                                             {                                                                       
-//                                                     AliMUONLocalTriggerBoard *b = (AliMUONLocalTriggerBoard*)boards->At(k);
-                                                       
-//                                                     if (b && nboard && b->GetNumber()==nboard) 
-//                                                     {
-//                                                             if (cathode && b->GetSwitch(6)) ibitxy += 8;
-
-//                                                             b->SetbitM(ibitxy,cathode,ichamber-10);
-
-// //                                                                  cout << "BOARD: " << b->GetName() << " Number: " << b->GetNumber() 
-// //                                                                            << " ibitxy: " << ibitxy
-// //                                                                    << " nboard: " << nboard 
-// //                                                                    << " ich: " << ichamber-10 << endl;
-                                                               
-//                                                             DigitFiredCircuit(b->GetI(), cathode, ichamber, digitindex);
-//                                                     }
-//                                             }
-//                                     }
-                               }
-                       }                       
-               }
-
-//       fMUONData->ResetDigits();
-       }
+      AliMpPad pad = seg->PadByIndices(ix,iy,kTRUE);
+      
+      for (Int_t i=0; i<pad.GetNofLocations(); i++) 
+      {
+        Int_t nboard = pad.GetLocalBoardId(i);
+        
+        Int_t ibitxy = pad.GetLocalBoardChannel(i);
+        
+        AliMUONLocalTriggerBoard *b = fCrates->LocalBoard(nboard);
+        
+        if (b) 
+        {
+          if (cathode && b->GetSwitch(AliMpLocalBoard::kZeroAllYLSB)) ibitxy += 8;
+          
+          b->SetbitM(ibitxy,cathode,ichamber-10);
+        }
+        else
+        {
+          AliError(Form("Could not get local board number %d",nboard));
+        }
+      }
+    }          
+  }
 
-// Particular case of the columns with 22 local boards (2R(L) 3R(L))   
-       AliMUONTriggerCrate *crate = 0x0; TObjArray *bs = 0x0;
+  FeedCopyNeighbours();
+}
 
-       char *scratess[4] = {  "2R",   "2L",   "3L",   "3R"}; 
-       char *scratesd[4] = {"2-3R", "2-3L", "2-3L", "2-3R"}; 
-       Int_t    slotf[4] = {     2,      2,     10,     10}; 
-       Int_t    slotd[4] = {     1,      1,      9,      9}; 
 
-       for (Int_t i=0; i<4; i++)
-       {
-      crate = (AliMUONTriggerCrate*)fCrates->FindObject(scratess[i]); 
-      bs = crate->Boards();
-      AliMUONLocalTriggerBoard *desybb = (AliMUONLocalTriggerBoard*)bs->At(14);
-      AliMUONLocalTriggerBoard *fromcb = (AliMUONLocalTriggerBoard*)bs->At(15);
-      AliMUONLocalTriggerBoard *desxbb = (AliMUONLocalTriggerBoard*)bs->At(16);
+//___________________________________________
+void AliMUONTriggerElectronics::FeedCopyNeighbours()
+{
+  //
+  /// Feed the local copies
+  /// and complete the feed with the information of neighbours
+  //
 
-      crate = (AliMUONTriggerCrate*)fCrates->FindObject(scratesd[i]); 
-      bs = crate->Boards();
-      AliMUONLocalTriggerBoard *frombb = (AliMUONLocalTriggerBoard*)bs->At(slotf[i]);
-      AliMUONLocalTriggerBoard *desycb = (AliMUONLocalTriggerBoard*)bs->At(slotd[i]);
+  // Particular case of the columns with 22 local boards (2R(L) 3R(L))   
+  // fill copy input from mapping instead of hardcoded valued (Ch.F)
+  AliMUONTriggerCrate *crate = 0x0; TObjArray *bs = 0x0;
 
-      UShort_t cX[2];
+  for (Int_t i = 0; i < fCopyXInput[0]->GetEntries(); ++i) 
+  {
+    AliMpIntPair* pair = (AliMpIntPair*)fCopyXInput[0]->At(i);
+    TString crateFrom  =  AliMpExMap::GetString(pair->GetFirst());
+    Int_t   slotFrom   =  pair->GetSecond();
 
-//    COPY X3-4 FROM BOARD  2 OF CRATE 2-3 TO BOARD 16 OF CRATE 2
-//    COPY X3-4 FROM BOARD 10 OF CRATE 2-3 TO BOARD 16 OF CRATE 3
-      frombb->GetX34(cX); desxbb->SetX34(cX);
+    pair = (AliMpIntPair*)fCopyXInput[1]->At(i);
+    TString crateTo  =  AliMpExMap::GetString(pair->GetFirst());
+    Int_t   slotTo   =  pair->GetSecond();
 
-//    COPY X3-4 FROM BOARD 15 OF CRATE 2 TO BOARD 1 OF CRATE 2-3
-//    COPY X3-4 FROM BOARD 15 OF CRATE 3 TO BOARD 9 OF CRATE 2-3
-      fromcb->GetX34(cX); desycb->SetX34(cX);
+    AliDebug(3, Form("copy xInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom, 
+                    crateTo.Data(), slotTo));
 
-      UShort_t cY[4];
+    UShort_t cX[2];
+    crate = fCrates->Crate(crateFrom); 
+    bs = crate->Boards();
+    AliMUONLocalTriggerBoard *fromxb = (AliMUONLocalTriggerBoard*)bs->At(slotFrom);
+    crate = fCrates->Crate(crateTo); 
+    bs = crate->Boards();
+    AliMUONLocalTriggerBoard *desxb = (AliMUONLocalTriggerBoard*)bs->At(slotTo);
+    fromxb->GetX34(cX); desxb->SetX34(cX);
 
-      desybb->GetY(cY); frombb->SetY(cY);
 
-      frombb->GetY(cY); desxbb->SetY(cY);
-      fromcb->GetY(cY); desycb->SetY(cY);
-       }
+  }
 
-// FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
-   for (Int_t i=0; i<fgkNCrates; i++)
-       {            
-               AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-               
-               TObjArray *boards = cr->Boards();
-               
-               for (Int_t j=1; j<boards->GetEntries()-1; j++)
-               {
-                       TObject *o = boards->At(j);
+  for (Int_t i = 0; i < fCopyYInput[0]->GetEntries(); ++i) 
+  {
+    AliMpIntPair* pair = (AliMpIntPair*)fCopyYInput[0]->At(i);
+    TString crateFrom  =  AliMpExMap::GetString(pair->GetFirst());
+    Int_t   slotFrom   =  pair->GetSecond();
+
+    pair = (AliMpIntPair*)fCopyYInput[1]->At(i);
+    TString crateTo  =  AliMpExMap::GetString(pair->GetFirst());
+    Int_t   slotTo   =  pair->GetSecond();
+
+    AliDebug(3, Form("copy yInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom, 
+                    crateTo.Data(), slotTo));
+
+    UShort_t cY[4];
+    crate = fCrates->Crate(crateFrom); 
+    bs = crate->Boards();
+    AliMUONLocalTriggerBoard *fromyb = (AliMUONLocalTriggerBoard*)bs->At(slotFrom);
+    crate = fCrates->Crate(crateTo); 
+    bs = crate->Boards();
+    AliMUONLocalTriggerBoard *desyb = (AliMUONLocalTriggerBoard*)bs->At(slotTo);
+    fromyb->GetY(cY); desyb->SetY(cY);
+  }
+  
+  // FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
+  AliMUONTriggerCrate* cr;
+  TIter next2(fCrates->CreateCrateIterator());
+  
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next2()) ) )
+  {            
+    TObjArray *boards = cr->Boards();
+    
+    for (Int_t j = 1; j < boards->GetEntries()-1; j++)
+    {
+      TObject *o = boards->At(j);
                        
-                       if (!o) break;
+      if (!o) break;
                        
-                       AliMUONLocalTriggerBoard *currboard = (AliMUONLocalTriggerBoard*)o;
+      AliMUONLocalTriggerBoard *currboard = (AliMUONLocalTriggerBoard*)o;
                        
-                       AliMUONLocalTriggerBoard *neighbour = (AliMUONLocalTriggerBoard*)boards->At(j+1);
+      AliMUONLocalTriggerBoard *neighbour = (AliMUONLocalTriggerBoard*)boards->At(j+1);
                        
-                       UShort_t cXY[2][4];
+      UShort_t cXY[2][4];
                        
-                       if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
+      if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
                        
-//       LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
-                       if (j<boards->GetEntries()-2)  
-                       {
-                               AliMUONLocalTriggerBoard *nextboard = (AliMUONLocalTriggerBoard*)boards->At(j+2);
+      //       LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
+      if (j < boards->GetEntries()-2)  
+      {
+             AliMUONLocalTriggerBoard *nextboard = (AliMUONLocalTriggerBoard*)boards->At(j+2);
                                
-                               currboard->GetXY(cXY); neighbour->SetXYD(cXY);
-                               nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
+             currboard->GetXY(cXY); neighbour->SetXYD(cXY);
+             nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
                                
-                               if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
-                       }
-               }
-       }
+             if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
+      }
+    }
+  }
 }
 
+
 //___________________________________________
 void AliMUONTriggerElectronics::Feed(UShort_t pattern[2][4])
 {
-   for (Int_t i=0; i<fgkNCrates; i++)
-   {            
-      AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-      
-      TObjArray *boards = cr->Boards();
-      
-      for (Int_t j=1; j<boards->GetEntries(); j++)
-      {
-         TObject *o = boards->At(j);
-         
-         if (!o) break;
-
-         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
-         
-         board->SetXY(pattern);
-      }
+  /// FILL INPUTS
+  ///
+  AliMUONTriggerCrate* cr;
+  TIter next(fCrates->CreateCrateIterator());
+   
+   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
+   {                 
+     TObjArray *boards = cr->Boards();
+     
+     for (Int_t j = 1; j < boards->GetEntries(); j++)
+     {
+       TObject *o = boards->At(j);
+       
+       if (!o) break;
+       
+       AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
+       
+       board->SetXY(pattern);
+     }
    }
 }
 
 //___________________________________________
 void AliMUONTriggerElectronics::DumpOS()
 {
-   for (Int_t i=0;i<234;i++)
+/// DUMP IN THE OLD WAY
+///
+   for (Int_t i= 0; i < 234;i++)
    {
-      char name[20];
-      BuildName(i,name);
-
-      for (Int_t i=0; i<fgkNCrates; i++)
-      {            
-         AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-            
-         TObjArray *boards = cr->Boards();
+      AliMUONLocalTriggerBoard *board = fCrates->LocalBoard(i);
 
-         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)boards->FindObject(name);
-
-                       if (board) board->Scan("ALL");
-      }
+      if (board) board->Scan("ALL");
    }
 }
 
 //___________________________________________
-void AliMUONTriggerElectronics::Scan(Option_t *option)
+void AliMUONTriggerElectronics::Scan(const Option_t *option)
 {
-   for (Int_t i=0; i<fgkNCrates; i++)
-   {            
-      AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-            
-      TObjArray *boards = cr->Boards();
-
-      for (Int_t j=0; j<boards->GetEntries(); j++)
-      {
-         TObject *o = boards->At(j);
-
-         TString op = option;
-
-         Bool_t cdtion = kFALSE;
-
-         if (op.Contains("LOCAL"))    cdtion = o->IsA() == AliMUONLocalTriggerBoard::Class();
-         if (op.Contains("REGIONAL")) cdtion = o->IsA() == AliMUONRegionalTriggerBoard::Class();
-         if (op.Contains("GLOBAL"))   cdtion = o->IsA() == AliMUONGlobalTriggerBoard::Class();
-         
-         if (!o || !cdtion) continue;
-
-         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
-
-         board->Scan();
-      }
-   }
+  /// SCAN
+  ///
+
+  AliMUONTriggerCrate* cr;
+  TIter next(fCrates->CreateCrateIterator());  
+  
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
+  {                
+    TObjArray *boards = cr->Boards();
+    
+    for (Int_t j = 0; j < boards->GetEntries(); j++)
+    {
+      TObject *o = boards->At(j);
+      
+      TString op = option;
+      
+      Bool_t cdtion = kFALSE;
+      
+      if (op.Contains("LOCAL"))    cdtion = o->IsA() == AliMUONLocalTriggerBoard::Class();
+      if (op.Contains("REGIONAL")) cdtion = o->IsA() == AliMUONRegionalTriggerBoard::Class();
+      if (op.Contains("GLOBAL"))   cdtion = o->IsA() == AliMUONGlobalTriggerBoard::Class();
+      
+      if (!o || !cdtion) continue;
+      
+      AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
+      
+      board->Scan();
+    }
+  }
 }
 
 //___________________________________________
 void AliMUONTriggerElectronics::Reset()
 {
-   for (Int_t i=0; i<fgkNCrates; i++)
+  /// RESET
+  ///
+  
+   AliMUONTriggerCrate* cr;
+  TIter next(fCrates->CreateCrateIterator());
+   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
    {            
-      AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-            
       TObjArray *boards = cr->Boards();
             
       for (Int_t j=0; j<boards->GetEntries(); j++)
@@ -599,364 +422,419 @@ void AliMUONTriggerElectronics::Reset()
          if (b) b->Reset();
       }
    }
-
-   for (Int_t i=0;i<16;i++) 
-   {
-      fRegional[i] = 0;
-      for (Int_t j=0;j<16;j++) fLocal[i][j] = 0;
-   }
-
-   fGlobal = 0;
 }
 
-//___________________________________________
-void AliMUONTriggerElectronics::LocalResponse()
+
+//_______________________________________________________________________
+void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
 {
-// INTERFACE BOARDS
-       struct crates_t 
-       {
-                       TString name;
-                       Int_t slots[5];
-                       Int_t ns;
-       } crate[6];
-
-       crate[0].name = "2R";   crate[0].ns = 1; crate[0].slots[0] = 16;
-       crate[1].name = "2L";   crate[1].ns = 1; crate[1].slots[0] = 16;
-       crate[2].name = "3L";   crate[2].ns = 1; crate[2].slots[0] = 16;
-       crate[3].name = "3R";   crate[3].ns = 1; crate[3].slots[0] = 16;
-       crate[4].name = "2-3R"; crate[4].ns = 2; crate[4].slots[0] = 1;  crate[4].slots[1] = 9;
-       crate[5].name = "2-3L"; crate[5].ns = 2; crate[5].slots[0] = 1;  crate[5].slots[1] = 9; 
-       
-   for (Int_t i=0; i<fgkNCrates; i++)
-   {           
-      Int_t iib = -1;
+  /// Load mask from config in CDB 
+  
+  // Set mask
+  
+  AliMUONRegionalTriggerConfig* regionalConfig = calibData->RegionalTriggerConfig();
+  if (!regionalConfig) {
+     AliError("No valid regional trigger configuration in CDB");
+     return;
+  }   
+  
+  AliMUONTriggerCrate* cr;
+  TIter next(fCrates->CreateCrateIterator());
+  
+  Int_t irb(0);
+  
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
+  {            
+    TObjArray *boards = cr->Boards();
+    
+    AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
+
+    AliMUONTriggerCrateConfig* crateConfig = regionalConfig->FindTriggerCrate(cr->GetName());
+    
+    if (!crateConfig)
+    {
+      AliError(Form("Crate %s not present in configuration !!!", cr->GetName()));
+      return;
+    }
+    
+    UShort_t rmask= crateConfig->GetMask();
+
+    regb->Mask(rmask);
+    
+    for (Int_t j = 1; j < boards->GetEntries(); j++)
+    {
+      AliMUONLocalTriggerBoard *b = (AliMUONLocalTriggerBoard*)boards->At(j);
       
-      AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-            
-      for (Int_t icr=0; icr<6; icr++) 
+      Int_t cardNumber = b->GetNumber();
+      
+      if (cardNumber) // interface board are not interested
       {
-                       const char *n = (crate[icr].name).Data();
-                       
-         AliMUONTriggerCrate *dcr = (AliMUONTriggerCrate*)fCrates->FindObject(n);
-
-//       THIS CRATE CONTAINS AN INTERFACE BOARD
-         if ( dcr && !strcmp(cr->GetName(),dcr->GetName()) ) iib = icr;
+        AliMUONVCalibParam* localBoardMasks = calibData->LocalTriggerBoardMasks(cardNumber);
+        for ( Int_t i = 0; i < localBoardMasks->Size(); ++i )
+        {
+          UShort_t lmask = static_cast<UShort_t>(localBoardMasks->ValueAsInt(i) & 0xFFFF);
+          b->Mask(i,lmask);
+        }
       }
+    }
+    ++irb;
+  }
+  
+   AliMUONGlobalCrateConfig * globalConfig = calibData->GlobalTriggerCrateConfig();
+   if (!globalConfig) {
+     AliError("No valid trigger crate configuration in CDB");
+     return;
+   }   
+
+    UInt_t gmask = 0;
+    for (Int_t i = 0; i < 4; i++) {
+      gmask = globalConfig->GetGlobalMask(i);
+      fGlobalTriggerBoard->Mask(i,gmask);
+    }
+}
 
-      TObjArray *boards = cr->Boards();
-
-      AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
-
-      for (Int_t j=1; j<boards->GetEntries(); j++)
-      {     
-         TObject *o = boards->At(j);
+//___________________________________________
+void AliMUONTriggerElectronics::LocalResponse()
+{
+/// Compute the response for local cards
 
-         if (!o) break;
+  AliCodeTimerAuto("",0);
+       
+  AliMUONTriggerCrate* cr;
+  TIter next(fCrates->CreateCrateIterator());
 
-         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
+  UShort_t thisl[16];
+  
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
+  {            
+    
+    TObjArray *boards = cr->Boards();
+    
+    AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
+    
+    for (Int_t j=0; j<16; ++j) thisl[j] = 0;
+  
+    for (Int_t j = 1; j < boards->GetEntries(); j++)
+    {     
+       TObject *o = boards->At(j);
+      
+       if (!o) break;
+      
+       AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
 
-         if (board) 
-         {
-            board->Response();
+       board->Response();
                                
-            fLocal[i][j-1] = board->GetResponse();            
-
-//          CRATE CONTAINING INTERFACE BOARD
-            if ( iib>-1 ) 
-            {
-               for (Int_t iid = 0; iid<crate[iib].ns; iid++) 
-                                       {
-                  if ( j == crate[iib].slots[iid] )
-                                               {
-                     if ( fLocal[i][j-1] != 0 ) 
-                        AliWarning(Form("Interface board %s in slot %d of crate %s has a non zero response",
-                                        board->GetName(),j,cr->GetName()));
-                                               }
-                                       }                                       
-            }
-         }
-
-         UShort_t thisl[16]; for (Int_t j=0; j<16; j++) thisl[j] = 0;
-
-         for (Int_t j=1; j<boards->GetEntries(); j++) thisl[j] = fLocal[i][j-1];
-
-         regb->SetLocalResponse(thisl);
-      }
-   }
+       UShort_t response = board->GetResponse();            
+        
+       // CRATE CONTAINING INTERFACE BOARD
+       if (board->GetNumber() == 0) // copy boards
+       {
+         if ( response != 0 ) 
+           AliWarning(Form("Interface board %s in slot %d of crate %s has a non zero response",
+                           board->GetName(),j,cr->GetName()));
+         AliDebug(1, Form("local slot %d, number %d in crate %s\n", j, board->GetNumber(), cr->GetName()));
+         
+       }
+        
+       thisl[j-1] = response;
+    }
+    
+    regb->SetLocalResponse(thisl);
+  }
 }
 
 //___________________________________________
 void AliMUONTriggerElectronics::RegionalResponse()
 {
-   for (Int_t i=0; i<fgkNCrates; i++)
-   {            
-      AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-            
+  /// Compute the response for all regional cards.
+
+  AliCodeTimerAuto("",0);
+
+  AliMUONTriggerCrate* cr;
+  TIter next(fCrates->CreateCrateIterator());
+  
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
+  {            
       TObjArray *boards = cr->Boards();
 
       AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
-      
-      if (regb) 
-      {
-         regb->Response();
 
-         fRegional[i] = regb->GetResponse();
-      }  
+      regb->Response();
+
    }
 }
 
 //___________________________________________
 void AliMUONTriggerElectronics::GlobalResponse()
 {
-   fGlobalTriggerBoard->SetRegionalResponse(fRegional);
-
-   fGlobalTriggerBoard->Response();
-
-   fGlobal = fGlobalTriggerBoard->GetResponse();
-}
-
-//___________________________________________
-void AliMUONTriggerElectronics::BoardName(Int_t ix, Int_t iy, char *name)
-{
-   TString s = (ix>0) ? "R" : "L"; 
-
-   Int_t board = iy / 16, bid[4] = {12,34,56,78}; 
+  /// Compute the global response
 
-   ix = abs(ix);
+  AliCodeTimerAuto("",0);
 
-   Int_t line = ix / 10, column = ix - 10 * line;
+  UShort_t regional[16];
+  
+  AliMUONTriggerCrate* cr;
+  Int_t irb(0);
+  
+  if ( !fCrates->NumberOfCrates() >= 16 ) 
+  {
+    AliFatal(Form("Something is wrong : too many crates %d",
+                  fCrates->NumberOfCrates()));
+  }
 
-// old scheme: line==1 is line==9
-   line -= 9; line = TMath::Abs(line); line++;
+  // send regional responses to the global trigger in right order
+  // do not used iterator order
+  
+  for (Int_t iSide = 0; iSide < 2; iSide++) // right & left side
+  {            
+    for (Int_t iReg = 0; iReg < 8; iReg++) // 8 crates/regional boards for each side.
+    {
+      cr = fCrates->Crate(iSide, iReg);     
+
+      AliMUONTriggerBoard* rb = 
+       static_cast<AliMUONTriggerBoard*>(cr->Boards()->At(0));
+      regional[irb] = rb->GetResponse();
+      ++irb;
+    }
+  }
 
-   sprintf(name,"%sC%dL%dB%d", s.Data(), column, line, bid[board]);
-   
-   AliDebug(3, Form("Strip ( %d , %d ) connected to board %s ", ix, iy, name));
+  fGlobalTriggerBoard->SetRegionalResponse(regional);
+  fGlobalTriggerBoard->Response();
 }
 
-//___________________________________________
-void AliMUONTriggerElectronics::AddCrate(char *name)
+//_______________________________________________________________________
+void AliMUONTriggerElectronics::Digits2Trigger(const AliMUONVDigitStore& digitStore,
+                                               AliMUONVTriggerStore& triggerStore)
 {
-   TClonesArray &lcrates = *fCrates;
-   new(lcrates[fNCrates++]) AliMUONTriggerCrate(name,17);
-}
+  AliCodeTimerAuto("",0);
+
+  /// Main method to go from digits to trigger decision
+  AliMUONRegionalTrigger pRegTrig;
+  
+  triggerStore.Clear();
+
+  // NOW RESET ELECTRONICS
+  Reset();
+  
+  // RUN THE FULL BEE CHAIN
+  Feed(digitStore);
+  LocalResponse();
+  RegionalResponse();      
+  GlobalResponse();
+  //    DumpOS();
+       
+  AliMUONTriggerCrate* cr;
+  AliMUONLocalTrigger localTrigger;
+  
+  // stored in right order
+  // do not used iterator order
+  
+  for (Int_t iSide = 0; iSide < 2; iSide++) // right & left side
+  {            
+    for (Int_t iReg = 0; iReg < 8; iReg++) // 8 crates/regional boards for each side.
+    {
+      cr = fCrates->Crate(iSide, iReg);     
+      TObjArray *boards = cr->Boards();
+      
+      UInt_t regInpLpt = 0;
+      UInt_t regInpHpt = 0;
+      
+      AliMUONRegionalTriggerBoard *regBoard = (AliMUONRegionalTriggerBoard*)boards->At(0);
+      
+      for (Int_t j = 1; j < boards->GetEntries(); j++)
+      {     
+        TObject *o = boards->At(j);
+        
+        if (!o) break;
+        
+        AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
+        
+        if (board) 
+        {
+          //          L0 TRIGGER
+          // pcrochet 181206: MOOD needs ALL boards
+          //     if (board->Triggered())
+          //     {
+          
+          Int_t icirc = board->GetNumber();
+          if (icirc != 0) { // pcrochet 181206: MOOD needs ALL boards
+            
+            localTrigger.SetLoCircuit(icirc);
+            localTrigger.SetLoStripX(board->GetStripX11());
+            localTrigger.SetLoDev(board->GetDev());
+            localTrigger.SetLoSdev(board->GetSdev());
+            localTrigger.SetLoTrigY(board->GetTrigY());
+            localTrigger.SetLoStripY(board->GetStripY11());
+            
+            //             SAVE LUT OUTPUT 
+            UShort_t response = board->GetResponse();
+            localTrigger.SetLoHpt((response & 12) >> 2);
+            localTrigger.SetLoLpt(response &  3);
+            
+            // calculates regional inputs from local for the moment
+            UInt_t hPt = (response >> 2) & 0x3;
+            UInt_t lPt =  response       & 0x3;
+            
+            regInpHpt |= hPt << (30 - (j-1)*2);
+            regInpLpt |= lPt << (30 - (j-1)*2);
+            
+            TBits rrr;
+            rrr.Set(6,&response);        
+            
+            //             SAVE BIT PATTERN
+            localTrigger.SetX1Pattern(board->GetXY(0,0));
+            localTrigger.SetX2Pattern(board->GetXY(0,1));
+            localTrigger.SetX3Pattern(board->GetXY(0,2));
+            localTrigger.SetX4Pattern(board->GetXY(0,3));
+            
+            localTrigger.SetY1Pattern(board->GetXY(1,0));
+            localTrigger.SetY2Pattern(board->GetXY(1,1));
+            localTrigger.SetY3Pattern(board->GetXY(1,2));
+            localTrigger.SetY4Pattern(board->GetXY(1,3));
+            
+            //             ADD A NEW LOCAL TRIGGER          
+            triggerStore.Add(localTrigger);  
+            
+          }
+          }
+        }
+      pRegTrig.SetId(iReg + 8*iSide);
+      pRegTrig.SetLocalOutput(regInpLpt, 0);
+      pRegTrig.SetLocalOutput(regInpHpt, 1);
+      pRegTrig.SetOutput(regBoard->GetResponse());
+      
+      triggerStore.Add(pRegTrig);  
+      }
+    }
+  
+  // GLOBAL TRIGGER INFORMATION
+  UShort_t global = fGlobalTriggerBoard->GetResponse();
+  UInt_t *globalInput = fGlobalTriggerBoard->GetGlobalInput();  
+
+  AliMUONGlobalTrigger globalTrigger;
+  
+  globalTrigger.SetFromGlobalResponse(global);
+  globalTrigger.SetFromGlobalInput(globalInput);
+  // ADD A LOCAL TRIGGER IN THE LIST 
+  triggerStore.SetGlobal(globalTrigger);
 
-//___________________________________________
-AliMUONTriggerCrate* AliMUONTriggerElectronics::Crate(char *name)
-{
-   return (AliMUONTriggerCrate*)fCrates->FindObject(name);
 }
 
 //___________________________________________
-void AliMUONTriggerElectronics::BuildName(Int_t icirc, char name[20])
+void AliMUONTriggerElectronics::Feed(const AliMUONVTriggerStore& triggerStore)
 {
-   const Int_t CircuitId[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 
-      };
-
-   Int_t b[4] = {12, 34, 56, 78};
-
-   Int_t code = TMath::Abs(CircuitId[icirc]);
-
-   Int_t L = code / 100;
-
-   Int_t C = ( code - 100 * L ) / 10;
-   
-   Int_t B = code - 100 * L - 10 * C;
-   
-   const char *Side = (CircuitId[icirc]>0) ? "R" : "L";
-
-// L=1 AT TOP
-   L -= 9; L = abs(L); L++;
+  //
+  /// Fill inputs from reconstructed local trigger store
+  //
+  AliMUONLocalTrigger* locTrg;
+  TIter next(triggerStore.CreateLocalIterator());
+  TArrayS xyPattern[2];
+  UShort_t xy[2][4];
+  Int_t loCircuit;
+  while ( ( locTrg = static_cast<AliMUONLocalTrigger*>( next() )) != NULL ){
+    locTrg->GetXPattern(xyPattern[0]);
+    locTrg->GetYPattern(xyPattern[1]);
+    loCircuit = locTrg->LoCircuit();
+    AliMUONLocalTriggerBoard* localBoard = fCrates->LocalBoard(loCircuit);
+    for (Int_t icath = 0; icath<2; ++icath){
+      for (Int_t ich = 0; ich < 4; ++ich){
+       xy[icath][ich] = xyPattern[icath][ich];
+      }
+    }
+    localBoard->SetXY(xy);
+  }
 
-   sprintf(name,"%sC%dL%dB%d",Side,C,L,b[B-1]);
+  FeedCopyNeighbours();
 }
 
 //_______________________________________________________________________
-void 
-AliMUONTriggerElectronics::Exec(Option_t*)
+Bool_t AliMUONTriggerElectronics::ModifiedLocalResponse(Int_t loCircuit,
+                                                       Bool_t& bendingPlaneResp,
+                                                       Bool_t& nonBendingPlaneResp,
+                                                       Bool_t isCoinc44,
+                                                       Int_t removeChamber)
 {
-  Digits2Trigger();
-}
+  //
+  /// Re-compute the local trigger response
+  /// with some modifications (i.e. setting coinc44 or after removing one chamber)
+  //
 
-//_______________________________________________________________________
-void AliMUONTriggerElectronics::Trigger()
-{
-   FeedM();
-   LocalResponse();
-   RegionalResponse();      
-   GlobalResponse();
-}
-/*
-//_______________________________________________________________________
-void AliMUONTriggerElectronics::DisableCrate(Int_t icrate)
-{
-   fRegional[icrate] = 0;
-}
+  bendingPlaneResp = kFALSE;
+  nonBendingPlaneResp = kFALSE;
 
-//_______________________________________________________________________
-void AliMUONTriggerElectronics::DisableCrate(char *Name)
-{
-   Int_t icrate;
-   
-   for (Int_t i=0; i<fgkNCrates; i++)
-   {
-      AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-      if (strcmp(cr->GetName(),Name) )
-         continue;
-      else
-      {
-         icrate = i;
-         break;
-      }
-   }
+  Bool_t isTriggered = kFALSE;
 
-   fRegional[icrate] = 0;
-}
+  AliMUONLocalTriggerBoard* currBoard = fCrates->LocalBoard(loCircuit);
 
-//_______________________________________________________________________
-void AliMUONTriggerElectronics::DisableBoardInCrate(Int_t icrate, Int_t islot)
-{
-// BEWARE, REGIONAL BOARD IS IN SLOT 0
-   fLocal[icrate][islot] = 0;
-}
-*/
-//_______________________________________________________________________
-void AliMUONTriggerElectronics::Digits2Trigger()
-{
-   ClearDigitNumbers();
+  if ( ! currBoard ) return isTriggered;
 
-   fMUONData->ResetTrigger();
+  AliMUONLocalTriggerBoard localBoard (*currBoard);
 
-// RUN THE FULL BEE CHAIN
-   Trigger();
-//     DumpOS();
-       
-   for (Int_t i=0; i<fgkNCrates; i++)
-   {            
-      AliMUONTriggerCrate *cr = (AliMUONTriggerCrate*)fCrates->UncheckedAt(i);
-            
-      TObjArray *boards = cr->Boards();
+  if (removeChamber>=0 && removeChamber<=3){
 
-      for (Int_t j=1; j<boards->GetEntries(); j++)
-      {     
-         TObject *o = boards->At(j);
-
-         if (!o) break;
-
-         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
-
-         if (board) 
-         {
-//          L0 TRIGGER
-            if (board->Triggered())
-            {
-               Int_t localtr[15] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0};
-
-               Int_t icirc = board->GetI();
-
-               localtr[0] = icirc;
-               localtr[1] = board->GetStripX11();
-               localtr[2] = board->GetDev();
-               localtr[3] = board->GetStripY11();
-
-//             SAVE LUT OUTPUT 
-               localtr[4] = (fLocal[i][j-1] & 12) >> 2;
-               localtr[5] = (fLocal[i][j-1] & 48) >> 4;
-               localtr[6] = (fLocal[i][j-1] &  3);
-               
-//             SAVE BIT PATTERN
-               localtr[7]  = board->GetXY(0,0);
-               localtr[8]  = board->GetXY(0,1);
-               localtr[9]  = board->GetXY(0,2);
-               localtr[10] = board->GetXY(0,3);
-
-               localtr[11] = board->GetXY(1,0);
-               localtr[12] = board->GetXY(1,1);
-               localtr[13] = board->GetXY(1,2);
-               localtr[14] = board->GetXY(1,3);
-
-//             ADD A NEW LOCAL TRIGGER
-               AliMUONLocalTrigger *pLocTrig = new AliMUONLocalTrigger(localtr, fDigitNumbers[icirc]);
-
-               fMUONData->AddLocalTrigger(*pLocTrig);  
-            }
-         }
-      }
-   }
+    // Set the bit pattern of selected chamber to 0
+    UShort_t xy[2][4];
+    UShort_t xyu[2][4];
+    UShort_t xyd[2][4];
 
-// GLOBAL TRIGGER INFORMATION: [0] -> LOW PT 
-//                             [1] -> HIGH PT
-//                             [2] -> ALL PT 
-   Int_t GlobalSinglePlus[3], GlobalSingleMinus[3], GlobalSingleUndef[3]; 
-   Int_t GlobalPairUnlike[3], GlobalPairLike[3];   
+    localBoard.GetXY(xy);
+    localBoard.GetXYU(xyu);
+    localBoard.GetXYD(xyd);
 
-   GlobalPairUnlike[0] = (fGlobal &  16) >> 4;
-   GlobalPairUnlike[1] = (fGlobal & 256) >> 8;
-   GlobalPairUnlike[2] = (fGlobal &   1);
-   
-   GlobalPairLike[0] = (fGlobal &  32) >> 5;
-   GlobalPairLike[1] = (fGlobal & 512) >> 9;
-   GlobalPairLike[2] = (fGlobal &   2) >> 1;
-   
-   GlobalSinglePlus[0] = ((fGlobal &  192) >>  6) == 2;
-   GlobalSinglePlus[1] = ((fGlobal & 3072) >> 10) == 2;
-   GlobalSinglePlus[2] = ((fGlobal &   12) >>  2) == 2;
+    for(Int_t icath=0; icath<2; icath++){
+      xy[icath][removeChamber] = 0;
+      xyu[icath][removeChamber] = 0;
+      xyd[icath][removeChamber] = 0;
+    }
 
-   GlobalSingleMinus[0] = ((fGlobal &  192) >>  6) == 1;
-   GlobalSingleMinus[1] = ((fGlobal & 3072) >> 10) == 1;
-   GlobalSingleMinus[2] = ((fGlobal &   12) >>  2) == 1;
-   
-   GlobalSingleUndef[0] = ((fGlobal &  192) >>  6) == 3;
-   GlobalSingleUndef[1] = ((fGlobal & 3072) >> 10) == 3;
-   GlobalSingleUndef[2] = ((fGlobal &   12) >>  2) == 3;
+    localBoard.SetXY(xy);
+    localBoard.SetXYU(xyu);
+    localBoard.SetXYD(xyd);
+  }
 
-   AliMUONGlobalTrigger *pGloTrig = new AliMUONGlobalTrigger(GlobalSinglePlus, GlobalSingleMinus,
-                                                             GlobalSingleUndef, GlobalPairUnlike, 
-                                                             GlobalPairLike);
+  localBoard.ResetResponse();
 
-// ADD A LOCAL TRIGGER IN THE LIST 
-   fMUONData->AddGlobalTrigger(*pGloTrig);
+  localBoard.SetCoinc44((Int_t)isCoinc44);
+  localBoard.Response();
 
-// NOW RESET ELECTRONICS
-   Reset();
-}
+  bendingPlaneResp = localBoard.IsTrigX();
+  nonBendingPlaneResp = localBoard.IsTrigY();
+  isTriggered = localBoard.Triggered();
 
-//_______________________________________________________________________
-void AliMUONTriggerElectronics::ClearDigitNumbers()
-{
-// RESET fDigitNumbers
-       for (Int_t i=0; i<AliMUONConstants::NTriggerCircuit(); i++) fDigitNumbers[i].Set(0);
+  return isTriggered;
 }
 
+
 //_______________________________________________________________________
-void AliMUONTriggerElectronics::DigitFiredCircuit(Int_t circuit, Int_t cathode,
-                                                  Int_t chamber, Int_t digit)
+void AliMUONTriggerElectronics::ResponseRemovingChambers(AliMUONVTriggerStore& triggerStore)
 {
-// REGISTERS THAT THE SPECIFIED DIGIT FIRED THE SPECIFIED CIRCUIT
-// THIS DIGIT GETS ADDED TO AN ARRAY WHICH WILL BE COPIED TO
-// AliMUONLocalTrigger WHEN SUCH AN OBJECT IS CREATED FOR EACH CIRCUIT
-       Int_t digitnumber = AliMUONLocalTrigger::EncodeDigitNumber(chamber, cathode, digit);
-       Int_t last = fDigitNumbers[circuit].GetSize();
-       fDigitNumbers[circuit].Set(last + 1);
-       fDigitNumbers[circuit][last] = digitnumber;
+  /// Update local board information with the trigger response after removing each chamber
+
+  AliCodeTimerAuto("", 0);
+
+  Reset();
+  Feed(triggerStore);
+
+  AliMUONLocalTrigger* locTrg;
+  TIter next(triggerStore.CreateLocalIterator());
+  Int_t loCircuit;
+  Bool_t planeResp[2], isTrig44;
+  Bool_t bendPlaneRespNoCh, nonBendPlaneRespNoCh, isTrigWithoutCh;
+  while ( ( locTrg = static_cast<AliMUONLocalTrigger*>( next() )) != NULL ){
+    if ( ! ( locTrg->IsTrigX() && locTrg->IsTrigY() ) ) continue;
+    loCircuit = locTrg->LoCircuit();
+    isTrig44 = ModifiedLocalResponse(loCircuit, planeResp[0], planeResp[1], kTRUE);
+    for (Int_t ich=0; ich<4; ++ich){
+      if ( ! isTrig44 ){
+       isTrigWithoutCh = ModifiedLocalResponse(loCircuit, bendPlaneRespNoCh, nonBendPlaneRespNoCh, kFALSE, ich);
+       if ( ! isTrigWithoutCh ) continue;
+       for (Int_t icath=0; icath<2; icath++){
+         if ( ! planeResp[icath] )
+           locTrg->SetNoHitInPlane(icath, ich);
+       } // loop on cathodes
+      }
+      locTrg->SetTriggerWithoutChamber(ich);
+    } // loop on chambers
+    AliDebug(1, Form("Is44 %i  triggers %i  pattern %i", isTrig44, locTrg->GetTriggerWithoutChamber(), locTrg->GetHitPatternFromResponse()));
+  }
 }
-