cbb79eb9b7f3e1c8b2855501b129155b6d15b38d
[u/mrichter/AliRoot.git] / EVE / hlt-macros / homer_display.C
1 // $Id$
2 // Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
3
4 /**************************************************************************
5  * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
6  * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
7  * full copyright notice.                                                 *
8  **************************************************************************/
9
10 // Functions to read data from HOMER.
11 //
12 // Setup: edit location of HLT configuration in first line of
13 // homer_display(). This is a temporary solution.
14 //
15 // Run as: alieve command_queue.C+ hlt_structs.C+ homer_display.C
16 //
17 // nextEvent() will get next event from HOMER.
18
19
20 class AliRawReaderMemory;
21 class AliEveHOMERManager;
22 class AliHLTHOMERBlockDesc;
23
24 class TEvePointSet;
25 class TEveTrackList;
26 class TEveTrack;
27
28 class AliEveTPCLoader;
29 class AliEveTPCData;
30 class AliEveTPCSector2D;
31 class AliEveTPCSector3D;
32 class AliEveITSDigitsInfo;
33
34 //***********************************************************
35 #include "TTimer.h"
36 #include "TRandom.h"
37 #include "TVirtualPad.h"
38 #include "TGLViewer.h"
39 #include "TThread.h"
40 #include "TGFileBrowser.h"
41 #include "TStyle.h"
42 #include "TList.h"
43 #include "TDirectory.h"
44 //***********************************************************
45 #include "TEveManager.h"
46 #include "TEvePointSet.h"
47 #include "TEveTrack.h"
48 #include "TEveVSDStructs.h"
49 #include "TEveTrackPropagator.h"
50 #include "TEvePointSet.h"
51 #include "TEveScene.h"
52 #include "TEveElement.h"
53 // #include "TEveElementList.h"
54 #include "TEveEventManager.h"
55 //***********************************************************
56 #include "AliESDEvent.h"
57 #include "AliCDBManager.h"
58 #include "AliRawReaderMemory.h"
59 #include "AliTPCRawStream.h"
60 #include "AliGeomManager.h"
61 //***********************************************************
62 #include "AliEveHOMERManager.h"
63 #include "AliEveTPCLoader.h" 
64 #include "AliEveTPCData.h"
65 #include "AliEveITSDigitsInfo.h"
66 #include "AliEveITSModule.h"
67 //***********************************************************
68 #include "AliHLTHOMERBlockDesc.h"
69 #include "AliHLTHOMERReader.h"
70 //***********************************************************
71 #include "hlt_structs.C"
72 #include "TFile.h"
73 //***********************************************************
74 #include <AliHLTMUONUtils.h>
75 #include "AliHLTMUONDataBlockReader.h"
76 #include "tracking-ca/AliHLTTPCCATrackParam.h"
77
78 // -- globals --
79  
80 AliEveTPCLoader*                          gTPCLoader    = 0;
81 AliEveTPCData*                            gTPCData      = 0;
82 TEvePointSet*                             gTPCClusters  = 0;
83 TEveTrackList*                            gTPCTrack     = 0;
84
85 AliEveITSDigitsInfo*                      gITSDigits    = 0; 
86
87 AliRawReaderMemory*                       gMemReader    = 0;
88 AliEveHOMERManager*                       gHomerManager = 0;
89
90 TEvePointSet*                             gMUONClusters  = 0;
91 Double_t                                  gSolenoidField = 5;
92 //***********************************************************
93
94 Int_t globMaxPoint = 0 ;
95
96 //***********************************************************
97
98 // -- needed below ??
99
100 Int_t    event  = -1;
101
102 TTimer   timer;
103 TTimer   event_timer;
104
105 TThread* ldthread = 0;
106
107 TRandom  rnd(0);
108
109 Bool_t vC = kFALSE;
110 TGFileBrowser *g_hlt_browser = 0;
111 TCanvas       *g_hlt_canvas  = 0;
112
113 TGLViewer::ECameraType camera = TGLViewer::kCameraPerspXOZ;
114
115 //****************************************************************************
116 Int_t nextEvent();
117
118 //****************************************************************************
119 Int_t processSPDRawData( AliHLTHOMERBlockDesc* block );
120 Int_t drawSPDRawData();
121
122 //****************************************************************************
123 Int_t processTPCRawData( AliHLTHOMERBlockDesc* block );
124 Int_t processTPCClusters( AliHLTHOMERBlockDesc* block );
125 Int_t processTPCTracks( AliHLTHOMERBlockDesc* block );
126
127 Int_t processMUONClusters( AliHLTHOMERBlockDesc* block );
128
129 //****************************************************************************
130 TEveTrack* makeESDTrack( TEveTrackPropagator*   rnrStyle,
131                          Int_t                  idx,
132                          AliESDtrack*           at,
133                          AliExternalTrackParam* tp = 0 );
134
135 //****************************************************************************
136 void homer_display( Int_t run = 0) {
137
138   AliCDBManager::Instance()->SetRun(run);
139   AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
140   
141   gMemReader = new AliRawReaderMemory(0, 0);
142
143   gStyle->SetPalette(1, 0);
144   gEve->DisableRedraw();
145
146   // -- Create HOMER Manager
147   gHomerManager = new AliEveHOMERManager("/local/home/hlt/AliEVE-Config.xml");
148
149   // -- Set Realm  ( can be "GPN","ACR","HLT","KIP" )
150   gHomerManager->SetRealm("ACR"); 
151   
152   gEve->AddToListTree(gHomerManager, kTRUE);
153
154   // -- Create list of HOMER sources
155   gHomerManager->CreateHOMERSourcesList();
156
157   // -- TPC Loader
158   gTPCLoader = new AliEveTPCLoader;
159   gTPCLoader->SetDoubleSR(kTRUE);
160   gTPCLoader->SetInitParams(40, 900, 2, 100);   // Sector params (mint, maxt, thr, maxval)
161   
162   // -- TPC Data
163   gTPCData = gTPCLoader->GetData();
164   gTPCData->SetLoadPedestal(0);
165   gTPCData->SetLoadThreshold(0);
166   gTPCData->SetAutoPedestal(kFALSE);             // For zero suppressed data.
167
168   gEve->AddElement(gTPCLoader);
169
170   gEve->Redraw3D(0,1); // (0, 1)
171   gEve->EnableRedraw();  
172 }
173
174 //****************************************************************************
175 Int_t nextEvent() {
176
177   Int_t iResult = 0;
178
179   gStyle->SetPalette(1, 0);
180   gEve->DisableRedraw();
181
182   // ** Get Next Event from HOMER
183   if ( gHomerManager->NextEvent() ) 
184     return ++iResult;
185
186   // ** Reset
187   if ( gTPCClusters ) gTPCClusters->Reset();
188   if ( gTPCTrack )    gTPCTrack->DestroyElements();
189   if ( gTPCData )     gTPCData->DropAllSectors();
190
191   if ( gITSDigits ) {
192     delete gITSDigits;
193     gITSDigits = NULL;
194   }
195   
196   if ( gMUONClusters ) gMUONClusters->Reset();
197
198
199   // ----------------------------------- foo A
200   vC = kFALSE;
201
202   // TList* hListKR = new TList;
203   // TList* hListCF = new TList;
204
205   // ----------------------------------- foo A
206
207   TIter next(gHomerManager->GetBlockList());
208   AliHLTHOMERBlockDesc* block = 0;
209
210   while ((block = (AliHLTHOMERBlockDesc*)next())) {
211    
212 //     printf ( "Det : %s\n" ,block->GetDetector().Data() );
213 //     printf ( "Datatype : %s\n" ,block->GetDataType().Data() );
214
215     
216     
217     // -- TPC
218     // -----------------------------------------------------
219     
220     if ( ! block->GetDetector().CompareTo("TPC") ){
221       
222
223     // +++ CLUSTERS BLOCK
224     // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
225       
226       if ( block->GetDataType().CompareTo("CLUSTERS") == 0 ) {
227         if ( !gTPCClusters ) {
228           gTPCClusters = new TEvePointSet("TPC Clusters");
229           gTPCClusters->SetMainColor(kRed);
230           gTPCClusters->SetMarkerStyle((Style_t)kFullDotSmall);
231           gEve->AddElement(gTPCClusters);
232         }
233         
234         // ** Process Clusters
235         processTPCClusters( block );
236         
237         gTPCClusters->ElementChanged();
238         
239       }else if ( block->GetDataType().CompareTo("ESD_TREE") == 0 ) {
240       // +++ ESD BLOCK
241       // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
242
243         // ** Initialize TPC Tracks
244         if ( !gTPCTrack ) {
245           gTPCTrack = new TEveTrackList("TPC Tracks");
246           gTPCTrack->SetMainColor(kBlue);
247           
248           gEve->AddElement(gTPCTrack);
249         
250           TEveTrackPropagator* rnrStyle = gTPCTrack->GetPropagator();
251           rnrStyle->SetMagField( 0 );
252           rnrStyle->SetFitDecay( 1 );
253         }
254         cout<<"SIZE : "<<block->GetSize()<<endl;
255         // ** Proces Tracks
256         processTPCTracks( block );
257       }else if ( block->GetDataType().CompareTo("DDL_RAW") == 0 ) {
258         processTPCRawData( block );
259       }
260       
261     } else if ( ! block->GetDetector().CompareTo("MUON") ) {
262
263       // -- MUON
264       //-----------------------------------------------------
265       if ( (block->GetDataType().CompareTo("RECHITS") == 0) || (block->GetDataType().CompareTo("TRIGRECS") == 0) ) {
266
267 //      printf ( "Inside : Datatype : %s\n" ,block->GetDataType().Data() );
268 //      printf ( "Inside : DataSize : %d\n" ,block->GetSize() );
269         if ( !gMUONClusters ) {
270           gMUONClusters = new TEvePointSet("MUON RecHits");
271           gMUONClusters->SetMainColor(kBlue);
272           gMUONClusters->SetMarkerStyle(20);
273           gEve->AddElement(gMUONClusters);
274         }
275         
276         // ** Process Clusters
277         processMUONClusters( block );
278         
279         gMUONClusters->ElementChanged();
280         
281       }//MUON Clusters
282
283
284     }  else if ( ! block->GetDetector().CompareTo("SPD") ) {
285
286       // -- SPD 
287       // -----------------------------------------------------
288
289       if ( block->GetDataType().CompareTo("DDL_RAW") == 0 ) {
290         // ** Initialize SPD Digits
291         if ( !gITSDigits ) {
292           gITSDigits = new AliEveITSDigitsInfo();
293         }
294         
295         processSPDRawData( block );             
296       }
297
298     }else{
299
300       printf ("Detector \"%s\" has not been recognized",block->GetDetector().Data());
301     }
302     
303   }
304   
305   if ( gTPCLoader )   gTPCLoader->UpdateSectors( kTRUE );
306   if ( gTPCClusters ) gTPCClusters->ResetBBox();
307   if ( gTPCTrack )    gTPCTrack->MakeTracks();
308   if ( gITSDigits )   drawSPDRawData();
309   
310   if ( gMUONClusters ) gMUONClusters->ResetBBox();
311   
312   gEve->Redraw3D(0,1); // (0, 1)
313   gEve->EnableRedraw(); 
314     
315   return iResult;
316 }
317
318 //****************************************************************************
319 //****************************************************************************
320 //****************************************************************************
321 void loopEvent() {
322   event_timer.SetCommand("nextEvent()");
323   event_timer.Start(6000);
324 }
325
326 //****************************************************************************
327 void stopLoopEvent() {
328   event_timer.Stop();
329 }
330
331 //****************************************************************************
332 Int_t processTPCRawData(AliHLTHOMERBlockDesc* block) {
333
334   Int_t iResult = 0;
335
336   Int_t sector = block->GetSubDetector().Atoi();
337   Int_t patch  = block->GetSubSubDetector().Atoi();
338   Int_t eqId   = 768 + patch;
339   
340   if ( patch >= 2) eqId += 4 * sector + 70;
341   else             eqId += 2 * sector;
342
343   printf("sector : %d %d %d -- %p %lu\n", sector, patch, eqId, block->GetData(), block->GetSize());
344
345   gMemReader->SetMemory( reinterpret_cast<UChar_t*> ( block->GetData() ), block->GetSize() );
346   gMemReader->SetEquipmentID( eqId );
347   gMemReader->Reset();
348
349   AliTPCRawStream tpcStream( gMemReader );
350   gMemReader->Select("TPC"); 
351   
352   gTPCData->LoadRaw( tpcStream, kTRUE, kTRUE );
353
354   return iResult;
355 }
356
357 //****************************************************************************
358 Int_t processTPCClusters(AliHLTHOMERBlockDesc* block) {
359   Int_t iResult = 0;
360
361   Int_t   slice = block->GetSubDetector().Atoi();
362   Int_t   patch = block->GetSubSubDetector().Atoi();
363   Float_t phi   = ( slice + 0.5 ) * TMath::Pi() / 9.0;  
364   Float_t cos   = TMath::Cos( phi );
365   Float_t sin   = TMath::Sin( phi );
366     
367   AliHLTTPCClusterData *cd = (AliHLTTPCClusterData*) block->GetData();
368   UChar_t *data            = (UChar_t*) cd->fSpacePoints;
369
370   if ( cd->fSpacePointCnt == 0 ) {
371     printf ("No Clusters found in sector %d patch %d.\n", slice, patch );
372     iResult = -1;
373   } 
374   else {
375     
376     for (Int_t ii = 0; ii < cd->fSpacePointCnt; ++ii, data += sizeof(AliHLTTPCSpacePointData)) {
377       AliHLTTPCSpacePointData *sp = (AliHLTTPCSpacePointData *) data;
378
379       gTPCClusters->SetNextPoint(cos*sp->fX - sin*sp->fY, sin*sp->fX + cos*sp->fY, sp->fZ);
380     }
381   }
382
383   return iResult;
384 }
385
386 //****************************************************************************
387 TEveTrack* makeESDTrack( TEveTrackPropagator*   rnrStyle,
388                          Int_t                  idx,
389                          AliESDtrack*           esdTrack,
390                          AliExternalTrackParam* trackParam  ) {
391   // Helper function
392   
393   Double_t     pbuf[3], vbuf[3];
394   TEveRecTrack rt;
395   TEvePathMark startPoint(TEvePathMark::kReference);
396   TEvePathMark midPoint(TEvePathMark::kReference);
397   TEvePathMark mid1Point(TEvePathMark::kReference);
398   TEvePathMark endPoint(TEvePathMark::kReference);
399   TEvePathMark decPoint(TEvePathMark::kDecay);
400
401   /*printf("ESD track: %f, %f, %f, %f, %f, %f, %f",
402          esdTrack->GetAlpha(),
403          esdTrack->GetX(), 
404          esdTrack->GetY(),
405          esdTrack->GetZ(),    
406          esdTrack->GetSnp(),  
407          esdTrack->GetTgl(),  
408          esdTrack->GetSigned1Pt()
409          );
410   */
411   cout<<"TPCPoints::"<<esdTrack->GetTPCPoints(0)<<" "<<esdTrack->GetTPCPoints(1)<<" "<<esdTrack->GetTPCPoints(2)<<" "<<esdTrack->GetTPCPoints(3)<<endl;
412
413   if ( trackParam == 0 ) 
414     trackParam = esdTrack;
415
416   rt.fLabel  = esdTrack->GetLabel();
417   rt.fIndex  = idx;
418   rt.fStatus = (Int_t) esdTrack->GetStatus();
419   rt.fSign   = (Int_t) trackParam->GetSign();
420
421   Double_t x0 = trackParam->GetX();
422   Double_t dx = esdTrack->GetTPCPoints(2) - x0;
423
424   for( Double_t x1=x0; x1<x0+dx; x1+=(dx)*.1 ){//SG
425     AliExternalTrackParam startParam = *trackParam;
426     AliHLTTPCCATrackParam t;
427     t.SetExtParam(startParam, gSolenoidField );
428     if( !t.TransportToX(x1) ) continue; 
429     t.GetExtParam( startParam, startParam.GetAlpha(), gSolenoidField );
430     if( TMath::Abs(startParam.GetSnp())>.99 ) continue;
431
432     startParam.GetXYZ(vbuf);
433     
434     { // get momentum manually because trackParam->GetPxPyPz doesn't works for straight lines
435
436       Double_t pt= TMath::Abs(startParam.GetSigned1Pt());
437       pt = (pt>kAlmost0) ?1./pt :100.;
438       
439       Double_t cA=TMath::Cos(startParam.GetAlpha()), sA=TMath::Sin(startParam.GetAlpha());
440     
441       Double_t sT=startParam.GetSnp();
442       if( sT>kAlmost1 ){ sT = kAlmost1; }
443       else if( sT<-kAlmost1 ){ sT = -kAlmost1; }
444       Double_t cT = TMath::Sqrt(TMath::Abs(1 - sT*sT));
445       
446       pbuf[0] = pt*(cT*cA - sT*sA); 
447       pbuf[1] = pt*(sT*cA + cT*sA); 
448       pbuf[2] = pt*startParam.GetTgl();
449     }
450   
451     break;
452   }
453
454   rt.fV.Set(vbuf);
455   rt.fP.Set(pbuf);
456   startPoint.fV.Set(vbuf);
457   startPoint.fP.Set(pbuf);
458   
459   Double_t ep = esdTrack->GetP(), mc = esdTrack->GetMass();
460   rt.fBeta = ep/TMath::Sqrt(ep*ep + mc*mc);
461
462   TEveTrack* track = new TEveTrack(&rt, rnrStyle);
463
464   cout<<"startPoint = "<<vbuf[0]<<" "<<vbuf[1]<<" "<<vbuf[2]<<" "<<pbuf[0]<<" "<<pbuf[1]<<" "<<pbuf[2]<<endl;
465
466  
467   for( ; TMath::Abs(dx)>=1.; dx*=.9 ){
468     AliExternalTrackParam endParam = *trackParam;
469     //if( !endParam.PropagateTo(x0+dx, gSolenoidField) ) continue; 
470     AliHLTTPCCATrackParam t;
471     t.SetExtParam(endParam, gSolenoidField );
472     if( !t.TransportToX(x0+dx) ) continue; 
473     t.GetExtParam( endParam, endParam.GetAlpha(), gSolenoidField );
474
475     if( TMath::Abs(endParam.GetSnp())>.99 ) continue;
476     
477     { // get momentum manually because trackParam->GetPxPyPz doesn't works for straight lines
478
479       Double_t pt= TMath::Abs(endParam.GetSigned1Pt());
480       pt = (pt>kAlmost0) ?1./pt :100.;
481       
482       Double_t cA=TMath::Cos(endParam.GetAlpha()), sA=TMath::Sin(endParam.GetAlpha());
483       
484       Double_t sT=endParam.GetSnp();
485       if( sT>=kAlmost1 ){ sT = kAlmost1; }
486       else if( sT<-kAlmost1 ){ sT = -kAlmost1; }
487       Double_t cT = TMath::Sqrt(TMath::Abs(1 - sT*sT));
488       
489       endParam.GetXYZ(vbuf);
490       pbuf[0] = pt*(cT*cA - sT*sA);
491       pbuf[1] = pt*(sT*cA + cT*sA);
492       pbuf[2] = pt*endParam.GetTgl();
493     }
494     break;
495   }
496   endPoint.fV.Set(vbuf);
497   endPoint.fP.Set(pbuf);
498   decPoint.fV.Set(vbuf);
499   decPoint.fP.Set(pbuf);
500
501   cout<<"endPoint = "<<vbuf[0]<<" "<<vbuf[1]<<" "<<vbuf[2]<<" "<<pbuf[0]<<" "<<pbuf[1]<<" "<<pbuf[2]<<endl;
502
503   dx*=.6;
504   for( ; TMath::Abs(dx)>=.5; dx*=.8 ){
505     AliExternalTrackParam endParam = *trackParam;
506     //if( !endParam.PropagateTo(x0+dx, gSolenoidField) ) continue; 
507     AliHLTTPCCATrackParam t;
508     t.SetExtParam(endParam, gSolenoidField );
509     if( !t.TransportToX(x0+dx) ) continue; 
510     t.GetExtParam( endParam, endParam.GetAlpha(), gSolenoidField );
511     if( TMath::Abs(endParam.GetSnp())>.99 ) continue;
512     
513     { // get momentum manually because trackParam->GetPxPyPz doesn't works for straight lines
514
515       Double_t pt= TMath::Abs(endParam.GetSigned1Pt());
516       pt = (pt>kAlmost0) ?1./pt :100.;
517       
518       Double_t cA=TMath::Cos(endParam.GetAlpha()), sA=TMath::Sin(endParam.GetAlpha());
519       
520       Double_t sT=endParam.GetSnp();
521       if( sT>=kAlmost1 ){ sT = kAlmost1; }
522       else if( sT<-kAlmost1 ){ sT = -kAlmost1; }
523       Double_t cT = TMath::Sqrt(TMath::Abs(1 - sT*sT));
524       
525       endParam.GetXYZ(vbuf);
526       pbuf[0] = pt*(cT*cA - sT*sA);
527       pbuf[1] = pt*(sT*cA + cT*sA);
528       pbuf[2] = pt*endParam.GetTgl();
529     }
530     break;
531   }
532
533   mid1Point.fV.Set(vbuf);
534   mid1Point.fP.Set(pbuf);
535
536   //cout<<"midPoint = "<<vbuf[0]<<" "<<vbuf[1]<<" "<<vbuf[2]<<" "<<pbuf[0]<<" "<<pbuf[1]<<" "<<pbuf[2]<<endl;
537  
538   dx*=.5;
539   for( ; TMath::Abs(dx)>=.5; dx*=.8 ){
540     AliExternalTrackParam endParam = *trackParam;
541     //if( !endParam.PropagateTo(x0+dx, gSolenoidField) ) continue; 
542     AliHLTTPCCATrackParam t;
543     t.SetExtParam(endParam, gSolenoidField );
544     if( !t.TransportToX(x0+dx) ) continue; 
545     t.GetExtParam( endParam, endParam.GetAlpha(), gSolenoidField );
546     if( TMath::Abs(endParam.GetSnp())>.99 ) continue;
547     
548     { // get momentum manually because trackParam->GetPxPyPz doesn't works for straight lines
549
550       Double_t pt= TMath::Abs(endParam.GetSigned1Pt());
551       pt = (pt>kAlmost0) ?1./pt :100.;
552       
553       Double_t cA=TMath::Cos(endParam.GetAlpha()), sA=TMath::Sin(endParam.GetAlpha());
554       
555       Double_t sT=endParam.GetSnp();
556       if( sT>=kAlmost1 ){ sT = kAlmost1; }
557       else if( sT<-kAlmost1 ){ sT = -kAlmost1; }
558       Double_t cT = TMath::Sqrt(TMath::Abs(1 - sT*sT));
559       
560       endParam.GetXYZ(vbuf);
561       pbuf[0] = pt*(cT*cA - sT*sA);
562       pbuf[1] = pt*(sT*cA + cT*sA);
563       pbuf[2] = pt*endParam.GetTgl();
564     }
565     break;
566   }
567
568   midPoint.fV.Set(vbuf);
569   midPoint.fP.Set(pbuf);
570
571   track->AddPathMark( startPoint );
572   track->AddPathMark( midPoint );
573   track->AddPathMark( mid1Point );
574   track->AddPathMark( endPoint );
575   track->AddPathMark( decPoint );
576   
577   //PH The line below is replaced waiting for a fix in Root
578   //PH which permits to use variable siza arguments in CINT
579   //PH on some platforms (alphalinuxgcc, solariscc5, etc.)
580   //PH  track->SetName(Form("ESDTrack %d", rt.label));
581   //PH  track->SetTitle(Form("pT=%.3f, pZ=%.3f; V=(%.3f, %.3f, %.3f)",
582   //PH                 rt.sign*TMath::Hypot(rt.P.x, rt.P.y), rt.P.z,
583   //PH                 rt.V.x, rt.V.y, rt.V.z));
584   char form[1000];
585   sprintf(form,"TEveTrack %d", rt.fIndex);
586   track->SetName(form);
587   track->SetStdTitle();
588   return track;
589 }
590
591 //****************************************************************************
592 Int_t processTPCTracks(AliHLTHOMERBlockDesc* block) {
593
594   TTree *tr = (TTree*) block->GetTObject();
595
596 //   ofstream fout("ESD_TPC.dat",ios::binary);
597 //   fout.write((char*)block->GetData(),block->GetSize());
598 //   fout.close();
599   TFile f("ESD_TPC.root","recreate");
600   tr->Write();
601   f.Close();
602
603   TFile* esdFile = TFile::Open("ESD_TPC.root");
604   
605   AliESDEvent* esd = new AliESDEvent();
606   TTree* tree = (TTree*) esdFile->Get("esdTree");
607   esd->ReadFromTree(tree);
608   //tr->SetBranchAddress("ESD", &esd);
609   //   if(tr->GetBranch("ESD"))
610   //     return 0;
611
612   tree->GetEntry(0);
613
614   TEveTrackPropagator* rnrStyle = gTPCTrack->GetPropagator();
615   rnrStyle->SetMagField( 0.1*esd->GetMagneticField() );
616   gSolenoidField = esd->GetMagneticField();
617
618   cout << "Number of tracks found :" << esd->GetNumberOfTracks() << endl;
619
620   Double_t pin[3];
621   
622   for (Int_t ii=0; ii< esd->GetNumberOfTracks(); ii++) {
623
624     AliESDtrack           *esdTrack = esd->GetTrack(ii);
625     AliExternalTrackParam *trackParam = esdTrack;
626     cout<<"\nESD track N"<<ii<<":"<<endl;
627     trackParam->Print();
628
629     TEveTrack* track = makeESDTrack( rnrStyle, ii, esdTrack, trackParam );
630     esdTrack->GetPxPyPz(pin);
631
632     //cout<<"pt : "<<sqrt(pin[0]*pin[0] + pin[1]*pin[1])<<endl;
633     track->SetAttLineAttMarker(gTPCTrack);    
634    gEve->AddElement(track, gTPCTrack);
635  }
636   
637   delete esd;
638   
639   return 0;
640 }
641
642 //****************************************************************************
643 Int_t processSPDRawData(AliHLTHOMERBlockDesc* block) {
644   Int_t iResult = 0;
645
646   Int_t partition = block->GetSubDetector().Atoi();
647   Int_t eqId      = partition;
648
649   gMemReader->SetMemory( reinterpret_cast<UChar_t*> ( block->GetData() ), block->GetSize() );
650   gMemReader->SetEquipmentID( eqId );
651   gMemReader->Reset();
652
653   gITSDigits->ReadRaw( gMemReader, 3);
654
655   return iResult;
656 }
657
658 //****************************************************************************
659 Int_t drawSPDRawData() {
660
661   Int_t iResult = 0;
662
663   TString sSector;
664   TString bsSector="Sector";
665   TString sStave;
666   TString bsStave="Stave";
667
668   Int_t ndx=0;
669   Int_t sector, stave, module;
670
671   //gEve->DisableRedraw();
672
673   // ** first layer **
674
675   TEveElementList* layer1 = new TEveElementList( "SPD0" );
676   layer1->SetTitle( "SPDs' first layer" );
677   layer1->SetMainColor(2);
678   gEve->AddElement( layer1 );
679   
680   for ( sector=0; sector<10; sector++ ) {
681     sSector  = bsSector;
682     sSector += sector;
683
684     TEveElementList* relSector = new TEveElementList( sSector.Data() );
685     relSector->SetMainColor(2);
686     gEve->AddElement( relSector, layer1 );
687
688     for ( stave=0; stave<2; stave++ ) {
689       sStave  = bsStave;
690       sStave += stave;
691       
692       TEveElementList* relStave = new TEveElementList( sStave.Data() );
693       relStave->SetMainColor(2);
694       gEve->AddElement( relStave, relSector );
695
696       for ( module=0; module<4; module++ ) {
697         
698         if ( gITSDigits->GetDigits( ndx, 0 ) && 
699              gITSDigits->GetDigits( ndx, 0 )->GetEntriesFast() > 0) {
700           
701           AliEveITSModule* moduleITS = new AliEveITSModule( ndx, gITSDigits );
702           gEve->AddElement( moduleITS, relStave );
703         }
704
705         ++ndx; 
706
707       } // for ( module=0; module<4; module++ ) {
708     } // for ( stave=0; stave<2; stave++ ) {
709   } // for ( sector=0; sector<10; sector++ ) {
710
711   // ** second layer **
712
713   TEveElementList* layer2 = new TEveElementList( "SPD1" );
714   layer2->SetTitle( "SPDs' second layer" );
715   layer2->SetMainColor(2);
716   gEve->AddElement(layer2);
717   
718   for ( sector=0; sector<10; sector++ ) {
719     sSector  = bsSector;
720     sSector += sector;
721     
722     TEveElementList* relSector = new TEveElementList( sSector.Data() );
723     relSector->SetMainColor(2);
724     gEve->AddElement(relSector, layer2 );
725     
726     for ( stave=0; stave<4; stave++ ) {
727       sStave  = bsStave;
728       sStave += stave;
729
730       TEveElementList* relStave = new TEveElementList( sStave.Data() );
731       relStave->SetMainColor(2);
732       gEve->AddElement( relStave, relSector );
733
734       for ( module=0; module<4; module++) {
735
736         if ( gITSDigits->GetDigits( ndx, 0 ) && 
737              gITSDigits->GetDigits( ndx, 0 )->GetEntriesFast() > 0) {
738
739           AliEveITSModule* moduleITS = new AliEveITSModule( ndx, gITSDigits );
740           gEve->AddElement( moduleITS, relStave );
741         }
742          
743         ++ndx;
744       } // for ( module=0; module<4; module++) {
745     } // for ( stave=0; stave<2; stave++ ) {
746   } //for ( sector=0; sector<10; sector++ ) {
747
748   gEve->EnableRedraw();
749     
750   return iResult;
751 }
752
753 //****************************************************************************
754 Int_t processMUONClusters(AliHLTHOMERBlockDesc* block) {
755   Int_t iResult = 0;
756
757       unsigned long size = block->GetSize();
758       int * buffer ;
759
760       //       for(int idata=0;idata<int(size);idata++)
761       //        printf("\tbuffer[%d] : %d\n",idata,buffer[idata]);
762       
763       buffer = (int *)block->GetData();
764       
765       if(block->GetDataType().CompareTo("RECHITS") == 0){
766         
767         AliHLTMUONRecHitsBlockReader trackblock((char*)buffer, size);
768         const AliHLTMUONRecHitStruct* hit = trackblock.GetArray();
769       
770         for(AliHLTUInt32_t ientry = 0; ientry < trackblock.Nentries(); ientry++){
771 //        cout << setw(13) << left << hit->fX << setw(0);
772 //        cout << setw(13) << left << hit->fY << setw(0);
773 //        cout << hit->fZ << setw(0) << endl;
774           gMUONClusters->SetNextPoint(hit->fX,hit->fY,hit->fZ);
775           hit++;
776           
777         }// track hit loop
778       }else{// if rechits
779       
780       
781 //       if(!strcmp((BlockType(ULong64_t(reader->GetBlockDataType(i)))).Data(),"TRIGRECS")){
782
783         AliHLTMUONTriggerRecordsBlockReader trigblock(buffer, size);
784         const AliHLTMUONTriggerRecordStruct* trigrec = trigblock.GetArray();
785         for(AliHLTUInt32_t ientry = 0; ientry < trigblock.Nentries(); ientry++){
786
787           const AliHLTMUONRecHitStruct* hit = &trigrec->fHit[0];
788           for(AliHLTUInt32_t ch = 0; ch < 4; ch++)
789             {
790 //            cout << setw(10) << left << ch + 11 << setw(0);
791 //            cout << setw(13) << left << hit->fX << setw(0);
792 //            cout << setw(13) << left << hit->fY << setw(0);
793 //            cout << hit->fZ << setw(0) << endl;
794               gMUONClusters->SetNextPoint(hit->fX,hit->fY,hit->fZ);
795               hit++;
796             }// trig chamber loop
797           
798         }//trig hit loop
799       }// if trigrecs
800       
801       
802 //       //delete[] buffer;
803 //     }//nof Block received
804 //   }// if any event found
805   
806   
807 //   delete reader;
808
809
810   return iResult;
811 }
812
813
814 //****************************************************************************