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