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