Fixes for #86059: Install data when ALICE_ROOT does not point to source (Christian)
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerGUIbdmap.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 AliMUONTriggerGUIbdmap
20 ///
21 /// The gui map of a single board object, strips/digits
22 ///
23 /// \author Bogdan Vulpescu, LPC Clermont-Ferrand
24 //-----------------------------------------------------------------------------
25
26 #include <TPolyLine.h>
27 #include <TStyle.h>
28 #include <TGButton.h>
29 #include <TRootEmbeddedCanvas.h>
30 #include <TBox.h>
31 #include <TPaveText.h>
32 #include <TGTextEdit.h>
33 #include <TGText.h>
34 #include <TTimer.h>
35 #include <TObjArray.h>
36 #include <TCanvas.h>
37
38 #include "AliLoader.h"
39 #include "AliRunLoader.h"
40 #include "AliMUONVDigit.h"
41 #include "AliMUONGeometryTransformer.h"
42 #include "AliMUONLocalTrigger.h"
43 #include "AliMUONLocalTriggerBoard.h"
44 #include "AliMUONTriggerCrateStore.h"
45 #include "AliMUONMCDataInterface.h"
46 #include "AliMUONTriggerStoreV1.h"
47 #include "AliMUONDigitStoreV1.h"
48 #include "AliMUONTriggerGUIboard.h"
49 #include "AliMUONTriggerGUIbdmap.h"
50
51 #include "AliMpDEManager.h"
52 #include "AliMpDEIterator.h"
53 #include "AliMpEncodePair.h"
54 #include "AliMpVSegmentation.h"
55 #include "AliMpSegmentation.h"
56
57 #include <cstdio>
58
59
60 /// \cond CLASSIMP
61 ClassImp(AliMUONTriggerGUIbdmap)
62 /// \endcond
63
64 //__________________________________________________________________________
65 AliMUONTriggerGUIbdmap::AliMUONTriggerGUIbdmap(const TGWindow *p, const TGWindow *mainWindow, UInt_t w, UInt_t h)
66   : TGFrame(0),
67     fMain(0),
68     fLocTrigE(0),
69     fBoard(0),
70     fLoader(0),
71     fMCDataInterface(0),
72     fRawDigitStore(0),
73     fRawTriggerStore(0),
74     fXStrips(0),
75     fYStrips(0),
76     fEditStrips(0),
77     fXOn(0),
78     fYOn(0),
79     fLabelX(0),
80     fLabelY(0),
81     fIsEditable(0),
82     fCanvasSize(0),
83     fNStripX(0),
84     fNStripY(0),
85     fBoards(0),
86     fCalibrationData(0x0),
87     fCrateManager(0)
88 {
89   /// frame constructor
90
91   gStyle->SetPadLeftMargin(0.05);
92   gStyle->SetPadRightMargin(0.05);
93   gStyle->SetPadTopMargin(0.05);
94   gStyle->SetPadBottomMargin(0.05);
95
96   fMain = new TGTransientFrame(p, mainWindow, w, h, kVerticalFrame);
97   fMain->Connect("CloseWindow()", "AliMUONTriggerGUIbdmap", this, "CloseWindow()");
98   fMain->DontCallClose(); // to avoid double deletions.
99   
100   // use hierarchical cleaning
101   fMain->SetCleanup(kDeepCleanup);
102
103   fMain->ChangeOptions((fMain->GetOptions() & ~kVerticalFrame) | kHorizontalFrame);
104
105   // strips/digits canvases
106   
107   fCanvasSize = 200;
108
109   TRootEmbeddedCanvas *recanvas[4];
110   Char_t ecname[2];
111   for (Int_t i = 0; i < kNMT; i++) {
112
113     snprintf(ecname,2,"%1d",i+1);
114     recanvas[i] = new TRootEmbeddedCanvas(ecname,fMain,fCanvasSize,fCanvasSize);
115     
116     fCanvas[i] = recanvas[i]->GetCanvas();
117     
118     fCanvas[i]->SetBorderMode(0);
119     fCanvas[i]->SetBit(kNoContextMenu);
120     
121     fCanvas[i]->Connect("ProcessedEvent(Int_t,Int_t,Int_t,TObject*)",
122                         "AliMUONTriggerGUIbdmap",this,
123                         "EditStrips(Int_t,Int_t,Int_t,TObject*)");
124
125     fMain->AddFrame(recanvas[i],
126                     /*
127                     new TGTableLayoutHints(2,5,2,6,
128                                            kLHintsExpandX|kLHintsExpandY |
129                                            kLHintsShrinkX|kLHintsShrinkY |
130                                            kLHintsFillX|kLHintsFillY)
131                     */
132                     new TGLayoutHints(kLHintsTop | 
133                                       kLHintsLeft, 
134                                       2, 2, 2, 2)
135                     );
136
137   }
138
139   //TGDimension size = fMain->GetDefaultSize();
140   //fMain->Resize(size);
141     
142   // the other frames
143
144   TGCompositeFrame *cf0 = new TGCompositeFrame(fMain, 60, 20, kVerticalFrame);
145
146   TGCompositeFrame *cf1 = new TGCompositeFrame(cf0, 60, 20, kVerticalFrame | kFixedWidth);
147
148   cf1->AddFrame(fXStrips = new TGCheckButton(cf1, "Draw X strips and digits", 1),
149                 new TGLayoutHints(kLHintsTop | 
150                                   kLHintsLeft, 
151                                   2, 2, 2, 2)
152                 );
153
154   cf1->Resize(fXStrips->GetDefaultWidth()+10, fMain->GetDefaultHeight());
155
156   cf1->AddFrame(fYStrips = new TGCheckButton(cf1, "Draw Y strips and digits", 2),
157                 new TGLayoutHints(kLHintsTop | 
158                                   kLHintsLeft, 
159                                   2, 2, 2, 2)          
160                 );
161
162   cf1->Resize(fYStrips->GetDefaultWidth()+10, fMain->GetDefaultHeight());
163
164   cf1->AddFrame(fEditStrips = new TGCheckButton(cf1, "Set/unset strips", 3),
165                 new TGLayoutHints(kLHintsTop | 
166                                   kLHintsLeft, 
167                                   2, 2, 2, 2)          
168                 );
169
170   fXStrips->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "HandleButtons()");
171   fYStrips->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "HandleButtons()");
172   fEditStrips->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "HandleEditButton()");
173
174   cf0->AddFrame(cf1, 
175                 new TGLayoutHints(kLHintsTop | 
176                                   kLHintsExpandX, 
177                                   2, 2, 2, 2)          
178                 );
179   
180   TGCompositeFrame *cf2 = new TGCompositeFrame(cf0, 60, 20, kHorizontalFrame | kFixedWidth);
181
182   TGTextButton *digitsButton = new TGTextButton(cf2, "Digits", 4);
183   digitsButton->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "DoDigits()");
184
185   //cf2->Resize(digitsButton->GetDefaultWidth()+40, fMain->GetDefaultHeight());
186
187   cf2->AddFrame(digitsButton, 
188                 new TGLayoutHints(kLHintsTop | 
189                                   kLHintsLeft |
190                                   kLHintsExpandX, 
191                                   2, 2, 5, 5)          
192                 );
193
194   TGTextButton *dresetButton = new TGTextButton(cf2, "Reset", 5);
195   dresetButton->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "ResetDigits()");
196
197   //cf2->Resize(dresetButton->GetDefaultWidth()+40, fMain->GetDefaultHeight());
198
199   cf2->AddFrame(dresetButton, 
200                 new TGLayoutHints(kLHintsTop | 
201                                   kLHintsLeft |
202                                   kLHintsExpandX, 
203                                   2, 2, 5, 5)          
204                 );
205
206   TGTextButton *closeButton = new TGTextButton(cf2, "Close", 6);
207   closeButton->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "DoClose()");
208
209   //cf2->Resize(closeButton->GetDefaultWidth()+40, fMain->GetDefaultHeight());
210
211   cf2->AddFrame(closeButton, 
212                 new TGLayoutHints(kLHintsTop | 
213                                   kLHintsLeft |
214                                   kLHintsExpandX, 
215                                   2, 2, 5, 5)          
216                 );
217
218   cf0->AddFrame(cf2, 
219                   new TGLayoutHints(kLHintsTop | 
220                                     kLHintsExpandX, 
221                                     2, 2, 2, 2)        
222                   );
223   
224   // editor window for the local trigger
225
226   TGCompositeFrame *cf3 = new TGCompositeFrame(cf0, 60, 20, kVerticalFrame | kFixedWidth);
227
228   fLocTrigE = new TGTextEdit(cf3, 100, 100, kSunkenFrame | kDoubleBorder);
229   cf3->AddFrame(fLocTrigE, 
230                 new TGLayoutHints(kLHintsExpandX | 
231                                   kLHintsExpandY, 
232                                   3, 3, 3, 3)
233                 );
234
235   cf0->AddFrame(cf3, 
236                   new TGLayoutHints(kLHintsTop | 
237                                     kLHintsExpandX, 
238                                     2, 2, 2, 2)        
239                   );
240   
241   fMain->AddFrame(cf0, 
242                   new TGLayoutHints(kLHintsTop | 
243                                     kLHintsExpandX, 
244                                     2, 2, 2, 2)        
245                   );
246   
247   fIsEditable = kFALSE;
248   fLabelX = kFALSE;
249   fLabelY = kFALSE;
250
251   fMain->MapSubwindows();
252   fMain->Resize();
253   
254   fMain->CenterOnParent();
255
256   //fMain->MapWindow();
257   //gClient->WaitFor(fMain);
258   
259 }
260
261 //__________________________________________________________________________
262 AliMUONTriggerGUIbdmap::~AliMUONTriggerGUIbdmap()
263 {
264   /// frame destructor
265
266   fMain->DeleteWindow();
267
268 }
269
270 //__________________________________________________________________________
271 void AliMUONTriggerGUIbdmap::Show()
272 {
273   /// map the main frame
274
275   fMain->MapWindow();
276   LocalTriggerInfo();
277
278 }
279
280 //__________________________________________________________________________
281 void AliMUONTriggerGUIbdmap::LocalTriggerInfo()
282 {
283   /// print the local trigger
284
285   TGText txt;
286   Char_t buffer[20];
287
288   snprintf(buffer,20,"Local trigger info\n");
289   fLocTrigE->LoadBuffer(buffer);
290
291   AliMUONVTriggerStore *triggerStore;
292
293   if (fLoader != 0x0) {
294     AliRunLoader *runLoader = fLoader->GetRunLoader();
295     triggerStore = fMCDataInterface->TriggerStore(runLoader->GetEventNumber());
296   } else if (fRawTriggerStore != 0x0) {
297     triggerStore = static_cast<AliMUONVTriggerStore*>(fRawTriggerStore);
298   } else {
299     snprintf(buffer,20,"No data loaded yet...\n");
300     txt.LoadBuffer(buffer);
301     fLocTrigE->AddText(&txt);
302     return;
303   }
304
305   Int_t circuitNumber = fBoard->GetIdCircuit();
306
307   UShort_t x2m, x2u, x2d;
308
309   Int_t loStripX, loStripY, loDev, loCircuit, iStripX, iStripY, loLpt, loHpt;
310   AliMUONLocalTrigger *mlt;
311
312   TIter next(triggerStore->CreateLocalIterator());
313   
314   while ( ( mlt = static_cast<AliMUONLocalTrigger*>(next()) ) )
315   {    
316     loCircuit = mlt->LoCircuit();
317
318     if (loCircuit == circuitNumber) {
319
320       AliMUONLocalTriggerBoard* ltb = fCrateManager->LocalBoard(loCircuit);
321       x2d = ltb->GetSwitch(0);
322       x2m = ltb->GetSwitch(1);
323       x2u = ltb->GetSwitch(2);
324
325       loStripX = mlt->LoStripX();
326       loStripY = mlt->LoStripY();
327       loDev    = mlt->LoDev();
328       loLpt    = mlt->LoLpt();
329       loHpt    = mlt->LoHpt();
330
331       iStripX = loStripX/2;
332       if ((x2u == 1 || x2m == 1 || x2d == 1) && x2m == 1) {
333         iStripY = loStripY/2;
334       } else {
335         iStripY = loStripY;
336       }
337
338       snprintf(buffer,20,"Circuit = %03d",loCircuit);
339       txt.LoadBuffer(buffer);
340       fLocTrigE->AddText(&txt);
341
342       snprintf(buffer,20,"LoStripX = %2d",loStripX);
343       txt.LoadBuffer(buffer);
344       fLocTrigE->AddText(&txt);
345
346       snprintf(buffer,20,"LoStripY = %2d",loStripY);
347       txt.LoadBuffer(buffer);
348       fLocTrigE->AddText(&txt);
349
350       snprintf(buffer,20,"LoDev = %2d",loDev);
351       txt.LoadBuffer(buffer);
352       fLocTrigE->AddText(&txt);
353
354       snprintf(buffer,20,"--------------------");
355       txt.LoadBuffer(buffer);
356       fLocTrigE->AddText(&txt);
357
358       snprintf(buffer,20,"X-strip = %2d ( %2d )",iStripX,(loStripX+loDev+1)/2);
359       txt.LoadBuffer(buffer);
360       fLocTrigE->AddText(&txt);
361
362       snprintf(buffer,20,"Y-strip = %2d",iStripY);
363       txt.LoadBuffer(buffer);
364       fLocTrigE->AddText(&txt);
365
366       snprintf(buffer,20,"--------------------");
367       txt.LoadBuffer(buffer);
368       fLocTrigE->AddText(&txt);
369
370       snprintf(buffer,20,"LoLpt = %2d",loLpt);
371       txt.LoadBuffer(buffer);
372       fLocTrigE->AddText(&txt);
373
374       snprintf(buffer,20,"LoHpt = %2d",loHpt);
375       txt.LoadBuffer(buffer);
376       fLocTrigE->AddText(&txt);
377
378       break;
379
380     }
381
382   }
383   
384 }
385
386 //__________________________________________________________________________
387 void AliMUONTriggerGUIbdmap::Init()
388 {
389   /// initialize the boards in the four MT
390
391   for (Int_t i = 0; i < kNMT; i++) {
392
393     fXWidth[i]  = fBoard->GetXWidth(i);
394     fYWidth[i]  = fBoard->GetYWidth(i); 
395     fXCenter[i] = fBoard->GetXCenter(i);
396     fYCenter[i] = fBoard->GetYCenter(i); 
397     
398   }
399
400   Float_t xw, yw;
401   for (Int_t i = 0; i < kNMT; i++) {
402     xw = 1.20*fXWidth[i];
403     yw = 1.20*fYWidth[i];
404     fCanvas[i]->Range(-xw/2,-yw/2,+xw/2,+yw/2);
405     for (Int_t is = 0; is < kNS; is++) {
406
407       fXDigPL[i][is] = new TPolyLine(5);
408       fYDigPL[i][is] = new TPolyLine(5);
409       fXDigPL[i][is]->SetBit(kCannotPick);
410       fYDigPL[i][is]->SetBit(kCannotPick);
411       fXDigPL[i][is]->SetLineColor(4);
412       fYDigPL[i][is]->SetLineColor(4);
413
414       fXDigBox[i][is] = new TBox(0,0,0,0);
415       fYDigBox[i][is] = new TBox(0,0,0,0);
416       fXDigBox[i][is]->SetBit(kCannotPick);
417       fYDigBox[i][is]->SetBit(kCannotPick);
418       fXDigBox[i][is]->SetFillStyle(0);
419       fYDigBox[i][is]->SetFillStyle(0);
420       fXDigBox[i][is]->SetLineColor(4);
421       fYDigBox[i][is]->SetLineColor(4);
422
423       fXLabelL[i][is] = 0;
424       fXLabelR[i][is] = 0;
425       fYLabelL[i][is] = 0;
426       fYLabelR[i][is] = 0;
427
428     }
429   }
430
431
432   fXOn = kFALSE;
433   fYOn = kFALSE;
434
435   fNStripX = fBoard->GetXSiy2() - fBoard->GetXSiy1() + 1;
436   fNStripY = fBoard->GetYSix2() - fBoard->GetYSix1() + 1;
437
438 }
439
440 //__________________________________________________________________________
441 void AliMUONTriggerGUIbdmap::HandleEditButton()
442 {
443   /// handle the editable check button
444
445   if (((fXOn && !fYOn) || (!fXOn && fYOn)) && 
446       (fEditStrips->GetState() == kButtonDown)) {
447     fIsEditable = kTRUE;
448   } else {
449     fIsEditable = kFALSE;
450   }
451
452 }
453
454 //__________________________________________________________________________
455 void AliMUONTriggerGUIbdmap::EditStrips(Int_t event, Int_t x, Int_t y, TObject *sel)
456 {
457   /// set/unset strips
458
459   TString cs;
460   Int_t iMT;
461   Double_t *px, *py;
462   Double_t xf1, yf1, xf2, yf2;
463   Int_t np = 5;
464   Double_t xMin, xMax, yMin, yMax;
465   Float_t xd, yd, fxDim, fyDim, cDim;
466   Char_t cln[3];
467
468   cDim = (Float_t)fCanvasSize;
469   
470   // the (x,y) event does not really go up to the canvas size...
471   cDim = 196.0;
472
473   if (fIsEditable) {
474
475     if (event == kButton1Down) {
476       
477       cs = TString(sel->GetName());
478       iMT = cs.Atoi()-1;
479
480       fCanvas[iMT]->cd();
481
482       fCanvas[iMT]->GetRange(xf1,yf1,xf2,yf2);      
483       fxDim = (Float_t)xf2;
484       fyDim = (Float_t)yf2;
485
486       //xd = fxDim*(+2.0*(Float_t)(x)/cDim - 1.0);
487       //yd = fyDim*(-2.0*(Float_t)(y)/cDim + 1.0);
488
489       xd = +(2.0*fxDim*(Float_t)(x))/cDim - fxDim;
490       yd = -(2.0*fyDim*(Float_t)(y))/cDim + fyDim;
491
492       if (fXOn) {
493
494         for (Int_t ix = 0; ix < fNStripX; ix++) {
495           
496           px = fXDigPL[iMT][ix]->GetX();
497           py = fXDigPL[iMT][ix]->GetY();
498
499           xMin = +9999.;
500           xMax = -9999.;
501           yMin = +9999.;
502           yMax = -9999.;
503           for (Int_t ip = 0; ip < np; ip++) {
504             xMin = TMath::Min(xMin,px[ip]);
505             xMax = TMath::Max(xMax,px[ip]);
506             yMin = TMath::Min(yMin,py[ip]);
507             yMax = TMath::Max(yMax,py[ip]);
508           }
509             
510           if (yd > (Float_t)yMin && yd < (Float_t)yMax) {
511
512             if (fXDigBox[iMT][ix]->GetFillStyle() == 0) {
513
514               fXDigBox[iMT][ix]->SetFillStyle(1001);
515               fXDigBox[iMT][ix]->SetFillColor(2);
516
517               snprintf(cln,3,"%2d",ix);
518
519               fXLabelL[iMT][ix]->Clear();
520               fXLabelL[iMT][ix]->AddText(cln);
521               fXLabelL[iMT][ix]->Draw();
522
523               fXLabelR[iMT][ix]->Clear();
524               fXLabelR[iMT][ix]->AddText(cln);
525               fXLabelR[iMT][ix]->Draw();
526
527               fXDigBox[iMT][ix]->SetX1(xMin);
528               fXDigBox[iMT][ix]->SetY1(yMin);
529               fXDigBox[iMT][ix]->SetX2(xMax);
530               fXDigBox[iMT][ix]->SetY2(yMax);
531
532               fXDigBox[iMT][ix]->Draw();
533
534             } else if (fXDigBox[iMT][ix]->GetFillStyle() == 1001) {
535
536               fXDigBox[iMT][ix]->SetFillStyle(0);
537
538               fXLabelL[iMT][ix]->Clear();
539               fXLabelL[iMT][ix]->Draw();
540
541               fXLabelR[iMT][ix]->Clear();
542               fXLabelR[iMT][ix]->Draw();
543
544               fXDigBox[iMT][ix]->SetX1(-fBoard->GetXCenter(iMT));
545               fXDigBox[iMT][ix]->SetY1(-fBoard->GetYCenter(iMT));
546               fXDigBox[iMT][ix]->SetX2(-fBoard->GetXCenter(iMT));
547               fXDigBox[iMT][ix]->SetY2(-fBoard->GetYCenter(iMT));
548
549               fXDigBox[iMT][ix]->Draw();
550
551             }
552
553             if (!fXDigBox[iMT][ix]->TestBit(kObjInCanvas))
554               fXDigBox[iMT][ix]->Draw();
555
556             fCanvas[iMT]->Modified();
557             fCanvas[iMT]->Update();
558
559             break;
560             
561           } 
562         }
563
564       }
565
566       if (fYOn) {
567
568         for (Int_t iy = 0; iy < fNStripY; iy++) {
569
570           px = fYDigPL[iMT][iy]->GetX();
571           py = fYDigPL[iMT][iy]->GetY();
572
573           xMin = +9999.;
574           xMax = -9999.;
575           yMin = +9999.;
576           yMax = -9999.;
577           for (Int_t ip = 0; ip < np; ip++) {
578             xMin = TMath::Min(xMin,px[ip]);
579             xMax = TMath::Max(xMax,px[ip]);
580             yMin = TMath::Min(yMin,py[ip]);
581             yMax = TMath::Max(yMax,py[ip]);
582           }
583
584           if (xd > (Float_t)xMin && xd < (Float_t)xMax) {
585
586             if (fYDigBox[iMT][iy]->GetFillStyle() == 0) {
587
588               fYDigBox[iMT][iy]->SetFillStyle(1001);
589               fYDigBox[iMT][iy]->SetFillColor(2);
590
591               snprintf(cln,3,"%2d",iy);
592
593               fYLabelL[iMT][iy]->Clear();
594               fYLabelL[iMT][iy]->AddText(cln);
595               fYLabelL[iMT][iy]->Draw();
596
597               fYLabelR[iMT][iy]->Clear();
598               fYLabelR[iMT][iy]->AddText(cln);
599               fYLabelR[iMT][iy]->Draw();
600
601               fYDigBox[iMT][iy]->SetX1(xMin);
602               fYDigBox[iMT][iy]->SetY1(yMin);
603               fYDigBox[iMT][iy]->SetX2(xMax);
604               fYDigBox[iMT][iy]->SetY2(yMax);
605               
606               fYDigBox[iMT][iy]->Draw();
607
608             } else if (fYDigBox[iMT][iy]->GetFillStyle() == 1001) {
609
610               fYDigBox[iMT][iy]->SetFillStyle(0);
611
612               fYLabelL[iMT][iy]->Clear();
613               fYLabelL[iMT][iy]->Draw();
614
615               fYLabelR[iMT][iy]->Clear();
616               fYLabelR[iMT][iy]->Draw();
617
618               fYDigBox[iMT][iy]->SetX1(-fBoard->GetXCenter(iMT));
619               fYDigBox[iMT][iy]->SetY1(-fBoard->GetYCenter(iMT));
620               fYDigBox[iMT][iy]->SetX2(-fBoard->GetXCenter(iMT));
621               fYDigBox[iMT][iy]->SetY2(-fBoard->GetYCenter(iMT));
622
623               fYDigBox[iMT][iy]->Draw();
624
625             }
626
627             if (!fYDigBox[iMT][iy]->TestBit(kObjInCanvas))
628               fYDigBox[iMT][iy]->Draw();
629
630             fCanvas[iMT]->Modified();
631             fCanvas[iMT]->Update();
632
633             break;
634             
635           } 
636         }
637
638       }
639
640     }  // end button event
641
642   }  // end IsEditable
643
644 }
645
646 //__________________________________________________________________________
647 void AliMUONTriggerGUIbdmap::DoDigits()
648 {
649   /// set the board digits from GUI input (set/unset)
650
651   Int_t amp = 0;
652   Int_t number = fBoard->GetNumber();
653   Int_t pos, over;
654   pos  = fBoard->GetPosition();
655   over = fBoard->GetYOver();
656   AliMUONTriggerGUIboard *board;
657
658   for (Int_t imt = 0; imt < kNMT; imt++) {
659
660     for (Int_t ix = 0; ix < fNStripX; ix++) {
661       if (fXDigBox[imt][ix]->GetFillStyle() ==    0) {
662         amp = 0;
663       }
664       if (fXDigBox[imt][ix]->GetFillStyle() == 1001) {
665         amp = 1;
666       }
667       fBoard->SetDigitX(imt,ix,amp);
668     }
669
670     for (Int_t iy = 0; iy < fNStripY; iy++) {
671       if (fYDigBox[imt][iy]->GetFillStyle() ==    0) {
672         amp = 0;
673       }
674       if (fYDigBox[imt][iy]->GetFillStyle() == 1001) {
675         amp = 1;
676       }
677       fBoard->SetDigitY(imt,iy,amp);
678
679       // extended y-strips
680       for (Int_t io = 1; io <= over; io++) {
681         if (io == pos) continue;
682         board = (AliMUONTriggerGUIboard*)fBoards->UncheckedAt(number+io-pos);
683         board->SetDigitY(imt,iy,amp);
684       }
685
686     }
687
688   }
689
690 }
691
692 //__________________________________________________________________________
693 void AliMUONTriggerGUIbdmap::ResetDigits()
694 {
695   /// set the board digits from GUI input (set/unset)
696
697   Int_t amp = 0;
698   Int_t number = fBoard->GetNumber();
699   AliMUONTriggerGUIboard *board;
700   Int_t pos, over;
701   pos  = fBoard->GetPosition();
702   over = fBoard->GetYOver();
703
704   for (Int_t imt = 0; imt < kNMT; imt++) {
705     for (Int_t ix = 0; ix < fNStripX; ix++) {
706       fXDigBox[imt][ix]->SetFillStyle(0);
707       fXDigBox[imt][ix]->SetX1(-fBoard->GetXCenter(imt));
708       fXDigBox[imt][ix]->SetY1(-fBoard->GetYCenter(imt));
709       fXDigBox[imt][ix]->SetX2(-fBoard->GetXCenter(imt));
710       fXDigBox[imt][ix]->SetY2(-fBoard->GetYCenter(imt));
711
712       fBoard->SetDigitX(imt,ix,amp);
713     }
714     for (Int_t iy = 0; iy < fNStripY; iy++) {
715       fYDigBox[imt][iy]->SetFillStyle(0);
716       fYDigBox[imt][iy]->SetX1(-fBoard->GetXCenter(imt));
717       fYDigBox[imt][iy]->SetY1(-fBoard->GetYCenter(imt));
718       fYDigBox[imt][iy]->SetX2(-fBoard->GetXCenter(imt));
719       fYDigBox[imt][iy]->SetY2(-fBoard->GetYCenter(imt));
720
721       fBoard->SetDigitY(imt,iy,amp);
722
723       // extended y-strips
724       for (Int_t io = 1; io <= over; io++) {
725         if (io == pos) continue;
726         board = (AliMUONTriggerGUIboard*)fBoards->UncheckedAt(number+io-pos);
727
728         board->SetDigitY(imt,iy,amp);
729
730       }
731
732     }
733   }
734
735   fBoard->ClearXDigits();
736   fBoard->ClearYDigits();
737
738   // extended y-strips
739   for (Int_t io = 1; io <= over; io++) {
740     if (io == pos) continue;
741     board = (AliMUONTriggerGUIboard*)fBoards->UncheckedAt(number+io-pos);
742     board->ClearYDigits();
743   }
744   
745   fXStrips->SetState(kButtonUp);
746   fYStrips->SetState(kButtonUp);
747   fEditStrips->SetState(kButtonUp);
748   fIsEditable = kFALSE;
749                       
750   DrawClear();
751   fXOn = kFALSE;
752   fYOn = kFALSE;
753
754 }
755
756 //__________________________________________________________________________
757 void AliMUONTriggerGUIbdmap::HandleButtons(Int_t id)
758 {
759   /// handle the check buttons
760
761   if (id == -1) {
762     TGButton *btn = (TGButton *) gTQSender;
763     id = btn->WidgetId();
764   }
765
766   // draw x and y 
767   if(fXStrips->GetState() == kButtonDown && 
768      fYStrips->GetState() == kButtonDown    ) {
769     
770     DrawClear();
771     DrawStrips(kTRUE,kTRUE);
772     DrawDigits(kTRUE,kTRUE);
773     fXOn = kTRUE;
774     fYOn = kTRUE;
775
776   }
777
778   // draw only x
779   if(fXStrips->GetState() == kButtonDown && 
780      fYStrips->GetState() == kButtonUp      ) {
781     
782     DrawClear();
783     DrawStrips(kTRUE,kFALSE);
784     DrawDigits(kTRUE,kFALSE);
785     fXOn = kTRUE;
786     fYOn = kFALSE;
787
788   }
789
790   // draw only y
791   if(fXStrips->GetState() == kButtonUp   && 
792      fYStrips->GetState() == kButtonDown    ) {
793     
794     DrawClear();
795     DrawStrips(kFALSE,kTRUE);
796     DrawDigits(kFALSE,kTRUE);
797     fXOn = kFALSE;
798     fYOn = kTRUE;
799
800   }
801
802   // clear
803   if(fXStrips->GetState() == kButtonUp   && 
804      fYStrips->GetState() == kButtonUp      ) {
805     
806     DrawClear();
807     fXOn = kFALSE;
808     fYOn = kFALSE;
809
810   }
811
812   HandleEditButton();
813
814 }
815
816 //__________________________________________________________________________
817 void AliMUONTriggerGUIbdmap::DrawClear()
818 {
819   /// draw the frame of the board image in the canvas
820   
821   for (Int_t i = 0; i < kNMT; i++) {
822
823     fCanvas[i]->cd();
824     fCanvas[i]->Clear();
825
826     fCanvas[i]->Modified();
827     fCanvas[i]->Update();
828
829   }
830
831 }
832
833 //__________________________________________________________________________
834 void AliMUONTriggerGUIbdmap::DrawDigits(Bool_t bx, Bool_t by)
835 {
836   /// draw the digits in "x" or/and "y"
837
838   Bool_t drawDigits = kTRUE;
839   Bool_t drawDigitsRaw = kTRUE;
840   if (fLoader == 0x0) {
841     drawDigits = kFALSE;
842   }
843   if (fRawDigitStore == 0x0) {
844     drawDigitsRaw = kFALSE;
845   }
846   
847   AliMUONTriggerGUIboard *board;
848   Int_t over, pos, number;
849   const AliMpVSegmentation* seg;
850   AliMpPad pad;
851   Int_t cathode, detElemId, ix, iy, charge;
852   Int_t chamber, np = 5;
853   AliMpDEIterator it;
854   Float_t xpmin, xpmax, ypmin, ypmax;
855   Float_t xg1, xg2, yg1, yg2, zg1;
856   Float_t xdw, ydw, xcw, ycw;
857   Double_t xc1, xc2, yc1, yc2;
858   Char_t cln[3];
859   TBox *boxd;
860   Double_t xMin, xMax, yMin, yMax;
861   Double_t *px, *py;
862     
863   number = fBoard->GetNumber();
864   pos    = fBoard->GetPosition();
865   over   = fBoard->GetYOver();
866   
867   if (drawDigits || drawDigitsRaw) {
868
869   for (Int_t i = 0; i < kNMT; i++) {
870     
871     fCanvas[i]->cd();
872     
873     fCanvas[i]->GetRange(xc1,yc1,xc2,yc2);
874     xcw = (Float_t)(0.5*(xc2-xc1));
875     ycw = (Float_t)(0.5*(yc2-yc1));
876
877     AliMUONVDigitStore *digitStore = 0x0;
878     AliMUONGeometryTransformer transformer;
879     transformer.LoadGeometryData("transform.dat");
880
881     if (drawDigits) {
882       AliRunLoader *runLoader = fLoader->GetRunLoader();
883       digitStore = fMCDataInterface->DigitStore(runLoader->GetEventNumber());
884     }
885     if (drawDigitsRaw) {
886       digitStore = static_cast<AliMUONVDigitStore*>(fRawDigitStore);
887     }
888
889     chamber = 11+i;
890     
891     MpPair_t deRange = AliMpDEManager::GetDetElemIdRange(chamber-1);
892     TIter next(digitStore->CreateIterator(AliMp::PairFirst(deRange),AliMp::PairSecond(deRange)));
893     AliMUONVDigit *mdig;
894     
895     while ( ( mdig = static_cast<AliMUONVDigit*>(next())) )
896       {
897         cathode = mdig->Cathode();
898         
899         ix = mdig->PadX();
900         iy = mdig->PadY();
901         detElemId = mdig->DetElemId(); 
902         charge = (Int_t)mdig->Charge();
903         
904         Bool_t triggerBgn = kFALSE;
905         Int_t schg = (Int_t)(charge + 0.5);
906         // APPLY CONDITION ON SOFT BACKGROUND   
907         Int_t tchg = schg - (Int_t(schg/10))*10;        
908         if (schg<=10 || tchg>0) {
909           triggerBgn = kFALSE;
910         } else {
911           triggerBgn = kTRUE;
912         }
913         
914         if (detElemId%100 != fBoard->GetDetElemId()) continue;
915         
916         seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(cathode));  
917         
918         pad = seg->PadByIndices(ix,iy,kTRUE);
919         
920         //if (cathode == 0) printf("GUI x:  ix %d iy %d \n",ix,iy);
921         //if (cathode == 1) printf("GUI y:  ix %d iy %d \n",ix,iy);
922         
923         // get the pad position and dimensions
924         Float_t xlocal1 = pad.GetPositionX();
925         Float_t ylocal1 = pad.GetPositionY();
926         Float_t xlocal2 = pad.GetDimensionX();
927         Float_t ylocal2 = pad.GetDimensionY();
928         
929         transformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
930         // (no transformation for pad dimensions)
931         xg2 = xlocal2;
932         yg2 = ylocal2;
933         
934         // transform in the monitor coordinate system
935         // ALICE SC
936         xpmin = +(xg1-xg2);
937         xpmax = +(xg1+xg2);
938         ypmin = -(yg2-yg1);
939         ypmax = +(yg2+yg1);
940         
941         xpmin -= fXCenter[i];
942         xpmax -= fXCenter[i];
943         ypmin -= fYCenter[i];
944         ypmax -= fYCenter[i];
945         
946         xdw = xpmax-xpmin;
947         ydw = ypmax-ypmin;
948         
949         // x-strips
950         if ((xdw > ydw) && bx) {
951           
952           //printf("X strips mdig->Cathode() = %1d \n",mdig->Cathode());
953           
954           Int_t iX, iY1, iY2;
955           iX  = fBoard->GetXSix();
956           iY1 = fBoard->GetXSiy1();
957           iY2 = fBoard->GetXSiy2();
958           if (ix == iX && iy >= iY1 && iy <= iY2) {
959             //printf("Digit indices (x-strip) ix = %3d iy = %3d board = %s %d chamber = %2d \n",ix,iy,fBoard->GetBoardName(),fBoard->GetNumber(),chamber); 
960             /*
961               xpmin += 0.01*fXWidth[i];
962               xpmax -= 0.01*fXWidth[i];
963               ypmin += 0.1*ydw;
964               ypmax -= 0.1*ydw;
965             */
966             boxd = new TBox(xpmin,ypmin,xpmax,ypmax);
967             boxd->SetFillStyle(1001);
968             if (triggerBgn) boxd->SetFillColor(6);
969             else boxd->SetFillColor(5);
970             boxd->SetBit(kCannotPick);
971             boxd->Draw();
972             
973             fXDigBox[i][iy-iY1]->SetFillStyle(1001);
974             fXDigBox[i][iy-iY1]->SetFillColor(2);
975             fXDigBox[i][iy-iY1]->SetX1(xpmin);
976             fXDigBox[i][iy-iY1]->SetY1(ypmin);
977             fXDigBox[i][iy-iY1]->SetX2(xpmax);
978             fXDigBox[i][iy-iY1]->SetY2(ypmax);
979             fXDigBox[i][iy-iY1]->Draw();
980             
981             snprintf(cln,3,"%2d",(iy-iY1));
982             fXLabelL[i][iy-iY1]->Clear();
983             fXLabelL[i][iy-iY1]->AddText(cln);
984             fXLabelL[i][iy-iY1]->Draw();
985             fXLabelR[i][iy-iY1]->Clear();
986             fXLabelR[i][iy-iY1]->AddText(cln);
987             fXLabelR[i][iy-iY1]->Draw();
988             
989             fBoard->SetDigitX(i,iy-iY1,charge);
990             
991           }
992           
993         }
994         
995         // y-strips
996         if ((xdw < ydw) && by) {
997           
998           //printf("Y strips mdig->Cathode() = %1d \n",mdig->Cathode());
999           
1000           Int_t iX1, iX2, iY;
1001           iX1 = fBoard->GetYSix1();
1002           iX2 = fBoard->GetYSix2();
1003           iY  = fBoard->GetYSiy();
1004           if (ix >= iX1 && ix <= iX2 && iy == iY) {
1005             //printf("Digit indices (y-strip) ix = %3d iy = %3d board = %s chamber = %2d \n",ix,iy,fBoard->GetBoardName(),chamber); 
1006             ypmin = -0.5*fYWidth[i];
1007             ypmax = +0.5*fYWidth[i];
1008             /*
1009               ypmin = -0.5*fYWidth[i];
1010               ypmax = +0.5*fYWidth[i];
1011               ypmin += 0.01*fYWidth[i];
1012               ypmax -= 0.01*fYWidth[i];   
1013               xpmin += 0.1*xdw;
1014               xpmax -= 0.1*xdw;
1015             */
1016             boxd = new TBox(xpmin,ypmin,xpmax,ypmax);
1017             boxd->SetFillStyle(1001);
1018             if (triggerBgn) boxd->SetFillColor(6);
1019             else boxd->SetFillColor(5);
1020             boxd->SetBit(kCannotPick);
1021             boxd->Draw();
1022             
1023             fYDigBox[i][ix-iX1]->SetFillStyle(1001);
1024             fYDigBox[i][ix-iX1]->SetFillColor(2);
1025             fYDigBox[i][ix-iX1]->SetX1(xpmin);
1026             fYDigBox[i][ix-iX1]->SetY1(ypmin);
1027             fYDigBox[i][ix-iX1]->SetX2(xpmax);
1028             fYDigBox[i][ix-iX1]->SetY2(ypmax);
1029             fYDigBox[i][ix-iX1]->Draw();
1030             
1031             snprintf(cln,3,"%2d",(ix-iX1));
1032             fYLabelL[i][ix-iX1]->Clear();
1033             fYLabelL[i][ix-iX1]->AddText(cln);
1034             fYLabelL[i][ix-iX1]->Draw();
1035             fYLabelR[i][ix-iX1]->Clear();
1036             fYLabelR[i][ix-iX1]->AddText(cln);
1037             fYLabelR[i][ix-iX1]->Draw();
1038             
1039             fBoard->SetDigitY(i,ix-iX1,charge);
1040             
1041             // extended y-strips
1042             for (Int_t io = 1; io <= over; io++) {
1043               if (io == pos) continue;
1044               board = (AliMUONTriggerGUIboard*)fBoards->UncheckedAt(number+io-pos);
1045               board->SetDigitY(i,ix-iX1,charge);
1046             }
1047             
1048           }
1049         }
1050         
1051       }  // end digits loop
1052
1053   }  // end chamber loop
1054
1055   }  // end drawDigits
1056
1057   // DSET digits
1058   for (Int_t i = 0; i < kNMT; i++) {
1059     
1060     fCanvas[i]->cd();
1061     
1062     fCanvas[i]->GetRange(xc1,yc1,xc2,yc2);
1063     xcw = (Float_t)(0.5*(xc2-xc1));
1064     ycw = (Float_t)(0.5*(yc2-yc1));
1065     
1066     // x-strips DSET
1067     if (bx) {
1068       
1069       for (ix = 0; ix < fNStripX; ix++) {
1070         //if (fBoard->GetXDig(i,ix) > 0) {
1071         if (fXDigBox[i][ix]->GetFillStyle() == 1001 || 
1072             fBoard->GetXDig(i,ix) > 0) {
1073           
1074           px = fXDigPL[i][ix]->GetX();
1075           py = fXDigPL[i][ix]->GetY();
1076           
1077           xMin = +9999.;
1078           xMax = -9999.;
1079           yMin = +9999.;
1080           yMax = -9999.;
1081           for (Int_t ip = 0; ip < np; ip++) {
1082             xMin = TMath::Min(xMin,px[ip]);
1083             xMax = TMath::Max(xMax,px[ip]);
1084             yMin = TMath::Min(yMin,py[ip]);
1085             yMax = TMath::Max(yMax,py[ip]);
1086           }
1087           
1088           if (fXDigBox[i][ix]->GetFillStyle() == 0) {
1089             fXDigBox[i][ix]->SetFillStyle(1001);
1090             fXDigBox[i][ix]->SetFillColor(2);
1091             fXDigBox[i][ix]->SetX1(xMin);
1092             fXDigBox[i][ix]->SetY1(yMin);
1093             fXDigBox[i][ix]->SetX2(xMax);
1094             fXDigBox[i][ix]->SetY2(yMax);
1095           }
1096           
1097           snprintf(cln,3,"%2d",ix);
1098           
1099           fXLabelL[i][ix]->Clear();
1100           fXLabelL[i][ix]->AddText(cln);
1101           fXLabelL[i][ix]->Draw();
1102           
1103           fXLabelR[i][ix]->Clear();
1104           fXLabelR[i][ix]->AddText(cln);
1105           fXLabelR[i][ix]->Draw();
1106           
1107           fXDigBox[i][ix]->Draw();
1108           
1109         }
1110         
1111       }
1112
1113     }
1114       
1115     // y-strips DSET
1116     if (by) {
1117       
1118       for (iy = 0; iy < fNStripY; iy++) {
1119         //if (fBoard->GetYDig(i,iy) > 0) {
1120         if (fYDigBox[i][iy]->GetFillStyle() == 1001 || 
1121             fBoard->GetYDig(i,iy) > 0) {
1122           
1123           px = fYDigPL[i][iy]->GetX();
1124           py = fYDigPL[i][iy]->GetY();
1125           
1126           xMin = +9999.;
1127           xMax = -9999.;
1128           yMin = +9999.;
1129           yMax = -9999.;
1130           for (Int_t ip = 0; ip < np; ip++) {
1131             xMin = TMath::Min(xMin,px[ip]);
1132             xMax = TMath::Max(xMax,px[ip]);
1133             yMin = TMath::Min(yMin,py[ip]);
1134             yMax = TMath::Max(yMax,py[ip]);
1135           }
1136           
1137           if (fYDigBox[i][iy]->GetFillStyle() == 0) {
1138             fYDigBox[i][iy]->SetFillStyle(1001);
1139             fYDigBox[i][iy]->SetFillColor(2);
1140             fYDigBox[i][iy]->SetX1(xMin);
1141             fYDigBox[i][iy]->SetY1(yMin);
1142             fYDigBox[i][iy]->SetX2(xMax);
1143             fYDigBox[i][iy]->SetY2(yMax);
1144           }
1145           
1146           snprintf(cln,3,"%2d",iy);
1147           
1148           fYLabelL[i][iy]->Clear();
1149           fYLabelL[i][iy]->AddText(cln);
1150           fYLabelL[i][iy]->Draw();
1151           
1152           fYLabelR[i][iy]->Clear();
1153           fYLabelR[i][iy]->AddText(cln);
1154           fYLabelR[i][iy]->Draw();
1155           
1156           fYDigBox[i][iy]->Draw();
1157           
1158         }
1159         
1160       }
1161
1162     }
1163       
1164     fCanvas[i]->Modified();
1165     fCanvas[i]->Update();
1166       
1167   }  // end canvas (chamber) loop
1168
1169   fMain->MapWindow();
1170
1171 }
1172
1173 //__________________________________________________________________________
1174 void AliMUONTriggerGUIbdmap::DrawStrips(Bool_t bx, Bool_t by)
1175 {
1176   /// draw the "x" or/and "y" strips
1177
1178   AliMUONGeometryTransformer transformer;
1179   transformer.LoadGeometryData("transform.dat");
1180
1181   const AliMpVSegmentation* seg;
1182   AliMpPad pad;
1183   AliMpDEIterator it;
1184   Int_t chamber;
1185   Float_t xg1, xg2, yg1, yg2, zg1;
1186   Float_t xlocal1, xlocal2, ylocal1, ylocal2;
1187   Int_t detElemId, maxX, maxY;
1188   Float_t xdw, ydw, xpmin, xpmax, ypmin, ypmax;
1189   Float_t ptx1, ptx2, pty1, pty2;
1190   Char_t cln[3];
1191   Double_t xc1, xc2, yc1, yc2;
1192   Float_t xcw, ycw;
1193
1194   Bool_t makeLabelsX = kFALSE;
1195   Bool_t makeLabelsY = kFALSE;
1196
1197   if (bx && !fLabelX) {
1198     makeLabelsX = kTRUE;
1199     fLabelX = kTRUE;
1200   }
1201
1202   if (by && !fLabelY) {
1203     makeLabelsY = kTRUE;
1204     fLabelY = kTRUE;
1205   }
1206
1207   for (Int_t i = 0; i < kNMT; i++) {
1208
1209     fCanvas[i]->cd();
1210     
1211     fCanvas[i]->GetRange(xc1,yc1,xc2,yc2);
1212     xcw = (Float_t)(0.5*(xc2-xc1));
1213     ycw = (Float_t)(0.5*(yc2-yc1));
1214
1215     chamber = 11+i;
1216
1217     for ( it.First(chamber-1); ! it.IsDone(); it.Next() ) {
1218     
1219       detElemId = it.CurrentDEId();
1220     
1221       if (detElemId%100 != fBoard->GetDetElemId()) continue;
1222
1223       /*---------- y-pads ic = 1 ----------*/
1224       
1225       seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::kCath1);  
1226
1227       maxX = seg->MaxPadIndexX();
1228       maxY = seg->MaxPadIndexY();
1229       
1230       for (Int_t ix = 0; ix <= maxX; ix++) {
1231         for (Int_t iy = 0; iy <= maxY; iy++) {
1232           
1233           pad = seg->PadByIndices(ix,iy,kFALSE);
1234           
1235           if (!pad.IsValid()) continue;
1236           
1237           // get the pad position and dimensions
1238           xlocal1 = pad.GetPositionX();
1239           ylocal1 = pad.GetPositionY();
1240           xlocal2 = pad.GetDimensionX();
1241           ylocal2 = pad.GetDimensionY();
1242           
1243           transformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
1244           // (no transformation for pad dimensions)
1245           xg2 = xlocal2;
1246           yg2 = ylocal2;
1247           
1248           // transform in the monitor coordinate system
1249           // ALICE SC
1250           xpmin = +(xg1-xg2);
1251           xpmax = +(xg1+xg2);
1252           ypmin = -(yg2-yg1);
1253           ypmax = +(yg2+yg1);
1254           
1255           xpmin -= fXCenter[i];
1256           xpmax -= fXCenter[i];
1257           ypmin -= fYCenter[i];
1258           ypmax -= fYCenter[i];
1259           
1260           xdw = xpmax-xpmin;
1261           ydw = ypmax-ypmin;
1262           
1263           // y-strips
1264           if (by) {
1265             
1266             Int_t iX1, iX2, iY, ixDig;
1267             iX1 = fBoard->GetYSix1();
1268             iX2 = fBoard->GetYSix2();
1269             iY  = fBoard->GetYSiy();
1270             if (ix >= iX1 && ix <= iX2 && iy == iY) {
1271               
1272               ypmin = -0.5*fYWidth[i];
1273               ypmax = +0.5*fYWidth[i];
1274               /*
1275               ypmin += 0.01*fYWidth[i];
1276               ypmax -= 0.01*fYWidth[i];
1277               xpmin += 0.1*xdw;
1278               xpmax -= 0.1*xdw;
1279               */
1280               ixDig = ix - iX1;
1281               fYDigPL[i][ixDig]->SetPoint(0,xpmin,ypmin);
1282               fYDigPL[i][ixDig]->SetPoint(1,xpmax,ypmin);
1283               fYDigPL[i][ixDig]->SetPoint(2,xpmax,ypmax);
1284               fYDigPL[i][ixDig]->SetPoint(3,xpmin,ypmax);
1285               fYDigPL[i][ixDig]->SetPoint(4,xpmin,ypmin);
1286               fYDigPL[i][ixDig]->Draw();
1287               /*
1288               fYDigBox[i][ixDig]->SetFillStyle(1001);
1289               fYDigBox[i][ixDig]->SetFillColor(5);
1290               fYDigBox[i][ixDig]->DrawBox(xpmin,ypmin,xpmax,ypmax);
1291               */
1292               if (makeLabelsY) {
1293                 snprintf(cln,3,"%2d",(ix-iX1));
1294                 ptx1 = xpmin;
1295                 ptx2 = xpmax;
1296                 
1297                 pty1 = 1.065*ypmin - 0.04*ycw;
1298                 pty2 = 1.065*ypmin + 0.04*ycw;
1299                 fYLabelL[i][ix-iX1] = new TPaveText(ptx1,pty1,ptx2,pty2);
1300                 fYLabelL[i][ix-iX1]->SetBorderSize(0);
1301                 fYLabelL[i][ix-iX1]->SetBit(kCannotPick);
1302                 
1303                 pty1 = 1.065*ypmax - 0.04*ycw;
1304                 pty2 = 1.065*ypmax + 0.04*ycw;
1305                 fYLabelR[i][ix-iX1] = new TPaveText(ptx1,pty1,ptx2,pty2);
1306                 fYLabelR[i][ix-iX1]->SetBorderSize(0);
1307                 fYLabelR[i][ix-iX1]->SetBit(kCannotPick);
1308               }
1309
1310             }
1311             
1312           }
1313           
1314         }  // end maxY
1315         
1316       }  // end maxX
1317       
1318       /*---------- x-pads ic = 0 ----------*/
1319       
1320       seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::kCath0); 
1321
1322       maxX = seg->MaxPadIndexX();
1323       maxY = seg->MaxPadIndexY();
1324       
1325       for (Int_t ix = 0; ix <= maxX; ix++) {
1326         for (Int_t iy = 0; iy <= maxY; iy++) {
1327           
1328           pad = seg->PadByIndices(ix,iy,kFALSE);
1329           
1330           if (!pad.IsValid()) continue;
1331           
1332           // get the pad position and dimensions
1333           xlocal1 = pad.GetPositionX();
1334           ylocal1 = pad.GetPositionY();
1335           xlocal2 = pad.GetDimensionX();
1336           ylocal2 = pad.GetDimensionY();
1337           
1338           transformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
1339           // (no transformation for pad dimensions)
1340           xg2 = xlocal2;
1341           yg2 = ylocal2;
1342           
1343           // transform in the monitor coordinate system
1344           // ALICE SC
1345           xpmin = +(xg1-xg2);
1346           xpmax = +(xg1+xg2);
1347           ypmin = -(yg2-yg1);
1348           ypmax = +(yg2+yg1);
1349           
1350           xpmin -= fXCenter[i];
1351           xpmax -= fXCenter[i];
1352           ypmin -= fYCenter[i];
1353           ypmax -= fYCenter[i];
1354           xdw = xpmax-xpmin;
1355           ydw = ypmax-ypmin;
1356           
1357           // x-strips
1358           if (bx) {
1359             
1360             Int_t iX, iY1, iY2, iyDig;
1361             iX  = fBoard->GetXSix();
1362             iY1 = fBoard->GetXSiy1();
1363             iY2 = fBoard->GetXSiy2();
1364             if (ix == iX && iy >= iY1 && iy <= iY2) {
1365               /*                  
1366               xpmin += 0.01*fXWidth[i];
1367               xpmax -= 0.01*fXWidth[i];
1368               ypmin += 0.1*ydw;
1369               ypmax -= 0.1*ydw;
1370               */
1371               iyDig = iy - iY1;
1372               fXDigPL[i][iyDig]->SetPoint(0,xpmin,ypmin);
1373               fXDigPL[i][iyDig]->SetPoint(1,xpmax,ypmin);
1374               fXDigPL[i][iyDig]->SetPoint(2,xpmax,ypmax);
1375               fXDigPL[i][iyDig]->SetPoint(3,xpmin,ypmax);
1376               fXDigPL[i][iyDig]->SetPoint(4,xpmin,ypmin);
1377               fXDigPL[i][iyDig]->Draw();
1378               /*              
1379               fXDigBox[i][iyDig]->SetFillStyle(1001);
1380               fXDigBox[i][iyDig]->SetFillColor(5);
1381               fXDigBox[i][iyDig]->DrawBox(xpmin,ypmin,xpmax,ypmax);
1382               */
1383               if (makeLabelsX) {
1384                 snprintf(cln,3,"%2d",(iy-iY1));
1385                 pty1 = ypmin;
1386                 pty2 = ypmax;
1387                 
1388                 ptx1 = 1.065*xpmin - 0.04*xcw;
1389                 ptx2 = 1.065*xpmin + 0.04*xcw;
1390                 fXLabelL[i][iy-iY1] = new TPaveText(ptx1,pty1,ptx2,pty2);
1391                 fXLabelL[i][iy-iY1]->SetBorderSize(0);
1392                 fXLabelL[i][iy-iY1]->SetBit(kCannotPick);
1393                 
1394                 ptx1 = 1.065*xpmax - 0.04*xcw;
1395                 ptx2 = 1.065*xpmax + 0.04*xcw;
1396                 fXLabelR[i][iy-iY1] = new TPaveText(ptx1,pty1,ptx2,pty2);
1397                 fXLabelR[i][iy-iY1]->SetBorderSize(0);
1398                 fXLabelR[i][iy-iY1]->SetBit(kCannotPick);
1399               }
1400
1401             }
1402             
1403           }
1404           
1405         }  // end maxY
1406         
1407       }  // end maxX
1408       
1409     }  // end DEIterator
1410     
1411     fCanvas[i]->Modified();
1412     fCanvas[i]->Update();
1413
1414   }
1415
1416   fMain->MapWindow();
1417
1418 }
1419
1420 //__________________________________________________________________________
1421 void AliMUONTriggerGUIbdmap::CloseWindow() const
1422 {
1423   /// close dialog in response to window manager close.
1424
1425   delete this;
1426
1427 }
1428
1429 //__________________________________________________________________________
1430 void AliMUONTriggerGUIbdmap::DoClose()
1431 {
1432   /// handle Close button.
1433
1434   fBoard->SetOpen(kFALSE);
1435   TTimer::SingleShot(150,"AliMUONTriggerGUIbdmap",this,"CloseWindow()");
1436
1437 }
1438
1439