]> git.uio.no Git - u/mrichter/AliRoot.git/blame - EVE/hlt-macros/onlineDisplay.C
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bugfix, historams where missing when running on the grid
[u/mrichter/AliRoot.git] / EVE / hlt-macros / onlineDisplay.C
CommitLineData
9e78371d 1//-*- Mode: C++ -*-
2
3// ** USED macros :
4// ***************************************************
5// - hlt_alieve_init.C
6// - VizDB_scan.C
7// - geom_gentle_hlt.C
8// - geom_gentle_muon.C
9// ***************************************************
10
1d8ae8b6 11#if !defined(__CINT__) || defined(__MAKECINT__)
12
ea48ba6e 13//****************** ROOT ******************************************
1d8ae8b6 14#include "TTimer.h"
15#include "TRandom.h"
16#include "TVirtualPad.h"
17#include "TGLViewer.h"
18#include "TThread.h"
19#include "TGFileBrowser.h"
20#include "TStyle.h"
21#include "TList.h"
22#include "TDirectory.h"
23#include "TFile.h"
24#include "TH2.h"
25#include "TCanvas.h"
26#include "TColor.h"
c5e3aa8e 27#include "TVector3.h"
1d8ae8b6 28
ea48ba6e 29//****************** ROOT/EVE **************************************
1d8ae8b6 30#include "TEveManager.h"
31#include "TEvePointSet.h"
32#include "TEveTrack.h"
33#include "TEveVSDStructs.h"
34#include "TEveTrackPropagator.h"
35#include "TEveScene.h"
36#include "TEveElement.h"
37#include "TEveUtil.h"
38#include "TEveEventManager.h"
39#include "TEveProjectionAxes.h"
40#include "TEveWindowManager.h"
41#include "TEveViewer.h"
42#include "TEveText.h"
43#include "TEveProjectionManager.h"
44#include "TEveGeoShape.h"
c5e3aa8e 45#include "TEveBoxSet.h"
46#include "TEveTrans.h"
47#include "TEveRGBAPalette.h"
cfa641b1 48#include "TLine.h"
49#include "TEveStraightLineSet.h"
50#include "TGeoNode.h"
51#include "TGeoManager.h"
52#include "TGLOverlayButton.h"
ea48ba6e 53//****************** AliRoot ***************************************
1d8ae8b6 54#include "AliESDEvent.h"
55#include "AliCDBManager.h"
56#include "AliRawReaderMemory.h"
57#include "AliTPCRawStream.h"
58#include "AliGeomManager.h"
ea48ba6e 59
60//****************** AliRoot/EVE ***********************************
1d8ae8b6 61#include "AliHLTHOMERManager.h"
62#include "AliEveHOMERManager.h"
63#include "AliEveTPCLoader.h"
64#include "AliEveTPCData.h"
65#include "AliEveITSDigitsInfo.h"
66#include "AliEveITSModule.h"
67#include "AliEveMacroExecutor.h"
68#include "AliEveMacro.h"
69#include "AliEveTrack.h"
ea48ba6e 70
71//****************** AliRoot/HLT ***********************************
1d8ae8b6 72#include "AliHLTHOMERBlockDesc.h"
73#include "AliHLTHOMERReader.h"
c5e3aa8e 74#include "AliHLTMUONUtils.h"
1d8ae8b6 75#include "AliHLTMUONDataBlockReader.h"
76#include "AliHLTTriggerDecision.h"
1d8ae8b6 77#include "AliHLTGlobalTriggerDecision.h"
c5e3aa8e 78#include "AliHLTTPCCATrackParam.h"
cfa641b1 79
ea48ba6e 80//****************** AliRoot/MUON **********************************
1d8ae8b6 81#include "AliMUONCalibrationData.h"
82#include "AliMUONVCalibParam.h"
83#include "AliMUONGeometryTransformer.h"
84#include "AliMUONGeometryDetElement.h"
cfa641b1 85#include "AliMUONConstants.h"
1d8ae8b6 86
87#include "AliMpCDB.h"
88#include "AliMpDDLStore.h"
89#include "AliMpDetElement.h"
90#include "AliMpDEIterator.h"
91#include "AliMpVSegmentation.h"
92#include "AliMpSegmentation.h"
93#include "AliMpTriggerCrate.h"
94#include "AliMpLocalBoard.h"
1d8ae8b6 95
ff64d287 96//****************** AliRoot/ITS ***********************************
c5e3aa8e 97#include "AliITSRecPoint.h"
98
ea48ba6e 99//****************** AliRoot/TRD ***********************************
100#include "AliHLTTRDCluster.h"
101#include "AliTRDcluster.h"
cfa641b1 102#include "AliTRDCalibraVdriftLinearFit.h"
ea48ba6e 103
ff64d287 104//****************** AliRoot/EMCAL *********************************
cfa641b1 105#include "AliHLTCaloClusterDataStruct.h"
106#include "AliHLTCaloClusterReader.h"
107
108#include "HLT/CALO/AliHLTCaloChannelDataHeaderStruct.h"
109#include "HLT/CALO/AliHLTCaloChannelDataStruct.h"
110
ff64d287 111//****************** AliRoot/PHOS **********************************
cfa641b1 112#include "AliPHOSGeometry.h"
113#include "HLT/PHOS/AliHLTPHOSDigitDataStruct.h"
114#include "AliHLTPHOSChannelDataHeaderStruct.h"
115#include "AliHLTPHOSChannelDataStruct.h"
922c1000 116#include "HLT/CALO/AliHLTCaloChannelDataHeaderStruct.h"
117#include "HLT/CALO/AliHLTCaloChannelDataStruct.h"
118
119#include "AliHLTCaloDigitDataStruct.h"
120
121
ea48ba6e 122//****************** Macros ****************************************
1d8ae8b6 123#include "hlt_structs.C"
124#include "hlt_alieve_init.C"
125#include "geom_gentle_hlt.C"
126#include "alice-macros/esd_tracks.C"
cfa641b1 127#include "hlt_esd_tracks.C"
09cdbe4c 128
cfa641b1 129//#include "alieve_vizdb.C"
1d8ae8b6 130
f1fefc07 131#endif
9e78371d 132
f1fefc07 133class TEveTrackList;
9e78371d 134class TEveProjectionManager;
135class TEveGeoShape;
136class TEveUtil;
137class AliEveMacroExecutor;
138class TEveScene;
139class TEveElement;
140class TEveText;
141class AliHLTTriggerDecision;
142class TEvePointSet;
1d8ae8b6 143class TEvePointSetArray;
f1fefc07 144class AliHLTHOMERBlockDesc;
9e78371d 145
f1fefc07 146class TEveViewer;
ea48ba6e 147
cfa641b1 148
9e78371d 149// -----------------------------------------------------------------
150// -- Geometry / Scenes --
151// -----------------------------------------------------------------
152
f1fefc07 153TEveGeoShape *gGeomGentle = 0;
154TEveGeoShape *gGeomGentleRPhi = 0;
155TEveGeoShape *gGeomGentleRhoZ = 0;
156TEveGeoShape *gGeomGentleTRD = 0;
157TEveGeoShape *gGeomGentleMUON = 0;
158
159TEveScene *gRPhiGeomScene = 0;
160TEveScene *gRhoZGeomScene = 0;
161TEveScene *gRPhiEventScene = 0;
162TEveScene *gRhoZEventScene = 0;
163
9e78371d 164TEveProjectionManager *gRPhiMgr = 0;
165TEveProjectionManager *gRhoZMgr = 0;
166
f1fefc07 167TEveViewer *g3DView = 0;
168TEveViewer *gRPhiView = 0;
169TEveViewer *gRhoZView = 0;
170
9e78371d 171// -----------------------------------------------------------------
172// -- Geometry / Scenes Parameters --
173// -----------------------------------------------------------------
174
175// -- Parameters to show different geometries
176Bool_t gShowMUON = kTRUE;
177Bool_t gShowMUONRPhi = kFALSE;
178Bool_t gShowMUONRhoZ = kTRUE;
f1fefc07 179Bool_t gShowTRD = kFALSE;
180
181Bool_t gCenterProjectionsAtPrimaryVertex = kFALSE;
9e78371d 182
183// -----------------------------------------------------------------
184// -- Members --
185// -----------------------------------------------------------------
186
187// -- Timer for automatic event loop
188TTimer eventTimer;
1d8ae8b6 189TTimer eventTimerFast;
9e78371d 190
191// -- HOMERManager
c5e3aa8e 192AliEveHOMERManager* gHomerManager = 0;
193
194// -- Geometry Manager
195TGeoManager* gGeoManager = 0;
196AliPHOSGeometry* gPHOSGeom = 0;
9e78371d 197
198// -- Cluster members
c5e3aa8e 199TEvePointSet* gSPDClusters = 0;
200TEvePointSet* gSSDClusters = 0;
201TEvePointSet* gSDDClusters = 0;
202TEvePointSet* gTRDClusters = 0;
203TEvePointSetArray* gTRDColClusters = 0;
204TEvePointSet* gTPCClusters = 0;
49993c6f 205TEvePointSet* gTPCTestClusters = 0;
c5e3aa8e 206TEvePointSetArray* gTPCColClusters = 0;
207TEveBoxSet* gPHOSBoxSet[5] = {0, 0, 0, 0, 0};
cfa641b1 208TEveBoxSet* gEMCALBoxSet[13] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
c5e3aa8e 209TEvePointSet* gMUONClusters = 0;
cfa641b1 210TEveStraightLineSet* gMUONTracks = 0;
9e78371d 211
f1fefc07 212// -- Text output members
c5e3aa8e 213TEveText* gHLTText = 0;
f1fefc07 214
9e78371d 215// -- Tracks members
c5e3aa8e 216TEveTrackList* gTPCTrack = 0;
9e78371d 217
1d8ae8b6 218// -- Canvas for histograms
c5e3aa8e 219TCanvas* gTRDCanvas = 0;
220TCanvas* gTPCCanvas = 0;
922c1000 221TCanvas* gTPCClustCanvas = 0;
ff64d287 222TCanvas* gTRDCalibCanvas = 0;
223TCanvas* gTRDEORCanvas = 0;
224TCanvas* gPrimVertexCanvas = 0;
225TCanvas* gSPDVertexCanvas = 0;
226TCanvas* gITSCanvas = 0;
227TCanvas* gSSDCanvas0 = 0;
228TCanvas* gSSDCanvas1 = 0;
229TCanvas* gV0Canvas = 0;
922c1000 230TCanvas* gPHOSCanvas = 0;
09cdbe4c 231TCanvas* gEMCALCanvas = 0;
ff64d287 232
233// -- vertex --
234Int_t gSPDVertexHistoCount = 0;
cfa641b1 235
ff64d287 236
237// -- ITS --
238Int_t gITSHistoCount = 0;
239Int_t gSSDHistoCount0 = 0;
240Int_t gSSDHistoCount1 = 0;
1d8ae8b6 241
ea48ba6e 242// -- TRD --
c5e3aa8e 243Int_t gTRDHistoCount = 0;
244Int_t gTRDEvents = 0;
245Int_t gTRDBins = 12;
246
247// -- TPC --
248Int_t gTPCBins = 15;
249TH1F* gTPCCharge = 0;
250TH1F* gTPCQMax = 0;
251TH1F* gTPCQMaxOverCharge = 0;
ea48ba6e 252
922c1000 253TH1F* gTPCPt = 0; // KK
254TH1F* gTPCEta = 0;
255TH1F* gTPCPsi = 0;
256TH1F* gTPCnClusters = 0;
257TH1F* gTPCMult = 0;
258
c5e3aa8e 259// -- PHOS --
260TEveElementList* gPHOSElementList = 0;
922c1000 261Int_t gPHOSHistoCount =0;
cfa641b1 262// -- EMCAL
263TEveElementList* gEMCALElementList = 0;
ff64d287 264TGeoNode* gEMCALNode = 0;
09cdbe4c 265Int_t gEMCALHistoCount =0;
cfa641b1 266
1d8ae8b6 267// --- Flag if eventloop is running
268Bool_t gEventLoopStarted = kFALSE;
f1fefc07 269
cfa641b1 270
271//Container for gGeoManager till it is broken
272TGeoManager *fGeoManager = 0;
9e78371d 273// -----------------------------------------------------------------
274// -- Methods --
275// -----------------------------------------------------------------
276
1d8ae8b6 277Int_t initializeEveViewer( Bool_t TPCMode, Bool_t MUONMode, Bool_t TRDMode );
9e78371d 278
1d8ae8b6 279void nextEvent();
5de5a293 280
ea9a0e13 281Int_t processEvent();
9e78371d 282
c5e3aa8e 283Int_t processPHOSClusters( AliHLTHOMERBlockDesc* block);
922c1000 284Int_t processPHOSDigits(AliHLTHOMERBlockDesc* block);
9e78371d 285
cfa641b1 286Int_t processEMCALClusters( AliHLTHOMERBlockDesc* block);
287
9e78371d 288Int_t processEsdTracks( AliHLTHOMERBlockDesc* block, TEveTrackList* cont );
289
290Int_t processHLTRDLST( AliHLTHOMERBlockDesc* block );
291
1d8ae8b6 292Int_t processROOTTOBJ( AliHLTHOMERBlockDesc* block, TEveText* text );
293
49993c6f 294Int_t processTPCClusters( AliHLTHOMERBlockDesc * block, TEvePointSet *cont, TEvePointSetArray *contCol = NULL );
1d8ae8b6 295
c5e3aa8e 296Int_t processTRDClusters( AliHLTHOMERBlockDesc * block, TEvePointSet *cont, TEvePointSetArray *contCol);
1d8ae8b6 297
ff64d287 298Int_t processTRDHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas );
299
300Int_t processITSHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas );
301
922c1000 302Int_t processPHOSHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas );
303
ff64d287 304Int_t processSSDHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas, TCanvas * canvas1 );
1d8ae8b6 305
ff64d287 306Int_t processPrimVertexHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas );
cfa641b1 307
ff64d287 308Int_t processSPDVertexHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas );
cfa641b1 309
ff64d287 310Int_t processV0Histograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas );
9e78371d 311
ff64d287 312Int_t processTRDCalibHistograms( AliHLTHOMERBlockDesc *block, TCanvas *canvas );
cfa641b1 313
ff64d287 314Int_t processMUONClusters( AliHLTHOMERBlockDesc* block );
c5e3aa8e 315
ff64d287 316Int_t processMUONTracks( AliHLTHOMERBlockDesc* block );
317
318Int_t processITSClusters( AliHLTHOMERBlockDesc* block, TEvePointSet* cont );
319
320Int_t processITSHist( AliHLTHOMERBlockDesc* block );
9e78371d 321
09cdbe4c 322Int_t processBlock( AliHLTHOMERBlockDesc* block );
323Int_t processAsyncBlock( AliHLTHOMERBlockDesc* block );
324Int_t updateDisplay();
8fa2fdc9 325Int_t addHistogramsToCanvas(AliHLTHOMERBlockDesc * block, TCanvas * canvas, Int_t &cdCount );
cfa641b1 326void writeToFile();
327
328
9e78371d 329// #################################################################
330// #################################################################
331// #################################################################
332
333// -----------------------------------------------------------------
1d8ae8b6 334void onlineDisplay(Bool_t TPCMode = kTRUE, Bool_t MUONMode = kFALSE, Bool_t TRDMode = kFALSE) {
f1fefc07 335
9e78371d 336 // -- Loading Geometry
337 // ---------------------
338 Int_t run = 67179;
339 AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
340 AliCDBManager::Instance()->SetRun(run);
341 AliGeomManager::LoadGeometry();
342
c5e3aa8e 343 // Get the pointer to gGeoManager before it's broken (bug in alieve)
cfa641b1 344 fGeoManager = gGeoManager;
c5e3aa8e 345
9e78371d 346 // -- Create new hM object
347 // -------------------------
348 gHomerManager = new AliEveHOMERManager();
cfa641b1 349 gHomerManager->SetRetryCount(1000,15);
9e78371d 350
351 Int_t iResult = gHomerManager->Initialize();
352 if (iResult) {
353 printf("Error Initializing AliHLTHOMERManager, quitting");
354 return;
355 }
356
357 // -- Add hM to EveTree
358 // ----------------------
359 gEve->AddToListTree(gHomerManager, kTRUE);
360
361 // -- Create SourceList
362 // ----------------------
363 iResult = gHomerManager->CreateEveSourcesListLoop();
364 if (iResult) {
365 printf ("Couldn't find active services. returning\n");
366 return;
367 }
368
369 // -- Initialize pointsets and add macros
370 // ----------------------------------------
1d8ae8b6 371 //TEveUtil::LoadMacro("hlt_alieve_init.C");
372 //hlt_alieve_init(".", -1);
9e78371d 373
374 // -- Initialize Eve
375 // -------------------
1d8ae8b6 376 initializeEveViewer( TPCMode, MUONMode, TRDMode);
9e78371d 377
c5e3aa8e 378 // -- Reset gGeoManager to the original pointer
379 // ----------------------------------------------
cfa641b1 380 gGeoManager = fGeoManager;
c5e3aa8e 381 gPHOSGeom = AliPHOSGeometry::GetInstance("IHEP", "IHEP");
382
9e78371d 383 // -- Finalize Eve
384 // -----------------
385 gSystem->ProcessEvents();
386 gEve->Redraw3D(kTRUE);
f1fefc07 387
1d8ae8b6 388 if ( TPCMode ) {
389 gHomerManager->ConnectEVEtoHOMER("TPC" );
390 } else if ( MUONMode ) {
391 gHomerManager->ConnectEVEtoHOMER("MUON");
392 } else if( TRDMode ) {
393 gHomerManager->ConnectEVEtoHOMER("TRD");
394 } else {
395 cout<<" No detectors selected, nothing will be displayed"<<endl;
396 }
c5e3aa8e 397
398 g_esd_tracks_true_field = kFALSE;
cfa641b1 399
9e78371d 400}
401
1d8ae8b6 402// -------------------------------------------------------------------------
403Int_t initializeEveViewer( Bool_t TPCMode, Bool_t MUONMode, Bool_t TRDMode) {
9e78371d 404
cfa641b1 405 //=============================================================================
406 // Visualization database
407 //============================================================================
408
409 TEveUtil::AssertMacro("VizDB_scan.C");
410
411 // alieve_vizdb();
412
413
414
9e78371d 415 //==============================================================================
ea48ba6e 416 // -- Geometry, scenes, projections and viewers
9e78371d 417 //==============================================================================
418
09cdbe4c 419
f1fefc07 420 TEveBrowser *browser = gEve->GetBrowser();
421 browser->ShowCloseTab(kFALSE);
422
9e78371d 423 // -- Disable extra geometry
424 // ---------------------------
ea48ba6e 425 if (!MUONMode)
9e78371d 426 gShowMUON = gShowMUONRPhi = gShowMUONRhoZ = kFALSE;
ea48ba6e 427
9e78371d 428 // -- Load Geometry
429 // ------------------
430 TEveUtil::LoadMacro("geom_gentle_hlt.C");
f1fefc07 431 gGeomGentle = geom_gentle_hlt();
432 gGeomGentleRPhi = geom_gentle_rphi(); gGeomGentleRPhi->IncDenyDestroy();
433 gGeomGentleRhoZ = geom_gentle_rhoz(); gGeomGentleRhoZ->IncDenyDestroy();
434 gGeomGentleTRD = geom_gentle_trd();
435
cfa641b1 436 gGeoManager = fGeoManager;
437
438 gEMCALNode = gGeoManager->GetTopVolume()->FindNode("XEN1_1");
439
440 TEveGeoTopNode* emcal_re = new TEveGeoTopNode(gGeoManager, gEMCALNode);
441 gEve->AddGlobalElement(emcal_re);
442 gEve->Redraw3D();
443
ea48ba6e 444 if (gShowMUON)
f1fefc07 445 gGeomGentleMUON = geom_gentle_muon(kFALSE);
ea48ba6e 446
447 // -- Scenes
448 // -----------
f1fefc07 449 gRPhiGeomScene = gEve->SpawnNewScene("RPhi Geometry",
450 "Scene holding projected geometry for the RPhi view.");
451 gRhoZGeomScene = gEve->SpawnNewScene("RhoZ Geometry",
452 "Scene holding projected geometry for the RhoZ view.");
453 gRPhiEventScene = gEve->SpawnNewScene("RPhi Event Data",
454 "Scene holding projected geometry for the RPhi view.");
455 gRhoZEventScene = gEve->SpawnNewScene("RhoZ Event Data",
456 "Scene holding projected geometry for the RhoZ view.");
9e78371d 457
ea48ba6e 458 // -- Projection managers
459 // ------------------------
f1fefc07 460
9e78371d 461 gRPhiMgr = new TEveProjectionManager();
462 gRPhiMgr->SetProjection(TEveProjection::kPT_RPhi);
463 gEve->AddToListTree(gRPhiMgr, kFALSE);
464 {
465 TEveProjectionAxes* a = new TEveProjectionAxes(gRPhiMgr);
466 a->SetMainColor(kWhite);
467 a->SetTitle("R-Phi");
468 a->SetTitleSize(0.05);
469 a->SetTitleFont(102);
470 a->SetLabelSize(0.025);
471 a->SetLabelFont(102);
f1fefc07 472 gRPhiGeomScene->AddElement(a);
9e78371d 473 }
9e78371d 474 gRPhiMgr->SetCurrentDepth(-10);
f1fefc07 475 gRPhiMgr->ImportElements(gGeomGentleRPhi, gRPhiGeomScene);
9e78371d 476 gRPhiMgr->SetCurrentDepth(0);
1d8ae8b6 477 gRPhiMgr->ImportElements(gGeomGentleTRD, gRPhiGeomScene);
f1fefc07 478 if (gShowMUONRPhi) gRPhiMgr->ImportElements(gGeomGentleMUON, gRPhiGeomScene);
9e78371d 479
9e78371d 480 gRhoZMgr = new TEveProjectionManager();
481 gRhoZMgr->SetProjection(TEveProjection::kPT_RhoZ);
482 gEve->AddToListTree(gRhoZMgr, kFALSE);
483 {
484 TEveProjectionAxes* a = new TEveProjectionAxes(gRhoZMgr);
485 a->SetMainColor(kWhite);
486 a->SetTitle("Rho-Z");
487 a->SetTitleSize(0.05);
488 a->SetTitleFont(102);
489 a->SetLabelSize(0.025);
490 a->SetLabelFont(102);
f1fefc07 491 gRhoZGeomScene->AddElement(a);
9e78371d 492 }
493 gRhoZMgr->SetCurrentDepth(-10);
f1fefc07 494 gRhoZMgr->ImportElements(gGeomGentleRhoZ, gRhoZGeomScene);
9e78371d 495 gRhoZMgr->SetCurrentDepth(0);
f1fefc07 496 if (gShowTRD) gRhoZMgr->ImportElements(gGeomGentleTRD, gRhoZGeomScene);
497 if (gShowMUONRhoZ) gRhoZMgr->ImportElements(gGeomGentleMUON, gRhoZGeomScene);
9e78371d 498
ea48ba6e 499 // -- Viewers
500 // ------------
9e78371d 501
ea48ba6e 502 TEveWindowSlot *slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
503 TEveWindowPack *pack = slot->MakePack();
9e78371d 504 pack->SetElementName("Multi View");
505 pack->SetHorizontal();
506 pack->SetShowTitleBar(kFALSE);
507 pack->NewSlot()->MakeCurrent();
f1fefc07 508 g3DView = gEve->SpawnNewViewer("3D View", "");
509 g3DView->AddScene(gEve->GetGlobalScene());
510 g3DView->AddScene(gEve->GetEventScene());
511
cfa641b1 512
513
514
9e78371d 515 pack = pack->NewSlot()->MakePack();
516 pack->SetShowTitleBar(kFALSE);
517 pack->NewSlot()->MakeCurrent();
f1fefc07 518 gRPhiView = gEve->SpawnNewViewer("RPhi View", "");
519 gRPhiView->GetGLViewer()->SetCurrentCamera(TGLViewer::kCameraOrthoXOY);
520 gRPhiView->AddScene(gRPhiGeomScene);
521 gRPhiView->AddScene(gRPhiEventScene);
9e78371d 522
523 pack->NewSlot()->MakeCurrent();
f1fefc07 524 gRhoZView = gEve->SpawnNewViewer("RhoZ View", "");
525 gRhoZView->GetGLViewer()->SetCurrentCamera(TGLViewer::kCameraOrthoXOY);
526 gRhoZView->AddScene(gRhoZGeomScene);
527 gRhoZView->AddScene(gRhoZEventScene);
528
cfa641b1 529
530
531 //Add HLT Text to windows
532
533 TGLOverlayButton *ob1 = new TGLOverlayButton(g3DView->GetGLViewer(), "HLT", 0, 20, 110, 60);
534 ob1->SetAlphaValues(0.8, 0.8);
ff64d287 535 // cout << "color" << ob1->GetBackColor() << endl;
cfa641b1 536 //ob1->SetBackColor(8421631);
537 ob1->SetBackColor(10492431);
538 TGLOverlayButton *ob2 = new TGLOverlayButton(g3DView->GetGLViewer(), "ALICE", 0, 0, 110, 20);
539 ob2->SetAlphaValues(0.8, 0.8);
540 ob1->SetBackColor(0.2);
541 TGLOverlayButton *ob3 = new TGLOverlayButton(gEve->GetDefaultGLViewer(), "HLT", 0, 20, 110, 60);
542 ob3->SetAlphaValues(0.8, 0.8);
543 TGLOverlayButton *ob4 = new TGLOverlayButton(gEve->GetDefaultGLViewer(), "ALICE", 0, 0, 110, 20);
544 ob4->SetAlphaValues(0.8, 0.8);
545
546
ea48ba6e 547 // -- List of Viewers
548 // --------------------
9e78371d 549
550 TEveViewerList *viewerlist = new TEveViewerList();
551 viewerlist->AddElement(gEve->GetDefaultViewer());
552
f1fefc07 553 viewerlist->AddElement(g3DView);
554 viewerlist->AddElement(gRhoZView);
555 viewerlist->AddElement(gRPhiView);
9e78371d 556 viewerlist->SwitchColorSet();
557
558 //==============================================================================
ea48ba6e 559 // -- Macros / QA histograms
9e78371d 560 //==============================================================================
561
562 // -- Registration of per-event macros
563 // -------------------------------------
564
565 AliEveMacroExecutor *exec = new AliEveMacroExecutor();
09cdbe4c 566
567
9e78371d 568#if 0
569 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "SIM Track", "kine_tracks.C", "kine_tracks", "", kFALSE));
570
571 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "SIM Hit ITS", "its_hits.C", "its_hits", "", kFALSE));
572 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "SIM Hit TPC", "tpc_hits.C", "tpc_hits", "", kFALSE));
573 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "SIM Hit T0", "t0_hits.C", "t0_hits", "", kFALSE));
574 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "SIM Hit FMD", "fmd_hits.C", "fmd_hits", "", kFALSE));
575
576 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "DIG FMD", "fmd_digits.C", "fmd_digits", "", kFALSE));
577
578 exec->AddMacro(new AliEveMacro(AliEveMacro::kRawReader, "RAW TPC", "tpc_raw.C", "tpc_raw", "", kFALSE));
579 exec->AddMacro(new AliEveMacro(AliEveMacro::kRawReader, "RAW T0", "t0_raw.C", "t0_raw", "", kFALSE));
580 exec->AddMacro(new AliEveMacro(AliEveMacro::kRawReader, "RAW FMD", "fmd_raw.C", "fmd_raw", "", kFALSE));
581 exec->AddMacro(new AliEveMacro(AliEveMacro::kRawReader, "RAW VZERO", "vzero_raw.C", "vzero_raw", "", kFALSE));
582 exec->AddMacro(new AliEveMacro(AliEveMacro::kRawReader, "RAW ACORDE", "acorde_raw.C", "acorde_raw", "", kFALSE));
583
584 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC PVTX", "primary_vertex.C", "primary_vertex", "", kTRUE));
585 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC PVTX Ellipse", "primary_vertex.C", "primary_vertex_ellipse", "", kTRUE));
586 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC PVTX Box", "primary_vertex.C", "primary_vertex_box", "kFALSE, 3, 3, 3", kFALSE));
587 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC PVTX", "primary_vertex.C", "primary_vertex_spd", "", kTRUE));
588 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC PVTX Ellipse", "primary_vertex.C", "primary_vertex_ellipse_spd", "", kTRUE));
589 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC PVTX Box", "primary_vertex.C", "primary_vertex_box_spd", "kFALSE, 3, 3, 3", kFALSE));
590 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC PVTX", "primary_vertex.C", "primary_vertex_tpc", "", kFALSE));
591 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC PVTX Ellipse", "primary_vertex.C", "primary_vertex_ellipse_tpc", "", kFALSE));
592 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC PVTX Box", "primary_vertex.C", "primary_vertex_box_tpc", "kFALSE, 3, 3, 3", kFALSE));
593#endif
594 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC V0", "esd_V0_points.C", "esd_V0_points_onfly"));
595 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC V0", "esd_V0_points.C", "esd_V0_points_offline"));
596 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC V0", "esd_V0.C", "esd_V0"));
597 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC CSCD", "esd_cascade_points.C", "esd_cascade_points"));
598 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC CSCD", "esd_cascade.C", "esd_cascade"));
599 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC KINK", "esd_kink_points.C", "esd_kink_points"));
600 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC KINK", "esd_kink.C", "esd_kink"));
601
602 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC Track", "esd_tracks.C", "esd_tracks", "", kFALSE));
603 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC Track", "esd_tracks.C", "esd_tracks_MI", "", kFALSE));
604 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC Track", "esd_tracks.C", "esd_tracks_by_category", "", kTRUE));
605
606 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC Tracklet", "esd_spd_tracklets.C", "esd_spd_tracklets", "", kFALSE));
607
608 exec->AddMacro(new AliEveMacro(AliEveMacro::kESD, "REC ZDC", "esd_zdc.C", "esd_zdc", "", kFALSE));
609#if 0
610 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "REC Clus", "clusters.C+", "clusters", "", kFALSE));
611 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "REC Clus ITS", "its_clusters.C+", "its_clusters"));
612 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "REC Clus TPC", "tpc_clusters.C+", "tpc_clusters"));
613 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "REC Clus TRD", "trd_clusters.C+", "trd_clusters"));
614 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "REC Clus TOF", "tof_clusters.C+", "tof_clusters"));
615
616 exec->AddMacro(new AliEveMacro(AliEveMacro::kRunLoader, "REC Clus TPC", "vplot_tpc.C+", "vplot_tpc", "", kFALSE));
617
618 exec->AddMacro(new AliEveMacro(AliEveMacro::kAOD, "ANA HF", "aod_HF.C", "aod_HF", "", kFALSE));
619 exec->AddMacro(new AliEveMacro(AliEveMacro::kAOD, "ANA Jets", "jetplane.C", "jetplane", "", kFALSE));
620
621 // -- QA Viewer
622 // --------------
1d8ae8b6 623# endif
9e78371d 624
c5e3aa8e 625
626 //==============================================================================
627 // -- Histograms
628 //==============================================================================
629
630 if(TRDMode) {
ea48ba6e 631 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
632 slot->StartEmbedding();
633
634 gTRDCanvas = new TCanvas("canvasTRD","canvasTRD", 600, 400);
635 gTRDCanvas->Divide(3,2);
09cdbe4c 636 slot->StopEmbedding("TRD QA");
cfa641b1 637
638 slot=TEveWindow::CreateWindowInTab(browser->GetTabRight());
639 slot->StartEmbedding();
640 gTRDCalibCanvas=new TCanvas("CalibCanvasTRD","CalibCanvasTRD",600,400);
641 gTRDCalibCanvas->Divide(2,2);
09cdbe4c 642 slot->StopEmbedding("TRD Calib");
cfa641b1 643
644 slot=TEveWindow::CreateWindowInTab(browser->GetTabRight());
645 slot->StartEmbedding();
646 gTRDEORCanvas=new TCanvas("CalibEORTRD","CalibCEORTRD",600,400);
647 gTRDEORCanvas->Divide(3,2);
09cdbe4c 648 slot->StopEmbedding("TRD QA");
ea48ba6e 649 }
650 else if(TPCMode){
c5e3aa8e 651 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
652 slot->StartEmbedding();
653
654 gTPCCanvas = new TCanvas("canvasTPC","canvasTPC", 600, 400);
655 gTPCCharge = new TH1F("ClusterCharge","ClusterCharge",100,0,500);
656 gTPCQMax = new TH1F("QMax","QMax",50,0,250);
657 gTPCQMaxOverCharge = new TH1F("QMaxOverCharge","QMaxOverCharge",50,0,1);
09cdbe4c 658 slot->StopEmbedding("TPC QA");
ea48ba6e 659 }
f1fefc07 660
cfa641b1 661 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
ff64d287 662 slot->StartEmbedding();
663 gPrimVertexCanvas = new TCanvas("canvasPrimVertex","canvasPrimVertex", 600, 400);
664 slot->StopEmbedding("Primary Vertex");
665
666 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
667 slot->StartEmbedding();
668 gSPDVertexCanvas = new TCanvas("canvasSPDVertex","canvasSPDVertex", 600, 400);
669 slot->StopEmbedding("SPD Vertex");
670
671 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
672 slot->StartEmbedding();
673 gV0Canvas = new TCanvas("canvasV0","canvasV0", 600, 400);
674 slot->StopEmbedding("V0");
cfa641b1 675
ff64d287 676 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
677 slot->StartEmbedding();
678 gITSCanvas = new TCanvas("canvasITS","canvasITS", 600, 400);
09cdbe4c 679 slot->StopEmbedding("ITS QA");
cfa641b1 680
ff64d287 681 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
682 slot->StartEmbedding();
683 gSSDCanvas0 = new TCanvas("canvasSSD0","canvasSSD0", 600, 400);
09cdbe4c 684 slot->StopEmbedding("SSD QA 0");
cfa641b1 685
ff64d287 686 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
687 slot->StartEmbedding();
688 gSSDCanvas1 = new TCanvas("canvasSSD1","canvasSSD1", 600, 400);
09cdbe4c 689 slot->StopEmbedding("SSD QA 1");
cfa641b1 690
922c1000 691 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
692 slot->StartEmbedding();
693 gPHOSCanvas = new TCanvas("canvasPHOS1","canvasPHOS1", 600, 400);
694 gPHOSCanvas->Divide(3, 2);
09cdbe4c 695 slot->StopEmbedding("PHOS QA");
696
697 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
698 slot->StartEmbedding();
699 gEMCALCanvas = new TCanvas("canvasEMCAL","canvasEMCAL", 600, 400);
700 gEMCALCanvas->Divide(3, 2);
701 slot->StopEmbedding("EMCAL QA");
702
922c1000 703
704 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
705 slot->StartEmbedding();
706 gTPCClustCanvas = new TCanvas("canvasTPCClust","canvasTPCClust", 600, 400);
707 gTPCClustCanvas->Divide(3, 2);
dcd3b5e8 708 slot->StopEmbedding("TPC Cluster QA Histograms ");
922c1000 709
710
9e78371d 711 //==============================================================================
ea48ba6e 712 // -- Additional GUI components
9e78371d 713 //==============================================================================
714
715 slot = TEveWindow::CreateWindowInTab(browser->GetTabRight());
5de5a293 716 TEveWindowTab *storeTab = slot->MakeTab();
1d8ae8b6 717 storeTab->SetElementNameTitle("WindowStore",
9e78371d 718 "Undocked windows whose previous container is not known\n"
719 "are placed here when the main-frame is closed.");
5de5a293 720 gEve->GetWindowManager()->SetDefaultContainer(storeTab);
9e78371d 721
cfa641b1 722
723
9e78371d 724 return 0;
725}
726
5de5a293 727// -----------------------------------------------------------------
728void nextEvent() {
729
cfa641b1 730 if ( gHomerManager->NextEvent() ) {
731 if (gEventLoopStarted) {
732 cout << "HomerManager failed getting next event, trying to reconnect" << endl;
733
734 gHomerManager->DisconnectHOMER();
735 gHomerManager->ConnectEVEtoHOMER();
736 nextEvent();
737
738 } else {
739 return;
740 }
741 }
742
5de5a293 743 processEvent();
744}
745
9e78371d 746// -----------------------------------------------------------------
ea9a0e13 747Int_t processEvent() {
9e78371d 748
09cdbe4c 749
750
751
752
753
9e78371d 754 Int_t iResult = 0;
755
756 gStyle->SetPalette(1, 0);
757 gEve->DisableRedraw();
758
09cdbe4c 759 //resetDisplay();
760
761
762
ea48ba6e 763 //==============================================================================
9e78371d 764 // -- Reset
ea48ba6e 765 //==============================================================================
ff64d287 766
ea48ba6e 767 if ( gTRDCanvas ) {
768 gTRDCanvas->Clear();
769 gTRDCanvas->Divide(3,2);
770 }
cfa641b1 771 if(gTRDCalibCanvas){
ff64d287 772 gTRDCalibCanvas->Clear();
773 gTRDCalibCanvas->Divide(2,2);
774 }
cfa641b1 775 if(gTRDEORCanvas){
ff64d287 776 gTRDEORCanvas->Clear();
777 gTRDEORCanvas->Divide(3,2);
778 }
779
780 if(gSSDCanvas0) {
781 gSSDCanvas0->Clear();
782 gSSDCanvas0->Divide(6,6);
783 }
784
785 if(gSSDCanvas1) {
786 gSSDCanvas1->Clear();
787 gSSDCanvas1->Divide(2,3);
788 }
789
790 if(gITSCanvas) {
791 gITSCanvas->Clear();
792 gITSCanvas->Divide(3,3);
793 }
794
795 if(gPrimVertexCanvas) {
796 gPrimVertexCanvas->Clear();
797 gPrimVertexCanvas->Divide(2,2);
798 }
799
800 if(gSPDVertexCanvas) {
801 gSPDVertexCanvas->Clear();
802 gSPDVertexCanvas->Divide(2,2);
803 }
cfa641b1 804
ff64d287 805 if(gV0Canvas) {
806 gV0Canvas->Clear();
807 gV0Canvas->Divide(2,2);
cfa641b1 808 }
ea48ba6e 809
922c1000 810 if(gPHOSCanvas) {
811 gPHOSCanvas->Clear();
812 gPHOSCanvas->Divide(3, 3);
813 }
814
09cdbe4c 815 if(gEMCALCanvas) {
816 gEMCALCanvas->Clear();
817 gEMCALCanvas->Divide(3, 3);
818 }
819
ea48ba6e 820 if ( gTPCTrack ) gTPCTrack->DestroyElements();
821
c5e3aa8e 822 if ( gSPDClusters ) gSPDClusters->Reset();
823 if ( gSSDClusters ) gSSDClusters->Reset();
bdff3917 824 if ( gSDDClusters ) gSDDClusters->Reset();
ea48ba6e 825 if ( gTPCClusters ) gTPCClusters->Reset();
49993c6f 826 if ( gTPCTestClusters ) gTPCTestClusters->Reset();
ea48ba6e 827 if ( gTRDClusters ) gTRDClusters->Reset();
c5e3aa8e 828 if ( gMUONClusters ) gMUONClusters->Reset();
cfa641b1 829 if ( gMUONTracks ){
830 gMUONTracks->Destroy();
831 gMUONTracks = 0x0;
832 }
1d8ae8b6 833
c5e3aa8e 834 if ( gPHOSBoxSet[1] )
835 for(int im = 0; im < 5; im++)
836 gPHOSBoxSet[im]->Reset();
837
cfa641b1 838 if ( gEMCALElementList)
839 for(int i = 0; i < 12; i++) {
840 gEMCALBoxSet[i]->Reset();
841 }
842
c5e3aa8e 843 if ( gTPCColClusters )
844 for (Int_t ii = 0; ii <= gTPCBins+1; ++ii)
845 gTPCColClusters->GetBin(ii)->Reset();
846
847 if ( gTRDColClusters )
848 for (Int_t ii = 0; ii <= gTRDBins+1; ++ii)
1d8ae8b6 849 gTRDColClusters->GetBin(ii)->Reset();
1d8ae8b6 850
ea48ba6e 851 gTRDHistoCount = 0;
ff64d287 852 gSPDVertexHistoCount = 0;
853 gSSDHistoCount0 = 0;
854 gSSDHistoCount1 = 0;
855 gITSHistoCount = 0;
922c1000 856 gPHOSHistoCount = 0;
09cdbe4c 857 gEMCALHistoCount = 0;
cfa641b1 858
ea48ba6e 859 //==============================================================================
860 // -- Process Blocks
861 //==============================================================================
1d8ae8b6 862
dcd3b5e8 863 AliHLTHOMERBlockDesc* block = 0;
864
1d8ae8b6 865 if ( gHomerManager->GetBlockList() == NULL) {
922c1000 866 printf ("onlineDisplay: No regular BlockList ... \n");
09cdbe4c 867 cout << endl;
868 //return -1;
869
922c1000 870 } else {
dcd3b5e8 871
872 if (gHomerManager->GetBlockList()->IsEmpty() ) {
09cdbe4c 873 printf ("onlineDisplay: No Sync Blocks in list ... \n");
dcd3b5e8 874 cout<<endl;
09cdbe4c 875 return -2;
dcd3b5e8 876 }
877
09cdbe4c 878
922c1000 879 TIter next(gHomerManager->GetBlockList());
09cdbe4c 880
881
922c1000 882 // -- Iterate over blocks in the block list
883 // ------------------------------------------
884 while ((block = (AliHLTHOMERBlockDesc*)next())) {
09cdbe4c 885 iResult = processBlock(block);
886 }
887 }
cfa641b1 888
09cdbe4c 889 //============================================================================
890 // Read out histograms and detectors outside physics 1 partition
891 //===========================================================================
922c1000 892
cfa641b1 893 TIter anext(gHomerManager->GetAsyncBlockList());
49993c6f 894
cfa641b1 895 while ( (block = (AliHLTHOMERBlockDesc*)anext()) ) {
922c1000 896
09cdbe4c 897 iResult = processAsyncBlock(block);
ff64d287 898
09cdbe4c 899 }
cfa641b1 900
09cdbe4c 901 iResult = updateDisplay();
cfa641b1 902
09cdbe4c 903 return iResult;
904}
cfa641b1 905
906
09cdbe4c 907Int_t updateDisplay() {
908 Int_t iResult = 0;
cfa641b1 909
09cdbe4c 910
c5e3aa8e 911 //==============================================================================
912 // -- Update Objects
913 //==============================================================================
09cdbe4c 914
c5e3aa8e 915 // -- TPC Histograms
916 if ( gTPCCanvas && gTPCCharge && gTPCQMax) {
cfa641b1 917
c5e3aa8e 918 gTPCCanvas->Clear();
919 gTPCCanvas->Divide(1,3);
920
921 gTPCCanvas->cd(1);
922 gTPCCharge->Draw();
923
924 gTPCCanvas->cd(2);
925 gTPCQMax->Draw();
926
927 gTPCCanvas->cd(3);
928 gTPCQMaxOverCharge->Draw();
929
930 gTPCCanvas->Update();
931 }
f1fefc07 932
9e78371d 933 if ( gTPCClusters ) gTPCClusters->ResetBBox();
49993c6f 934 if ( gTPCTestClusters ) gTPCTestClusters->ResetBBox();
1d8ae8b6 935 if ( gTRDClusters ) gTRDClusters->ResetBBox();
9e78371d 936 if ( gSPDClusters ) gSPDClusters->ResetBBox();
c5e3aa8e 937 if ( gSDDClusters ) gSDDClusters->ResetBBox();
938 if ( gSSDClusters ) gSSDClusters->ResetBBox();
939 if ( gMUONClusters ) gMUONClusters->ResetBBox();
940
941 if ( gPHOSBoxSet[1] )
942 for(int im = 0; im < 5; im++)
943 gPHOSBoxSet[im]->ResetBBox();
ea9a0e13 944
cfa641b1 945 if ( gEMCALElementList )
946 for(int sm = 0; sm < 12; sm++)
947 gEMCALBoxSet[sm]->ResetBBox();
948
c5e3aa8e 949 //==============================================================================
ea9a0e13 950 // -- Set EventID in Window Title
c5e3aa8e 951 // -- Update Objects
952 //==============================================================================
953
ea9a0e13 954 TString winTitle("Eve Main Window -- Event ID : ");
955 winTitle += Form("0x%016X ", gHomerManager->GetEventID() );
956 gEve->GetBrowser()->SetWindowName(winTitle);
9e78371d 957
c5e3aa8e 958 //==============================================================================
9e78371d 959 // -- Set Projections
c5e3aa8e 960 //==============================================================================
9e78371d 961
962 // XXX Primary vertex ... to be retrieved from the ESD
ea48ba6e 963 Double_t x[3] = { 0, 0, 0 };
964
f1fefc07 965 TEveElement* top = gEve->GetCurrentEvent();
ea48ba6e 966
ea9a0e13 967 if (gRPhiMgr && top) {
f1fefc07 968 gRPhiEventScene->DestroyElements();
969 if (gCenterProjectionsAtPrimaryVertex)
970 gRPhiMgr->SetCenter(x[0], x[1], x[2]);
971 gRPhiMgr->ImportElements(top, gRPhiEventScene);
9e78371d 972 }
ea9a0e13 973
974 if (gRhoZMgr && top) {
f1fefc07 975 gRhoZEventScene->DestroyElements();
976 if (gCenterProjectionsAtPrimaryVertex)
977 gRhoZMgr->SetCenter(x[0], x[1], x[2]);
978 gRhoZMgr->ImportElements(top, gRhoZEventScene);
9e78371d 979 }
9e78371d 980
c5e3aa8e 981 //==============================================================================
ea9a0e13 982
983 gEve->Redraw3D(0,1); // (0, 1)
9e78371d 984 gEve->EnableRedraw();
f1fefc07 985
9e78371d 986 return iResult;
09cdbe4c 987
9e78371d 988}
989
09cdbe4c 990
f1fefc07 991// -----------------------------------------------------------------
c5e3aa8e 992Int_t processITSHist(AliHLTHOMERBlockDesc* /*block*/) {
f1fefc07 993 return 0;
994}
1d8ae8b6 995
9e78371d 996// -----------------------------------------------------------------
1d8ae8b6 997Int_t processHLTRDLST(AliHLTHOMERBlockDesc* /*block*/) {
9e78371d 998 return 0;
999}
1000
1001// -----------------------------------------------------------------
1d8ae8b6 1002Int_t processROOTTOBJ(AliHLTHOMERBlockDesc* block, TEveText* /*et*/) {
9e78371d 1003
1004 // -- AliHLTGlobalTriggerDecision
1005 if ( ! block->GetClassName().CompareTo("AliHLTGlobalTriggerDecision") ) {
1006
1d8ae8b6 1007 AliHLTGlobalTriggerDecision *trig = dynamic_cast<AliHLTGlobalTriggerDecision*>( block->GetTObject());
5de5a293 1008 trig->Print();
f1fefc07 1009
ea9a0e13 1010 // et->SetText("balle");;
9e78371d 1011
ea9a0e13 1012 // TEveText* tt = new TEveText("Trigger: Class is known ;-) ");
1013 // gEve->AddElement(tt);
9e78371d 1014
1015 }
1016 else {
1017 printf(" Unknown root object %s",block->GetClassName().Data() );
1018 }
1019
1020 return 0;
1021}
1022
1023// -----------------------------------------------------------------
1024Int_t processEsdTracks( AliHLTHOMERBlockDesc* block, TEveTrackList* cont ) {
1025
1026 AliESDEvent* esd = (AliESDEvent *) (block->GetTObject());
1027 esd->GetStdContent();
1028
ff64d287 1029 esd_track_propagator_setup(cont->GetPropagator(),-0.1*esd->GetMagneticField(), 520);
9e78371d 1030
cfa641b1 1031 // printf( "Number of ESD Tracks : %d \n", esd->GetNumberOfTracks());
9e78371d 1032
1033 for (Int_t iter = 0; iter < esd->GetNumberOfTracks(); ++iter) {
cfa641b1 1034 //AliEveTrack* track = dynamic_cast<AliEveTrack*>(esd_make_track(esd->GetTrack(iter), cont));
1035 AliEveTrack* track = dynamic_cast<AliEveTrack*>(hlt_esd_make_track(esd->GetTrack(iter), cont));
9e78371d 1036 cont->AddElement(track);
922c1000 1037
1038 gTPCPt->Fill(esd->GetTrack(iter)->GetSignedPt()); // KK
1039 gTPCEta->Fill(esd->GetTrack(iter)->GetSnp());
1040 gTPCPsi->Fill(esd->GetTrack(iter)->GetTgl());
1041 gTPCnClusters->Fill(esd->GetTrack(iter)->GetTPCNcls());
9e78371d 1042 }
1043
922c1000 1044 gTPCMult->Fill(esd->GetNumberOfTracks()); // KK
1045
1046 Int_t icd = 0;
dcd3b5e8 1047 gTPCClustCanvas->Clear();
1048 gTPCClustCanvas->Divide(2, 2);
922c1000 1049 gTPCClustCanvas->cd(icd++);
1050 gTPCPt->Draw();
1051 gTPCClustCanvas->cd(icd++);
1052 gTPCEta->Draw();
1053 gTPCClustCanvas->cd(icd++);
1054 gTPCPsi->Draw();
1055 gTPCClustCanvas->cd(icd++);
1056 gTPCnClusters->Draw();
1057 gTPCClustCanvas->cd(icd++);
1058 gTPCMult->Draw();
dcd3b5e8 1059 gTPCClustCanvas->Update();
1060
1061
9e78371d 1062 cont->SetTitle(Form("N=%d", esd->GetNumberOfTracks()) );
1063 cont->MakeTracks();
1064
1065 return 0;
1066}
1067
922c1000 1068// // -----------------------------------------------------------------
1069// Int_t processPHOSClusters(AliHLTHOMERBlockDesc* block) {
1070
c5e3aa8e 1071
922c1000 1072// cout <<"Processgin phos clusters"<<endl;
ff64d287 1073
922c1000 1074// AliHLTCaloChannelDataHeaderStruct *chh = reinterpret_cast<AliHLTCaloChannelDataHeaderStruct*> (block->GetData());
cfa641b1 1075
922c1000 1076// AliHLTCaloChannelDataStruct *chd = reinterpret_cast<AliHLTCaloChannelDataStruct*>(chh+1);
cfa641b1 1077
922c1000 1078// for(Int_t i = 0; i < chh->fNChannels; i++, chd++) {
cfa641b1 1079
922c1000 1080// Int_t gain = (chd->fChannelID >> 12)&0x1;
1081// Int_t module = (chd->fChannelID >> 13)&0x1f;
1082// module = 4 -module;
c5e3aa8e 1083
c5e3aa8e 1084
922c1000 1085// if(gain == 1)
cfa641b1 1086
922c1000 1087// {
1088// Float_t x = (static_cast<Float_t>(chd->fChannelID&0x3f) - 32)* 2.2;
1089// Float_t z = (static_cast<Float_t>((chd->fChannelID >> 6)&0x3f) - 28) * 2.2;
1090// // gPHOSBoxSet[ds->fModule]->AddBox(ds->fLocX, 0, ds->fLocZ, 2.2, ds->fEnergy*20, 2.2);
1091// gPHOSBoxSet[module]->AddBox(x, 0, z, 2.2, chd->fEnergy/1, 2.2);
1092// gPHOSBoxSet[module]->DigitValue(static_cast<Int_t>(chd->fEnergy));
1093// }
c5e3aa8e 1094
cfa641b1 1095
1096
922c1000 1097// }
1098// cout <<"done with phos"<<endl;
1099
1100
1101// return 0;
1102// }
1103
1104
1105
1106// // -----------------------------------------------------------------
1107Int_t processPHOSDigits(AliHLTHOMERBlockDesc* block) {
1108
1109 AliHLTCaloDigitDataStruct *ds = reinterpret_cast<AliHLTCaloDigitDataStruct*> (block->GetData());
1110 UInt_t nDigits = block->GetSize()/sizeof(AliHLTCaloDigitDataStruct);
1111
1112
1113 for(UInt_t i = 0; i < nDigits; i++, ds++) {
1114
1115 Float_t x = (ds->fX - 32)* 2.2;
1116 Float_t z = (ds->fZ - 28) * 2.2;
1117
1118 cout << "MODULE DIGITTYP :" << ds->fModule;
1119
1120 gPHOSBoxSet[4-ds->fModule]->AddBox(x, 0, z, 2.2, ds->fEnergy*20, 2.2);
1121 gPHOSBoxSet[4-ds->fModule]->DigitValue(static_cast<Int_t>(ds->fEnergy*10));
cfa641b1 1122 }
1123
1124 return 0;
1125}
1126
922c1000 1127
cfa641b1 1128// // -----------------------------------------------------------------
922c1000 1129Int_t processPHOSClusters(AliHLTHOMERBlockDesc* block) {
cfa641b1 1130
922c1000 1131 AliHLTCaloClusterHeaderStruct *dh = reinterpret_cast<AliHLTCaloClusterHeaderStruct*> (block->GetData());
1132 AliHLTCaloClusterReader * clusterReader = new AliHLTCaloClusterReader();
1133 clusterReader->SetMemory(dh);
cfa641b1 1134
922c1000 1135 AliHLTCaloClusterDataStruct * ds;
1136
1137 Int_t nc = 0;
1138
1139
1140 while(ds = clusterReader->NextCluster()){
1141 nc++;
1142 cout << "Cluster nr " << nc << " Energy " << ds->fEnergy<< " " << ds->fGlobalPos[0] << " " << ds->fGlobalPos[1] << " " << ds->fGlobalPos[2] << endl;
1143
1144
1145 gPHOSBoxSet[2]->AddBox(ds->fGlobalPos[0], 0, ds->fGlobalPos[2], 2.2, -ds->fEnergy*20, 2.2);
1146 gPHOSBoxSet[2]->DigitValue(static_cast<Int_t>(ds->fEnergy*10));
1147 }
1148
1149 return 0;
1150}
cfa641b1 1151
c5e3aa8e 1152
c5e3aa8e 1153
c5e3aa8e 1154// -----------------------------------------------------------------
cfa641b1 1155Int_t processEMCALClusters(AliHLTHOMERBlockDesc* block) {
c5e3aa8e 1156
cfa641b1 1157 AliHLTCaloChannelDataHeaderStruct *dhs = reinterpret_cast<AliHLTCaloChannelDataHeaderStruct*> (block->GetData());
1158 Short_t nC = dhs->fNChannels;
1159 AliHLTUInt8_t *ui = reinterpret_cast<AliHLTUInt8_t*>(dhs) + sizeof(AliHLTCaloChannelDataHeaderStruct);
1160 AliHLTCaloChannelDataStruct *ds = reinterpret_cast<AliHLTCaloChannelDataStruct*>(ui);
1161
1162 UShort_t fX =0;
1163 UShort_t fZ =0;
1164 UShort_t fGain =0;
1165 UShort_t fModuleId =0;
1166
c5e3aa8e 1167
c5e3aa8e 1168
cfa641b1 1169 for(Short_t s = 0; s < nC; s++ ) {
ff64d287 1170
cfa641b1 1171 fX = ds->fChannelID&0x3f;
1172 fZ = (ds->fChannelID >> 6)&0x3f;
1173 fGain = (ds->fChannelID >> 12)&0x1;
1174 fModuleId = (ds->fChannelID >> 13)&0x1f;
1175
1176 // cout << fX << " " << fZ << " " << fGain << " " << fModuleId <<endl;
1177
ff64d287 1178 if ( ( fModuleId >= 0 && fModuleId < 12 ) ) {
cfa641b1 1179 gEMCALBoxSet[fModuleId]->AddBox(10, fX*6-12*6, fZ*6-24*6, ds->fEnergy/4, 6, 6);
1180 gEMCALBoxSet[fModuleId]->DigitValue(static_cast<Int_t>(ds->fEnergy));
1181 }
1182 ds++;
cfa641b1 1183
ff64d287 1184 }
1185
c5e3aa8e 1186 return 0;
1187}
1188
ea9a0e13 1189// -----------------------------------------------------------------
c5e3aa8e 1190Int_t processITSClusters(AliHLTHOMERBlockDesc* block, TEvePointSet* cont) {
1191
1192 AliHLTITSClusterData *cd = reinterpret_cast<AliHLTITSClusterData*> (block->GetData());
1193 UChar_t *data = reinterpret_cast<UChar_t*> (cd->fSpacePoints);
1194
1195 if ( cd->fSpacePointCnt != 0 ) {
1196 for (Int_t iter = 0; iter < cd->fSpacePointCnt; ++iter, data += sizeof(AliHLTITSSpacePointData)) {
1197 AliHLTITSSpacePointData *sp = reinterpret_cast<AliHLTITSSpacePointData*> (data);
f1fefc07 1198
c5e3aa8e 1199 Int_t lab[4] = {0,0,0,0};
1200 Float_t hit[6] = {0,0,0,0,0,0};
1201 Int_t info[3] = {0,0,0};
1202
1203 lab[0] = sp->fTracks[0];
1204 lab[1] = sp->fTracks[1];
1205 lab[2] = sp->fTracks[2];
1206 lab[3] = sp->fIndex;
1207 hit[0] = sp->fY;
1208 hit[1] = sp->fZ;
1209 hit[2] = sp->fSigmaY2;
1210 hit[3] = sp->fSigmaZ2;
1211 hit[4] = sp->fQ;
1212 hit[5] = sp->fSigmaYZ;
1213 info[0] = sp->fNy;
1214 info[1] = sp->fNz;
1215 info[2] = sp->fLayer;
1216
1217 Float_t xyz[3];
1218 AliITSRecPoint recpoint(lab,hit,info);
1219 recpoint.GetGlobalXYZ(xyz);
1220
1221 cont->SetNextPoint(xyz[0], xyz[1], xyz[2]);
1222 }
1223 }
1224 return 0;
1225}
1226
1227// -----------------------------------------------------------------
1228Int_t processTPCClusters(AliHLTHOMERBlockDesc* block, TEvePointSet* cont, TEvePointSetArray *contCol ) {
1229
f1fefc07 1230 Int_t slice = block->GetSubDetector();
9e78371d 1231 Float_t phi = ( slice + 0.5 ) * TMath::Pi() / 9.0;
1232 Float_t cos = TMath::Cos( phi );
1233 Float_t sin = TMath::Sin( phi );
ea9a0e13 1234
1235 AliHLTTPCClusterData *cd = reinterpret_cast<AliHLTTPCClusterData*> (block->GetData());
1236 UChar_t *data = reinterpret_cast<UChar_t*> (cd->fSpacePoints);
9e78371d 1237
ea9a0e13 1238 if ( cd->fSpacePointCnt != 0 ) {
1239 for (Int_t iter = 0; iter < cd->fSpacePointCnt; ++iter, data += sizeof(AliHLTTPCSpacePointData)) {
1240 AliHLTTPCSpacePointData *sp = reinterpret_cast<AliHLTTPCSpacePointData*> (data);
9e78371d 1241 cont->SetNextPoint(cos*sp->fX - sin*sp->fY, sin*sp->fX + cos*sp->fY, sp->fZ);
49993c6f 1242 if (contCol)
1243 contCol->Fill(cos*sp->fX - sin*sp->fY, sin*sp->fX + cos*sp->fY, sp->fZ, sp->fCharge);
c5e3aa8e 1244
1245 gTPCCharge->Fill(sp->fCharge);
1246 gTPCQMax->Fill(sp->fQMax);
1247 gTPCQMaxOverCharge->Fill(((Float_t)sp->fQMax)/((Float_t)sp->fCharge));
9e78371d 1248 }
1249 }
1250
ea9a0e13 1251 return 0;
9e78371d 1252}
1d8ae8b6 1253
ea48ba6e 1254// -----------------------------------------------------------------
1d8ae8b6 1255Int_t processMUONClusters(AliHLTHOMERBlockDesc* block) {
ea48ba6e 1256
1d8ae8b6 1257 Int_t iResult = 0;
1258
1259 unsigned long size = block->GetSize();
ea48ba6e 1260 Int_t * buffer ;
1d8ae8b6 1261
ea48ba6e 1262 buffer = (Int_t *)block->GetData();
1d8ae8b6 1263// cout<<"block size : "<<size<<", buffer : "<<buffer<<", DataType : "<<block->GetDataType()<<endl;
1264
1265// // for(int idata=0;idata<int(size);idata++)
1266// // printf("\tbuffer[%d] : %d\n",idata,buffer[idata]);
1267
1268
1269
1270 if(block->GetDataType().CompareTo("RECHITS") == 0){
1271
1272 AliHLTMUONRecHitsBlockReader trackblock((char*)buffer, size);
1273 const AliHLTMUONRecHitStruct* hit = trackblock.GetArray();
1274
1275 for(AliHLTUInt32_t ientry = 0; ientry < trackblock.Nentries(); ientry++){
1276// cout << setw(13) << left << hit->fX << setw(0);
1277// cout << setw(13) << left << hit->fY << setw(0);
1278// cout << hit->fZ << setw(0) << endl;
1279 if(hit->fX!=0.0 && hit->fY!=0.0 && hit->fZ!=0.0)
1280 gMUONClusters->SetNextPoint(hit->fX,hit->fY,hit->fZ);
1281 hit++;
1282
1283 }// track hit loop
1284 }
1285
1286 else{// if rechits
1287 // if(!strcmp((BlockType(ULong64_t(reader->GetBlockDataType(i)))).Data(),"TRIGRECS")){
1288
1289 AliHLTMUONTriggerRecordsBlockReader trigblock(buffer, size);
1290 const AliHLTMUONTriggerRecordStruct* trigrec = trigblock.GetArray();
1291 for(AliHLTUInt32_t ientry = 0; ientry < trigblock.Nentries(); ientry++){
1292
1293 const AliHLTMUONRecHitStruct* hit = &trigrec->fHit[0];
1294 for(AliHLTUInt32_t ch = 0; ch < 4; ch++)
1295 {
cfa641b1 1296// cout << setw(10) << left << ch + 11 << setw(0);
1297// cout << setw(13) << left << hit->fX << setw(0);
1298// cout << setw(13) << left << hit->fY << setw(0);
1299// cout << hit->fZ << setw(0) << endl;
1d8ae8b6 1300 if(hit->fX!=0.0 && hit->fY!=0.0 && hit->fZ!=0.0)
1301 gMUONClusters->SetNextPoint(hit->fX,hit->fY,hit->fZ);
1302 hit++;
1303 }// trig chamber loop
1304 trigrec++;
1305 }//trig hit loop
1306 }//else trigger
1307
1308 return iResult;
1309}
1310
cfa641b1 1311// -----------------------------------------------------------------
1312Int_t processMUONTracks(AliHLTHOMERBlockDesc* block) {
1313
1314 Int_t iResult = 0;
1315
1316 unsigned long size = block->GetSize();
1317 Int_t * buffer = (Int_t *)block->GetData();
1318 AliHLTMUONRecHitStruct hit1,hit2;
1319 hit1.fX = hit1.fY = hit1.fZ = hit2.fX = hit2.fY = hit2.fZ = 0;
1320 Int_t ch1=0, ch2=0;
1321 Float_t x0=0.0,y0=0.0,z0=0.0;
1322 Float_t x3=0.0,y3=0.0,z3=0.0;
1323 if(block->GetDataType().CompareTo("MANTRACK") == 0){
1324 AliHLTMUONMansoTracksBlockReader mantrackblock(buffer, size);
1325 const AliHLTMUONMansoTrackStruct* mtrack = mantrackblock.GetArray();
1326 for(AliHLTUInt32_t ientry = 0; ientry < mantrackblock.Nentries(); ientry++){
1327 const AliHLTMUONRecHitStruct* hit = &mtrack->fHit[0];
1328 for(AliHLTUInt32_t ch = 0; ch < 4; ch++){
1329 // cout << setw(10) << left << ch + 7 << setw(0);
1330 // cout << setw(13) << left << hit->fX << setw(0);
1331 // cout << setw(13) << left << hit->fY << setw(0);
1332 // cout << hit->fZ << setw(0) << endl;
1333 if(hit->fZ != 0.0){
1334 if(ch==0 || ch==1){
1335 hit1 = *hit; ch1 = ch+6;
1336 }else{
1337 hit2 = *hit; ch2 = ch+6;
1338 }
1339 }
1340 hit++;
1341 }// trig chamber loop
1342 // printf("ch : %d, (X,Y,Z) : (%f,%f,%f)\n",ch1,hit1.fX,hit1.fY,hit1.fZ);
1343 // printf("ch : %d, (X,Y,Z) : (%f,%f,%f)\n",ch2,hit2.fX,hit2.fY,hit2.fZ);
1344 // meminfo();
1345 z3 = AliMUONConstants::DefaultChamberZ(ch2+4);
1346 y3 = hit1.fY - (hit1.fZ-z3)*(hit1.fY - hit2.fY)/(hit1.fZ - hit2.fZ) ;
1347 x3 = hit1.fX - (hit1.fZ-z3)*(hit1.fX - hit2.fX)/(hit1.fZ - hit2.fZ) ;
1348
1349 z0 = AliMUONConstants::DefaultChamberZ(ch1);
1350 y0 = hit1.fY - (hit1.fZ-z0)*(hit1.fY - hit2.fY)/(hit1.fZ - hit2.fZ) ;
1351 x0 = hit1.fX - (hit1.fZ-z0)*(hit1.fX - hit2.fX)/(hit1.fZ - hit2.fZ) ;
1352
1353
1354 gMUONTracks->AddLine(x0,y0,z0,x3,y3,z3);
1355 mtrack++;
1356 }
1357 cout<<"NofManso Tracks : "<<mantrackblock.Nentries()<<endl;
1358 }
1359
1360 return iResult;
1361
1362}
1363
9e78371d 1364
1d8ae8b6 1365// -----------------------------------------------------------------
1366Int_t processTRDClusters(AliHLTHOMERBlockDesc* block, TEvePointSet *cont, TEvePointSetArray *contCol) {
1367
1368 Int_t iResult = 0;
1369
ea48ba6e 1370 Int_t sm = block->GetSubDetector();
1d8ae8b6 1371 if ( sm == 6 ) sm = 7;
ea48ba6e 1372
1d8ae8b6 1373 Float_t phi = ( sm + 0.5 ) * TMath::Pi() / 9.0;
1374 Float_t cos = TMath::Cos( phi );
1375 Float_t sin = TMath::Sin( phi );
1376
ea48ba6e 1377 Byte_t* ptrData = reinterpret_cast<Byte_t*>(block->GetData());
1d8ae8b6 1378 UInt_t ptrSize = block->GetSize();
1379
1380 for (UInt_t size = 0; size+sizeof(AliHLTTRDCluster) <= ptrSize; size+=sizeof(AliHLTTRDCluster) ) {
1381 AliHLTTRDCluster *cluster = reinterpret_cast<AliHLTTRDCluster*>(&(ptrData[size]));
1382
1383 AliTRDcluster *trdCluster = new AliTRDcluster;
1384 cluster->ExportTRDCluster( trdCluster );
1385
1386 contCol->Fill(cos*trdCluster->GetX() - sin*trdCluster->GetY(),
1387 sin*trdCluster->GetX() + cos*trdCluster->GetY(),
1388 trdCluster->GetZ(),
1389 trdCluster->GetQ() );
1390
1391 cont->SetNextPoint(cos*trdCluster->GetX() - sin*trdCluster->GetY(),
ea48ba6e 1392 sin*trdCluster->GetX() + cos*trdCluster->GetY(), trdCluster->GetZ());
1d8ae8b6 1393 }
1394
1395 return iResult;
1396}
1397
1398// -----------------------------------------------------------------
1399Int_t processTRDHistograms(AliHLTHOMERBlockDesc* block, TCanvas * canvas) {
1400
1401 Int_t iResult = 0;
1402
1403 if ( ! block->GetClassName().CompareTo("TH1D")) {
1404 TH1D* histo = reinterpret_cast<TH1D*>(block->GetTObject());
ea48ba6e 1405 ++gTRDHistoCount;
1d8ae8b6 1406
ea48ba6e 1407 TVirtualPad* pad = canvas->cd(gTRDHistoCount);
1d8ae8b6 1408 histo->Draw();
1409 pad->SetGridy();
1410 pad->SetGridx();
1411
1412 if ( ! strcmp(histo->GetName(), "nscls") ) {
1413 gTRDEvents = static_cast<Int_t>(histo->GetEntries());
1414 histo->GetXaxis()->SetRangeUser(0.,15.);
1415 }
1416
1417 if ( ! strcmp(histo->GetName(),"sclsdist") ||
1418 ! strcmp(histo->GetName(),"qClsCand") )
1419 pad->SetLogy();
1420 }
1421 else if ( ! block->GetClassName().CompareTo("TH2F")) {
1422 TH2F *hista = reinterpret_cast<TH2F*>(block->GetTObject());
ea48ba6e 1423 ++gTRDHistoCount;
1d8ae8b6 1424
ea48ba6e 1425 TVirtualPad* pad = canvas->cd(gTRDHistoCount);
1d8ae8b6 1426
1427 if (gTRDEvents > 0)
1428 hista->Scale(1./gTRDEvents);
1429
1430 hista->Draw("COLZ");
1431 pad->SetLogz();
1432 pad->SetGridy();
1433 pad->SetGridx();
1434 }
1435
1436 return iResult;
1437}
1438
ff64d287 1439// -----------------------------------------------------------------
1440Int_t processPrimVertexHistograms(AliHLTHOMERBlockDesc* block, TCanvas * canvas) {
1441
1442 Int_t iResult = 0;
1443
1444 if ( ! block->GetClassName().CompareTo("TH1F")) {
1445 TH1F* histo = reinterpret_cast<TH1F*>(block->GetTObject());
1446 if( histo ){
1447 TString name(histo->GetName());
1448 if( !name.CompareTo("primVertexZ") ){
1449 canvas->cd(2);
1450 histo->Draw();
1451 }else if( !name.CompareTo("primVertexX") ){
1452 canvas->cd(3);
1453 histo->Draw();
1454 }else if( !name.CompareTo("primVertexY") ){
1455 canvas->cd(4);
1456 histo->Draw();
1457 }
1458 }
1459 } else if ( ! block->GetClassName().CompareTo("TH2F")) {
1460 TH2F *hista = reinterpret_cast<TH2F*>(block->GetTObject());
1461 if (hista ){
1462 TString name(hista->GetName());
1463 if( !name.CompareTo("primVertexXY")) {
1464 canvas->cd(1);
1465 hista->Draw();
1466 }
1467 }
1468 }
1469 canvas->cd();
1470
1471 return iResult;
1472}
cfa641b1 1473
1474// -----------------------------------------------------------------
ff64d287 1475Int_t processSPDVertexHistograms(AliHLTHOMERBlockDesc* block, TCanvas * canvas) {
cfa641b1 1476
1477 Int_t iResult = 0;
cfa641b1 1478
1479 if ( ! block->GetClassName().CompareTo("TH1F")) {
cfa641b1 1480 TH1F* histo = reinterpret_cast<TH1F*>(block->GetTObject());
ff64d287 1481 ++gSPDVertexHistoCount;
cfa641b1 1482
ff64d287 1483 canvas->cd(gSPDVertexHistoCount);
cfa641b1 1484 histo->Draw();
cfa641b1 1485
ff64d287 1486 }
1487 else if ( ! block->GetClassName().CompareTo("TH2F")) {
cfa641b1 1488 TH2F *hista = reinterpret_cast<TH2F*>(block->GetTObject());
1489 if (hista) {
ff64d287 1490 ++gSPDVertexHistoCount;
cfa641b1 1491
ff64d287 1492 canvas->cd(gSPDVertexHistoCount);
cfa641b1 1493 hista->Draw();
1494 }
1495 }
1496 canvas->cd();
1497
cfa641b1 1498 return iResult;
ff64d287 1499}
cfa641b1 1500
ff64d287 1501// -----------------------------------------------------------------
1502Int_t processV0Histograms(AliHLTHOMERBlockDesc* block, TCanvas * canvas) {
cfa641b1 1503
ff64d287 1504 Int_t iResult = 0;
1505 bool update = 0;
1506 if ( ! block->GetClassName().CompareTo("TH1F")) {
1507 TH1F* histo = reinterpret_cast<TH1F*>(block->GetTObject());
1508 if( histo ){
1509 TString name(histo->GetName());
1510 if( !name.CompareTo("hKShort") ){
1511 canvas->cd(1);
1512 histo->Draw();
1513 update = 1;
1514 }else if( !name.CompareTo("hLambda") ){
1515 canvas->cd(3);
1516 histo->Draw();
1517 update = 1;
1518 }
1519 }
1520 } else if ( ! block->GetClassName().CompareTo("TH2F")) {
1521 TH2F *hista = reinterpret_cast<TH2F*>(block->GetTObject());
1522 if (hista ){
1523 TString name(hista->GetName());
1524 if( !name.CompareTo("hAP")) {
1525 canvas->cd(2);
1526 hista->Draw();
1527 update = 1;
1528 }
1529 else if( !name.CompareTo("hGammaXY")) {
1530 canvas->cd(4);
1531 hista->Draw();
1532 update = 1;
1533 }
1534 }
1535 }
1536 if( update ){
1537 canvas->cd();
1538 canvas->Update();
1539 }
1540 return iResult;
cfa641b1 1541}
1542
ff64d287 1543
1544// -----------------------------------------------------------------
1545Int_t processITSHistograms(AliHLTHOMERBlockDesc* block, TCanvas * canvas) {
1546
1547 Int_t iResult = 0;
1548
1549 if ( ! block->GetClassName().CompareTo("TH1F")) {
1550 TH1F* histo = reinterpret_cast<TH1F*>(block->GetTObject());
1551 ++gITSHistoCount;
1552
1553 canvas->cd(gITSHistoCount);
1554 histo->Draw();
1555
1556 }
1557 else if ( ! block->GetClassName().CompareTo("TH2F")) {
1558 TH2F *hista = reinterpret_cast<TH2F*>(block->GetTObject());
1559 if (hista) {
1560 ++gITSHistoCount;
1561
1562 canvas->cd(gITSHistoCount);
1563 hista->Draw("COLZ");
1564 }
1565 }
1566 canvas->cd();
1567
1568 return iResult;
1569}
09cdbe4c 1570
1571
1572Int_t addHistogramsToCanvas(AliHLTHOMERBlockDesc * block, TCanvas * canvas, Int_t &cdCount ) {
922c1000 1573
1574 Int_t iResult = 0;
1575
09cdbe4c 1576 printf(Form("Adding histogram(s) to canvas %s \n", canvas->GetTitle()));
922c1000 1577
1578 if ( ! block->GetClassName().CompareTo("TObjArray")) {
1579 TIter next((TObjArray*)(block->GetTObject()));
1580 TObject *object;
1581 while (( object = (TObject*) next())) {
922c1000 1582 TH1* histo = dynamic_cast<TH1*>(object);
09cdbe4c 1583 cout <<" cd"<< cdCount << endl;
1584 canvas->cd(++cdCount);
922c1000 1585 cout <<"draw"<<endl;
1586 histo->Draw();
1587 cout <<"drew"<<endl;
1588 }
1589 }
09cdbe4c 1590
1591 // canvas->cd();
1592 canvas->Update();
1593
922c1000 1594 return iResult;
1595}
ff64d287 1596
1597// -----------------------------------------------------------------
1598Int_t processSSDHistograms(AliHLTHOMERBlockDesc* block, TCanvas *canvas0, TCanvas *canvas1) {
1599
1600 Int_t iResult = 0;
1601
1602 if ( ! block->GetClassName().CompareTo("TH1F")) {
1603 TH1F* histo = reinterpret_cast<TH1F*>(block->GetTObject());
1604 ++gSSDHistoCount0;
1605
1606 canvas0->cd(gSSDHistoCount0);
1607 histo->Draw();
1608 }
1609 else if ( ! block->GetClassName().CompareTo("TH2F")) {
1610 TH2F *hista = reinterpret_cast<TH2F*>(block->GetTObject());
1611 if (hista) {
1612 ++gSSDHistoCount1;
1613
1614 canvas1->cd(gSSDHistoCount1);
1615 hista->Draw("COLZ");
1616 }
1617 } else if ( ! block->GetClassName().CompareTo("TObjArray")) {
1618 TIter next((TObjArray*)(block->GetTObject()));
1619 TObject *object;
1620 while (( object = (TObject*) next())) {
1621 TString string;
1622 string = "TH1F";
1623 TString string2;
1624 string2 = "TH2F";
1625
1626 if ( !(string.CompareTo(object->ClassName())) ) {
1627 TH1F* histo = reinterpret_cast<TH1F*>(object);
1628 ++gSSDHistoCount0;
1629
1630 canvas0->cd(gSSDHistoCount0);
1631 histo->Draw();
1632
1633 }
1634 else if ( !(string2.CompareTo(object->ClassName()) ) ) {
1635 TH2F* histo = reinterpret_cast<TH2F*>(object);
1636 ++gSSDHistoCount1;
1637
1638 canvas1->cd(gSSDHistoCount1);
1639 histo->Draw("COLZ");
1640 }
1641 }
1642 }
1643
1644 canvas0->cd(); canvas1->cd();
1645
1646 return iResult;
1647}
1648
1649
cfa641b1 1650//*--------------------------------------------------------------------------------------
1651Int_t processTRDCalibHistograms(AliHLTHOMERBlockDesc* block, TCanvas * canvas) {
1652 Int_t iResult = 0;
1653
1654 TObjArray *HistArray=(TObjArray*)block->GetTObject();
1655 Int_t nCalibHistos=HistArray->GetEntriesFast();
1656 for(Int_t CalibHistoCount=0;CalibHistoCount<nCalibHistos;CalibHistoCount++){
1657 canvas->cd(CalibHistoCount+1);
1658
1659 if(HistArray->At(CalibHistoCount)->InheritsFrom("TH2S")){
1660 TH2S *histCalib=(TH2S*)(HistArray->At(CalibHistoCount));
1661 histCalib->Draw("colz");
1662 }
1663 else if(HistArray->At(CalibHistoCount)->InheritsFrom("TH2")){
1664 //TH2D *histCalib=dynamic_cast<TH2D*>(HistArray->At(CalibHistoCount));
1665 TH2D *histCalib=(TH2D*)(HistArray->At(CalibHistoCount));
1666 histCalib->Draw("lego2");
1667 }
1668 else if(HistArray->At(CalibHistoCount)->InheritsFrom("TH1")){
1669 //TH1D *histCalib=dynamic_cast<TH1D*>(HistArray->At(CalibHistoCount));
1670 TH1D *histCalib=(TH1D*)(HistArray->At(CalibHistoCount));
1671 histCalib->Draw();
1672 }
1673 else if(HistArray->At(CalibHistoCount)->InheritsFrom("AliTRDCalibraVdriftLinearFit")){
1674 //TH2S *histCalib = ((dynamic_cast<AliTRDCalibraVdriftLinearFit*>(HistArray->At(CalibHistoCount)))->GetLinearFitterHisto(10,kTRUE));
1675 TH2S *histCalib =(TH2S*)(((AliTRDCalibraVdriftLinearFit*)HistArray->At(CalibHistoCount))->GetLinearFitterHisto(10,kTRUE));
1676
1677 histCalib->Draw();
1678 }
1679
1680
1681 }
1682 return iResult;
1683}
ea48ba6e 1684//****************************************************************************
1685
922c1000 1686
1687
cfa641b1 1688void writeToFile(){
1689
cfa641b1 1690 TList * bList = gHomerManager->GetBlockList();
1691 TFile * file = TFile::Open(Form("Event_0x%016X_ITS.root", gHomerManager->GetEventID()), "RECREATE");
1692 bList->Write("blockList", TObject::kSingleKey);
1693 file->Close();
1694
1695 bList = gHomerManager->GetAsyncBlockList();
1696 TFile * afile = TFile::Open(Form("Event_0x%016X_Async.root", gHomerManager->GetEventID()), "RECREATE");
1697 bList->Write("blockList", TObject::kSingleKey);
1698 afile->Close();
1699
1700
1701// TIter next(bList);
1702
1703// AliHLTHOMERBlockDesc* block = 0;
1704
1705// // -- Iterate over blocks in the block list
1706// // ------------------------------------------
1707// while ((block = (AliHLTHOMERBlockDesc*)next())) {
1708// cout << "balle " << endl;
1709// }
1710
1711}
1712
1713
ea48ba6e 1714// -----------------------------------------------------------------
1715void loopEvent() {
1716 eventTimer.SetCommand("nextEvent()");
1717 eventTimer.Start(6000);
1718}
1719
1720// -----------------------------------------------------------------
1721void stopLoopEvent() {
1722 eventTimer.Stop();
1723}
1724
1725
1726// -----------------------------------------------------------------
1727void loopEventFast() {
1728 eventTimerFast.SetCommand("nextEvent()");
1729 eventTimerFast.Start(500);
1730}
1731
1732// -----------------------------------------------------------------
1733void stopLoopEventFast() {
1734 eventTimerFast.Stop();
1735}
1736
1d8ae8b6 1737// -----------------------------------------------------------------
1738void EventLoopFast() {
1739
1740 // Start/stop event loop
1741 if ( gEventLoopStarted ) {
1742 loopEventFast();
1743 gEventLoopStarted = kTRUE;
cfa641b1 1744
1745 } else {
1d8ae8b6 1746 stopLoopEventFast();
1747 gEventLoopStarted = kFALSE;
cfa641b1 1748
1d8ae8b6 1749 }
1750}
09cdbe4c 1751
1752
1753
1754 Int_t processAsyncBlock(AliHLTHOMERBlockDesc * block) {
1755
1756 Int_t iResult = 0;
1757
1758#if 1//DEBUG
1759 printf( "------------------- xxxxxxxxxxxxxxx ----------------------\n");
1760 printf( "Detector : %s\n", block->GetDetector().Data() );
1761 printf( "Datatype : %s\n", block->GetDataType().Data() );
1762 if (block->IsTObject() )
1763 printf( "Is TObject of class: %s\n", block->GetClassName().Data() );
1764 printf( "------------------- xxxxxxxxxxxxxxx ----------------------\n");
1765#endif
1766
1767 // ++ V0 BLOCK
1768 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1769 if ( block->GetDataType().CompareTo("ROOTHIST") == 0 ) {
1770 // -- Process V0 Histos
1771 processV0Histograms( block , gV0Canvas);
1772 }
1773
1774 // ++ vertex BLOCK
1775 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1776 if ( ! block->GetDetector().CompareTo("HLT") &&
1777 !block->GetDataType().CompareTo("ROOTHIST") ) {
1778 // -- Process Vertex Histos
1779 processPrimVertexHistograms( block , gPrimVertexCanvas);
1780 gPrimVertexCanvas->Update();
1781 }
1782
1783 // ++ ISPD Vertex BLOCK
1784 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1785 if ( ! block->GetDetector().CompareTo("ISPD") ){
1786 if ( block->GetDataType().CompareTo("ROOTHIST") == 0 ) {
1787
1788 // -- Process Vertex Histos
1789 processSPDVertexHistograms( block , gSPDVertexCanvas);
1790 gSPDVertexCanvas->Update();
1791 }
1792 }
1793
1794 // ++ ITS BLOCK
1795 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1796 if ( ! block->GetDetector().CompareTo("ITS") ){
1797 if ( block->GetDataType().CompareTo("ROOTHIST") == 0 ) {
1798
1799 // -- Process Vertex Histos
1800 processITSHistograms( block , gITSCanvas);
1801 gITSCanvas->Update();
1802 }
1803 }
1804
1805 // ++ ISSD BLOCK
1806 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1807 if ( ! block->GetDetector().CompareTo("ISSD") ){
1808 if ( block->GetDataType().CompareTo("ROOTOBAR") == 0 ) {
1809
1810 // -- Process Vertex Histos
1811 processSSDHistograms( block , gSSDCanvas0, gSSDCanvas1);
1812 gSSDCanvas0->Update();
1813 gSSDCanvas1->Update();
1814 }
1815 }
1816
1817 // ++ PHOS BLOCK
1818 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1819 if ( ! block->GetDetector().CompareTo("PHOS") ) {
1820
1821 cout << "PHOS"<<endl;
1822
1823 if( !gPHOSElementList ){
1824 gPHOSElementList = new TEveElementList("PHOS Cells");
1825 gEve->AddElement(gPHOSElementList);
1826
1827 TVector3 center;
1828 Float_t angle;
1829
1830 // -- Create boxsets
1831 for(int im = 0; im < 5; im++) {
1832
1833 TEveRGBAPalette* pal = new TEveRGBAPalette(0,120);
1834 pal->SetLimits(-0.1, 1024);
1835 gPHOSBoxSet[im] = new TEveBoxSet(Form("Cells Module %d" , im));
1836 gPHOSBoxSet[im]->SetPalette(pal);
1837 gPHOSBoxSet[im]->Reset(TEveBoxSet::kBT_AABox, kFALSE, 64);
1838 gPHOSBoxSet[im]->SetOwnIds(kTRUE);
1839
1840
1841 gPHOSGeom->GetModuleCenter(center, "CPV", im+1);
1842 angle = gPHOSGeom->GetPHOSAngle(im+1)*TMath::Pi()/180;
1843
1844 gPHOSBoxSet[im]->RefitPlex();
1845 TEveTrans& t = gPHOSBoxSet[im]->RefMainTrans();
1846 t.SetupRotation(1, 2, angle );
1847 t.SetPos(center.X(), center.Y(), center.Z());
1848
1849 gPHOSElementList->AddElement(gPHOSBoxSet[im]);
1850 }
1851 } // for(int im = 0; im < 5; im++) {
1852
1853 // -- Process Digitss
1854 if ( block->GetDataType().CompareTo("CALOCLUS") == 0 ) {
1855
1856 cout << "CHANNELT"<<endl;
1857 iResult = processPHOSClusters( block );
1858
1859 } else if ( block->GetDataType().CompareTo("DIGITTYP") == 0 ) {
1860
1861 cout << "DIGITTYP"<<endl;
1862 iResult - processPHOSDigits( block);
1863 }
1864
1865 else if ( block->GetDataType().CompareTo("ROOTHIST") == 0 ) {
1866 cout << "ROOTHIST"<<endl;
1867 iResult = addHistogramsToCanvas(block, gPHOSCanvas, gPHOSHistoCount);
1868 }
1869
1870 for(int im = 0; im < 5; im++)
1871 gPHOSBoxSet[im]->ElementChanged();
1872
1873 } // else if ( ! block->GetDetector().CompareTo("PHOS") ){
1874
1875 else if ( ! block->GetDetector().CompareTo("EMCA") ){
1876 if ( block->GetDataType().CompareTo("CHANNELT") == 0 ) {
1877
1878 if( !gEMCALElementList ){
1879 gEMCALElementList = new TEveElementList("EMCAL Cells");
1880 gEMCALElementList->SetTitle("Tooltip");
1881 gEve->AddElement(gEMCALElementList);
1882
1883
1884 gStyle->SetPalette(1, 0);
1885 TEveRGBAPalette* pal = new TEveRGBAPalette(0, 512);
1886 pal->SetLimits(0, 1024);
1887
1888
1889 for (Int_t sm=0; sm<12; ++sm) {
1890
1891 TEveBoxSet* q = new TEveBoxSet(Form("SM %d", sm+1));
1892 q->SetOwnIds(kTRUE);
1893
1894 q->Reset(TEveBoxSet::kBT_AABox, kFALSE, 64);
1895 q->RefMainTrans().SetFrom(*gEMCALNode->GetDaughter(sm)->GetMatrix());
1896 q->SetPalette(pal);
1897
1898 gEve->AddElement(q, gEMCALElementList);
1899 gEMCALBoxSet[sm] = q;
1900 }
1901 }
1902 // cout << "Processing emcal digits" << endl;
1903 iResult = processEMCALClusters( block );
1904
1905 for(int sm = 0; sm < 12; sm++) {
1906 gEMCALBoxSet[sm]->ElementChanged();
1907 }
1908
1909
1910 } else if ( block->GetDataType().CompareTo("ROOTHIST") == 0 ) {
1911 iResult = addHistogramsToCanvas(block, gEMCALCanvas, gEMCALHistoCount);
1912 }
1913 } // "EMCAL" blocks end
1914
1915 //Extra TPC clusters set for testing
1916 else if ( ! block->GetDetector().CompareTo("TPC") ) {
1917 if ( ! block->GetDataType().CompareTo("HWCL_ALT") ) {
1918 if(!gTPCTestClusters){
1919
1920 gTPCTestClusters = new TEvePointSet("TPC Clusters Test");
1921 //ggTPCTestClusters->ApplyVizTag("TPC Clusters");
1922 gTPCTestClusters->SetMainColor(kBlue);
1923 gTPCTestClusters->SetMarkerStyle((Style_t)kFullDotSmall);
1924 gEve->AddElement(gTPCTestClusters);
1925 }
1926
1927 iResult = processTPCClusters(block, gTPCTestClusters);
1928 gTPCTestClusters->ElementChanged();
1929 }
1930
1931
1932 }
1933
1934 }
1935
1936
1937
1938
1939
1940Int_t processBlock (AliHLTHOMERBlockDesc * block ){
1941
1942 Int_t iResult = 0;
1943
1944
1945#if 0 //DEBUG
1946 printf( "------------------- xxxxxxxxxxxxxxx ----------------------\n");
1947 printf( "Detector : %s\n", block->GetDetector().Data() );
1948 printf( "Datatype : %s\n", block->GetDataType().Data() );
1949 if (block->IsTObject() )
1950 printf( "Is TObject of class: %s\n", block->GetClassName().Data() );
1951 printf( "------------------- xxxxxxxxxxxxxxx ----------------------\n");
1952#endif
1953
1954 // ++ HLT BLOCK
1955 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1956 if ( ! block->GetDetector().CompareTo("HLT") ) {
1957
1958 // -- ESDTREE
1959 if ( ! block->GetDataType().CompareTo("ALIESDV0") ) {
1960 if(!gTPCTrack){
1961 gTPCTrack = new TEveTrackList("ESD Tracks");
1962 gTPCTrack->SetMainColor(6);
1963 gEve->AddElement(gTPCTrack);
1964 }
1965 iResult = processEsdTracks(block, gTPCTrack);
1966 gTPCTrack->ElementChanged();
1967 } // if ( ! block->GetDataType().CompareTo("ALIESDV0") ) {
1968
1969 // -- Process ROOTObj
1970 else if ( ! block->GetDataType().CompareTo("ROOTTOBJ") ) {
1971 if(!gHLTText){
1972 //gHLTText = new TEveText();
1973 //gHLTText->BBoxZero(5, -5, -5, 0);
1974 //gHLTText->SetExtrude(25);
1975 //gHLTText->AssertBBoxExtents(25,25,25);
1976 //gEve->AddElement(gHLTText);
1977 }
1978 processROOTTOBJ( block, gHLTText );
1979 } // else if ( ! block->GetDataType().CompareTo("ROOTTOBJ") ) {
1980
1981 // -- Process HLT RDLST
1982 else if ( ! block->GetDataType().CompareTo("HLTRDLST") ) {
1983 processHLTRDLST( block );
1984 } // else if ( ! block->GetDataType().CompareTo("HLTRDLST") ) {
1985
1986 } // if ( ! block->GetDetector().CompareTo("HLT") ) {
1987
1988 // ++ TPC BLOCK
1989 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1990 else if ( ! block->GetDetector().CompareTo("TPC") ) {
1991
1992 // -- Process TPC Clusters
1993 if ( ! block->GetDataType().CompareTo("CLUSTERS") ) {
1994 if(!gTPCClusters){
1995 gTPCClusters = new TEvePointSet("TPC Clusters");
1996 //gTPCClusters->ApplyVizTag("TPC Clusters");
1997 gTPCClusters->SetMainColor(kRed);
1998 gTPCClusters->SetMarkerStyle((Style_t)kFullDotSmall);
1999 //gEve->AddElement(gTPCClusters);
2000 }
2001
2002 if(!gTPCColClusters){
2003 gTPCColClusters = new TEvePointSetArray("TPC Clusters Colorized");
2004 gTPCColClusters->SetMainColor(kRed);
2005 gTPCColClusters->SetMarkerStyle(4); // antialiased circle
2006 gTPCColClusters->SetMarkerSize(0.4);
2007 gTPCColClusters->InitBins("Cluster Charge", gTPCBins, 0., gTPCBins*20.);
2008
2009 const Int_t nCol = TColor::GetNumberOfColors();
2010
2011 for (Int_t ii = 0; ii < gTPCBins+1; ++ii)
2012 gTPCColClusters->GetBin(ii)->SetMainColor(TColor::GetColorPalette(ii * nCol / (gTPCBins+2)));
2013
2014 gEve->AddElement(gTPCColClusters);
2015 }
2016
2017 iResult = processTPCClusters(block, gTPCClusters, gTPCColClusters);
2018 //gTPCClusters->ElementChanged();
2019 gTPCColClusters->ElementChanged();
2020 }
2021
2022 } // else if ( ! block->GetDetector().CompareTo("TPC") ) {
2023
2024 // ++ TRD BLOCK
2025 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
2026 else if ( ! block->GetDetector().CompareTo("TRD") ) {
2027
2028 // -- Process TRD Clusters
2029 if ( ! block->GetDataType().CompareTo("CLUSTERS") ) {
2030
2031 if(!gTRDClusters){
2032 gTRDClusters = new TEvePointSet("TRD Clusters");
2033 gTRDClusters->SetMainColor(kBlue);
2034 gTRDClusters->SetMarkerStyle((Style_t)kFullDotSmall);
2035 //gEve->AddElement(gTRDClusters);
2036 }
2037
2038 if(!gTRDColClusters){
2039 gTRDColClusters = new TEvePointSetArray("TRD Clusters Colorized");
2040 gTRDColClusters->SetMainColor(kRed);
2041 gTRDColClusters->SetMarkerStyle(4); // antialiased circle
2042 // gTRDColClusters->SetMarkerStyle((Style_t)kFullDotSmall);
2043 gTRDColClusters->SetMarkerSize(0.4);
2044 gTRDColClusters->InitBins("Cluster Charge", gTRDBins, 0., gTRDBins*100.);
2045
2046 //TColor::SetPalette(1, 0); // Spectrum palette
2047 const Int_t nCol = TColor::GetNumberOfColors();
2048 for (Int_t ii = 0; ii < gTRDBins+1; ++ii)
2049 gTRDColClusters->GetBin(ii)->SetMainColor(TColor::GetColorPalette(ii * nCol / (gTRDBins+2)));
2050
2051 gEve->AddElement(gTRDColClusters);
2052 }
2053
2054 iResult = processTRDClusters( block, gTRDClusters, gTRDColClusters );
2055 //gTRDClusters->ElementChanged();
2056 gTRDColClusters->ElementChanged();
2057 }
2058
2059 // -- Process TRD Histograms
2060 else if ( block->GetDataType().CompareTo("ROOTHIST") == 0 ) {
2061 iResult = processTRDHistograms( block, gTRDCanvas );
2062 if ( gTRDCanvas) gTRDCanvas->Update();
2063 }
2064 else if(block->GetDataType().CompareTo("CALIBRAH")==0){
2065 iResult=processTRDCalibHistograms(block,gTRDCalibCanvas);
2066 if(gTRDCalibCanvas)gTRDCalibCanvas->Update();
2067 }
2068 else if(block->GetDataType().CompareTo("CALIBEOR")==0){
2069 iResult=processTRDCalibHistograms(block,gTRDEORCanvas);
2070 if(gTRDEORCanvas)gTRDEORCanvas->Update();
2071 }
2072 } // else if ( ! block->GetDetector().CompareTo("TRD") ) {
2073
2074 // ++ MUON BLOCK
2075 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
2076 else if ( ! block->GetDetector().CompareTo("MUON") && gShowMUON ) {
2077
2078 // -- Process MUON Clusters
2079 if ( (block->GetDataType().CompareTo("RECHITS") == 0) || (block->GetDataType().CompareTo("TRIGRECS") == 0) ) {
2080
2081 if ( !gMUONClusters ) {
2082 gMUONClusters = new TEvePointSet("MUON RecHits");
2083 gMUONClusters->SetMainColor(kBlue);
2084 gMUONClusters->SetMarkerStyle(20);
2085 gEve->AddElement(gMUONClusters);
2086 }
2087
2088 processMUONClusters( block );
2089 gMUONClusters->ElementChanged();
2090
2091 }else if(block->GetDataType().CompareTo("MANTRACK") == 0){
2092
2093 if ( !gMUONTracks ) {
2094 gMUONTracks = new TEveStraightLineSet("MUON Tracks");
2095 gMUONTracks->SetMainColor(kRed);
2096 gMUONTracks->SetLineWidth(3);
2097 gEve->AddElement(gMUONTracks);
2098 }
2099
2100 processMUONTracks( block );
2101 gMUONTracks->ElementChanged();
2102
2103
2104 }
2105 } // else if ( ! block->GetDetector().CompareTo("MUON") && gShowMUON ) {
2106
2107 // ++ ISPD BLOCK
2108 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
2109 else if ( ! block->GetDetector().CompareTo("ISPD") ){
2110 if ( block->GetDataType().CompareTo("CLUSTERS") == 0 ) {
2111
2112 if(!gSPDClusters){
2113 gSPDClusters = new TEvePointSet("SPD Clusters");
2114 gSPDClusters->SetMainColor(kBlack);
2115 gSPDClusters->SetMarkerStyle((Style_t)kFullDotMedium);
2116 gEve->AddElement(gSPDClusters);
2117 }
2118
2119 processITSClusters( block , gSPDClusters);
2120 gSPDClusters->ElementChanged();
2121
2122 } else if ( block->GetDataType().CompareTo("ROOTHIST") == 0 ) {
2123
2124 // -- Process Vertex Histos
2125 processSPDVertexHistograms( block , gSPDVertexCanvas);
2126 gSPDVertexCanvas->Update();
2127 }
2128 } // else if ( ! block->GetDetector().CompareTo("ISPD") ){
2129
2130 // ++ ISDD BLOCK
2131 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
2132 else if ( ! block->GetDetector().CompareTo("ISDD") ){
2133 if ( block->GetDataType().CompareTo("CLUSTERS") == 0 ) {
2134
2135 if(!gSDDClusters){
2136 gSDDClusters = new TEvePointSet("SDD Clusters");
2137 gSDDClusters->SetMainColor(kPink);
2138 gSDDClusters->SetMarkerStyle((Style_t)kFullDotMedium);
2139 gEve->AddElement(gSDDClusters);
2140 }
2141
2142 processITSClusters( block , gSDDClusters);
2143 gSDDClusters->ElementChanged();
2144 }
2145 } // else if ( ! block->GetDetector().CompareTo("ISDD") ){
2146
2147 // ++ ISSD BLOCK
2148 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
2149 else if ( ! block->GetDetector().CompareTo("ISSD") ){
2150 if ( block->GetDataType().CompareTo("CLUSTERS") == 0 ) {
2151
2152 if(!gSSDClusters){
2153 gSSDClusters = new TEvePointSet("SSD Clusters");
2154 gSSDClusters->SetMainColor(kBlue);
2155 gSSDClusters->SetMarkerStyle((Style_t)kFullDotMedium);
2156 gEve->AddElement(gSSDClusters);
2157 }
2158
2159 processITSClusters( block , gSSDClusters);
2160 gSSDClusters->ElementChanged();
2161 }
2162 } // else if ( ! block->GetDetector().CompareTo("ISSD") ){
2163
2164 // ++ ITS BLOCK
2165 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
2166 else if ( ! block->GetDetector().CompareTo("ITS") ){
2167 if ( block->GetDataType().CompareTo("ROOTHIST") == 0 ) {
2168 iResult = processITSHist( block );
2169 }
2170 } // else if ( ! block->GetDetector().CompareTo("ITS") ){
2171
2172 // ++ PHOS BLOCK
2173 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
2174 else if ( ! block->GetDetector().CompareTo("PHOS") ) {
2175
2176 // -- Process Digits
2177 //if ( block->GetDataType().CompareTo("DIGITTYP") == 0 ) {
2178 if ( block->GetDataType().CompareTo("CHANNELT") == 0 ) {
2179
2180 if( !gPHOSElementList ){
2181 gPHOSElementList = new TEveElementList("PHOS Cells");
2182 gEve->AddElement(gPHOSElementList);
2183
2184 TVector3 center;
2185 Float_t angle;
2186
2187 // -- Create boxsets
2188 for(int im = 0; im < 5; im++) {
2189
2190 TEveRGBAPalette* pal = new TEveRGBAPalette(0,120);
2191 pal->SetLimits(-0.1, 1024);
2192 gPHOSBoxSet[im] = new TEveBoxSet(Form("Cells Module %d" , im));
2193 gPHOSBoxSet[im]->SetPalette(pal);
2194 gPHOSBoxSet[im]->Reset(TEveBoxSet::kBT_AABox, kFALSE, 64);
2195 gPHOSBoxSet[im]->SetOwnIds(kTRUE);
2196
2197
2198 gPHOSGeom->GetModuleCenter(center, "CPV", im+1);
2199 angle = gPHOSGeom->GetPHOSAngle(im+1)*TMath::Pi()/180;
2200
2201 gPHOSBoxSet[im]->RefitPlex();
2202 TEveTrans& t = gPHOSBoxSet[im]->RefMainTrans();
2203 t.SetupRotation(1, 2, angle );
2204 t.SetPos(center.X(), center.Y(), center.Z());
2205
2206 gPHOSElementList->AddElement(gPHOSBoxSet[im]);
2207 }
2208 } // for(int im = 0; im < 5; im++) {
2209
2210 iResult = processPHOSClusters( block );
2211
2212 for(int im = 0; im < 5; im++)
2213 gPHOSBoxSet[im]->ElementChanged();
2214
2215 } // if ( block->GetDataType().CompareTo("DIGITTYP") == 0 ) {
2216
2217 } // else if ( ! block->GetDetector().CompareTo("PHOS") ){
2218
2219 else if ( ! block->GetDetector().CompareTo("EMCAL") ){
2220 if ( block->GetDataType().CompareTo("CHANNELT") == 0 ) {
2221
2222 if( !gEMCALElementList ){
2223 gEMCALElementList = new TEveElementList("EMCAL Cells");
2224 gEMCALElementList->SetTitle("Tooltip");
2225 gEve->AddElement(gEMCALElementList);
2226
2227
2228 gStyle->SetPalette(1, 0);
2229 TEveRGBAPalette* pal = new TEveRGBAPalette(0, 512);
2230 pal->SetLimits(0, 1024);
2231
2232
2233 for (Int_t sm=0; sm<12; ++sm) {
2234
2235 TEveBoxSet* q = new TEveBoxSet(Form("SM %d", sm+1));
2236 q->SetOwnIds(kTRUE);
2237
2238 q->Reset(TEveBoxSet::kBT_AABox, kFALSE, 64);
2239 q->RefMainTrans().SetFrom(*gEMCALNode->GetDaughter(sm)->GetMatrix());
2240 q->SetPalette(pal);
2241
2242 gEve->AddElement(q, gEMCALElementList);
2243 gEMCALBoxSet[sm] = q;
2244 }
2245 }
2246
2247 iResult = processEMCALClusters( block );
2248
2249 for(int sm = 0; sm < 12; sm++) {
2250 gEMCALBoxSet[sm]->ElementChanged();
2251 }
2252
2253
2254 }
2255
2256 } // "EMCAL" blocks end
2257
2258 // ---------------------------------------------------------
2259} // while ((block = (AliHLTHOMERBlockDesc*)next())) {
2260