Coverity
[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveFMDLoader.cxx
1 /**************************************************************************
2  * Copyright(c) 2008, Christian Holm Christensen                          *
3  *                                                                        *
4  * Author: Christian Holm Christensen.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation for any purposes is hereby granted without fee,          * 
9  * provided that the above copyright notice appears in all copies and     *
10  * that both the copyright notice and this permission notice remains      *
11  * intact.  The authors make no claims about the suitability of this      * 
12  * software for any purpose. It is provided "as is" without express or    *
13  * implied warranty.                                                      * 
14  **************************************************************************/
15 /* $Id$ */
16 /** @file    AliEveFMDLoader.cxx
17     @author  Christian Holm Christensen <cholm@nbi.dk>
18     @date    Sun Mar 26 17:59:18 2006
19     @brief   Implementation of AliEveFMDLoader singleton class 
20 */
21 //____________________________________________________________________
22 //                                                                          
23 // Forward Multiplicity Detector based on Silicon wafers. This class
24 // is the loader for the event display. 
25 //
26 // This class is a singleton, meaning that there's only one instance
27 // of this.  This is done to speed up the processing by putting all
28 // things that are needed every time into the constructor. 
29 //
30 #include "AliRunLoader.h"
31 #include "EveBase/AliEveEventManager.h"
32 #include "AliEveFMDLoader.h"
33 #include "../FMD/AliFMDUShortMap.h"
34 #include "../FMD/AliFMDBoolMap.h"
35 #include "../FMD/AliFMDGeometry.h"
36 #include "../FMD/AliFMDParameters.h"
37 #include "../FMD/AliFMDDetector.h"
38 #include "../FMD/AliFMDRing.h"
39 #include "../FMD/AliFMDBaseDigit.h"
40 #include "../FMD/AliFMDDigit.h"
41 #include "../FMD/AliFMDRawReader.h"
42 #include "../FMD/AliFMDHit.h"
43 #include "AliESDEvent.h"
44 #include "AliESDFMD.h"
45 #include "AliLog.h"
46 #include "AliRawReader.h"
47 #include <TClonesArray.h>
48 #include <TTree.h>
49 #include <TGeoShape.h>
50 #include <TGeoManager.h>
51 #include <TEveGeoNode.h>
52 #include <TEveBoxSet.h>
53 #include <TEveQuadSet.h>
54 #include <TEveManager.h>
55 #include <TEveUtil.h>
56 #include <TStyle.h>
57 #include <TMath.h>
58 #include <iostream>
59
60 // Some very private variables. 
61 namespace 
62 {
63   const Char_t* kDetector = "FMD%d";
64   const Char_t* kRing     = "FMD%d%c";
65   const Char_t* kModule   = "FMD%d%c[%02d-%02d]";
66   const Char_t* kSector   = "FMD%d%c[%02d] %s";
67
68   const Char_t* kHits     = "Hits";
69   const Char_t* kDigits   = "Digits";
70   const Char_t* kRaw      = "Raw";
71   const Char_t* kESD      = "ESD";
72   
73 }
74
75 //____________________________________________________________________
76 AliEveFMDLoader* AliEveFMDLoader::fgInstance = 0;
77
78 //____________________________________________________________________
79 AliEveFMDLoader* AliEveFMDLoader::Instance()
80 {
81   // Get the singleton instance.  If the instance has not been
82   // instantised yet, it will be after this call.
83   if (!fgInstance) 
84     fgInstance = new AliEveFMDLoader();
85   return fgInstance;
86 }
87
88 //____________________________________________________________________
89 AliEveFMDLoader::AliEveFMDLoader(const char* name, Bool_t useBoxes, 
90                                  Bool_t /* old */)
91   : TEveElementList(name, 0), 
92     fHitPalette(0, 1000),
93     fDigitPalette(0, 1023), 
94     fMultPalette(0, 20),
95     fUseBoxDigits(useBoxes), 
96     fHitCache("AliFMDHit",0),
97     fDigitCache("AliFMDDigit", 0),
98     fRawCache("AliFMDDigit", 0)
99 {
100   // Constructor 
101   // Parameters:
102   // @param name     Name of the folder. 
103   // @param useBoxes Whether to use boxes or Quads for the signals 
104   // @param old      Whether to enable reading old RCU data format
105
106   // increase reference count 
107   IncDenyDestroy();
108   
109   // Increase reference counts on palettes 
110   fHitPalette.IncRefCount();
111   fDigitPalette.IncRefCount();
112   fMultPalette.IncRefCount();
113   
114   
115   // Initialize the FMD geometry manager 
116   TGeoManager* geoMan  = AliEveEventManager::AssertGeometry();
117   if (!geoMan) return;
118   geoMan->GetTopVolume()->cd(0);
119
120   AliFMDGeometry* geom = AliFMDGeometry::Instance();
121   geom->Init();
122   geom->InitTransformations();
123
124   AliFMDParameters* pars = AliFMDParameters::Instance();
125   // pars->UseRcuTrailer(!old);
126   // pars->UseCompleteHeader(old);
127   // pars->SetSampleRate(4);
128   pars->Init(kFALSE, 0);
129
130   // Get shapes
131   TGeoShape* inner = static_cast<TGeoShape*>(gGeoManager->GetListOfShapes()
132                                              ->FindObject("FMDI_physical_sensor"));
133   if (!inner) throw TEveException("Shape of inner type sensors not found");
134   TGeoShape* outer = static_cast<TGeoShape*>(gGeoManager->GetListOfShapes()
135                                              ->FindObject("FMDO_physical_sensor"));
136   if (!outer) throw TEveException("Shape of outer type sensors not found");
137
138   // Emulate reference counting 
139   inner->SetUniqueID(1000);
140   outer->SetUniqueID(1000);
141   
142   // Loop over detectors 
143   for (UShort_t d = 1; d <= 3; d++) { 
144     AliFMDDetector*  detector = geom->GetDetector(d);
145     if (!detector) continue;
146     TEveElementList* ed       = new TEveElementList(Form(kDetector, 
147                                                          detector->GetId()));
148     AddElement(ed);
149     ed->IncDenyDestroy();
150     ed->SetUserData(detector);
151
152     // Loop over rings 
153     Char_t           rings[]  = { 'I', 'O', 0 };
154     Char_t*          pr       = &(rings[0]);
155     while (*pr) { 
156       AliFMDRing* ring = detector->GetRing(*pr);
157       pr++;
158       if (!ring) continue;
159       TEveElementList* er      = new TEveElementList(Form(kRing, 
160                                                           detector->GetId(),
161                                                           ring->GetId()));
162       ed->AddElement(er);
163       er->IncDenyDestroy();
164       er->SetUserData(ring);
165       
166       // UShort_t      nsec    = ring->GetNSectors();
167       // UShort_t      nstr    = ring->GetNStrips();
168       UShort_t         nmod    = ring->GetNModules();
169       // Loop over modules 
170       for (UShort_t m = 0; m < nmod; m++) { 
171         TEveGeoShape* em = new TEveGeoShape(Form(kModule, 
172                                                  detector->GetId(),
173                                                  ring->GetId(), 
174                                                  2*m, 2*m+1));
175         er->AddElement(em);
176         em->SetTransMatrix(*(detector->FindTransform(ring->GetId(), 2*m)));
177         em->SetShape(ring->GetId() == 'I' ? inner : outer);
178         em->SetMainColor(Color_t(kGray));
179         em->SetMainTransparency(32);
180         em->IncDenyDestroy();
181         ModuleData* data = new ModuleData;
182         data->fScaledSum = 0;
183         em->SetUserData(data);
184
185 #if 0
186         for (UShort_t s = 2*m; s < 2*m+2 && s < nsec; s++) { 
187           TEveDigitSet* eb = MakeDigitSet(Form(kSector,
188                                                detector->GetId(), 
189                                                ring->GetId(), s), nstr);
190           em->AddElement(eb);
191           eb->SetEmitSignals(kFALSE);
192           eb->SetPickable(kTRUE);
193           // eb->SetOwnIds(kTRUE);
194         } // for (UShort_t s ...)
195 #endif
196       }  // for (UShort_t m ...)
197     }  // while (pr)
198   }  // for (UShort_t d ...)
199 }
200
201 //____________________________________________________________________
202 AliEveFMDLoader::~AliEveFMDLoader()
203 {
204   // Destructor
205   AliWarning("AliEveFMDLoader being destroyed!");
206 }
207
208 //____________________________________________________________________
209 Int_t
210 AliEveFMDLoader::RemoveFromListTrees(TEveElement* el)
211 {
212   // Called when the element should be removed from the list. We
213   // overload this to allow clearing of signals.
214   // Parameters:
215   // @param el Tree to remove from.
216
217   // Since we're most likely setting up for a new event, we clear all
218   // signals here - a little tricky, but it works(tm). 
219   ClearDigitSets("All");
220   
221   // Do normal TEveElement::RemoveElement
222   return TEveElementList::RemoveFromListTrees(el);
223 }
224 //____________________________________________________________________
225 void
226 AliEveFMDLoader::RemoveParent(TEveElement* el)
227 {
228   // Called when the element should be removed from the list. We
229   // overload this to allow clearing of signals.
230   // Parameters:
231   // @param el Parent to remove from.
232   TEveElementList::RemoveParent(el);
233 }
234
235 //____________________________________________________________________
236 TEveDigitSet* 
237 AliEveFMDLoader::MakeDigitSet(const char* name, UShort_t nstr)
238 {
239   // Make a digit set.  The type of digit set depends on the setting
240   // of fUseBoxDigits.  If this is true, we return a TEveBoxSet,
241   // otherwise a TEveQuadSet   
242   // Parameters: 
243   //    name    The name 
244   //    nstr    The number of strips 
245   // Return 
246   //    newly allocated digit set
247   TEveDigitSet* ret = 0;
248   if (fUseBoxDigits) { 
249     TEveBoxSet* boxes = new TEveBoxSet(name);
250     // boxes->Reset(TEveBoxSet::kBT_AABox, kFALSE, nstr);
251     boxes->Reset(TEveBoxSet::kBT_FreeBox, kFALSE, nstr);
252     ret = boxes;
253   }
254   else { 
255     TEveQuadSet* quads = new TEveQuadSet(name);
256     quads->Reset(TEveQuadSet::kQT_RectangleXY, kFALSE, nstr);
257     ret = quads;
258   }
259   return ret;
260 }
261
262 //____________________________________________________________________
263 void
264 AliEveFMDLoader::ClearDigitSets(const char* type)
265 {
266   // Clear signals of some type.   
267   // Parameters:
268   // @param type Type of signals to clear 
269   //     Type can be one of 
270   //     - All    All signals 
271   //     - Hits   Hits 
272   //     - Digits Digits 
273   //     - Raw    Raw 
274   //     - ESD    ESD 
275   TString stype(type);
276
277   for (TEveElement::List_i di = BeginChildren(); 
278        di != EndChildren(); ++di) { 
279     for (TEveElement::List_i ri = (*di)->BeginChildren(); 
280          ri != (*di)->EndChildren(); ++ri) { 
281       for (TEveElement::List_i mi = (*ri)->BeginChildren();
282            mi != (*ri)->EndChildren(); ++mi) { 
283         ModuleData* data = static_cast<ModuleData*>((*mi)->GetUserData());
284         data->fScaledSum = 0;
285         (*mi)->SetMainColor(Color_t(kGray));
286         if (stype == "All") {
287           (*mi)->RemoveElements();
288           continue;
289         }
290         for (TEveElement::List_i si = (*mi)->BeginChildren(); 
291              si != (*mi)->EndChildren(); ++si) { 
292           TEveDigitSet* signals = static_cast<TEveDigitSet*>((*si));
293           if (!signals) continue;
294           TString s(signals->GetName());
295           if (!s.Contains(type)) continue;
296           (*mi)->RemoveElement(signals);
297         }
298       }
299     }
300   }
301 }
302
303 //____________________________________________________________________
304 TEveDigitSet*
305 AliEveFMDLoader::FindDigitSet(const char* t, UShort_t d, Char_t r, UShort_t s)
306 {
307   // Find a digit set corresponding to the passed parameters.  If it
308   // is not found, one is created
309   // Parameters:
310   // @param type   Type of data 
311   // @param d      Detector 
312   // @param r      Ring 
313   // @param s      Sector 
314   // @return a digit set
315   TEveElement* detector = FindChild(Form(kDetector, d));
316   if (!detector) { 
317     AliError(Form("Detector %s not found", Form(kDetector, d)));
318     return 0;
319   }
320   
321   TEveElement* ring = detector->FindChild(Form(kRing, d, r));
322   if (!ring) { 
323     AliError(Form("Ring %s not found", Form(kRing, d, r)));
324     return 0;
325   }
326   
327   Int_t mod = 2*(s/2);
328   TEveElement* module = ring->FindChild(Form(kModule, d, r, mod, mod+1));
329   if (!module) { 
330     AliError(Form("Module %s not found", Form(kModule, d, r, s, s+1)));
331     return 0;
332   }
333   
334   TEveElement*  sector = module->FindChild(Form(kSector, d, r, s, t));
335   TEveDigitSet* signal = static_cast<TEveDigitSet*>(sector);
336   if (!sector) { 
337     AliFMDRing* rng = AliFMDGeometry::Instance()->GetRing(r);
338     signal = MakeDigitSet(Form(kSector, d, r, s, t), rng->GetNStrips());
339     module->AddElement(signal);
340     signal->SetEmitSignals(kFALSE);
341     signal->SetPickable(kTRUE);
342     TString st(t);
343     if      (t == kHits)   signal->SetPalette(&fHitPalette);
344     else if (t == kDigits) signal->SetPalette(&fDigitPalette);
345     else if (t == kRaw)    signal->SetPalette(&fDigitPalette);
346     else if (t == kESD) {
347       signal->SetPalette(&fMultPalette);
348       signal->SetOwnIds(kTRUE);
349     }    
350   }
351   return signal;
352 }
353
354 //____________________________________________________________________
355 void
356 AliEveFMDLoader::AddSignal(const char* t, 
357                            UShort_t det, Char_t rng, UShort_t sec, 
358                            UShort_t str, Float_t signal, Float_t min, 
359                            Float_t  max, TObject* ref)
360 {
361   // Add a signal to a digit set
362   // Parameters:
363   // @param type   Type of data 
364   // @param det    Detector 
365   // @param rng    Ring 
366   // @param sec    Sector 
367   // @param str    Strip
368   // @param signal Signal value 
369   // @param min    Minimum of this kind of signal 
370   // @param max    Maximum of this kind of signal 
371   // @param ref    Reference object 
372   AliFMDGeometry* geom = AliFMDGeometry::Instance();
373   Double_t x, y, z;
374   geom->Detector2XYZ(det, rng, sec, str, x, y, z);
375   AddSignal(t, det, rng, sec, str, x, y, z, signal, min, max, ref);
376 }
377
378 //____________________________________________________________________
379 void
380 AliEveFMDLoader::AddSignal(const char* t, 
381                            UShort_t det, Char_t rng, UShort_t sec, 
382                            UShort_t str, Double_t x, Double_t y, Double_t z, 
383                            Float_t signal, Float_t min, Float_t  max, 
384                            TObject* ref)
385 {
386   // Add a signal to a digit set, with known (x,y,z) coordinates
387   // (this is for hits)
388   // Parameters:
389   // @param type   Type of data 
390   // @param det    Detector 
391   // @param rng    Ring 
392   // @param sec    Sector 
393   // @param str    Strip
394   // @param x      X coordinate  
395   // @param y      Y coordinate  
396   // @param z      Z coordinate  
397   // @param signal Signal value 
398   // @param min    Minimum of this kind of signal 
399   // @param max    Maximum of this kind of signal 
400   // @param ref    Reference object 
401   AliFMDGeometry* geom = AliFMDGeometry::Instance();
402   AliFMDRing*     ring = geom->GetRing(rng);
403   if (!ring) return;
404
405   TEveDigitSet* signals = FindDigitSet(t, det, rng, sec);
406   if (!signals) { 
407     AliWarning(Form("No signal (%s) found for FMD%d%c[%02d,%03d]", 
408                     t, det, rng, sec, str));
409     return;
410   }
411   
412   Float_t  scaled = TMath::Min((signal - min) / (max - min) * 10., 10.);
413   if ((scaled - min) < 1e-6) { 
414     // Very small (scalled) signals are ignored 
415     AliDebug(10, Form("Skipping small %s signal at FMD%d%c[%02d,%03d]=%f (s-min=%f<1e-6)", 
416                       t, det, rng, sec, str, signal, scaled-min));
417     return;
418   }
419   Double_t w      = 2*ring->GetPitch();
420   Int_t    value  = int(TMath::Nint(signal));
421   AliDebug(5, Form("New %s signal at FMD%d%c[%02d,%03d]=%f (v=%d, s=%f)", 
422                    t, det, rng, sec, str, signal, value, scaled));
423   AddDigit(signals, x, y, z, w, scaled, value, ref);
424 }
425
426 //____________________________________________________________________
427 void
428 AliEveFMDLoader::AddDigit(TEveDigitSet* signals, 
429                           Double_t x, Double_t y, Double_t z, 
430                           Double_t w, Float_t scaled, Int_t value, 
431                           TObject* ref)
432 {
433   // Add a digit to a digit set. 
434   // Parameters:
435   // @param signals Digit set. 
436   // @param x      X coordinate  
437   // @param y      Y coordinate  
438   // @param z      Z coordinate  
439   // @param w      strip pitch 
440   // @param scaled Scaled value 
441   // @param value  Signal value 
442   // @param ref    Reference object
443   if (fUseBoxDigits) { 
444     TEveBoxSet* boxes = static_cast<TEveBoxSet*>(signals);
445     Float_t zc   = (z > 0 ? -1 : 1) * scaled + z;
446     Float_t vs[] = { -w, -5*w, zc-scaled,   // Lower back  left
447                      +w, -5*w, zc-scaled,   // Lower back  right
448                      +w, +5*w, zc-scaled,   // Lower front right
449                      -w, +5*w, zc-scaled,   // Lower front left 
450                      -w, -5*w, zc+scaled,   // Upper back  left
451                      +w, -5*w, zc+scaled,   // Upper back  right
452                      +w, +5*w, zc+scaled,   // Upper front right
453                      -w, +5*w, zc+scaled }; // Upper front left
454     Float_t ang  = TMath::ATan2(y,x);
455     for (size_t i = 0; i < 8; i++) { 
456       Float_t bx = vs[3*i+0];
457       Float_t by = vs[3*i+1];
458       Float_t ca = TMath::Cos(ang);
459       Float_t sa = TMath::Sin(ang);
460       vs[3*i+0]  = bx * ca - by * sa + x;
461       vs[3*i+1]  = bx * sa + by * ca + y;
462     }
463     // boxes->AddBox(x, y, (z > 0 ? -scaled : 0) + z , 5*w, w, scaled);
464     boxes->AddBox(vs);
465     boxes->DigitValue(value);
466     if (ref) boxes->DigitId(ref);
467   }
468   else { 
469     TEveQuadSet* quads = static_cast<TEveQuadSet*>(signals);
470     quads->AddQuad(x,y,z,w,w);
471     quads->QuadValue(value);
472     if (ref) quads->QuadId(ref);
473   }
474   TEveElement* par  = *(signals->BeginParents());
475   ModuleData*  data = static_cast<ModuleData*>(par->GetUserData());
476   int          maxD = 0;
477   switch (signals->GetName()[4]) { 
478   case 'I': case 'i': maxD = 2 * 512; break;
479   case 'O': case 'o': maxD = 2 * 256; break;
480   default:  return;
481   }
482   data->fScaledSum += scaled / maxD;
483 }
484 //____________________________________________________________________
485 void
486 AliEveFMDLoader::SummarizeModule(TEveElement* module)
487 {
488   // Modify color of module according to the summed signal
489   ModuleData*  data = static_cast<ModuleData*>(module->GetUserData());
490   Float_t      sum  = data->fScaledSum / module->NumChildren();
491   if (sum <= 1e-6) {
492     module->SetMainColor(Color_t(kGray));
493     module->SetMainAlpha(0);
494     return;
495   }
496
497
498   /* The sum stored is 
499    * 
500    *  1/N 1/M_max   S_i^N S_j^M_i x_ij 
501    *
502    * where i runs over the number (N) of digit sets in the module 
503    * (zero or more of  Hits, Digits, Raw, ESD, i.e., in the range from
504    * 0 to 4), j runs over the number of digits (M_i) in a single digit
505    * set, M_max is the possible number of digits sets in each module 
506    * (2*256 for outer rings, 2*512 for inner rings), and x_ij is the 
507    * scaled signal (according to the colour palette for the signal in 
508    * question) multiplied by 10 i.e., 
509    * 
510    *   x_ij = 10 * (s_ij - s_min,i) / (s_max,i - s_min,i)
511    * 
512    * Here, s_ij is the basic signal (E-loss, ADC, or multiplicity), 
513    * and s_min,i and s_max,i are the corresponding limits. 
514    *
515    * Hence, the scaled sum above is in the range from 0 to 10.  
516    *
517    * To use one of the palettes, we need to scale this number to the 
518    * range set in the palette and cast it to an integer. 
519    */
520   int min  = fMultPalette.GetMinVal();
521   int max  = fMultPalette.GetMaxVal();
522   int cidx = sum/10 * (max-min) + min;
523   UChar_t pix[3];
524   fMultPalette.ColorFromValue(cidx, pix, false);
525   module->SetMainColorRGB(pix[0], pix[1], pix[2]);
526   module->SetMainAlpha(0.33);
527 }
528
529 //____________________________________________________________________
530 void
531 AliEveFMDLoader::SummarizeModules()
532 {
533   // Summarize the signals in the all the modules, and modify 
534   // the module colour accordingly 
535   
536   for (TEveElement::List_i di = BeginChildren(); 
537        di != EndChildren(); ++di) { 
538     for (TEveElement::List_i ri = (*di)->BeginChildren(); 
539          ri != (*di)->EndChildren(); ++ri) { 
540       for (TEveElement::List_i mi = (*ri)->BeginChildren();
541            mi != (*ri)->EndChildren(); ++mi) { 
542
543         TEveElement* module = *mi;
544         SummarizeModule(module);
545       }
546     }
547   }
548 }
549 //____________________________________________________________________
550 void
551 AliEveFMDLoader::CheckAdd()
552 {
553   // check if we shoul re-add ourselves to the current event node 
554   TEveElement* event = gEve->GetCurrentEvent();
555   SummarizeModules();
556   if (event && event->FindChild(GetName())) return;
557   gEve->AddElement(this);
558 }
559
560
561 //____________________________________________________________________
562 void
563 AliEveFMDLoader::LoadHits()
564 {
565   // Load and display hits
566   ClearDigitSets(kHits);
567
568   AliRunLoader* rl =  AliEveEventManager::AssertRunLoader();
569   if (!rl) { 
570     AliError("No run loader");
571     return;
572   }
573   
574   rl->LoadHits("FMD");
575   TTree* ht = rl->GetTreeH("FMD", false);
576   if (!ht) { 
577     AliError("No FMD tree");
578     return;
579   }
580   
581   TClonesArray* hits = &fHitCache;
582   fHitCache.Clear();
583   ht->SetBranchAddress("FMD", &hits);
584
585   Float_t min = fHitPalette.GetMinVal();
586   Float_t max = fHitPalette.GetMaxVal();
587
588   Int_t nTracks = ht->GetEntriesFast();
589   for (Int_t i = 0; i < nTracks; i++) {
590     Int_t hitRead  = ht->GetEntry(i);
591     if (hitRead <= 0) continue;
592
593     Int_t nHit = hits->GetEntriesFast();
594     if (nHit <= 0) continue;
595   
596     for (Int_t j = 0; j < nHit; j++) {
597       AliFMDHit* hit = static_cast<AliFMDHit*>(hits->At(j));
598       if (!hit) continue;
599   
600       AddSignal(kHits, 
601                 hit->Detector(), hit->Ring(), hit->Sector(), hit->Strip(),
602                 hit->X(), hit->Y(), hit->Z(), int(hit->Edep()*1000), 
603                 min, max, hit);
604     }
605   }
606   CheckAdd();
607 }
608
609 //____________________________________________________________________
610 void
611 AliEveFMDLoader::DoLoadDigits(const char* t, TClonesArray* digits)
612 {
613   // Do the actual display of digits 
614   // Parameters:
615   // @param type What to show 
616   // @param digits The digits
617   Float_t min = fDigitPalette.GetMinVal();
618   Float_t max = fDigitPalette.GetMaxVal();
619
620   Int_t n = digits->GetEntriesFast();
621   for (Int_t i = 0; i < n; i++) { 
622     AliFMDDigit* digit = static_cast<AliFMDDigit*>(digits->At(i));
623     if (!digit) return;
624     AddSignal(t, digit->Detector(), digit->Ring(), digit->Sector(),
625               digit->Strip(), digit->Counts(), min, max, digit);
626   }
627   CheckAdd();
628 }
629
630 //____________________________________________________________________
631 void
632 AliEveFMDLoader::LoadDigits()
633 {
634   // Load and display simulated digits 
635   ClearDigitSets(kDigits);
636
637   AliRunLoader* rl =  AliEveEventManager::AssertRunLoader();
638   if (!rl) { 
639     AliError("No run-loader");
640     return;
641   }
642   
643   rl->LoadDigits("FMD");
644   TTree* dt = rl->GetTreeD("FMD", false);
645   if (!dt) { 
646     AliError("No FMD tree");
647     return;
648   }
649   
650   TClonesArray* digits = &fDigitCache;
651   fDigitCache.Clear();
652   dt->SetBranchAddress("FMD", &digits);
653
654   Int_t read = dt->GetEntry(0);
655   if (read <= 0) { 
656     AliWarning("Nothing read");
657     return;
658   }
659   DoLoadDigits(kDigits, digits);
660 }
661
662
663 //____________________________________________________________________
664 void
665 AliEveFMDLoader::LoadRaw()
666 {
667   // Load and display raw digits 
668   ClearDigitSets(kRaw);
669
670   AliRawReader* rr =  AliEveEventManager::AssertRawReader();
671   if (!rr) { 
672     AliError("No raw-reader");
673     return;
674   }
675   rr->Reset();
676   AliFMDRawReader* fr = new AliFMDRawReader(rr, 0);
677   TClonesArray* digits = &fRawCache;
678   fRawCache.Clear();
679   
680   fr->ReadAdcs(digits);
681   
682   DoLoadDigits(kRaw, digits);
683 }
684
685 //____________________________________________________________________
686 void
687 AliEveFMDLoader::LoadESD()
688 {
689   // Load and display ESD information 
690   ClearDigitSets(kESD);
691
692   AliESDEvent* esd =  AliEveEventManager::AssertESD();
693   if (!esd) { 
694     AliError("No ESD");
695     return;
696   }
697
698   AliESDFMD* fmd = esd->GetFMDData();
699   if (!fmd) { 
700     AliError("No FMD ESD data");
701     return;
702   }
703
704   Float_t min = fMultPalette.GetMinVal();
705   Float_t max = fMultPalette.GetMaxVal();
706   
707   for (UShort_t det = 1; det <= 3; det++) {
708     Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
709     for (Char_t* rng = rings; *rng != '\0'; rng++) {
710       UShort_t nsec = (*rng == 'I' ?  20 :  40);
711       UShort_t nstr = (*rng == 'I' ? 512 : 256);
712       for (UShort_t sec = 0; sec < nsec; sec++) {
713         for (UShort_t str = 0; str < nstr; str++) {
714           Float_t mult = fmd->Multiplicity(det,*rng,sec,str);
715           if (mult == AliESDFMD::kInvalidMult) continue;
716           Float_t eta  = fmd->Eta(det,*rng,sec,str);
717           AddSignal(kESD, det, *rng, sec, str, mult, min, max, 
718                     new TNamed(Form("FMD%d%c[%02d,%03d]", det, *rng, sec, str), 
719                                Form("Mch=%f, eta=%f", mult, eta)));
720         }
721       }
722     }
723   }
724   CheckAdd();
725 }
726   
727 //____________________________________________________________________
728 //
729 // EOF
730 //