RICH/AliRICHDisplay.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.4  2000/06/12 15:21:08  jbarbosa
  19   Cleaned up version.
  20
  21   Revision 1.3  2000/06/09 14:52:08  jbarbosa
  22   New tentative ellipse drawing routine
  23
  24   Revision 1.1  2000/04/19 13:07:45  morsch
  25   Digits, clusters and reconstruction results added.
  26
  27 */
  28
  29
  30 //////////////////////////////////////////////////////////////////////////
  31 //                                                                      //
  32 // AliDisplay                                                           //
  33 //                                                                      //
  34 // Utility class to display ALICE outline, tracks, hits,..              //
  35 //                                                                      //
  36 //////////////////////////////////////////////////////////////////////////
  37
  38 #include <TROOT.h>
  39 #include <TTree.h>
  40 #include <TButton.h>
  41 #include <TColor.h>
  42 #include <TCanvas.h>
  43 #include <TView.h>
  44 #include <TText.h>
  45 #include <TPolyMarker3D.h>
  46 #include <TPolyMarker.h>
  47 #include <TPaveLabel.h>
  48 #include <TPaveText.h>
  49 #include <TList.h>
  50 #include <TDiamond.h>
  51 #include <TNode.h>
  52 #include <TArc.h>
  53 #include <TTUBE.h>
  54 #include <TSlider.h>
  55 #include <TSliderBox.h>
  56 #include <TGaxis.h>
  57 #include <TVirtualX.h>
  58 #include <TMath.h>
  59 #include <TRandom.h>
  60 #include <X3DBuffer.h>
  61 #include <TParticle.h>
  62
  63 #include "AliRun.h"
  64 #include "AliPDG.h"
  65 #include "AliDetector.h"
  66 #include "AliRICH.h"
  67 #include "AliRICHConst.h"
  68 #include "AliRICHDisplay.h"
  69 #include "AliRICHPoints.h"
  70
  71 #include "AliRICHHit.h"
  72 #include "AliRICHCerenkov.h"
  73 #include "AliRICHPadHit.h"
  74 #include "AliRICHDigit.h"
  75 #include "AliRICHRawCluster.h"
  76 #include "AliRICHRecHit.h"
  77 #include "AliRICHEllipse.h"
  78
  79 ClassImp(AliRICHDisplay)
  80
  81
  82 //____________________________________________________________________________
  83 AliRICHDisplay::AliRICHDisplay()
  84 {
  85
  86 // default constructor
  87
  88     fPoints = 0;
  89     fPhits = 0;
  90     fPCerenkovs = 0;
  91     fCanvas = 0;
  92     fRpoints = 0;
  93     fRecpoints = 0;
  94 }
  95
  96 //_____________________________________________________________________________
  97 AliRICHDisplay::AliRICHDisplay(Int_t size)
  98 {
  99 // Create an event display object.
 100 // A canvas named "edisplay" is created with a vertical size in pixels
 101 //
 102 //    A QUICK Overview of the Event Display functions
 103 //    ===============================================
 104 //
 105 //  The event display can ve invoked by executing the macro "display.C"
 106 // A canvas like in the picture below will appear.
 107 //
 108 //  On the left side of the canvas, the following buttons appear:
 109 //   *Next*       to move to the next event
 110 //   *Previous*   to move to the previous event
 111
 112 //   *Pick*       Select this option to be able to point on a track with the
 113 //                mouse. Once on the track, use the right button to select
 114 //                an action. For example, select SetMarkerAttributes to
 115 //                change the marker type/color/size for the track.
 116 //   *Zoom*       Select this option (default) if you want to zoom.
 117 //                To zoom, simply select the selected area with the left button.
 118 //   *UnZoom*     To revert to the previous picture size.
 119 //
 120 //   slider R     On the left side, the vertical slider can be used to
 121 //                set the default picture size.
 122 //
 123 //    When you are in Zoom mode, you can click on the black part of the canvas
 124 //  to select special options with the right mouse button.
 125
 126 //
 127 //  When you are in pick mode, you can "Inspect" the object pointed by the mouse.
 128 //  When you are on a track, select the menu item "InspectParticle"
 129 //  to display the current particle attributes.
 130 //
 131 //  You can activate the Root browser by selecting the Inspect menu
 132 //  in the canvas tool bar menu. Then select "Start Browser"
 133 //  This will open a new canvas with the browser. At this point, you may want
 134 //  to display some histograms (from the Trees). Go to the "File" menu
 135 //  of the browser and click on "New canvas".
 136 //  In the browser, click on item "ROOT files" in the left pane.
 137 //  Click on galice.root.
 138 //  Click on TH
 139 //  Click on TPC for example
 140 //  Click on any variable (eg TPC.fX) to histogram the variable.
 141 //
 142 //   If you are lost, you can click on HELP in any Root canvas or browser.
 143 //Begin_Html
 144 /*
 145   <img src="gif/AliRICHDisplay.gif">
 146 */
 147 //End_Html
 148
 149
 150     fPad = 0;
 151
 152     gAlice->SetDisplay(this);
 153
 154     // Initialize display default parameters
 155     SetRange();
 156
 157     // Set front view by default
 158     fTheta = 90;
 159     fPhi   = 90;
 160     fPsi   = 0;
 161     fChamber = 1;
 162     fCathode = 1;
 163     //   fRzone   = 1.e10;
 164     fDrawClusters  = kTRUE;
 165     fDrawCoG       = kTRUE;
 166     fDrawRecHits   = kTRUE;
 167     fZoomMode      = 1;
 168     fZooms         = 0;
 169     fClustersCuts  = 0;
 170     fPoints        = 0;
 171     fPCerenkovs    = 0;
 172     fPhits         = 0;
 173     fRpoints       = 0;
 174     fRecpoints       = 0;
 175     // Create colors
 176     CreateColors();
 177     // Create display canvas
 178     Int_t ysize = size;
 179     if (ysize < 100) ysize = 750;
 180     Int_t xsize = Int_t(size*830./ysize);
 181     fCanvas = new TCanvas("Canvas", "RICH Clusters Display",14,47,xsize,ysize);
 182     fCanvas->ToggleEventStatus();
 183
 184     // Create main display pad
 185     fPad = new TPad("viewpad", "RICH display",0.15,0,0.9,1);
 186     fPad->Draw();
 187     fPad->Modified();
 188     fPad->SetFillColor(1);
 189     fPad->SetBorderSize(2);
 190
 191     fCanvas->cd();
 192
 193     // Create colors pad
 194     fColPad = new TPad("colpad", "Colors pad",0.9,0,1,1);
 195     fColPad->Draw();
 196     fColPad->Modified();
 197     fColPad->SetFillColor(19);
 198     fColPad->SetBorderSize(2);
 199     fColPad->cd();
 200     DisplayColorScale();
 201
 202     fCanvas->cd();
 203
 204     // Create user interface control pad
 205     DisplayButtons();
 206     fCanvas->cd();
 207
 208     // Create Range and mode pad
 209     Float_t dxtr     = 0.15;
 210     Float_t dytr     = 0.45;
 211     fTrigPad = new TPad("trigger", "range and mode pad",0,0,dxtr,dytr);
 212     fTrigPad->SetEditable(kFALSE);
 213     fTrigPad->Draw();
 214     fTrigPad->cd();
 215     fTrigPad->SetFillColor(22);
 216     fTrigPad->SetBorderSize(2);
 217     fRangeSlider = new TSlider("range","range",0.7,0.42,0.9,0.98);
 218     fRangeSlider->SetObject(this);
 219     char pickmode[] = "gAlice->Display()->SetPickMode()";
 220     Float_t db = 0.09;
 221     fPickButton = new TButton("Pick",pickmode,0.05,0.32,0.65,0.32+db);
 222     fPickButton->SetFillColor(38);
 223     fPickButton->Draw();
 224     char zoommode[] = "gAlice->Display()->SetZoomMode()";
 225     fZoomButton = new TButton("Zoom",zoommode,0.05,0.21,0.65,0.21+db);
 226     fZoomButton->SetFillColor(38);
 227     fZoomButton->Draw();
 228     fArcButton = new TArc(.8,fZoomButton->GetYlowNDC()+0.5*db,0.33*db);
 229     fArcButton->SetFillColor(kGreen);
 230     fArcButton->Draw();
 231     char butUnzoom[] = "gAlice->Display()->UnZoom()";
 232     TButton *button = new TButton("UnZoom",butUnzoom,0.05,0.05,0.95,0.15);
 233     button->SetFillColor(38);
 234     button->Draw();
 235     AppendPad(); // append display object as last object to force selection
 236
 237     fCanvas->cd();
 238     fCanvas->Update();
 239 }
 240
 241
 242 //_____________________________________________________________________________
 243 AliRICHDisplay::~AliRICHDisplay()
 244 {
 245     // Delete space point structure
 246     if (fPoints) fPoints->Delete();
 247     delete fPoints;
 248     fPoints     = 0;
 249     //
 250     if (fPhits) fPhits->Delete();
 251     delete fPhits;
 252     fPhits     = 0;
 253     //
 254     if (fRpoints) fRpoints->Delete();
 255     delete fRpoints;
 256     fRpoints     = 0;
 257     //
 258     if (fRecpoints) fRecpoints->Delete();
 259     delete fRecpoints;
 260     fRecpoints     = 0;
 261     //
 262     if (fPCerenkovs) fPCerenkovs->Delete();
 263     delete fPCerenkovs;
 264     fPCerenkovs     = 0;
 265 }
 266
 267 //_____________________________________________________________________________
 268 void AliRICHDisplay::Clear(Option_t *)
 269 {
 270 //    Delete graphics temporary objects
 271 }
 272
 273 //_____________________________________________________________________________
 274 void AliRICHDisplay::DisplayButtons()
 275 {
 276 //    Create the user interface buttons
 277
 278
 279     fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
 280     fButtons->SetEditable(kFALSE);
 281     fButtons->Draw();
 282     fButtons->SetFillColor(38);
 283     fButtons->SetBorderSize(2);
 284     fButtons->cd();
 285
 286     //   Int_t butcolor = 33;
 287     Float_t dbutton = 0.08;
 288     Float_t y  = 0.96;
 289     Float_t dy = 0.014;
 290     Float_t x0 = 0.05;
 291     Float_t x1 = 0.95;
 292
 293     TButton *button;
 294     char but1[] = "gAlice->Display()->ShowNextEvent(1)";
 295     button = new TButton("Next",but1,x0,y-dbutton,x1,y);
 296     button->SetFillColor(38);
 297     button->Draw();
 298
 299     y -= dbutton +dy;
 300     char but2[] = "gAlice->Display()->ShowNextEvent(-1)";
 301     button = new TButton("Previous",but2,x0,y-dbutton,x1,y);
 302     button->SetFillColor(38);
 303     button->Draw();
 304
 305     y -= dbutton +dy;
 306     char but7[] = "gAlice->Display()->DrawViewGL()";
 307     button = new TButton("OpenGL",but7,x0,y-dbutton,x1,y);
 308     button->SetFillColor(38);
 309     button->Draw();
 310
 311     y -= dbutton +dy;
 312     char but8[] = "gAlice->Display()->DrawViewX3D()";
 313     button = new TButton("X3D",but8,x0,y-dbutton,x1,y);
 314     button->SetFillColor(38);
 315     button->Draw();
 316
 317     // display logo
 318     TDiamond *diamond = new TDiamond(0.05,0.015,0.95,0.22);
 319     diamond->SetFillColor(50);
 320     diamond->SetTextAlign(22);
 321     diamond->SetTextColor(5);
 322     diamond->SetTextSize(0.11);
 323     diamond->Draw();
 324     diamond->AddText(".. ");
 325     diamond->AddText("ROOT");
 326     diamond->AddText("RICH");
 327     diamond->AddText("... ");
 328     diamond->AddText(" ");
 329 }
 330
 331 //_____________________________________________________________________________
 332 void AliRICHDisplay::CreateColors()
 333 {
 334 //    Create the colors palette used to display clusters
 335
 336     Int_t k,i;
 337     Int_t color;
 338     Float_t r,g,b;
 339
 340     for (k=1;k<=5;k++) {
 341         switch(k) {
 342         case 1:
 343             for (i=1;i<=5;i++) {
 344                 r=1.;
 345                 g=i*0.2;
 346                 b=0.;
 347                 color=i;
 348                 color=700+23-color;
 349                 new TColor(color,r,g,b);
 350             }
 351             break;
 352         case 2:
 353             for (i=1;i<=4;i++) {
 354                 r=1.1-i*0.2;
 355                 g=1.;
 356                 b=0.;
 357                 color=i+5;
 358                 color=700+23-color;
 359                 new TColor(color,r,g,b);
 360             }
 361             break;
 362     case 3:
 363         for (i=1;i<=4;i++) {
 364             r=0.;
 365             g=1.;
 366             b=i*0.2+0.2;
 367             color=i+9;
 368             color=700+23-color;
 369             new TColor(color,r,g,b);
 370         }
 371         break;
 372         case 4:
 373             for (i=1;i<=4;i++) {
 374                 r=0.;
 375                 g=1.1-i*0.2;
 376                 b=1.;
 377                 color=i+13;
 378                 color=700+23-color;
 379                 new TColor(color,r,g,b);
 380             }
 381             break;
 382         case 5:
 383             for (i=1;i<=5;i++) {
 384                 r=i*0.2;
 385                 g=0.;
 386                 b=1.;
 387                 color=i+17;
 388                 color=700+23-color;
 389                 new TColor(color,r,g,b);
 390             }
 391             break;
 392         }
 393     }
 394 }
 395
 396 //_____________________________________________________________________________
 397 void AliRICHDisplay::DisplayColorScale()
 398 {
 399
 400 // Draw the color scale in the RICH display canvas
 401
 402     Int_t i;
 403     Int_t color;
 404     Float_t xlow, ylow, xup, yup, hs;
 405     Float_t x1, y1, x2, y2;
 406     x1 = y1 = 0;
 407     x2 = y2 = 20;
 408
 409     gPad->SetFillColor(0);
 410     gPad->Clear();
 411     gPad->Range(x1,y1,x2,y2);
 412     TText *text = new TText(0,0,"");
 413     text->SetTextFont(61);
 414     text->SetTextSize(0.03);
 415     text->SetTextAlign(22);
 416
 417     TBox *box;
 418     char label[8];
 419 //*-* draw colortable boxes
 420     hs = (y2-y1)/Float_t(22);
 421     xlow=x1+1;
 422     xup=x2-9;
 423     for (i=0;i<22;i++) {
 424         ylow = y1 + hs*(Float_t(i));
 425         yup  = y1 + hs*(Float_t(i+1));
 426         color = 701+i;
 427         Double_t logscale=Double_t(i+1)*(TMath::Log(adc_satm)/22);
 428         Int_t scale=(Int_t)TMath::Exp(logscale);
 429         sprintf(label,"%d",scale);
 430         box = new TBox(xlow, ylow, xup, yup);
 431         box->SetFillColor(color);
 432         box->Draw();
 433         text->DrawText(xup+4, 0.5*(ylow+yup),label);
 434     }
 435 }
 436
 437 //______________________________________________________________________________
 438 Int_t AliRICHDisplay::DistancetoPrimitive(Int_t px, Int_t)
 439 {
 440 // Compute distance from point px,py to objects in event
 441
 442     gPad->SetCursor(kCross);
 443
 444     if (gPad == fTrigPad) return 9999;
 445
 446     const Int_t kBig = 9999;
 447     Int_t dist   = kBig;
 448     Float_t xmin = gPad->GetX1();
 449     Float_t xmax = gPad->GetX2();
 450     Float_t dx   = 0.02*(xmax - xmin);
 451     Float_t x    = gPad->AbsPixeltoX(px);
 452     if (x < xmin+dx || x > xmax-dx) return dist;
 453     if (fZoomMode) return 0;
 454     else           return 7;
 455 }
 456
 457 //_____________________________________________________________________________
 458 void AliRICHDisplay::Draw(Option_t *)
 459 {
 460 //    Display current event
 461
 462     fPad->cd();
 463
 464     DrawView(fTheta, fPhi, fPsi);      // see how to draw PGON+inner frames
 465
 466     // Display the event number and title
 467     fPad->cd();
 468     DrawTitle();
 469 }
 470
 471 //_____________________________________________________________________________
 472 void AliRICHDisplay::DrawCoG()
 473 {
 474 //    Draw hits for RICH chambers
 475
 476     if (!fDrawCoG) return;
 477     ResetRpoints();
 478     for (Int_t chamber=0;chamber<kNCH;chamber++) {
 479         LoadCoG(chamber,1);
 480     }
 481
 482     Int_t ncog, icog;
 483     TObjArray *points;
 484     AliRICHPoints *pm;
 485     points = fRpoints;
 486     if (!points) return;
 487     ncog = points->GetEntriesFast();
 488     for (icog=0; icog < ncog; icog++) {
 489         pm = (AliRICHPoints*)points->UncheckedAt(icog);
 490         if (!pm) continue;
 491         pm->Draw();
 492     }
 493 }
 494
 495 void AliRICHDisplay::DrawRecHits()
 496 {
 497 //    Draw rec hits for RICH chambers
 498
 499     if (!fDrawRecHits) return;
 500     //ResetRecpoints();
 501     for (Int_t chamber=0;chamber<kNCH;chamber++) {
 502         LoadRecHits(chamber,1);
 503     }
 504
 505     Int_t nrec, irec;
 506     TObjArray *points;
 507     AliRICHPoints *pm;
 508     points = fRecpoints;
 509     if (!points) return;
 510     nrec = points->GetEntriesFast();
 511     printf("Nrec %d\n",nrec);
 512     for (irec=0; irec < nrec; irec++) {
 513         pm = (AliRICHPoints*)points->UncheckedAt(irec);
 514         if (!pm) continue;
 515         pm->Draw();
 516     }
 517 }
 518
 519 //_____________________________________________________________________________
 520
 521 void AliRICHDisplay::DrawCerenkovs()
 522 {
 523 //    Draw cerenkovs hits for RICH chambers
 524
 525     LoadCerenkovs(fChamber);
 526     //printf("\nDrawCerenkovs\n");
 527
 528     Int_t ntracks, track;
 529     TObjArray *cpoints;
 530     AliRICHPoints *pm;
 531
 532     fHitsCuts = 0;
 533     cpoints = fPCerenkovs;
 534     //printf ("Cpoints: %p",cpoints);
 535     if (!cpoints) return;
 536     ntracks = cpoints->GetEntriesFast();
 537     //printf("DrawCerenkovs - ntracks %d \n",ntracks);
 538     for (track=0;track<ntracks;track++) {
 539         pm = (AliRICHPoints*)cpoints->UncheckedAt(track);
 540         if (!pm) continue;
 541         pm->Draw();
 542         fHitsCuts += pm->GetN();
 543     }
 544 }
 545
 546 //_____________________________________________________________________________
 547
 548 void AliRICHDisplay::DrawClusters()
 549 {
 550 //    Draw clusterss for RICH chambers
 551
 552     Int_t ndigits, digit;
 553     TObjArray *points;
 554     AliRICHPoints *pm;
 555
 556     fClustersCuts = 0;
 557     points = fPoints;
 558     if (!points) return;
 559     ndigits = points->GetEntriesFast();
 560     for (digit=0;digit<ndigits;digit++){
 561         pm = (AliRICHPoints*)points->UncheckedAt(digit);
 562         if (!pm) continue;
 563         pm->Draw();
 564         Float_t *pxyz;
 565         pxyz=pm->GetP();
 566         for (Int_t im=0;im<3;im++) {
 567             TMarker3DBox *marker=pm->GetMarker(im);
 568             if (marker)
 569                 marker->Draw();
 570         }
 571         fClustersCuts +=pm->GetN();
 572     }
 573 }
 574
 575 //_____________________________________________________________________________
 576 void AliRICHDisplay::DrawHits()
 577 {
 578 //    Draw hits for RICH chambers
 579
 580     LoadHits(fChamber);
 581
 582     Int_t ntracks, track;
 583     TObjArray *points;
 584     AliRICHPoints *pm;
 585
 586     fHitsCuts = 0;
 587     points = Phits();
 588     if (!fPhits) return;
 589 //    ntracks = points->GetEntriesFast();
 590     ntracks = fPhits->GetEntriesFast();
 591
 592     //printf("DrawHits - ntracks %d \n",ntracks);
 593     for (track=0;track<ntracks;track++) {
 594         pm = (AliRICHPoints*)fPhits->UncheckedAt(track);
 595         if (!pm) continue;
 596         pm->Draw();
 597         fHitsCuts += pm->GetN();
 598     }
 599 }
 600
 601
 602 //_____________________________________________________________________________
 603 void AliRICHDisplay::DrawTitle(Option_t *option)
 604 {
 605 //    Draw the event title
 606
 607     Float_t xmin = gPad->GetX1();
 608     Float_t xmax = gPad->GetX2();
 609     Float_t ymin = gPad->GetY1();
 610     Float_t ymax = gPad->GetY2();
 611     Float_t dx   = xmax-xmin;
 612     Float_t dy   = ymax-ymin;
 613
 614     if (strlen(option) == 0) {
 615         TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
 616         title->SetBit(kCanDelete);
 617         title->SetFillColor(42);
 618         title->Draw();
 619         char ptitle[100];
 620         sprintf(ptitle,"Alice event: %d, Run:%d",
 621                 gAlice->GetHeader()->GetEvent(), gAlice->GetHeader()->GetRun());
 622         title->AddText(ptitle);
 623         Int_t nparticles = gAlice->Particles()->GetEntriesFast();
 624         sprintf(ptitle,"Nparticles = %d Nhits = %d Npads fired = %d",
 625                 nparticles, fHitsCuts,fClustersCuts);
 626         title->AddText(ptitle);
 627     } else {
 628         TPaveLabel *label =
 629             new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
 630         label->SetBit(kCanDelete);
 631         label->SetFillColor(42);
 632         label->Draw();
 633     }
 634 }
 635
 636 //_____________________________________________________________________________
 637 void AliRICHDisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
 638 {
 639 //    Draw a view of RICH clusters
 640
 641    gPad->SetCursor(kWatch);
 642    gPad->SetFillColor(1);
 643    gPad->Clear();
 644
 645    Int_t iret;
 646    TView *view = new TView(1);
 647    Float_t range = fRrange*fRangeSlider->GetMaximum();
 648    view->SetRange(-range,-range,-range,range, range, range);
 649    fZoomX0[0] = -1;
 650    fZoomY0[0] = -1;
 651    fZoomX1[0] =  1;
 652    fZoomY1[0] =  1;
 653    fZooms = 0;
 654
 655    //Display RICH Chamber Geometry
 656    gAlice->GetGeometry()->Draw("same");
 657
 658    //add clusters to the pad
 659    DrawClusters();
 660    DrawHits();
 661 //   DrawCerenkovs();
 662    printf("Calling DrawCoG\n");
 663    DrawCoG();
 664    printf("Calling DrawRecHits\n");
 665    DrawRecHits();
 666    /*for (Int_t i=0;i<7;i++)
 667      LoadRecHits(i,1);*/
 668
 669    // add itself to the list (must be last)
 670    AppendPad();
 671
 672    view->SetView(phi, theta, psi, iret);
 673 }
 674
 675 //______________________________________________________________________________
 676 void AliRICHDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
 677 {
 678 //  Execute action corresponding to the mouse event
 679
 680     static Float_t x0, y0, x1, y1;
 681
 682    static Int_t pxold, pyold;
 683    static Int_t px0, py0;
 684    static Int_t linedrawn;
 685    Float_t temp;
 686
 687    if (px == 0 && py == 0) { //when called by sliders
 688        if (event == kButton1Up) {
 689            Draw();
 690        }
 691        return;
 692    }
 693    if (!fZoomMode && gPad->GetView()) {
 694        gPad->GetView()->ExecuteRotateView(event, px, py);
 695        return;
 696    }
 697
 698    // something to zoom ?
 699    gPad->SetCursor(kCross);
 700
 701    switch (event) {
 702
 703    case kButton1Down:
 704        gVirtualX->SetLineColor(-1);
 705        gPad->TAttLine::Modify();  //Change line attributes only if necessary
 706        x0 = gPad->AbsPixeltoX(px);
 707        y0 = gPad->AbsPixeltoY(py);
 708        px0   = px; py0   = py;
 709        pxold = px; pyold = py;
 710        linedrawn = 0;
 711        return;
 712
 713    case kButton1Motion:
 714        if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
 715        pxold = px;
 716        pyold = py;
 717        linedrawn = 1;
 718        gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
 719        return;
 720
 721    case kButton1Up:
 722        gPad->GetCanvas()->FeedbackMode(kFALSE);
 723        if (px == px0) return;
 724        if (py == py0) return;
 725        x1 = gPad->AbsPixeltoX(px);
 726        y1 = gPad->AbsPixeltoY(py);
 727
 728        if (x1 < x0) {temp = x0; x0 = x1; x1 = temp;}
 729        if (y1 < y0) {temp = y0; y0 = y1; y1 = temp;}
 730        gPad->Range(x0,y0,x1,y1);
 731        if (fZooms < kMAXZOOM-1) {
 732            fZooms++;
 733            fZoomX0[fZooms] = x0;
 734            fZoomY0[fZooms] = y0;
 735            fZoomX1[fZooms] = x1;
 736            fZoomY1[fZooms] = y1;
 737        }
 738        gPad->Modified(kTRUE);
 739        return;
 740    }
 741
 742 }
 743 //___________________________________________
 744 void AliRICHDisplay::LoadCoG(Int_t chamber, Int_t cathode)
 745 {
 746 // Read raw clusters info and store x,y,z info in arrays fRpoints
 747 // Loop on all detectors
 748
 749    if (chamber > 6) return;
 750
 751    printf("Entering LoadCoG\n");
 752
 753
 754    AliRICH *pRICH  = (AliRICH*)gAlice->GetModule("RICH");
 755    AliRICHChamber*  iChamber;
 756
 757    TClonesArray *pRICHrawclust  = pRICH->RawClustAddress(chamber);
 758    printf ("Chamber:%d has adress:%p\n", chamber, pRICHrawclust );
 759    if (pRICHrawclust == 0) return;
 760
 761    pRICH->ResetRawClusters();
 762
 763
 764    Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
 765    gAlice->TreeR()->GetEvent(nent-1+cathode-1);
 766    Int_t nrawcl = pRICHrawclust->GetEntriesFast();
 767    printf ("nrawcl:%d\n",nrawcl);
 768    if (nrawcl == 0) return;
 769    if (fRpoints == 0) fRpoints = new TObjArray(nrawcl);
 770
 771    iChamber = &(pRICH->Chamber(chamber));
 772    AliRICHRawCluster  *mRaw;
 773    AliRICHPoints *points = 0;
 774    //
 775    //loop over all raw clusters and store their position
 776    points = new AliRICHPoints(nrawcl);
 777    for (Int_t iraw=0;iraw<nrawcl;iraw++) {
 778        mRaw   = (AliRICHRawCluster*)pRICHrawclust->UncheckedAt(iraw);
 779        fRpoints->AddAt(points,iraw);
 780        points->SetMarkerColor(3);
 781        points->SetMarkerStyle(3);
 782        points->SetMarkerSize(1.);
 783        points->SetParticle(-1);
 784        points->SetHitIndex(-1);
 785        points->SetTrackIndex(-1);
 786        points->SetDigitIndex(-1);
 787        Float_t  vectorLoc[3]={mRaw->fX,6.276,mRaw->fY};
 788        Float_t  vectorGlob[3];
 789        iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
 790        points->SetPoint(iraw,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
 791    }
 792 }
 793 //___________________________________________
 794 void AliRICHDisplay::LoadRecHits(Int_t chamber, Int_t cathode)
 795 {
 796 // Read rec. hits info
 797 // Loop on all detectors
 798
 799    if (chamber > 6) return;
 800
 801    printf("Entering LoadRecHits\n");
 802
 803
 804    AliRICH *pRICH  = (AliRICH*)gAlice->GetModule("RICH");
 805    AliRICHChamber*  iChamber;
 806
 807    TClonesArray *pRICHrechits  = pRICH->RecHitsAddress(chamber);
 808    printf ("Chamber:%d\n", chamber);
 809    if (pRICHrechits == 0) return;
 810
 811    //RICH->ResetRecHits();
 812
 813
 814    Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
 815    gAlice->TreeR()->GetEvent(nent-1+cathode-1);
 816    Int_t nrechits = pRICHrechits->GetEntriesFast();
 817    printf ("nrechits:%d\n",nrechits);
 818    if (nrechits == 0) return;
 819    if (fRecpoints == 0) fRecpoints = new TObjArray(50);
 820
 821    iChamber = &(pRICH->Chamber(chamber));
 822    AliRICHRecHit  *mRec;
 823    AliRICHPoints *points = 0;
 824    //AliRICHEllipse *ellipse = 0;
 825    //
 826    //loop over all rechits and store their position
 827
 828    points = new AliRICHPoints(nrechits);
 829    for (Int_t irec=0;irec<nrechits;irec++) {
 830        mRec   = (AliRICHRecHit*)pRICHrechits->UncheckedAt(irec);
 831        fRecpoints->AddAt(points,irec);
 832        points->SetMarkerColor(38);
 833        points->SetMarkerStyle(8);
 834        points->SetMarkerSize(1.);
 835        points->SetParticle(-1);
 836        points->SetHitIndex(-1);
 837        points->SetTrackIndex(-1);
 838        points->SetDigitIndex(-1);
 839        Float_t  vectorLoc[3]={mRec->fX,6.276,mRec->fY};
 840        Float_t  vectorGlob[3];
 841        iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
 842        points->SetPoint(irec,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
 843        //Float_t theta = iChamber->GetRotMatrix()->GetTheta();
 844        //Float_t phi   = iChamber->GetRotMatrix()->GetPhi();
 845        //ellipse=new TEllipse(vectorGlob[0],vectorGlob[2],10,10,0,360,phi);
 846        printf("Generating ellipse %d\n",irec);
 847        AliRICHEllipse *ellipse=new AliRICHEllipse(mRec->fX,mRec->fY,mRec->fOmega,mRec->fTheta,mRec->fPhi,mRec->fEmissPoint);
 848        ellipse->CerenkovRingDrawing(chamber,irec);
 849        //ellipse->SetFillStyle(1001);
 850        ellipse->SetMarkerColor(38);
 851        ellipse->Draw();
 852        //marker->SetRefObject((TObject*)points);
 853        //points->Set3DMarker(0, marker);
 854    }
 855 }
 856 //___________________________________________
 857 void AliRICHDisplay::LoadDigits()
 858 {
 859 // Read digits info and store x,y,z info in arrays fPoints
 860 // Loop on all detectors
 861
 862    ResetPoints();
 863    AliRICH *pRICH  = (AliRICH*)gAlice->GetDetector("RICH");
 864    AliRICHChamber*       iChamber;
 865    AliRICHSegmentation*  segmentation;
 866    Int_t nAllDigits=0;
 867    Int_t ich;
 868
 869    for (ich=0; ich<kNCH; ich++) {
 870        TClonesArray *pRICHdigits  = pRICH->DigitsAddress(ich);
 871        if (pRICHdigits == 0) continue;
 872        gAlice->ResetDigits();
 873        gAlice->TreeD()->GetEvent(1);
 874        Int_t ndigits = pRICHdigits->GetEntriesFast();
 875         nAllDigits+=ndigits;
 876    }
 877    if (fPoints == 0) fPoints = new TObjArray(nAllDigits);
 878    Int_t counter=0;
 879    for (ich=0; ich<kNCH; ich++) {
 880        TClonesArray *pRICHdigits  = pRICH->DigitsAddress(ich);
 881        if (pRICHdigits == 0) continue;
 882        gAlice->ResetDigits();
 883        gAlice->TreeD()->GetEvent(1);
 884        Int_t ndigits = pRICHdigits->GetEntriesFast();
 885        if (ndigits == 0) continue;
 886        iChamber = &(pRICH->Chamber(ich));
 887        segmentation=iChamber->GetSegmentationModel();
 888        Float_t dpx  = segmentation->Dpx();
 889        Float_t dpy  = segmentation->Dpy();
 890
 891        //printf("Dpx:%d, Dpy:%d\n",dpx,dpy);
 892
 893        AliRICHDigit  *mdig;
 894        AliRICHPoints *points = 0;
 895        TMarker3DBox  *marker = 0;
 896        //
 897        //loop over all digits and store their position
 898        Int_t npoints=1;
 899
 900        for (Int_t digit=0;digit<ndigits;digit++) {
 901            mdig    = (AliRICHDigit*)pRICHdigits->UncheckedAt(digit);
 902            points = new AliRICHPoints(npoints);
 903            fPoints->AddAt(points,counter);
 904            counter++;
 905            Int_t charge=mdig->fSignal;
 906            Int_t index=Int_t(TMath::Log(charge)/(TMath::Log(adc_satm)/22));
 907            Int_t color=701+index;
 908            if (color>722) color=722;
 909            points->SetMarkerColor(color);
 910            points->SetMarkerStyle(21);
 911            points->SetMarkerSize(0.5);
 912            Float_t xpad, ypad;
 913            segmentation->GetPadCxy(mdig->fPadX, mdig->fPadY,xpad, ypad);
 914            Float_t vectorLoc[3]={xpad,6.276,ypad};
 915            Float_t  vectorGlob[3];
 916            iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
 917            points->SetParticle(-1);
 918            points->SetHitIndex(-1);
 919            points->SetTrackIndex(-1);
 920            points->SetDigitIndex(digit);
 921            points->SetPoint(0,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
 922
 923            segmentation->GetPadCxy(mdig->fPadX, mdig->fPadY, xpad, ypad);
 924            Float_t theta = iChamber->GetRotMatrix()->GetTheta();
 925            Float_t phi   = iChamber->GetRotMatrix()->GetPhi();
 926            marker=new TMarker3DBox(vectorGlob[0],vectorGlob[1],vectorGlob[2],
 927                                    dpy/2,0,dpx/2,theta,phi);
 928            marker->SetLineColor(2);
 929            marker->SetFillStyle(1001);
 930            marker->SetFillColor(color);
 931            marker->SetRefObject((TObject*)points);
 932            points->Set3DMarker(0, marker);
 933        } // loop over digits
 934    } // loop over chambers
 935 }
 936
 937
 938 //___________________________________________
 939 void AliRICHDisplay::LoadHits(Int_t chamber)
 940 {
 941 // Read hits info and store x,y,z info in arrays fPhits
 942 // Loop on all detectors
 943
 944
 945     fChamber=chamber;
 946     ResetPhits();
 947
 948     AliRICH *pRICH  = (AliRICH*)gAlice->GetDetector("RICH");
 949     AliRICHChamber*  iChamber;
 950
 951     iChamber = &(pRICH->Chamber(chamber-1));
 952     Int_t ntracks = (Int_t)gAlice->TreeH()->GetEntries();
 953     Int_t track;
 954
 955     if (fPhits == 0) fPhits = new TObjArray(ntracks);
 956     //TVector *xp = new TVector(1000);
 957     //TVector *yp = new TVector(1000);
 958     //TVector *zp = new TVector(1000);
 959     //TVector *ptrk = new TVector(1000);
 960     //TVector *phit = new TVector(1000);
 961     Int_t nAllHits=0;
 962     for (track=0; track<ntracks;track++) {
 963         gAlice->ResetHits();
 964         gAlice->TreeH()->GetEvent(track);
 965         TClonesArray *pRICHhits  = pRICH->Hits();
 966         if (pRICHhits == 0) return;
 967         Int_t nhits = pRICHhits->GetEntriesFast();
 968         nAllHits+=nhits;
 969     }
 970
 971     fPhits = new TObjArray(nAllHits);
 972
 973     Int_t npoints=0;
 974     for (track=0; track<ntracks;track++) {
 975         gAlice->ResetHits();
 976         gAlice->TreeH()->GetEvent(track);
 977         TClonesArray *pRICHhits  = pRICH->Hits();
 978         if (pRICHhits == 0) return;
 979         Int_t nhits = pRICHhits->GetEntriesFast();
 980         if (nhits == 0) continue;
 981         AliRICHHit *mHit;
 982         AliRICHPoints *points = 0;
 983         for (Int_t hit=0;hit<nhits;hit++) {
 984             points = new AliRICHPoints(1);
 985             fPhits->AddAt(points,npoints);
 986             mHit = (AliRICHHit*)pRICHhits->UncheckedAt(hit);
 987             TParticle *current =
 988                 (TParticle*)(*gAlice->Particles())[mHit->fTrack];
 989             if (current->GetPdgCode() == 50000050) {
 990                 points->SetMarkerColor(kBlue);
 991             } else if (current->GetPdgCode() == 50000051) {
 992                 points->SetMarkerColor(kYellow);
 993             } else {
 994                 points->SetMarkerColor(kRed);
 995             }
 996             points->SetMarkerStyle(5);
 997             points->SetMarkerSize(1.);
 998             points->SetParticle(mHit->fTrack);
 999             points->SetHitIndex(hit);
1000             points->SetTrackIndex(track);
1001             points->SetDigitIndex(-1);
1002             points->SetPoint(hit,mHit->fX, mHit->fY, mHit->fZ);
1003             npoints++;
1004         }
1005     }
1006 }
1007
1008 //_____________________________________________________________________________
1009
1010 void AliRICHDisplay::LoadCerenkovs(Int_t chamber)
1011 {
1012 // Read cerenkov hits info and store x,y,z info in array fPCerenkovs
1013 // Loop on all detectors
1014
1015     fChamber=chamber;
1016     ResetPCerenkovs();
1017
1018     AliRICH *pRICH  = (AliRICH*)gAlice->GetDetector("RICH");
1019     AliRICHChamber*  iChamber;
1020
1021     iChamber = &(pRICH->Chamber(chamber-1));
1022
1023     pRICH->SetTreeAddress();
1024     Int_t ntracks = (Int_t)gAlice->TreeH()->GetEntries();
1025
1026     if (fPCerenkovs == 0) fPCerenkovs = new TObjArray(ntracks);
1027     TVector *xp = new TVector(1000);
1028     TVector *yp = new TVector(1000);
1029     TVector *zp = new TVector(1000);
1030     TVector *ptrk = new TVector(1000);
1031     TVector *phit = new TVector(1000);
1032     for (Int_t track=0; track<ntracks;track++) {
1033         gAlice->ResetHits();
1034         gAlice->TreeH()->GetEvent(track);
1035         TClonesArray *pRICHCerenkovs  = pRICH->Cerenkovs();
1036         if (pRICHCerenkovs == 0) return;
1037         Int_t nhits = pRICHCerenkovs->GetEntriesFast();
1038         if (nhits == 0) continue;
1039         AliRICHCerenkov *mCerenkov;
1040         AliRICHPoints *cpoints = 0;
1041         Int_t npoints=0;
1042
1043
1044 //Display Cerenkov hits in blue
1045
1046         for (Int_t hit=0;hit<nhits;hit++) {
1047             mCerenkov = (AliRICHCerenkov*)pRICHCerenkovs->UncheckedAt(hit);
1048             (*xp)(npoints)=mCerenkov->fX;
1049             (*yp)(npoints)=mCerenkov->fY;
1050             (*zp)(npoints)=mCerenkov->fZ;
1051             (*ptrk)(npoints)=Float_t(mCerenkov->GetTrack());
1052             (*phit)(npoints)=Float_t(hit);
1053             npoints++;
1054         }
1055         if (npoints == 0) continue;
1056         cpoints = new AliRICHPoints(npoints);
1057         for (Int_t p=0;p<npoints;p++) {
1058             cpoints->SetMarkerColor(kBlue);
1059             cpoints->SetMarkerStyle(5);
1060             cpoints->SetMarkerSize(1.);
1061             cpoints->SetParticle(Int_t((*ptrk)(p)));
1062             cpoints->SetHitIndex(Int_t((*phit)(p)));
1063             cpoints->SetTrackIndex(track);
1064             cpoints->SetDigitIndex(-1);
1065             cpoints->SetPoint(p,(*xp)(p),(*yp)(p),(*zp)(p));
1066         }
1067         xp->Zero();
1068         yp->Zero();
1069         ptrk->Zero();
1070         phit->Zero();
1071         fPCerenkovs->AddAt(cpoints,track);
1072     }
1073 }
1074
1075 //_____________________________________________________________________________
1076 void AliRICHDisplay::Paint(Option_t *)
1077 {
1078 //    Paint miscellaneous items
1079
1080 }
1081
1082 //_____________________________________________________________________________
1083 void AliRICHDisplay::SetPickMode()
1084 {
1085
1086 // Toggle pick mode
1087
1088     fZoomMode = 0;
1089
1090     fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
1091     fTrigPad->Modified();
1092 }
1093
1094 //_____________________________________________________________________________
1095 void AliRICHDisplay::SetZoomMode()
1096 {
1097
1098 // Toggle Zoom mode
1099
1100     fZoomMode = 1;
1101
1102     fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
1103     fTrigPad->Modified();
1104 }
1105
1106 //_____________________________________________________________________________
1107 void AliRICHDisplay::SetChamberAndCathode(Int_t chamber, Int_t cathode)
1108 {
1109 // Set chamber and cathode number
1110     fChamber = chamber;
1111     fCathode = cathode;
1112
1113     printf("SetChamberAndCathode - fChamber fCathode %d %d\n",fChamber,fCathode);
1114     if (!fPad) return;
1115     fPad->Clear();
1116     LoadDigits();
1117     Draw();
1118 }
1119
1120 //_____________________________________________________________________________
1121 void AliRICHDisplay::SetRange(Float_t rrange, Float_t zrange)
1122 {
1123 // Set view range along R and Z
1124     fRrange = rrange;
1125     fZrange = zrange;
1126
1127    if (!fPad) return;
1128    fPad->Clear();
1129    Draw();
1130 }
1131
1132 //_____________________________________________________________________________
1133 void AliRICHDisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
1134 {
1135 //  change viewing angles for current event
1136
1137     fPad->cd();
1138     fPhi   = phi;
1139     fTheta = theta;
1140     fPsi   = psi;
1141     Int_t iret = 0;
1142
1143     TView *view = gPad->GetView();
1144     if (view) view->SetView(fPhi, fTheta, fPsi, iret);
1145     else      Draw();
1146
1147     gPad->Modified();
1148 }
1149
1150 //_____________________________________________________________________________
1151 void AliRICHDisplay::ShowNextEvent(Int_t delta)
1152 {
1153 //  Display (current event_number+delta)
1154 //    delta =  1  shown next event
1155 //    delta = -1 show previous event
1156
1157     if (delta) {
1158         gAlice->Clear();
1159         Int_t currentEvent = gAlice->GetHeader()->GetEvent();
1160         Int_t newEvent     = currentEvent + delta;
1161         gAlice->GetEvent(newEvent);
1162         if (!gAlice->TreeD()) return;
1163     }
1164     LoadDigits();
1165     DrawClusters();
1166     fPad->cd();
1167     Draw();
1168
1169
1170 }
1171
1172 //______________________________________________________________________________
1173 void AliRICHDisplay::UnZoom()
1174 {
1175
1176 // Return to previous zoom factor
1177
1178     if (fZooms <= 0) return;
1179     fZooms--;
1180     TPad *pad = (TPad*)gPad->GetPadSave();
1181     pad->Range(fZoomX0[fZooms],fZoomY0[fZooms], fZoomX1[fZooms],fZoomY1[fZooms]);
1182     pad->Modified();
1183 }
1184
1185 //_____________________________________________________________________________
1186 void AliRICHDisplay::ResetPoints()
1187 {
1188     //
1189     // Reset array of points
1190     //
1191     if (fPoints) {
1192         fPoints->Delete();
1193         delete fPoints;
1194         fPoints = 0;
1195   }
1196 }
1197 //_____________________________________________________________________________
1198 void AliRICHDisplay::ResetRpoints()
1199 {
1200   //
1201   // Reset array of points
1202   //
1203   if (fRpoints) {
1204     fRpoints->Delete();
1205     delete fRpoints;
1206     fRpoints = 0;
1207   }
1208 }
1209 //_____________________________________________________________________________
1210 void AliRICHDisplay::ResetRecpoints()
1211 {
1212   //
1213   // Reset array of points
1214   //
1215   if (fRecpoints) {
1216     fRecpoints->Delete();
1217     delete fRecpoints;
1218     fRecpoints = 0;
1219   }
1220 }
1221 //_____________________________________________________________________________
1222 void AliRICHDisplay::ResetPhits()
1223 {
1224     //
1225     // Reset array of points
1226     //
1227     if (fPhits) {
1228         fPhits->Delete();
1229         delete fPhits;
1230         fPhits = 0;
1231     }
1232 }
1233 //_____________________________________________________________________________
1234 void AliRICHDisplay::ResetPCerenkovs()
1235 {
1236     //
1237     // Reset array of points
1238     //
1239     if (fPCerenkovs) {
1240         fPCerenkovs->Delete();
1241         delete fPCerenkovs;
1242         fPCerenkovs = 0;
1243     }
1244 }
1245
1246 //_____________________________________________________________________________
1247
1248 void AliRICHDisplay::DrawViewGL()
1249 {
1250 //    Draw current view using OPENGL
1251
1252    TPad *pad = (TPad*)gPad->GetPadSave();
1253    pad->cd();
1254    TView *view = pad->GetView();
1255    if (!view) return;
1256    pad->x3d("OPENGL");
1257 }
1258
1259 //_____________________________________________________________________________
1260 void AliRICHDisplay::DrawViewX3D()
1261 {
1262 //    Draw current view using X3D
1263
1264    TPad *pad = (TPad*)gPad->GetPadSave();
1265    pad->cd();
1266    TView *view = pad->GetView();
1267    if (!view) return;
1268    pad->x3d();
1269 }