CMake: removing qpythia from the depedencies
[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveFMDLoader.cxx
CommitLineData
274799f3 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"
b9df0156 31#include "AliEveEventManager.h"
274799f3 32#include "AliEveFMDLoader.h"
b9df0156 33#include "AliFMDUShortMap.h"
34#include "AliFMDBoolMap.h"
35#include "AliFMDGeometry.h"
36#include "AliFMDParameters.h"
37#include "AliFMDDetector.h"
38#include "AliFMDRing.h"
39#include "AliFMDBaseDigit.h"
40#include "AliFMDDigit.h"
41#include "AliFMDRawReader.h"
42#include "AliFMDHit.h"
274799f3 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.
61namespace
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//____________________________________________________________________
76AliEveFMDLoader* AliEveFMDLoader::fgInstance = 0;
77
78//____________________________________________________________________
79AliEveFMDLoader* 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//____________________________________________________________________
89AliEveFMDLoader::AliEveFMDLoader(const char* name, Bool_t useBoxes,
46e3ca9c 90 Bool_t /* old */)
274799f3 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
9f330d54 114
274799f3 115 // Initialize the FMD geometry manager
1c69419e 116 TGeoManager* geoMan = AliEveEventManager::AssertGeometry();
117 if (!geoMan) return;
118 geoMan->GetTopVolume()->cd(0);
119
274799f3 120 AliFMDGeometry* geom = AliFMDGeometry::Instance();
121 geom->Init();
122 geom->InitTransformations();
123
124 AliFMDParameters* pars = AliFMDParameters::Instance();
125 // pars->UseRcuTrailer(!old);
1c69419e 126 // pars->UseCompleteHeader(old);
127 // pars->SetSampleRate(4);
274799f3 128 pars->Init(kFALSE, 0);
129
130 // Get shapes
131 TGeoShape* inner = static_cast<TGeoShape*>(gGeoManager->GetListOfShapes()
d05d10dc 132 ->FindObject("FMDI_physical_sensor"));
274799f3 133 if (!inner) throw TEveException("Shape of inner type sensors not found");
134 TGeoShape* outer = static_cast<TGeoShape*>(gGeoManager->GetListOfShapes()
d05d10dc 135 ->FindObject("FMDO_physical_sensor"));
274799f3 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);
6a11b092 178 em->SetMainColor(Color_t(kGray));
274799f3 179 em->SetMainTransparency(32);
180 em->IncDenyDestroy();
6a11b092 181 ModuleData* data = new ModuleData;
182 data->fScaledSum = 0;
183 em->SetUserData(data);
274799f3 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//____________________________________________________________________
202AliEveFMDLoader::~AliEveFMDLoader()
203{
204 // Destructor
205 AliWarning("AliEveFMDLoader being destroyed!");
206}
207
208//____________________________________________________________________
209Int_t
210AliEveFMDLoader::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//____________________________________________________________________
225void
226AliEveFMDLoader::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//____________________________________________________________________
236TEveDigitSet*
237AliEveFMDLoader::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//____________________________________________________________________
263void
264AliEveFMDLoader::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) {
6a11b092 283 ModuleData* data = static_cast<ModuleData*>((*mi)->GetUserData());
284 data->fScaledSum = 0;
285 (*mi)->SetMainColor(Color_t(kGray));
274799f3 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//____________________________________________________________________
304TEveDigitSet*
305AliEveFMDLoader::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);
6a11b092 349 }
274799f3 350 }
351 return signal;
352}
353
354//____________________________________________________________________
355void
356AliEveFMDLoader::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//____________________________________________________________________
379void
380AliEveFMDLoader::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.);
6a11b092 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 }
274799f3 419 Double_t w = 2*ring->GetPitch();
420 Int_t value = int(TMath::Nint(signal));
6a11b092 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));
274799f3 423 AddDigit(signals, x, y, z, w, scaled, value, ref);
424}
425
426//____________________________________________________________________
427void
428AliEveFMDLoader::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);
9ad09c97 445 Float_t fw = w;
274799f3 446 Float_t zc = (z > 0 ? -1 : 1) * scaled + z;
9ad09c97 447 Float_t vs[] = { -fw, -5*fw, zc-scaled, // Lower back left
448 +fw, -5*fw, zc-scaled, // Lower back right
449 +fw, +5*fw, zc-scaled, // Lower front right
450 -fw, +5*fw, zc-scaled, // Lower front left
451 -fw, -5*fw, zc+scaled, // Upper back left
452 +fw, -5*fw, zc+scaled, // Upper back right
453 +fw, +5*fw, zc+scaled, // Upper front right
454 -fw, +5*fw, zc+scaled }; // Upper front left
274799f3 455 Float_t ang = TMath::ATan2(y,x);
456 for (size_t i = 0; i < 8; i++) {
457 Float_t bx = vs[3*i+0];
458 Float_t by = vs[3*i+1];
459 Float_t ca = TMath::Cos(ang);
460 Float_t sa = TMath::Sin(ang);
461 vs[3*i+0] = bx * ca - by * sa + x;
462 vs[3*i+1] = bx * sa + by * ca + y;
463 }
464 // boxes->AddBox(x, y, (z > 0 ? -scaled : 0) + z , 5*w, w, scaled);
465 boxes->AddBox(vs);
466 boxes->DigitValue(value);
467 if (ref) boxes->DigitId(ref);
468 }
469 else {
470 TEveQuadSet* quads = static_cast<TEveQuadSet*>(signals);
471 quads->AddQuad(x,y,z,w,w);
472 quads->QuadValue(value);
473 if (ref) quads->QuadId(ref);
474 }
6a11b092 475 TEveElement* par = *(signals->BeginParents());
476 ModuleData* data = static_cast<ModuleData*>(par->GetUserData());
477 int maxD = 0;
478 switch (signals->GetName()[4]) {
479 case 'I': case 'i': maxD = 2 * 512; break;
480 case 'O': case 'o': maxD = 2 * 256; break;
481 default: return;
482 }
483 data->fScaledSum += scaled / maxD;
484}
485//____________________________________________________________________
486void
487AliEveFMDLoader::SummarizeModule(TEveElement* module)
488{
489 // Modify color of module according to the summed signal
490 ModuleData* data = static_cast<ModuleData*>(module->GetUserData());
491 Float_t sum = data->fScaledSum / module->NumChildren();
492 if (sum <= 1e-6) {
493 module->SetMainColor(Color_t(kGray));
494 module->SetMainAlpha(0);
495 return;
496 }
497
498
499 /* The sum stored is
500 *
501 * 1/N 1/M_max S_i^N S_j^M_i x_ij
502 *
503 * where i runs over the number (N) of digit sets in the module
504 * (zero or more of Hits, Digits, Raw, ESD, i.e., in the range from
505 * 0 to 4), j runs over the number of digits (M_i) in a single digit
506 * set, M_max is the possible number of digits sets in each module
507 * (2*256 for outer rings, 2*512 for inner rings), and x_ij is the
508 * scaled signal (according to the colour palette for the signal in
509 * question) multiplied by 10 i.e.,
510 *
511 * x_ij = 10 * (s_ij - s_min,i) / (s_max,i - s_min,i)
512 *
513 * Here, s_ij is the basic signal (E-loss, ADC, or multiplicity),
514 * and s_min,i and s_max,i are the corresponding limits.
515 *
516 * Hence, the scaled sum above is in the range from 0 to 10.
517 *
518 * To use one of the palettes, we need to scale this number to the
519 * range set in the palette and cast it to an integer.
520 */
521 int min = fMultPalette.GetMinVal();
522 int max = fMultPalette.GetMaxVal();
38662ed8 523 int cidx = int(sum/10 * (max-min) + min);
6a11b092 524 UChar_t pix[3];
525 fMultPalette.ColorFromValue(cidx, pix, false);
526 module->SetMainColorRGB(pix[0], pix[1], pix[2]);
527 module->SetMainAlpha(0.33);
274799f3 528}
529
6a11b092 530//____________________________________________________________________
531void
532AliEveFMDLoader::SummarizeModules()
533{
534 // Summarize the signals in the all the modules, and modify
535 // the module colour accordingly
536
537 for (TEveElement::List_i di = BeginChildren();
538 di != EndChildren(); ++di) {
539 for (TEveElement::List_i ri = (*di)->BeginChildren();
540 ri != (*di)->EndChildren(); ++ri) {
541 for (TEveElement::List_i mi = (*ri)->BeginChildren();
542 mi != (*ri)->EndChildren(); ++mi) {
274799f3 543
6a11b092 544 TEveElement* module = *mi;
545 SummarizeModule(module);
546 }
547 }
548 }
549}
274799f3 550//____________________________________________________________________
551void
552AliEveFMDLoader::CheckAdd()
553{
554 // check if we shoul re-add ourselves to the current event node
555 TEveElement* event = gEve->GetCurrentEvent();
6a11b092 556 SummarizeModules();
274799f3 557 if (event && event->FindChild(GetName())) return;
558 gEve->AddElement(this);
559}
560
561
562//____________________________________________________________________
563void
564AliEveFMDLoader::LoadHits()
565{
566 // Load and display hits
567 ClearDigitSets(kHits);
568
569 AliRunLoader* rl = AliEveEventManager::AssertRunLoader();
570 if (!rl) {
571 AliError("No run loader");
572 return;
573 }
574
575 rl->LoadHits("FMD");
576 TTree* ht = rl->GetTreeH("FMD", false);
577 if (!ht) {
578 AliError("No FMD tree");
579 return;
580 }
581
582 TClonesArray* hits = &fHitCache;
583 fHitCache.Clear();
584 ht->SetBranchAddress("FMD", &hits);
585
586 Float_t min = fHitPalette.GetMinVal();
587 Float_t max = fHitPalette.GetMaxVal();
588
589 Int_t nTracks = ht->GetEntriesFast();
590 for (Int_t i = 0; i < nTracks; i++) {
591 Int_t hitRead = ht->GetEntry(i);
592 if (hitRead <= 0) continue;
593
594 Int_t nHit = hits->GetEntriesFast();
595 if (nHit <= 0) continue;
596
597 for (Int_t j = 0; j < nHit; j++) {
598 AliFMDHit* hit = static_cast<AliFMDHit*>(hits->At(j));
599 if (!hit) continue;
600
601 AddSignal(kHits,
602 hit->Detector(), hit->Ring(), hit->Sector(), hit->Strip(),
603 hit->X(), hit->Y(), hit->Z(), int(hit->Edep()*1000),
604 min, max, hit);
605 }
606 }
607 CheckAdd();
608}
609
610//____________________________________________________________________
611void
612AliEveFMDLoader::DoLoadDigits(const char* t, TClonesArray* digits)
613{
614 // Do the actual display of digits
615 // Parameters:
616 // @param type What to show
617 // @param digits The digits
618 Float_t min = fDigitPalette.GetMinVal();
619 Float_t max = fDigitPalette.GetMaxVal();
620
621 Int_t n = digits->GetEntriesFast();
622 for (Int_t i = 0; i < n; i++) {
623 AliFMDDigit* digit = static_cast<AliFMDDigit*>(digits->At(i));
624 if (!digit) return;
625 AddSignal(t, digit->Detector(), digit->Ring(), digit->Sector(),
626 digit->Strip(), digit->Counts(), min, max, digit);
627 }
628 CheckAdd();
629}
630
631//____________________________________________________________________
632void
633AliEveFMDLoader::LoadDigits()
634{
635 // Load and display simulated digits
636 ClearDigitSets(kDigits);
637
638 AliRunLoader* rl = AliEveEventManager::AssertRunLoader();
639 if (!rl) {
640 AliError("No run-loader");
641 return;
642 }
643
644 rl->LoadDigits("FMD");
645 TTree* dt = rl->GetTreeD("FMD", false);
646 if (!dt) {
647 AliError("No FMD tree");
648 return;
649 }
650
651 TClonesArray* digits = &fDigitCache;
652 fDigitCache.Clear();
653 dt->SetBranchAddress("FMD", &digits);
654
655 Int_t read = dt->GetEntry(0);
656 if (read <= 0) {
657 AliWarning("Nothing read");
658 return;
659 }
660 DoLoadDigits(kDigits, digits);
661}
662
663
664//____________________________________________________________________
665void
666AliEveFMDLoader::LoadRaw()
667{
668 // Load and display raw digits
669 ClearDigitSets(kRaw);
670
671 AliRawReader* rr = AliEveEventManager::AssertRawReader();
672 if (!rr) {
673 AliError("No raw-reader");
674 return;
675 }
676 rr->Reset();
274799f3 677 AliFMDRawReader* fr = new AliFMDRawReader(rr, 0);
678 TClonesArray* digits = &fRawCache;
679 fRawCache.Clear();
680
681 fr->ReadAdcs(digits);
682
683 DoLoadDigits(kRaw, digits);
684}
685
686//____________________________________________________________________
687void
688AliEveFMDLoader::LoadESD()
689{
690 // Load and display ESD information
e339938c 691
274799f3 692 ClearDigitSets(kESD);
693
694 AliESDEvent* esd = AliEveEventManager::AssertESD();
695 if (!esd) {
696 AliError("No ESD");
697 return;
698 }
699
700 AliESDFMD* fmd = esd->GetFMDData();
701 if (!fmd) {
702 AliError("No FMD ESD data");
703 return;
704 }
705
706 Float_t min = fMultPalette.GetMinVal();
707 Float_t max = fMultPalette.GetMaxVal();
708
709 for (UShort_t det = 1; det <= 3; det++) {
710 Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
711 for (Char_t* rng = rings; *rng != '\0'; rng++) {
712 UShort_t nsec = (*rng == 'I' ? 20 : 40);
713 UShort_t nstr = (*rng == 'I' ? 512 : 256);
714 for (UShort_t sec = 0; sec < nsec; sec++) {
715 for (UShort_t str = 0; str < nstr; str++) {
716 Float_t mult = fmd->Multiplicity(det,*rng,sec,str);
717 if (mult == AliESDFMD::kInvalidMult) continue;
718 Float_t eta = fmd->Eta(det,*rng,sec,str);
e339938c 719
720 // As it was before, it causes big memory leak:
721// AddSignal(kESD, det, *rng, sec, str, mult, min, max,
722// new TNamed(Form("FMD%d%c[%02d,%03d]", det, *rng, sec, str),
723// Form("Mch=%f, eta=%f", mult, eta)));
724
725 // I propose to replace it with:
726 TNamed *tmpNamed = new TNamed(Form("FMD%d%c[%02d,%03d]", det, *rng, sec, str),Form("Mch=%f, eta=%f", mult, eta));
727 AddSignal(kESD, det, *rng, sec, str, mult, min, max,tmpNamed);
728 if(tmpNamed)delete tmpNamed;
729 //
730
274799f3 731 }
732 }
733 }
734 }
735 CheckAdd();
736}
274799f3 737
738//____________________________________________________________________
739//
740// EOF
741//