MUON/AliMUONDisplay.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 /*
  17 $Log$
  18 Revision 1.6  2000/07/03 11:54:57  morsch
  19 AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
  20 The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
  21
  22 Revision 1.5  2000/06/28 15:16:35  morsch
  23 (1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
  24 to allow development of slat-muon chamber simulation and reconstruction code in the MUON
  25 framework. The changes should have no side effects (mostly dummy arguments).
  26 (2) Hit disintegration uses 3-dim hit coordinates to allow simulation
  27 of chambers with overlapping modules (MakePadHits, Disintegration).
  28
  29 Revision 1.4  2000/06/27 09:46:57  morsch
  30 kMAXZOOM global constant now in AliMUONConstants
  31
  32 Revision 1.3  2000/06/26 14:02:38  morsch
  33 Add class AliMUONConstants with MUON specific constants using static memeber data and access methods.
  34
  35 Revision 1.2  2000/06/15 07:58:48  morsch
  36 Code from MUON-dev joined
  37
  38 Revision 1.1.2.15  2000/06/14 14:37:53  morsch
  39 method Trigger() modified
  40
  41 Revision 1.1.2.14  2000/06/09 21:57:09  morsch
  42 Bug in color scale diplay corrected.
  43 Most coding rule violations corrected.
  44
  45 Revision 1.1.2.13  2000/05/02 11:57:27  morsch
  46 Coding rules RN3, RN13, RN17 violations corrected.
  47
  48 Revision 1.1.2.12  2000/04/26 12:27:33  morsch
  49 Mods for trigger display (P. Crochet):
  50 - color code versus time for pad hits in trigger chambers
  51 - call to TriggerDecision corrected
  52
  53 Revision 1.1.2.11  2000/04/26 09:04:46  morsch
  54 Obsolete cathode correlation related code removed.
  55
  56 Revision 1.1.2.10  2000/04/19 19:43:47  morsch
  57 change NCH to kNCH as in AliMUON.h
  58 no more TreeC related methods
  59
  60 Revision 1.1.2.9  2000/03/20 18:10:33  morsch
  61 Trigger method for "online" trigger decission added
  62
  63 Revision 1.1.2.8  2000/02/23 10:12:01  morsch
  64 Dont't try to draw reconstructed hit coordinates for Trigger Chambers.
  65 General clean-up of commented code.
  66
  67 Revision 1.1.2.7  2000/02/17 14:36:55  morsch
  68 Display of Trigger hits and clusters added.
  69 Displacement between clusters and hits has to be investigated and corrected ! (A.M.)
  70
  71 Revision 1.1.2.6  2000/02/15 10:19:42  morsch
  72 Previous log messages included
  73
  74 Revision 1.1.2.5  2000/02/15 10:09:09  morsch
  75 Log Message added
  76
  77 Revision 1.1.2.4  2000/02/08 09:17:16  gosset
  78 One more improvement of MUON display:
  79 same zoom for both cathode planes in a chamber
  80
  81 Revision 1.1.2.3  2000/02/07 15:37:21  gosset
  82 A few improvements of the MUON display:
  83 new buttons to change either chamber or cathode,
  84 added to the more complicated way
  85 (right mouse click and explicit filling of chamber and cathode)
  86
  87 Revision 1.1.2.2  2000/02/04 10:57:34  gosset
  88 Z position of the chambers:
  89 it was the Z position of the stations;
  90 it is now really the Z position of the chambers.
  91    !!!! WARNING: THE CALLS TO "AliMUONChamber::SetZPOS"
  92    !!!!                   AND "AliMUONChamber::ZPosition"
  93    !!!! HAVE TO BE CHANGED TO "AliMUONChamber::"SetZ"
  94    !!!!                   AND "AliMUONChamber::Z"
  95 */
  96
  97 //////////////////////////////////////////////////////////////////////////
  98 //                                                                      //
  99 // AliDisplay                                                           //
 100 //                                                                      //
 101 // Utility class to display ALICE outline, tracks, hits,..              //
 102 //                                                                      //
 103 //////////////////////////////////////////////////////////////////////////
 104
 105 #include <TROOT.h>
 106 #include <TTree.h>
 107 #include <TButton.h>
 108 #include <TColor.h>
 109 #include <TCanvas.h>
 110 #include <TView.h>
 111 #include <TText.h>
 112 #include <TPolyMarker3D.h>
 113 #include <TPaveLabel.h>
 114 #include <TPaveText.h>
 115 #include <TList.h>
 116 #include <TDiamond.h>
 117 #include <TNode.h>
 118 #include <TArc.h>
 119 #include <TTUBE.h>
 120 #include <TSlider.h>
 121 #include <TSliderBox.h>
 122 #include <TGaxis.h>
 123 #include <TVirtualX.h>
 124 #include <TMath.h>
 125 #include <TMatrix.h>
 126 #include <TGeometry.h>
 127 #include <X3DBuffer.h>
 128 #include <TMarker3DBox.h>
 129
 130 #include "AliRun.h"
 131 #include "AliDetector.h"
 132 #include "AliMUON.h"
 133 #include "AliMUONDisplay.h"
 134 #include "AliMUONPoints.h"
 135 #include "TParticle.h"
 136 #include "AliMUONTriggerDecision.h"
 137
 138 #include "AliMUONHit.h"
 139 #include "AliMUONPadHit.h"
 140 #include "AliMUONDigit.h"
 141 #include "AliMUONRawCluster.h"
 142
 143 #include "AliSegmentation.h"
 144 #include "AliMUONResponse.h"
 145 #include "AliMUONChamber.h"
 146 #include "AliMUONConstants.h"
 147 // to manage the same zoom on both cathodes
 148
 149
 150
 151 ClassImp(AliMUONDisplay)
 152
 153
 154 //_____________________________________________________________________________
 155 AliMUONDisplay::AliMUONDisplay()
 156 {
 157 // Constructor
 158     fPoints = 0;
 159     fPhits = 0;
 160     fRpoints = 0;
 161     fR2points = 0;
 162     fCpoints = 0;
 163     fCanvas = 0;
 164     fNextCathode = kFALSE;
 165 }
 166
 167 //_____________________________________________________________________________
 168 AliMUONDisplay::AliMUONDisplay(Int_t size)
 169 {
 170 // Create an event display object.
 171 // A canvas named "edisplay" is created with a vertical size in pixels
 172 //
 173 //    A QUICK Overview of the Event Display functions
 174 //    ===============================================
 175 //
 176 //  The event display can ve invoked by executing the macro "display.C"
 177 // A canvas like in the picture below will appear.
 178 //
 179 //  On the left side of the canvas, the following buttons appear:
 180 //   *Next*       to move to the next event
 181 //   *Previous*   to move to the previous event
 182
 183 //   *Pick*       Select this option to be able to point on a track with the
 184 //                mouse. Once on the track, use the right button to select
 185 //                an action. For example, select SetMarkerAttributes to
 186 //                change the marker type/color/size for the track.
 187 //   *Zoom*       Select this option (default) if you want to zoom.
 188 //                To zoom, simply select the selected area with the left button.
 189 //   *UnZoom*     To revert to the previous picture size.
 190 //
 191 //   slider R     On the left side, the vertical slider can be used to
 192 //                set the default picture size.
 193 //
 194 //    When you are in Zoom mode, you can click on the black part of the canvas
 195 //  to select special options with the right mouse button.
 196
 197 //
 198 //  When you are in pick mode, you can "Inspect" the object pointed by the mouse.
 199 //  When you are on a track, select the menu item "InspectParticle"
 200 //  to display the current particle attributes.
 201 //
 202 //  You can activate the Root browser by selecting the Inspect menu
 203 //  in the canvas tool bar menu. Then select "Start Browser"
 204 //  This will open a new canvas with the browser. At this point, you may want
 205 //  to display some histograms (from the Trees). Go to the "File" menu
 206 //  of the browser and click on "New canvas".
 207 //  In the browser, click on item "ROOT files" in the left pane.
 208 //  Click on galice.root.
 209 //  Click on TH
 210 //  Click on TPC for example
 211 //  Click on any variable (eg TPC.fX) to histogram the variable.
 212 //
 213 //   If you are lost, you can click on HELP in any Root canvas or browser.
 214 //Begin_Html
 215 /*
 216 <img src="gif/AliMUONDisplay.gif">
 217 */
 218 //End_Html
 219
 220
 221     fPad = 0;
 222
 223     gAlice->SetDisplay(this);
 224
 225    // Initialize display default parameters
 226     SetRange(200,2000);
 227    // Set front view by default
 228     fTheta =   0;
 229     fPhi   = -90;
 230     fPsi   =   0;
 231     fChamber = 1;
 232     fCathode = 1;
 233     //   fRzone   = 1.e10;
 234     fDrawClusters  = kTRUE;
 235     fDrawCoG       = kTRUE;
 236     fDrawCoG  = kTRUE;
 237     fZoomMode      = 1;
 238     fZooms         = 0;
 239     fClustersCuts  = 0;
 240     fPoints        = 0;
 241     fPhits         = 0;
 242     fRpoints       = 0;
 243     fR2points = 0;
 244     fCpoints = 0;
 245     // Create colors
 246     CreateColors();
 247     // Create display canvas
 248     Int_t ysize = size;
 249     if (ysize < 100) ysize = 750;
 250     Int_t xsize = Int_t(size*830./ysize);
 251     fCanvas = new TCanvas("Canvas", "MUON Clusters Display",14,47,xsize,ysize);
 252     fCanvas->ToggleEventStatus();
 253
 254    // Create main display pad
 255     fPad = new TPad("viewpad", "MUON display",0.15,0,0.9,1);
 256     fPad->Draw();
 257     fPad->Modified();
 258     fPad->SetFillColor(30);
 259     fPad->SetBorderSize(2);
 260
 261     fCanvas->cd();
 262
 263    // Create colors pad
 264     fColPad = new TPad("colpad", "Colors pad",0.9,0,1,1);
 265     fColPad->Draw();
 266     fColPad->SetFillColor(17);
 267     fColPad->SetBorderSize(2);
 268     fColPad->cd();
 269     DisplayColorScale();
 270
 271     fCanvas->cd();
 272    // Create user interface control pad
 273     DisplayButtons();
 274     fCanvas->cd();
 275
 276    // Create Range and mode pad
 277     Float_t dxtr     = 0.15;
 278     Float_t dytr     = 0.45;
 279     fTrigPad = new TPad("trigger", "range and mode pad",0,0,dxtr,dytr);
 280     fTrigPad->SetEditable(kFALSE);
 281     fTrigPad->Draw();
 282     fTrigPad->cd();
 283     fTrigPad->SetFillColor(22);
 284     fTrigPad->SetBorderSize(2);
 285     fRangeSlider = new TSlider("range","range",0.7,0.42,0.9,0.98);
 286     fRangeSlider->SetObject(this);
 287     char pickmode[] = "gAlice->Display()->SetPickMode()";
 288     Float_t db = 0.09;
 289     fPickButton = new TButton("Pick",pickmode,0.05,0.32,0.65,0.32+db);
 290     fPickButton->SetFillColor(38);
 291     fPickButton->Draw();
 292     char zoommode[] = "gAlice->Display()->SetZoomMode()";
 293     fZoomButton = new TButton("Zoom",zoommode,0.05,0.21,0.65,0.21+db);
 294     fZoomButton->SetFillColor(38);
 295     fZoomButton->Draw();
 296     fArcButton = new TArc(.8,fZoomButton->GetYlowNDC()+0.5*db,0.33*db);
 297     fArcButton->SetFillColor(kGreen);
 298     fArcButton->Draw();
 299     char butUnzoom[] = "gAlice->Display()->UnZoom()";
 300     TButton *button = new TButton("UnZoom",butUnzoom,0.05,0.05,0.95,0.15);
 301     button->SetFillColor(38);
 302     button->Draw();
 303     AppendPad(); // append display object as last object to force selection
 304
 305     fCanvas->cd();
 306     fCanvas->Update();
 307     fNextCathode = kFALSE;
 308 }
 309
 310 AliMUONDisplay::AliMUONDisplay(const AliMUONDisplay & display)
 311 {
 312 // Dummy copy constructor
 313     ;
 314 }
 315
 316
 317
 318 //_____________________________________________________________________________
 319 AliMUONDisplay::~AliMUONDisplay()
 320 {
 321   // Delete space point structure
 322     if (fPoints) fPoints->Delete();
 323     delete fPoints;
 324     fPoints     = 0;
 325     //
 326     if (fPhits) fPhits->Delete();
 327     delete fPhits;
 328     fPhits     = 0;
 329     //
 330     if (fRpoints) fRpoints->Delete();
 331     delete fRpoints;
 332     fRpoints     = 0;
 333 //
 334     if (fR2points) fR2points->Delete();
 335     delete fR2points;
 336     fR2points     = 0;
 337 //
 338     if (fCpoints) fCpoints->Delete();
 339     delete fCpoints;
 340     fCpoints     = 0;
 341 }
 342
 343 //_____________________________________________________________________________
 344 void AliMUONDisplay::Clear(Option_t *)
 345 {
 346 //    Delete graphics temporary objects
 347 }
 348
 349 //_____________________________________________________________________________
 350 void AliMUONDisplay::DisplayButtons()
 351 {
 352 //    Create the user interface buttons
 353
 354
 355     fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
 356     fButtons->SetEditable(kFALSE);
 357     fButtons->Draw();
 358     fButtons->SetFillColor(38);
 359     fButtons->SetBorderSize(2);
 360     fButtons->cd();
 361
 362 //   Int_t butcolor = 33;
 363     Float_t dbutton = 0.08;
 364     Float_t y  = 0.96;
 365     Float_t dy = 0.014;
 366     Float_t x0 = 0.05;
 367     Float_t x1 = 0.95;
 368
 369     TButton *button;
 370     char but1[] = "gAlice->Display()->ShowNextEvent(1)";
 371     button = new TButton("Event +", but1, x0, y - dbutton, x1, y);
 372     button->SetFillColor(38);
 373     button->Draw();
 374
 375     y -= dbutton + dy;
 376     char but2[] = "gAlice->Display()->ShowNextEvent(-1)";
 377     button = new TButton("Event -", but2, x0, y - dbutton, x1, y);
 378     button->SetFillColor(38);
 379     button->Draw();
 380
 381     y -= dbutton + dy;
 382     char but3[] = "((AliMUONDisplay*)(gAlice->Display()))->NextChamber(1)";
 383     button = new TButton("Chamber +", but3, x0, y - dbutton, x1, y);
 384     button->SetFillColor(38);
 385     button->Draw();
 386
 387     y -= dbutton + dy;
 388     char but4[] = "((AliMUONDisplay*)(gAlice->Display()))->NextChamber(-1)";
 389     button = new TButton("Chamber -", but4, x0, y - dbutton, x1, y);
 390     button->SetFillColor(38);
 391     button->Draw();
 392
 393     y -= dbutton + dy;
 394     char but5[] = "((AliMUONDisplay*)(gAlice->Display()))->SetChamberAndCathode(1,1)";
 395     button = new TButton("Chamber 1", but5, x0, y - dbutton, x1, y);
 396     button->SetFillColor(38);
 397     button->Draw();
 398
 399     y -= dbutton + dy;
 400     char but6[] = "((AliMUONDisplay*)(gAlice->Display()))->NextCathode()";
 401     button = new TButton("Cathode <>", but6, x0, y - dbutton, x1, y);
 402     button->SetFillColor(38);
 403     button->Draw();
 404
 405     y -= dbutton + dy;
 406     char but7[] = "((AliMUONDisplay*)(gAlice->Display()))->Trigger()";
 407     button = new TButton("Trigger", but7, x0, y - dbutton, x1, y);
 408     button->SetFillColor(38);
 409     button->Draw();
 410
 411    // display logo
 412     TDiamond *diamond = new TDiamond(0.05,0.015,0.95,0.22);
 413     diamond->SetFillColor(50);
 414     diamond->SetTextAlign(22);
 415     diamond->SetTextColor(5);
 416     diamond->SetTextSize(0.11);
 417     diamond->Draw();
 418     diamond->AddText(".. ");
 419     diamond->AddText("ROOT");
 420     diamond->AddText("MUON");
 421     diamond->AddText("... ");
 422     diamond->AddText(" ");
 423 }
 424
 425 //_____________________________________________________________________________
 426 void AliMUONDisplay::CreateColors()
 427 {
 428 //    Create the colors palette used to display clusters
 429
 430     Int_t k,i;
 431     Int_t color;
 432     Float_t r,g,b;
 433
 434     for (k=1;k<=5;k++) {
 435         switch(k) {
 436         case 1:
 437             for (i=1;i<=5;i++) {
 438                 r=1.;
 439                 g=i*0.2;
 440                 b=0.;
 441                 color=i;
 442                 color=260+23-color;
 443                 new TColor(color,r,g,b);
 444             }
 445             break;
 446         case 2:
 447             for (i=1;i<=4;i++) {
 448                 r=1.1-i*0.2;
 449                 g=1.;
 450                 b=0.;
 451                 color=i+5;
 452                 color=260+23-color;
 453                 new TColor(color,r,g,b);
 454             }
 455             break;
 456         case 3:
 457             for (i=1;i<=4;i++) {
 458                 r=0.;
 459                 g=1.;
 460                 b=i*0.2+0.2;
 461                 color=i+9;
 462                 color=260+23-color;
 463                 new TColor(color,r,g,b);
 464             }
 465             break;
 466         case 4:
 467             for (i=1;i<=4;i++) {
 468                 r=0.;
 469                 g=1.1-i*0.2;
 470                 b=1.;
 471                 color=i+13;
 472                 color=260+23-color;
 473                 new TColor(color,r,g,b);
 474             }
 475             break;
 476         case 5:
 477             for (i=1;i<=5;i++) {
 478                 r=i*0.2;
 479                 g=0.;
 480                 b=1.;
 481                 color=i+17;
 482                 color=260+23-color;
 483                 new TColor(color,r,g,b);
 484             }
 485             break;
 486         }
 487     }
 488 }
 489
 490 //_____________________________________________________________________________
 491 void AliMUONDisplay::DisplayColorScale()
 492 {
 493 // Display pulse height color scale
 494     Int_t i;
 495     Int_t color;
 496     Float_t xlow, ylow, xup, yup, hs;
 497     Float_t x1, y1, x2, y2;
 498     x1 = y1 = 0;
 499     x2 = y2 = 1.0;
 500
 501     TText *text = new TText(0,0,"");
 502     text->SetTextFont(61);
 503     text->SetTextSize(0.2);
 504     text->SetTextAlign(22);
 505
 506     AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
 507     AliMUONChamber *iChamber = &(pMUON->Chamber(fChamber-1));
 508     AliMUONResponse * response=iChamber->ResponseModel();
 509     Int_t adcmax=1024;
 510     if (response) adcmax= (Int_t) response->MaxAdc();
 511
 512
 513     TBox *box;
 514     char label[8];
 515 //*-* draw colortable boxes
 516     hs = (y2-y1)/Float_t(22);
 517     xlow=x1+.05;
 518     xup=x2-0.5;
 519     for (i=0;i<22;i++) {
 520         ylow = y1 + hs*(Float_t(i));
 521         yup  = y1 + hs*(Float_t(i+1));
 522         color = 261+i;
 523         Double_t logscale=Double_t(i+1)*(TMath::Log(adcmax)/22);
 524         Int_t scale=(Int_t)TMath::Exp(logscale);
 525         sprintf(label,"%d",scale);
 526         box = new TBox(xlow, ylow, xup, yup);
 527         box->Draw();
 528         box->SetFillColor(color);
 529         text->DrawText(xlow+0.7, 0.5*(ylow+yup),label);
 530     }
 531 }
 532
 533 //______________________________________________________________________________
 534 Int_t AliMUONDisplay::DistancetoPrimitive(Int_t px, Int_t)
 535 {
 536 // Compute distance from point px,py to objects in event
 537
 538     gPad->SetCursor(kCross);
 539
 540     if (gPad == fTrigPad) return 9999;
 541
 542     const Int_t kBig = 9999;
 543     Int_t dist   = kBig;
 544     Float_t xmin = gPad->GetX1();
 545     Float_t xmax = gPad->GetX2();
 546     Float_t dx   = 0.02*(xmax - xmin);
 547     Float_t x    = gPad->AbsPixeltoX(px);
 548     if (x < xmin+dx || x > xmax-dx) return dist;
 549
 550     if (fZoomMode) return 0;
 551     else           return 7;
 552 }
 553
 554 //_____________________________________________________________________________
 555 void AliMUONDisplay::Draw(Option_t *)
 556 {
 557 //    Display current event
 558
 559     fPad->cd();
 560
 561     DrawView(fTheta, fPhi, fPsi);
 562     // Display the event number and title
 563     fPad->cd();
 564     DrawTitle();
 565 }
 566
 567 void AliMUONDisplay::DrawSegmentation()
 568 {
 569 // Draw graphical representation of segmenatation
 570 // Attention: still experimental code
 571     Int_t icat=1;
 572
 573     AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
 574     AliMUONChamber*   iChamber;
 575     AliSegmentation*  seg;
 576     iChamber = &(pMUON->Chamber(fChamber));
 577     seg=iChamber->SegmentationModel(icat);
 578     Float_t zpos=iChamber->Z();
 579     Float_t r=iChamber->ROuter();
 580
 581     TMarker3DBox *marker;
 582     if (icat == 1) {
 583         for (Int_t j=0; j<seg->Npy(); j++) {
 584             Float_t y0;
 585             y0=j*seg->Dpy()-seg->Dpy()/2.;
 586             for (seg->FirstPad(0.,y0,0,300,0.);
 587                  seg->MorePads();
 588                  seg->NextPad())
 589             {
 590                 if (seg->ISector()==0) continue;
 591                 Float_t x,y,z;
 592                 seg->GetPadC(seg->Ix(), seg->Iy(), x, y, z);
 593                 Float_t dpx=seg->Dpx(seg->ISector())/2;
 594                 Float_t dpy=seg->Dpy(seg->ISector())/2;
 595                 marker=new TMarker3DBox(x,y,zpos,dpx,dpy,0,0,0);
 596                 marker->SetLineColor(seg->ISector()+1);
 597                 marker->SetFillStyle(1001);
 598                 marker->SetFillColor(0);
 599                 marker->Draw();
 600             }
 601         }
 602     } else {
 603         for (Int_t j=0; j<250; j++) {
 604             Float_t x0=j*seg->Dpx();
 605             Float_t y0=TMath::Sqrt(r*r-x0*x0);
 606
 607             for (seg->FirstPad(x0,0,0,0,y0);
 608                  seg->MorePads();
 609                  seg->NextPad())
 610             {
 611                 if (seg->ISector()==0) continue;
 612
 613                 Float_t x,y,z;
 614                 seg->GetPadC(seg->Ix(), seg->Iy(), x, y, z);
 615                 Float_t dpx=seg->Dpx(seg->ISector())/2;
 616                 Float_t dpy=seg->Dpy(seg->ISector())/2;
 617                 marker=new TMarker3DBox(x,y,zpos,dpx,dpy,0,0,0);
 618                 marker->SetLineColor(seg->ISector()+1);
 619                 marker->SetFillStyle(1001);
 620                 marker->SetFillColor(0);
 621                 marker->Draw();
 622             }
 623         }
 624     }
 625 }
 626
 627 //_____________________________________________________________________________
 628 void AliMUONDisplay::DrawClusters()
 629 {
 630 //    Draw clusters for MUON chambers
 631
 632     Int_t ndigits, digit;
 633     TObjArray *points;
 634     AliMUONPoints *pm;
 635
 636
 637     fClustersCuts = 0;
 638     points = Points();
 639     if (!points) return;
 640     ndigits = points->GetEntriesFast();
 641     for (digit=0;digit<ndigits;digit++){
 642         pm = (AliMUONPoints*)points->UncheckedAt(digit);
 643         if (!pm) continue;
 644         Float_t *pxyz;
 645         pxyz=pm->GetP();
 646         for (Int_t im=0;im<3;im++) {
 647             TMarker3DBox *marker=pm->GetMarker(im);
 648             if (marker)
 649                 marker->Draw();
 650         }
 651         pm->Draw();
 652         fClustersCuts +=pm->GetN();
 653     }
 654 }
 655
 656 //_____________________________________________________________________________
 657 void AliMUONDisplay::DrawHits()
 658 {
 659 //    Draw hits for MUON chambers
 660
 661     LoadHits(fChamber);
 662
 663     Int_t ntracks, track;
 664     TObjArray *points;
 665     AliMUONPoints *pm;
 666
 667     fHitsCuts = 0;
 668     points = Phits();
 669     if (!points) return;
 670     ntracks = points->GetEntriesFast();
 671     for (track=0;track<ntracks;track++) {
 672         pm = (AliMUONPoints*)points->UncheckedAt(track);
 673         if (!pm) continue;
 674         pm->Draw();
 675         fHitsCuts += pm->GetN();
 676     }
 677 }
 678
 679
 680 //_____________________________________________________________________________
 681 void AliMUONDisplay::DrawCoG()
 682 {
 683 //    Draw hits for MUON chambers
 684     if (!fDrawCoG) return;
 685     if (fChamber > 10) return;
 686     LoadCoG(fChamber,fCathode);
 687
 688     Int_t ncog, icog;
 689     TObjArray *points;
 690     AliMUONPoints *pm;
 691
 692     points = Rpoints();
 693     if (!points) return;
 694     ncog = points->GetEntriesFast();
 695     for (icog=0;icog<ncog;icog++) {
 696         pm = (AliMUONPoints*)points->UncheckedAt(icog);
 697         if (!pm) continue;
 698         pm->Draw();
 699     }
 700 }
 701 void AliMUONDisplay::DrawCoG2()
 702 {
 703 //    Draw hits for MUON chambers
 704
 705     if (!fDrawCoG) return;
 706     if (fChamber > 10) return;
 707
 708     if (fCathode==1) {
 709         LoadCoG2(fChamber,2);
 710     } else if (fCathode==2) {
 711         LoadCoG2(fChamber,1);
 712     }
 713
 714     Int_t ncog, icog;
 715     TObjArray *points;
 716     AliMUONPoints *pm;
 717
 718     points = R2points();
 719     if (!points) return;
 720     ncog = points->GetEntriesFast();
 721     for (icog=0;icog<ncog;icog++) {
 722         pm = (AliMUONPoints*)points->UncheckedAt(icog);
 723         if (!pm) continue;
 724         pm->Draw();
 725     }
 726 }
 727 //_____________________________________________________________________________
 728
 729 void AliMUONDisplay::DrawTitle(Option_t *option)
 730 {
 731 //    Draw the event title
 732
 733     Float_t xmin = gPad->GetX1();
 734     Float_t xmax = gPad->GetX2();
 735     Float_t ymin = gPad->GetY1();
 736     Float_t ymax = gPad->GetY2();
 737     Float_t dx   = xmax-xmin;
 738     Float_t dy   = ymax-ymin;
 739
 740     if (strlen(option) == 0) {
 741         TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
 742 //      title->SetTextSize(0.023932);
 743         title->SetTextSize(0.02);
 744         title->SetBit(kCanDelete);
 745         title->SetFillColor(42);
 746         title->Draw();
 747         char ptitle[100];
 748         sprintf(ptitle, "Alice event:%d Run:%d Chamber:%d Cathode:%d",
 749                 gAlice->GetHeader()->GetEvent(),
 750                 gAlice->GetHeader()->GetRun(),
 751                 fChamber,
 752                 fCathode);
 753         title->AddText(ptitle);
 754         Int_t nparticles = gAlice->Particles()->GetEntriesFast();
 755         sprintf(ptitle,"Nparticles = %d Nhits = %d Npads fired = %d",
 756                 nparticles, fHitsCuts,fClustersCuts);
 757         title->AddText(ptitle);
 758     } else {
 759         TPaveLabel *label = new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
 760         label->SetBit(kCanDelete);
 761         label->SetFillColor(42);
 762         label->Draw();
 763     }
 764 }
 765
 766 //_____________________________________________________________________________
 767 void AliMUONDisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
 768 {
 769 //    Draw a view of MUON clusters
 770     printf("\n Draw View");
 771
 772     gPad->SetCursor(kWatch);
 773     // gPad->SetFillColor(39);
 774     gPad->SetFillColor(1);
 775     gPad->Clear();
 776     // gPad->SetFillColor(39);
 777     gPad->SetFillColor(1);
 778
 779
 780     Int_t iret=0;
 781     TView *view = new TView(1);
 782
 783     Float_t range = fRrange*fRangeSlider->GetMaximum();
 784     view->SetRange(-range,-range,-range,range, range, range);
 785     // zoom back to full scale only if DrawView not called from NextCathode
 786     if (!fNextCathode) {
 787         fZoomX0[0] = -1;
 788         fZoomY0[0] = -1;
 789         fZoomX1[0] =  1;
 790         fZoomY1[0] =  1;
 791         fZooms = 0;
 792     }
 793
 794 // Display MUON Chamber Geometry
 795 // gAlice->GetGeometry()->Draw("same");
 796     char nodeName[7];
 797     sprintf(nodeName,"MUON%d",100+fChamber);
 798     printf("\n Node name %s", nodeName);
 799
 800     TNode *node1=gAlice->GetGeometry()->GetNode(nodeName);
 801     if (node1) node1->Draw("same");
 802 //add clusters to the pad
 803     DrawClusters();
 804     printf("Node name %s", nodeName);
 805     DrawHits();
 806     DrawCoG();
 807     DrawCoG2();
 808 //     DrawSegmentation();
 809     // add itself to the list (must be last)
 810     AppendPad();
 811     view->SetView(phi, theta, psi, iret);
 812 }
 813
 814
 815 //______________________________________________________________________________
 816 void AliMUONDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
 817 {
 818 //  Execute action corresponding to the mouse event
 819
 820     static Float_t x0, y0, x1, y1;
 821
 822     static Int_t pxold, pyold;
 823     static Int_t px0, py0;
 824     static Int_t linedrawn;
 825     Float_t temp;
 826
 827     if (px == 0 && py == 0) { //when called by sliders
 828         if (event == kButton1Up) {
 829             Draw();
 830         }
 831         return;
 832     }
 833     if (!fZoomMode && gPad->GetView()) {
 834         gPad->GetView()->ExecuteRotateView(event, px, py);
 835         return;
 836     }
 837
 838     // something to zoom ?
 839     gPad->SetCursor(kCross);
 840
 841     switch (event) {
 842
 843     case kButton1Down:
 844         gVirtualX->SetLineColor(-1);
 845         gPad->TAttLine::Modify();  //Change line attributes only if necessary
 846         x0 = gPad->AbsPixeltoX(px);
 847         y0 = gPad->AbsPixeltoY(py);
 848         px0   = px; py0   = py;
 849         pxold = px; pyold = py;
 850         linedrawn = 0;
 851         return;
 852
 853     case kButton1Motion:
 854         if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
 855         pxold = px;
 856         pyold = py;
 857         linedrawn = 1;
 858         gVirtualX->DrawBox(px0, py0, pxold, pyold,  TVirtualX::kHollow);
 859         return;
 860
 861     case kButton1Up:
 862         gPad->GetCanvas()->FeedbackMode(kFALSE);
 863         if (px == px0) return;
 864         if (py == py0) return;
 865         x1 = gPad->AbsPixeltoX(px);
 866         y1 = gPad->AbsPixeltoY(py);
 867
 868         if (x1 < x0) {temp = x0; x0 = x1; x1 = temp;}
 869         if (y1 < y0) {temp = y0; y0 = y1; y1 = temp;}
 870         gPad->Range(x0,y0,x1,y1);
 871         if (fZooms < AliMUONConstants::MaxZoom()-1) {
 872             fZooms++;
 873             fZoomX0[fZooms] = x0;
 874             fZoomY0[fZooms] = y0;
 875             fZoomX1[fZooms] = x1;
 876             fZoomY1[fZooms] = y1;
 877         }
 878         gPad->Modified(kTRUE);
 879         return;
 880     }
 881 }
 882
 883 //___________________________________________
 884 void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
 885 {
 886 // Read digits info and store x,y,z info in arrays fPoints
 887 // Loop on all detectors
 888
 889     if (chamber > 14) return;
 890     printf(" chamber %d \n",chamber);
 891     fChamber=chamber;
 892     fCathode=cathode;
 893
 894     ResetPoints();
 895
 896     AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
 897     AliMUONChamber*       iChamber;
 898     AliSegmentation*      segmentation;
 899     AliMUONResponse*      response;
 900
 901     TClonesArray *muonDigits  = pMUON->DigitsAddress(chamber-1);
 902     if (muonDigits == 0) return;
 903
 904     gAlice->ResetDigits();
 905
 906     Int_t nent=(Int_t)gAlice->TreeD()->GetEntries();
 907     gAlice->TreeD()->GetEvent(nent-2+cathode-1);
 908     Int_t ndigits = muonDigits->GetEntriesFast();
 909     if (ndigits == 0) return;
 910     if (fPoints == 0) fPoints = new TObjArray(ndigits);
 911
 912     iChamber = &(pMUON->Chamber(chamber-1));
 913
 914     segmentation = iChamber->SegmentationModel(cathode);
 915     response     = iChamber->ResponseModel();
 916     Float_t zpos=iChamber->Z();
 917     AliMUONDigit  *mdig;
 918     AliMUONPoints *points = 0;
 919     TMarker3DBox *marker=0;
 920     //
 921     //loop over all digits and store their position
 922
 923     Int_t npoints=1;
 924     Float_t adcmax=1024;
 925     if (response) adcmax= response->MaxAdc();
 926
 927     for (Int_t digit=0;digit<ndigits;digit++) {
 928         mdig    = (AliMUONDigit*)muonDigits->UncheckedAt(digit);
 929         //
 930         // First get all needed parameters
 931         //
 932         Int_t charge=mdig->fSignal;
 933         Int_t index=Int_t(TMath::Log(charge)/(TMath::Log(adcmax)/22));
 934         Int_t color=261+index;
 935         Int_t colorTrigger=2;
 936         if (color>282) color=282;
 937
 938         if (chamber > 10) { // trigger chamber
 939             Int_t sumCharge=0;
 940             for (Int_t icharge=0; icharge<10; icharge++) {
 941                 sumCharge=sumCharge+mdig->fTcharges[icharge];
 942             }
 943             Int_t testCharge=sumCharge-(Int_t(sumCharge/10))*10;
 944             if(sumCharge<=10||testCharge>0) {
 945                 colorTrigger=color;
 946             } else {
 947                 colorTrigger=5;
 948             }
 949         }
 950
 951         // get the center of the pad - add on x and y half of pad size
 952         Float_t xpad, ypad, zpad;
 953         segmentation->GetPadC(mdig->fPadX, mdig->fPadY,xpad, ypad, zpad);
 954
 955         Int_t isec=segmentation->Sector(mdig->fPadX, mdig->fPadY);
 956         Float_t dpx=segmentation->Dpx(isec)/2;
 957         Float_t dpy=segmentation->Dpy(isec)/2;
 958         Int_t nPara, offset;
 959         segmentation->GetNParallelAndOffset(mdig->fPadX,mdig->fPadY,
 960                 &nPara,&offset);
 961         //
 962         // Then set the objects
 963         //
 964         points = new AliMUONPoints(npoints);
 965         fPoints->AddAt(points,digit);
 966         if (chamber > 10) {
 967             points->SetMarkerColor(colorTrigger);
 968         } else {
 969             points->SetMarkerColor(color);
 970         }
 971         points->SetMarkerStyle(21);
 972         points->SetMarkerSize(0.5);
 973         points->SetParticle(-1);
 974         points->SetHitIndex(-1);
 975         points->SetTrackIndex(-1);
 976         points->SetDigitIndex(digit);
 977         points->SetPoint(0,xpad,ypad,zpos);
 978         for (Int_t imark=0;imark<nPara; imark++)
 979         {
 980             segmentation->GetPadC(mdig->fPadX + imark*offset, mdig->fPadY,xpad, ypad, zpad);
 981             marker=new TMarker3DBox(xpad,ypad,zpos,dpx,dpy,0,0,0);
 982             marker->SetLineColor(2);
 983             marker->SetFillStyle(1001);
 984             marker->SetFillColor(color);
 985             marker->SetRefObject((TObject*)points);
 986             points->Set3DMarker(imark, marker);
 987         }
 988     }
 989 }
 990 //___________________________________________
 991 void AliMUONDisplay::LoadCoG(Int_t chamber, Int_t cathode)
 992 {
 993 // Read raw clusters info and store x,y,z info in arrays fRpoints
 994 // Loop on all detectors
 995
 996     if (chamber > 10) return;
 997
 998     ResetRpoints();
 999
1000     AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
1001     AliMUONChamber*  iChamber;
1002
1003     TClonesArray *muonRawClusters  = pMUON->RawClustAddress(chamber-1);
1004     if (muonRawClusters == 0) return;
1005
1006     pMUON->ResetRawClusters();
1007
1008
1009     Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
1010     gAlice->TreeR()->GetEvent(nent-2+cathode-1);
1011     Int_t nrawcl = muonRawClusters->GetEntriesFast();
1012     if (nrawcl == 0) return;
1013     if (fRpoints == 0) fRpoints = new TObjArray(nrawcl);
1014
1015     iChamber = &(pMUON->Chamber(chamber-1));
1016     Float_t zpos=iChamber->Z();
1017     AliMUONRawCluster  *mRaw;
1018     AliMUONPoints *points = 0;
1019     //
1020     //loop over all raw clusters and store their position
1021     points = new AliMUONPoints(nrawcl);
1022     for (Int_t iraw=0;iraw<nrawcl;iraw++) {
1023         mRaw   = (AliMUONRawCluster*)muonRawClusters->UncheckedAt(iraw);
1024         fRpoints->AddAt(points,iraw);
1025         points->SetMarkerColor(51);
1026         points->SetMarkerStyle(2);
1027         points->SetMarkerSize(1.);
1028         points->SetParticle(-1);
1029         points->SetHitIndex(-1);
1030         points->SetTrackIndex(-1);
1031         points->SetDigitIndex(-1);
1032         points->SetPoint(iraw,mRaw->fX[0],mRaw->fY[0],zpos);
1033     }
1034 }
1035 //___________________________________________
1036 void AliMUONDisplay::LoadCoG2(Int_t chamber, Int_t cathode)
1037 {
1038 // Read raw clusters info and store x,y,z info in arrays fRpoints
1039 // Loop on all detectors
1040
1041     if (chamber > 10) return;
1042
1043     ResetR2points();
1044
1045     AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
1046     AliMUONChamber*  iChamber;
1047
1048     TClonesArray *muonRawClusters  = pMUON->RawClustAddress(chamber-1);
1049     if (muonRawClusters == 0) return;
1050
1051     pMUON->ResetRawClusters();
1052
1053     Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
1054     gAlice->TreeR()->GetEvent(nent-2+cathode-1);
1055     Int_t nrawcl = muonRawClusters->GetEntriesFast();
1056     if (nrawcl == 0) return;
1057     if (fR2points == 0) fR2points = new TObjArray(nrawcl);
1058
1059     iChamber = &(pMUON->Chamber(chamber-1));
1060     Float_t zpos=iChamber->Z();
1061     AliMUONRawCluster  *mRaw;
1062     AliMUONPoints *points = 0;
1063     //
1064     //loop over all raw clusters and store their position
1065     points = new AliMUONPoints(nrawcl);
1066     for (Int_t iraw=0;iraw<nrawcl;iraw++) {
1067         mRaw   = (AliMUONRawCluster*)muonRawClusters->UncheckedAt(iraw);
1068         fR2points->AddAt(points,iraw);
1069         points->SetMarkerColor(51);
1070         points->SetMarkerStyle(4);
1071         points->SetMarkerSize(1.3);
1072         points->SetParticle(-1);
1073         points->SetHitIndex(-1);
1074         points->SetTrackIndex(-1);
1075         points->SetDigitIndex(-1);
1076         points->SetPoint(iraw,mRaw->fX[0],mRaw->fY[0],zpos);
1077    }
1078 }
1079 //___________________________________________
1080 void AliMUONDisplay::LoadHits(Int_t chamber)
1081 {
1082 // Read hits info and store x,y,z info in arrays fPhits
1083 // Loop on all detectors
1084
1085     if (chamber > 14) return;
1086     Int_t track;
1087
1088     fChamber=chamber;
1089
1090     ResetPhits();
1091
1092     AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
1093     AliMUONChamber*  iChamber;
1094
1095     iChamber = &(pMUON->Chamber(chamber-1));
1096     Float_t zpos=iChamber->Z();
1097
1098     Int_t ntracks = (Int_t)gAlice->TreeH()->GetEntries();
1099     Int_t nthits=0;
1100     for (track=0; track<ntracks;track++) {
1101         gAlice->ResetHits();
1102         gAlice->TreeH()->GetEvent(track);
1103         TClonesArray *muonHits  = pMUON->Hits();
1104         if (muonHits == 0) return;
1105         nthits += muonHits->GetEntriesFast();
1106     }
1107     if (fPhits == 0) fPhits = new TObjArray(nthits);
1108     Int_t nhold=0;
1109     for (track=0; track<ntracks;track++) {
1110         gAlice->ResetHits();
1111         gAlice->TreeH()->GetEvent(track);
1112         TClonesArray *muonHits  = pMUON->Hits();
1113         if (muonHits == 0) return;
1114         Int_t nhits = muonHits->GetEntriesFast();
1115         if (nhits == 0) continue;
1116         AliMUONHit *mHit;
1117         AliMUONPoints *points = 0;
1118         Int_t npoints=1;
1119         for (Int_t hit=0;hit<nhits;hit++) {
1120             mHit = (AliMUONHit*)muonHits->UncheckedAt(hit);
1121             Int_t nch  = mHit->fChamber;              // chamber number
1122             if (nch != chamber) continue;
1123             //
1124             // Retrieve info and set the objects
1125             //
1126             points = new AliMUONPoints(npoints);
1127             fPhits->AddAt(points,nhold+hit);
1128             points->SetMarkerColor(kRed);
1129             points->SetMarkerStyle(5);
1130             points->SetMarkerSize(1.);
1131             points->SetParticle(mHit->Track());
1132             points->SetHitIndex(hit);
1133             points->SetTrackIndex(track);
1134             points->SetDigitIndex(-1);
1135             points->SetPoint(0,mHit->X(),mHit->Y(),zpos);
1136         }
1137         nhold+=nhits;
1138     }
1139 }
1140
1141 //_____________________________________________________________________________
1142 void AliMUONDisplay::Paint(Option_t *)
1143 {
1144 //    Paint miscellaneous items
1145 }
1146
1147 //_____________________________________________________________________________
1148 void AliMUONDisplay::SetPickMode()
1149 {
1150 // Set parameters for pick mode.
1151 //
1152     fZoomMode = 0;
1153
1154     fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
1155     fTrigPad->Modified();
1156 }
1157
1158 //_____________________________________________________________________________
1159 void AliMUONDisplay::SetZoomMode()
1160 {
1161 //  Set parameters for zoom mode
1162     fZoomMode = 1;
1163
1164     fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
1165     fTrigPad->Modified();
1166 }
1167
1168 //_____________________________________________________________________________
1169 void AliMUONDisplay::NextChamber(Int_t delta)
1170 {
1171   // to go from chamber to next chamber if delta = 1
1172   // or previous chamber otherwise
1173     if (delta == 1) {
1174         if (fChamber < AliMUONConstants::NCh()) fChamber++;
1175     } else {
1176         if (fChamber > 1) fChamber--;
1177     }
1178     if (!fPad) return;
1179     fPad->Clear();
1180     LoadDigits(fChamber, fCathode);
1181     Draw();
1182 }
1183
1184 //_____________________________________________________________________________
1185 void AliMUONDisplay::NextCathode()
1186 {
1187     // to switch to other cathode plane
1188     if (!fPad) return;
1189     fPad->Clear();
1190     if (fCathode == 1) {
1191         LoadDigits(fChamber, 2);
1192     } else {
1193         LoadDigits(fChamber, 1);
1194     }
1195     fNextCathode = kTRUE; // to keep the same zoom
1196     Draw();
1197     fNextCathode = kFALSE;
1198     TPad *pad = (TPad*)gPad->GetPadSave();
1199     pad->Range(fZoomX0[fZooms], fZoomY0[fZooms],
1200                fZoomX1[fZooms], fZoomY1[fZooms]);
1201     pad->Modified();
1202     fPad->cd();
1203     DrawTitle();
1204 }
1205
1206 //_____________________________________________________________________________
1207 void AliMUONDisplay::Trigger()
1208 {
1209   // returns Trigger Decision for current event
1210   AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
1211   decision->Trigger();
1212 }
1213
1214
1215 //_____________________________________________________________________________
1216 void AliMUONDisplay::SetChamberAndCathode(Int_t chamber, Int_t cathode)
1217 {
1218 // Set chamber and cathode number
1219    fChamber = chamber;
1220    fCathode = cathode;
1221
1222    if (!fPad) return;
1223    fPad->Clear();
1224    LoadDigits(chamber,cathode);
1225    Draw();
1226 }
1227
1228 void AliMUONDisplay::SetEvent(Int_t newevent)
1229 {
1230 // Chose event
1231     gAlice->GetEvent(newevent);
1232     fEvent=newevent;
1233     if (!gAlice->TreeD()) return;
1234     if (!fPad) return;
1235     fPad->Clear();
1236     LoadDigits(fChamber,fCathode);
1237     Draw();
1238 }
1239
1240 //_____________________________________________________________________________
1241 void AliMUONDisplay::SetRange(Float_t rrange, Float_t zrange)
1242 {
1243 // Set view range along R and Z
1244     fRrange = rrange;
1245     fZrange = zrange;
1246
1247     if (!fPad) return;
1248     fPad->Clear();
1249     Draw();
1250 }
1251
1252 //_____________________________________________________________________________
1253 void AliMUONDisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
1254 {
1255 //  change viewing angles for current event
1256
1257     fPad->cd();
1258     fPhi   = phi;
1259     fTheta = theta;
1260     fPsi   = psi;
1261     Int_t iret = 0;
1262
1263     TView *view = gPad->GetView();
1264     if (view) view->SetView(fPhi, fTheta, fPsi, iret);
1265     else      Draw();
1266     gPad->Modified();
1267 }
1268
1269 //_____________________________________________________________________________
1270 void AliMUONDisplay::ShowNextEvent(Int_t delta)
1271 {
1272 //  Display (current event_number + delta)
1273 //    delta =  1  shown next event
1274 //    delta = -1 show previous event
1275     if (delta) {
1276         gAlice->Clear();
1277         Int_t currentEvent = gAlice->GetHeader()->GetEvent();
1278         Int_t newEvent     = currentEvent + delta;
1279         gAlice->GetEvent(newEvent);
1280         fEvent=newEvent;
1281         if (!gAlice->TreeD()) return;
1282     }
1283
1284     LoadDigits(fChamber, fCathode);
1285     fPad->cd();
1286     Draw();
1287 }
1288
1289 //______________________________________________________________________________
1290 void AliMUONDisplay::UnZoom()
1291 {
1292 // Unzoom
1293     if (fZooms <= 0) return;
1294     fZooms--;
1295     TPad *pad = (TPad*)gPad->GetPadSave();
1296     pad->Range(fZoomX0[fZooms],fZoomY0[fZooms], fZoomX1[fZooms],fZoomY1[fZooms]);
1297     pad->Modified();
1298 }
1299
1300 //_____________________________________________________________________________
1301 void AliMUONDisplay::ResetPoints()
1302 {
1303     //
1304     // Reset array of points
1305     //
1306     if (fPoints) {
1307         fPoints->Delete();
1308         delete fPoints;
1309         fPoints = 0;
1310     }
1311 }
1312 //_____________________________________________________________________________
1313 void AliMUONDisplay::ResetPhits()
1314 {
1315     //
1316     // Reset array of points
1317     //
1318     if (fPhits) {
1319         fPhits->Delete();
1320         delete fPhits;
1321         fPhits = 0;
1322     }
1323 }
1324 //_____________________________________________________________________________
1325 void AliMUONDisplay::ResetRpoints()
1326 {
1327   //
1328   // Reset array of points
1329   //
1330     if (fRpoints) {
1331         fRpoints->Delete();
1332         delete fRpoints;
1333         fRpoints = 0;
1334     }
1335 }
1336 //_____________________________________________________________________________
1337 void AliMUONDisplay::ResetR2points()
1338 {
1339   //
1340   // Reset array of points
1341   //
1342     if (fR2points) {
1343         fR2points->Delete();
1344         delete fR2points;
1345         fR2points = 0;
1346     }
1347 }
1348 //_____________________________________________________________________________
1349 void AliMUONDisplay::ResetCpoints()
1350 {
1351     //
1352     // Reset array of points
1353     //
1354   if (fCpoints) {
1355       fCpoints->Delete();
1356       delete fCpoints;
1357       fCpoints = 0;
1358   }
1359 }
1360
1361
1362 AliMUONDisplay & AliMUONDisplay::operator = (const AliMUONDisplay &)
1363 {
1364 // Dummy assignment operator
1365     return *this;
1366 }
1367
1368
1369
1370
1371
1372
1373
1374
1375