Several fixes (the Make-Federico-Happy-Commit):
[u/mrichter/AliRoot.git] / FMD / AliFMDDisplay.cxx
1 /**************************************************************************
2  * Copyright(c) 2004, 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 /* $Id$ */
16 /** @file    AliFMDDisplay.cxx
17     @author  Christian Holm Christensen <cholm@nbi.dk>
18     @date    Mon Mar 27 12:39:09 2006
19     @brief   FMD Event display 
20 */
21 //___________________________________________________________________
22 //
23 // The classes defined here, are utility classes for reading in data
24 // for the FMD.  They are  put in a seperate library to not polute the
25 // normal libraries.  The classes are intended to be used as base
26 // classes for customized class that do some sort of analysis on the
27 // various types of data produced by the FMD. 
28 //
29 // Latest changes by Christian Holm Christensen
30 //
31
32 #include <TSystem.h>
33 #include <TApplication.h>
34 #include <TButton.h>
35 #include <TCanvas.h>
36 #include <TGeoManager.h>
37 #include <TH1D.h>
38 #include <TMarker3DBox.h>
39 #include <TMath.h>
40 #include <TSlider.h>
41 #include <TSliderBox.h>
42 #include <TStyle.h>
43 #include <TView.h>
44 #include <TVirtualX.h>
45 #include <TVirtualViewer3D.h>
46 #include <TList.h>
47 // #include <TArrayF.h>
48 // #include <TParticle.h>
49
50 #include "AliFMDDisplay.h"      // ALIFMDDISPLAY_H
51 #include "AliFMDHit.h"          // ALIFMDHIT_H
52 #include "AliFMDDigit.h"        // ALIFMDDIGIT_H
53 #include "AliFMDSDigit.h"       // ALIFMDSDIGIT_H
54 #include "AliFMDRecPoint.h"     // ALIFMDRECPOINT_H
55 #include "AliFMDGeometry.h"     // ALIFMDGEOMETRY_H
56 #include "AliFMDParameters.h"   // ALIFMDPARAMETERS_H
57 #include <AliESDFMD.h>          // ALIESDFMD_H
58 // #include <AliLog.h>
59 #include "AliFMDDebug.h" // Better debug macros
60
61 //____________________________________________________________________
62 ClassImp(AliFMDDisplay)
63 #if 0
64   ; // This is here to keep Emacs for indenting the next line
65 #endif
66
67 //____________________________________________________________________
68 AliFMDDisplay* AliFMDDisplay::fgInstance = 0;
69
70 //____________________________________________________________________
71 const AliFMDDisplay::Range_t AliFMDDisplay::fgkEdepRange = {  100, 0.,    2. };
72 const AliFMDDisplay::Range_t AliFMDDisplay::fgkAdcRange  = { 1024, 0., 1023. };
73 const AliFMDDisplay::Range_t AliFMDDisplay::fgkMultRange = {  500, 0.,   20. };
74
75   
76 //____________________________________________________________________
77 AliFMDDisplay* 
78 AliFMDDisplay::Instance()
79 {
80   // Return static instance 
81   // If the instance does not exist
82   // it is not created!
83   return fgInstance;
84 }
85
86 //____________________________________________________________________
87 AliFMDDisplay::~AliFMDDisplay()
88 {
89   // Destructor. 
90   // Cleans 
91   // up 
92   if (fMarkers) {
93     fMarkers->Delete();
94     delete fMarkers;
95   }
96   if (fHits) {
97     fHits->Clear();
98     delete fHits;
99   }
100   if (fPad)     delete fPad;
101   fButtons.Delete();
102   if (fSlider)  delete fSlider;
103   if (fCanvas)  delete fCanvas;
104 }
105   
106 //____________________________________________________________________
107 AliFMDDisplay::AliFMDDisplay(Bool_t onlyFMD, const char* gAliceFile)
108   : AliFMDInput(gAliceFile),
109     fWait(kFALSE),
110     fMarkers(0),
111     fHits(0),
112     fCanvas(0), 
113     fPad(0), 
114     fButtons(0),
115     fSlider(0),
116     fFactor(0),
117     fZoomMode(kFALSE),
118     fX0(0),
119     fY0(0),
120     fX1(0),
121     fY1(0),
122     fXPixel(0),
123     fYPixel(0),
124     fOldXPixel(0),
125     fOldYPixel(0),
126     fLineDrawn(0),
127     fOnlyFMD(onlyFMD),
128     fSpec(0), 
129     fSpecCut(0),
130     fAux(0), 
131     fReturn(kFALSE)
132 {
133   // Constructor of an FMD display object. 
134   // Must be called 
135   // before Instance 
136   SetName("AliFMDDisplay");
137   SetTitle("3D Display of various kinds of FMD data");
138   AddLoad(kGeometry);
139   if (fgInstance) delete fgInstance;
140   fgInstance = this;
141 }
142
143 //____________________________________________________________________
144 void           
145 AliFMDDisplay::MakeCanvas(const char** which)
146 {
147   // Make a canvas 
148   // Parameters: 
149   //   which   Which button to put up. 
150   gStyle->SetPalette(1);
151   // gStyle->SetCanvasPreferGL(kTRUE);
152   Double_t y1 = .10;
153   Int_t    w  = 700;
154   fCanvas = new TCanvas(Form("gl%s", GetName()), 
155                         Form("%s - Display", GetTitle()), 
156                         w, Int_t(w / (1-y1)));
157   fCanvas->SetFillColor(1);
158   fCanvas->ToggleEventStatus();
159   fCanvas->cd();
160   fPad = new TPad("glview", "3DView", 0.0, y1, 1.0, 1.0, 1, 0, 0);
161   fPad->Draw();
162   
163   const char** p = which;
164   const char*  m;
165   Int_t        n  = 0;
166   Int_t        j  = 0;
167   while (*(p++)) n++;
168   AliInfo(Form("Got %d buttons", n));
169   if (n <= 0) return;
170
171   Double_t yb = 0;
172   Double_t xb = 1;
173   fCanvas->cd();
174   if (TESTBIT(fTreeMask, kDigits)) { 
175     yb = .05;
176     xb = .66;
177     fFactor = new TSlider("pedFactor", "Pedestal Factor", xb+.01, 0, 1, yb);
178     fFactor->SetMethod("AliFMDDisplay::Instance()->ChangeFactor()");
179     fFactor->SetRange(3./10, 1);
180     fFactor->Draw();
181     TSliderBox *sbox = 
182       static_cast<TSliderBox*>(fFactor->GetListOfPrimitives()->
183                                FindObject("TSliderBox"));
184     if (sbox) { 
185       sbox->SetToolTipText("Adjust the noise suppression factor by moving "
186                            "lower limit");
187     }
188   }
189   if (TESTBIT(fTreeMask, kHits)    || 
190       TESTBIT(fTreeMask, kESD)     || 
191       TESTBIT(fTreeMask, kDigits)  || 
192       TESTBIT(fTreeMask, kSDigits) || 
193       TESTBIT(fTreeMask, kRaw)) {
194     yb = .05;
195     fSlider = new TSlider("genCut", "Multiplicity cut", 0, 0, xb, yb);
196     fSlider->SetMethod("AliFMDDisplay::Instance()->ChangeCut()");
197     fSlider->SetRange(0,1);
198     fSlider->Draw();
199     TSliderBox *sbox = 
200       static_cast<TSliderBox*>(fSlider->GetListOfPrimitives()->
201                                FindObject("TSliderBox"));
202     if (sbox) { 
203       sbox->SetToolTipText("Adjust lower and upper limit on data signal");
204     }
205   }
206   Float_t      x0 = 0;
207   Float_t      dx = 1. / n;
208   p               = which;
209   while ((m = *(p++))) {
210     fCanvas->cd();
211     AliInfo(Form("Adding button %s", m));
212     TButton* b = new TButton(m, Form("AliFMDDisplay::Instance()->%s()", m),
213                              x0, yb, TMath::Min(x0 + dx,.999F), y1);
214     b->Draw();
215     fButtons.Add(b);
216     x0 += dx;
217     j++;
218   }
219 }
220
221 //____________________________________________________________________
222 void           
223 AliFMDDisplay::ShowOnlyFMD()
224 {
225   // Show only the FMD 
226   // Do not show 
227   // other volumes 
228   if (!fGeoManager) return;
229   static bool once = false;
230   if (once) return;
231   once = true;
232   AliInfo("Will only show the FMD");
233   TGeoVolume* top = gGeoManager->GetTopVolume();
234   top->InvisibleAll(kTRUE);
235   TGeoIterator next(top);
236   TGeoNode* node;
237   TGeoVolume* v = 0;
238   Bool_t hasFMD1 = kFALSE;
239   Bool_t hasFMD2 = kFALSE;
240   Bool_t hasFMD3 = kFALSE;
241   AliInfo("Getting material FMD_Si$");
242   TGeoMaterial* si   = gGeoManager->GetMaterial("FMD_Si$");      // kRed 
243   AliInfo("Getting material FMD_Carbon$");
244   TGeoMaterial* c    = gGeoManager->GetMaterial("FMD_Carbon$");  // kGray
245   AliInfo("Getting material FMD_Aluminum$");
246   TGeoMaterial* al   = gGeoManager->GetMaterial("FMD_Aluminum$");// kGray-2
247   AliInfo("Getting material FMD_Copper$");
248   TGeoMaterial* cu   = gGeoManager->GetMaterial("FMD_Copper$"); // kGreen-2
249   AliInfo("Getting material FMD_PCB$");
250   TGeoMaterial* pcb  = gGeoManager->GetMaterial("FMD_PCB$");    // kGreen+2
251   AliInfo("Getting material FMD_PCB$");
252   TGeoMaterial* chip = gGeoManager->GetMaterial("FMD_Si Chip$");// kGreen+2
253   TObjArray     toshow;
254   while ((node = static_cast<TGeoNode*>(next()))) {
255     const char* name = node->GetName();
256     if (!name) continue;
257     if (!(v = node->GetVolume())) continue;
258
259     if (name[0] == 'F') {
260       TGeoMaterial* m   = (v->IsAssembly() ? 0 : v->GetMaterial());
261       Int_t         col = -1;
262       if      (m == si)   col = kRed;
263       else if (m == c)    col = kGray;
264       else if (m == al)   col = kYellow+4;  
265       else if (m == cu)   col = kRed+6;   
266       else if (m == pcb)  col = kGreen+2; 
267       else if (m == chip) col = kGreen+4; 
268       if (col >= 0) { 
269         v->SetLineColor(col);
270         v->SetFillColor(col);
271       }
272       if (name[2] == 'M' && (name[3] == 'T' || name[3] == 'B')) {
273         // Virtual Master half-ring volume - top-level
274         Int_t det = node->GetNumber();
275         switch (det) {
276         case 1: hasFMD1 = true; break;
277         case 2: hasFMD2 = true; break;
278         case 3: hasFMD3 = true; break;
279         default: continue;
280         }
281         toshow.Add(v);
282       }
283       else if (name[3] == 'V' && (name[2] == 'T' || name[2] == 'B')) 
284         toshow.Add(v); // Virtual Half-ring, bare detectors
285       else if (name[3] == 'H' && (name[2] == 'F' || name[2] == 'B')) 
286         toshow.Add(v); // Virtual Hybrid container 
287       else if (name[2] == 'S' && name[3] == 'U') 
288         toshow.Add(v); // Virtual support structre 
289       // else if (name[3] == 'H' && (name[2] == 'F' || name[2] == 'B')) 
290       //  toshow.Add(v); // Virtual Hybrid container 
291     }
292     v->SetVisibility(kFALSE);
293     v->SetVisDaughters(kFALSE);
294     v->InvisibleAll(kTRUE);
295   }
296   TIter i(&toshow);
297   while ((v = static_cast<TGeoVolume*>(i()))) {
298     if (!v->IsAssembly())
299       v->SetVisibility(kTRUE);
300     v->InvisibleAll(kFALSE);
301     v->SetVisDaughters(kTRUE);
302     
303   }  
304 }
305
306     
307 //____________________________________________________________________
308 void           
309 AliFMDDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py) 
310 {
311   // Execute an event on canvas 
312   // Parameters: 
313   //   event   What happened
314   //   px, py  Pixel coordinates 
315   if (px == 0 && py == 0) return;
316   if (!fZoomMode && fPad->GetView()) {
317     fPad->GetView()->ExecuteRotateView(event, px, py);
318     return;
319   }
320   fPad->SetCursor(kCross);
321   switch (event) {
322   case kButton1Down: 
323     fPad->TAttLine::Modify();
324     fX0        = fPad->AbsPixeltoX(px);
325     fY0        = fPad->AbsPixeltoY(py);
326     fXPixel    = fOldXPixel = px;
327     fYPixel    = fOldYPixel = py;
328     fLineDrawn = kFALSE;
329     return;
330   case kButton1Motion:
331     if (fLineDrawn) 
332       gVirtualX->DrawBox(fXPixel, fYPixel, fOldXPixel, fOldYPixel, 
333                          TVirtualX::kHollow);
334     fOldXPixel = px;
335     fOldYPixel = py;
336     fLineDrawn = kTRUE;
337     gVirtualX->DrawBox(fXPixel, fYPixel, fOldXPixel, fOldYPixel, 
338                        TVirtualX::kHollow);
339     return;
340   case kButton1Up:
341     fPad->GetCanvas()->FeedbackMode(kFALSE);
342     if (px == fXPixel || py == fYPixel) return;
343     fX1 = fPad->AbsPixeltoX(px);
344     fY1 = fPad->AbsPixeltoY(py);
345     if (fX1 < fX0) std::swap(fX0, fX1); 
346     if (fY1 < fY0) std::swap(fY0, fY1); 
347     fPad->Range(fX0, fY0, fX1, fY1);
348     fPad->Modified();
349     return;
350   }
351 }
352
353 //____________________________________________________________________
354 Int_t          
355 AliFMDDisplay::DistancetoPrimitive(Int_t px, Int_t) 
356 {
357   // Calculate the distance from point to 
358   // something in the canvas. 
359   // Depends on the zoom mode. 
360   fPad->SetCursor(kCross);
361   Float_t xmin = fPad->GetX1();
362   Float_t xmax = fPad->GetX2();
363   Float_t dx   = .02 * (xmax - xmin);
364   Float_t x    = fPad->AbsPixeltoX(px);
365   if (x < xmin + dx || x > xmax - dx) return 9999;
366   return (fZoomMode ? 0 : 7);
367 }
368 //____________________________________________________________________
369 Bool_t 
370 AliFMDDisplay::Init()
371 {
372   // Initialize.  GEt transforms and such,
373   // so that we can draw thins properly 
374   // Returns true on success 
375   if (!AliFMDInput::Init()) return kFALSE;
376   AliFMDGeometry* geom = AliFMDGeometry::Instance();
377   geom->Init();
378   geom->InitTransformations();
379   if (TESTBIT(fTreeMask, kDigits) || TESTBIT(fTreeMask, kRaw)) 
380     AliFMDParameters::Instance()->Init();
381
382   fMarkers = new TObjArray;
383   fHits    = new TObjArray;
384   fMarkers->SetOwner(kTRUE);
385   fHits->SetOwner(kFALSE);
386   return kTRUE;
387 }
388
389 //____________________________________________________________________
390 void
391 AliFMDDisplay::MakeAux()
392 {
393   // MAke the aux canvas 
394   // This is used to display spectra
395   // etc, 
396   const Range_t* range = 0;
397   if      (TESTBIT(fTreeMask, kESD))      range = &fgkMultRange;
398   else if (TESTBIT(fTreeMask, kDigits))   range = &fgkAdcRange;
399   else if (TESTBIT(fTreeMask, kSDigits))  range = &fgkAdcRange;
400   else if (TESTBIT(fTreeMask, kRaw))      range = &fgkAdcRange;
401   else if (TESTBIT(fTreeMask, kHits))     range = &fgkEdepRange;
402   if (!range) return;
403   
404   if (!fAux) {
405     fAux = new TCanvas("aux", "Aux");
406     fAux->SetLogy();
407     Float_t dBin = (range->fHigh - range->fLow) / range->fNbins;
408     fSpec = new TH1D("spec", "Spectra", range->fNbins, 
409                      range->fLow-dBin/2, range->fHigh-dBin/2);
410     fSpecCut = static_cast<TH1*>(fSpec->Clone("specCut"));
411     fSpec->SetFillColor(2);
412     fSpec->SetFillStyle(3001);
413     fSpecCut->SetFillColor(4);
414     fSpecCut->SetFillStyle(3001);
415   }
416   else {
417     fSpec->Reset();
418     fSpecCut->Reset();
419   }  
420 }
421
422 //____________________________________________________________________
423 void
424 AliFMDDisplay::DrawAux()
425 {
426   // Draw in the Aux the canvas 
427   // For example draw the spectra 
428   // or such stuff 
429   if (!fAux) return;
430   fAux->cd();
431   fAux->Clear();
432   fSpec->Draw();
433   fSpecCut->Draw("same");
434   fAux->Modified();
435   fAux->Update();
436   fAux->cd();
437 }
438
439 //____________________________________________________________________
440 Bool_t 
441 AliFMDDisplay::Begin(Int_t event) 
442 {
443   // Begin of event.  Make canvas is not already done 
444   // Parameters: 
445   //   event   The event number 
446   if (!fCanvas) {
447     const char* m[] = { "Continue", 
448                         "Break", 
449                         "Zoom", 
450                         "Pick", 
451                         "Redisplay", 
452                         "Render", 
453                         0 }; 
454     MakeCanvas(m);
455   }
456   MakeAux();
457   fReturn = kFALSE;
458   
459   // AliInfo("Clearing canvas");
460   // fCanvas->Clear();
461   if (!fGeoManager) {
462     Warning("End", "No geometry manager");
463     return kFALSE;
464   }
465   AliInfo("Drawing geometry");
466   fPad->cd();
467   fGeoManager->GetTopVolume()->Draw();
468   if (fOnlyFMD) ShowOnlyFMD();
469   AliInfo("Adjusting view");
470   Int_t irep;
471   if (fPad->GetView()) {
472     fPad->GetView()->SetView(-200, -40, 80, irep);
473     fPad->GetView()->Zoom();
474     fPad->Modified();
475     fPad->cd();
476   }
477   return AliFMDInput::Begin(event);
478 }
479
480 //____________________________________________________________________
481 void
482 AliFMDDisplay::AtEnd() 
483 {
484   // Called at of the event. 
485   // Draw stuff. 
486   // Draw spectrum. 
487   fPad->cd();
488   fMarkers->Draw();
489   fPad->cd();
490   AppendPad();
491   fPad->cd();
492   DrawAux();
493 }
494
495 //____________________________________________________________________
496 void
497 AliFMDDisplay::Idle() 
498 {
499   // Idle loop. 
500   // Sends the ROOT loop into the idle loop,
501   // so that we can go on. 
502   fWait = kTRUE;
503   while (fWait) {
504     gApplication->StartIdleing();
505     gSystem->InnerLoop();
506     gApplication->StopIdleing();
507   }
508   AliInfo("After idle loop");
509   if (fMarkers) fMarkers->Delete();
510   if (fHits)    fHits->Clear();
511   AliInfo("After clearing caches");
512 }
513
514 //____________________________________________________________________
515 Bool_t 
516 AliFMDDisplay::End()
517 {
518   // End of event.  Draw everything 
519   AtEnd();
520   Idle();
521   if (fReturn) return kFALSE;
522   return AliFMDInput::End();
523 }
524
525 //____________________________________________________________________
526 Int_t
527 AliFMDDisplay::LookupColor(Float_t x, Float_t min, Float_t max) const
528 {
529   // Look-up color.  
530   // Get a colour from the  current palette depending 
531   // on the ratio x/max 
532   Float_t range  = (max-min);
533   Float_t l      = fSlider->GetMinimum();
534   Float_t h      = fSlider->GetMaximum();
535   if (l == h) { l = 0; h = 1; }
536   Float_t cmin   = range * l;
537   Float_t cmax   = range * h;
538   Float_t crange = (cmax-cmin);
539   Int_t   idx    = Int_t((x-cmin) / crange * gStyle->GetNumberOfColors());
540   return gStyle->GetColorPalette(idx);
541
542
543 //____________________________________________________________________
544 void
545 AliFMDDisplay::SetCut(Float_t l, Float_t h) 
546 {
547   // Change the cut on the slider. 
548   fSlider->SetMinimum(l);
549   fSlider->SetMaximum(h);
550   ChangeCut();
551 }
552
553 //____________________________________________________________________
554 void
555 AliFMDDisplay::ChangeCut() 
556 {
557   // Change the cut on the slider. 
558   // The factor depends on what is 
559   // drawn in the AUX canvas
560   AliInfo(Form("Range is now %7.5f - %7.5f", fSlider->GetMinimum(), 
561                fSlider->GetMaximum()));
562   if ((TESTBIT(fTreeMask, kESD) || 
563        TESTBIT(fTreeMask, kDigits) || 
564        TESTBIT(fTreeMask, kSDigits) || 
565        TESTBIT(fTreeMask, kRaw))) {
566     Float_t l = fSlider->GetMinimum();
567     Float_t h = fSlider->GetMaximum();
568     l         = 1024 * l + 0;
569     h         = 1024 * h + 0;
570     AliInfo(Form("ADC range is now %4d - %4d", int(l), int(h)));
571   }
572   Redisplay();
573 }
574 //____________________________________________________________________
575 void
576 AliFMDDisplay::ChangeFactor() 
577 {
578   // Change the cut on the slider. 
579   // The factor depends on what is 
580   // drawn in the AUX canvas
581   AliInfo(Form("Noise factor is now %4.1f, pedestal factor %3.1f", 
582                10*fFactor->GetMinimum(),fFactor->GetMaximum()));
583   Redisplay();
584 }
585
586 //____________________________________________________________________
587 void
588 AliFMDDisplay::Redisplay()
589 {
590   // Redisplay stuff. 
591   // Redraw markers, hits, 
592   // spectra 
593   if (fMarkers) fMarkers->Delete();
594   if (fHits)    fHits->Clear();
595   if (fSpec)    fSpec->Reset();
596   if (fSpecCut) fSpecCut->Reset();
597   Event();
598   AtEnd();
599 }
600 //____________________________________________________________________
601 void
602 AliFMDDisplay::Break()
603 {
604   // Redisplay stuff. 
605   // Redraw markers, hits, 
606   // spectra 
607   if (fMarkers) fMarkers->Delete();
608   if (fHits)    fHits->Clear();
609   if (fSpec)    fSpec->Reset();
610   if (fSpecCut) fSpecCut->Reset();
611   fReturn = kTRUE;
612   fWait   = kFALSE;
613 }
614 //____________________________________________________________________
615 void
616 AliFMDDisplay::Render()
617 {
618   fPad->cd();
619   TVirtualViewer3D* viewer = fPad->GetViewer3D("ogl");
620   if (!viewer) return;
621 }
622
623 //____________________________________________________________________
624 void
625 AliFMDDisplay::AddMarker(Float_t x, Float_t y, Float_t z,
626                          TObject* o, Float_t s, Float_t min, Float_t max)
627 {
628   // Add a marker to the display
629   //
630   //    det     Detector
631   //    rng     Ring
632   //    sec     Sector 
633   //    str     Strip
634   //    o       Object to refer to
635   //    s       Signal 
636   //    max     Maximum of signal 
637   //
638   Float_t  size  = .1;
639   Float_t  zsize = (s - min) / (max-min) * 10;
640   Float_t  r     = TMath::Sqrt(x * x + y * y);
641   Float_t  theta = TMath::ATan2(r, z);
642   Float_t  phi   = TMath::ATan2(y, x);
643   Float_t  rz    = z + (z < 0 ? 1 : -1) * zsize;
644   TMarker3DBox* marker = new  TMarker3DBox(x,y,rz,size,size,zsize,theta,phi);
645   if (o) marker->SetRefObject(o);
646   marker->SetLineColor(LookupColor(s, min, max));
647   fMarkers->Add(marker);
648 }
649 //____________________________________________________________________
650 void
651 AliFMDDisplay::AddMarker(UShort_t det, Char_t rng, UShort_t sec, UShort_t str,
652                          TObject* o, Float_t s, Float_t min, Float_t max)
653 {
654   // Add a marker to the display
655   //
656   //    det     Detector
657   //    rng     Ring
658   //    sec     Sector 
659   //    str     Strip
660   //    o       Object to refer to
661   //    s       Signal 
662   //    max     Maximum of signal 
663   //
664   AliFMDGeometry*   geom = AliFMDGeometry::Instance();
665   Double_t x, y, z;
666   geom->Detector2XYZ(det, rng, sec, str, x, y, z);
667   AddMarker(x,y,z,o,s,min,max);
668 }
669   
670 //____________________________________________________________________
671 Bool_t 
672 AliFMDDisplay::InsideCut(Float_t val, const Float_t& min, 
673                          const Float_t& max) const
674 {
675   Float_t r = max - min;
676   Float_t l = fSlider->GetMinimum();
677   Float_t h = fSlider->GetMaximum();
678   if (l == h) { l = 0; h = 1; }
679   if (val < r * l + min || val > r * h + min) return kFALSE;
680   return kTRUE;
681 }
682
683
684 //____________________________________________________________________
685 Bool_t 
686 AliFMDDisplay::ProcessHit(AliFMDHit* hit, TParticle* /* p */) 
687 {
688   // Process a hit. 
689   // Parameters: 
690   //   hit   Hit data
691   static const Float_t rMin  = fgkEdepRange.fLow;
692   static const Float_t rMax  = fgkEdepRange.fHigh;
693
694   if (!hit) { AliError("No hit");   return kFALSE; }
695   // if (!p)   { AliError("No track"); return kFALSE; }
696   Float_t  edep  = hit->Edep();
697
698   if (fHits)                        fHits->Add(hit);
699   if (fSpec)                        fSpec->Fill(edep);
700   if (!InsideCut(edep, rMin, rMax)) return kTRUE;
701   if (fSpecCut)                     fSpecCut->Fill(edep);
702   
703   AddMarker(hit->X(), hit->Y(), hit->Z(), hit, edep, rMin, rMax);
704   return kTRUE;
705 }
706
707 //____________________________________________________________________
708 Bool_t 
709 AliFMDDisplay::ProcessDigit(AliFMDDigit* digit)
710 {
711   // Process a digit 
712   // Parameters: 
713   //   digit Digit information 
714   static const Float_t rMin  = fgkAdcRange.fLow;
715   static const Float_t rMax  = fgkAdcRange.fHigh;
716
717   if (!digit) { AliError("No digit");   return kFALSE; }
718
719   AliFMDParameters* parm = AliFMDParameters::Instance();
720   UShort_t det           =  digit->Detector();
721   Char_t   ring          =  digit->Ring();
722   UShort_t sec           =  digit->Sector();
723   UShort_t str           =  digit->Strip();
724   Double_t ped           =  parm->GetPedestal(det,ring, sec, str);
725   Double_t pedW          =  parm->GetPedestalWidth(det,ring, sec, str);
726   Double_t threshold     =  (ped * fFactor->GetMaximum()
727                              + pedW * fFactor->GetMinimum());
728   Float_t  counts        =  digit->Counts();
729
730   if (fHits)                                    fHits->Add(digit);
731   if (fSpec)                                    fSpec->Fill(counts);
732   if (!InsideCut(counts-threshold, rMin, rMax)) return kTRUE;
733   if (fSpecCut)                                 fSpecCut->Fill(counts);
734   
735
736   AddMarker(det, ring, sec, str, digit, counts, rMin, rMax);
737   return kTRUE;
738 }
739
740 //____________________________________________________________________
741 Bool_t 
742 AliFMDDisplay::ProcessSDigit(AliFMDSDigit* sdigit)
743 {
744   // Process a sdigit 
745   // Parameters: 
746   //   sdigit Digit information 
747   static const Float_t rMin  = fgkAdcRange.fLow;
748   static const Float_t rMax  = fgkAdcRange.fHigh;
749
750   if (!sdigit) { AliError("No sdigit");   return kFALSE; }
751   
752   UShort_t det           =  sdigit->Detector();
753   Char_t   ring          =  sdigit->Ring();
754   UShort_t sec           =  sdigit->Sector();
755   UShort_t str           =  sdigit->Strip();
756   Float_t  counts        =  sdigit->Counts();
757
758   if (fHits)                          fHits->Add(sdigit);
759   if (fSpec)                          fSpec->Fill(counts);
760   if (!InsideCut(counts, rMin, rMax)) return kTRUE;
761   if (fSpecCut)                       fSpecCut->Fill(counts);
762   
763   AddMarker(det, ring, sec, str, sdigit, counts, rMin, rMax);
764   return kTRUE;
765 }
766
767 //____________________________________________________________________
768 Bool_t 
769 AliFMDDisplay::ProcessRaw(AliFMDDigit* digit)
770 {
771   // PRocess raw data 
772   // Parameters: 
773   //   digit Digit information 
774   return ProcessDigit(digit);
775 }
776
777 //____________________________________________________________________
778 Bool_t 
779 AliFMDDisplay::ProcessRecPoint(AliFMDRecPoint* recpoint)
780 {
781   // Process reconstructed point 
782   // Parameters: 
783   //  recpoint  Reconstructed multiplicity/energy
784   static const Float_t rMin  = fgkMultRange.fLow;
785   static const Float_t rMax  = fgkMultRange.fHigh;
786
787
788   if (!recpoint) { AliError("No recpoint");   return kFALSE; }
789
790   if (!InsideCut(recpoint->Particles(), rMin, rMax)) return kTRUE;
791
792   if (fHits) fHits->Add(recpoint);
793   AddMarker(recpoint->Detector(), recpoint->Ring(), recpoint->Sector(),  
794             recpoint->Strip(), recpoint, recpoint->Particles(), rMin, rMax);
795   return kTRUE;
796 }
797
798 //____________________________________________________________________
799 Bool_t 
800 AliFMDDisplay::ProcessESD(UShort_t det, Char_t rng, UShort_t sec, UShort_t str,
801                           Float_t, Float_t mult)
802 {
803   // Process data from ESD 
804   // Parameters 
805   //   det,rng,sec,str   Detector coordinates. 
806   //   mult              Multiplicity. 
807   static const Float_t rMin  = fgkMultRange.fLow;
808   static const Float_t rMax  = fgkMultRange.fHigh;
809   
810   Double_t cmult = mult;
811   if (fSpec) fSpec->Fill(cmult);
812   if (!InsideCut(cmult, rMin, rMax) || cmult == AliESDFMD::kInvalidMult) 
813     return kTRUE;
814
815   AddMarker(det,rng,sec,str, 0, cmult, rMin, rMax);
816
817   if (fSpecCut) fSpecCut->Fill(cmult);
818
819   return kTRUE;
820 }
821
822 //____________________________________________________________________
823 //
824 // EOF
825 //