MUON/AliMUONTriggerElectronics.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //-----------------------------------------------------------------------------
  19 // Class AliMUONTriggerElectronics
  20 //--------------------------------
  21 // Manager class for muon trigger electronics
  22 // Client of trigger board classes
  23 // Debugged by Ph. Crochet & Ch. Finck
  24 // Interfaced with new mapping Ch. Finck
  25 //
  26 // Author: Rachid Guernane (LPCCFd)
  27 //-----------------------------------------------------------------------------
  28
  29 #include "AliLoader.h"
  30 #include "AliLog.h"
  31 #include "AliMUONCalibrationData.h"
  32 #include "AliMUONVDigit.h"
  33 #include "AliMUONVDigitStore.h"
  34 #include "AliMUONGlobalTrigger.h"
  35 #include "AliMUONGlobalTriggerBoard.h"
  36 #include "AliMUONLocalTrigger.h"
  37 #include "AliMUONLocalTriggerBoard.h"
  38 #include "AliMUONRegionalTrigger.h"
  39 #include "AliMUONRegionalTriggerBoard.h"
  40 #include "AliMUONTriggerCrate.h"
  41 #include "AliMUONTriggerCrateStore.h"
  42 #include "AliMUONTriggerElectronics.h"
  43 #include "AliMUONTriggerCrateConfig.h"
  44 #include "AliMUONRegionalTriggerConfig.h"
  45 #include "AliMUONGlobalCrateConfig.h"
  46 #include "AliMUONVTriggerStore.h"
  47 #include "AliMUONVCalibParam.h"
  48 #include "AliMpCathodType.h"
  49 #include "AliMpCDB.h"
  50 #include "AliMpDEManager.h"
  51 #include "AliMpSegmentation.h"
  52 #include "AliMpVSegmentation.h"
  53 #include "AliMpCathodType.h"
  54 #include "AliMpTriggerCrate.h"
  55 #include "AliMpLocalBoard.h"
  56 #include "AliMpDDLStore.h"
  57 #include "AliMpExMap.h"
  58 #include "AliMpIntPair.h"
  59
  60 #include "AliLog.h"
  61 #include "AliLoader.h"
  62 #include "AliRun.h"
  63 #include <TBits.h>
  64 #include <TSystem.h>
  65
  66
  67 /// \cond CLASSIMP
  68 ClassImp(AliMUONTriggerElectronics)
  69 /// \endcond
  70
  71 //___________________________________________
  72 AliMUONTriggerElectronics::AliMUONTriggerElectronics(AliMUONCalibrationData* calibData)
  73 : TObject(),
  74   fCrates(new AliMUONTriggerCrateStore),
  75   fGlobalTriggerBoard(new AliMUONGlobalTriggerBoard)
  76 {
  77  /// CONSTRUCTOR
  78 ///
  79
  80   for (Int_t i = 0; i < 2; ++i) {
  81     fCopyXInput[i] = new TList();
  82     fCopyXInput[i]->SetOwner();
  83     fCopyYInput[i] = new TList();
  84     fCopyYInput[i]->SetOwner();
  85   }
  86
  87   // force loading of mapping if not already done
  88   if ( !AliMpDDLStore::Instance(kFALSE) )
  89   {
  90     AliMpCDB::LoadDDLStore();
  91   }
  92
  93   SetCopyInput();
  94
  95   Factory(calibData);
  96   LoadMasks(calibData);
  97 }
  98
  99 //___________________________________________
 100 AliMUONTriggerElectronics::~AliMUONTriggerElectronics()
 101 {
 102 /// DESTRUCTOR
 103 ///
 104   delete fGlobalTriggerBoard;
 105   delete fCrates;
 106   for (Int_t i = 0; i < 2; ++i) {
 107     delete fCopyXInput[i];
 108     delete fCopyYInput[i];
 109   }
 110
 111 }
 112
 113 //___________________________________________
 114 void AliMUONTriggerElectronics::SetCopyInput()
 115 {
 116   /// set list of copy input
 117
 118     for (Int_t iDDL = 0; iDDL < 2; ++iDDL) {
 119
 120       for(Int_t iReg = 0; iReg < 8; ++iReg){   //reg loop
 121
 122         AliMpTriggerCrate* crateMapping = AliMpDDLStore::Instance()->GetTriggerCrate(iDDL, iReg);
 123
 124         for(Int_t iLocal = 0; iLocal < crateMapping->GetNofLocalBoards(); ++iLocal) {
 125
 126           Int_t localBoardFromId = crateMapping->GetLocalBoardId(iLocal);
 127           if (!localBoardFromId) continue; //empty slot, should not happen
 128
 129           AliMpLocalBoard* localBoardFrom = AliMpDDLStore::Instance()->GetLocalBoard(localBoardFromId);
 130           Int_t localBoardToId;
 131           if ((localBoardToId = localBoardFrom->GetInputXto())) {
 132               AliMpLocalBoard* localBoardTo = AliMpDDLStore::Instance()->GetLocalBoard(localBoardToId);
 133               TString crateFrom = localBoardFrom->GetCrate();
 134               Int_t   slotFrom  = localBoardFrom->GetSlot();
 135               TString crateTo   = localBoardTo->GetCrate();
 136               Int_t   slotTo    = localBoardTo->GetSlot();
 137
 138               fCopyXInput[0]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateFrom), slotFrom));
 139               fCopyXInput[1]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateTo), slotTo));
 140               AliDebug(3, Form("copy xInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom,
 141                                crateTo.Data(), slotTo));
 142           }
 143
 144           if ((localBoardToId = localBoardFrom->GetInputYto())) {
 145               AliMpLocalBoard* localBoardTo = AliMpDDLStore::Instance()->GetLocalBoard(localBoardToId);
 146               TString crateFrom = localBoardFrom->GetCrate();
 147               Int_t   slotFrom  = localBoardFrom->GetSlot();
 148               TString crateTo   = localBoardTo->GetCrate();
 149               Int_t   slotTo    = localBoardTo->GetSlot();
 150
 151               fCopyYInput[0]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateFrom), slotFrom));
 152               fCopyYInput[1]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateTo), slotTo));
 153               AliDebug(3, Form("copy yInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom,
 154                                crateTo.Data(), slotTo));
 155
 156           }
 157
 158         }
 159       }
 160     }
 161 }
 162
 163 //___________________________________________
 164 void AliMUONTriggerElectronics::Factory(AliMUONCalibrationData* calibData)
 165 {
 166  /// BUILD ALL ELECTRONICS
 167  ///
 168
 169     fCrates->ReadFromFile(calibData);
 170 }
 171
 172 //___________________________________________
 173 void AliMUONTriggerElectronics::Feed(const AliMUONVDigitStore& digitStore)
 174 {
 175   /// FILL INPUTS
 176   ///
 177
 178   TIter next(digitStore.CreateTriggerIterator());
 179   AliMUONVDigit* mdig;
 180
 181   while ( ( mdig = static_cast<AliMUONVDigit*>(next()) ) )
 182   {
 183     //       CHECKME ! The TrackCharge is not ok with new digitizerV3 !
 184     //                  for (Int_t ichg=0; ichg<10; ichg++) schg += mdig->TrackCharge(ichg);
 185     Int_t ichamber = AliMpDEManager::GetChamberId(mdig->DetElemId());
 186     Int_t schg = (Int_t)(mdig->Charge() + 0.5);
 187
 188     //       APPLY CONDITION ON SOFT BACKGROUND
 189     Int_t tchg = schg - (Int_t(schg/10))*10;
 190
 191     if (schg<=10 || tchg>0)
 192     {
 193       Int_t detElemId  = mdig->DetElemId();
 194       Int_t cathode    = mdig->Cathode();
 195
 196       const AliMpVSegmentation* seg =
 197           AliMpSegmentation::Instance()
 198           ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
 199
 200       Int_t ix = mdig->PadX(), iy = mdig->PadY();
 201
 202       AliDebug(3,Form("cathode %d ix %d iy %d ",cathode,ix,iy));
 203
 204       AliMpPad pad = seg->PadByIndices(ix,iy,kTRUE);
 205
 206       for (Int_t i=0; i<pad.GetNofLocations(); i++)
 207       {
 208         Int_t nboard = pad.GetLocalBoardId(i);
 209
 210         Int_t ibitxy = pad.GetLocalBoardChannel(i);
 211
 212         AliMUONLocalTriggerBoard *b = fCrates->LocalBoard(nboard);
 213
 214         if (b)
 215         {
 216           if (cathode && b->GetSwitch(6)) ibitxy += 8;
 217
 218           b->SetbitM(ibitxy,cathode,ichamber-10);
 219         }
 220         else
 221         {
 222           AliError(Form("Could not get local board number %d",b->GetNumber()));
 223         }
 224       }
 225     }
 226   }
 227
 228   // Particular case of the columns with 22 local boards (2R(L) 3R(L))
 229   // fill copy input from mapping instead of hardcoded valued (Ch.F)
 230   AliMUONTriggerCrate *crate = 0x0; TObjArray *bs = 0x0;
 231
 232   for (Int_t i = 0; i < fCopyXInput[0]->GetEntries(); ++i)
 233   {
 234     AliMpIntPair* pair = (AliMpIntPair*)fCopyXInput[0]->At(i);
 235     TString crateFrom  =  AliMpExMap::GetString(pair->GetFirst());
 236     Int_t   slotFrom   =  pair->GetSecond();
 237
 238     pair = (AliMpIntPair*)fCopyXInput[1]->At(i);
 239     TString crateTo  =  AliMpExMap::GetString(pair->GetFirst());
 240     Int_t   slotTo   =  pair->GetSecond();
 241
 242     AliDebug(3, Form("copy xInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom,
 243                      crateTo.Data(), slotTo));
 244
 245     UShort_t cX[2];
 246     crate = fCrates->Crate(crateFrom);
 247     bs = crate->Boards();
 248     AliMUONLocalTriggerBoard *fromxb = (AliMUONLocalTriggerBoard*)bs->At(slotFrom);
 249     crate = fCrates->Crate(crateTo);
 250     bs = crate->Boards();
 251     AliMUONLocalTriggerBoard *desxb = (AliMUONLocalTriggerBoard*)bs->At(slotTo);
 252     fromxb->GetX34(cX); desxb->SetX34(cX);
 253
 254
 255   }
 256
 257   for (Int_t i = 0; i < fCopyYInput[0]->GetEntries(); ++i)
 258   {
 259     AliMpIntPair* pair = (AliMpIntPair*)fCopyYInput[0]->At(i);
 260     TString crateFrom  =  AliMpExMap::GetString(pair->GetFirst());
 261     Int_t   slotFrom   =  pair->GetSecond();
 262
 263     pair = (AliMpIntPair*)fCopyYInput[1]->At(i);
 264     TString crateTo  =  AliMpExMap::GetString(pair->GetFirst());
 265     Int_t   slotTo   =  pair->GetSecond();
 266
 267     AliDebug(3, Form("copy yInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom,
 268                      crateTo.Data(), slotTo));
 269
 270     UShort_t cY[4];
 271     crate = fCrates->Crate(crateFrom);
 272     bs = crate->Boards();
 273     AliMUONLocalTriggerBoard *fromyb = (AliMUONLocalTriggerBoard*)bs->At(slotFrom);
 274     crate = fCrates->Crate(crateTo);
 275     bs = crate->Boards();
 276     AliMUONLocalTriggerBoard *desyb = (AliMUONLocalTriggerBoard*)bs->At(slotTo);
 277     fromyb->GetY(cY); desyb->SetY(cY);
 278   }
 279
 280   // FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
 281   AliMUONTriggerCrate* cr;
 282   TIter next2(fCrates->CreateCrateIterator());
 283
 284   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next2()) ) )
 285   {
 286     TObjArray *boards = cr->Boards();
 287
 288     for (Int_t j = 1; j < boards->GetEntries()-1; j++)
 289     {
 290       TObject *o = boards->At(j);
 291
 292       if (!o) break;
 293
 294       AliMUONLocalTriggerBoard *currboard = (AliMUONLocalTriggerBoard*)o;
 295
 296       AliMUONLocalTriggerBoard *neighbour = (AliMUONLocalTriggerBoard*)boards->At(j+1);
 297
 298       UShort_t cXY[2][4];
 299
 300       if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
 301
 302       //       LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
 303       if (j < boards->GetEntries()-2)
 304       {
 305               AliMUONLocalTriggerBoard *nextboard = (AliMUONLocalTriggerBoard*)boards->At(j+2);
 306
 307               currboard->GetXY(cXY); neighbour->SetXYD(cXY);
 308               nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
 309
 310               if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
 311       }
 312     }
 313   }
 314
 315 }
 316
 317
 318 //___________________________________________
 319 void AliMUONTriggerElectronics::Feed(UShort_t pattern[2][4])
 320 {
 321   /// FILL INPUTS
 322   ///
 323   AliMUONTriggerCrate* cr;
 324   TIter next(fCrates->CreateCrateIterator());
 325
 326    while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
 327    {
 328      TObjArray *boards = cr->Boards();
 329
 330      for (Int_t j = 1; j < boards->GetEntries(); j++)
 331      {
 332        TObject *o = boards->At(j);
 333
 334        if (!o) break;
 335
 336        AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
 337
 338        board->SetXY(pattern);
 339      }
 340    }
 341 }
 342
 343 //___________________________________________
 344 void AliMUONTriggerElectronics::DumpOS()
 345 {
 346 /// DUMP IN THE OLD WAY
 347 ///
 348    for (Int_t i= 0; i < 234;i++)
 349    {
 350       AliMUONLocalTriggerBoard *board = fCrates->LocalBoard(i);
 351
 352       if (board) board->Scan("ALL");
 353    }
 354 }
 355
 356 //___________________________________________
 357 void AliMUONTriggerElectronics::Scan(Option_t *option)
 358 {
 359   /// SCAN
 360   ///
 361
 362   AliMUONTriggerCrate* cr;
 363   TIter next(fCrates->CreateCrateIterator());
 364
 365   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
 366   {
 367     TObjArray *boards = cr->Boards();
 368
 369     for (Int_t j = 0; j < boards->GetEntries(); j++)
 370     {
 371       TObject *o = boards->At(j);
 372
 373       TString op = option;
 374
 375       Bool_t cdtion = kFALSE;
 376
 377       if (op.Contains("LOCAL"))    cdtion = o->IsA() == AliMUONLocalTriggerBoard::Class();
 378       if (op.Contains("REGIONAL")) cdtion = o->IsA() == AliMUONRegionalTriggerBoard::Class();
 379       if (op.Contains("GLOBAL"))   cdtion = o->IsA() == AliMUONGlobalTriggerBoard::Class();
 380
 381       if (!o || !cdtion) continue;
 382
 383       AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
 384
 385       board->Scan();
 386     }
 387   }
 388 }
 389
 390 //___________________________________________
 391 void AliMUONTriggerElectronics::Reset()
 392 {
 393   /// RESET
 394   ///
 395
 396    AliMUONTriggerCrate* cr;
 397   TIter next(fCrates->CreateCrateIterator());
 398    while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
 399    {
 400       TObjArray *boards = cr->Boards();
 401
 402       for (Int_t j=0; j<boards->GetEntries(); j++)
 403       {
 404          AliMUONTriggerBoard *b = (AliMUONTriggerBoard*)boards->At(j);
 405
 406          if (b) b->Reset();
 407       }
 408    }
 409 }
 410
 411
 412 //_______________________________________________________________________
 413 void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
 414 {
 415   /// Load mask from config in CDB
 416
 417   // Set mask
 418
 419   AliMUONRegionalTriggerConfig* regionalConfig = calibData->RegionalTriggerConfig();
 420   if (!regionalConfig)
 421      AliWarning("No valid regional trigger configuration in CDB");
 422
 423
 424   AliMUONTriggerCrate* cr;
 425   TIter next(fCrates->CreateCrateIterator());
 426
 427   Int_t irb(0);
 428
 429   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
 430   {
 431     TObjArray *boards = cr->Boards();
 432
 433     AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
 434
 435     AliMUONTriggerCrateConfig* crateConfig = regionalConfig->FindTriggerCrate(cr->GetName());
 436
 437     if (!crateConfig)
 438     {
 439       AliError(Form("Crate %s not present in configuration !!!", cr->GetName()));
 440       return;
 441     }
 442
 443     UShort_t rmask= crateConfig->GetMask();
 444
 445     regb->Mask(rmask);
 446
 447     for (Int_t j = 1; j < boards->GetEntries(); j++)
 448     {
 449       AliMUONLocalTriggerBoard *b = (AliMUONLocalTriggerBoard*)boards->At(j);
 450
 451       Int_t cardNumber = b->GetNumber();
 452
 453       if (cardNumber) // interface board are not interested
 454       {
 455         AliMUONVCalibParam* localBoardMasks = calibData->LocalTriggerBoardMasks(cardNumber);
 456         for ( Int_t i = 0; i < localBoardMasks->Size(); ++i )
 457         {
 458           UShort_t lmask = static_cast<UShort_t>(localBoardMasks->ValueAsInt(i) & 0xFFFF);
 459           b->Mask(i,lmask);
 460         }
 461       }
 462     }
 463     ++irb;
 464   }
 465
 466    AliMUONGlobalCrateConfig * globalConfig = calibData->GlobalTriggerCrateConfig();
 467   if (!globalConfig)
 468      AliWarning("No valid trigger crate configuration in CDB");
 469
 470     UInt_t gmask = 0;
 471     for (Int_t i = 0; i < 4; i++) {
 472       gmask = globalConfig->GetGlobalMask(i);
 473       fGlobalTriggerBoard->Mask(i,gmask);
 474     }
 475 }
 476
 477 //___________________________________________
 478 void AliMUONTriggerElectronics::LocalResponse()
 479 {
 480 /// Compute the response for local cards
 481
 482   AliMUONTriggerCrate* cr;
 483   TIter next(fCrates->CreateCrateIterator());
 484
 485   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
 486   {
 487
 488     TObjArray *boards = cr->Boards();
 489
 490     AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
 491
 492     UShort_t thisl[16]; for (Int_t j=0; j<16; j++) thisl[j] = 0;
 493
 494     for (Int_t j = 1; j < boards->GetEntries(); j++)
 495     {
 496         TObject *o = boards->At(j);
 497
 498         if (!o) break;
 499
 500         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
 501
 502         if (board) // check if empty slot
 503         {
 504           board->Response();
 505
 506           UShort_t response = board->GetResponse();
 507
 508           // CRATE CONTAINING INTERFACE BOARD
 509           if (board->GetNumber() == 0) // copy boards
 510           {
 511             if ( response != 0 )
 512               AliWarning(Form("Interface board %s in slot %d of crate %s has a non zero response",
 513                                           board->GetName(),j,cr->GetName()));
 514             AliDebug(1, Form("local slot %d, number %d in crate %s\n", j, board->GetNumber(), cr->GetName()));
 515
 516           }
 517
 518           thisl[j-1] = response;
 519         }
 520       }
 521
 522     regb->SetLocalResponse(thisl);
 523   }
 524 }
 525
 526 //___________________________________________
 527 void AliMUONTriggerElectronics::RegionalResponse()
 528 {
 529   /// Compute the response for all regional cards.
 530   AliMUONTriggerCrate* cr;
 531   TIter next(fCrates->CreateCrateIterator());
 532
 533   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
 534   {
 535       TObjArray *boards = cr->Boards();
 536
 537       AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
 538
 539       if (regb)
 540       {
 541          regb->Response();
 542       }
 543    }
 544 }
 545
 546 //___________________________________________
 547 void AliMUONTriggerElectronics::GlobalResponse()
 548 {
 549   /// Compute the global response
 550
 551   UShort_t regional[16];
 552
 553   AliMUONTriggerCrate* cr;
 554   Int_t irb(0);
 555
 556   if ( !fCrates->NumberOfCrates() >= 16 )
 557   {
 558     AliFatal(Form("Something is wrong : too many crates %d",
 559                   fCrates->NumberOfCrates()));
 560   }
 561
 562   // send regional responses to the global trigger in right order
 563   // do not used iterator order
 564
 565   for (Int_t iSide = 0; iSide < 2; iSide++) // right & left side
 566   {
 567     for (Int_t iReg = 0; iReg < 8; iReg++) // 8 crates/regional boards for each side.
 568     {
 569       cr = fCrates->Crate(iSide, iReg);
 570
 571       AliMUONTriggerBoard* rb =
 572         static_cast<AliMUONTriggerBoard*>(cr->Boards()->At(0));
 573       regional[irb] = rb->GetResponse();
 574       ++irb;
 575     }
 576   }
 577
 578   fGlobalTriggerBoard->SetRegionalResponse(regional);
 579   fGlobalTriggerBoard->Response();
 580 }
 581
 582 //_______________________________________________________________________
 583 void AliMUONTriggerElectronics::Digits2Trigger(const AliMUONVDigitStore& digitStore,
 584                                                AliMUONVTriggerStore& triggerStore)
 585 {
 586   /// Main method to go from digits to trigger decision
 587   AliMUONRegionalTrigger pRegTrig;
 588
 589   triggerStore.Clear();
 590
 591   // RUN THE FULL BEE CHAIN
 592   Feed(digitStore);
 593   LocalResponse();
 594   RegionalResponse();
 595   GlobalResponse();
 596   //    DumpOS();
 597
 598   AliMUONTriggerCrate* cr;
 599   AliMUONLocalTrigger localTrigger;
 600
 601   // stored in right order
 602   // do not used iterator order
 603
 604   for (Int_t iSide = 0; iSide < 2; iSide++) // right & left side
 605   {
 606     for (Int_t iReg = 0; iReg < 8; iReg++) // 8 crates/regional boards for each side.
 607     {
 608       cr = fCrates->Crate(iSide, iReg);
 609       TObjArray *boards = cr->Boards();
 610
 611       UInt_t regInpLpt = 0;
 612       UInt_t regInpHpt = 0;
 613
 614       AliMUONRegionalTriggerBoard *regBoard = (AliMUONRegionalTriggerBoard*)boards->At(0);
 615
 616       for (Int_t j = 1; j < boards->GetEntries(); j++)
 617       {
 618         TObject *o = boards->At(j);
 619
 620         if (!o) break;
 621
 622         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
 623
 624         if (board)
 625         {
 626           //          L0 TRIGGER
 627           // pcrochet 181206: MOOD needs ALL boards
 628           //      if (board->Triggered())
 629           //      {
 630
 631           Int_t icirc = board->GetNumber();
 632           if (icirc != 0) { // pcrochet 181206: MOOD needs ALL boards
 633
 634             localTrigger.SetLoCircuit(icirc);
 635             localTrigger.SetLoStripX(board->GetStripX11());
 636             localTrigger.SetLoDev(board->GetDev());
 637             localTrigger.SetLoSdev(board->GetSdev());
 638             localTrigger.SetLoTrigY(board->GetTrigY());
 639             localTrigger.SetLoStripY(board->GetStripY11());
 640
 641             //             SAVE LUT OUTPUT
 642             UShort_t response = board->GetResponse();
 643             localTrigger.SetLoHpt((response & 12) >> 2);
 644             localTrigger.SetLoLpt(response &  3);
 645
 646             // calculates regional inputs from local for the moment
 647             UInt_t hPt = (response >> 2) & 0x3;
 648             UInt_t lPt =  response       & 0x3;
 649
 650             regInpHpt |= hPt << (30 - (j-1)*2);
 651             regInpLpt |= lPt << (30 - (j-1)*2);
 652
 653             TBits rrr;
 654             rrr.Set(6,&response);
 655
 656             //             SAVE BIT PATTERN
 657             localTrigger.SetX1Pattern(board->GetXY(0,0));
 658             localTrigger.SetX2Pattern(board->GetXY(0,1));
 659             localTrigger.SetX3Pattern(board->GetXY(0,2));
 660             localTrigger.SetX4Pattern(board->GetXY(0,3));
 661
 662             localTrigger.SetY1Pattern(board->GetXY(1,0));
 663             localTrigger.SetY2Pattern(board->GetXY(1,1));
 664             localTrigger.SetY3Pattern(board->GetXY(1,2));
 665             localTrigger.SetY4Pattern(board->GetXY(1,3));
 666
 667             //             ADD A NEW LOCAL TRIGGER
 668             triggerStore.Add(localTrigger);
 669
 670           }
 671           }
 672         }
 673       pRegTrig.SetId(iReg + 8*iSide);
 674       pRegTrig.SetLocalOutput(regInpLpt, 0);
 675       pRegTrig.SetLocalOutput(regInpHpt, 1);
 676       pRegTrig.SetOutput(regBoard->GetResponse());
 677
 678       triggerStore.Add(pRegTrig);
 679       }
 680     }
 681
 682   // GLOBAL TRIGGER INFORMATION
 683   UShort_t global = fGlobalTriggerBoard->GetResponse();
 684   UInt_t *globalInput = fGlobalTriggerBoard->GetGlobalInput();
 685
 686   AliMUONGlobalTrigger globalTrigger;
 687
 688   globalTrigger.SetFromGlobalResponse(global);
 689   globalTrigger.SetFromGlobalInput(globalInput);
 690   // ADD A LOCAL TRIGGER IN THE LIST
 691   triggerStore.SetGlobal(globalTrigger);
 692
 693   // NOW RESET ELECTRONICS
 694   Reset();
 695 }