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