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   for (Int_t i = 0; i < 235; i++) cIdtobId[i] = -1;
1458
1459   AliMpDEIterator it;
1460   Int_t boardId = -1;
1461   Int_t manuIdPrev, ich, idet, boardIdTmp = -1;
1462   for (Int_t chamber = 0; chamber < kNMT; chamber++) {
1463     for ( it.First(); ! it.IsDone(); it.Next() ) {
1464
1465       if (it.CurrentDEId()/100 < 11) continue;
1466
1467       ich = it.CurrentDEId()/100 - 11;
1468       if (ich != chamber) continue;
1469       idet = it.CurrentDEId()%100;
1470
1471       const AliMpVSegmentation* seg0 = AliMpSegmentation::Instance()->GetMpSegmentation(it.CurrentDEId(), AliMp::kCath0);
1472       const AliMpVSegmentation* seg1 = AliMpSegmentation::Instance()->GetMpSegmentation(it.CurrentDEId(), AliMp::kCath1);
1473
1474       // x-strips
1475       manuIdPrev = 0;
1476       for (Int_t ix = 0; ix <= seg0->MaxPadIndexX(); ix++) {
1477         for (Int_t iy = 0; iy <= seg0->MaxPadIndexY(); iy++) {
1478           AliMpPad pad = seg0->PadByIndices(ix,iy,kFALSE);
1479           if (pad.IsValid()) {
1480             Int_t manuId = pad.GetLocalBoardId(0);
1481             if (manuId != manuIdPrev) {
1482               AliMpLocalBoard *mpboard = AliMpDDLStore::Instance()->GetLocalBoard(manuId);
1483               manuIdPrev = manuId;
1484               if (ich == 0) {
1485                 boardId++;
1486               } else {
1487                 boardId = cIdtobId[manuId];
1488               }
1489               board = GetBoard(boardId);
1490               if (board->GetNumber() == -1)
1491                 board->SetNumber(boardId);
1492               if (board->GetDetElemId() == -1)
1493                 board->SetDetElemId(idet);
1494               if (!strcmp(board->GetBoardName(),""))
1495                 board->SetBoardName(mpboard->GetName());
1496               cIdtobId[manuId] = boardId;
1497             }
1498             GetBoard(boardId)->AddPadX(pad,ich);
1499           }
1500         }
1501       }  // end plane 0 (x-strips)
1502
1503       // y-strips
1504       manuIdPrev = 0;
1505       for (Int_t ix = 0; ix <= seg1->MaxPadIndexX(); ix++) {
1506         for (Int_t iy = 0; iy <= seg1->MaxPadIndexY(); iy++) {
1507           AliMpPad pad = seg1->PadByIndices(ix,iy,kFALSE);
1508           if (pad.IsValid()) {
1509             Int_t nloc = pad.GetNofLocations();
1510             for (Int_t iloc = 0; iloc < nloc; iloc++) {
1511               Int_t manuId = pad.GetLocalBoardId(iloc);
1512               if (manuId != manuIdPrev) {
1513                 manuIdPrev = manuId;
1514                 boardIdTmp = cIdtobId[manuId];
1515               }
1516               GetBoard(boardIdTmp)->AddPadY(pad,ich);
1517             }
1518           }
1519         }
1520       }  // end plane 1 (y-strips)
1521
1522     } // end det elem loop
1523   } // end chamber loop
1524
1525   for (Int_t ib = 0; ib < kNBoards; ib++) {
1526     board = GetBoard(ib);
1527     board->MakeGeometry();
1528     AliMUONLocalTriggerBoard* b = fCrateManager->LocalBoard(board->GetIdCircuit());
1529     board->SetCrateName((b->GetCrate()).Data());
1530   }
1531
1532   // create the sensitive map
1533
1534   Int_t nPixelX = 700;
1535   Int_t nPixelY = 676;
1536
1537   Int_t nPixelBorderX = 40;  // to guess...
1538   Int_t nPixelBorderY = 40;  // to guess...
1539
1540   // boards limits
1541   Float_t boardsX = 2*257.00;  // cm
1542   Float_t boardsY = 2*306.61;  // cm
1543
1544   UShort_t status = 1;
1545   Float_t xc, yc, xw, yw;
1546   Char_t text[256];
1547   Int_t x, y;
1548   UInt_t w, h;
1549   Int_t xp[5];
1550   Int_t yp[5];
1551
1552   TGRegion *reg;
1553
1554   // regions for the image map (from MT11)
1555
1556   for (Int_t ib = 0; ib < kNBoards; ib++) {
1557
1558     board = GetBoard(ib);
1559
1560     status = 1;
1561     board->SetStatus(status);
1562
1563     xc = board->GetXCenter(0);
1564     yc = board->GetYCenter(0);
1565     xw = board->GetXWidth(0);
1566     yw = board->GetYWidth(0);
1567
1568     x = (Int_t)(nPixelX/2 + xc * (nPixelX - 2*nPixelBorderX)/boardsX);
1569     y = (Int_t)(nPixelY/2 - yc * (nPixelY - 2*nPixelBorderY)/boardsY);
1570
1571     if (x < 0) x = 0;
1572     if (y < 0) y = 0;
1573
1574     w = (UInt_t)(xw*(nPixelX-2*nPixelBorderX)/boardsX);
1575     h = (UInt_t)(yw*(nPixelY-2*nPixelBorderY)/boardsY);
1576
1577     xp[0] = x-w/2;
1578     xp[1] = x+w/2;
1579     xp[2] = x+w/2;
1580     xp[3] = x-w/2;
1581     xp[4] = x-w/2;
1582
1583     yp[0] = y-h/2;
1584     yp[1] = y-h/2;
1585     yp[2] = y+h/2;
1586     yp[3] = y+h/2;
1587     yp[4] = y-h/2;
1588
1589     reg = new TGRegion(5,xp,yp);
1590     fImageMap->AddRegion(*reg, ib);
1591
1592     snprintf(text,256,"%s (crate %s circuit %3d, number %3d)",board->GetBoardName(),board->GetCrateName(),board->GetIdCircuit(),board->GetNumber());
1593     fImageMap->SetToolTipText(ib, text);
1594
1595     // Set coordinates of strips boxes
1596
1597     SetStripBoxes(board);
1598
1599     //board->PrintBoard();
1600
1601   }
1602
1603 }
1604
1605 //__________________________________________________________________________
1606 void AliMUONTriggerGUI::SetStripBoxes(AliMUONTriggerGUIboard *board)
1607 {
1608   /// set coordinates of strip boxes
1609
1610   AliMUONGeometryTransformer transformer;
1611   transformer.LoadGeometryData("transform.dat");
1612
1613   const AliMpVSegmentation* seg;
1614   AliMpPad pad;
1615   AliMpDEIterator it;
1616
1617   Int_t chamber, detElemId, maxX, maxY;
1618   Float_t xpmin, xpmax, ypmin, ypmax;
1619   Float_t xg1, xg2, yg1, yg2, zg1;
1620   Float_t xlocal1, xlocal2, ylocal1, ylocal2;
1621   Float_t xCenter, yCenter, xWidth, yWidth;
1622
1623   for (Int_t i = 0; i < kNMT; i++) {
1624
1625     chamber = 11+i;
1626
1627     xCenter = board->GetXCenter(i);
1628     yCenter = board->GetYCenter(i);
1629     xWidth  = board->GetXWidth(i);
1630     yWidth  = board->GetYWidth(i);
1631
1632     for ( it.First(chamber-1); ! it.IsDone(); it.Next() ) {
1633
1634       detElemId = it.CurrentDEId();
1635
1636       if (detElemId%100 != board->GetDetElemId()) continue;
1637
1638       /*---------- y-pads cath = 1 ----------*/
1639
1640       seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::kCath1);
1641
1642       maxX = seg->MaxPadIndexX();
1643       maxY = seg->MaxPadIndexY();
1644
1645       for (Int_t ix = 0; ix <= maxX; ix++) {
1646         for (Int_t iy = 0; iy <= maxY; iy++) {
1647
1648           pad = seg->PadByIndices(ix,iy,kFALSE);
1649
1650           if (!pad.IsValid()) continue;
1651
1652           // get the pad position and dimensions
1653           xlocal1 = pad.GetPositionX();
1654           ylocal1 = pad.GetPositionY();
1655           xlocal2 = pad.GetDimensionX();
1656           ylocal2 = pad.GetDimensionY();
1657
1658           transformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
1659           // (no transformation for pad dimensions)
1660           xg2 = xlocal2;
1661           yg2 = ylocal2;
1662
1663           // transform in the monitor coordinate system
1664           // ALICE SC
1665           xpmin = +(xg1-xg2);
1666           xpmax = +(xg1+xg2);
1667           ypmin = -(yg2-yg1);
1668           ypmax = +(yg2+yg1);
1669
1670           xpmin -= xCenter;
1671           xpmax -= xCenter;
1672           ypmin -= yCenter;
1673           ypmax -= yCenter;
1674
1675           Int_t iX1, iX2, iY, ixDig;
1676           iX1 = board->GetYSix1();
1677           iX2 = board->GetYSix2();
1678           iY  = board->GetYSiy();
1679           if (ix >= iX1 && ix <= iX2 && iy == iY) {
1680
1681             ypmin = -0.5*yWidth;
1682             ypmax = +0.5*yWidth;
1683
1684             ixDig = ix - iX1;
1685
1686             board->SetYDigBox(i,ixDig,(Double_t)xpmin,(Double_t)ypmin,
1687                                       (Double_t)xpmax,(Double_t)ypmax);
1688
1689           }
1690
1691         }  // end maxY
1692       }  // end maxX
1693
1694       /*---------- x-pads cath = 0 ----------*/
1695
1696       seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::kCath0);
1697
1698       maxX = seg->MaxPadIndexX();
1699       maxY = seg->MaxPadIndexY();
1700
1701       for (Int_t ix = 0; ix <= maxX; ix++) {
1702         for (Int_t iy = 0; iy <= maxY; iy++) {
1703
1704           pad = seg->PadByIndices(ix,iy,kFALSE);
1705
1706           if (!pad.IsValid()) continue;
1707
1708           // get the pad position and dimensions
1709           xlocal1 = pad.GetPositionX();
1710           ylocal1 = pad.GetPositionY();
1711           xlocal2 = pad.GetDimensionX();
1712           ylocal2 = pad.GetDimensionY();
1713
1714           transformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
1715           // (no transformation for pad dimensions)
1716           xg2 = xlocal2;
1717           yg2 = ylocal2;
1718
1719           // transform in the monitor coordinate system
1720           // ALICE SC
1721           xpmin = +(xg1+xg2);
1722           xpmax = +(xg1-xg2);
1723           ypmin = -(yg2-yg1);
1724           ypmax = +(yg2+yg1);
1725
1726           xpmin -= xCenter;
1727           xpmax -= xCenter;
1728           ypmin -= yCenter;
1729           ypmax -= yCenter;
1730
1731           Int_t iX, iY1, iY2, iyDig;
1732           iX  = board->GetXSix();
1733           iY1 = board->GetXSiy1();
1734           iY2 = board->GetXSiy2();
1735           if (ix == iX && iy >= iY1 && iy <= iY2) {
1736
1737             iyDig = iy - iY1;
1738
1739             board->SetXDigBox(i,iyDig,(Double_t)xpmin,(Double_t)ypmin,
1740                                       (Double_t)xpmax,(Double_t)ypmax);
1741
1742           }
1743
1744         }  // end maxY
1745       }  // end maxX
1746
1747     }  // end detElemId
1748
1749   }  // end kNMT loop
1750
1751 }
1752
1753 //__________________________________________________________________________
1754 void AliMUONTriggerGUI::CreateDigitStore()
1755 {
1756   /// create memory resident digits store with set strips
1757
1758   Int_t nstripX, nstripY, detElemId, charge, ix, iy, iX1, iY1;
1759   Int_t cathode, maxX, maxY;
1760   Int_t manuId, manuChannel;
1761   const AliMpVSegmentation* seg;
1762   AliMpPad pad;
1763   AliMUONTriggerGUIboard* board;
1764   AliMUONVDigit *dig;
1765
1766   for (Int_t ib = 0; ib < kNBoards; ib++) {
1767
1768     board = (AliMUONTriggerGUIboard*)fBoards->At(ib);
1769     if (board == 0) continue;
1770
1771     nstripX = board->GetNStripX();
1772     nstripY = board->GetNStripY();
1773     for (Int_t ichamber = 11; ichamber <= 14; ichamber++) {
1774
1775       detElemId = ichamber * 100 + board->GetDetElemId();
1776       // x strips
1777       cathode = 0;
1778       for (Int_t isx = 0; isx < nstripX; isx++) {
1779
1780         charge = (Int_t)board->GetXDig(ichamber-11,isx);
1781         if (charge == 0) continue;
1782         ix  = board->GetXSix();
1783         iY1 = board->GetXSiy1();
1784         iy  = isx + iY1;
1785         seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(cathode));
1786         maxX = seg->MaxPadIndexX();
1787         maxY = seg->MaxPadIndexY();
1788         if (ix > maxX) printf("Index x > maximum!\n");
1789         if (iy > maxY) printf("Index y > maximum!\n");
1790         pad = seg->PadByIndices(ix,iy,kTRUE);
1791         manuId = pad.GetLocalBoardId(0);
1792         manuChannel = pad.GetLocalBoardChannel(0);
1793
1794         dig = fDigitStore->Add(detElemId,manuId,manuChannel,cathode,AliMUONVDigitStore::kAllow);
1795         dig->SetCharge(charge);
1796         dig->SetPadXY(ix,iy);
1797         //printf("Cathode 0: ix %3d iy %3d manuId %3d manuChannel %3d \n",ix,iy,manuId,manuChannel);
1798
1799       }  // end x strips
1800
1801       // y strips
1802       cathode = 1;
1803       for (Int_t isy = 0; isy < nstripY; isy++) {
1804
1805         charge = board->GetYDig(ichamber-11,isy);
1806         if (charge == 0) continue;
1807         iX1 = board->GetYSix1();
1808         ix  = isy + iX1;
1809         iy  = board->GetYSiy();
1810         seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(cathode));
1811         maxX = seg->MaxPadIndexX();
1812         maxY = seg->MaxPadIndexY();
1813         if (ix > maxX) printf("Index x > maximum!\n");
1814         if (iy > maxY) printf("Index y > maximum!\n");
1815         pad = seg->PadByIndices(ix,iy,kTRUE);
1816         manuId = pad.GetLocalBoardId(0);
1817         manuChannel = pad.GetLocalBoardChannel(0);
1818
1819         dig = fDigitStore->Add(detElemId,manuId,manuChannel,cathode,AliMUONVDigitStore::kAllow);
1820         dig->SetCharge(charge);
1821         dig->SetPadXY(ix,iy);
1822         //printf("Cathode 1: ix %3d iy %3d manuId %3d manuChannel %3d \n",ix,iy,manuId,manuChannel);
1823
1824       }  // end y strips
1825
1826     }  // end chambers
1827
1828   }  // end boards
1829
1830 }
1831
1832 //__________________________________________________________________________
1833 void AliMUONTriggerGUI::PrintDigitStore() const
1834 {
1835   /// Print the digits created in the GUI
1836
1837   const AliMpVSegmentation* seg;
1838   AliMpPad pad;
1839   Int_t ix, iy, charge, detElemId, cathode;
1840
1841   Int_t chamber;
1842   for (Int_t i = 0; i < kNMT; i++) {
1843
1844     chamber = 11+i;
1845
1846     MpPair_t deRange = AliMpDEManager::GetDetElemIdRange(chamber-1);
1847     TIter next(fDigitStore->CreateIterator(AliMp::PairFirst(deRange),AliMp::PairSecond(deRange)));
1848     AliMUONVDigit *mdig;
1849
1850     while ( ( mdig = static_cast<AliMUONVDigit*>(next())) )
1851     {
1852       cathode = mdig->Cathode();
1853
1854       ix = mdig->PadX();
1855       iy = mdig->PadY();
1856       detElemId = mdig->DetElemId();
1857       charge = (Int_t)mdig->Charge();
1858
1859       seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(cathode));
1860       pad = seg->PadByIndices(ix,iy,kTRUE);
1861
1862       printf("Digit: detElemId %4d cath %1d ix %2d iy %3d charge %1d \n",detElemId,cathode,ix,iy,charge);
1863
1864     }
1865
1866   }
1867
1868 }
1869
1870 //__________________________________________________________________________
1871 void AliMUONTriggerGUI::CreateTriggerStore()
1872 {
1873   /// Process the DSET digit store and fill the trigger store
1874
1875   if (fDigitStore->GetSize() == 0) {
1876     printf("The digit store is empty...\n");
1877     return;
1878   }
1879   fTStoreOn = kTRUE;
1880
1881   AliMUONVDigitStore *digitStore = static_cast<AliMUONVDigitStore*>(fDigitStore);
1882
1883   fTriggerProcessor->Digits2Trigger(*digitStore,*fTriggerStore);
1884
1885 }
1886
1887 //__________________________________________________________________________
1888 void AliMUONTriggerGUI::PrintTriggerStore() const
1889 {
1890   /// Print the trigger output for DSET digits store
1891
1892   if (!fTStoreOn) return;
1893
1894   TIter next(fTriggerStore->CreateLocalIterator());
1895
1896   UShort_t x2m, x2u, x2d;
1897   Int_t loStripX, loStripY, loDev, loCircuit, iStripX, iStripY, loLpt, loHpt;
1898   AliMUONLocalTrigger *mlt;
1899   while ( ( mlt = static_cast<AliMUONLocalTrigger*>(next()) ) )
1900   {
1901     loCircuit = mlt->LoCircuit();
1902
1903     AliMUONLocalTriggerBoard* ltb = fCrateManager->LocalBoard(loCircuit);
1904     x2d = ltb->GetSwitch(0);
1905     x2m = ltb->GetSwitch(1);
1906     x2u = ltb->GetSwitch(2);
1907
1908     loStripX = mlt->LoStripX();
1909     loStripY = mlt->LoStripY();
1910     loDev    = mlt->LoDev();
1911     loLpt    = mlt->LoLpt();
1912     loHpt    = mlt->LoHpt();
1913
1914     iStripX = loStripX/2;
1915     if ((x2u == 1 || x2m == 1 || x2d == 1) && x2m == 1) {
1916       iStripY = loStripY/2;
1917     } else {
1918       iStripY = loStripY;
1919     }
1920
1921     printf("Circ %3d Xs %2d Ys %2d Dev %2d Lpt %1d Hpt %1d \n",loCircuit,loStripX,loStripY,loDev,loLpt,loHpt);
1922
1923     AliMUONGlobalTrigger *globalTrigger = fTriggerStore->Global();
1924     globalTrigger->Print();
1925
1926   }
1927
1928 }
1929
1930 //__________________________________________________________________________
1931 void AliMUONTriggerGUI::WriteTriggerRawData()
1932 {
1933   /// Write raw data (DATE and ROOT) for the trigger store from
1934   /// the DSET digit store
1935
1936   if (!fTStoreOn) {
1937     printf("The trigger store is empty... \n");
1938     return;
1939   }
1940
1941   // raw data (ddl)
1942
1943   AliMUONRawWriter *rawWriter = new AliMUONRawWriter();
1944   AliRawDataHeaderSim header;
1945   rawWriter->SetHeader(header);
1946   rawWriter->Digits2Raw(0,fTriggerStore);
1947
1948   delete rawWriter;
1949
1950   // raw data (ddl) to date
1951   // AliSimulation::ConvertRawFilesToDate
1952
1953   char command[256];
1954   char dateFileName[256];
1955   snprintf(dateFileName,256,"TriggerGUI.date");
1956   snprintf(command, 256,"dateStream -c -s -D -o %s -# %d -C -run %d",
1957           dateFileName, 1, 0);
1958   FILE* pipe = gSystem->OpenPipe(command, "w");
1959
1960   UInt_t detectorPattern = 0;
1961   fprintf(pipe, "GDC DetectorPattern %u\n", detectorPattern);
1962   Float_t ldc = 0;
1963   Int_t prevLDC = -1;
1964
1965   // loop over detectors and DDLs
1966   for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1967     for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1968
1969       Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1970       Int_t ldcID = Int_t(ldc + 0.0001);
1971       ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1972
1973       char rawFileName[256];
1974       snprintf(rawFileName, 256,"%s",AliDAQ::DdlFileName(iDet,iDDL));
1975       // check existence and size of raw data file
1976       FILE* file = fopen(rawFileName, "rb");
1977       if (!file) continue;
1978       fseek(file, 0, SEEK_END);
1979       unsigned long size = ftell(file);
1980       fclose(file);
1981       if (!size) continue;
1982
1983       if (ldcID != prevLDC) {
1984         fprintf(pipe, " LDC Id %d\n", ldcID);
1985         prevLDC = ldcID;
1986       }
1987       fprintf(pipe, "  Equipment Id %d Payload %s\n", ddlID, rawFileName);
1988     }
1989   }
1990   Int_t result = gSystem->ClosePipe(pipe);
1991
1992   // raw data (date) to root
1993   // AliSimulation::ConvertDateToRoot
1994
1995   char rootFileName[256];
1996   snprintf(rootFileName,256,"TriggerGUI.root");
1997
1998   // ALIMDC setup
1999   const Int_t kDBSize = 2000000000;
2000   const Int_t kTagDBSize = 1000000000;
2001   const Bool_t kFilter = kFALSE;
2002   const Int_t kCompression = 1;
2003
2004   char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
2005   if (!path) {
2006     printf("the program alimdc was not found\n");
2007     return;
2008   } else {
2009     delete[] path;
2010   }
2011
2012   printf("converting DATE file %s to root file %s \n",
2013                dateFileName, rootFileName);
2014
2015   const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
2016   const char* tagDBFS    = "/tmp/mdc1/tags";
2017
2018   // User defined file system locations
2019   if (gSystem->Getenv("ALIMDC_RAWDB1"))
2020     rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
2021   if (gSystem->Getenv("ALIMDC_RAWDB2"))
2022     rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
2023   if (gSystem->Getenv("ALIMDC_TAGDB"))
2024     tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
2025
2026   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
2027   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
2028   gSystem->Exec(Form("rm -rf %s",tagDBFS));
2029
2030   gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
2031   gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
2032   gSystem->Exec(Form("mkdir %s",tagDBFS));
2033
2034   result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
2035                               kDBSize, kTagDBSize, kFilter, kCompression,
2036                               dateFileName));
2037   gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
2038
2039   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
2040   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
2041   gSystem->Exec(Form("rm -rf %s",tagDBFS));
2042
2043 }
2044
2045 //__________________________________________________________________________
2046 void AliMUONTriggerGUI::FETboard(Int_t ib, Int_t amp)
2047 {
2048   /// Front End test set all strips for board with index "ib"
2049   /// AliMUONTriggerGUIbdmap::DoDigits()
2050
2051   AliMUONTriggerGUIboard *board;
2052   AliMUONTriggerGUIboard *btmp;
2053   Int_t pos, over, number, nStripX, nStripY;
2054
2055   board = (AliMUONTriggerGUIboard*)fBoards->At(ib);
2056   if (board == 0) return;
2057
2058   nStripX = board->GetXSiy2() - board->GetXSiy1() + 1;
2059   nStripY = board->GetYSix2() - board->GetYSix1() + 1;
2060
2061   number = board->GetNumber();
2062   pos    = board->GetPosition();
2063   over   = board->GetYOver();
2064
2065   for (Int_t imt = 0; imt < kNMT; imt++) {
2066
2067     for (Int_t ix = 0; ix < nStripX; ix++) {
2068       board->SetDigitX(imt,ix,amp);
2069     }
2070
2071     for (Int_t iy = 0; iy < nStripY; iy++) {
2072       board->SetDigitY(imt,iy,amp);
2073
2074       // extended y-strips
2075       for (Int_t io = 1; io <= over; io++) {
2076         if (io == pos) continue;
2077         btmp = (AliMUONTriggerGUIboard*)fBoards->UncheckedAt(number+io-pos);
2078         btmp->SetDigitY(imt,iy,amp);
2079       }
2080
2081     }
2082
2083   }
2084
2085 }
2086
2087 //__________________________________________________________________________
2088 void AliMUONTriggerGUI::FET(Int_t onoff)
2089 {
2090   /// Front End test set all strips for all boards
2091   /// AliMUONTriggerGUIbdmap::DoDigits()
2092
2093   Int_t amp = onoff;
2094
2095   for (Int_t ib = 0; ib < kNBoards; ib++) {
2096     FETboard(ib,amp);
2097   }
2098
2099 }
2100
2101 //__________________________________________________________________________
2102 void AliMUONTriggerGUI::ClearDigitStore()
2103 {
2104   /// Clear the DSET digit store
2105
2106   fDigitStore->Clear();
2107
2108 }
2109
2110 //__________________________________________________________________________
2111 void AliMUONTriggerGUI::ClearTriggerStore()
2112 {
2113   /// Clear the trigger store from the DSET digit store
2114
2115   fTriggerStore->Clear();
2116   fTStoreOn = kFALSE;
2117
2118 }