]> git.uio.no Git - u/mrichter/AliRoot.git/blame - MUON/AliMUONDisplay.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
AliMUONTrackExtrap.h
[u/mrichter/AliRoot.git] / MUON / AliMUONDisplay.cxx
CommitLineData
a9e2aefa 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
88cb7938 16/* $Id$ */
a9e2aefa 17
5398f946 18/// \class AliMUONDisplay
19/// Create an event display object.
20/// A canvas named "edisplay" is created with a vertical size in pixels \n
21///
22/// A QUICK Overview of the Event Display functions \n
23/// =============================================== \n
24///
25/// The event display can ve invoked by executing the macro "display.C" \n
26/// A canvas like in the picture below will appear.
27///
28/// On the left side of the canvas, the following buttons appear:
29/// - *Next* to move to the next event
30/// - *Previous* to move to the previous event
31/// - *Pick* Select this option to be able to point on a track with the
32/// mouse. Once on the track, use the right button to select
33/// an action. For example, select SetMarkerAttributes to
34/// change the marker type/color/size for the track.
35/// - *Zoom* Select this option (default) if you want to zoom.
36/// To zoom, simply select the selected area with the left button.
37/// - *UnZoom* To revert to the previous picture size.
38///
39/// - slider R On the left side, the vertical slider can be used to
40/// set the default picture size.
41///
42/// When you are in Zoom mode, you can click on the black part of the canvas
43/// to select special options with the right mouse button.
44///
45/// When you are in pick mode, you can "Inspect" the object pointed by the mouse.
46/// When you are on a track, select the menu item "InspectParticle"
47/// to display the current particle attributes.
48///
49/// You can activate the Root browser by selecting the Inspect menu
50/// in the canvas tool bar menu. Then select "Start Browser"
51/// This will open a new canvas with the browser. At this point, you may want
52/// to display some histograms (from the Trees). Go to the "File" menu
53/// of the browser and click on "New canvas".
54/// In the browser, click on item "ROOT files" in the left pane.
55/// Click on galice.root.
56/// Click on TH
57/// Click on TPC for example
58/// Click on any variable (eg TPC.fX) to histogram the variable.
59///
60/// If you are lost, you can click on HELP in any Root canvas or browser.
61
62//Begin_Html
63/*
64<img src="gif/AliMUONDisplay.gif">
65*/
66//End_Html
a9e2aefa 67
30178c30 68#include "AliMUONDisplay.h"
a9e2aefa 69#include "AliMUON.h"
a9e2aefa 70#include "AliMUONPoints.h"
d226f81b 71#include "AliMUONGlobalTrigger.h"
a9e2aefa 72#include "AliMUONHit.h"
a9e2aefa 73#include "AliMUONDigit.h"
74#include "AliMUONRawCluster.h"
572d5bb2 75#include "AliMUONTrack.h"
76#include "AliMUONTrackParam.h"
b7ef3c96 77#include "AliMUONGeometryTransformer.h"
7502d0e5 78#include "AliMUONSegmentation.h"
79#include "AliMUONGeometrySegmentation.h"
80#include "AliMUONConstants.h"
94d085f8 81#include "AliMUONTriggerSegmentation.h"
7502d0e5 82
83#include "AliMpDEIterator.h"
666ada1e 84#include "AliMpSegmentation.h"
123469eb 85#include "AliMpSlatSegmentation.h"
86#include "AliMpSlat.h"
63216d66 87#include "AliMpSectorSegmentation.h"
e0d2f4db 88#include "AliMpSector.h"
e0d2f4db 89#include "AliMpTriggerSegmentation.h"
90#include "AliMpTrigger.h"
1169bc87 91#include "AliMpStationType.h"
92#include "AliMpDEManager.h"
123469eb 93
5d12ce38 94#include "AliMC.h"
8c343c7c 95#include "AliLog.h"
7502d0e5 96#include "AliRun.h"
97#include "AliHeader.h"
98
99#include <TButton.h>
100#include <TColor.h>
101#include <TCanvas.h>
102#include <TView.h>
103#include <TText.h>
104#include <TPaveLabel.h>
105#include <TPaveText.h>
106#include <TDiamond.h>
107#include <TNode.h>
108#include <TArc.h>
109#include <TSlider.h>
110#include <TVirtualX.h>
111#include <TMath.h>
112#include <TGeometry.h>
113#include <TMarker3DBox.h>
114#include <TParticle.h>
115#include <TPolyLine3D.h>
116#include <TBox.h>
a9e2aefa 117
5398f946 118/// \cond CLASSIMP
a9e2aefa 119ClassImp(AliMUONDisplay)
5398f946 120/// \endcond
a9e2aefa 121
122//_____________________________________________________________________________
123AliMUONDisplay::AliMUONDisplay()
5398f946 124 : AliDisplay(),
125 fEvent(0),
126 fChamber(0),
127 fCathode(0),
128 fDrawClusters(kTRUE),
129 fDrawCoG(kTRUE),
130 fDrawTracks(kFALSE),
131 fClustersCuts(0),
132 fColPad(0),
133 fPoints(0),
134 fPhits(0),
135 fRpoints(0),
136 fNextCathode(0),
137 fLoader(0),
138 fMUONData(0)
a9e2aefa 139{
5398f946 140/// Default constructor
a9e2aefa 141}
142
143//_____________________________________________________________________________
307d9d04 144AliMUONDisplay::AliMUONDisplay(Int_t size, AliLoader * loader)
5398f946 145 : AliDisplay(),
146 fEvent(0),
147 fChamber(1),
148 fCathode(1),
149 fDrawClusters(kTRUE),
150 fDrawCoG(kTRUE),
151 fDrawTracks(kFALSE),
152 fClustersCuts(0),
153 fColPad(0),
154 fPoints(0),
155 fPhits(0),
156 fRpoints(0),
157 fNextCathode(kFALSE),
158 fLoader(loader),
159 fMUONData(0)
160
a9e2aefa 161{
5398f946 162/// Standard constructor to create an event display object.
a9e2aefa 163
164 fPad = 0;
165
166 gAlice->SetDisplay(this);
167
168 // Initialize display default parameters
169 SetRange(200,2000);
5398f946 170
a9e2aefa 171 // Set front view by default
172 fTheta = 0;
173 fPhi = -90;
174 fPsi = 0;
a9e2aefa 175 fZoomMode = 1;
176 fZooms = 0;
5398f946 177
a9e2aefa 178 // Create colors
179 CreateColors();
180 // Create display canvas
181 Int_t ysize = size;
182 if (ysize < 100) ysize = 750;
183 Int_t xsize = Int_t(size*830./ysize);
572d5bb2 184 fCanvas = new TCanvas("Canvas", "MUON Display",14,47,xsize,ysize);
a9e2aefa 185 fCanvas->ToggleEventStatus();
186
187 // Create main display pad
188 fPad = new TPad("viewpad", "MUON display",0.15,0,0.9,1);
189 fPad->Draw();
190 fPad->Modified();
191 fPad->SetFillColor(30);
192 fPad->SetBorderSize(2);
193
194 fCanvas->cd();
195
196 // Create colors pad
197 fColPad = new TPad("colpad", "Colors pad",0.9,0,1,1);
198 fColPad->Draw();
199 fColPad->SetFillColor(17);
200 fColPad->SetBorderSize(2);
201 fColPad->cd();
202 DisplayColorScale();
203
204 fCanvas->cd();
205 // Create user interface control pad
206 DisplayButtons();
207 fCanvas->cd();
208
209 // Create Range and mode pad
210 Float_t dxtr = 0.15;
211 Float_t dytr = 0.45;
212 fTrigPad = new TPad("trigger", "range and mode pad",0,0,dxtr,dytr);
a9e2aefa 213 fTrigPad->Draw();
214 fTrigPad->cd();
215 fTrigPad->SetFillColor(22);
216 fTrigPad->SetBorderSize(2);
217 fRangeSlider = new TSlider("range","range",0.7,0.42,0.9,0.98);
218 fRangeSlider->SetObject(this);
219 char pickmode[] = "gAlice->Display()->SetPickMode()";
220 Float_t db = 0.09;
221 fPickButton = new TButton("Pick",pickmode,0.05,0.32,0.65,0.32+db);
222 fPickButton->SetFillColor(38);
223 fPickButton->Draw();
224 char zoommode[] = "gAlice->Display()->SetZoomMode()";
225 fZoomButton = new TButton("Zoom",zoommode,0.05,0.21,0.65,0.21+db);
226 fZoomButton->SetFillColor(38);
227 fZoomButton->Draw();
228 fArcButton = new TArc(.8,fZoomButton->GetYlowNDC()+0.5*db,0.33*db);
229 fArcButton->SetFillColor(kGreen);
230 fArcButton->Draw();
231 char butUnzoom[] = "gAlice->Display()->UnZoom()";
232 TButton *button = new TButton("UnZoom",butUnzoom,0.05,0.05,0.95,0.15);
233 button->SetFillColor(38);
234 button->Draw();
235 AppendPad(); // append display object as last object to force selection
236
237 fCanvas->cd();
1c4b7942 238 fTrigPad->SetEditable(kFALSE);
239 fButtons->SetEditable(kFALSE);
a9e2aefa 240 fCanvas->Update();
5398f946 241
d226f81b 242 // initialize container
243 if(fLoader)
244 fMUONData = new AliMUONData(fLoader,"MUON","MUON");
245 else
246 fMUONData =0x0;
a9e2aefa 247}
248
a9e2aefa 249//_____________________________________________________________________________
250AliMUONDisplay::~AliMUONDisplay()
251{
5398f946 252/// Destructor
253
a9e2aefa 254 // Delete space point structure
255 if (fPoints) fPoints->Delete();
256 delete fPoints;
257 fPoints = 0;
258 //
259 if (fPhits) fPhits->Delete();
260 delete fPhits;
261 fPhits = 0;
262 //
d226f81b 263 if (fRpoints) fRpoints->Delete();
a9e2aefa 264 delete fRpoints;
d226f81b 265 fRpoints = 0;
a9e2aefa 266}
267
268//_____________________________________________________________________________
269void AliMUONDisplay::Clear(Option_t *)
270{
5398f946 271/// Delete graphics temporary objects
a9e2aefa 272}
273
274//_____________________________________________________________________________
275void AliMUONDisplay::DisplayButtons()
276{
5398f946 277/// Create the user interface buttons
a9e2aefa 278
279
280 fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
a9e2aefa 281 fButtons->Draw();
282 fButtons->SetFillColor(38);
283 fButtons->SetBorderSize(2);
284 fButtons->cd();
285
286// Int_t butcolor = 33;
287 Float_t dbutton = 0.08;
288 Float_t y = 0.96;
289 Float_t dy = 0.014;
290 Float_t x0 = 0.05;
291 Float_t x1 = 0.95;
292
293 TButton *button;
294 char but1[] = "gAlice->Display()->ShowNextEvent(1)";
295 button = new TButton("Event +", but1, x0, y - dbutton, x1, y);
296 button->SetFillColor(38);
297 button->Draw();
298
299 y -= dbutton + dy;
300 char but2[] = "gAlice->Display()->ShowNextEvent(-1)";
301 button = new TButton("Event -", but2, x0, y - dbutton, x1, y);
302 button->SetFillColor(38);
303 button->Draw();
304
305 y -= dbutton + dy;
306 char but3[] = "((AliMUONDisplay*)(gAlice->Display()))->NextChamber(1)";
307 button = new TButton("Chamber +", but3, x0, y - dbutton, x1, y);
308 button->SetFillColor(38);
309 button->Draw();
310
311 y -= dbutton + dy;
312 char but4[] = "((AliMUONDisplay*)(gAlice->Display()))->NextChamber(-1)";
313 button = new TButton("Chamber -", but4, x0, y - dbutton, x1, y);
314 button->SetFillColor(38);
315 button->Draw();
316
317 y -= dbutton + dy;
318 char but5[] = "((AliMUONDisplay*)(gAlice->Display()))->SetChamberAndCathode(1,1)";
319 button = new TButton("Chamber 1", but5, x0, y - dbutton, x1, y);
320 button->SetFillColor(38);
321 button->Draw();
322
323 y -= dbutton + dy;
324 char but6[] = "((AliMUONDisplay*)(gAlice->Display()))->NextCathode()";
325 button = new TButton("Cathode <>", but6, x0, y - dbutton, x1, y);
326 button->SetFillColor(38);
327 button->Draw();
328
329 y -= dbutton + dy;
330 char but7[] = "((AliMUONDisplay*)(gAlice->Display()))->Trigger()";
331 button = new TButton("Trigger", but7, x0, y - dbutton, x1, y);
332 button->SetFillColor(38);
333 button->Draw();
334
572d5bb2 335 y -= dbutton + dy;
336 char but8[] = "((AliMUONDisplay*)(gAlice->Display()))->DrawReco()";
337 button = new TButton("Tracking", but8, x0, y - dbutton, x1, y);
338 button->SetFillColor(38);
339 button->Draw();
340
a9e2aefa 341 // display logo
342 TDiamond *diamond = new TDiamond(0.05,0.015,0.95,0.22);
343 diamond->SetFillColor(50);
344 diamond->SetTextAlign(22);
345 diamond->SetTextColor(5);
346 diamond->SetTextSize(0.11);
347 diamond->Draw();
348 diamond->AddText(".. ");
349 diamond->AddText("ROOT");
350 diamond->AddText("MUON");
351 diamond->AddText("... ");
352 diamond->AddText(" ");
353}
354
355//_____________________________________________________________________________
30178c30 356void AliMUONDisplay::CreateColors() const
a9e2aefa 357{
5398f946 358/// Create the colors palette used to display clusters
a9e2aefa 359
360 Int_t k,i;
361 Int_t color;
362 Float_t r,g,b;
363
364 for (k=1;k<=5;k++) {
365 switch(k) {
366 case 1:
367 for (i=1;i<=5;i++) {
368 r=1.;
369 g=i*0.2;
370 b=0.;
371 color=i;
372 color=260+23-color;
373 new TColor(color,r,g,b);
374 }
375 break;
376 case 2:
377 for (i=1;i<=4;i++) {
378 r=1.1-i*0.2;
379 g=1.;
380 b=0.;
381 color=i+5;
382 color=260+23-color;
383 new TColor(color,r,g,b);
384 }
385 break;
386 case 3:
387 for (i=1;i<=4;i++) {
388 r=0.;
389 g=1.;
390 b=i*0.2+0.2;
391 color=i+9;
392 color=260+23-color;
393 new TColor(color,r,g,b);
394 }
395 break;
396 case 4:
397 for (i=1;i<=4;i++) {
398 r=0.;
399 g=1.1-i*0.2;
400 b=1.;
401 color=i+13;
402 color=260+23-color;
403 new TColor(color,r,g,b);
404 }
405 break;
406 case 5:
407 for (i=1;i<=5;i++) {
408 r=i*0.2;
409 g=0.;
410 b=1.;
411 color=i+17;
412 color=260+23-color;
413 new TColor(color,r,g,b);
414 }
415 break;
416 }
417 }
418}
419
420//_____________________________________________________________________________
421void AliMUONDisplay::DisplayColorScale()
422{
5398f946 423/// Display pulse height color scale
424
a9e2aefa 425 Int_t i;
426 Int_t color;
427 Float_t xlow, ylow, xup, yup, hs;
428 Float_t x1, y1, x2, y2;
429 x1 = y1 = 0;
430 x2 = y2 = 1.0;
431
432 TText *text = new TText(0,0,"");
433 text->SetTextFont(61);
434 text->SetTextSize(0.2);
435 text->SetTextAlign(22);
436
7e4a628d 437
438 Int_t adcmax=4096; // default 12 bits ADC
439
a9e2aefa 440
441
442 TBox *box;
443 char label[8];
444//*-* draw colortable boxes
445 hs = (y2-y1)/Float_t(22);
446 xlow=x1+.05;
447 xup=x2-0.5;
448 for (i=0;i<22;i++) {
449 ylow = y1 + hs*(Float_t(i));
450 yup = y1 + hs*(Float_t(i+1));
451 color = 261+i;
452 Double_t logscale=Double_t(i+1)*(TMath::Log(adcmax)/22);
453 Int_t scale=(Int_t)TMath::Exp(logscale);
454 sprintf(label,"%d",scale);
455 box = new TBox(xlow, ylow, xup, yup);
456 box->Draw();
457 box->SetFillColor(color);
458 text->DrawText(xlow+0.7, 0.5*(ylow+yup),label);
459 }
460}
461
462//______________________________________________________________________________
463Int_t AliMUONDisplay::DistancetoPrimitive(Int_t px, Int_t)
464{
5398f946 465/// Compute distance from point px,py to objects in event
a9e2aefa 466
467 gPad->SetCursor(kCross);
468
469 if (gPad == fTrigPad) return 9999;
470
471 const Int_t kBig = 9999;
472 Int_t dist = kBig;
473 Float_t xmin = gPad->GetX1();
474 Float_t xmax = gPad->GetX2();
475 Float_t dx = 0.02*(xmax - xmin);
476 Float_t x = gPad->AbsPixeltoX(px);
477 if (x < xmin+dx || x > xmax-dx) return dist;
478
479 if (fZoomMode) return 0;
480 else return 7;
481}
482
483//_____________________________________________________________________________
484void AliMUONDisplay::Draw(Option_t *)
485{
5398f946 486/// Display current event
a9e2aefa 487
572d5bb2 488 if (!fDrawTracks)
489 DrawChamber();
490 else
491 DrawReco();
492
493}
494//_____________________________________________________________________________
495void AliMUONDisplay::DrawChamber()
496{
5398f946 497/// Display current event
a9e2aefa 498
572d5bb2 499 fDrawTracks = kFALSE;
500 fPad->cd();
501 DrawView(fTheta, fPhi, fPsi);
502 // Display the event number and title
503 fPad->cd();
504 DrawTitle();
505
506}
507//_____________________________________________________________________________
508void AliMUONDisplay::DrawReco(Option_t *)
509{
5398f946 510/// Display current event
572d5bb2 511
512 fDrawTracks = kTRUE;
513 // print kinematics of generated particles
514 PrintKinematics();
515 // Draw global view of muon system
516 fPad->cd();
517 DrawGlobalView(135, -50, -140);
518
a9e2aefa 519 // Display the event number and title
520 fPad->cd();
521 DrawTitle();
522}
523
572d5bb2 524//_____________________________________________________________________________
525void AliMUONDisplay::PrintKinematics()
526{
5398f946 527/// Print kinematic tree
528
572d5bb2 529 AliRunLoader * runLoader;
530 TParticle *particle = new TParticle();
531 Int_t nPart;
532 Float_t vertex[3], momentum[3];
533
534 if (fLoader)
535 runLoader = fLoader->GetRunLoader();
536 else
537 runLoader = 0x0;
538
539 printf("****** Event # %d ******\n",runLoader->GetEventNumber());
540 runLoader->TreeK()->GetBranch("Particles")->SetAddress(&particle);
541 nPart = (Int_t)runLoader->TreeK()->GetEntries();
542 for(Int_t iPart = 0; iPart < nPart; iPart++) {
543 runLoader->TreeK()->GetEvent(iPart);
544 vertex[0] = particle->Vx();
545 vertex[1] = particle->Vy();
546 vertex[2] = particle->Vz();
547 momentum[0] = particle->Px();
548 momentum[1] = particle->Py();
549 momentum[2] = particle->Pz();
550
551 printf("===================================================\n");
552 printf(" Generated particle # %d \n",iPart);
553 printf(" name: %s \n",particle->GetName());
554 printf(" vertex x,y,z (cm): %f %f %f \n",vertex[0],vertex[1],vertex[2]);
555 printf(" momentum Px,Py,Pz (GeV/c): %f %f %f \n",momentum[0],momentum[1],momentum[2]);
556 }
557 delete particle;
558}
559
5398f946 560//_____________________________________________________________________________
a9e2aefa 561void AliMUONDisplay::DrawSegmentation()
562{
5398f946 563/// \todo to be re-written for new seg
564/// Draw graphical representation of segmenatation
565/// Attention: still experimental code
002920d1 566// Int_t icat=1;
a9e2aefa 567
002920d1 568// AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
569// AliMUONChamber* iChamber;
76dadf7e 570
002920d1 571// AliSegmentation* seg;
572// iChamber = &(pMUON->Chamber(fChamber));
573// seg=iChamber->SegmentationModel(icat);
76dadf7e 574
002920d1 575// Float_t zpos=iChamber->Z();
576// Float_t r=iChamber->ROuter();
a9e2aefa 577
002920d1 578// TMarker3DBox *marker;
579// if (icat == 1) {
580// for (Int_t j=0; j<seg->Npy(); j++) {
581// Float_t y0;
582// y0=j*seg->Dpy()-seg->Dpy()/2.;
583// for (seg->FirstPad(0.,y0,0,300,0.);
584// seg->MorePads();
585// seg->NextPad())
586// {
587// if (seg->ISector()==0) continue;
588// Float_t x,y,z;
589// seg->GetPadC(seg->Ix(), seg->Iy(), x, y, z);
590// Float_t dpx=seg->Dpx(seg->ISector())/2;
591// Float_t dpy=seg->Dpy(seg->ISector())/2;
592// marker=new TMarker3DBox(x,y,zpos,dpx,dpy,0,0,0);
593// marker->SetLineColor(seg->ISector()+1);
594// marker->SetFillStyle(1001);
595// marker->SetFillColor(0);
596// marker->Draw();
597// }
598// }
599// } else {
600// for (Int_t j=0; j<250; j++) {
601// Float_t x0=j*seg->Dpx();
602// Float_t y0=TMath::Sqrt(r*r-x0*x0);
a9e2aefa 603
002920d1 604// for (seg->FirstPad(x0,0,0,0,y0);
605// seg->MorePads();
606// seg->NextPad())
607// {
608// if (seg->ISector()==0) continue;
a9e2aefa 609
002920d1 610// Float_t x,y,z;
611// seg->GetPadC(seg->Ix(), seg->Iy(), x, y, z);
612// Float_t dpx=seg->Dpx(seg->ISector())/2;
613// Float_t dpy=seg->Dpy(seg->ISector())/2;
614// marker=new TMarker3DBox(x,y,zpos,dpx,dpy,0,0,0);
615// marker->SetLineColor(seg->ISector()+1);
616// marker->SetFillStyle(1001);
617// marker->SetFillColor(0);
618// marker->Draw();
619// }
620// }
621// }
622 }
a9e2aefa 623
624//_____________________________________________________________________________
625void AliMUONDisplay::DrawClusters()
626{
5398f946 627/// Draw clusters for MUON chambers
a9e2aefa 628
629 Int_t ndigits, digit;
630 TObjArray *points;
631 AliMUONPoints *pm;
632
633
634 fClustersCuts = 0;
635 points = Points();
636 if (!points) return;
637 ndigits = points->GetEntriesFast();
638 for (digit=0;digit<ndigits;digit++){
639 pm = (AliMUONPoints*)points->UncheckedAt(digit);
640 if (!pm) continue;
641 Float_t *pxyz;
642 pxyz=pm->GetP();
643 for (Int_t im=0;im<3;im++) {
644 TMarker3DBox *marker=pm->GetMarker(im);
645 if (marker)
646 marker->Draw();
647 }
648 pm->Draw();
123469eb 649 fClustersCuts += pm->GetN();
a9e2aefa 650 }
651}
652
653//_____________________________________________________________________________
654void AliMUONDisplay::DrawHits()
655{
5398f946 656/// Draw hits for MUON chambers
a9e2aefa 657
658 LoadHits(fChamber);
659
660 Int_t ntracks, track;
661 TObjArray *points;
662 AliMUONPoints *pm;
663
664 fHitsCuts = 0;
665 points = Phits();
666 if (!points) return;
667 ntracks = points->GetEntriesFast();
668 for (track=0;track<ntracks;track++) {
669 pm = (AliMUONPoints*)points->UncheckedAt(track);
670 if (!pm) continue;
671 pm->Draw();
672 fHitsCuts += pm->GetN();
673 }
674}
675
676
677//_____________________________________________________________________________
678void AliMUONDisplay::DrawCoG()
679{
5398f946 680/// Draw hits for MUON chambers
681
a9e2aefa 682 if (!fDrawCoG) return;
683 if (fChamber > 10) return;
684 LoadCoG(fChamber,fCathode);
685
686 Int_t ncog, icog;
687 TObjArray *points;
688 AliMUONPoints *pm;
689
690 points = Rpoints();
691 if (!points) return;
692 ncog = points->GetEntriesFast();
693 for (icog=0;icog<ncog;icog++) {
694 pm = (AliMUONPoints*)points->UncheckedAt(icog);
695 if (!pm) continue;
696 pm->Draw();
697 }
698}
a9e2aefa 699//_____________________________________________________________________________
572d5bb2 700void AliMUONDisplay::DrawTracks()
701{
5398f946 702/// Draw tracks
703
572d5bb2 704 if (!fDrawTracks) return;
705 LoadTracks();
706
707 Int_t nTrack, iTrack;
708 TObjArray *points;
709 TPolyLine3D *pm;
710
711 points = Rpoints();
712 if (!points) return;
713 nTrack = points->GetEntriesFast();
714 for ( iTrack = 0; iTrack < nTrack; iTrack++) {
715 pm = (TPolyLine3D*)points->UncheckedAt(iTrack);
716 if (!pm) continue;
717 pm->Draw();
718 }
719}
720//_____________________________________________________________________________
a9e2aefa 721
722void AliMUONDisplay::DrawTitle(Option_t *option)
723{
5398f946 724/// Draw the event title
a9e2aefa 725
726 Float_t xmin = gPad->GetX1();
727 Float_t xmax = gPad->GetX2();
728 Float_t ymin = gPad->GetY1();
729 Float_t ymax = gPad->GetY2();
730 Float_t dx = xmax-xmin;
731 Float_t dy = ymax-ymin;
732
30178c30 733 AliRunLoader * runLoader;
307d9d04 734 if (fLoader)
30178c30 735 runLoader = fLoader->GetRunLoader();
307d9d04 736 else
30178c30 737 runLoader = 0x0;
7985603c 738
739
a9e2aefa 740 if (strlen(option) == 0) {
741 TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
742// title->SetTextSize(0.023932);
743 title->SetTextSize(0.02);
744 title->SetBit(kCanDelete);
745 title->SetFillColor(42);
746 title->Draw();
747 char ptitle[100];
748 sprintf(ptitle, "Alice event:%d Run:%d Chamber:%d Cathode:%d",
30178c30 749 runLoader->GetEventNumber(),
a9e2aefa 750 gAlice->GetHeader()->GetRun(),
751 fChamber,
752 fCathode);
753 title->AddText(ptitle);
5d12ce38 754 Int_t nparticles = gAlice->GetMCApp()->Particles()->GetEntriesFast();
a9e2aefa 755 sprintf(ptitle,"Nparticles = %d Nhits = %d Npads fired = %d",
756 nparticles, fHitsCuts,fClustersCuts);
757 title->AddText(ptitle);
758 } else {
759 TPaveLabel *label = new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
760 label->SetBit(kCanDelete);
761 label->SetFillColor(42);
762 label->Draw();
763 }
764}
765
766//_____________________________________________________________________________
767void AliMUONDisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
768{
5398f946 769/// Draw a view of MUON clusters
770
98944e1e 771 AliInfo(" Draw View");
772
773 gPad->SetCursor(kWatch);
774 // gPad->SetFillColor(39);
775 gPad->SetFillColor(1);
776 gPad->Clear();
777 // gPad->SetFillColor(39);
778 gPad->SetFillColor(1);
779
780 Int_t iret=0;
781 TView *view = new TView(1);
782
783 Float_t range = fRrange*fRangeSlider->GetMaximum();
784 view->SetRange(-range,-range,-range,range, range, range);
785 // zoom back to full scale only if DrawView not called from NextCathode
786 if (!fNextCathode) {
787 fZoomX0[0] = -1;
788 fZoomY0[0] = -1;
789 fZoomX1[0] = 1;
790 fZoomY1[0] = 1;
791 fZooms = 0;
792 }
793
794 Float_t xg1, xg2, yg1, yg2, zg1, zg2;
795
796 // Recovering the chamber
797 AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
798
799 const AliMUONGeometryTransformer* kGeomTransformer
800 = pMUON->GetGeometryTransformer();
801
802 AliMUONSegmentation* segmentation = pMUON->GetSegmentation();
98944e1e 803
804 // Display MUON Chamber Geometry
805 char nodeName[7];
806 sprintf(nodeName,"MUON%d",100+fChamber);
807 printf(">>>> chamber is %d\n",fChamber);
808
809 if(fChamber < 5) {
810 AliMpDEIterator it;
811 for ( it.First(fChamber-1); ! it.IsDone(); it.Next() ) {
812
813 Int_t detElemId = it.CurrentDE();
814 AliMpSectorSegmentation * seg =
666ada1e 815 (AliMpSectorSegmentation *) AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, 0);
98944e1e 816 const AliMpSector * sector = seg->GetSector();
817
818 // get sector measurements
819 TVector2 position = sector->Position();
820 TVector2 dimension = sector->Dimensions(); // half length
821
822 Float_t xlocal1 = position.Px(); // FIXME: not really needed as it's 0 ?
823 Float_t ylocal1 = position.Py(); // FIXME: not really needed as it's 0 ?
824 Float_t xlocal2 = dimension.Px() * 2.;
825 Float_t ylocal2 = dimension.Px() * 2.;
826
827 kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
828 kGeomTransformer->Local2Global(detElemId, xlocal2, ylocal2, 0, xg2, yg2, zg2);
829
830 // drawing
831 TPolyLine3D* poly = new TPolyLine3D();
832 Int_t nPoint = 0;
833
834 poly->SetPoint(nPoint++, xg1, yg1, 0.);
835 for (Float_t d = 0; d < TMath::Pi()/2.; d+= 0.01) {
836 Float_t x = xg1 + xg2 * TMath::Cos(d);
837 Float_t y = yg1 + yg2 * TMath::Sin(d);
838 poly->SetPoint(nPoint++, x, y, 0.);
123469eb 839 }
98944e1e 840 poly->SetPoint(nPoint++, xg1, yg1, 0.);
841
842 poly->SetLineColor(2);
843 poly->Draw("s");
e0d2f4db 844 }
845
98944e1e 846 }
847
848 if (fChamber>4)
849 {
850 AliMpDEIterator it;
851 for ( it.First(fChamber-1); ! it.IsDone(); it.Next() )
852 {
853 Int_t detElemId = it.CurrentDE();
854 AliMpStationType stationType = AliMpDEManager::GetStationType(detElemId);
855
856 if ( segmentation->HasDE(detElemId) )
857 {
666ada1e 858 const AliMpVSegmentation* seg
859 = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, 0);
98944e1e 860 if (seg)
861 {
862 Float_t deltax = seg->Dimensions().X();
863 Float_t deltay = seg->Dimensions().Y();
864 Float_t xlocal1 = -deltax;
865 Float_t ylocal1 = -deltay;
866 Float_t xlocal2 = +deltax;
867 Float_t ylocal2 = +deltay;
868 kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
869 kGeomTransformer->Local2Global(detElemId, xlocal2, ylocal2, 0, xg2, yg2, zg2);
870
871 // drawing slat active volumes
872 Float_t xCenter = (xg1 + xg2)/2.;
873 Float_t yCenter = (yg1 + yg2)/2.;
874
875 TMarker3DBox* box = new TMarker3DBox(xCenter,yCenter,0,xlocal1,ylocal2,0,0,0);
876
877 box->SetFillStyle(0);
878 box->SetLineColor( stationType == kStationTrigger ? 4 : 2);
879 box->Draw("s");
880
881 if ( stationType == kStation345 )
882 {
883 // drawing inner circle + disc
884 TPolyLine3D* poly = new TPolyLine3D();
885 TPolyLine3D* poly1 = new TPolyLine3D();
886
887 Int_t nPoint = 0;
888 Int_t nPoint1 = 0;
889 for (Float_t d = 0; d < 6.24; d+= 0.005)
890 {
891 Double_t x = AliMUONConstants::Dmin((fChamber-1)/2) * TMath::Cos(d)/2.;
892 Double_t y = AliMUONConstants::Dmin((fChamber-1)/2) * TMath::Sin(d)/2.;
893 if (nPoint % 2 == 0) poly->SetPoint(nPoint++, 0., 0., 0.);
894 poly->SetPoint(nPoint++, x, y, 0.);
895 poly1->SetPoint(nPoint1++, x, y, 0.);
896 }
897 poly->SetLineColor(1);
898 poly->Draw("s");
899 poly1->SetLineColor(2);
900 poly1->Draw("s");
901 }
902 }
e0d2f4db 903 }
904 }
98944e1e 905 }
906
98944e1e 907 //add clusters to the pad
908 DrawClusters();
909 DrawHits();
910 DrawCoG();
911 // DrawSegmentation();
912 // add itself to the list (must be last)
913 AppendPad();
914 view->SetView(phi, theta, psi, iret);
a9e2aefa 915}
916
572d5bb2 917//_____________________________________________________________________________
918void AliMUONDisplay::DrawGlobalView(Float_t theta, Float_t phi, Float_t psi)
919{
5398f946 920/// Draw a view of muons chambers with tracks
572d5bb2 921
922 gPad->SetCursor(kWatch);
923 // gPad->SetFillColor(39);
924 gPad->SetFillColor(1);
925 gPad->Clear();
926 // gPad->SetFillColor(39);
927 gPad->SetFillColor(1);
928
929
930 Int_t iret=0;
931 TView *view = new TView(1);
932
933 Float_t range = fRrange*fRangeSlider->GetMaximum()*3.;
934 view->SetRange(-range,-range,-range,range,range,range);
935
936// Display all MUON Chambers segmentation
937 char nodeName[7];
938 TNode *node1;
939 sprintf(nodeName,"alice");
940
941 node1=gAlice->GetGeometry()->GetNode(nodeName);
942 if (node1) node1->Draw("same");
943
944
945// Draw clusters for all chambers
946 Int_t chamberSave = fChamber;
947 for (fChamber = 1; fChamber <= 10; fChamber++){
948 DrawCoG();
949 }
950 fChamber = chamberSave;
951// Draw reconstructed tracks
952 DrawTracks();
953
954 AppendPad();
955
956 Float_t zoom = 2.;
957 Float_t shift = 0.9;
958 Float_t x0 = (-1+shift)/zoom;
959 Float_t y0 = (-1+shift)/zoom;
960 Float_t x1 = (1+shift)/zoom;
961 Float_t y1 = (1+shift)/zoom;
962 gPad->Range(x0,y0,x1,y1);
963 view->SetView(phi, theta, psi, iret);
964
965}
a9e2aefa 966
967//______________________________________________________________________________
968void AliMUONDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
969{
5398f946 970/// Execute action corresponding to the mouse event
a9e2aefa 971
972 static Float_t x0, y0, x1, y1;
973
974 static Int_t pxold, pyold;
975 static Int_t px0, py0;
976 static Int_t linedrawn;
977 Float_t temp;
978
979 if (px == 0 && py == 0) { //when called by sliders
980 if (event == kButton1Up) {
981 Draw();
982 }
983 return;
984 }
985 if (!fZoomMode && gPad->GetView()) {
986 gPad->GetView()->ExecuteRotateView(event, px, py);
987 return;
988 }
989
990 // something to zoom ?
991 gPad->SetCursor(kCross);
992
993 switch (event) {
994
995 case kButton1Down:
996 gVirtualX->SetLineColor(-1);
997 gPad->TAttLine::Modify(); //Change line attributes only if necessary
998 x0 = gPad->AbsPixeltoX(px);
999 y0 = gPad->AbsPixeltoY(py);
1000 px0 = px; py0 = py;
1001 pxold = px; pyold = py;
1002 linedrawn = 0;
1003 return;
1004
1005 case kButton1Motion:
1006 if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
1007 pxold = px;
1008 pyold = py;
1009 linedrawn = 1;
1010 gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
1011 return;
1012
1013 case kButton1Up:
1014 gPad->GetCanvas()->FeedbackMode(kFALSE);
1015 if (px == px0) return;
1016 if (py == py0) return;
1017 x1 = gPad->AbsPixeltoX(px);
1018 y1 = gPad->AbsPixeltoY(py);
1019
1020 if (x1 < x0) {temp = x0; x0 = x1; x1 = temp;}
1021 if (y1 < y0) {temp = y0; y0 = y1; y1 = temp;}
1022 gPad->Range(x0,y0,x1,y1);
97ccf8cb 1023 if (fZooms < AliMUONConstants::MaxZoom()-1) {
a9e2aefa 1024 fZooms++;
1025 fZoomX0[fZooms] = x0;
1026 fZoomY0[fZooms] = y0;
1027 fZoomX1[fZooms] = x1;
1028 fZoomY1[fZooms] = y1;
1029 }
1030 gPad->Modified(kTRUE);
1031 return;
1032 }
1033}
1034
1035//___________________________________________
1036void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
1037{
5398f946 1038/// Read digits info and store x,y,z info in arrays fPoints.
1039/// Loop on all detectors
a9e2aefa 1040
1041 if (chamber > 14) return;
08a636a8 1042 fChamber = chamber;
1043 fCathode = cathode;
a9e2aefa 1044
1045 ResetPoints();
1046
08a636a8 1047 AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
1169bc87 1048
d226f81b 1049 GetMUONData()->SetTreeAddress("D");
a9e2aefa 1050
d226f81b 1051 TClonesArray *muonDigits = GetMUONData()->Digits(chamber-1);
a9e2aefa 1052 if (muonDigits == 0) return;
1053
d226f81b 1054 gAlice->ResetDigits();
00f56532 1055 Int_t nent = 0;
1056
1169bc87 1057 if (GetLoader()->TreeD()) {
1058 nent = (Int_t) GetLoader()->TreeD()->GetEntries();
1059 // gAlice->TreeD()->GetEvent(nent-2+cathode-1);
1060 GetMUONData()->GetDigits();
00f56532 1061 }
1062
1169bc87 1063 Int_t ndigits = muonDigits->GetEntriesFast();
a9e2aefa 1064 if (ndigits == 0) return;
1065 if (fPoints == 0) fPoints = new TObjArray(ndigits);
1066
b7ef3c96 1067 Float_t zpos = AliMUONConstants::DefaultChamberZ(chamber-1);
08a636a8 1068
a9e2aefa 1069 AliMUONDigit *mdig;
08a636a8 1070 AliMUONPoints *points = 0;
1071 TMarker3DBox *marker = 0;
1169bc87 1072
08a636a8 1073 Int_t npoints = 1;
7e4a628d 1074 Float_t adcmax = 1024; // default
1075 if (chamber<11) adcmax = 4096;
a9e2aefa 1076
1169bc87 1077// check if trigger is using new or old segmentation
1078 Bool_t old = true;
1079 AliMUONSegmentation* segmentation = pMUON->GetSegmentation();
666ada1e 1080 const AliMUONVGeometryDESegmentation* kdeSegmentation
1081 = segmentation->GetDESegmentation(1100, cathode-1);
94d085f8 1082 if ( dynamic_cast<const AliMUONTriggerSegmentation*>(kdeSegmentation) ) old = false;
a9e2aefa 1083
1169bc87 1084 if ( old && chamber > 10) {
1085 if (chamber > 10) printf(">>> old segmentation for trigger \n");
1086 else printf(">>> old segmentation for tracking \n");
76dadf7e 1087
1169bc87 1088 for (Int_t digit = 0; digit < ndigits; digit++) {
1089 mdig = (AliMUONDigit*)muonDigits->UncheckedAt(digit);
1090 if (mdig->Cathode() != cathode-1) continue;
1091
1092 //
1093 // First get all needed parameters
1094 //
45dd3605 1095 Float_t charge = mdig->Signal();
1169bc87 1096 Int_t index = Int_t(TMath::Log(charge)/(TMath::Log(adcmax)/22));
1097 Int_t color = 261+index;
1098 Int_t colorTrigger = 2;
1099 if (color > 282) color = 282;
1100
1101 if (chamber > 10) { // trigger chamber
1102
45dd3605 1103 Float_t sumCharge = 0;
1169bc87 1104 for (Int_t icharge = 0; icharge < 10; icharge++) {
1105 sumCharge = sumCharge+mdig->TrackCharge(icharge);
1106 }
45dd3605 1107 Float_t testCharge = sumCharge-(Int_t(sumCharge/10))*10;
1169bc87 1108 if(sumCharge <= 10 || testCharge > 0) {
1109 colorTrigger = color;
1110 } else {
1111 colorTrigger = 5;
1112 }
1113 }
1114
1115 // get the center of the pad - add on x and y half of pad size
1116 Float_t xpad, ypad, zpad;
1117 Int_t isec;
1118 Float_t dpx, dpy;
1119
1120 Int_t detElemId = mdig->DetElemId();
c2a43efa 1121 AliMUONGeometrySegmentation* segmentation2
1122 = pMUON->GetSegmentation()->GetModuleSegmentationByDEId(detElemId, cathode-1);
1169bc87 1123 segmentation2->GetPadC(detElemId, mdig->PadX(), mdig->PadY(), xpad, ypad, zpad);
1124 isec = segmentation2->Sector(detElemId, mdig->PadX(), mdig->PadY());
1125 dpx = segmentation2->Dpx(detElemId, isec)/2;
1126 dpy = segmentation2->Dpy(detElemId, isec)/2;
1127
1128 // Then set the objects
1129 points = new AliMUONPoints(npoints);
1130 fPoints->AddAt(points,digit);
1131 if (chamber > 10) {
1132 points->SetMarkerColor(colorTrigger);
1133 } else {
1134 points->SetMarkerColor(color);
1135 }
1136 points->SetMarkerStyle(21);
1137 points->SetMarkerSize(0.5);
1138 points->SetParticle(-1);
1139 points->SetHitIndex(-1);
1140 points->SetTrackIndex(-1);
1141 points->SetDigitIndex(digit);
1142 points->SetPoint(0,xpad,ypad,zpos);
1143
1144 Int_t lineColor = (zpad-zpos > 0) ? 2:3;
1145 marker=new TMarker3DBox(xpad,ypad,zpos,dpx,dpy,0,0,0);
1146
1147
1148 marker->SetLineColor(lineColor);
1149 marker->SetFillStyle(1001);
1150 marker->SetFillColor(color);
1151 marker->SetRefObject((TObject*)points);
1152 points->Set3DMarker(0, marker);
1153 } // end loop on digits
a9e2aefa 1154
1169bc87 1155 } else {
1156 if (chamber > 10) printf(">>> new segmentation for trigger \n");
1157 else printf(">>> new segmentation for tracking \n");
4554f81d 1158
1169bc87 1159 const AliMUONGeometryTransformer* kGeomTransformer
1160 = pMUON->GetGeometryTransformer();
1161
1162 //loop over all digits and store their position
1163 for (Int_t digit = 0; digit < ndigits; digit++) {
1164 mdig = (AliMUONDigit*)muonDigits->UncheckedAt(digit);
1165 if (mdig->Cathode() != cathode-1) continue;
08a636a8 1166
1169bc87 1167 // get all needed parameters
1168 Int_t ix=mdig->PadX();
1169 Int_t iy=mdig->PadY();
1170 Int_t detElemId=mdig->DetElemId();
45dd3605 1171 Float_t charge = mdig->Signal();
1169bc87 1172 Int_t index = Int_t(TMath::Log(charge)/(TMath::Log(adcmax)/22));
1173 Int_t color = 261+index;
1174 Int_t colorTrigger = 2;
1175 if (color > 282) color = 282;
1176
1177 const AliMpVSegmentation* seg =
666ada1e 1178 AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,cathode-1);
1169bc87 1179
98944e1e 1180 AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
1169bc87 1181
1182 if (chamber > 10) { // trigger chamber
45dd3605 1183 Float_t sumCharge = 0;
98944e1e 1184 Int_t n = mdig->Ntracks();
1185 for (Int_t icharge = 0; icharge < n; icharge++) {
1169bc87 1186 sumCharge = sumCharge+mdig->TrackCharge(icharge);
1187 }
45dd3605 1188 Float_t testCharge = sumCharge-(Int_t(sumCharge/n))*n;
98944e1e 1189 if(sumCharge <= n || testCharge > 0) {
1169bc87 1190 colorTrigger = color;
1191 } else {
1192 colorTrigger = 5;
1193 }
1194 }
1195
1196 // get the pad position and dimensions
1197 Float_t xlocal1 = pad.Position().X();
1198 Float_t ylocal1 = pad.Position().Y();
1199 Float_t xlocal2 = pad.Dimensions().X();
1200 Float_t ylocal2 = pad.Dimensions().Y();
1201
1202 Float_t xg1, xg2, yg1, yg2, zg1;
1203
1204 kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
1205 // (no transformation for pad dimensions)
1206 xg2 = xlocal2;
1207 yg2 = ylocal2;
1208
1209 // Then set the objects
1210 points = new AliMUONPoints(npoints);
1211 fPoints->AddAt(points,digit);
1212 if (chamber > 10) {
1213 points->SetMarkerColor(colorTrigger);
1214 } else {
1215 points->SetMarkerColor(color);
1216 }
1217 points->SetMarkerStyle(21);
1218 points->SetMarkerSize(0.5);
1219 points->SetParticle(-1);
1220 points->SetHitIndex(-1);
1221 points->SetTrackIndex(-1);
1222 points->SetDigitIndex(digit);
1223 points->SetPoint(0,xg1,yg1,zpos);
1224
1225 Int_t lineColor = (zg1-zpos > 0) ? 2:3;
1226 marker=new TMarker3DBox(xg1,yg1,zpos,xg2,yg2,0,0,0);
1227
1228 marker->SetLineColor(lineColor);
1229 marker->SetFillStyle(1001);
1230 marker->SetFillColor(color);
1231 marker->SetRefObject((TObject*)points);
1232 points->Set3DMarker(0, marker);
1233
1234 } // end loop on digits
1235 } // end of new segmentation
a9e2aefa 1236}
1237//___________________________________________
e0875ac1 1238void AliMUONDisplay::LoadCoG(Int_t chamber, Int_t /*cathode*/)
a9e2aefa 1239{
5398f946 1240/// Read raw clusters info and store x,y,z info in arrays fRpoints.
1241/// Loop on all detectors
a9e2aefa 1242
1243 if (chamber > 10) return;
1244
1245 ResetRpoints();
1246
d226f81b 1247 GetMUONData()->SetTreeAddress("RC");
1248 TClonesArray *muonRawClusters = GetMUONData()->RawClusters(chamber-1);
a9e2aefa 1249
7985603c 1250 if (muonRawClusters == 0) return;
a9e2aefa 1251
00f56532 1252 Int_t nent = 0;
d226f81b 1253 if (GetMUONData()->TreeR()) {
1254 nent=(Int_t) GetMUONData()->TreeR()->GetEntries();
1255 GetMUONData()->TreeR()->GetEvent(0);
00f56532 1256 }
1257
a9e2aefa 1258 Int_t nrawcl = muonRawClusters->GetEntriesFast();
1259 if (nrawcl == 0) return;
d226f81b 1260 if (fRpoints == 0) fRpoints = new TObjArray(nrawcl);
a9e2aefa 1261
b7ef3c96 1262 Float_t zpos = AliMUONConstants::DefaultChamberZ(chamber-1);
a9e2aefa 1263 AliMUONRawCluster *mRaw;
1264 AliMUONPoints *points = 0;
1265 //
1266 //loop over all raw clusters and store their position
1267 points = new AliMUONPoints(nrawcl);
1268 for (Int_t iraw=0;iraw<nrawcl;iraw++) {
1269 mRaw = (AliMUONRawCluster*)muonRawClusters->UncheckedAt(iraw);
a9e2aefa 1270 points->SetMarkerColor(51);
1271 points->SetMarkerStyle(2);
1272 points->SetMarkerSize(1.);
1273 points->SetParticle(-1);
1274 points->SetHitIndex(-1);
1275 points->SetTrackIndex(-1);
1276 points->SetDigitIndex(-1);
ba12c242 1277 points->SetPoint(iraw,mRaw->GetX(0),mRaw->GetY(0),zpos);
d226f81b 1278 fRpoints->AddAt(points,iraw);
ba12c242 1279 // printf("%f and %f and %f\n",mRaw->GetX(0),mRaw->GetY(0),mRaw->GetZ(0));
a9e2aefa 1280 }
1281}
572d5bb2 1282
1283//___________________________________________
1284void AliMUONDisplay::LoadTracks()
1285{
5398f946 1286/// Load tracks
1287
572d5bb2 1288 AliMUONTrack* recTrack = 0;
1289 AliMUONTrackParam* trackParam = 0;
1290 TClonesArray * trackParamAtHit = 0;
1291
1292 ResetRpoints();
1293
1294 GetMUONData()->SetTreeAddress("RT");
1295 TClonesArray* recTracksArray = GetMUONData()->RecTracks();
1296 if (recTracksArray == NULL) return;
1297 GetMUONData()->GetRecTracks();
1298
1299 Int_t nRecTracks = 0;
1300 if (recTracksArray)
1301 nRecTracks = (Int_t) recTracksArray->GetEntriesFast();
1302
1303
1304 if (fRpoints == 0) fRpoints = new TObjArray(nRecTracks);
1305
1306 for (Int_t iRecTracks = 0; iRecTracks < nRecTracks; iRecTracks++) {
1307 // reading info from tracks
1308 recTrack = (AliMUONTrack*) recTracksArray->At(iRecTracks);
1309
1310 Int_t nTrackHits = recTrack->GetNTrackHits();
1311
1312 if (nTrackHits == 0) continue;
1313
1314 Int_t iPoint = 0;
1315 TPolyLine3D *points = new TPolyLine3D(nTrackHits+1);
1316 points->SetLineColor(6);
1317 points->SetLineWidth(1);
1318 fRpoints->AddAt(points,iRecTracks);
1319
1320 Float_t xRec=0;
1321 Float_t yRec=0;
1322 Float_t zRec=0;
1323
1324 trackParam = recTrack->GetTrackParamAtVertex();
1325 xRec = trackParam->GetNonBendingCoor();
1326 yRec = trackParam->GetBendingCoor();
1327 zRec = trackParam->GetZ();
1328 points->SetPoint(iPoint,xRec,yRec,zRec);
1329 iPoint++;
1330
1331 for (Int_t iHit = 0; iHit < nTrackHits; iHit++){
1332 trackParamAtHit = recTrack->GetTrackParamAtHit();
1333 trackParam = (AliMUONTrackParam*) trackParamAtHit->At(iHit);
1334 xRec = trackParam->GetNonBendingCoor();
1335 yRec = trackParam->GetBendingCoor();
1336 zRec = trackParam->GetZ();
1337 points->SetPoint(iPoint,xRec,yRec,zRec);
1338 iPoint++;
1339 } // end loop rec. hits
1340 PrintTrack(iRecTracks,recTrack);
1341 } // end loop tracks
1342
1343
1344}
1345
5398f946 1346//___________________________________________
572d5bb2 1347void AliMUONDisplay::PrintTrack(Int_t iRecTracks, AliMUONTrack *recTrack)
1348{
5398f946 1349/// Print reconstructed track
1350
572d5bb2 1351 AliMUONTrackParam *trackParam;
1352 Float_t vertex[3], momentum[3];
1353 Float_t pYZ, bendingSlope, nonBendingSlope, chi2dof;
1354 Int_t charge;
1355
1356 trackParam = recTrack->GetTrackParamAtVertex();
1357 vertex[0] = trackParam->GetNonBendingCoor();
1358 vertex[1] = trackParam->GetBendingCoor();
1359 vertex[2] = trackParam->GetZ();
1360 pYZ = 1./TMath::Abs(trackParam->GetInverseBendingMomentum());
1361 bendingSlope = trackParam->GetBendingSlope();
1362 nonBendingSlope = trackParam->GetNonBendingSlope();
1363 momentum[2] = -pYZ / TMath::Sqrt(1.0 + bendingSlope*bendingSlope);
1364 momentum[0] = momentum[2] * nonBendingSlope;
1365 momentum[1] = momentum[2] * bendingSlope;
1366 charge = Int_t(TMath::Sign(1.,trackParam->GetInverseBendingMomentum()));
1367 chi2dof = recTrack->GetFitFMin()/(2.0 * recTrack->GetNTrackHits() - 5.);
1368
1369 printf("===================================================\n");
1370 printf(" Reconstructed track # %d \n",iRecTracks);
1371 printf(" charge: %d \n",charge);
1372 printf(" vertex x,y,z (cm): %f %f %f \n",vertex[0],vertex[1],vertex[2]);
1373 printf(" momentum Px,Py,Pz (GeV/c): %f %f %f \n",momentum[0],momentum[1],momentum[2]);
1374 printf(" track chi2/dof: %f \n",chi2dof);
1375
1376}
1377
a9e2aefa 1378//___________________________________________
a9e2aefa 1379void AliMUONDisplay::LoadHits(Int_t chamber)
1380{
5398f946 1381/// Read hits info and store x,y,z info in arrays fPhits.
1382/// Loop on all detectors
a9e2aefa 1383
1384 if (chamber > 14) return;
1385 Int_t track;
1386
1387 fChamber=chamber;
1388
1389 ResetPhits();
1390
b7ef3c96 1391 Float_t zpos=AliMUONConstants::DefaultChamberZ(chamber-1);
c856e086 1392
1393 if (GetMUONData()->TreeH()) {
1394 GetMUONData()->SetTreeAddress("H");
1395 Int_t ntracks = (Int_t)GetMUONData()->TreeH()->GetEntries(); //skowron
1396 Int_t nthits = 0;
1397 for (track = 0; track < ntracks; track++) {
d226f81b 1398 GetMUONData()->ResetHits();
1399 GetMUONData()->GetTrack(track);//skowron
1400 TClonesArray *muonHits = GetMUONData()->Hits();
a9e2aefa 1401 if (muonHits == 0) return;
1402 nthits += muonHits->GetEntriesFast();
c856e086 1403 }
1404 if (fPhits == 0) fPhits = new TObjArray(nthits);
1405 Int_t nhold=0;
1406 for (track=0; track<ntracks;track++) {
d226f81b 1407 GetMUONData()->ResetHits();
1408 GetMUONData()->GetTrack(track);//skowron
1409 TClonesArray *muonHits = GetMUONData()->Hits();
a9e2aefa 1410 if (muonHits == 0) return;
1411 Int_t nhits = muonHits->GetEntriesFast();
1412 if (nhits == 0) continue;
1413 AliMUONHit *mHit;
1414 AliMUONPoints *points = 0;
1415 Int_t npoints=1;
1416 for (Int_t hit=0;hit<nhits;hit++) {
c856e086 1417 mHit = (AliMUONHit*)muonHits->UncheckedAt(hit);
1418 Int_t nch = mHit->Chamber(); // chamber number
1419 if (nch != chamber) continue;
1420 //
1421 // Retrieve info and set the objects
1422 //
1423 points = new AliMUONPoints(npoints);
1424 fPhits->AddAt(points,nhold+hit);
1425 points->SetMarkerColor(kRed);
1426 points->SetMarkerStyle(5);
1427 points->SetMarkerSize(1.);
1428 points->SetParticle(mHit->Track());
1429 points->SetHitIndex(hit);
1430 points->SetTrackIndex(track);
1431 points->SetDigitIndex(-1);
1432 points->SetPoint(0,mHit->X(),mHit->Y(),zpos);
1433 // printf("%f and %f and %f\n",mHit->X(),mHit->Y(),mHit->Z());
a9e2aefa 1434 }
1435 nhold+=nhits;
c856e086 1436 }
a9e2aefa 1437 }
1438}
1439
1440//_____________________________________________________________________________
1441void AliMUONDisplay::Paint(Option_t *)
1442{
5398f946 1443/// Paint miscellaneous items
a9e2aefa 1444}
1445
1446//_____________________________________________________________________________
1447void AliMUONDisplay::SetPickMode()
1448{
5398f946 1449/// Set parameters for pick mode.
1450
a9e2aefa 1451 fZoomMode = 0;
1452
1453 fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
1454 fTrigPad->Modified();
1455}
1456
1457//_____________________________________________________________________________
1458void AliMUONDisplay::SetZoomMode()
1459{
5398f946 1460/// Set parameters for zoom mode
1461
a9e2aefa 1462 fZoomMode = 1;
1463
1464 fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
1465 fTrigPad->Modified();
1466}
1467
1468//_____________________________________________________________________________
1469void AliMUONDisplay::NextChamber(Int_t delta)
1470{
5398f946 1471/// To go from chamber to next chamber if delta = 1
1472/// or previous chamber otherwise
a9e2aefa 1473 if (delta == 1) {
f665c1ea 1474 if (fChamber < AliMUONConstants::NCh()) fChamber++;
a9e2aefa 1475 } else {
1476 if (fChamber > 1) fChamber--;
1477 }
1478 if (!fPad) return;
1479 fPad->Clear();
1480 LoadDigits(fChamber, fCathode);
572d5bb2 1481 DrawChamber();
a9e2aefa 1482}
1483
1484//_____________________________________________________________________________
1485void AliMUONDisplay::NextCathode()
1486{
5398f946 1487/// To switch to other cathode plane
1488
a9e2aefa 1489 if (!fPad) return;
1490 fPad->Clear();
1491 if (fCathode == 1) {
1492 LoadDigits(fChamber, 2);
1493 } else {
1494 LoadDigits(fChamber, 1);
1495 }
1496 fNextCathode = kTRUE; // to keep the same zoom
572d5bb2 1497 DrawChamber();
a9e2aefa 1498 fNextCathode = kFALSE;
1499 TPad *pad = (TPad*)gPad->GetPadSave();
1500 pad->Range(fZoomX0[fZooms], fZoomY0[fZooms],
1501 fZoomX1[fZooms], fZoomY1[fZooms]);
1502 pad->Modified();
1503 fPad->cd();
1504 DrawTitle();
1505}
1506
1507//_____________________________________________________________________________
1508void AliMUONDisplay::Trigger()
1509{
5398f946 1510/// Print global trigger output
52c9bc11 1511
d226f81b 1512 AliMUONGlobalTrigger* globalTrig;
1513
1514 GetMUONData()->SetTreeAddress("GLT");
95e68a13 1515 GetMUONData()->GetTriggerD();
d226f81b 1516
1517 globalTrig = (AliMUONGlobalTrigger*)GetMUONData()->GlobalTrigger()->UncheckedAt(0);
1518 if (globalTrig == 0) return;
1519
eba3379e 1520 globalTrig->Print("full");
d226f81b 1521
1522 // // returns Trigger Decision for current event
1523// AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(GetLoader(),1);
1524
1525// // AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
1526// AliMUONData* muonData = decision->GetMUONData();
1527// muonData->SetTreeAddress("D");
1528// decision->Trigger();
a9e2aefa 1529}
a9e2aefa 1530//_____________________________________________________________________________
1531void AliMUONDisplay::SetChamberAndCathode(Int_t chamber, Int_t cathode)
1532{
5398f946 1533/// Set chamber and cathode number
1534
a9e2aefa 1535 fChamber = chamber;
1536 fCathode = cathode;
1537
1538 if (!fPad) return;
1539 fPad->Clear();
1540 LoadDigits(chamber,cathode);
572d5bb2 1541 DrawChamber();
a9e2aefa 1542}
1543
5398f946 1544//_____________________________________________________________________________
a9e2aefa 1545void AliMUONDisplay::SetEvent(Int_t newevent)
1546{
5398f946 1547/// Chose event
1548
a9e2aefa 1549 gAlice->GetEvent(newevent);
1550 fEvent=newevent;
1551 if (!gAlice->TreeD()) return;
1552 if (!fPad) return;
1553 fPad->Clear();
1554 LoadDigits(fChamber,fCathode);
1555 Draw();
1556}
1557
1558//_____________________________________________________________________________
1559void AliMUONDisplay::SetRange(Float_t rrange, Float_t zrange)
1560{
5398f946 1561/// Set view range along R and Z
1562
a9e2aefa 1563 fRrange = rrange;
1564 fZrange = zrange;
1565
1566 if (!fPad) return;
1567 fPad->Clear();
1568 Draw();
1569}
1570
1571//_____________________________________________________________________________
1572void AliMUONDisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
1573{
5398f946 1574/// Change viewing angles for current event
a9e2aefa 1575
1576 fPad->cd();
1577 fPhi = phi;
1578 fTheta = theta;
1579 fPsi = psi;
1580 Int_t iret = 0;
1581
1582 TView *view = gPad->GetView();
1583 if (view) view->SetView(fPhi, fTheta, fPsi, iret);
1584 else Draw();
1585 gPad->Modified();
1586}
1587
1588//_____________________________________________________________________________
1589void AliMUONDisplay::ShowNextEvent(Int_t delta)
1590{
5398f946 1591/// Display (current event_number + delta)
1592/// - delta = 1 shown next event
1593/// - delta = -1 show previous event
1594
30178c30 1595 AliRunLoader * runLoader;
307d9d04 1596 if (fLoader)
30178c30 1597 runLoader = fLoader->GetRunLoader();
307d9d04 1598 else
30178c30 1599 runLoader = 0x0;
1391e633 1600
a9e2aefa 1601 if (delta) {
30178c30 1602 //runLoader->CleanDetectors();
1603 //runLoader->CleanKinematics();
1604 Int_t currentEvent = runLoader->GetEventNumber();
1391e633 1605 Int_t newEvent = currentEvent + delta;
30178c30 1606 runLoader->GetEvent(newEvent);
1391e633 1607 fEvent=newEvent;
a9e2aefa 1608 }
a9e2aefa 1609 LoadDigits(fChamber, fCathode);
1610 fPad->cd();
1611 Draw();
1612}
1613
1614//______________________________________________________________________________
1615void AliMUONDisplay::UnZoom()
1616{
5398f946 1617/// Unzoom
1618
a9e2aefa 1619 if (fZooms <= 0) return;
1620 fZooms--;
1621 TPad *pad = (TPad*)gPad->GetPadSave();
1622 pad->Range(fZoomX0[fZooms],fZoomY0[fZooms], fZoomX1[fZooms],fZoomY1[fZooms]);
1623 pad->Modified();
1624}
1625
1626//_____________________________________________________________________________
1627void AliMUONDisplay::ResetPoints()
1628{
5398f946 1629/// Reset array of points
1630
a9e2aefa 1631 if (fPoints) {
1632 fPoints->Delete();
1633 delete fPoints;
1634 fPoints = 0;
1635 }
1636}
1637//_____________________________________________________________________________
1638void AliMUONDisplay::ResetPhits()
1639{
5398f946 1640/// Reset array of points
1641
a9e2aefa 1642 if (fPhits) {
1643 fPhits->Delete();
1644 delete fPhits;
1645 fPhits = 0;
1646 }
1647}
1648//_____________________________________________________________________________
1649void AliMUONDisplay::ResetRpoints()
1650{
5398f946 1651/// Reset array of points
1652
d226f81b 1653 if (fRpoints) {
1654 fRpoints->Clear();
1655 // delete fRpoints;
1656 fRpoints = 0;
a9e2aefa 1657 }
1658}