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 //