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.5  1999/09/29 09:24:29  fca
  19 Introduction of the Copyright and cvs Log
  20
  21 */
  22
  23
  24 //////////////////////////////////////////////////////////////////////////
  25 //                                                                      //
  26 // AliDisplay                                                           //
  27 //                                                                      //
  28 // Utility class to display ALICE outline, tracks, hits,..              //
  29 //                                                                      //
  30 //////////////////////////////////////////////////////////////////////////
  31
  32 #include <TROOT.h>
  33 #include <TTree.h>
  34 #include <TButton.h>
  35 #include <TColor.h>
  36 #include <TCanvas.h>
  37 #include <TView.h>
  38 #include <TText.h>
  39 #include <TPolyMarker3D.h>
  40 #include <TPolyMarker.h>
  41 #include <TPaveLabel.h>
  42 #include <TPaveText.h>
  43 #include <TList.h>
  44 #include <TDiamond.h>
  45 #include <TNode.h>
  46 #include <TArc.h>
  47 #include <TTUBE.h>
  48 #include <TSlider.h>
  49 #include <TSliderBox.h>
  50 #include <TGaxis.h>
  51 #include <TVirtualX.h>
  52 #include <TMath.h>
  53 #include <X3DBuffer.h>
  54
  55 #include "AliRun.h"
  56 #include "AliDetector.h"
  57 #include "AliRICH.h"
  58 #include "AliRICHConst.h"
  59 #include "AliRICHdisplay.h"
  60 #include "AliRICHpoints.h"
  61 #include "TParticle.h"
  62
  63
  64 ClassImp(AliRICHdisplay)
  65
  66
  67 //____________________________________________________________________________
  68 AliRICHdisplay::AliRICHdisplay()
  69 {
  70     fPoints = 0;
  71     fPhits = 0;
  72     fPCerenkovs = 0;
  73     fCanvas = 0;
  74 }
  75
  76 //_____________________________________________________________________________
  77 AliRICHdisplay::AliRICHdisplay(Int_t size)
  78 {
  79 // Create an event display object.
  80 // A canvas named "edisplay" is created with a vertical size in pixels
  81 //
  82 //    A QUICK Overview of the Event Display functions
  83 //    ===============================================
  84 //
  85 //  The event display can ve invoked by executing the macro "display.C"
  86 // A canvas like in the picture below will appear.
  87 //
  88 //  On the left side of the canvas, the following buttons appear:
  89 //   *Next*       to move to the next event
  90 //   *Previous*   to move to the previous event
  91
  92 //   *Pick*       Select this option to be able to point on a track with the
  93 //                mouse. Once on the track, use the right button to select
  94 //                an action. For example, select SetMarkerAttributes to
  95 //                change the marker type/color/size for the track.
  96 //   *Zoom*       Select this option (default) if you want to zoom.
  97 //                To zoom, simply select the selected area with the left button.
  98 //   *UnZoom*     To revert to the previous picture size.
  99 //
 100 //   slider R     On the left side, the vertical slider can be used to
 101 //                set the default picture size.
 102 //
 103 //    When you are in Zoom mode, you can click on the black part of the canvas
 104 //  to select special options with the right mouse button.
 105
 106 //
 107 //  When you are in pick mode, you can "Inspect" the object pointed by the mouse.
 108 //  When you are on a track, select the menu item "InspectParticle"
 109 //  to display the current particle attributes.
 110 //
 111 //  You can activate the Root browser by selecting the Inspect menu
 112 //  in the canvas tool bar menu. Then select "Start Browser"
 113 //  This will open a new canvas with the browser. At this point, you may want
 114 //  to display some histograms (from the Trees). Go to the "File" menu
 115 //  of the browser and click on "New canvas".
 116 //  In the browser, click on item "ROOT files" in the left pane.
 117 //  Click on galice.root.
 118 //  Click on TH
 119 //  Click on TPC for example
 120 //  Click on any variable (eg TPC.fX) to histogram the variable.
 121 //
 122 //   If you are lost, you can click on HELP in any Root canvas or browser.
 123 //Begin_Html
 124 /*
 125   <img src="gif/aliRICHdisplay.gif">
 126 */
 127 //End_Html
 128
 129
 130     fPad = 0;
 131
 132     gAlice->SetDisplay(this);
 133
 134     // Initialize display default parameters
 135     SetRange();
 136
 137     // Set front view by default
 138     fTheta = 90;
 139     fPhi   = 90;
 140     fPsi   = 0;
 141     fChamber = 1;
 142     fCathode = 1;
 143     //   fRzone   = 1.e10;
 144     fDrawClusters  = kTRUE;
 145     fZoomMode      = 1;
 146     fZooms         = 0;
 147     fClustersCuts  = 0;
 148     fPoints        = 0;
 149     fPCerenkovs    = 0;
 150     fPhits         = 0;
 151     // Create colors
 152     CreateColors();
 153     // Create display canvas
 154     Int_t ysize = size;
 155     if (ysize < 100) ysize = 750;
 156     Int_t xsize = Int_t(size*830./ysize);
 157     fCanvas = new TCanvas("Canvas", "RICH Clusters Display",14,47,xsize,ysize);
 158     fCanvas->SetEditable(kFALSE);
 159     fCanvas->ToggleEventStatus();
 160
 161     // Create main display pad
 162     fPad = new TPad("viewpad", "RICH display",0.15,0,0.9,1);
 163     fPad->Draw();
 164     fPad->Modified();
 165     fPad->SetFillColor(1);
 166     fPad->SetBorderSize(2);
 167
 168     fCanvas->cd();
 169
 170     // Create colors pad
 171     fColPad = new TPad("colpad", "Colors pad",0.9,0,1,1);
 172     fColPad->Draw();
 173     fColPad->Modified();
 174     fColPad->SetFillColor(19);
 175     fColPad->SetBorderSize(2);
 176     fColPad->cd();
 177     DisplayColorScale();
 178
 179     fCanvas->cd();
 180
 181     // Create user interface control pad
 182     DisplayButtons();
 183     fCanvas->cd();
 184
 185     // Create Range and mode pad
 186     Float_t dxtr     = 0.15;
 187     Float_t dytr     = 0.45;
 188     fTrigPad = new TPad("trigger", "range and mode pad",0,0,dxtr,dytr);
 189     fTrigPad->Draw();
 190     fTrigPad->cd();
 191     fTrigPad->SetFillColor(22);
 192     fTrigPad->SetBorderSize(2);
 193     fRangeSlider = new TSlider("range","range",0.7,0.42,0.9,0.98);
 194     fRangeSlider->SetObject(this);
 195     char pickmode[] = "gAlice->Display()->SetPickMode()";
 196     Float_t db = 0.09;
 197     fPickButton = new TButton("Pick",pickmode,0.05,0.32,0.65,0.32+db);
 198     fPickButton->SetFillColor(38);
 199     fPickButton->Draw();
 200     char zoommode[] = "gAlice->Display()->SetZoomMode()";
 201     fZoomButton = new TButton("Zoom",zoommode,0.05,0.21,0.65,0.21+db);
 202     fZoomButton->SetFillColor(38);
 203     fZoomButton->Draw();
 204     fArcButton = new TArc(.8,fZoomButton->GetYlowNDC()+0.5*db,0.33*db);
 205     fArcButton->SetFillColor(kGreen);
 206     fArcButton->Draw();
 207     char butUnzoom[] = "gAlice->Display()->UnZoom()";
 208     TButton *button = new TButton("UnZoom",butUnzoom,0.05,0.05,0.95,0.15);
 209     button->SetFillColor(38);
 210     button->Draw();
 211     AppendPad(); // append display object as last object to force selection
 212
 213     fCanvas->cd();
 214     fCanvas->Update();
 215 }
 216
 217
 218 //_____________________________________________________________________________
 219 AliRICHdisplay::~AliRICHdisplay()
 220 {
 221     // Delete space point structure
 222     if (fPoints) fPoints->Delete();
 223     delete fPoints;
 224     fPoints     = 0;
 225     //
 226     if (fPhits) fPhits->Delete();
 227     delete fPhits;
 228     fPhits     = 0;
 229     //
 230     if (fPCerenkovs) fPCerenkovs->Delete();
 231     delete fPCerenkovs;
 232     fPCerenkovs     = 0;
 233 }
 234
 235 //_____________________________________________________________________________
 236 void AliRICHdisplay::Clear(Option_t *)
 237 {
 238 //    Delete graphics temporary objects
 239 }
 240
 241 //_____________________________________________________________________________
 242 void AliRICHdisplay::DisplayButtons()
 243 {
 244 //    Create the user interface buttons
 245
 246
 247     fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
 248     fButtons->Draw();
 249     fButtons->SetFillColor(38);
 250     fButtons->SetBorderSize(2);
 251     fButtons->cd();
 252
 253     //   Int_t butcolor = 33;
 254     Float_t dbutton = 0.08;
 255     Float_t y  = 0.96;
 256     Float_t dy = 0.014;
 257     Float_t x0 = 0.05;
 258     Float_t x1 = 0.95;
 259
 260     TButton *button;
 261     char but1[] = "gAlice->Display()->ShowNextEvent(1)";
 262     button = new TButton("Next",but1,x0,y-dbutton,x1,y);
 263     button->SetFillColor(38);
 264     button->Draw();
 265
 266     y -= dbutton +dy;
 267     char but2[] = "gAlice->Display()->ShowNextEvent(-1)";
 268     button = new TButton("Previous",but2,x0,y-dbutton,x1,y);
 269     button->SetFillColor(38);
 270     button->Draw();
 271
 272     // display logo
 273     TDiamond *diamond = new TDiamond(0.05,0.015,0.95,0.22);
 274     diamond->SetFillColor(50);
 275     diamond->SetTextAlign(22);
 276     diamond->SetTextColor(5);
 277     diamond->SetTextSize(0.11);
 278     diamond->Draw();
 279     diamond->AddText(".. ");
 280     diamond->AddText("ROOT");
 281     diamond->AddText("RICH");
 282     diamond->AddText("... ");
 283     diamond->AddText(" ");
 284 }
 285
 286 //_____________________________________________________________________________
 287 void AliRICHdisplay::CreateColors()
 288 {
 289 //    Create the colors palette used to display clusters
 290
 291     Int_t k,i;
 292     Int_t color;
 293     Float_t r,g,b;
 294
 295     for (k=1;k<=5;k++) {
 296         switch(k) {
 297         case 1:
 298             for (i=1;i<=5;i++) {
 299                 r=1.;
 300                 g=i*0.2;
 301                 b=0.;
 302                 color=i;
 303                 color=50+23-color;
 304                 new TColor(color,r,g,b);
 305             }
 306             break;
 307         case 2:
 308             for (i=1;i<=4;i++) {
 309                 r=1.1-i*0.2;
 310                 g=1.;
 311                 b=0.;
 312                 color=i+5;
 313                 color=50+23-color;
 314                 new TColor(color,r,g,b);
 315             }
 316             break;
 317     case 3:
 318         for (i=1;i<=4;i++) {
 319             r=0.;
 320             g=1.;
 321             b=i*0.2+0.2;
 322             color=i+9;
 323             color=50+23-color;
 324             new TColor(color,r,g,b);
 325         }
 326         break;
 327         case 4:
 328             for (i=1;i<=4;i++) {
 329                 r=0.;
 330                 g=1.1-i*0.2;
 331                 b=1.;
 332                 color=i+13;
 333                 color=50+23-color;
 334                 new TColor(color,r,g,b);
 335             }
 336             break;
 337         case 5:
 338             for (i=1;i<=5;i++) {
 339                 r=i*0.2;
 340                 g=0.;
 341                 b=1.;
 342                 color=i+17;
 343                 color=50+23-color;
 344                 new TColor(color,r,g,b);
 345             }
 346             break;
 347         }
 348
 349     }
 350
 351 }
 352
 353 //_____________________________________________________________________________
 354 void AliRICHdisplay::DisplayColorScale()
 355 {
 356
 357     Int_t i;
 358     Int_t color;
 359     Float_t xlow, ylow, xup, yup, hs;
 360     Float_t x1, y1, x2, y2;
 361     x1 = y1 = 0;
 362     x2 = y2 = 20;
 363
 364     gPad->SetFillColor(0);
 365     gPad->Clear();
 366     gPad->Range(x1,y1,x2,y2);
 367     TText *text = new TText(0,0,"");
 368     text->SetTextFont(61);
 369     text->SetTextSize(0.03);
 370     text->SetTextAlign(22);
 371
 372     TBox *box;
 373     char label[8];
 374 //*-* draw colortable boxes
 375     hs = (y2-y1)/Float_t(22);
 376     xlow=x1+1;
 377     xup=x2-9;
 378     for (i=0;i<22;i++) {
 379         ylow = y1 + hs*(Float_t(i));
 380         yup  = y1 + hs*(Float_t(i+1));
 381         color = 51+i;
 382         Double_t logscale=Double_t(i+1)*(TMath::Log(adc_satm)/22);
 383         Int_t scale=(Int_t)TMath::Exp(logscale);
 384         sprintf(label,"%d",scale);
 385         box = new TBox(xlow, ylow, xup, yup);
 386         box->SetFillColor(color);
 387         box->Draw();
 388         text->DrawText(xup+4, 0.5*(ylow+yup),label);
 389     }
 390 }
 391
 392 //______________________________________________________________________________
 393 Int_t AliRICHdisplay::DistancetoPrimitive(Int_t px, Int_t)
 394 {
 395 // Compute distance from point px,py to objects in event
 396
 397     gPad->SetCursor(kCross);
 398
 399     if (gPad == fTrigPad) return 9999;
 400
 401     const Int_t big = 9999;
 402     Int_t dist   = big;
 403     Float_t xmin = gPad->GetX1();
 404     Float_t xmax = gPad->GetX2();
 405     Float_t dx   = 0.02*(xmax - xmin);
 406     Float_t x    = gPad->AbsPixeltoX(px);
 407     if (x < xmin+dx || x > xmax-dx) return dist;
 408
 409     if (fZoomMode) return 0;
 410     else           return 7;
 411 }
 412
 413 //_____________________________________________________________________________
 414 void AliRICHdisplay::Draw(Option_t *)
 415 {
 416 //    Display current event
 417
 418     fPad->cd();
 419
 420     DrawView(fTheta, fPhi, fPsi);      // see how to draw PGON+inner frames
 421
 422     // Display the event number and title
 423     fPad->cd();
 424     DrawTitle();
 425 }
 426
 427
 428 //_____________________________________________________________________________
 429
 430 void AliRICHdisplay::DrawCerenkovs()
 431 {
 432 //    Draw cerenkovs hits for RICH chambers
 433
 434     LoadCerenkovs(fChamber);
 435     printf("\nDrawCerenkovs\n");
 436
 437     Int_t ntracks, track;
 438     TObjArray *cpoints;
 439     AliRICHpoints *pm;
 440
 441     fHitsCuts = 0;
 442     cpoints = fPCerenkovs;
 443     printf ("Cpoints: %p",cpoints);
 444     if (!cpoints) return;
 445     ntracks = cpoints->GetEntriesFast();
 446     printf("DrawCerenkovs - ntracks %d \n",ntracks);
 447     for (track=0;track<ntracks;track++) {
 448         pm = (AliRICHpoints*)cpoints->UncheckedAt(track);
 449         if (!pm) continue;
 450         pm->Draw();
 451         fHitsCuts += pm->GetN();
 452     }
 453 }
 454
 455 //_____________________________________________________________________________
 456 void AliRICHdisplay::DrawClusters()
 457 {
 458 //    Draw clusterss for RICH chambers
 459
 460     Int_t ndigits, digit;
 461     TObjArray *points;
 462     AliRICHpoints *pm;
 463
 464     fClustersCuts = 0;
 465     points = fPoints;
 466     if (!points) return;
 467     ndigits = points->GetEntriesFast();
 468     printf("DrawClusters - ndigits %d \n",ndigits);
 469     for (digit=0;digit<ndigits;digit++){
 470         pm = (AliRICHpoints*)points->UncheckedAt(digit);
 471         if (!pm) continue;
 472         pm->Draw();
 473         fClustersCuts +=pm->GetN();
 474     }
 475 }
 476
 477 //_____________________________________________________________________________
 478 void AliRICHdisplay::DrawHits()
 479 {
 480 //    Draw hits for RICH chambers
 481
 482     LoadHits(fChamber);
 483
 484     Int_t ntracks, track;
 485     TObjArray *points;
 486     AliRICHpoints *pm;
 487
 488     fHitsCuts = 0;
 489     points = Phits();
 490     if (!points) return;
 491     ntracks = points->GetEntriesFast();
 492     printf("DrawHits - ntracks %d \n",ntracks);
 493     for (track=0;track<ntracks;track++) {
 494         pm = (AliRICHpoints*)points->UncheckedAt(track);
 495         if (!pm) continue;
 496         pm->Draw();
 497         fHitsCuts += pm->GetN();
 498     }
 499 }
 500
 501
 502 //_____________________________________________________________________________
 503 void AliRICHdisplay::DrawTitle(Option_t *option)
 504 {
 505 //    Draw the event title
 506
 507     Float_t xmin = gPad->GetX1();
 508     Float_t xmax = gPad->GetX2();
 509     Float_t ymin = gPad->GetY1();
 510     Float_t ymax = gPad->GetY2();
 511     Float_t dx   = xmax-xmin;
 512     Float_t dy   = ymax-ymin;
 513
 514     if (strlen(option) == 0) {
 515         TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
 516         title->SetBit(kCanDelete);
 517         title->SetFillColor(42);
 518         title->Draw();
 519         char ptitle[100];
 520         sprintf(ptitle,"Alice event: %d, Run:%d",gAlice->GetHeader()->GetEvent(), gAlice->GetHeader()->GetRun());
 521         title->AddText(ptitle);
 522         Int_t nparticles = gAlice->Particles()->GetEntriesFast();
 523         sprintf(ptitle,"Nparticles = %d Nhits = %d Npads fired = %d",nparticles, fHitsCuts,fClustersCuts);
 524         title->AddText(ptitle);
 525     } else {
 526         TPaveLabel *label = new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
 527         label->SetBit(kCanDelete);
 528         label->SetFillColor(42);
 529         label->Draw();
 530     }
 531 }
 532
 533 //_____________________________________________________________________________
 534 void AliRICHdisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
 535 {
 536 //    Draw a view of RICH clusters
 537
 538    gPad->SetCursor(kWatch);
 539    gPad->SetFillColor(1);
 540    gPad->Clear();
 541
 542    Int_t iret;
 543    TView *view = new TView(1);
 544    Float_t range = fRrange*fRangeSlider->GetMaximum();
 545    view->SetRange(-range,-range,-range,range, range, range);
 546    fZoomX0[0] = -1;
 547    fZoomY0[0] = -1;
 548    fZoomX1[0] =  1;
 549    fZoomY1[0] =  1;
 550    fZooms = 0;
 551
 552    //Display RICH Chamber Geometry
 553    gAlice->GetGeometry()->Draw("same");
 554
 555    //add clusters to the pad
 556    DrawClusters();
 557    DrawHits();
 558    DrawCerenkovs();
 559
 560    // add itself to the list (must be last)
 561    AppendPad();
 562
 563    view->SetView(phi, theta, psi, iret);
 564 }
 565
 566
 567 //______________________________________________________________________________
 568 void AliRICHdisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
 569 {
 570 //  Execute action corresponding to the mouse event
 571
 572     static Float_t x0, y0, x1, y1;
 573
 574    static Int_t pxold, pyold;
 575    static Int_t px0, py0;
 576    static Int_t linedrawn;
 577    Float_t temp;
 578
 579    if (px == 0 && py == 0) { //when called by sliders
 580        if (event == kButton1Up) {
 581            Draw();
 582        }
 583        return;
 584    }
 585    if (!fZoomMode && gPad->GetView()) {
 586        gPad->GetView()->ExecuteRotateView(event, px, py);
 587        return;
 588    }
 589
 590    // something to zoom ?
 591    gPad->SetCursor(kCross);
 592
 593    switch (event) {
 594
 595    case kButton1Down:
 596        gVirtualX->SetLineColor(-1);
 597        gPad->TAttLine::Modify();  //Change line attributes only if necessary
 598        x0 = gPad->AbsPixeltoX(px);
 599        y0 = gPad->AbsPixeltoY(py);
 600        px0   = px; py0   = py;
 601        pxold = px; pyold = py;
 602        linedrawn = 0;
 603        return;
 604
 605    case kButton1Motion:
 606        if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
 607        pxold = px;
 608        pyold = py;
 609        linedrawn = 1;
 610        gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
 611        return;
 612
 613    case kButton1Up:
 614        gPad->GetCanvas()->FeedbackMode(kFALSE);
 615        if (px == px0) return;
 616        if (py == py0) return;
 617        x1 = gPad->AbsPixeltoX(px);
 618        y1 = gPad->AbsPixeltoY(py);
 619
 620        if (x1 < x0) {temp = x0; x0 = x1; x1 = temp;}
 621        if (y1 < y0) {temp = y0; y0 = y1; y1 = temp;}
 622        gPad->Range(x0,y0,x1,y1);
 623        if (fZooms < kMAXZOOM-1) {
 624            fZooms++;
 625            fZoomX0[fZooms] = x0;
 626            fZoomY0[fZooms] = y0;
 627            fZoomX1[fZooms] = x1;
 628            fZoomY1[fZooms] = y1;
 629        }
 630        gPad->Modified(kTRUE);
 631        return;
 632    }
 633
 634 }
 635
 636 //___________________________________________
 637 void AliRICHdisplay::LoadDigits()
 638 {
 639 // Read digits info and store x,y,z info in arrays fPoints
 640 // Loop on all detectors
 641
 642     printf("Entering Load-digits");
 643
 644
 645    ResetPoints();
 646    AliRICH *RICH  = (AliRICH*)gAlice->GetDetector("RICH");
 647    AliRICHchamber*       iChamber;
 648    AliRICHsegmentation*  segmentation;
 649    Int_t NallDigits=0;
 650    Int_t ich;
 651
 652    for (ich=0; ich<7; ich++) {
 653        TClonesArray *RICHdigits  = RICH->DigitsAddress(ich);
 654        if (RICHdigits == 0) continue;
 655        gAlice->ResetDigits();
 656        gAlice->TreeD()->GetEvent(1);
 657        Int_t ndigits = RICHdigits->GetEntriesFast();
 658        printf("Found %d digits in chamber %d \n",ndigits,ich);
 659        NallDigits+=ndigits;
 660    }
 661    if (fPoints == 0) fPoints = new TObjArray(NallDigits);
 662    Int_t counter=0;
 663    for (ich=0; ich<7; ich++) {
 664        TClonesArray *RICHdigits  = RICH->DigitsAddress(ich);
 665        if (RICHdigits == 0) continue;
 666        gAlice->ResetDigits();
 667        gAlice->TreeD()->GetEvent(1);
 668        Int_t ndigits = RICHdigits->GetEntriesFast();
 669        printf("Found %d digits in chamber %d \n",ndigits,ich);
 670        if (ndigits == 0) continue;
 671
 672
 673
 674        iChamber = &(RICH->Chamber(ich));
 675        printf("LoadPoints - chamber %d \n",ich);
 676        segmentation=iChamber->GetSegmentationModel(1);
 677        Float_t dpx  = segmentation->Dpx();
 678        Float_t dpy  = segmentation->Dpy();
 679        printf("LoadPoints - dpx, dpy %f %f \n",dpx,dpy);
 680        AliRICHdigit  *mdig;
 681        AliRICHpoints *points = 0;
 682        //
 683        //loop over all digits and store their position
 684        Int_t npoints=1;
 685
 686        for (Int_t digit=0;digit<ndigits;digit++) {
 687            mdig    = (AliRICHdigit*)RICHdigits->UncheckedAt(digit);
 688            points = new AliRICHpoints(npoints);
 689            fPoints->AddAt(points,counter);
 690            counter++;
 691            Int_t charge=mdig->fSignal;
 692            Int_t index=Int_t(TMath::Log(charge)/(TMath::Log(adc_satm)/22));
 693            Int_t color=51+index;
 694            if (color>72) color=72;
 695            points->SetMarkerColor(color);
 696            points->SetMarkerStyle(21);
 697            points->SetMarkerSize(0.5);
 698            // get the center of the pad - add on x and y half of pad size
 699            Float_t xpad, ypad;
 700            segmentation->GetPadCxy(mdig->fPadX, mdig->fPadY,xpad, ypad);
 701            printf("\n chamber x,y, %d %f %f ", ich, xpad, ypad);
 702
 703            Float_t VecLoc[3]={xpad,0,ypad};
 704            Float_t  VecGlob[3];
 705            iChamber->LocaltoGlobal(VecLoc,VecGlob);
 706            points->SetParticle(-1);
 707            points->SetHitIndex(-1);
 708            points->SetTrackIndex(-1);
 709            points->SetDigitIndex(digit);
 710            points->SetPoint(0,VecGlob[0],VecGlob[1],VecGlob[2]);
 711        } // loop over digits
 712    } // loop over chambers
 713 }
 714
 715
 716 //___________________________________________
 717 void AliRICHdisplay::LoadHits(Int_t chamber)
 718 {
 719 // Read hits info and store x,y,z info in arrays fPhits
 720 // Loop on all detectors
 721
 722     printf("Entering Load-hits");
 723
 724     fChamber=chamber;
 725     ResetPhits();
 726
 727     AliRICH *RICH  = (AliRICH*)gAlice->GetDetector("RICH");
 728     AliRICHchamber*  iChamber;
 729
 730     iChamber = &(RICH->Chamber(chamber-1));
 731     Float_t zpos=iChamber->ZPosition();
 732     printf("LoadHits - zpos %f \n",zpos);
 733
 734     Int_t ntracks = (Int_t)gAlice->TreeH()->GetEntries();
 735     printf("ntracks %d\n",ntracks);
 736     Int_t ntrks = gAlice->GetNtrack();
 737     printf("ntrks %d\n",ntrks);
 738
 739     if (fPhits == 0) fPhits = new TObjArray(ntracks);
 740     TVector *xp = new TVector(1000);
 741     TVector *yp = new TVector(1000);
 742     TVector *zp = new TVector(1000);
 743     TVector *ptrk = new TVector(1000);
 744     TVector *phit = new TVector(1000);
 745     for (Int_t track=0; track<ntracks;track++) {
 746         gAlice->ResetHits();
 747         gAlice->TreeH()->GetEvent(track);
 748         TClonesArray *RICHhits  = RICH->Hits();
 749         if (RICHhits == 0) return;
 750         Int_t nhits = RICHhits->GetEntriesFast();
 751         if (nhits == 0) continue;
 752         AliRICHhit *mHit;
 753         AliRICHpoints *points = 0;
 754         Int_t npoints=0;
 755         for (Int_t hit=0;hit<nhits;hit++) {
 756             mHit = (AliRICHhit*)RICHhits->UncheckedAt(hit);
 757             (*xp)(npoints)=mHit->fX;
 758             (*yp)(npoints)=mHit->fY;
 759             (*zp)(npoints)=mHit->fZ;
 760             (*ptrk)(npoints)=Float_t(mHit->GetTrack());
 761             (*phit)(npoints)=Float_t(hit);
 762             npoints++;
 763         }
 764
 765         if (npoints == 0) continue;
 766         points = new AliRICHpoints(npoints);
 767         for (Int_t p=0;p<npoints;p++) {
 768             points->SetMarkerColor(kRed);
 769             points->SetMarkerStyle(5);
 770             points->SetMarkerSize(1.);
 771             points->SetParticle(Int_t((*ptrk)(p)));
 772             points->SetHitIndex(Int_t((*phit)(p)));
 773             points->SetTrackIndex(track);
 774             points->SetDigitIndex(-1);
 775             points->SetPoint(p,(*xp)(p),(*yp)(p),(*zp)(p));
 776         }
 777         xp->Zero();
 778         yp->Zero();
 779         ptrk->Zero();
 780         phit->Zero();
 781         fPhits->AddAt(points,track);
 782     }
 783
 784 }
 785
 786 //_____________________________________________________________________________
 787
 788 void AliRICHdisplay::LoadCerenkovs(Int_t chamber)
 789 {
 790 // Read cerenkov hits info and store x,y,z info in array fPCerenkovs
 791 // Loop on all detectors
 792
 793     printf("Entering Load-Cerenkovs");
 794
 795     fChamber=chamber;
 796     ResetPCerenkovs();
 797
 798     AliRICH *RICH  = (AliRICH*)gAlice->GetDetector("RICH");
 799     AliRICHchamber*  iChamber;
 800
 801     iChamber = &(RICH->Chamber(chamber-1));
 802     Float_t zpos=iChamber->ZPosition();
 803     printf("LoadCerenkovs - zpos %f \n",zpos);
 804
 805     RICH->SetTreeAddress();
 806     Int_t ntracks = (Int_t)gAlice->TreeH()->GetEntries();
 807     printf("ntracks %d\n",ntracks);
 808     Int_t ntrks = gAlice->GetNtrack();
 809     printf("ntrks %d\n",ntrks);
 810
 811     if (fPCerenkovs == 0) fPCerenkovs = new TObjArray(ntracks);
 812     TVector *xp = new TVector(1000);
 813     TVector *yp = new TVector(1000);
 814     TVector *zp = new TVector(1000);
 815     TVector *ptrk = new TVector(1000);
 816     TVector *phit = new TVector(1000);
 817     for (Int_t track=0; track<ntracks;track++) {
 818         gAlice->ResetHits();
 819         gAlice->TreeH()->GetEvent(track);
 820         TClonesArray *RICHCerenkovs  = RICH->Cerenkovs();
 821         printf("RICHCerenkovs %p\n",RICHCerenkovs);
 822         if (RICHCerenkovs == 0) return;
 823         Int_t nhits = RICHCerenkovs->GetEntriesFast();
 824         if (nhits == 0) continue;
 825         printf("nhits %d \n",nhits);
 826         AliRICHCerenkov *mCerenkov;
 827         AliRICHpoints *cpoints = 0;
 828         Int_t npoints=0;
 829
 830 //Display Cerenkov hits in blue
 831
 832         for (Int_t hit=0;hit<nhits;hit++) {
 833             mCerenkov = (AliRICHCerenkov*)RICHCerenkovs->UncheckedAt(hit);
 834             (*xp)(npoints)=mCerenkov->fX;
 835             (*yp)(npoints)=mCerenkov->fY;
 836             (*zp)(npoints)=mCerenkov->fZ;
 837             (*ptrk)(npoints)=Float_t(mCerenkov->GetTrack());
 838             (*phit)(npoints)=Float_t(hit);
 839             printf("track, trk %d %d\n",track,mCerenkov->GetTrack());
 840             npoints++;
 841         }
 842         if (npoints == 0) continue;
 843         printf("npoints %d \n",npoints);
 844         cpoints = new AliRICHpoints(npoints);
 845         for (Int_t p=0;p<npoints;p++) {
 846             cpoints->SetMarkerColor(kBlue);
 847             cpoints->SetMarkerStyle(3);
 848             cpoints->SetMarkerSize(1.);
 849             cpoints->SetParticle(Int_t((*ptrk)(p)));
 850             Int_t index=cpoints->GetIndex();
 851             printf("index %d \n",index);
 852             cpoints->SetHitIndex(Int_t((*phit)(p)));
 853             cpoints->SetTrackIndex(track);
 854             cpoints->SetDigitIndex(-1);
 855             cpoints->SetPoint(p,(*xp)(p),(*yp)(p),(*zp)(p));
 856         }
 857         xp->Zero();
 858         yp->Zero();
 859         ptrk->Zero();
 860         phit->Zero();
 861         fPCerenkovs->AddAt(cpoints,track);
 862     }
 863 }
 864
 865 //_____________________________________________________________________________
 866 void AliRICHdisplay::Paint(Option_t *)
 867 {
 868 //    Paint miscellaneous items
 869
 870 }
 871
 872 //_____________________________________________________________________________
 873 void AliRICHdisplay::SetPickMode()
 874 {
 875     fZoomMode = 0;
 876
 877     fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
 878     fTrigPad->Modified();
 879 }
 880
 881 //_____________________________________________________________________________
 882 void AliRICHdisplay::SetZoomMode()
 883 {
 884     fZoomMode = 1;
 885
 886     fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
 887     fTrigPad->Modified();
 888 }
 889
 890 //_____________________________________________________________________________
 891 void AliRICHdisplay::SetChamberAndCathode(Int_t chamber, Int_t cathode)
 892 {
 893 // Set chamber and cathode number
 894     fChamber = chamber;
 895     fCathode = cathode;
 896
 897     printf("SetChamberAndCathode - fChamber fCathode %d %d\n",fChamber,fCathode);
 898     if (!fPad) return;
 899     fPad->Clear();
 900     LoadDigits();
 901     Draw();
 902 }
 903
 904 //_____________________________________________________________________________
 905 void AliRICHdisplay::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 AliRICHdisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
 918 {
 919 //  change viewing angles for current event
 920
 921     fPad->cd();
 922     fPhi   = phi;
 923     fTheta = theta;
 924     fPsi   = psi;
 925     Int_t iret = 0;
 926
 927     TView *view = gPad->GetView();
 928     if (view) view->SetView(fPhi, fTheta, fPsi, iret);
 929     else      Draw();
 930
 931     gPad->Modified();
 932 }
 933
 934 //_____________________________________________________________________________
 935 void AliRICHdisplay::ShowNextEvent(Int_t delta)
 936 {
 937 //  Display (current event_number+delta)
 938 //    delta =  1  shown next event
 939 //    delta = -1 show previous event
 940
 941     if (delta) {
 942         gAlice->Clear();
 943         Int_t current_event = gAlice->GetHeader()->GetEvent();
 944         Int_t new_event     = current_event + delta;
 945         gAlice->GetEvent(new_event);
 946         if (!gAlice->TreeD()) return;
 947     }
 948     LoadDigits();
 949     DrawClusters();
 950     fPad->cd();
 951     Draw();
 952
 953
 954 }
 955
 956 //______________________________________________________________________________
 957 void AliRICHdisplay::UnZoom()
 958 {
 959     if (fZooms <= 0) return;
 960     fZooms--;
 961     TPad *pad = (TPad*)gPad->GetPadSave();
 962     pad->Range(fZoomX0[fZooms],fZoomY0[fZooms], fZoomX1[fZooms],fZoomY1[fZooms]);
 963     pad->Modified();
 964 }
 965
 966 //_____________________________________________________________________________
 967 void AliRICHdisplay::ResetPoints()
 968 {
 969     //
 970     // Reset array of points
 971     //
 972     if (fPoints) {
 973         fPoints->Delete();
 974         delete fPoints;
 975         fPoints = 0;
 976   }
 977 }
 978 //_____________________________________________________________________________
 979 void AliRICHdisplay::ResetPhits()
 980 {
 981     //
 982     // Reset array of points
 983     //
 984     if (fPhits) {
 985         fPhits->Delete();
 986         delete fPhits;
 987         fPhits = 0;
 988     }
 989 }
 990 //_____________________________________________________________________________
 991 void AliRICHdisplay::ResetPCerenkovs()
 992 {
 993     //
 994     // Reset array of points
 995     //
 996     if (fPCerenkovs) {
 997         fPCerenkovs->Delete();
 998         delete fPCerenkovs;
 999         fPCerenkovs = 0;
1000     }
1001 }