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