Go from pointer to ifstream to ifstream.
[u/mrichter/AliRoot.git] / 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 }