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