STEER/AliDisplay.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 //                                                                      //
  20 // AliDisplay                                                           //
  21 //                                                                      //
  22 // Utility class to display ALICE outline, tracks, hits,..              //
  23 //                                                                      //
  24 //////////////////////////////////////////////////////////////////////////
  25
  26 #include <TArc.h>
  27 #include <TButton.h>
  28 #include <TCanvas.h>
  29 #include <TDiamond.h>
  30 #include <TGaxis.h>
  31 #include <TMath.h>
  32 #include <TPaveLabel.h>
  33 #include <TPaveText.h>
  34 #include <TSlider.h>
  35 #include <TSliderBox.h>
  36 #include <TTree.h>
  37 #include <TView.h>
  38 #include <TVirtualX.h>
  39
  40 #include "AliDetector.h"
  41 #include "AliDisplay.h"
  42 #include "AliHeader.h"
  43 #include "AliPoints.h"
  44 #include "AliRun.h"
  45 #include "AliStack.h"
  46 #include "TGeometry.h"
  47 #include "TParticle.h"
  48 #include "AliMC.h"
  49
  50 static const Float_t kptcutmax  = 2;
  51 static const Float_t ketacutmax = 1.5;
  52
  53 ClassImp(AliDisplay)
  54
  55
  56 //_______________________________________________________________________
  57 AliDisplay::AliDisplay():
  58   fZoomMode(0),
  59   fDrawAllViews(0),
  60   fDrawParticles(0),
  61   fDrawHits(0),
  62   fPTcut(0),
  63   fTheta(0),
  64   fPhi(0),
  65   fPsi(0),
  66   fRrange(0),
  67   fZrange(0),
  68   fZooms(0),
  69   fHitsCuts(0),
  70   fCanvas(0),
  71   fTrigPad(0),
  72   fCutPad(0),
  73   fEtaPad(0),
  74   fButtons(0),
  75   fPad(0),
  76   fCutSlider(0),
  77   fEtaSlider(0),
  78   fRangeSlider(0),
  79   fPickButton(0),
  80   fZoomButton(0),
  81   fArcButton(0),
  82   fFruits(0),
  83   fTracksToDisplay(0),
  84   fNTracksToDisplay(0)
  85 {
  86   //
  87   // Default constructor
  88   //
  89 }
  90
  91 //_____________________________________________________________________________
  92 AliDisplay::AliDisplay(Int_t size):
  93   fZoomMode(1),
  94   fDrawAllViews(kFALSE),
  95   fDrawParticles(kTRUE),
  96   fDrawHits(kTRUE),
  97   fPTcut(0),
  98   fTheta(0),
  99   fPhi(-90),
 100   fPsi(0),
 101   fRrange(0),
 102   fZrange(0),
 103   fZooms(1),
 104   fHitsCuts(0),
 105   fCanvas(0),
 106   fTrigPad(0),
 107   fCutPad(0),
 108   fEtaPad(0),
 109   fButtons(0),
 110   fPad(0),
 111   fCutSlider(0),
 112   fEtaSlider(0),
 113   fRangeSlider(0),
 114   fPickButton(0),
 115   fZoomButton(0),
 116   fArcButton(0),
 117   fFruits(0),
 118   fTracksToDisplay(0),
 119   fNTracksToDisplay(0)
 120 {
 121 // Create an event display object.
 122 // A canvas named "edisplay" is created with a vertical size in pixels
 123 //
 124 //    A QUICK Overview of the Event Display functions
 125 //    ===============================================
 126 //
 127 //  The event display can ve invoked by executing the macro "display.C"
 128 // A canvas like in the picture below will appear.
 129 //
 130 //  On the left side of the canvas, the following buttons appear:
 131 //   *Next*       to move to the next event
 132 //   *Previous*   to move to the previous event
 133 //   *Top View*   to display a top view of the current event
 134 //   *Side View*  to display a side view of the current event
 135 //   *Front View* to display a front view of the current event
 136 //   *All Views*  to display front/side/top/30-30 views of the current event
 137 //   *OpenGL*     to use OpenGl to view the current event.
 138 //                Note that OpenGL cannot be used across the network.
 139 //                Before using OpenGL, load the GL libraries
 140 //                by executing the macro GL.C (in $ROOTSYS/macros/GL.C.
 141 //                Once in GL, click the HELP button of the GL canvas.
 142 //   *X3D*        to use X3D to view the current event (Unix only).
 143 //                Once in X3D, type M to see the list of all possible options.
 144 //                for example type J to zoom, K to unzoom
 145 //                use the mouse to rotate.
 146 //   *Pick*       Select this option to be able to point on a track with the
 147 //                mouse. Once on the track, use the right button to select
 148 //                an action. For example, select SetMarkerAttributes to
 149 //                change the marker type/color/size for the track.
 150 //   *Zoom*       Select this option (default) if you want to zoom.
 151 //                To zoom, simply select the selected area with the left button.
 152 //   *UnZoom*     To revert to the previous picture size.
 153 //
 154 //   slider R     On the left side, the vertical slider can be used to
 155 //                set the default picture size.
 156 //   slider pcut  At the top of the canvas, a slider can be used to change
 157 //                the momentum cut (or range) to display tracks.
 158 //   slider eta   On the right side of the canvas, a vertical slider can be used
 159 //                to specify a rapidity range for the tracks.
 160 //
 161 //    When you are in Zoom mode, you can click on the black part of the canvas
 162 //  to select special options with the right mouse button.
 163 //  This will display a pop-up menu with items like:
 164 //     *Disable detector*
 165 //     *Enable detector*, etc.
 166 //  For example select "Disable detector". You get a dialog box.
 167 //  Diable detector TRD for example.
 168 //
 169 //  When you are in pick mode, you can "Inspect" the object pointed by the mouse.
 170 //  When you are on a track, select the menu item "InspectParticle"
 171 //  to display the current particle attributes.
 172 //
 173 //  You can activate the Root browser by selecting the Inspect menu
 174 //  in the canvas tool bar menu. Then select "Start Browser"
 175 //  This will open a new canvas with the browser. At this point, you may want
 176 //  to display some histograms (from the Trees). Go to the "File" menu
 177 //  of the browser and click on "New canvas".
 178 //  In the browser, click on item "ROOT files" in the left pane.
 179 //  Click on galice.root.
 180 //  Click on TH
 181 //  Click on TPC for example
 182 //  Click on any variable (eg TPC.fX) to histogram the variable.
 183 //
 184 //   If you are lost, you can click on HELP in any Root canvas or browser.
 185 //Begin_Html
 186 /*
 187 <img src="picts/alidisplay.gif">
 188 */
 189 //End_Html
 190
 191   gAlice->SetDisplay(this);
 192
 193   // Initialize display default parameters
 194   SetRange();
 195   SetPTcut();
 196
 197   // Create display canvas
 198   Int_t ysize = size;
 199   if (ysize < 100) ysize = 750;
 200   Int_t xsize = Int_t(size*830./ysize);
 201   fCanvas = new TCanvas("Canvas", "ALICE Event Display",14,47,xsize,ysize);
 202   fCanvas->ToggleEventStatus();
 203
 204   // Create main display pad
 205   fPad = new TPad("viewpad", "Alice display",0.15,0,0.97,0.96);
 206   fPad->Draw();
 207   fPad->Modified();
 208   fPad->SetFillColor(1);
 209   fPad->SetBorderSize(2);
 210
 211   // Create user interface control pad
 212   DisplayButtons();
 213   fCanvas->cd();
 214
 215   // Create Range and mode pad
 216   Float_t dxtr     = 0.15;
 217   Float_t dytr     = 0.45;
 218   fTrigPad = new TPad("trigger", "range and mode pad",0,0,dxtr,dytr);
 219   fTrigPad->Draw();
 220   fTrigPad->cd();
 221   fTrigPad->SetFillColor(22);
 222   fTrigPad->SetBorderSize(2);
 223   fRangeSlider = new TSlider("range","range",0.7,0.42,0.9,0.98);
 224   fRangeSlider->SetObject(this);
 225   char pickmode[] = "gAlice->Display()->SetPickMode()";
 226   Float_t db = 0.09;
 227   fPickButton = new TButton("Pick",pickmode,0.05,0.32,0.65,0.32+db);
 228   fPickButton->SetFillColor(38);
 229   fPickButton->Draw();
 230   char zoommode[] = "gAlice->Display()->SetZoomMode()";
 231   fZoomButton = new TButton("Zoom",zoommode,0.05,0.21,0.65,0.21+db);
 232   fZoomButton->SetFillColor(38);
 233   fZoomButton->Draw();
 234   fArcButton = new TArc(.8,fZoomButton->GetYlowNDC()+0.5*db,0.33*db);
 235   fArcButton->SetFillColor(kGreen);
 236   fArcButton->Draw();
 237   char butUnzoom[] = "gAlice->Display()->UnZoom()";
 238   TButton *button = new TButton("UnZoom",butUnzoom,0.05,0.05,0.95,0.15);
 239   button->SetFillColor(38);
 240   button->Draw();
 241   AppendPad(); // append display object as last object to force selection
 242   // Create momentum cut slider pad
 243   fCanvas->cd();
 244   fCutPad = new TPad("cutSlider", "pcut slider pad",dxtr,.96,1,1);
 245   fCutPad->Draw();
 246   fCutPad->cd();
 247   fCutPad->SetFillColor(22);
 248   fCutPad->SetBorderSize(2);
 249   fCutSlider = new TSlider("pcut","Momentum cut",0,0,1,1);
 250   fCutSlider->SetRange(fPTcut/kptcutmax,1);
 251   fCutSlider->SetObject(this);
 252   fCutSlider->SetFillColor(45);
 253   TSliderBox *sbox = dynamic_cast<TSliderBox*>(fCutSlider->GetListOfPrimitives()->First());
 254   sbox->SetFillColor(46);
 255   fCutSlider->cd();
 256   TGaxis *cutaxis = new TGaxis(0.02,0.8,0.98,0.8,0,kptcutmax,510,"");
 257   cutaxis->SetLabelSize(0.5);
 258   cutaxis->SetTitleSize(0.6);
 259   cutaxis->SetTitleOffset(0.5);
 260   cutaxis->SetTitle("pcut .  ");
 261   fCutSlider->GetListOfPrimitives()->AddFirst(cutaxis);
 262   // Create rapidity cut slider pad
 263   fCanvas->cd();
 264   fEtaPad = new TPad("EtaSlider", "Eta slider pad",0.97,0,1,0.96);
 265   fEtaPad->Draw();
 266   fEtaPad->cd();
 267   fEtaPad->SetFillColor(22);
 268   fEtaPad->SetBorderSize(2);
 269   fEtaSlider = new TSlider("etacut","Rapidity cut",0,0,1,1);
 270   fEtaSlider->SetObject(this);
 271   fEtaSlider->SetFillColor(45);
 272   TSliderBox *sbox2 = dynamic_cast<TSliderBox*>(fEtaSlider->GetListOfPrimitives()->First());
 273   sbox2->SetFillColor(46);
 274   fEtaSlider->cd();
 275   TGaxis *etaaxis = new TGaxis(0.9,0.02,0.9,0.98,-ketacutmax,ketacutmax,510,"");
 276   etaaxis->SetLabelSize(0.5);
 277   etaaxis->SetTitleSize(0.6);
 278   etaaxis->SetTitleOffset(0.2);
 279   cutaxis->SetTitle("Etacut .  ");
 280   fEtaSlider->GetListOfPrimitives()->AddFirst(etaaxis);
 281   fCanvas->cd();
 282
 283   fTrigPad->SetEditable(kFALSE);
 284   fButtons->SetEditable(kFALSE);
 285   fTracksToDisplay =0;
 286   fNTracksToDisplay =0;
 287
 288   fCanvas->cd();
 289   fCanvas->Update();
 290 }
 291
 292
 293 //_______________________________________________________________________
 294 AliDisplay::AliDisplay(const AliDisplay &disp):
 295   TObject(disp),
 296   fZoomMode(0),
 297   fDrawAllViews(0),
 298   fDrawParticles(0),
 299   fDrawHits(0),
 300   fPTcut(0),
 301   fTheta(0),
 302   fPhi(0),
 303   fPsi(0),
 304   fRrange(0),
 305   fZrange(0),
 306   fZooms(0),
 307   fHitsCuts(0),
 308   fCanvas(0),
 309   fTrigPad(0),
 310   fCutPad(0),
 311   fEtaPad(0),
 312   fButtons(0),
 313   fPad(0),
 314   fCutSlider(0),
 315   fEtaSlider(0),
 316   fRangeSlider(0),
 317   fPickButton(0),
 318   fZoomButton(0),
 319   fArcButton(0),
 320   fFruits(0),
 321   fTracksToDisplay(0),
 322   fNTracksToDisplay(0)
 323 {
 324   //
 325   // Copy constructor
 326   //
 327   disp.Copy(*this);
 328 }
 329
 330 //_____________________________________________________________________________
 331 AliDisplay::~AliDisplay()
 332 {
 333   //
 334   // Destructor
 335   //
 336 }
 337
 338 //_____________________________________________________________________________
 339 void AliDisplay::Clear(Option_t *)
 340 {
 341 //    Delete graphics temporary objects
 342 }
 343
 344 //_____________________________________________________________________________
 345 void AliDisplay::Copy(AliDisplay &) const
 346 {
 347   //
 348   // Copy *this onto disp -- not implemented
 349   //
 350   Fatal("Copy","Not implemented~\n");
 351 }
 352
 353 //----------------------------------------------------------------------------
 354 void AliDisplay::ShowTrack(Int_t idx)
 355 {
 356   //
 357   // Display track idx
 358   //
 359    AliDetector *mTPC=dynamic_cast<AliDetector*>(gAlice->GetModule("TPC"));
 360    TObjArray *points=mTPC->Points();
 361    int ntracks=points->GetEntriesFast();
 362    for (int track=0;track<ntracks;track++) {
 363       AliPoints *pm = dynamic_cast<AliPoints*>(points->UncheckedAt(track));
 364       if (!pm) continue;
 365       if (idx == pm->GetIndex()) {
 366          pm->SetMarkerColor(2);
 367          pm->SetMarkerStyle(22);
 368          pm->Draw("same");
 369 //       fPad->Update();
 370 //       fPad->Modified();
 371          //         TClonesArray *particles=gAlice->Particles();
 372          //         TParticle *p = (TParticle*)particles->UncheckedAt(idx);
 373          TParticle *p = gAlice->GetMCApp()->Particle(idx);
 374          printf("\nTrack index %d\n",idx);
 375          printf("Particle ID %d\n",p->GetPdgCode());
 376          printf("Parent %d\n",p->GetFirstMother());
 377          printf("First child %d\n",p->GetFirstDaughter());
 378          printf("Px,Py,Pz %f %f %f\n",p->Px(),p->Py(),p->Pz());
 379          return;
 380       }
 381    }
 382 }
 383
 384 //----------------------------------------------------------------------------
 385 void AliDisplay::HideTrack(Int_t idx) const
 386 {
 387   //
 388   // Hide track on display
 389   //
 390    AliDetector *mTPC=dynamic_cast<AliDetector*>(gAlice->GetModule("TPC"));
 391    TObjArray *points=mTPC->Points();
 392    int ntracks=points->GetEntriesFast();
 393    for (int track=0;track<ntracks;track++) {
 394       AliPoints *pm = dynamic_cast<AliPoints*>(points->UncheckedAt(track));
 395       if (!pm) continue;
 396       if (idx == pm->GetIndex()) {
 397          pm->SetMarkerColor(5);
 398          pm->SetMarkerStyle(1);
 399          pm->Draw("same");
 400 //       fPad->Update();
 401 //       fPad->Modified();
 402          return;
 403       }
 404    }
 405 }
 406
 407 //_____________________________________________________________________________
 408 void AliDisplay::DisableDetector(const char *name)
 409 {
 410 //    Disable detector name from graphics views
 411
 412    AliModule *module = dynamic_cast<AliModule*>(gAlice->Modules()->FindObject(name));
 413    if (!module) return;
 414    module->Disable();
 415    Draw();
 416 }
 417
 418 //_____________________________________________________________________________
 419 void AliDisplay::DisplayButtons()
 420 {
 421 //    Create the user interface buttons
 422
 423    fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
 424    fButtons->Draw();
 425    fButtons->SetFillColor(38);
 426    fButtons->SetBorderSize(2);
 427    fButtons->cd();
 428
 429    Int_t butcolor = 33;
 430    Float_t dbutton = 0.08;
 431    Float_t y  = 0.96;
 432    Float_t dy = 0.014;
 433    Float_t x0 = 0.05;
 434    Float_t x1 = 0.95;
 435
 436    TButton *button;
 437    char but1[] = "gAlice->Display()->ShowNextEvent(1)";
 438    button = new TButton("Next",but1,x0,y-dbutton,x1,y);
 439    button->SetFillColor(38);
 440    button->Draw();
 441
 442    y -= dbutton +dy;
 443    char but2[] = "gAlice->Display()->ShowNextEvent(-1)";
 444    button = new TButton("Previous",but2,x0,y-dbutton,x1,y);
 445    button->SetFillColor(38);
 446    button->Draw();
 447
 448    y -= dbutton +dy;
 449    char but3[] = "gAlice->Display()->SetView(90,-90,90)";
 450    button = new TButton("Top View",but3,x0,y-dbutton,x1,y);
 451    button->SetFillColor(butcolor);
 452    button->Draw();
 453
 454    y -= dbutton +dy;
 455    char but4[] = "gAlice->Display()->SetView(90,0,-90)";
 456    button = new TButton("Side View",but4,x0,y-dbutton,x1,y);
 457    button->SetFillColor(butcolor);
 458    button->Draw();
 459
 460    y -= dbutton +dy;
 461    char but5[] = "gAlice->Display()->SetView(0,-90,0)";
 462    button = new TButton("Front View",but5,x0,y-dbutton,x1,y);
 463    button->SetFillColor(butcolor);
 464    button->Draw();
 465
 466    y -= dbutton +dy;
 467    char but6[] = "gAlice->Display()->DrawAllViews()";
 468    button = new TButton("All Views",but6,x0,y-dbutton,x1,y);
 469    button->SetFillColor(butcolor);
 470    button->Draw();
 471
 472    y -= dbutton +dy;
 473    char but7[] = "gAlice->Display()->DrawViewGL()";
 474    button = new TButton("OpenGL",but7,x0,y-dbutton,x1,y);
 475    button->SetFillColor(38);
 476    button->Draw();
 477
 478    y -= dbutton +dy;
 479    char but8[] = "gAlice->Display()->DrawViewX3D()";
 480    button = new TButton("X3D",but8,x0,y-dbutton,x1,y);
 481    button->SetFillColor(38);
 482    button->Draw();
 483
 484    // display logo
 485    TDiamond *diamond = new TDiamond(0.05,0.015,0.95,0.22);
 486    diamond->SetFillColor(50);
 487    diamond->SetTextAlign(22);
 488    diamond->SetTextColor(5);
 489    diamond->SetTextSize(0.11);
 490    diamond->Draw();
 491    diamond->AddText(".. ");
 492    diamond->AddText("ROOT");
 493    diamond->AddText("ALICE");
 494    diamond->AddText("... ");
 495    diamond->AddText(" ");
 496 }
 497
 498 //______________________________________________________________________________
 499 Int_t AliDisplay::DistancetoPrimitive(Int_t px, Int_t)
 500 {
 501 // Compute distance from point px,py to objects in event
 502
 503    gPad->SetCursor(kCross);
 504
 505    if (gPad == fTrigPad) return 9999;
 506    if (gPad == fCutPad)  return 9999;
 507    if (gPad == fEtaPad)  return 9999;
 508
 509    const Int_t kbig = 9999;
 510    Int_t dist   = kbig;
 511    Float_t xmin = gPad->GetX1();
 512    Float_t xmax = gPad->GetX2();
 513    Float_t dx   = 0.02*(xmax - xmin);
 514    Float_t x    = gPad->AbsPixeltoX(px);
 515    if (x < xmin+dx || x > xmax-dx) return dist;
 516
 517    if (fZoomMode) return 0;
 518    else           return 7;
 519 }
 520
 521 //_____________________________________________________________________________
 522 void AliDisplay::Draw(Option_t *)
 523 {
 524 //    Display current event
 525
 526    if (fDrawAllViews) {
 527       DrawAllViews();
 528       return;
 529    }
 530
 531    fPad->cd();
 532
 533    DrawView(fTheta, fPhi, fPsi);
 534
 535    // Display the event number and title
 536    fPad->cd();
 537    DrawTitle();
 538 }
 539
 540 //_____________________________________________________________________________
 541 void AliDisplay::DrawAllViews()
 542 {
 543 //    Draw front,top,side and 30 deg views
 544
 545    fDrawAllViews = kTRUE;
 546    fPad->cd();
 547    fPad->SetFillColor(15);
 548    fPad->Clear();
 549    fPad->Divide(2,2);
 550
 551    // draw 30 deg view
 552    fPad->cd(1);
 553    DrawView(30, 30, 0);
 554    DrawTitle();
 555
 556    // draw front view
 557    fPad->cd(2);
 558    DrawView(0, -90,0);
 559    DrawTitle("Front");
 560
 561    // draw top view
 562    fPad->cd(3);
 563    DrawView(90, -90, 90);
 564    DrawTitle("Top");
 565
 566    // draw side view
 567    fPad->cd(4);
 568    DrawView(90, 0, -90);
 569    DrawTitle("Side");
 570
 571    fPad->cd(2);
 572 }
 573
 574 //_____________________________________________________________________________
 575 void AliDisplay::DrawHits()
 576 {
 577 //    Draw hits for all ALICE detectors
 578
 579    Float_t cutmin, cutmax, etamin, etamax, pmom, smin, smax, eta, theta, r;
 580    Float_t *pxyz;
 581    Int_t ntracks,track;
 582    TParticle *particle;
 583    TObjArray *points;
 584    AliPoints *pm;
 585
 586    //Get cut slider
 587    smax   = fCutSlider->GetMaximum();
 588    smin   = fCutSlider->GetMinimum();
 589    cutmin = kptcutmax*smin;
 590    if (smax < 0.98) cutmax = kptcutmax*smax;
 591    else             cutmax = 100000;
 592
 593    //Get eta slider
 594    smax   = fEtaSlider->GetMaximum();
 595    smin   = fEtaSlider->GetMinimum();
 596    etamin = ketacutmax*(2*smin-1);
 597    etamax = ketacutmax*(2*smax-1);
 598    if (smin < 0.02) etamin = -1000;
 599    if (smax > 0.98) etamax =  1000;
 600
 601    TIter next(gAlice->Modules());
 602    AliModule *module;
 603    fHitsCuts = 0;
 604    while((module = dynamic_cast<AliModule*>(next()))) {
 605       if (!module->IsActive()) continue;
 606       points = module->Points();
 607       if (!points) continue;
 608       ntracks = points->GetEntriesFast();
 609       for (track=0;track<ntracks;track++) {
 610          pm = dynamic_cast<AliPoints*>(points->UncheckedAt(track));
 611          if (!pm) continue;
 612          particle = pm->GetParticle();
 613          if (!particle) continue;
 614          pmom = particle->P();
 615          if (pmom < cutmin) continue;
 616          if (pmom > cutmax) continue;
 617          // as a first approximation, take eta of first point
 618          pxyz  = pm->GetP();
 619          r     = TMath::Sqrt(pxyz[0]*pxyz[0] + pxyz[1]*pxyz[1]);
 620          theta = TMath::ATan2(r,TMath::Abs(pxyz[2]));
 621          if(theta) eta = -TMath::Log(TMath::Abs(TMath::Tan(0.5*theta))); else eta = 1e10;
 622          if (pxyz[2] < 0) eta = -eta;
 623          if (eta < etamin || eta > etamax) continue;
 624          pm->Draw();
 625          fHitsCuts += pm->GetN();
 626       }
 627    }
 628 }
 629
 630 //_____________________________________________________________________________
 631 void AliDisplay::DrawTitle(Option_t *option)
 632 {
 633 //    Draw the event title
 634
 635    Float_t xmin = gPad->GetX1();
 636    Float_t xmax = gPad->GetX2();
 637    Float_t ymin = gPad->GetY1();
 638    Float_t ymax = gPad->GetY2();
 639    Float_t dx   = xmax-xmin;
 640    Float_t dy   = ymax-ymin;
 641
 642    if (strlen(option) == 0) {
 643       TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
 644       title->SetBit(kCanDelete);
 645       title->SetFillColor(42);
 646       title->Draw();
 647       char ptitle[100];
 648       sprintf(ptitle,"Alice event: %d, Run:%d",gAlice->GetHeader()->GetEvent(), gAlice->GetHeader()->GetRun());
 649       title->AddText(ptitle);
 650       Int_t nparticles = gAlice->GetMCApp()->Particles()->GetEntriesFast();
 651       sprintf(ptitle,"Nparticles = %d  Nhits = %d",nparticles, fHitsCuts);
 652       title->AddText(ptitle);
 653    } else {
 654       TPaveLabel *label = new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
 655       label->SetBit(kCanDelete);
 656       label->SetFillColor(42);
 657       label->Draw();
 658    }
 659 }
 660
 661 //_____________________________________________________________________________
 662 void AliDisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
 663 {
 664 //    Draw a view of ALICE
 665
 666    gPad->SetCursor(kWatch);
 667    gPad->SetFillColor(1);
 668    gPad->Clear();
 669
 670    Int_t iret;
 671    TView *view = new TView(1);
 672    Float_t range = fRrange*fRangeSlider->GetMaximum();
 673    view->SetRange(-range,-range,-range,range, range, range);
 674    fZoomX0[0] = -1;
 675    fZoomY0[0] = -1;
 676    fZoomX1[0] =  1;
 677    fZoomY1[0] =  1;
 678    fZooms = 0;
 679
 680    // Display Alice Geometry
 681    gAlice->GetGeometry()->Draw("same");
 682
 683    //Loop on all detectors to add their products to the pad
 684    DrawHits();
 685
 686     // add itself to the list (must be last)
 687    AppendPad();
 688
 689    view->SetView(phi, theta, psi, iret);
 690 }
 691
 692 //_____________________________________________________________________________
 693 void AliDisplay::DrawViewGL()
 694 {
 695 //    Draw current view using OPENGL
 696
 697    TPad *pad = dynamic_cast<TPad*>(gPad->GetPadSave());
 698    pad->cd();
 699    TView *view = pad->GetView();
 700    if (!view) return;
 701    pad->x3d("OPENGL");
 702 }
 703
 704 //_____________________________________________________________________________
 705 void AliDisplay::DrawViewX3D()
 706 {
 707 //    Draw current view using X3D
 708
 709    TPad *pad = dynamic_cast<TPad*>(gPad->GetPadSave());
 710    pad->cd();
 711    TView *view = pad->GetView();
 712    if (!view) return;
 713    pad->x3d();
 714 }
 715
 716 //_____________________________________________________________________________
 717 void AliDisplay::EnableDetector(const char *name)
 718 {
 719 //    Enable detector name in graphics views
 720
 721    AliModule *module = dynamic_cast<AliModule*>(gAlice->Modules()->FindObject(name));
 722    if (!module) return;
 723    module->Enable();
 724    Draw();
 725 }
 726
 727 //______________________________________________________________________________
 728 void AliDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
 729 {
 730 //  Execute action corresponding to the mouse event
 731
 732    static Float_t x0, y0, x1, y1;
 733
 734    static Int_t pxold, pyold;
 735    static Int_t px0, py0;
 736    static Int_t linedrawn;
 737    Float_t temp;
 738
 739    if (px == 0 && py == 0) { //when called by sliders
 740       if (event == kButton1Up) {
 741          Draw();
 742       }
 743       return;
 744    }
 745    if (!fZoomMode && gPad->GetView()) {
 746       gPad->GetView()->ExecuteRotateView(event, px, py);
 747       return;
 748    }
 749
 750    // something to zoom ?
 751 //   fPad->SetCursor(kCross);
 752    gPad->SetCursor(kCross);
 753
 754    switch (event) {
 755
 756    case kButton1Down:
 757       gVirtualX->SetLineColor(-1);
 758       gPad->TAttLine::Modify();  //Change line attributes only if necessary
 759       x0 = gPad->AbsPixeltoX(px);
 760       y0 = gPad->AbsPixeltoY(py);
 761       px0   = px; py0   = py;
 762       pxold = px; pyold = py;
 763       linedrawn = 0;
 764       return;
 765
 766    case kButton1Motion:
 767       if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
 768       pxold = px;
 769       pyold = py;
 770       linedrawn = 1;
 771       gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
 772       return;
 773
 774    case kButton1Up:
 775       gPad->GetCanvas()->FeedbackMode(kFALSE);
 776       if (px == px0) return;
 777       if (py == py0) return;
 778       x1 = gPad->AbsPixeltoX(px);
 779       y1 = gPad->AbsPixeltoY(py);
 780
 781       if (x1 < x0) {temp = x0; x0 = x1; x1 = temp;}
 782       if (y1 < y0) {temp = y0; y0 = y1; y1 = temp;}
 783       gPad->Range(x0,y0,x1,y1);
 784       if (fZooms < kMAXZOOMS-1) {
 785          fZooms++;
 786          fZoomX0[fZooms] = x0;
 787          fZoomY0[fZooms] = y0;
 788          fZoomX1[fZooms] = x1;
 789          fZoomY1[fZooms] = y1;
 790       }
 791       gPad->Modified(kTRUE);
 792       return;
 793    }
 794
 795 }
 796
 797
 798 void AliDisplay::SetTracksToDisplay(Int_t *tracks, Int_t n){
 799   //
 800   // set tracks to display  - MI
 801   fTracksToDisplay = tracks;
 802   fNTracksToDisplay = n;
 803 }
 804 //___________________________________________
 805 void AliDisplay::LoadPoints()
 806 {
 807 // Read hits info and store x,y,z info in arrays fPoints
 808 // Loop on all detectors
 809
 810    gAlice->ResetPoints();
 811    TIter next(gAlice->Modules());
 812    AliModule *module;
 813    Int_t ntracks = gAlice->GetMCApp()->GetNtrack();
 814
 815    while((module = (AliModule*)next()))
 816     {
 817      AliDetector* detector = dynamic_cast<AliDetector*>(module);
 818      if(detector) detector->SetTreeAddress();
 819     }
 820    next.Reset();
 821
 822    // load only wanted tracks
 823    if (fNTracksToDisplay>0)
 824     {
 825       Int_t nprim =  gAlice->Stack()->GetNprimary();
 826       for (Int_t track=0; track<fNTracksToDisplay;track++)
 827        {
 828         gAlice->ResetHits();
 829         Int_t nev = nprim-1-gAlice->GetMCApp()->GetPrimary(fTracksToDisplay[track]);
 830         while((module = (AliModule*)next()))
 831          {
 832           AliDetector* detector = dynamic_cast<AliDetector*>(module);
 833           if(detector)
 834            {
 835             detector->TreeH()->GetEvent(nev);
 836             module->LoadPoints(nprim-1-gAlice->GetMCApp()->GetPrimary(fTracksToDisplay[track]));
 837            }
 838          }
 839         next.Reset();
 840      }
 841    }
 842    else
 843     {
 844
 845       for (Int_t track=0; track<ntracks;track++) {
 846       gAlice->ResetHits();
 847       while((module = (AliModule*)next())) {
 848          AliDetector* detector = dynamic_cast<AliDetector*>(module);
 849          if(detector)
 850            {
 851              detector->TreeH()->GetEvent(track);
 852              detector->LoadPoints(track);
 853            }
 854       }
 855       next.Reset();
 856      }
 857    }
 858 }
 859
 860 //_____________________________________________________________________________
 861 void AliDisplay::Paint(Option_t *)
 862 {
 863 //    Paint miscellaneous items
 864
 865 }
 866
 867 //_____________________________________________________________________________
 868 void AliDisplay::SetPickMode()
 869 {
 870   //
 871   // Set Pick Mode -- disable zoom
 872   //
 873    fZoomMode = 0;
 874
 875    fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
 876    fTrigPad->Modified();
 877 }
 878
 879 //_____________________________________________________________________________
 880 void AliDisplay::SetZoomMode()
 881 {
 882   //
 883   // Set Zoom Mode -- disable pick
 884   //
 885    fZoomMode = 1;
 886
 887    fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
 888    fTrigPad->Modified();
 889 }
 890
 891 //_____________________________________________________________________________
 892 void AliDisplay::SetPTcut(Float_t ptcut)
 893 {
 894   //
 895   // Set Pt Cut
 896   //
 897    fPTcut = ptcut;
 898
 899    if (!fPad) return;
 900    fPad->Clear();
 901    Draw();
 902 }
 903
 904 //_____________________________________________________________________________
 905 void AliDisplay::SetRange(Float_t rrange, Float_t zrange)
 906 {
 907 // Set view range along R and Z
 908    fRrange = rrange;
 909    fZrange = zrange;
 910
 911    if (!fPad) return;
 912    fPad->Clear();
 913    Draw();
 914 }
 915
 916 //_____________________________________________________________________________
 917 void AliDisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
 918 {
 919 //  change viewing angles for current event
 920
 921    fPad->cd();
 922    fDrawAllViews = kFALSE;
 923    fPhi   = phi;
 924    fTheta = theta;
 925    fPsi   = psi;
 926    Int_t iret = 0;
 927
 928    TView *view = gPad->GetView();
 929    if (view) view->SetView(fPhi, fTheta, fPsi, iret);
 930    else      Draw();
 931
 932    gPad->Modified();
 933 }
 934
 935 //_____________________________________________________________________________
 936 void AliDisplay::ShowNextEvent(Int_t delta)
 937 {
 938 //  Display (current event_number+delta)
 939 //    delta =  1  shown next event
 940 //    delta = -1 show previous event
 941
 942   if (delta) {
 943 //     gAlice->Clear();
 944      //Int_t currentEvent = gAlice->GetHeader()->GetEvent();//event number is not filled correctly
 945      Int_t currentEvent = gAlice->GetRunLoader()->GetEventNumber();
 946      Int_t newEvent     = currentEvent + delta;
 947      gAlice->GetEvent(newEvent);
 948      cout<<"AliDisplay::ShowNextEvent: delta = "<<delta
 949          <<"  currentEvent = "<<currentEvent
 950          <<"  newEvent = "<<newEvent<<endl;
 951    }
 952   LoadPoints();
 953   fPad->cd();
 954   Draw();
 955 }
 956
 957 //______________________________________________________________________________
 958 void AliDisplay::UnZoom()
 959 {
 960   //
 961   // Resets ZOOM
 962   //
 963   if (fZooms <= 0) return;
 964   fZooms--;
 965   TPad *pad = dynamic_cast<TPad*>(gPad->GetPadSave());
 966   pad->Range(fZoomX0[fZooms],fZoomY0[fZooms], fZoomX1[fZooms],fZoomY1[fZooms]);
 967   pad->Modified();
 968 }
 969
 970 //_____________________________________________________________________________
 971 AliDisplay & AliDisplay::operator=(const AliDisplay &disp)
 972 {
 973   //
 974   // Assignment operator
 975   //
 976   disp.Copy(*this);
 977   return (*this);
 978 }