MUON/AliMUONTriggerGUI.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 AliMUONTriggerGUI
  20 /// Graphical User Interface utility class for the MUON trigger detector
  21 /// It creates, after initialisation with a data file, a sensitive map
  22 /// of the trigger boards
  23 /// \author Bogdan Vulpescu, LPC Clermont-Ferrand
  24 //-----------------------------------------------------------------------------
  25
  26 #include "AliMUONTriggerGUI.h"
  27 #include "AliMUONTriggerGUIboard.h"
  28 #include "AliMUONTriggerGUIdimap.h"
  29 #include "AliMUONTriggerGUIbdmap.h"
  30
  31 #include "AliMpDDLStore.h"
  32 #include "AliMpSegmentation.h"
  33 #include "AliMpVSegmentation.h"
  34 #include "AliMpTriggerSegmentation.h"
  35 #include "AliMpEncodePair.h"
  36 #include "AliMpCDB.h"
  37 #include "AliMpDEManager.h"
  38 #include "AliMpDEIterator.h"
  39
  40 #include "AliMUONGeometryTransformer.h"
  41 #include "AliMUONTriggerCrateStore.h"
  42 #include "AliMUONLocalTriggerBoard.h"
  43 #include "AliMUONTriggerElectronics.h"
  44 #include "AliMUONCalibrationData.h"
  45 #include "AliMUONMCDataInterface.h"
  46 #include "AliMUONDigitStoreV1.h"
  47 #include "AliMUONDigitStoreV2R.h"
  48 #include "AliMUONTriggerStoreV1.h"
  49 #include "AliMUONLocalTrigger.h"
  50 #include "AliMUONRawWriter.h"
  51 #include "AliMUONDigitMaker.h"
  52 #include "AliMUONGlobalTrigger.h"
  53
  54 #include "AliRun.h"
  55 #include "AliDAQ.h"
  56 #include "AliRunLoader.h"
  57 #include "AliCDBManager.h"
  58 #include "AliRawDataHeaderSim.h"
  59 #include "AliRawReader.h"
  60
  61 #include <TSystem.h>
  62 #include <TGLabel.h>
  63 #include <TGFrame.h>
  64 #include <TApplication.h>
  65 #include <TGDimension.h>
  66 #include <TString.h>
  67 #include <TGMenu.h>
  68 #include <TGTextEntry.h>
  69 #include <TGButton.h>
  70 #include <TFile.h>
  71 #include <TGImageMap.h>
  72 #include <TGTextBuffer.h>
  73
  74 #include <cstdio>
  75
  76 /// \cond CLASSIMP
  77 ClassImp(AliMUONTriggerGUI)
  78 /// \endcond
  79
  80 //__________________________________________________________________________
  81 AliMUONTriggerGUI::AliMUONTriggerGUI(Int_t runNumber)
  82   : TObject(),
  83     fMain(0),
  84     fImageMap(0),
  85     fTxtBuffer1(0),
  86     fTxtBuffer2(0),
  87     fTxtCircuit(0),
  88     fTxtFETRegOn(0),
  89     fTxtFETRegOff(0),
  90     fRunInput(0),
  91     fError(0),
  92     fControl(0),
  93     fCircuit(0),
  94     fFETRegOn(0),
  95     fFETRegOff(0),
  96     fSkipToEventTxt(0),
  97     fFileName(0),
  98     fPath(0),
  99     fEvString(0),
 100     fChamber(0),
 101     fEvent(0),
 102     fEventsPerRun(0),
 103     fLoader(0),
 104     fRunLoader(0),
 105     fCDBManager(0),
 106     fCalibrationData(0),
 107     fCrateManager(0),
 108     fMCDataInterface(0),
 109     fBoardsInit(0),
 110     fControlOn(kFALSE),
 111     fDiMap(0),
 112     fTriggerProcessor(0),
 113     fBoards(0),
 114     fDigitStore(0),
 115     fTriggerStore(0),
 116     fTStoreOn(kFALSE),
 117     fRUNRAW(kFALSE),
 118     fRawReader(0),
 119     fCurrentRawEvent(-1),
 120     fRawDigitStore(0),
 121     fRawTriggerStore(0)
 122 {
 123   /// main GUI frame of the trigger monitor
 124
 125   fChamber = 0;
 126   fEvent   = 0;
 127   fEventsPerRun = 0;
 128   fRunLoader = 0;
 129   fDiMap = 0;
 130
 131   fBoards = 0;
 132   fFileName = new TString("");
 133   fEvString = new TString("");
 134   fPath = new TString("");
 135
 136   fDigitStore = new AliMUONDigitStoreV2R;
 137   fDigitStore->Create();
 138
 139   fTriggerStore = new AliMUONTriggerStoreV1;
 140   fTriggerStore->Create();
 141
 142   fRawDigitStore = new AliMUONDigitStoreV1;
 143   fRawDigitStore->Create();
 144
 145   fRawTriggerStore = new AliMUONTriggerStoreV1;
 146   fRawTriggerStore->Create();
 147
 148   fCDBManager = AliCDBManager::Instance();
 149   fCDBManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
 150   fCDBManager->SetRun(runNumber);
 151   AliMpCDB::LoadDDLStore();
 152   fCalibrationData = new AliMUONCalibrationData(runNumber);
 153
 154   fTriggerProcessor = new AliMUONTriggerElectronics(fCalibrationData);
 155
 156   // Main frame
 157
 158   fMain = new TGMainFrame(gClient->GetRoot(), 750, 420);
 159   fMain->Connect("CloseWindow()", "AliMUONTriggerGUI", this, "CloseWindow()");
 160
 161   // Menu bar
 162
 163   TGMenuBar *menuBar = new TGMenuBar(fMain);
 164
 165   // File menu
 166
 167   TGPopupMenu *menuFile = new TGPopupMenu(gClient->GetRoot());
 168   //menuFile->AddLabel("");
 169
 170   menuFile->AddEntry("Run input", kMFILERUN);
 171   menuFile->AddEntry("Control",   kMFILECNTRL);
 172   menuFile->AddEntry("Exit",      kMFILEEXIT);
 173
 174   menuFile->Connect("Activated(Int_t)", "AliMUONTriggerGUI", this, "HandleMenu(Int_t)");
 175
 176   // Circuit menu
 177
 178   TGPopupMenu *menuCircuit = new TGPopupMenu(gClient->GetRoot());
 179   //menuCircuit->AddLabel("");
 180
 181   menuCircuit->AddEntry("Open",     kMCIRCUITOPEN);
 182
 183   menuCircuit->Connect("Activated(Int_t)", "AliMUONTriggerGUI", this, "HandleMenu(Int_t)");
 184
 185   // Digits map menu
 186
 187   TGPopupMenu *menuMap = new TGPopupMenu(gClient->GetRoot());
 188   //menuMap->AddLabel("");
 189
 190   menuMap->AddEntry("Digits map",   kMMAPDIGITS);
 191   menuMap->AddEntry("Reset digits", kMRESETDIGITS);
 192
 193   menuMap->Connect("Activated(Int_t)", "AliMUONTriggerGUI", this,
 194                     "HandleMenu(Int_t)");
 195
 196   // Trigger menu
 197
 198   TGPopupMenu *menuTrigger = new TGPopupMenu(gClient->GetRoot());
 199
 200   TGPopupMenu *menuTriggerD = new TGPopupMenu(gClient->GetRoot());
 201   TGPopupMenu *menuTriggerT = new TGPopupMenu(gClient->GetRoot());
 202   TGPopupMenu *menuTriggerF = new TGPopupMenu(gClient->GetRoot());
 203
 204   menuTrigger->AddPopup("Digit store",       menuTriggerD);
 205   menuTrigger->AddSeparator();
 206   menuTrigger->AddPopup("Trigger store",menuTriggerT);
 207   menuTrigger->AddSeparator();
 208   menuTrigger->AddPopup("Front End Test",    menuTriggerF);
 209   menuTrigger->AddSeparator();
 210
 211   menuTriggerD->AddEntry("Create", kMDSTORE);
 212   menuTriggerD->AddEntry("Print",  kMDSTOREP);
 213   menuTriggerD->AddEntry("Clear",  kMDSTORECL);
 214   menuTriggerT->AddEntry("Create", kMTSTORE);
 215   menuTriggerT->AddEntry("Print",  kMTSTOREP);
 216   menuTriggerT->AddEntry("Clear",  kMTSTORECL);
 217   menuTriggerF->AddEntry("On",     kMFETON);
 218   menuTriggerF->AddEntry("Off",    kMFETOFF);
 219   menuTriggerF->AddEntry("Reg On", kMFETREGON);
 220   menuTriggerF->AddEntry("Reg Off",kMFETREGOFF);
 221   menuTrigger->AddEntry("Write raw data", kMTRAWDATA);
 222
 223   menuTrigger->Connect("Activated(Int_t)", "AliMUONTriggerGUI", this, "HandleMenu(Int_t)");
 224
 225   // Add menus to the menu bar
 226
 227   menuBar->AddPopup("File", menuFile,
 228                     new TGLayoutHints(kLHintsTop | kLHintsLeft, 5,5,2,2)
 229                     );
 230
 231   menuBar->AddPopup("Maps", menuMap,
 232                     new TGLayoutHints(kLHintsTop | kLHintsLeft, 5,5,2,2)
 233                     );
 234
 235   menuBar->AddPopup("Circuit", menuCircuit,
 236                     new TGLayoutHints(kLHintsTop | kLHintsLeft, 5,5,2,2)
 237                     );
 238
 239   menuBar->AddPopup("TriggerDSET", menuTrigger,
 240                     new TGLayoutHints(kLHintsTop | kLHintsLeft, 5,5,2,2)
 241                     );
 242
 243   // Add menu bar to the main frame
 244
 245   fMain->AddFrame(menuBar,
 246                   new TGLayoutHints(kLHintsTop |
 247                                     kLHintsLeft |
 248                                     kLHintsExpandX,
 249                                     0, 0, 1, 1)
 250                   );
 251
 252   // The image map
 253
 254   fImageMap = new TGImageMap(fMain,"$ALICE_ROOT/MUON/data/guimap.gif");
 255
 256   fImageMap->Connect("RegionClicked(Int_t)", "AliMUONTriggerGUI", this, "OpenBoard(Int_t)");
 257
 258   fImageMap->SetToolTipText("Map of the local boards as seen from the I.P.");
 259
 260   // Add image map to the main frame
 261
 262   fMain->AddFrame(fImageMap);
 263   fMain->SetWindowName("Map of the local boards as seen from the I.P.");
 264
 265   // Resize the main frame
 266
 267   TGDimension size = fMain->GetDefaultSize();
 268   fMain->Resize(size);
 269
 270   fMain->MapSubwindows();
 271
 272   fMain->MapWindow();
 273
 274   fBoardsInit = kFALSE;
 275
 276   InitBoards();
 277
 278 }
 279
 280 //__________________________________________________________________________
 281 void AliMUONTriggerGUI::HandleMenu(Int_t id)
 282 {
 283   /// handles entry numbers in the available menus (EMenuIdentifiers)
 284
 285   TGCompositeFrame *runInput1, *runInput2, *runInput3;
 286   TGCompositeFrame *control1, *control2, *circuit1, *circuit2;
 287   TGCompositeFrame *fetregon1, *fetregon2;
 288   TGCompositeFrame *fetregoff1, *fetregoff2;
 289   TGLabel *runL1, *runL2, *circuitL1, *fetregonL1, *fetregoffL1;
 290   TGTextEntry *runText1, *runText2, *circuitText1;
 291   TGTextEntry *fetregonText1, *fetregoffText1;
 292   TGTextButton *runApply1, *runApply2, *runCancel;
 293   TGTextButton *controlClose, *nextEvent, *previousEvent, *skipToEvent;
 294   TGTextButton *circuitCancel, *circuitOpen;
 295   TGTextButton *fetregonCancel, *fetregoffCancel;
 296   TGTextButton *fetregonRun, *fetregoffRun;
 297
 298   switch (id) {
 299
 300   case kMFILEEXIT:
 301
 302     printf("\nBye. \n");
 303     CloseWindow();
 304     break;
 305
 306   case kMFILERUN:
 307
 308     // input main frame
 309
 310     fRunInput = new TGTransientFrame(gClient->GetRoot(), fMain, 400, 200);
 311     fRunInput->Connect("CloseWindow()", "AliMUONTriggerGUI", this, "CloseRunInput()");
 312     fRunInput->DontCallClose(); // to avoid double deletions.
 313
 314     // use hierarchical cleaning
 315     fRunInput->SetCleanup(kDeepCleanup);
 316
 317     fRunInput->SetWindowName("Input file and event number");
 318
 319     // input galice and event number frames
 320
 321     runInput1 = new TGCompositeFrame(fRunInput, 400, 200, kHorizontalFrame);
 322     runInput2 = new TGCompositeFrame(fRunInput, 400, 200, kHorizontalFrame);
 323
 324     // .. with labels
 325
 326     runL1 = new TGLabel(runInput1, new TGString("Full file path:"));
 327     runL2 = new TGLabel(runInput2, new TGString("Event number:"));
 328
 329     // galice text entry
 330
 331     runText1 = new TGTextEntry(runInput1, fTxtBuffer1 = new TGTextBuffer(100));
 332
 333     runText1->SetToolTipText("Enter the path to galice.root or the raw data file (root)");
 334     runText1->Resize(300, runText1->GetDefaultHeight());
 335
 336     // event number text entry
 337
 338     runText2 = new TGTextEntry(runInput2, fTxtBuffer2 = new TGTextBuffer(5));
 339
 340     fEvString->Form("%d",0);
 341     fTxtBuffer2->AddText(0,fEvString->Data());
 342
 343     runText2->SetToolTipText("Enter the first event number to start with");
 344     runText2->Resize(300, runText2->GetDefaultHeight());
 345
 346     // add to galice frame
 347
 348     runInput1->AddFrame(runL1,
 349                          new TGLayoutHints(kLHintsLeft |
 350                                            kLHintsCenterY,
 351                                            3, 5, 0, 0)
 352                         );
 353
 354     runInput1->AddFrame(runText1,
 355                         new TGLayoutHints(kLHintsRight |
 356                                           kLHintsCenterY,
 357                                           0, 2, 0, 0)
 358                         );
 359
 360     // add to event number frame
 361
 362     runInput2->AddFrame(runL2,
 363                          new TGLayoutHints(kLHintsLeft |
 364                                            kLHintsCenterY,
 365                                            3, 5, 0, 0)
 366                         );
 367
 368     runInput2->AddFrame(runText2,
 369                         new TGLayoutHints(kLHintsRight |
 370                                           kLHintsCenterY,
 371                                           0, 2, 0, 0)
 372                         );
 373
 374     // add input frames to main input frame
 375
 376     fRunInput->AddFrame(runInput1,
 377                         new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 3, 0));
 378
 379     fRunInput->AddFrame(runInput2,
 380                         new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 3, 0));
 381
 382     // frame with buttons
 383
 384     runInput3 = new TGCompositeFrame(fRunInput, 400, 200, kHorizontalFrame);
 385
 386     // buttons
 387
 388     runApply1 = new TGTextButton(runInput3, "Apply (galice)", 1);
 389     runApply1->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoRunGalApply()");
 390     runApply1->SetToolTipText("Apply changes (galice input)");
 391
 392     runApply2 = new TGTextButton(runInput3, "Apply (raw)", 1);
 393     runApply2->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoRunRawApply()");
 394     runApply2->SetToolTipText("Apply changes (raw data input)");
 395
 396     runCancel = new TGTextButton(runInput3, "Cancel", 2);
 397     runCancel->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoRunCancel()");
 398     runCancel->SetToolTipText("Cancel changes");
 399
 400     // add buttons
 401
 402     runInput3->AddFrame(runApply1,
 403                          new TGLayoutHints(kLHintsTop |
 404                                            kLHintsLeft,
 405                                            3, 3, 2, 2)
 406                         );
 407
 408     runInput3->AddFrame(runApply2,
 409                          new TGLayoutHints(kLHintsTop |
 410                                            kLHintsLeft,
 411                                            3, 3, 2, 2)
 412                         );
 413
 414     runInput3->AddFrame(runCancel,
 415                          new TGLayoutHints(kLHintsTop |
 416                                            kLHintsLeft,
 417                                            3, 3, 2, 2)
 418                         );
 419
 420     // add to the main input frame
 421
 422     fRunInput->AddFrame(runInput3,
 423                         new TGLayoutHints(kLHintsTop |
 424                                           kLHintsExpandX,
 425                                           2, 2, 3, 0)
 426                         );
 427
 428     fRunInput->MapSubwindows();
 429     fRunInput->Resize();
 430     fRunInput->MapWindow();
 431
 432     break;
 433
 434   case kMFILECNTRL:
 435
 436     // control main frame
 437
 438     fControl = new TGTransientFrame(gClient->GetRoot(), fMain, 50, 50);
 439     fControl->Connect("CloseWindow()", "AliMUONTriggerGUI", this, "CloseControl()");
 440     fControl->DontCallClose(); // to avoid double deletions.
 441
 442     // use hierarchical cleaning
 443     fControl->SetCleanup(kDeepCleanup);
 444
 445     fControl->SetWindowName("Run controls");
 446
 447     // frame to hold buttons
 448
 449     control1 = new TGCompositeFrame(fControl, 50, 50, kVerticalFrame);
 450
 451     // buttons
 452
 453     controlClose = new TGTextButton(control1, "Close", 1);
 454     controlClose->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoControlClose()");
 455     //controlClose->Resize(300, controlClose->GetDefaultHeight());
 456
 457     nextEvent = new TGTextButton(control1, "Next event", 2);
 458     nextEvent->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoNextEvent()");
 459
 460     previousEvent = new TGTextButton(control1, "Previous event", 3);
 461     previousEvent->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoPreviousEvent()");
 462
 463     // frame to hold event skip
 464
 465     control2 = new TGCompositeFrame(fControl, 50, 50, kHorizontalFrame);
 466
 467     // skip to event text field
 468
 469     fSkipToEventTxt = new TGTextEntry(control2, fTxtBuffer2 = new TGTextBuffer(5));
 470
 471     fTxtBuffer2->AddText(0,fEvString->Data());
 472
 473     // skip to event button
 474
 475     skipToEvent = new TGTextButton(control2, "Skip to event", 1);
 476     skipToEvent->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoSkipToEvent()");
 477
 478     // add to event skip frame
 479
 480     control2->AddFrame(fSkipToEventTxt,
 481                        new TGLayoutHints(kLHintsTop |
 482                                          kLHintsRight,
 483                                          10, 10, 5, 5)
 484                        );
 485
 486     control2->AddFrame(skipToEvent,
 487                        new TGLayoutHints(kLHintsTop |
 488                                          kLHintsRight,
 489                                          10, 10, 5, 5)
 490                        );
 491
 492     // add buttons
 493
 494     control1->AddFrame(controlClose,
 495                  new TGLayoutHints(kLHintsBottom |
 496                                    kLHintsExpandX,
 497                                    10, 10, 5, 5)
 498                  );
 499
 500     control1->AddFrame(nextEvent,
 501                  new TGLayoutHints(kLHintsBottom |
 502                                    kLHintsExpandX,
 503                                    10, 10, 5, 5)
 504                  );
 505
 506     control1->AddFrame(previousEvent,
 507                  new TGLayoutHints(kLHintsBottom |
 508                                    kLHintsExpandX,
 509                                    10, 10, 5, 5)
 510                  );
 511
 512     // add to the main frame
 513
 514     fControl->AddFrame(control1,
 515                        new TGLayoutHints(kLHintsBottom |
 516                                          kLHintsLeft |
 517                                          kLHintsCenterY,
 518                                          3, 5, 0, 0)
 519                        );
 520
 521     fControl->AddFrame(control2,
 522                        new TGLayoutHints(kLHintsTop |
 523                                          kLHintsCenterX,
 524                                          3, 5, 0, 0)
 525                        );
 526
 527     fControl->MapSubwindows();
 528     fControl->Resize();
 529     fControl->MapWindow();
 530
 531     fControlOn = kTRUE;
 532
 533     break;
 534
 535   case kMMAPDIGITS:
 536
 537     if (fDiMap == 0) {
 538       fDiMap = new AliMUONTriggerGUIdimap(fBoards,gClient->GetRoot(), fMain, 400, 200);
 539       fDiMap->SetLoader(fLoader);
 540       if (fRUNRAW) {
 541         fDiMap->SetRawDigitStore(fRawDigitStore);
 542       } else {
 543         fDiMap->SetMCDataInterface(fMCDataInterface);
 544       }
 545       fDiMap->DrawAllMaps();
 546     } else if (!fDiMap->IsOn()) {
 547       fDiMap = new AliMUONTriggerGUIdimap(fBoards,gClient->GetRoot(), fMain, 400, 200);
 548       fDiMap->SetLoader(fLoader);
 549       if (fRUNRAW) {
 550         fDiMap->SetRawDigitStore(fRawDigitStore);
 551       } else {
 552         fDiMap->SetMCDataInterface(fMCDataInterface);
 553       }
 554       fDiMap->DrawAllMaps();
 555     }
 556
 557     break;
 558
 559   case kMRESETDIGITS:
 560
 561     Int_t number, over, pos;
 562     for (Int_t ib = 0; ib < kNBoards; ib++) {
 563       AliMUONTriggerGUIboard *board = GetBoard(ib);
 564       board->ClearXDigits();
 565       board->ClearYDigits();
 566       // extended y-strips
 567       number = board->GetNumber();
 568       pos    = board->GetPosition();
 569       over   = board->GetYOver();
 570       for (Int_t io = 1; io <= over; io++) {
 571         if (io == pos) continue;
 572         board = GetBoard(number+io-pos);
 573         board->ClearYDigits();
 574       }
 575     }
 576
 577     break;
 578
 579   case kMCIRCUITOPEN:
 580
 581     fCircuit = new TGTransientFrame(gClient->GetRoot(), fMain, 50, 50);
 582     fCircuit->Connect("CloseWindow()", "AliMUONTriggerGUI", this, "CloseCircuit()");
 583     fCircuit->DontCallClose(); // to avoid double deletions.
 584
 585     // use hierarchical cleaning
 586     fCircuit->SetCleanup(kDeepCleanup);
 587
 588     fCircuit->SetWindowName("Board circuit");
 589
 590     // sub-frames
 591
 592     circuit1 = new TGCompositeFrame(fCircuit, 400, 200, kHorizontalFrame);
 593     circuit2 = new TGCompositeFrame(fCircuit, 400, 200, kHorizontalFrame);
 594
 595     // labels
 596
 597     circuitL1 = new TGLabel(circuit1, new TGString("Circuit number:"));
 598
 599     // text entry
 600
 601     circuitText1 = new TGTextEntry(circuit1, fTxtCircuit = new TGTextBuffer(10));
 602     // buttons
 603
 604     circuitCancel = new TGTextButton(circuit2, "Cancel", 1);
 605     circuitCancel->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoCircuitCancel()");
 606     //circuitCancel->Resize(100, circuitCancel->GetDefaultHeight());
 607
 608     circuitOpen = new TGTextButton(circuit2, "Open", 2);
 609     circuitOpen->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoCircuitOpen()");
 610     //circuitOpen->Resize(100, circuitOpen->GetDefaultHeight());
 611
 612     // adding
 613
 614     circuit1->AddFrame(circuitL1,
 615                        new TGLayoutHints(kLHintsLeft |
 616                                          kLHintsCenterY,
 617                                          5, 5, 2, 2)
 618                        );
 619
 620     circuit1->AddFrame(circuitText1,
 621                        new TGLayoutHints(kLHintsRight |
 622                                          kLHintsCenterY,
 623                                          0, 2, 2, 2)
 624                        );
 625
 626     circuit2->AddFrame(circuitCancel,
 627                  new TGLayoutHints(kLHintsBottom |
 628                                    kLHintsCenterY,
 629                                    5, 5, 2, 2)
 630                  );
 631
 632     circuit2->AddFrame(circuitOpen,
 633                  new TGLayoutHints(kLHintsBottom |
 634                                    kLHintsCenterY,
 635                                    5, 5, 2, 2)
 636                  );
 637
 638     fCircuit->AddFrame(circuit1,
 639                        new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 3, 0));
 640
 641     fCircuit->AddFrame(circuit2,
 642                        new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 3, 0));
 643
 644     fCircuit->MapSubwindows();
 645     fCircuit->Resize();
 646     fCircuit->MapWindow();
 647
 648     break;
 649
 650   case kMDSTORE:
 651     CreateDigitStore();
 652     break;
 653
 654   case kMDSTOREP:
 655     PrintDigitStore();
 656     break;
 657
 658   case kMDSTORECL:
 659     ClearDigitStore();
 660     break;
 661
 662   case kMTSTORE:
 663     CreateTriggerStore();
 664     break;
 665
 666   case kMTSTOREP:
 667     PrintTriggerStore();
 668     break;
 669
 670   case kMTSTORECL:
 671     ClearTriggerStore();
 672     break;
 673
 674   case kMTRAWDATA:
 675     WriteTriggerRawData();
 676     break;
 677
 678   case kMFETON:
 679     FET(1);
 680     break;
 681
 682   case kMFETOFF:
 683     FET(0);
 684     break;
 685
 686   case kMFETREGON:
 687
 688     fFETRegOn = new TGTransientFrame(gClient->GetRoot(), fMain, 50, 50);
 689     fFETRegOn->Connect("CloseWindow()", "AliMUONTriggerGUI", this, "CloseFETRegOn()");
 690     fFETRegOn->DontCallClose(); // to avoid double deletions.
 691
 692     // use hierarchical cleaning
 693     fFETRegOn->SetCleanup(kDeepCleanup);
 694
 695     fFETRegOn->SetWindowName("FET ON regional crate");
 696
 697     // sub-frames
 698
 699     fetregon1 = new TGCompositeFrame(fFETRegOn, 400, 200, kHorizontalFrame);
 700     fetregon2 = new TGCompositeFrame(fFETRegOn, 400, 200, kHorizontalFrame);
 701
 702     // labels
 703
 704     fetregonL1 = new TGLabel(fetregon1, new TGString("Regional crate name:"));
 705
 706     // text entry
 707
 708     fetregonText1 = new TGTextEntry(fetregon1, fTxtFETRegOn = new TGTextBuffer(10));
 709     // buttons
 710
 711     fetregonCancel = new TGTextButton(fetregon2, "Cancel", 1);
 712     fetregonCancel->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoFETRegOnCancel()");
 713     //fetregonCancel->Resize(100, fetregonCancel->GetDefaultHeight());
 714
 715     fetregonRun = new TGTextButton(fetregon2, "Run FET", 2);
 716     fetregonRun->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoFETRegOnRun()");
 717     //fetregonRun->Resize(100, fetregonRun->GetDefaultHeight());
 718
 719     // adding
 720
 721     fetregon1->AddFrame(fetregonL1,
 722                        new TGLayoutHints(kLHintsLeft |
 723                                          kLHintsCenterY,
 724                                          5, 5, 2, 2)
 725                        );
 726
 727     fetregon1->AddFrame(fetregonText1,
 728                        new TGLayoutHints(kLHintsRight |
 729                                          kLHintsCenterY,
 730                                          0, 2, 2, 2)
 731                        );
 732
 733     fetregon2->AddFrame(fetregonCancel,
 734                  new TGLayoutHints(kLHintsBottom |
 735                                    kLHintsCenterY,
 736                                    5, 5, 2, 2)
 737                  );
 738
 739     fetregon2->AddFrame(fetregonRun,
 740                  new TGLayoutHints(kLHintsBottom |
 741                                    kLHintsCenterY,
 742                                    5, 5, 2, 2)
 743                  );
 744
 745     fFETRegOn->AddFrame(fetregon1,
 746                        new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 3, 0));
 747
 748     fFETRegOn->AddFrame(fetregon2,
 749                        new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 3, 0));
 750
 751     fFETRegOn->MapSubwindows();
 752     fFETRegOn->Resize();
 753     fFETRegOn->MapWindow();
 754
 755     break;
 756
 757   case kMFETREGOFF:
 758
 759     fFETRegOff = new TGTransientFrame(gClient->GetRoot(), fMain, 50, 50);
 760     fFETRegOff->Connect("CloseWindow()", "AliMUONTriggerGUI", this, "CloseFETRegOff()");
 761     fFETRegOff->DontCallClose(); // to avoid double deletions.
 762
 763     // use hierarchical cleaning
 764     fFETRegOff->SetCleanup(kDeepCleanup);
 765
 766     fFETRegOff->SetWindowName("FET OFF regional crate");
 767
 768     // sub-frames
 769
 770     fetregoff1 = new TGCompositeFrame(fFETRegOff, 400, 200, kHorizontalFrame);
 771     fetregoff2 = new TGCompositeFrame(fFETRegOff, 400, 200, kHorizontalFrame);
 772
 773     // labels
 774
 775     fetregoffL1 = new TGLabel(fetregoff1, new TGString("Regional crate name:"));
 776
 777     // text entry
 778
 779     fetregoffText1 = new TGTextEntry(fetregoff1, fTxtFETRegOff = new TGTextBuffer(10));
 780     // buttons
 781
 782     fetregoffCancel = new TGTextButton(fetregoff2, "Cancel", 1);
 783     fetregoffCancel->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoFETRegOffCancel()");
 784     //fetregoffCancel->Resize(100, fetregoffCancel->GetDefaultHeight());
 785
 786     fetregoffRun = new TGTextButton(fetregoff2, "Run FET", 2);
 787     fetregoffRun->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoFETRegOffRun()");
 788     //fetregoffRun->Resize(100, fetregoffRun->GetDefaultHeight());
 789
 790     // adding
 791
 792     fetregoff1->AddFrame(fetregoffL1,
 793                        new TGLayoutHints(kLHintsLeft |
 794                                          kLHintsCenterY,
 795                                          5, 5, 2, 2)
 796                        );
 797
 798     fetregoff1->AddFrame(fetregoffText1,
 799                        new TGLayoutHints(kLHintsRight |
 800                                          kLHintsCenterY,
 801                                          0, 2, 2, 2)
 802                        );
 803
 804     fetregoff2->AddFrame(fetregoffCancel,
 805                  new TGLayoutHints(kLHintsBottom |
 806                                    kLHintsCenterY,
 807                                    5, 5, 2, 2)
 808                  );
 809
 810     fetregoff2->AddFrame(fetregoffRun,
 811                  new TGLayoutHints(kLHintsBottom |
 812                                    kLHintsCenterY,
 813                                    5, 5, 2, 2)
 814                  );
 815
 816     fFETRegOff->AddFrame(fetregoff1,
 817                        new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 3, 0));
 818
 819     fFETRegOff->AddFrame(fetregoff2,
 820                        new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 3, 0));
 821
 822     fFETRegOff->MapSubwindows();
 823     fFETRegOff->Resize();
 824     fFETRegOff->MapWindow();
 825
 826     break;
 827
 828   default:
 829     printf("Menu item %d selected\n", id);
 830     break;
 831
 832   }
 833
 834 }
 835
 836 //__________________________________________________________________________
 837 void AliMUONTriggerGUI::CloseRunInput() const
 838 {
 839   /// close the run input frame
 840
 841   delete fRunInput;
 842
 843 }
 844
 845 //__________________________________________________________________________
 846 void AliMUONTriggerGUI::CloseError() const
 847 {
 848   /// close the error frame
 849
 850   delete fError;
 851
 852 }
 853
 854 //__________________________________________________________________________
 855 void AliMUONTriggerGUI::CloseControl() const
 856 {
 857   /// close the event control frame
 858
 859   delete fControl;
 860
 861   //gSystem->Exec("cd $PWD/mtrun; aliroot -b -q mtsim.C");
 862
 863 }
 864
 865 //__________________________________________________________________________
 866 void AliMUONTriggerGUI::CloseCircuit() const
 867 {
 868   /// close the circuit frame
 869
 870   delete fCircuit;
 871
 872 }
 873
 874 //__________________________________________________________________________
 875 void AliMUONTriggerGUI::CloseFETRegOn() const
 876 {
 877   /// close the FET regional on frame
 878
 879   delete fFETRegOn;
 880
 881 }
 882
 883 //__________________________________________________________________________
 884 void AliMUONTriggerGUI::CloseFETRegOff() const
 885 {
 886   /// close the FET regional off frame
 887
 888   delete fFETRegOff;
 889
 890 }
 891
 892 //__________________________________________________________________________
 893 void AliMUONTriggerGUI::CloseWindow()
 894 {
 895   /// close the main frame and exit aplication
 896
 897   delete fRunLoader;
 898   delete fMCDataInterface;
 899   printf("\n");
 900   gApplication->Terminate();
 901
 902 }
 903
 904 //__________________________________________________________________________
 905 void AliMUONTriggerGUI::DoRunGalApply()
 906 {
 907   /// apply changes in the run control frame for galice input
 908
 909   if (fRUNRAW) {
 910     printf("This is a run with raw data input.\n");
 911     return;
 912   }
 913
 914   TString es = TString(fTxtBuffer2->GetString());
 915   fEvent = es.Atoi();
 916
 917   printf("Galice input = %s event = %d \n",fTxtBuffer1->GetString(),fEvent);
 918
 919   TString error = TString("");;
 920
 921   fPath->Form("%s",fTxtBuffer1->GetString());
 922   fFileName->Form("%s",fTxtBuffer1->GetString());
 923
 924   if (gSystem->AccessPathName(fFileName->Data()) || !fFileName->EndsWith(".root")) {
 925
 926     error.Append("No galice file: ");
 927     error.Append(fFileName->Data());
 928     DoErrorGUI(error.Data());
 929
 930   } else {
 931
 932     TFile *ftest = new TFile(fFileName->Data(),"READ");
 933     AliRun *galice = (AliRun*)ftest->Get("gAlice");
 934     if (galice == 0) {
 935
 936       ftest->Close();
 937       delete ftest;
 938
 939       error.Append("No gAlice in file: ");
 940       error.Append(fFileName->Data());
 941       DoErrorGUI(error.Data());
 942
 943       return;
 944
 945     } else {
 946       ftest->Close();
 947       delete ftest;
 948     }
 949
 950     if (fRunLoader) {
 951       delete fRunLoader;
 952       delete fMCDataInterface;
 953     }
 954
 955     fRunLoader = AliRunLoader::Open(fFileName->Data(),"MUONFolder","READ");
 956
 957     if (fRunLoader == 0x0) {
 958
 959       DoErrorGUI("No run loader !");
 960
 961     } else {
 962
 963       fRunLoader->LoadgAlice();
 964       gAlice = fRunLoader->GetAliRun();
 965       fEventsPerRun = AliRunLoader::Instance()->GetNumberOfEvents();
 966
 967       fLoader = fRunLoader->GetLoader("MUONLoader");
 968       fRunLoader->GetEvent(fEvent);
 969
 970       fMCDataInterface = new AliMUONMCDataInterface(fFileName->Data());
 971
 972       fRunInput->SendCloseMessage();
 973
 974       if (!fBoardsInit) {
 975         InitBoards();
 976       }
 977
 978       if (fDiMap) {
 979         if (fDiMap->IsOn()) {
 980           fDiMap->SetLoader(fLoader);
 981           fDiMap->SetMCDataInterface(fMCDataInterface);
 982         }
 983       }
 984
 985     }
 986
 987   }
 988
 989 }
 990
 991 //__________________________________________________________________________
 992 void AliMUONTriggerGUI::DoRunRawApply()
 993 {
 994   /// apply changes in the run control frame for raw date input
 995
 996   if (fControlOn) DoControlClose();
 997
 998   if (fRunLoader != 0) {
 999     printf("This is a run with galice input.\n");
1000     return;
1001   }
1002
1003   TString es = TString(fTxtBuffer2->GetString());
1004   fEvent = es.Atoi();
1005
1006   printf("Raw data input = %s event = %d \n",fTxtBuffer1->GetString(),fEvent);
1007
1008   TString error = TString("");;
1009
1010   fPath->Form("%s",fTxtBuffer1->GetString());
1011   fFileName->Form("%s",fTxtBuffer1->GetString());
1012
1013   if (gSystem->AccessPathName(fFileName->Data()) || !fFileName->EndsWith(".root")) {
1014
1015     error.Append("No raw data file: ");
1016     error.Append(fFileName->Data());
1017     DoErrorGUI(error.Data());
1018
1019   } else {
1020
1021     if (fRawReader == 0) {
1022       fRawReader = AliRawReader::Create(fFileName->Data());
1023     } else {
1024       delete fRawReader;
1025       fRawReader = AliRawReader::Create(fFileName->Data());
1026     }
1027     if (fRawReader == 0) {
1028       error.Append("Not a valid raw data file: ");
1029       error.Append(fFileName->Data());
1030       DoErrorGUI(error.Data());
1031       return;
1032     }
1033
1034     fRawReader->GotoEvent(fEvent);
1035     fCurrentRawEvent = fEvent;
1036
1037     AliMUONDigitMaker digitMaker;
1038     digitMaker.SetMakeTriggerDigits(kTRUE);
1039     digitMaker.Raw2Digits(fRawReader,fRawDigitStore,fRawTriggerStore);
1040
1041     fRunInput->SendCloseMessage();
1042
1043     if (!fBoardsInit) {
1044       InitBoards();
1045     }
1046
1047     if (fDiMap) {
1048       if (fDiMap->IsOn()) {
1049         fDiMap->SetRawDigitStore(fRawDigitStore);
1050       }
1051     }
1052
1053     fRUNRAW = kTRUE;
1054
1055   }
1056
1057 }
1058
1059 //__________________________________________________________________________
1060 void AliMUONTriggerGUI::DoRunCancel()
1061 {
1062   /// cancel the changes in the run control frame
1063
1064   fRunInput->SendCloseMessage();
1065
1066 }
1067
1068 //__________________________________________________________________________
1069 void AliMUONTriggerGUI::DoErrorGUI(const Char_t *wt)
1070 {
1071   /// show an error message in a new frame
1072
1073   fError = new TGTransientFrame(gClient->GetRoot(), fMain, 50, 50);
1074   fError->Connect("CloseWindow()", "AliMUONTriggerGUI", this, "CloseError()");
1075   fError->DontCallClose(); // to avoid double deletions.
1076
1077   // use hierarchical cleaning
1078   fError->SetCleanup(kDeepCleanup);
1079
1080   fError->SetWindowName("Error !");
1081
1082   TGCompositeFrame *fW = new TGCompositeFrame(fError, 50, 50, kVerticalFrame);
1083
1084   TGTextButton *fErrorOK = new TGTextButton(fW, "&Ok", 1);
1085   fErrorOK->Connect("Clicked()", "AliMUONTriggerGUI", this, "DoErrorOK()");
1086
1087   fW->AddFrame(fErrorOK,
1088                new TGLayoutHints(kLHintsBottom |
1089                                  kLHintsCenterX,
1090                                  5, 5, 5, 5)
1091                );
1092
1093   TGLabel *fWL = new TGLabel(fW, new TGString(wt));
1094
1095   fW->AddFrame(fWL,
1096                new TGLayoutHints(kLHintsTop |
1097                                  kLHintsCenterX,
1098                                  5, 5, 5, 5)
1099                );
1100
1101   fError->AddFrame(fW,
1102                    new TGLayoutHints(kLHintsLeft |
1103                                      kLHintsCenterY,
1104                                      5, 5, 5, 5)
1105                    );
1106
1107   fError->MapSubwindows();
1108   fError->Resize();
1109   fError->MapWindow();
1110
1111 }
1112
1113 //__________________________________________________________________________
1114 void AliMUONTriggerGUI::DoNextEvent()
1115 {
1116   /// load next event from the file
1117
1118   TString error = TString("");
1119
1120   if (!fRUNRAW) {
1121     if (fEvent < (fEventsPerRun-1)) {
1122       fEvent++;
1123       fRunLoader->GetEvent(fEvent);
1124
1125       fEvString->Form("%d",fEvent);
1126       fTxtBuffer2->RemoveText(0,5);
1127       fTxtBuffer2->AddText(0,fEvString->Data());
1128       fSkipToEventTxt->SetFocus();
1129
1130     } else {
1131       error.Form("Only %d event(s) in the run !",fEventsPerRun);
1132       DoErrorGUI(error.Data());
1133     }
1134   } else {
1135     if (fRawReader->NextEvent()) {
1136       fCurrentRawEvent++;
1137
1138       AliMUONDigitMaker digitMaker;
1139       digitMaker.SetMakeTriggerDigits(kTRUE);
1140       digitMaker.Raw2Digits(fRawReader,fRawDigitStore,fRawTriggerStore);
1141
1142       fEvString->Form("%d",fCurrentRawEvent);
1143       fTxtBuffer2->RemoveText(0,5);
1144       fTxtBuffer2->AddText(0,fEvString->Data());
1145       fSkipToEventTxt->SetFocus();
1146
1147     }
1148
1149   }
1150
1151 }
1152
1153 //__________________________________________________________________________
1154 void AliMUONTriggerGUI::DoPreviousEvent()
1155 {
1156   /// load previous event from the input file
1157
1158   TString error = TString("");
1159
1160   if (!fRUNRAW) {
1161     if (fEvent > 0) {
1162       fEvent--;
1163       fRunLoader->GetEvent(fEvent);
1164
1165       fEvString->Form("%d",fEvent);
1166       fTxtBuffer2->RemoveText(0,5);
1167       fTxtBuffer2->AddText(0,fEvString->Data());
1168       fSkipToEventTxt->SetFocus();
1169
1170     } else {
1171       error.Form("Already at event 0 !");
1172       DoErrorGUI(error.Data());
1173     }
1174   } else {
1175     if (fCurrentRawEvent > 0) {
1176       fCurrentRawEvent--;
1177       fRawReader->GotoEvent(fCurrentRawEvent);
1178
1179       AliMUONDigitMaker digitMaker;
1180       digitMaker.SetMakeTriggerDigits(kTRUE);
1181       digitMaker.Raw2Digits(fRawReader,fRawDigitStore,fRawTriggerStore);
1182
1183       fEvString->Form("%d",fCurrentRawEvent);
1184       fTxtBuffer2->RemoveText(0,5);
1185       fTxtBuffer2->AddText(0,fEvString->Data());
1186       fSkipToEventTxt->SetFocus();
1187
1188     }
1189
1190   }
1191
1192 }
1193
1194 //__________________________________________________________________________
1195 void AliMUONTriggerGUI::DoSkipToEvent()
1196 {
1197   /// skip to event -input- from the input file
1198
1199   TString error = TString("");
1200
1201   TString es = TString(fTxtBuffer2->GetString());
1202   fEvent = es.Atoi();
1203
1204   if (!fRUNRAW) {
1205     if (fEvent < 0 || fEvent > (fEventsPerRun-1)) {
1206       error.Form("Event number out of range !");
1207       DoErrorGUI(error.Data());
1208     } else {
1209       fRunLoader->GetEvent(fEvent);
1210     }
1211   } else {
1212     if (fRawReader->GotoEvent(fEvent)) {
1213       fCurrentRawEvent = fEvent;
1214
1215       AliMUONDigitMaker digitMaker;
1216       digitMaker.SetMakeTriggerDigits(kTRUE);
1217       digitMaker.Raw2Digits(fRawReader,fRawDigitStore,fRawTriggerStore);
1218
1219       fEvString->Form("%d",fCurrentRawEvent);
1220       fTxtBuffer2->RemoveText(0,5);
1221       fTxtBuffer2->AddText(0,fEvString->Data());
1222       fSkipToEventTxt->SetFocus();
1223     }
1224
1225   }
1226
1227 }
1228
1229 //__________________________________________________________________________
1230 void AliMUONTriggerGUI::DoErrorOK()
1231 {
1232   /// close the error frame
1233
1234   fError->SendCloseMessage();
1235
1236 }
1237
1238 //__________________________________________________________________________
1239 void AliMUONTriggerGUI::DoControlClose()
1240 {
1241   /// close the event control frame
1242
1243   fControl->SendCloseMessage();
1244   fControlOn = kFALSE;
1245
1246 }
1247
1248 //__________________________________________________________________________
1249 void AliMUONTriggerGUI::DoCircuitCancel()
1250 {
1251   /// close the circuit frame
1252
1253   fCircuit->SendCloseMessage();
1254
1255 }
1256
1257 //__________________________________________________________________________
1258 void AliMUONTriggerGUI::DoFETRegOnCancel()
1259 {
1260   /// close the FET regional on window
1261
1262   fFETRegOn->SendCloseMessage();
1263
1264 }
1265
1266 //__________________________________________________________________________
1267 void AliMUONTriggerGUI::DoFETRegOffCancel()
1268 {
1269   /// close the FET regional off window
1270
1271   fFETRegOff->SendCloseMessage();
1272
1273 }
1274
1275 //__________________________________________________________________________
1276 void AliMUONTriggerGUI::DoFETRegRun(Int_t onoff)
1277 {
1278   /// FET ON/OFF for the regional crate
1279
1280   TString crateName;
1281   if (onoff == 1)
1282     crateName = TString(fTxtFETRegOn->GetString());
1283   if (onoff == 0)
1284     crateName = TString(fTxtFETRegOff->GetString());
1285
1286   AliMUONTriggerGUIboard *board;
1287   Int_t amp = onoff;
1288
1289   for (Int_t ib = 0; ib < kNBoards; ib++) {
1290     board = (AliMUONTriggerGUIboard*)fBoards->At(ib);
1291     if (strcmp(board->GetCrateName(),crateName.Data()) != 0) continue;
1292     FETboard(ib,amp);
1293   }
1294
1295 }
1296
1297 //__________________________________________________________________________
1298 void AliMUONTriggerGUI::DoFETRegOnRun()
1299 {
1300   /// FET ON for the regional crate
1301
1302   DoFETRegRun(1);
1303   fFETRegOn->SendCloseMessage();
1304
1305 }
1306
1307 //__________________________________________________________________________
1308 void AliMUONTriggerGUI::DoFETRegOffRun()
1309 {
1310   /// FET ON for the regional crate
1311
1312   DoFETRegRun(0);
1313   fFETRegOff->SendCloseMessage();
1314
1315 }
1316
1317 //__________________________________________________________________________
1318 void AliMUONTriggerGUI::DoCircuitOpen()
1319 {
1320   /// open a circuit
1321
1322   TString cs = TString(fTxtCircuit->GetString());
1323   Int_t icirc = cs.Atoi();
1324
1325   AliMUONTriggerGUIboard *board;
1326
1327   for (Int_t ib = 0; ib < kNBoards; ib++) {
1328
1329     board = GetBoard(ib);
1330
1331     if (board->GetIdCircuit() == icirc) {
1332
1333       OpenBoard(ib);
1334
1335       if (fDiMap) {
1336         if (fDiMap->IsOn()) {
1337           fDiMap->SelectBoard(ib);
1338         }
1339       }
1340
1341       fCircuit->SendCloseMessage();
1342       return;
1343     }
1344
1345   }
1346
1347 }
1348
1349 //__________________________________________________________________________
1350 AliMUONTriggerGUIboard* AliMUONTriggerGUI::GetBoard(Int_t id) const
1351 {
1352   /// return board with "id"
1353
1354   if (fBoards == 0) return 0;
1355   void * b = fBoards->UncheckedAt(id);
1356   if (b == 0) return 0;
1357
1358   return (AliMUONTriggerGUIboard*)b;
1359
1360 }
1361
1362 //__________________________________________________________________________
1363 void AliMUONTriggerGUI::OpenBoard(Int_t id)
1364 {
1365   /// open board with "id" in a new frame
1366
1367   AliMUONTriggerGUIboard *board = GetBoard(id);
1368   UShort_t status = board->GetStatus();
1369   board->SetOpen(kTRUE);
1370
1371   AliMUONTriggerGUIbdmap *bf;
1372   Char_t text[200];
1373
1374   bf = new AliMUONTriggerGUIbdmap(gClient->GetRoot(), fMain, 400, 200);
1375
1376   if (status & kGood) {
1377     snprintf(text,200,"%s (Circuit %4d) status : working",
1378             board->GetBoardName(),board->GetIdCircuit());
1379   }
1380
1381   if (status & kWithProblems) {
1382     snprintf(text,200,"%s (Circuit %4d)  status : has problems...",
1383             board->GetBoardName(),board->GetIdCircuit());
1384   }
1385
1386   if (status & kNotWorking) {
1387     snprintf(text,200,"%s (Circuit %4d)  status : not working",
1388             board->GetBoardName(),board->GetIdCircuit());
1389   }
1390
1391   if (status & kUnknown) {
1392     snprintf(text,200,"%s (Circuit %4d)  status : unknown",
1393             board->GetBoardName(),board->GetIdCircuit());
1394   }
1395
1396   bf->SetName(text);
1397   bf->SetBoard(Boards(),id);
1398   bf->SetLoader(fLoader);
1399   bf->SetCrateManager(fCrateManager);
1400   if (fRUNRAW) {
1401     bf->SetRawDigitStore(fRawDigitStore);
1402     bf->SetRawTriggerStore(fRawTriggerStore);
1403   } else {
1404     bf->SetMCDataInterface(fMCDataInterface);
1405   }
1406   bf->Init();
1407
1408   bf->Show();
1409
1410   if (fDiMap) {
1411     if (fDiMap->IsOn()) {
1412       fDiMap->SelectBoard(id);
1413     }
1414   }
1415
1416 }
1417
1418 //__________________________________________________________________________
1419 void AliMUONTriggerGUI::Init()
1420 {
1421   /// initialize the main GUI frame
1422
1423   if (!fBoardsInit) {
1424     InitBoards();
1425   }
1426
1427   /*
1428   AliMUONTriggerGUIboard *board;
1429   for (Int_t ib = 0; ib < kNBoards; ib++) {
1430     board = GetBoard(ib);
1431     board->Dump();
1432   }
1433   */
1434 }
1435
1436 //__________________________________________________________________________
1437 void AliMUONTriggerGUI::InitBoards()
1438 {
1439   /// create board objects and define the sensitive regions in the image map
1440
1441   fBoardsInit = kTRUE;
1442
1443   // used by bdmap
1444   if (fCrateManager == 0x0) {
1445     fCrateManager = new AliMUONTriggerCrateStore();
1446     fCrateManager->ReadFromFile(fCalibrationData);
1447   }
1448
1449   // create boards geometry from the mapping
1450   AliMUONTriggerGUIboard *board;
1451   for (Int_t ib = 0; ib < kNBoards; ib++) {
1452     Boards()->Add(new AliMUONTriggerGUIboard());
1453   }
1454
1455   // circuit number to board number in array
1456   Int_t cIdtobId[235];
1457
1458   AliMpDEIterator it;
1459   Int_t boardId = -1;
1460   Int_t manuIdPrev, ich, idet, boardIdTmp = -1;
1461   for (Int_t chamber = 0; chamber < kNMT; chamber++) {
1462     for ( it.First(); ! it.IsDone(); it.Next() ) {
1463
1464       if (it.CurrentDEId()/100 < 11) continue;
1465
1466       ich = it.CurrentDEId()/100 - 11;
1467       if (ich != chamber) continue;
1468       idet = it.CurrentDEId()%100;
1469
1470       const AliMpVSegmentation* seg0 = AliMpSegmentation::Instance()->GetMpSegmentation(it.CurrentDEId(), AliMp::kCath0);
1471       const AliMpVSegmentation* seg1 = AliMpSegmentation::Instance()->GetMpSegmentation(it.CurrentDEId(), AliMp::kCath1);
1472
1473       // x-strips
1474       manuIdPrev = 0;
1475       for (Int_t ix = 0; ix <= seg0->MaxPadIndexX(); ix++) {
1476         for (Int_t iy = 0; iy <= seg0->MaxPadIndexY(); iy++) {
1477           AliMpPad pad = seg0->PadByIndices(ix,iy,kFALSE);
1478           if (pad.IsValid()) {
1479             Int_t manuId = pad.GetLocalBoardId(0);
1480             if (manuId != manuIdPrev) {
1481               AliMpLocalBoard *mpboard = AliMpDDLStore::Instance()->GetLocalBoard(manuId);
1482               manuIdPrev = manuId;
1483               if (ich == 0) {
1484                 boardId++;
1485               } else {
1486                 boardId = cIdtobId[manuId];
1487               }
1488               board = GetBoard(boardId);
1489               if (board->GetNumber() == -1)
1490                 board->SetNumber(boardId);
1491               if (board->GetDetElemId() == -1)
1492                 board->SetDetElemId(idet);
1493               if (!strcmp(board->GetBoardName(),""))
1494                 board->SetBoardName(mpboard->GetName());
1495               cIdtobId[manuId] = boardId;
1496             }
1497             GetBoard(boardId)->AddPadX(pad,ich);
1498           }
1499         }
1500       }  // end plane 0 (x-strips)
1501
1502       // y-strips
1503       manuIdPrev = 0;
1504       for (Int_t ix = 0; ix <= seg1->MaxPadIndexX(); ix++) {
1505         for (Int_t iy = 0; iy <= seg1->MaxPadIndexY(); iy++) {
1506           AliMpPad pad = seg1->PadByIndices(ix,iy,kFALSE);
1507           if (pad.IsValid()) {
1508             Int_t nloc = pad.GetNofLocations();
1509             for (Int_t iloc = 0; iloc < nloc; iloc++) {
1510               Int_t manuId = pad.GetLocalBoardId(iloc);
1511               if (manuId != manuIdPrev) {
1512                 manuIdPrev = manuId;
1513                 boardIdTmp = cIdtobId[manuId];
1514               }
1515               GetBoard(boardIdTmp)->AddPadY(pad,ich);
1516             }
1517           }
1518         }
1519       }  // end plane 1 (y-strips)
1520
1521     } // end det elem loop
1522   } // end chamber loop
1523
1524   for (Int_t ib = 0; ib < kNBoards; ib++) {
1525     board = GetBoard(ib);
1526     board->MakeGeometry();
1527     AliMUONLocalTriggerBoard* b = fCrateManager->LocalBoard(board->GetIdCircuit());
1528     board->SetCrateName((b->GetCrate()).Data());
1529   }
1530
1531   // create the sensitive map
1532
1533   Int_t nPixelX = 700;
1534   Int_t nPixelY = 676;
1535
1536   Int_t nPixelBorderX = 40;  // to guess...
1537   Int_t nPixelBorderY = 40;  // to guess...
1538
1539   // boards limits
1540   Float_t boardsX = 2*257.00;  // cm
1541   Float_t boardsY = 2*306.61;  // cm
1542
1543   UShort_t status = 1;
1544   Float_t xc, yc, xw, yw;
1545   Char_t text[256];
1546   Int_t x, y;
1547   UInt_t w, h;
1548   Int_t xp[5];
1549   Int_t yp[5];
1550
1551   TGRegion *reg;
1552
1553   // regions for the image map (from MT11)
1554
1555   for (Int_t ib = 0; ib < kNBoards; ib++) {
1556
1557     board = GetBoard(ib);
1558
1559     status = 1;
1560     board->SetStatus(status);
1561
1562     xc = board->GetXCenter(0);
1563     yc = board->GetYCenter(0);
1564     xw = board->GetXWidth(0);
1565     yw = board->GetYWidth(0);
1566
1567     x = (Int_t)(nPixelX/2 + xc * (nPixelX - 2*nPixelBorderX)/boardsX);
1568     y = (Int_t)(nPixelY/2 - yc * (nPixelY - 2*nPixelBorderY)/boardsY);
1569
1570     if (x < 0) x = 0;
1571     if (y < 0) y = 0;
1572
1573     w = (UInt_t)(xw*(nPixelX-2*nPixelBorderX)/boardsX);
1574     h = (UInt_t)(yw*(nPixelY-2*nPixelBorderY)/boardsY);
1575
1576     xp[0] = x-w/2;
1577     xp[1] = x+w/2;
1578     xp[2] = x+w/2;
1579     xp[3] = x-w/2;
1580     xp[4] = x-w/2;
1581
1582     yp[0] = y-h/2;
1583     yp[1] = y-h/2;
1584     yp[2] = y+h/2;
1585     yp[3] = y+h/2;
1586     yp[4] = y-h/2;
1587
1588     reg = new TGRegion(5,xp,yp);
1589     fImageMap->AddRegion(*reg, ib);
1590
1591     snprintf(text,256,"%s (crate %s circuit %3d, number %3d)",board->GetBoardName(),board->GetCrateName(),board->GetIdCircuit(),board->GetNumber());
1592     fImageMap->SetToolTipText(ib, text);
1593
1594     // Set coordinates of strips boxes
1595
1596     SetStripBoxes(board);
1597
1598     //board->PrintBoard();
1599
1600   }
1601
1602 }
1603
1604 //__________________________________________________________________________
1605 void AliMUONTriggerGUI::SetStripBoxes(AliMUONTriggerGUIboard *board)
1606 {
1607   /// set coordinates of strip boxes
1608
1609   AliMUONGeometryTransformer transformer;
1610   transformer.LoadGeometryData("transform.dat");
1611
1612   const AliMpVSegmentation* seg;
1613   AliMpPad pad;
1614   AliMpDEIterator it;
1615
1616   Int_t chamber, detElemId, maxX, maxY;
1617   Float_t xpmin, xpmax, ypmin, ypmax;
1618   Float_t xg1, xg2, yg1, yg2, zg1;
1619   Float_t xlocal1, xlocal2, ylocal1, ylocal2;
1620   Float_t xCenter, yCenter, xWidth, yWidth;
1621
1622   for (Int_t i = 0; i < kNMT; i++) {
1623
1624     chamber = 11+i;
1625
1626     xCenter = board->GetXCenter(i);
1627     yCenter = board->GetYCenter(i);
1628     xWidth  = board->GetXWidth(i);
1629     yWidth  = board->GetYWidth(i);
1630
1631     for ( it.First(chamber-1); ! it.IsDone(); it.Next() ) {
1632
1633       detElemId = it.CurrentDEId();
1634
1635       if (detElemId%100 != board->GetDetElemId()) continue;
1636
1637       /*---------- y-pads cath = 1 ----------*/
1638
1639       seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::kCath1);
1640
1641       maxX = seg->MaxPadIndexX();
1642       maxY = seg->MaxPadIndexY();
1643
1644       for (Int_t ix = 0; ix <= maxX; ix++) {
1645         for (Int_t iy = 0; iy <= maxY; iy++) {
1646
1647           pad = seg->PadByIndices(ix,iy,kFALSE);
1648
1649           if (!pad.IsValid()) continue;
1650
1651           // get the pad position and dimensions
1652           xlocal1 = pad.GetPositionX();
1653           ylocal1 = pad.GetPositionY();
1654           xlocal2 = pad.GetDimensionX();
1655           ylocal2 = pad.GetDimensionY();
1656
1657           transformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
1658           // (no transformation for pad dimensions)
1659           xg2 = xlocal2;
1660           yg2 = ylocal2;
1661
1662           // transform in the monitor coordinate system
1663           // ALICE SC
1664           xpmin = +(xg1-xg2);
1665           xpmax = +(xg1+xg2);
1666           ypmin = -(yg2-yg1);
1667           ypmax = +(yg2+yg1);
1668
1669           xpmin -= xCenter;
1670           xpmax -= xCenter;
1671           ypmin -= yCenter;
1672           ypmax -= yCenter;
1673
1674           Int_t iX1, iX2, iY, ixDig;
1675           iX1 = board->GetYSix1();
1676           iX2 = board->GetYSix2();
1677           iY  = board->GetYSiy();
1678           if (ix >= iX1 && ix <= iX2 && iy == iY) {
1679
1680             ypmin = -0.5*yWidth;
1681             ypmax = +0.5*yWidth;
1682
1683             ixDig = ix - iX1;
1684
1685             board->SetYDigBox(i,ixDig,(Double_t)xpmin,(Double_t)ypmin,
1686                                       (Double_t)xpmax,(Double_t)ypmax);
1687
1688           }
1689
1690         }  // end maxY
1691       }  // end maxX
1692
1693       /*---------- x-pads cath = 0 ----------*/
1694
1695       seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::kCath0);
1696
1697       maxX = seg->MaxPadIndexX();
1698       maxY = seg->MaxPadIndexY();
1699
1700       for (Int_t ix = 0; ix <= maxX; ix++) {
1701         for (Int_t iy = 0; iy <= maxY; iy++) {
1702
1703           pad = seg->PadByIndices(ix,iy,kFALSE);
1704
1705           if (!pad.IsValid()) continue;
1706
1707           // get the pad position and dimensions
1708           xlocal1 = pad.GetPositionX();
1709           ylocal1 = pad.GetPositionY();
1710           xlocal2 = pad.GetDimensionX();
1711           ylocal2 = pad.GetDimensionY();
1712
1713           transformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
1714           // (no transformation for pad dimensions)
1715           xg2 = xlocal2;
1716           yg2 = ylocal2;
1717
1718           // transform in the monitor coordinate system
1719           // ALICE SC
1720           xpmin = +(xg1+xg2);
1721           xpmax = +(xg1-xg2);
1722           ypmin = -(yg2-yg1);
1723           ypmax = +(yg2+yg1);
1724
1725           xpmin -= xCenter;
1726           xpmax -= xCenter;
1727           ypmin -= yCenter;
1728           ypmax -= yCenter;
1729
1730           Int_t iX, iY1, iY2, iyDig;
1731           iX  = board->GetXSix();
1732           iY1 = board->GetXSiy1();
1733           iY2 = board->GetXSiy2();
1734           if (ix == iX && iy >= iY1 && iy <= iY2) {
1735
1736             iyDig = iy - iY1;
1737
1738             board->SetXDigBox(i,iyDig,(Double_t)xpmin,(Double_t)ypmin,
1739                                       (Double_t)xpmax,(Double_t)ypmax);
1740
1741           }
1742
1743         }  // end maxY
1744       }  // end maxX
1745
1746     }  // end detElemId
1747
1748   }  // end kNMT loop
1749
1750 }
1751
1752 //__________________________________________________________________________
1753 void AliMUONTriggerGUI::CreateDigitStore()
1754 {
1755   /// create memory resident digits store with set strips
1756
1757   Int_t nstripX, nstripY, detElemId, charge, ix, iy, iX1, iY1;
1758   Int_t cathode, maxX, maxY;
1759   Int_t manuId, manuChannel;
1760   const AliMpVSegmentation* seg;
1761   AliMpPad pad;
1762   AliMUONTriggerGUIboard* board;
1763   AliMUONVDigit *dig;
1764
1765   for (Int_t ib = 0; ib < kNBoards; ib++) {
1766
1767     board = (AliMUONTriggerGUIboard*)fBoards->At(ib);
1768     if (board == 0) continue;
1769
1770     nstripX = board->GetNStripX();
1771     nstripY = board->GetNStripY();
1772     for (Int_t ichamber = 11; ichamber <= 14; ichamber++) {
1773
1774       detElemId = ichamber * 100 + board->GetDetElemId();
1775       // x strips
1776       cathode = 0;
1777       for (Int_t isx = 0; isx < nstripX; isx++) {
1778
1779         charge = (Int_t)board->GetXDig(ichamber-11,isx);
1780         if (charge == 0) continue;
1781         ix  = board->GetXSix();
1782         iY1 = board->GetXSiy1();
1783         iy  = isx + iY1;
1784         seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(cathode));
1785         maxX = seg->MaxPadIndexX();
1786         maxY = seg->MaxPadIndexY();
1787         if (ix > maxX) printf("Index x > maximum!\n");
1788         if (iy > maxY) printf("Index y > maximum!\n");
1789         pad = seg->PadByIndices(ix,iy,kTRUE);
1790         manuId = pad.GetLocalBoardId(0);
1791         manuChannel = pad.GetLocalBoardChannel(0);
1792
1793         dig = fDigitStore->Add(detElemId,manuId,manuChannel,cathode,AliMUONVDigitStore::kAllow);
1794         dig->SetCharge(charge);
1795         dig->SetPadXY(ix,iy);
1796         //printf("Cathode 0: ix %3d iy %3d manuId %3d manuChannel %3d \n",ix,iy,manuId,manuChannel);
1797
1798       }  // end x strips
1799
1800       // y strips
1801       cathode = 1;
1802       for (Int_t isy = 0; isy < nstripY; isy++) {
1803
1804         charge = board->GetYDig(ichamber-11,isy);
1805         if (charge == 0) continue;
1806         iX1 = board->GetYSix1();
1807         ix  = isy + iX1;
1808         iy  = board->GetYSiy();
1809         seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(cathode));
1810         maxX = seg->MaxPadIndexX();
1811         maxY = seg->MaxPadIndexY();
1812         if (ix > maxX) printf("Index x > maximum!\n");
1813         if (iy > maxY) printf("Index y > maximum!\n");
1814         pad = seg->PadByIndices(ix,iy,kTRUE);
1815         manuId = pad.GetLocalBoardId(0);
1816         manuChannel = pad.GetLocalBoardChannel(0);
1817
1818         dig = fDigitStore->Add(detElemId,manuId,manuChannel,cathode,AliMUONVDigitStore::kAllow);
1819         dig->SetCharge(charge);
1820         dig->SetPadXY(ix,iy);
1821         //printf("Cathode 1: ix %3d iy %3d manuId %3d manuChannel %3d \n",ix,iy,manuId,manuChannel);
1822
1823       }  // end y strips
1824
1825     }  // end chambers
1826
1827   }  // end boards
1828
1829 }
1830
1831 //__________________________________________________________________________
1832 void AliMUONTriggerGUI::PrintDigitStore() const
1833 {
1834   /// Print the digits created in the GUI
1835
1836   const AliMpVSegmentation* seg;
1837   AliMpPad pad;
1838   Int_t ix, iy, charge, detElemId, cathode;
1839
1840   Int_t chamber;
1841   for (Int_t i = 0; i < kNMT; i++) {
1842
1843     chamber = 11+i;
1844
1845     MpPair_t deRange = AliMpDEManager::GetDetElemIdRange(chamber-1);
1846     TIter next(fDigitStore->CreateIterator(AliMp::PairFirst(deRange),AliMp::PairSecond(deRange)));
1847     AliMUONVDigit *mdig;
1848
1849     while ( ( mdig = static_cast<AliMUONVDigit*>(next())) )
1850     {
1851       cathode = mdig->Cathode();
1852
1853       ix = mdig->PadX();
1854       iy = mdig->PadY();
1855       detElemId = mdig->DetElemId();
1856       charge = (Int_t)mdig->Charge();
1857
1858       seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(cathode));
1859       pad = seg->PadByIndices(ix,iy,kTRUE);
1860
1861       printf("Digit: detElemId %4d cath %1d ix %2d iy %3d charge %1d \n",detElemId,cathode,ix,iy,charge);
1862
1863     }
1864
1865   }
1866
1867 }
1868
1869 //__________________________________________________________________________
1870 void AliMUONTriggerGUI::CreateTriggerStore()
1871 {
1872   /// Process the DSET digit store and fill the trigger store
1873
1874   if (fDigitStore->GetSize() == 0) {
1875     printf("The digit store is empty...\n");
1876     return;
1877   }
1878   fTStoreOn = kTRUE;
1879
1880   AliMUONVDigitStore *digitStore = static_cast<AliMUONVDigitStore*>(fDigitStore);
1881
1882   fTriggerProcessor->Digits2Trigger(*digitStore,*fTriggerStore);
1883
1884 }
1885
1886 //__________________________________________________________________________
1887 void AliMUONTriggerGUI::PrintTriggerStore() const
1888 {
1889   /// Print the trigger output for DSET digits store
1890
1891   if (!fTStoreOn) return;
1892
1893   TIter next(fTriggerStore->CreateLocalIterator());
1894
1895   UShort_t x2m, x2u, x2d;
1896   Int_t loStripX, loStripY, loDev, loCircuit, iStripX, iStripY, loLpt, loHpt;
1897   AliMUONLocalTrigger *mlt;
1898   while ( ( mlt = static_cast<AliMUONLocalTrigger*>(next()) ) )
1899   {
1900     loCircuit = mlt->LoCircuit();
1901
1902     AliMUONLocalTriggerBoard* ltb = fCrateManager->LocalBoard(loCircuit);
1903     x2d = ltb->GetSwitch(0);
1904     x2m = ltb->GetSwitch(1);
1905     x2u = ltb->GetSwitch(2);
1906
1907     loStripX = mlt->LoStripX();
1908     loStripY = mlt->LoStripY();
1909     loDev    = mlt->LoDev();
1910     loLpt    = mlt->LoLpt();
1911     loHpt    = mlt->LoHpt();
1912
1913     iStripX = loStripX/2;
1914     if ((x2u == 1 || x2m == 1 || x2d == 1) && x2m == 1) {
1915       iStripY = loStripY/2;
1916     } else {
1917       iStripY = loStripY;
1918     }
1919
1920     printf("Circ %3d Xs %2d Ys %2d Dev %2d Lpt %1d Hpt %1d \n",loCircuit,loStripX,loStripY,loDev,loLpt,loHpt);
1921
1922     AliMUONGlobalTrigger *globalTrigger = fTriggerStore->Global();
1923     globalTrigger->Print();
1924
1925   }
1926
1927 }
1928
1929 //__________________________________________________________________________
1930 void AliMUONTriggerGUI::WriteTriggerRawData()
1931 {
1932   /// Write raw data (DATE and ROOT) for the trigger store from
1933   /// the DSET digit store
1934
1935   if (!fTStoreOn) {
1936     printf("The trigger store is empty... \n");
1937     return;
1938   }
1939
1940   // raw data (ddl)
1941
1942   AliMUONRawWriter *rawWriter = new AliMUONRawWriter();
1943   AliRawDataHeaderSim header;
1944   rawWriter->SetHeader(header);
1945   rawWriter->Digits2Raw(0,fTriggerStore);
1946
1947   delete rawWriter;
1948
1949   // raw data (ddl) to date
1950   // AliSimulation::ConvertRawFilesToDate
1951
1952   char command[256];
1953   char dateFileName[256];
1954   snprintf(dateFileName,256,"TriggerGUI.date");
1955   snprintf(command, 256,"dateStream -c -s -D -o %s -# %d -C -run %d",
1956           dateFileName, 1, 0);
1957   FILE* pipe = gSystem->OpenPipe(command, "w");
1958
1959   UInt_t detectorPattern = 0;
1960   fprintf(pipe, "GDC DetectorPattern %u\n", detectorPattern);
1961   Float_t ldc = 0;
1962   Int_t prevLDC = -1;
1963
1964   // loop over detectors and DDLs
1965   for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1966     for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1967
1968       Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1969       Int_t ldcID = Int_t(ldc + 0.0001);
1970       ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1971
1972       char rawFileName[256];
1973       snprintf(rawFileName, 256,"%s",AliDAQ::DdlFileName(iDet,iDDL));
1974       // check existence and size of raw data file
1975       FILE* file = fopen(rawFileName, "rb");
1976       if (!file) continue;
1977       fseek(file, 0, SEEK_END);
1978       unsigned long size = ftell(file);
1979       fclose(file);
1980       if (!size) continue;
1981
1982       if (ldcID != prevLDC) {
1983         fprintf(pipe, " LDC Id %d\n", ldcID);
1984         prevLDC = ldcID;
1985       }
1986       fprintf(pipe, "  Equipment Id %d Payload %s\n", ddlID, rawFileName);
1987     }
1988   }
1989   Int_t result = gSystem->ClosePipe(pipe);
1990
1991   // raw data (date) to root
1992   // AliSimulation::ConvertDateToRoot
1993
1994   char rootFileName[256];
1995   snprintf(rootFileName,256,"TriggerGUI.root");
1996
1997   // ALIMDC setup
1998   const Int_t kDBSize = 2000000000;
1999   const Int_t kTagDBSize = 1000000000;
2000   const Bool_t kFilter = kFALSE;
2001   const Int_t kCompression = 1;
2002
2003   char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
2004   if (!path) {
2005     printf("the program alimdc was not found\n");
2006     return;
2007   } else {
2008     delete[] path;
2009   }
2010
2011   printf("converting DATE file %s to root file %s \n",
2012                dateFileName, rootFileName);
2013
2014   const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
2015   const char* tagDBFS    = "/tmp/mdc1/tags";
2016
2017   // User defined file system locations
2018   if (gSystem->Getenv("ALIMDC_RAWDB1"))
2019     rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
2020   if (gSystem->Getenv("ALIMDC_RAWDB2"))
2021     rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
2022   if (gSystem->Getenv("ALIMDC_TAGDB"))
2023     tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
2024
2025   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
2026   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
2027   gSystem->Exec(Form("rm -rf %s",tagDBFS));
2028
2029   gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
2030   gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
2031   gSystem->Exec(Form("mkdir %s",tagDBFS));
2032
2033   result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
2034                               kDBSize, kTagDBSize, kFilter, kCompression,
2035                               dateFileName));
2036   gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
2037
2038   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
2039   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
2040   gSystem->Exec(Form("rm -rf %s",tagDBFS));
2041
2042 }
2043
2044 //__________________________________________________________________________
2045 void AliMUONTriggerGUI::FETboard(Int_t ib, Int_t amp)
2046 {
2047   /// Front End test set all strips for board with index "ib"
2048   /// AliMUONTriggerGUIbdmap::DoDigits()
2049
2050   AliMUONTriggerGUIboard *board;
2051   AliMUONTriggerGUIboard *btmp;
2052   Int_t pos, over, number, nStripX, nStripY;
2053
2054   board = (AliMUONTriggerGUIboard*)fBoards->At(ib);
2055   if (board == 0) return;
2056
2057   nStripX = board->GetXSiy2() - board->GetXSiy1() + 1;
2058   nStripY = board->GetYSix2() - board->GetYSix1() + 1;
2059
2060   number = board->GetNumber();
2061   pos    = board->GetPosition();
2062   over   = board->GetYOver();
2063
2064   for (Int_t imt = 0; imt < kNMT; imt++) {
2065
2066     for (Int_t ix = 0; ix < nStripX; ix++) {
2067       board->SetDigitX(imt,ix,amp);
2068     }
2069
2070     for (Int_t iy = 0; iy < nStripY; iy++) {
2071       board->SetDigitY(imt,iy,amp);
2072
2073       // extended y-strips
2074       for (Int_t io = 1; io <= over; io++) {
2075         if (io == pos) continue;
2076         btmp = (AliMUONTriggerGUIboard*)fBoards->UncheckedAt(number+io-pos);
2077         btmp->SetDigitY(imt,iy,amp);
2078       }
2079
2080     }
2081
2082   }
2083
2084 }
2085
2086 //__________________________________________________________________________
2087 void AliMUONTriggerGUI::FET(Int_t onoff)
2088 {
2089   /// Front End test set all strips for all boards
2090   /// AliMUONTriggerGUIbdmap::DoDigits()
2091
2092   Int_t amp = onoff;
2093
2094   for (Int_t ib = 0; ib < kNBoards; ib++) {
2095     FETboard(ib,amp);
2096   }
2097
2098 }
2099
2100 //__________________________________________________________________________
2101 void AliMUONTriggerGUI::ClearDigitStore()
2102 {
2103   /// Clear the DSET digit store
2104
2105   fDigitStore->Clear();
2106
2107 }
2108
2109 //__________________________________________________________________________
2110 void AliMUONTriggerGUI::ClearTriggerStore()
2111 {
2112   /// Clear the trigger store from the DSET digit store
2113
2114   fTriggerStore->Clear();
2115   fTStoreOn = kFALSE;
2116
2117 }