Fixes to AliFMDDisplay and AliFMDPattern for use in DQM environment.
[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 "AliFMDRawReader.h"    // ALIFMDRAWREADER_H
58 #include <AliESDFMD.h>          // ALIESDFMD_H
59 // #include <AliLog.h>
60 #include "AliFMDDebug.h" // Better debug macros
61
62 //____________________________________________________________________
63 ClassImp(AliFMDDisplay)
64 #if 0
65   ; // This is here to keep Emacs for indenting the next line
66 #endif
67
68 //____________________________________________________________________
69 AliFMDDisplay* AliFMDDisplay::fgInstance = 0;
70
71 //____________________________________________________________________
72 const AliFMDDisplay::Range_t AliFMDDisplay::fgkEdepRange = {  100, 0.,    2. };
73 const AliFMDDisplay::Range_t AliFMDDisplay::fgkAdcRange  = { 1024, 0., 1023. };
74 const AliFMDDisplay::Range_t AliFMDDisplay::fgkMultRange = {  500, 0.,   20. };
75
76   
77 //____________________________________________________________________
78 AliFMDDisplay* 
79 AliFMDDisplay::Instance()
80 {
81   // Return static instance 
82   // If the instance does not exist
83   // it is not created!
84   return fgInstance;
85 }
86
87 //____________________________________________________________________
88 AliFMDDisplay::~AliFMDDisplay()
89 {
90   // Destructor. 
91   // Cleans 
92   // up 
93   if (fMarkers) {
94     fMarkers->Delete();
95     delete fMarkers;
96   }
97   if (fHits) {
98     fHits->Clear();
99     delete fHits;
100   }
101   if (fPad)     delete fPad;
102   fButtons.Delete();
103   if (fSlider)  delete fSlider;
104   if (fCanvas)  delete fCanvas;
105 }
106   
107 //____________________________________________________________________
108 AliFMDDisplay::AliFMDDisplay(Bool_t onlyFMD, const char* gAliceFile)
109   : AliFMDInput(gAliceFile),
110     fWait(kFALSE),
111     fMarkers(0),
112     fHits(0),
113     fCanvas(0), 
114     fPad(0), 
115     fButtons(0),
116     fSlider(0),
117     fFactor(0),
118     fZoomMode(kFALSE),
119     fX0(0),
120     fY0(0),
121     fX1(0),
122     fY1(0),
123     fXPixel(0),
124     fYPixel(0),
125     fOldXPixel(0),
126     fOldYPixel(0),
127     fLineDrawn(0),
128     fOnlyFMD(onlyFMD),
129     fSpec(0), 
130     fSpecCut(0),
131     fAux(0), 
132     fReturn(kFALSE), 
133     fContinous(kFALSE),
134     fTimeout("gApplication->StopIdleing()", 10)
135 {
136   // Constructor of an FMD display object. 
137   // Must be called 
138   // before Instance 
139   SetName("AliFMDDisplay");
140   SetTitle("3D Display of various kinds of FMD data");
141   AddLoad(kGeometry);
142   if (fgInstance) delete fgInstance;
143   fgInstance = this;
144 }
145
146 //____________________________________________________________________
147 void           
148 AliFMDDisplay::MakeCanvas(const char** which)
149 {
150   // Make a canvas 
151   // Parameters: 
152   //   which   Which button to put up. 
153   gStyle->SetPalette(1);
154   // gStyle->SetCanvasPreferGL(kTRUE);
155   Double_t y1 = .10;
156   Int_t    w  = 700;
157   fCanvas = new TCanvas(Form("gl%s", GetName()), 
158                         Form("%s - Display", GetTitle()), 
159                         w, Int_t(w / (1-y1)));
160   fCanvas->SetFillColor(1);
161   fCanvas->ToggleEventStatus();
162   fCanvas->cd();
163   fPad = new TPad("glview", "3DView", 0.0, y1, 1.0, 1.0, 1, 0, 0);
164   fPad->Draw();
165   
166   const char** p = which;
167   const char*  m;
168   Int_t        n  = 0;
169   Int_t        j  = 0;
170   while (*(p++)) n++;
171   AliFMDDebug(1, ("Got %d buttons", n));
172   if (n <= 0) return;
173
174   Double_t yb = 0;
175   Double_t xb = 1;
176   fCanvas->cd();
177   if (TESTBIT(fTreeMask, kDigits) || 
178       TESTBIT(fTreeMask, kRawCalib) || 
179       TESTBIT(fTreeMask, kRaw)) { 
180     yb = .05;
181     xb = .66;
182     fFactor = new TSlider("pedFactor", "Pedestal Factor", xb+.01, 0, 1, yb);
183     fFactor->SetMethod("AliFMDDisplay::Instance()->ChangeFactor()");
184     fFactor->SetRange(3./10, 1);
185     fFactor->Draw();
186     TSliderBox *sbox = 
187       static_cast<TSliderBox*>(fFactor->GetListOfPrimitives()->
188                                FindObject("TSliderBox"));
189     if (sbox) { 
190       sbox->SetToolTipText("Adjust the noise suppression factor by moving "
191                            "lower limit");
192     }
193   }
194   if (TESTBIT(fTreeMask, kHits)    || 
195       TESTBIT(fTreeMask, kESD)     || 
196       TESTBIT(fTreeMask, kDigits)  || 
197       TESTBIT(fTreeMask, kSDigits) || 
198       TESTBIT(fTreeMask, kRaw)     ||
199       TESTBIT(fTreeMask, kRawCalib)) {
200     yb = .05;
201     fSlider = new TSlider("genCut", "Multiplicity cut", 0, 0, xb, yb);
202     fSlider->SetMethod("AliFMDDisplay::Instance()->ChangeCut()");
203     fSlider->SetRange(0,1);
204     fSlider->Draw();
205     TSliderBox *sbox = 
206       static_cast<TSliderBox*>(fSlider->GetListOfPrimitives()->
207                                FindObject("TSliderBox"));
208     if (sbox) { 
209       sbox->SetToolTipText("Adjust lower and upper limit on data signal");
210     }
211   }
212   Float_t      x0 = 0;
213   Float_t      dx = 1. / n;
214   p               = which;
215   while ((m = *(p++))) {
216     fCanvas->cd();
217     AliFMDDebug(1, ("Adding button %s", m));
218     TButton* b = new TButton(m, Form("AliFMDDisplay::Instance()->%s()", m),
219                              x0, yb, TMath::Min(x0 + dx,.999F), y1);
220     b->Draw();
221     fButtons.Add(b);
222     x0 += dx;
223     j++;
224   }
225 }
226
227 //____________________________________________________________________
228 void           
229 AliFMDDisplay::ShowOnlyFMD()
230 {
231   // Show only the FMD 
232   // Do not show 
233   // other volumes 
234   if (!fGeoManager) return;
235   static bool once = false;
236   if (once) return;
237   once = true;
238   AliInfo("Will only show the FMD");
239   TGeoVolume* top = gGeoManager->GetTopVolume();
240   top->InvisibleAll(kTRUE);
241   TGeoIterator next(top);
242   TGeoNode* node;
243   TGeoVolume* v = 0;
244   Bool_t hasFMD1 = kFALSE;
245   Bool_t hasFMD2 = kFALSE;
246   Bool_t hasFMD3 = kFALSE;
247   AliFMDDebug(1, ("Getting material FMD_Si$"));
248   TGeoMaterial* si   = gGeoManager->GetMaterial("FMD_Si$");      // kRed 
249   AliFMDDebug(1, ("Getting material FMD_Carbon$"));
250   TGeoMaterial* c    = gGeoManager->GetMaterial("FMD_Carbon$");  // kGray
251   AliFMDDebug(1, ("Getting material FMD_Aluminum$"));
252   TGeoMaterial* al   = gGeoManager->GetMaterial("FMD_Aluminum$");// kGray-2
253   AliFMDDebug(1, ("Getting material FMD_Copper$"));
254   TGeoMaterial* cu   = gGeoManager->GetMaterial("FMD_Copper$"); // kGreen-2
255   AliFMDDebug(1, ("Getting material FMD_PCB$"));
256   TGeoMaterial* pcb  = gGeoManager->GetMaterial("FMD_PCB$");    // kGreen+2
257   AliFMDDebug(1, ("Getting material FMD_PCB$"));
258   TGeoMaterial* chip = gGeoManager->GetMaterial("FMD_Si Chip$");// kGreen+2
259   TObjArray     toshow;
260   while ((node = static_cast<TGeoNode*>(next()))) {
261     const char* name = node->GetName();
262     if (!name) continue;
263     if (!(v = node->GetVolume())) continue;
264
265     if (name[0] == 'F') {
266       TGeoMaterial* m   = (v->IsAssembly() ? 0 : v->GetMaterial());
267       Int_t         col = -1;
268       if      (m == si)   col = kRed;
269       else if (m == c)    col = kGray;
270       else if (m == al)   col = kYellow+4;  
271       else if (m == cu)   col = kRed+6;   
272       else if (m == pcb)  col = kGreen+2; 
273       else if (m == chip) col = kGreen+4; 
274       if (col >= 0) { 
275         v->SetLineColor(col);
276         v->SetFillColor(col);
277       }
278       if (name[2] == 'M' && (name[3] == 'T' || name[3] == 'B')) {
279         // Virtual Master half-ring volume - top-level
280         Int_t det = node->GetNumber();
281         switch (det) {
282         case 1: hasFMD1 = true; break;
283         case 2: hasFMD2 = true; break;
284         case 3: hasFMD3 = true; break;
285         default: continue;
286         }
287         toshow.Add(v);
288       }
289       else if (name[3] == 'V' && (name[2] == 'T' || name[2] == 'B')) 
290         toshow.Add(v); // Virtual Half-ring, bare detectors
291       else if (name[3] == 'H' && (name[2] == 'F' || name[2] == 'B')) 
292         toshow.Add(v); // Virtual Hybrid container 
293       else if (name[2] == 'S' && name[3] == 'U') 
294         toshow.Add(v); // Virtual support structre 
295       // else if (name[3] == 'H' && (name[2] == 'F' || name[2] == 'B')) 
296       //  toshow.Add(v); // Virtual Hybrid container 
297     }
298     v->SetVisibility(kFALSE);
299     v->SetVisDaughters(kFALSE);
300     v->InvisibleAll(kTRUE);
301   }
302   TIter i(&toshow);
303   while ((v = static_cast<TGeoVolume*>(i()))) {
304     if (!v->IsAssembly())
305       v->SetVisibility(kTRUE);
306     v->InvisibleAll(kFALSE);
307     v->SetVisDaughters(kTRUE);
308     
309   }  
310 }
311
312     
313 //____________________________________________________________________
314 void           
315 AliFMDDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py) 
316 {
317   // Execute an event on canvas 
318   // Parameters: 
319   //   event   What happened
320   //   px, py  Pixel coordinates 
321   if (px == 0 && py == 0) return;
322   if (!fZoomMode && fPad->GetView()) {
323     fPad->GetView()->ExecuteRotateView(event, px, py);
324     return;
325   }
326   fPad->SetCursor(kCross);
327   switch (event) {
328   case kButton1Down: 
329     fPad->TAttLine::Modify();
330     fX0        = fPad->AbsPixeltoX(px);
331     fY0        = fPad->AbsPixeltoY(py);
332     fXPixel    = fOldXPixel = px;
333     fYPixel    = fOldYPixel = py;
334     fLineDrawn = kFALSE;
335     return;
336   case kButton1Motion:
337     if (fLineDrawn) 
338       gVirtualX->DrawBox(fXPixel, fYPixel, fOldXPixel, fOldYPixel, 
339                          TVirtualX::kHollow);
340     fOldXPixel = px;
341     fOldYPixel = py;
342     fLineDrawn = kTRUE;
343     gVirtualX->DrawBox(fXPixel, fYPixel, fOldXPixel, fOldYPixel, 
344                        TVirtualX::kHollow);
345     return;
346   case kButton1Up:
347     fPad->GetCanvas()->FeedbackMode(kFALSE);
348     if (px == fXPixel || py == fYPixel) return;
349     fX1 = fPad->AbsPixeltoX(px);
350     fY1 = fPad->AbsPixeltoY(py);
351     if (fX1 < fX0) std::swap(fX0, fX1); 
352     if (fY1 < fY0) std::swap(fY0, fY1); 
353     fPad->Range(fX0, fY0, fX1, fY1);
354     fPad->Modified();
355     return;
356   }
357 }
358
359 //____________________________________________________________________
360 Bool_t 
361 AliFMDDisplay::Init()
362 {
363   // Initialize.  GEt transforms and such,
364   // so that we can draw thins properly 
365   // Returns true on success 
366   if (!AliFMDInput::Init()) return kFALSE;
367   AliFMDGeometry* geom = AliFMDGeometry::Instance();
368   geom->Init();
369   geom->InitTransformations();
370   if (TESTBIT(fTreeMask, kDigits) || TESTBIT(fTreeMask, kRaw)) 
371     AliFMDParameters::Instance()->Init();
372
373   fMarkers = new TObjArray;
374   fHits    = new TObjArray;
375   fMarkers->SetOwner(kTRUE);
376   fHits->SetOwner(kFALSE);
377   return kTRUE;
378 }
379
380 //____________________________________________________________________
381 void
382 AliFMDDisplay::MakeAux()
383 {
384   // MAke the aux canvas 
385   // This is used to display spectra
386   // etc, 
387   const Range_t* range = 0;
388   if      (TESTBIT(fTreeMask, kESD))      range = &fgkMultRange;
389   else if (TESTBIT(fTreeMask, kRawCalib)) range = &fgkMultRange;
390   else if (TESTBIT(fTreeMask, kDigits))   range = &fgkAdcRange;
391   else if (TESTBIT(fTreeMask, kSDigits))  range = &fgkAdcRange;
392   else if (TESTBIT(fTreeMask, kRaw))      range = &fgkAdcRange;
393   else if (TESTBIT(fTreeMask, kHits))     range = &fgkEdepRange;
394   if (!range) return;
395   
396   if (!fAux) {
397     fAux = new TCanvas("aux", "Aux");
398     fAux->SetLogy();
399     fAux->SetFillColor(kWhite);
400     fAux->SetBorderMode(0);
401     fAux->SetBorderSize(0);
402     Float_t dBin = (range->fHigh - range->fLow) / range->fNbins;
403     fSpec = new TH1D("spec", "Spectra", range->fNbins, 
404                      range->fLow-dBin/2, range->fHigh+dBin/2);
405     fSpecCut = static_cast<TH1*>(fSpec->Clone("specCut"));
406     fSpec->SetXTitle("signal");
407     fSpec->SetYTitle("events");
408     fSpec->SetFillColor(2);
409     fSpec->SetFillStyle(3001);
410     fSpecCut->SetXTitle("signal");
411     fSpecCut->SetYTitle("events");
412     fSpecCut->SetFillColor(4);
413     fSpecCut->SetFillStyle(3001);
414   }
415   else {
416     fSpec->Reset();
417     fSpecCut->Reset();
418   }  
419 }
420
421 //____________________________________________________________________
422 void
423 AliFMDDisplay::DrawAux()
424 {
425   // Draw in the Aux the canvas 
426   // For example draw the spectra 
427   // or such stuff 
428   if (!fAux) return;
429   fAux->cd();
430   fAux->Clear();
431   fAux->SetLogy(fSpec->GetMaximum() > 10);
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   AliFMDDebug(1, ("Drawing geometry"));
466   fPad->cd();
467   fGeoManager->GetTopVolume()->Draw();
468   if (fOnlyFMD) ShowOnlyFMD();
469   AliFMDDebug(1, ("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   if (fContinous) fTimeout.Start(10, kTRUE);
504   while (fWait) {
505     gApplication->StartIdleing();
506     gSystem->InnerLoop();
507     gApplication->StopIdleing();
508     if (fContinous) break;
509   }
510   AliFMDDebug(1, ("After idle loop"));
511   if (fMarkers) fMarkers->Delete();
512   if (fHits)    fHits->Clear();
513   AliFMDDebug(1, ("After clearing caches"));
514 }
515
516 //____________________________________________________________________
517 Bool_t 
518 AliFMDDisplay::End()
519 {
520   // End of event.  Draw everything 
521   AtEnd();
522   Idle();
523   if (fReturn) return kFALSE;
524   return AliFMDInput::End();
525 }
526
527 //____________________________________________________________________
528 Int_t
529 AliFMDDisplay::LookupColor(Float_t x, Float_t min, Float_t max) const
530 {
531   // Look-up color.  
532   // Get a colour from the  current palette depending 
533   // on the ratio x/max 
534   Float_t range  = (max-min);
535   Float_t l      = fSlider->GetMinimum();
536   Float_t h      = fSlider->GetMaximum();
537   if (l == h) { l = 0; h = 1; }
538   Float_t cmin   = range * l;
539   Float_t cmax   = range * h;
540   Float_t crange = (cmax-cmin);
541   Int_t   idx    = Int_t((x-cmin) / crange * gStyle->GetNumberOfColors());
542   return gStyle->GetColorPalette(idx);
543
544
545 //____________________________________________________________________
546 void
547 AliFMDDisplay::SetCut(Float_t l, Float_t h) 
548 {
549   // Change the cut on the slider. 
550   fSlider->SetMinimum(l);
551   fSlider->SetMaximum(h);
552   ChangeCut();
553 }
554
555 //____________________________________________________________________
556 void
557 AliFMDDisplay::ChangeCut() 
558 {
559   // Change the cut on the slider. 
560   // The factor depends on what is 
561   // drawn in the AUX canvas
562   AliInfo(Form("Range is now %7.5f - %7.5f", fSlider->GetMinimum(), 
563                fSlider->GetMaximum()));
564   if ((TESTBIT(fTreeMask, kESD)     || 
565        TESTBIT(fTreeMask, kDigits)  || 
566        TESTBIT(fTreeMask, kSDigits) || 
567        TESTBIT(fTreeMask, kRaw)     ||
568        TESTBIT(fTreeMask, kRawCalib))) {
569     Float_t l = fSlider->GetMinimum();
570     Float_t h = fSlider->GetMaximum();
571     l         = 1024 * l + 0;
572     h         = 1024 * h + 0;
573     AliInfo(Form("ADC range is now %4d - %4d", int(l), int(h)));
574   }
575   Redisplay();
576 }
577 //____________________________________________________________________
578 void
579 AliFMDDisplay::ChangeFactor() 
580 {
581   // Change the cut on the slider. 
582   // The factor depends on what is 
583   // drawn in the AUX canvas
584   AliInfo(Form("Noise factor is now %4.1f", 10 * fFactor->GetMinimum()));
585   Redisplay();
586 }
587
588 //____________________________________________________________________
589 void
590 AliFMDDisplay::Redisplay()
591 {
592   // Redisplay stuff. 
593   // Redraw markers, hits, 
594   // spectra 
595   if (fMarkers) fMarkers->Delete();
596   if (fHits)    fHits->Clear();
597   if (fSpec)    fSpec->Reset();
598   if (fSpecCut) fSpecCut->Reset();
599   Event();
600   AtEnd();
601 }
602 //____________________________________________________________________
603 void
604 AliFMDDisplay::Break()
605 {
606   // Redisplay stuff. 
607   // Redraw markers, hits, 
608   // spectra 
609   if (fMarkers) fMarkers->Delete();
610   if (fHits)    fHits->Clear();
611   if (fSpec)    fSpec->Reset();
612   if (fSpecCut) fSpecCut->Reset();
613   fReturn = kTRUE;
614   fWait   = kFALSE;
615 }
616 //____________________________________________________________________
617 void
618 AliFMDDisplay::Render()
619 {
620   fPad->cd();
621   TVirtualViewer3D* viewer = fPad->GetViewer3D("ogl");
622   if (!viewer) return;
623 }
624
625 //____________________________________________________________________
626 void
627 AliFMDDisplay::AddMarker(Float_t x, Float_t y, Float_t z,
628                          TObject* o, Float_t s, Float_t min, Float_t max)
629 {
630   // Add a marker to the display
631   //
632   //    det     Detector
633   //    rng     Ring
634   //    sec     Sector 
635   //    str     Strip
636   //    o       Object to refer to
637   //    s       Signal 
638   //    max     Maximum of signal 
639   //
640   Float_t  size  = .1;
641   Float_t  zsize = (s - min) / (max-min) * 10;
642   Float_t  r     = TMath::Sqrt(x * x + y * y);
643   Float_t  theta = TMath::ATan2(r, z);
644   Float_t  phi   = TMath::ATan2(y, x);
645   Float_t  rz    = z + (z < 0 ? 1 : -1) * zsize;
646   TMarker3DBox* marker = new  TMarker3DBox(x,y,rz,size,size,zsize,theta,phi);
647   if (o) marker->SetRefObject(o);
648   marker->SetLineColor(LookupColor(s, min, max));
649   fMarkers->Add(marker);
650 }
651 //____________________________________________________________________
652 void
653 AliFMDDisplay::AddMarker(UShort_t det, Char_t rng, UShort_t sec, UShort_t str,
654                          TObject* o, Float_t s, Float_t min, Float_t max)
655 {
656   // Add a marker to the display
657   //
658   //    det     Detector
659   //    rng     Ring
660   //    sec     Sector 
661   //    str     Strip
662   //    o       Object to refer to
663   //    s       Signal 
664   //    max     Maximum of signal 
665   //
666   AliFMDGeometry*   geom = AliFMDGeometry::Instance();
667   Double_t x, y, z;
668   geom->Detector2XYZ(det, rng, sec, str, x, y, z);
669   AddMarker(x,y,z,o,s,min,max);
670 }
671   
672 //____________________________________________________________________
673 Bool_t 
674 AliFMDDisplay::InsideCut(Float_t val, const Float_t& min, 
675                          const Float_t& max) const
676 {
677   Float_t r = max - min;
678   Float_t l = fSlider->GetMinimum();
679   Float_t h = fSlider->GetMaximum();
680   if (l == h) { l = 0; h = 1; }
681   if (val < r * l + min || val > r * h + min) { 
682     AliFMDDebug(1, ("Value %f is outside cut %f - %f (range %f - %f)", 
683                     val, min+r*l, min+r*h, min, max));
684     return kFALSE;
685   }
686   return kTRUE;
687 }
688
689
690 //____________________________________________________________________
691 Bool_t 
692 AliFMDDisplay::ProcessHit(AliFMDHit* hit, TParticle* /* p */) 
693 {
694   // Process a hit. 
695   // Parameters: 
696   //   hit   Hit data
697   static const Float_t rMin  = fgkEdepRange.fLow;
698   static const Float_t rMax  = fgkEdepRange.fHigh;
699
700   if (!hit) { AliError("No hit");   return kFALSE; }
701   // if (!p)   { AliError("No track"); return kFALSE; }
702   Float_t  edep  = hit->Edep();
703
704   if (fHits)                        fHits->Add(hit);
705   if (fSpec)                        fSpec->Fill(edep);
706   if (!InsideCut(edep, rMin, rMax)) return kTRUE;
707   if (fSpecCut)                     fSpecCut->Fill(edep);
708   
709   AddMarker(hit->X(), hit->Y(), hit->Z(), hit, edep, rMin, rMax);
710   return kTRUE;
711 }
712
713 //____________________________________________________________________
714 Bool_t 
715 AliFMDDisplay::ProcessDigit(AliFMDDigit* digit)
716 {
717   // Process a digit 
718   // Parameters: 
719   //   digit Digit information 
720   static const Float_t rMin  = fgkAdcRange.fLow;
721   static const Float_t rMax  = fgkAdcRange.fHigh;
722
723   if (!digit) { AliError("No digit");   return kFALSE; }
724
725   UShort_t det           =  digit->Detector();
726   Char_t   ring          =  digit->Ring();
727   UShort_t sec           =  digit->Sector();
728   UShort_t str           =  digit->Strip();
729   Double_t threshold     =  GetADCThreshold(det, ring, sec, str);
730   Float_t  counts        =  digit->Counts();
731   if (threshold < 0) { counts += -threshold; threshold = 0; }
732
733   AliFMDDebug(10, ("FMD%d%c[%02d,%03d] counts %4d threshold %4d", 
734                    det, ring, sec, str, Int_t(counts), Int_t(threshold)));
735   if (fHits)                                    fHits->Add(digit);
736   if (fSpec)                                    fSpec->Fill(counts);
737   if (!InsideCut(counts-threshold, rMin, rMax)) return kTRUE;
738   if (fSpecCut)                                 fSpecCut->Fill(counts);
739   
740
741   AddMarker(det, ring, sec, str, digit, counts, rMin, rMax);
742   return kTRUE;
743 }
744
745 //____________________________________________________________________
746 Bool_t 
747 AliFMDDisplay::ProcessSDigit(AliFMDSDigit* sdigit)
748 {
749   // Process a sdigit 
750   // Parameters: 
751   //   sdigit Digit information 
752   static const Float_t rMin  = fgkAdcRange.fLow;
753   static const Float_t rMax  = fgkAdcRange.fHigh;
754
755   if (!sdigit) { AliError("No sdigit");   return kFALSE; }
756   
757   UShort_t det           =  sdigit->Detector();
758   Char_t   ring          =  sdigit->Ring();
759   UShort_t sec           =  sdigit->Sector();
760   UShort_t str           =  sdigit->Strip();
761   Float_t  counts        =  sdigit->Counts();
762
763   if (fHits)                          fHits->Add(sdigit);
764   if (fSpec)                          fSpec->Fill(counts);
765   if (!InsideCut(counts, rMin, rMax)) return kTRUE;
766   if (fSpecCut)                       fSpecCut->Fill(counts);
767   
768   AddMarker(det, ring, sec, str, sdigit, counts, rMin, rMax);
769   return kTRUE;
770 }
771
772 //____________________________________________________________________
773 Bool_t 
774 AliFMDDisplay::ProcessRawDigit(AliFMDDigit* digit)
775 {
776   // PRocess raw data 
777   // Parameters: 
778   //   digit Digit information 
779   AliFMDDebug(50, ("Forwarding call of ProcessRaw to ProcessDigit "
780                   "for FMD%d&c[%02d,%03d] %d", 
781                   digit->Detector(), digit->Ring(), digit->Sector(), 
782                   digit->Strip(), digit->Counts()));
783   return ProcessDigit(digit);
784 }
785
786 //____________________________________________________________________
787 Bool_t 
788 AliFMDDisplay::ProcessRawCalibDigit(AliFMDDigit* digit)
789 {
790   // Process a digit 
791   // Parameters: 
792   //   digit Digit information 
793   static const Float_t rMin  = fgkMultRange.fLow;
794   static const Float_t rMax  = fgkMultRange.fHigh;
795   static const Float_t aMin  = fgkAdcRange.fLow;
796   static const Float_t aMax  = fgkAdcRange.fHigh;
797
798   if (!digit) { AliError("No digit");   return kFALSE; }
799
800   AliFMDParameters* parm = AliFMDParameters::Instance();
801   UShort_t det           =  digit->Detector();
802   Char_t   ring          =  digit->Ring();
803   UShort_t sec           =  digit->Sector();
804   UShort_t str           =  digit->Strip();
805   Double_t gain          =  parm->GetPulseGain(det, ring, sec, str);
806   Double_t ped           =  parm->GetPedestal(det, ring, sec, str);
807   Double_t threshold     =  GetADCThreshold(det, ring, sec, str);
808   Float_t  counts        =  digit->Counts();
809   if (threshold < 0) { counts += -threshold; threshold = 0; ped = 0; }
810
811   //   Double_t edep = ((counts * parm->GetEdepMip() / 
812   //                (gain * parm->GetDACPerMIP()));
813   Double_t mult = (counts-ped) / (gain * parm->GetDACPerMIP());
814   
815
816   AliFMDDebug(10, ("FMD%d%c[%02d,%03d] adc %4d "
817                    "(threshold %4d, gain %6.3f) -> mult %7.4f", 
818                    det, ring, sec, str, int(counts), int(threshold), 
819                    gain, mult));
820   if (fHits)                                    fHits->Add(digit);
821   if (fSpec)                                    fSpec->Fill(mult);
822   if (!InsideCut(counts-threshold, aMin, aMax)) return kTRUE;
823   if (fSpecCut)                                 fSpecCut->Fill(mult);
824   
825   if (mult >= 0) 
826     AddMarker(det, ring, sec, str, digit, mult, rMin, rMax);
827   return kTRUE;
828 }
829
830 //____________________________________________________________________
831 Bool_t 
832 AliFMDDisplay::ProcessRecPoint(AliFMDRecPoint* recpoint)
833 {
834   // Process reconstructed point 
835   // Parameters: 
836   //  recpoint  Reconstructed multiplicity/energy
837   static const Float_t rMin  = fgkMultRange.fLow;
838   static const Float_t rMax  = fgkMultRange.fHigh;
839
840
841   if (!recpoint) { AliError("No recpoint");   return kFALSE; }
842
843   if (!InsideCut(recpoint->Particles(), rMin, rMax)) return kTRUE;
844
845   if (fHits) fHits->Add(recpoint);
846   AddMarker(recpoint->Detector(), recpoint->Ring(), recpoint->Sector(),  
847             recpoint->Strip(), recpoint, recpoint->Particles(), rMin, rMax);
848   return kTRUE;
849 }
850
851 //____________________________________________________________________
852 Bool_t 
853 AliFMDDisplay::ProcessESD(UShort_t det, Char_t rng, UShort_t sec, UShort_t str,
854                           Float_t, Float_t mult)
855 {
856   // Process data from ESD 
857   // Parameters 
858   //   det,rng,sec,str   Detector coordinates. 
859   //   mult              Multiplicity. 
860   static const Float_t rMin  = fgkMultRange.fLow;
861   static const Float_t rMax  = fgkMultRange.fHigh;
862   
863   Double_t cmult = mult;
864   if (fSpec) fSpec->Fill(cmult);
865   if (!InsideCut(cmult, rMin, rMax) || cmult == AliESDFMD::kInvalidMult) 
866     return kTRUE;
867
868   AddMarker(det,rng,sec,str, 0, cmult, rMin, rMax);
869
870   if (fSpecCut) fSpecCut->Fill(cmult);
871
872   return kTRUE;
873 }
874
875 Double_t
876 AliFMDDisplay::GetADCThreshold(UShort_t d, Char_t r, 
877                                UShort_t s, UShort_t t) const
878 {
879   AliFMDParameters* parm = AliFMDParameters::Instance();
880   Double_t ped           =  parm->GetPedestal(d,r, s, t);
881   Double_t pedW          =  parm->GetPedestalWidth(d,r, s, t);
882   Double_t threshold     = 0;
883   if (fFMDReader && fFMDReader->IsZeroSuppressed(d-1))
884     threshold = - fFMDReader->NoiseFactor(d-1) * pedW;
885   else 
886     threshold = ped + pedW * 10 * fFactor->GetMinimum();
887   AliFMDDebug(10, ("FMD%d%c[%2d,%3d] ped: %f +/- %f [factor: %f-%f]", 
888                    d, r, s, t, ped, pedW, 
889                    fFactor->GetMinimum(), fFactor->GetMaximum()));
890   if (threshold > fgkAdcRange.fHigh) threshold = fgkAdcRange.fHigh;
891   return threshold;
892 }
893
894 //____________________________________________________________________
895 //
896 // EOF
897 //