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