Added option to respond to missing galice.root or AliESD.root files in Open() with...
[u/mrichter/AliRoot.git] / EVE / Alieve / MUONModule.cxx
1 /* HEAD11Jul06 */
2 //////////////////////////////////////////////////////////////////////////
3 //                                                                      //
4 // The main AliEVE drawing module for the MUON detector                 //
5 //                                                                      //
6 //////////////////////////////////////////////////////////////////////////
7
8 #include "EventAlieve.h"
9 #include "Reve/PointSet.h"
10 #include "Reve/RGTopFrame.h"
11
12 #include "AliRun.h"
13 #include "AliRunLoader.h"
14
15 #include "AliMUON.h"
16 #include "AliMpDEIterator.h"
17 #include "AliMpSectorSegmentation.h"
18 #include "AliMpSector.h"
19 #include "AliMUONGeometryTransformer.h"
20 #include "AliMUONSegmentation.h"
21 #include "AliMUONSegFactory.h"
22 #include "AliMpStationType.h"
23 #include "AliMpDEManager.h"
24 #include "AliMUONConstants.h"
25 #include "AliMUONDigit.h"
26 #include "AliMUONRawCluster.h"
27 #include "AliMUONTrack.h"
28 #include "AliMUONTrackParam.h"
29
30 #include "MUONModule.h"
31
32 #include <TPolyLine3D.h>
33 #include <TMarker3DBox.h>
34 #include <TColor.h>
35
36 using namespace Reve;
37 using namespace Alieve;
38 using namespace std;
39
40 ClassImp(MUONModule)
41
42 /**************************************************************************/
43 MUONModule::MUONModule(const Text_t* n, const Text_t* t, Color_t col) :
44   Reve::RenderElement(col),
45   QuadSet(n, t),
46   fInfo(0),
47   fID(-1), 
48   fCath(0),
49   fShowDigits(0), fShowClusters(0), fShowTracks(0),
50   fFrameCol(col),
51   fDetElemId(-1)
52 {
53   //
54   // Default constructor
55   //
56
57 }
58
59 /**************************************************************************/
60 MUONModule::MUONModule(Int_t id, Int_t cath, MUONDigitsInfo* info, Bool_t dig, Bool_t clus, Color_t col ) :
61   Reve::RenderElement(col),
62   QuadSet(Form("M-DetElemId %d C%1d",id,cath)),
63   fInfo(info),
64   fID(-1), 
65   fCath(0),
66   fShowDigits(dig), fShowClusters(clus), fShowTracks(0),
67   fFrameCol(col),
68   fDetElemId(-1)
69 {
70   //
71   // Constructor
72   //
73
74   if (!fShowDigits && !fShowClusters) fShowTracks = 1;
75
76   if (fShowClusters) SetName(Form("M-DetElemId %d",id));
77
78   if (id/100 >= 11 && cath == 1) SetName(Form("M-DetElemId %d X",id));
79   if (id/100 >= 11 && cath == 2) SetName(Form("M-DetElemId %d Y",id));
80   if (id == -1 && cath == -1) SetName(Form("M-Chambers"));
81   if (id >  -1 && cath == -1) SetName(Form("M-Track %d",id));
82   if (cath == -2) SetName(Form("M-Chamber %2d",id));
83   if (cath == -3) SetName(Form("M-Pads %d X",id));
84   if (cath == -4) SetName(Form("M-Pads %d Y",id));
85
86   SetID(id,cath);
87
88 }
89
90 /**************************************************************************/
91 MUONModule::MUONModule(const MUONModule &mmod) :
92   Reve::RenderElement(),
93   QuadSet(Form("M-DetElemId %d C%1d",mmod.fID,mmod.fCath)),
94   fInfo(mmod.fInfo),
95   fID(mmod.fID),
96   fCath(mmod.fCath),
97   fShowDigits(mmod.fShowDigits),
98   fShowClusters(mmod.fShowClusters),
99   fShowTracks(mmod.fShowTracks),
100   fFrameCol(mmod.fFrameCol),
101   fDetElemId(mmod.fDetElemId)
102 {
103   //
104   // Copy constructor
105   //
106
107 }
108
109 /**************************************************************************/
110 MUONModule& MUONModule::operator=(const MUONModule &mmod)
111 {
112   //
113   // Assignment operator
114   //
115
116   if (this != &mmod) {
117
118     fInfo         = mmod.fInfo;
119     fID           = mmod.fID;
120     fCath         = mmod.fCath;
121     fShowDigits   = mmod.fShowDigits;
122     fShowClusters = mmod.fShowClusters;
123     fShowTracks   = mmod.fShowTracks;
124     fFrameCol     = mmod.fFrameCol;
125     fDetElemId    = mmod.fDetElemId;
126
127   }
128
129   return *this;
130
131 }
132
133 /**************************************************************************/
134 void MUONModule::SetID(Int_t id, Int_t cath)
135 {
136   //
137   // Select a single detector element id
138   //
139
140   static const Exc_t eH("MUOModule::SetID ");
141
142   if(fInfo == 0)
143     throw(eH + "MUONDigitsInfo not set.");
144
145   fID   = id;
146   fCath = cath;
147
148   InitModule();
149
150 }
151
152 /**************************************************************************/
153 void MUONModule::InitModule()
154 {
155   // 
156   // Initialize and draw selected items
157   //
158
159   fDetElemId = 0;
160
161   if (fShowDigits) LoadQuadsDigits();
162   if (fShowClusters) LoadQuadsClusters();
163   if (fShowTracks) {
164     if (fCath == -1){
165       LoadQuadsTracks(fID);
166     } else if (fCath == -2 || fCath == -3 || fCath == -4) {
167       if (fCath == -2) LoadQuadsChambers(fID,fID);
168       if (fCath == -3) LoadQuadsChambers(fID,fID,-1,1);
169       if (fCath == -4) LoadQuadsChambers(fID,fID,-1,2);
170     }
171   }
172   ComputeBBox();
173
174 }
175
176 /**************************************************************************/
177 void MUONModule::LoadQuadsChambers(Int_t chamber1, Int_t chamber2, Int_t id, Int_t cat)
178 {
179   //
180   // Draw chambers
181   //
182
183   //printf("Draw chambers: %d %d %d %d %d \n",chamber1,chamber2,id,cat,fCath);
184
185   Int_t fChamber;
186
187   AliRunLoader *runLoader = Alieve::Event::AssertRunLoader();
188   runLoader->LoadgAlice();
189
190   AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
191
192   const AliMUONGeometryTransformer* kGeomTransformer = pMUON->GetGeometryTransformer();
193   AliMUONSegmentation* segmentation = pMUON->GetSegmentation();
194   AliMpSegFactory segFactory;
195
196   Float_t xg1, xg2, yg1, yg2, zg1, zg2;
197
198   for (fChamber = chamber1; fChamber <= chamber2; fChamber++) {
199
200   if(fChamber < 5) {
201
202     AliMpDEIterator it;
203     for ( it.First(fChamber-1); ! it.IsDone(); it.Next() ) {
204       
205     Int_t detElemId = it.CurrentDE();
206
207     if (id > 0 && id != detElemId) continue;
208       
209     //printf("Detector element ID for chamber %d (tracking): %d \n",fChamber,detElemId);
210     
211     AliMpSectorSegmentation * seg = (AliMpSectorSegmentation *) segmentation->GetMpSegmentation(detElemId, 0);
212     const AliMpSector * sector = seg->GetSector();
213     
214     // get sector measurements
215     TVector2 position  = sector->Position(); 
216     TVector2 dimension = sector->Dimensions(); // half length
217
218     //printf("Sector position: \n"); position.Print();
219     //printf("Sector dimensions: \n"); dimension.Print();
220     
221     Float_t xlocal1 =  position.Px(); // FIXME: not really needed as it's 0 ?
222     Float_t ylocal1 =  position.Py(); // FIXME: not really needed as it's 0 ?
223     Float_t xlocal2 =  dimension.Px() * 2.;
224     Float_t ylocal2 =  dimension.Px() * 2.;
225     
226     //printf("Local position and dimension: xp = %f , yp = %f xd = %f yd = %f \n",xlocal1,ylocal1,xlocal2,ylocal2);
227     
228     kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
229     kGeomTransformer->Local2Global(detElemId, xlocal2, ylocal2, 0, xg2, yg2, zg2);
230     
231     //printf("Global position: xpg = %f , ypg = %f zpg = %f \n",xg1,yg1,zg1);
232     //printf("Global dimension: xdg = %f , ydg = %f zdg = %f \n",xg2,yg2,zg2);
233     
234     Float_t *p;
235     if (fCath != -3 && fCath != -4) {
236     fQuads.push_back(Reve::Quad(fFrameCol));
237     p = fQuads.back().vertices;
238     /*
239     p[0] = xg1;      p[1] =  yg1; p[2]  = zg1;
240     p[3] = xg1;      p[4] =  yg1; p[5]  = zg1;
241     p[6] = xg1+xg2;  p[7] =  yg1; p[8]  = zg1;
242     p[9] = xg1+xg2;  p[10] = yg1; p[11] = zg1;
243     */
244     // switch x <> z
245     p[0] = zg1;      p[1] =  yg1; p[2]  = xg1;
246     p[3] = zg1;      p[4] =  yg1; p[5]  = xg1;
247     p[6] = zg1;      p[7] =  yg1; p[8]  = xg1+xg2;
248     p[9] = zg1;      p[10] = yg1; p[11] = xg1+xg2;
249     
250     Float_t xprev = xg1+xg2;
251     Float_t yprev = yg1;
252     Int_t nstep = 100;
253     Float_t dstep = TMath::Pi()/2.0 / (Float_t)nstep;
254     Float_t d;
255     for (Int_t istep = 1; istep < (nstep+1); istep++) {
256
257       d = istep * dstep;
258       Float_t x = xg1 + xg2 * TMath::Cos(d);
259       Float_t y = yg1 + yg2 * TMath::Sin(d);
260
261       fQuads.push_back(Reve::Quad(fFrameCol));
262       p = fQuads.back().vertices;
263       /*
264       p[0] = xprev; p[1] =  yprev; p[2]  = zg1;
265       p[3] = xprev; p[4] =  yprev; p[5]  = zg1;
266       p[6] = x;     p[7] =  y;     p[8]  = zg1;
267       p[9] = x;     p[10] = y;     p[11] = zg1;
268       */
269       // switch x <> z
270       p[0] = zg1;   p[1] =  yprev; p[2]  = xprev;
271       p[3] = zg1;   p[4] =  yprev; p[5]  = xprev;
272       p[6] = zg1;   p[7] =  y;     p[8]  = x;
273       p[9] = zg1;   p[10] = y;     p[11] = x;
274
275       xprev = x;
276       yprev = y;
277
278     }
279
280     fQuads.push_back(Reve::Quad(fFrameCol));
281     p = fQuads.back().vertices;
282     /*
283     p[0] = xprev;      p[1] =  yprev; p[2]  = zg1;
284     p[3] = xprev;      p[4] =  yprev; p[5]  = zg1;
285     p[6] = xg1;        p[7] =  yg1;   p[8]  = zg1;
286     p[9] = xg1;        p[10] = yg1;   p[11] = zg1;
287     */
288     // switch x <> z
289     p[0] = zg1;        p[1] =  yprev; p[2]  = xprev;
290     p[3] = zg1;        p[4] =  yprev; p[5]  = xprev;
291     p[6] = zg1;        p[7] =  yg1;   p[8]  = xg1;
292     p[9] = zg1;        p[10] = yg1;   p[11] = xg1;
293     }  //  end fCath != -3 , -4
294     }  //  end detElemId
295
296   }
297
298   if (fChamber>4) {
299
300     AliMpDEIterator it;
301     for ( it.First(fChamber-1); ! it.IsDone(); it.Next() ) {
302       
303     Int_t detElemId = it.CurrentDE();
304           
305     if (id > 0 && id != detElemId) continue;
306       
307     //AliMpStationType stationType = AliMpDEManager::GetStationType(detElemId);
308     
309     //printf("Detector element ID for chamber %d (trigger, stationType %s): %d \n",fChamber,StationTypeName(stationType).Data(),detElemId);
310     
311     if (  segmentation->HasDE(detElemId) ) {
312       const AliMpVSegmentation* seg1 = segmentation->GetMpSegmentation(detElemId, 0);
313       if (!seg1) { 
314         // Create mapping segmentation if old trigger segmentation
315         // (not using mapping)
316         seg1 = segFactory.CreateMpSegmentation(detElemId, 0);
317       }   
318       if (seg1) {  
319         
320         Float_t deltax = seg1->Dimensions().X();
321         Float_t deltay = seg1->Dimensions().Y();
322         Float_t xlocal1 =  -deltax;
323         Float_t ylocal1 =  -deltay;
324         Float_t xlocal2 =  +deltax;
325         Float_t ylocal2 =  +deltay;
326         
327         //printf("Local corners: x1 = %f , y1 = %f x2 = %f y2 = %f \n",xlocal1,ylocal1,xlocal2,ylocal2);
328         
329         kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
330         kGeomTransformer->Local2Global(detElemId, xlocal2, ylocal2, 0, xg2, yg2, zg2);
331         
332         //printf("Global corner 1: xg1 = %f , yg1 = %f zg1 = %f \n",xg1,yg1,zg1);
333         //printf("Global corner 2: xg2 = %f , yg2 = %f zg2 = %f \n",xg2,yg2,zg2);
334         
335         if (fCath != -3 && fCath != -4) {
336         fQuads.push_back(Reve::Quad(fFrameCol));
337         Float_t* p = fQuads.back().vertices;
338         // the tilting direction now known...
339         /*
340         p[0] = xg1;  p[1] =  yg1; p[2]  = zg1;
341         p[3] = xg1;  p[4] =  yg2; p[5]  = zg1;
342         p[6] = xg2;  p[7] =  yg2; p[8]  = zg2;
343         p[9] = xg2;  p[10] = yg1; p[11] = zg2;
344         */
345         // switch x <> z
346         p[0] = zg1;  p[1] =  yg1; p[2]  = xg1;
347         p[3] = zg1;  p[4] =  yg2; p[5]  = xg1;
348         p[6] = zg2;  p[7] =  yg2; p[8]  = xg2;
349         p[9] = zg2;  p[10] = yg1; p[11] = xg2;
350         }
351         if (fCath == -3 || fCath == -4) {
352         // draw all pads in the trigger chambers
353         if (fChamber > 10) {
354
355           for (Int_t ic = 1; ic <= 2; ic++) {
356
357           if (ic != cat) continue;
358
359           const AliMpVSegmentation* seg3 = segmentation->GetMpSegmentation(detElemId, ic-1);
360           Int_t maxX = seg3->MaxPadIndexX();
361           Int_t maxY = seg3->MaxPadIndexY();
362           //printf("detElemId %d ic %d maxX %d maxY %d \n",detElemId,ic,maxX,maxY);
363           for (Int_t ix = 0; ix <= maxX; ix++) {
364             for (Int_t iy = 0; iy <= maxY; iy++) {
365
366               AliMpPad pad = seg3->PadByIndices(AliMpIntPair(ix,iy),kFALSE);
367
368               if (!pad.IsValid()) continue;
369
370               // get the pad position and dimensions
371               xlocal1 = pad.Position().X();
372               ylocal1 = pad.Position().Y();
373               xlocal2 = pad.Dimensions().X();
374               ylocal2 = pad.Dimensions().Y();
375
376               kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
377               // (no transformation for pad dimensions)
378               xg2 = xlocal2;
379               yg2 = ylocal2;
380               
381               Int_t pcolor = 0;
382               if (ic == 1) pcolor = 5;
383               if (ic == 2) pcolor = 5;
384
385               fQuads.push_back(Reve::Quad());
386               fQuads.back().ColorFromIdx(pcolor);
387               Float_t* p = fQuads.back().vertices;
388               // the tilting direction now known...
389               // switch x <> z
390               p[0] = zg1;         p[1] =  yg1-yg2; p[2]  = xg1-xg2;
391               p[3] = zg1;         p[4] =  yg1+yg2; p[5]  = xg1-xg2;
392               p[6] = zg1;         p[7] =  yg1+yg2; p[8]  = xg1+xg2;
393               p[9] = zg1;         p[10] = yg1-yg2; p[11] = xg1+xg2;
394               
395             }
396           }
397
398           }  // end "cathode" loop
399
400         }  // end draw pads
401         }  // end fCath == -3 , -4
402      }  
403
404     }
405     
406     }  // end detElemId
407   
408   }
409
410   }  // end chamber loop
411
412 }
413
414 /**************************************************************************/
415 void MUONModule::LoadQuadsDigits()
416 {
417   // 
418   // Draw digits
419   //
420
421   if (fDetElemId > 0 && fDetElemId != fID) return;
422
423   Int_t fChamber;
424
425   AliRunLoader *runLoader = Alieve::Event::AssertRunLoader();
426   runLoader->LoadgAlice();
427
428   AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
429
430   const AliMUONGeometryTransformer* kGeomTransformer = pMUON->GetGeometryTransformer();
431
432   fChamber = fID/100;
433
434   /*           D I S P L A Y     D I G I T S                              */
435
436   // Display X-Y strips for the trigger chambers
437
438   Float_t adcmax = 1024; // default
439   if (fChamber<11) adcmax = 4096;
440
441   TClonesArray *digits;
442   Int_t ndigits;
443   digits  = fInfo->GetDigits(fChamber);
444   ndigits = digits->GetEntriesFast(); 
445
446   AliMUONDigit  *mdig;
447
448   Int_t fCathode = fCath;
449
450   for (Int_t id = 0; id < ndigits; id++) {
451     mdig  = (AliMUONDigit*)digits->UncheckedAt(id);
452     if (mdig->Cathode() != fCathode-1) continue;
453
454     // get all needed parameters
455     Int_t ix=mdig->PadX();
456     Int_t iy=mdig->PadY();
457     Int_t detElemId=mdig->DetElemId();      
458     Int_t charge = mdig->Signal();
459     Int_t index  = Int_t(TMath::Log(charge)/(TMath::Log(adcmax)/22));
460     Int_t color  = 261+index;
461     Int_t colorTrigger = 2;   
462     if (color > 282) color = 282;
463
464     if (detElemId != fID) continue;
465       
466     const AliMpVSegmentation* seg2 = pMUON->GetSegmentation()->GetMpSegmentation(detElemId,fCathode-1);
467
468     AliMpPad pad = seg2->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
469
470     //printf("Dig ix %d iy %d \n",ix,iy);
471
472     // time delay information
473     if (fChamber > 10) { // trigger chamber
474       Int_t sumCharge = 0;
475       Int_t n = mdig->Ntracks();
476       for (Int_t icharge = 0; icharge < n; icharge++) {
477         sumCharge = sumCharge+mdig->TrackCharge(icharge);
478       }
479       assert(sumCharge==mdig->Signal());
480       Int_t testCharge = sumCharge-(Int_t(sumCharge/n))*n;
481       if(sumCharge <= n || testCharge > 0) {
482         colorTrigger = 4; 
483       } else {
484         colorTrigger = 5; 
485       }
486     }
487             
488     // get the pad position and dimensions
489     Float_t xlocal1 = pad.Position().X();
490     Float_t ylocal1 = pad.Position().Y();
491     Float_t xlocal2 = pad.Dimensions().X();
492     Float_t ylocal2 = pad.Dimensions().Y();
493
494     Float_t xg1, xg2, yg1, yg2, zg1;
495             
496     kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
497     // (no transformation for pad dimensions)
498     xg2 = xlocal2;
499     yg2 = ylocal2;
500
501     if (fChamber > 10) {
502       color = colorTrigger;
503     }
504
505     fQuads.push_back(Reve::Quad());
506     fQuads.back().ColorFromIdx(color);
507     Float_t* p = fQuads.back().vertices;
508     // the tilting direction now known...
509     /*
510     p[0] = xg1-xg2;  p[1] =  yg1-yg2; p[2]  = zg1;
511     p[3] = xg1-xg2;  p[4] =  yg1+yg2; p[5]  = zg1;
512     p[6] = xg1+xg2;  p[7] =  yg1+yg2; p[8]  = zg1;
513     p[9] = xg1+xg2;  p[10] = yg1-yg2; p[11] = zg1;
514     */
515     // switch x <> z
516     p[0] = zg1;         p[1] =  yg1-yg2; p[2]  = xg1-xg2;
517     p[3] = zg1;         p[4] =  yg1+yg2; p[5]  = xg1-xg2;
518     p[6] = zg1;         p[7] =  yg1+yg2; p[8]  = xg1+xg2;
519     p[9] = zg1;         p[10] = yg1-yg2; p[11] = xg1+xg2;
520     /*
521     if (fChamber < 11) {
522     printf("coordinates.............................. \n");
523     for (Int_t j = 0; j < 12; j++) {
524       printf("%f ",p[j]);
525       if ((j+1)%3 == 0) printf("\n");
526     }
527     }
528     */
529
530   }  // end loop over digits
531
532   LoadQuadsChambers(fChamber,fChamber,fID,fCath);
533
534 }
535
536 /**************************************************************************/
537 void MUONModule::LoadQuadsClusters()
538 {
539   //
540   // Draw clusters
541   //
542
543   Int_t fChamber;
544
545   fChamber = fID/100;
546
547   LoadQuadsChambers(fChamber,fChamber,fID);
548
549   /*           D I S P L A Y     C L U S T E R S                           */
550
551   TClonesArray *clusters;
552   Int_t nclusters;
553   clusters  = fInfo->GetClusters(fChamber);
554   if (clusters == 0) return;
555   nclusters = clusters->GetEntriesFast(); 
556
557   //Float_t zpos = AliMUONConstants::DefaultChamberZ(fChamber-1);  
558
559   AliMUONRawCluster  *cls;
560   for (Int_t iCls = 0; iCls < nclusters; iCls++) {
561
562     cls = (AliMUONRawCluster*)clusters->UncheckedAt(iCls);
563
564     if (cls->GetDetElemId() != fID) continue;
565
566     Float_t x = cls->GetX(0);
567     Float_t y = cls->GetY(0);
568     Float_t z = cls->GetZ(0);
569
570     Float_t dx = 1.0/2.0;
571     Float_t dy = 1.0/2.0;
572     Float_t r = TMath::Sqrt(dx*dx+dy*dy);
573     /*
574     // just an empty  square
575     fQuads.push_back(Reve::Quad(5));
576     Float_t* p = fQuads.back().vertices;
577     
578     //p[0] = x-dx;  p[1] =  y-dy; p[2]  = z;
579     //p[3] = x-dx;  p[4] =  y+dy; p[5]  = z;
580     //p[6] = x+dx;  p[7] =  y+dy; p[8]  = z;
581     //p[9] = x+dx;  p[10] = y-dy; p[11] = z;
582     
583     // switch x <> z
584     p[0] = z;     p[1] =  y-dy; p[2]  = x-dx;
585     p[3] = z;     p[4] =  y+dy; p[5]  = x-dx;
586     p[6] = z;     p[7] =  y+dy; p[8]  = x+dx;
587     p[9] = z;     p[10] = y-dy; p[11] = x+dx;
588     */
589     Int_t nstep = 100;
590     Float_t dstep = 2.0*TMath::Pi() / (Float_t)nstep;
591     Float_t d;
592     for (Int_t istep = 1; istep < (nstep+1); istep++) {
593
594       d = istep * dstep;
595       Float_t xc = x + r * TMath::Cos(d);
596       Float_t yc = y + r * TMath::Sin(d);
597
598       fQuads.push_back(Reve::Quad(5));
599       Float_t* p = fQuads.back().vertices;
600
601       p[0] = z;     p[1] =  y;  p[2]  = x;
602       p[3] = z;     p[4] =  y;  p[5]  = x;
603       p[6] = z;     p[7] =  yc; p[8]  = xc;
604       p[9] = z;     p[10] = yc; p[11] = xc;
605
606    }
607
608   }
609
610 }
611
612 /**************************************************************************/
613 void MUONModule::LoadQuadsTracks(Int_t id)
614 {
615   //
616   // Draw tracks
617   //
618
619   /*           D I S P L A Y     T R A C K S                           */
620
621   TClonesArray * trackParamAtHit = 0;   
622   TClonesArray *tracks;
623   Int_t ntracks;
624   tracks  = fInfo->GetTracks();
625   if (tracks == 0) return;
626   ntracks = tracks->GetEntriesFast(); 
627
628   Float_t *p;
629
630   AliMUONTrack *recTrack = (AliMUONTrack*)tracks->At(id);
631
632   Float_t xRec, xRec0;
633   Float_t yRec, yRec0;
634   Float_t zRec, zRec0;
635   
636   AliMUONTrackParam *trackParam = recTrack->GetTrackParamAtVertex(); 
637   xRec0  = trackParam->GetNonBendingCoor();
638   yRec0  = trackParam->GetBendingCoor();
639   zRec0  = trackParam->GetZ();
640
641   Int_t nTrackHits = recTrack->GetNTrackHits();
642   for (Int_t iHit = 0; iHit < nTrackHits; iHit++){
643     trackParamAtHit = recTrack->GetTrackParamAtHit();
644     trackParam = (AliMUONTrackParam*) trackParamAtHit->At(iHit); 
645     xRec  = trackParam->GetNonBendingCoor();
646     yRec  = trackParam->GetBendingCoor();
647     zRec  = trackParam->GetZ();
648
649     fQuads.push_back(Reve::Quad());
650     fQuads.back().ColorFromIdx(4);
651     p = fQuads.back().vertices;
652     
653     p[0] = zRec0; p[1] =  yRec0; p[2]  = xRec0;
654     p[3] = zRec0; p[4] =  yRec0; p[5]  = xRec0;
655     p[6] = zRec;  p[7] =  yRec;  p[8]  = xRec;
656     p[9] = zRec;  p[10] = yRec;  p[11] = xRec;
657
658     xRec0 = xRec;
659     yRec0 = yRec;
660     zRec0 = zRec;
661
662   } // end loop rec. hits
663
664 }
665