]>
Commit | Line | Data |
---|---|---|
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 | 133 | class TEveTrackList; |
9e78371d | 134 | class TEveProjectionManager; |
135 | class TEveGeoShape; | |
136 | class TEveUtil; | |
137 | class AliEveMacroExecutor; | |
138 | class TEveScene; | |
139 | class TEveElement; | |
140 | class TEveText; | |
141 | class AliHLTTriggerDecision; | |
142 | class TEvePointSet; | |
1d8ae8b6 | 143 | class TEvePointSetArray; |
f1fefc07 | 144 | class AliHLTHOMERBlockDesc; |
9e78371d | 145 | |
f1fefc07 | 146 | class TEveViewer; |
ea48ba6e | 147 | |
cfa641b1 | 148 | |
9e78371d | 149 | // ----------------------------------------------------------------- |
150 | // -- Geometry / Scenes -- | |
151 | // ----------------------------------------------------------------- | |
152 | ||
f1fefc07 | 153 | TEveGeoShape *gGeomGentle = 0; |
154 | TEveGeoShape *gGeomGentleRPhi = 0; | |
155 | TEveGeoShape *gGeomGentleRhoZ = 0; | |
156 | TEveGeoShape *gGeomGentleTRD = 0; | |
157 | TEveGeoShape *gGeomGentleMUON = 0; | |
158 | ||
159 | TEveScene *gRPhiGeomScene = 0; | |
160 | TEveScene *gRhoZGeomScene = 0; | |
161 | TEveScene *gRPhiEventScene = 0; | |
162 | TEveScene *gRhoZEventScene = 0; | |
163 | ||
9e78371d | 164 | TEveProjectionManager *gRPhiMgr = 0; |
165 | TEveProjectionManager *gRhoZMgr = 0; | |
166 | ||
f1fefc07 | 167 | TEveViewer *g3DView = 0; |
168 | TEveViewer *gRPhiView = 0; | |
169 | TEveViewer *gRhoZView = 0; | |
170 | ||
9e78371d | 171 | // ----------------------------------------------------------------- |
172 | // -- Geometry / Scenes Parameters -- | |
173 | // ----------------------------------------------------------------- | |
174 | ||
175 | // -- Parameters to show different geometries | |
176 | Bool_t gShowMUON = kTRUE; | |
177 | Bool_t gShowMUONRPhi = kFALSE; | |
178 | Bool_t gShowMUONRhoZ = kTRUE; | |
f1fefc07 | 179 | Bool_t gShowTRD = kFALSE; |
180 | ||
181 | Bool_t gCenterProjectionsAtPrimaryVertex = kFALSE; | |
9e78371d | 182 | |
183 | // ----------------------------------------------------------------- | |
184 | // -- Members -- | |
185 | // ----------------------------------------------------------------- | |
186 | ||
187 | // -- Timer for automatic event loop | |
188 | TTimer eventTimer; | |
1d8ae8b6 | 189 | TTimer eventTimerFast; |
9e78371d | 190 | |
191 | // -- HOMERManager | |
c5e3aa8e | 192 | AliEveHOMERManager* gHomerManager = 0; |
193 | ||
194 | // -- Geometry Manager | |
195 | TGeoManager* gGeoManager = 0; | |
196 | AliPHOSGeometry* gPHOSGeom = 0; | |
9e78371d | 197 | |
198 | // -- Cluster members | |
c5e3aa8e | 199 | TEvePointSet* gSPDClusters = 0; |
200 | TEvePointSet* gSSDClusters = 0; | |
201 | TEvePointSet* gSDDClusters = 0; | |
202 | TEvePointSet* gTRDClusters = 0; | |
203 | TEvePointSetArray* gTRDColClusters = 0; | |
204 | TEvePointSet* gTPCClusters = 0; | |
49993c6f | 205 | TEvePointSet* gTPCTestClusters = 0; |
c5e3aa8e | 206 | TEvePointSetArray* gTPCColClusters = 0; |
207 | TEveBoxSet* gPHOSBoxSet[5] = {0, 0, 0, 0, 0}; | |
cfa641b1 | 208 | TEveBoxSet* gEMCALBoxSet[13] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
c5e3aa8e | 209 | TEvePointSet* gMUONClusters = 0; |
cfa641b1 | 210 | TEveStraightLineSet* gMUONTracks = 0; |
9e78371d | 211 | |
f1fefc07 | 212 | // -- Text output members |
c5e3aa8e | 213 | TEveText* gHLTText = 0; |
f1fefc07 | 214 | |
9e78371d | 215 | // -- Tracks members |
c5e3aa8e | 216 | TEveTrackList* gTPCTrack = 0; |
9e78371d | 217 | |
1d8ae8b6 | 218 | // -- Canvas for histograms |
c5e3aa8e | 219 | TCanvas* gTRDCanvas = 0; |
220 | TCanvas* gTPCCanvas = 0; | |
922c1000 | 221 | TCanvas* gTPCClustCanvas = 0; |
ff64d287 | 222 | TCanvas* gTRDCalibCanvas = 0; |
223 | TCanvas* gTRDEORCanvas = 0; | |
224 | TCanvas* gPrimVertexCanvas = 0; | |
225 | TCanvas* gSPDVertexCanvas = 0; | |
226 | TCanvas* gITSCanvas = 0; | |
227 | TCanvas* gSSDCanvas0 = 0; | |
228 | TCanvas* gSSDCanvas1 = 0; | |
229 | TCanvas* gV0Canvas = 0; | |
922c1000 | 230 | TCanvas* gPHOSCanvas = 0; |
09cdbe4c | 231 | TCanvas* gEMCALCanvas = 0; |
ff64d287 | 232 | |
233 | // -- vertex -- | |
234 | Int_t gSPDVertexHistoCount = 0; | |
cfa641b1 | 235 | |
ff64d287 | 236 | |
237 | // -- ITS -- | |
238 | Int_t gITSHistoCount = 0; | |
239 | Int_t gSSDHistoCount0 = 0; | |
240 | Int_t gSSDHistoCount1 = 0; | |
1d8ae8b6 | 241 | |
ea48ba6e | 242 | // -- TRD -- |
c5e3aa8e | 243 | Int_t gTRDHistoCount = 0; |
244 | Int_t gTRDEvents = 0; | |
245 | Int_t gTRDBins = 12; | |
246 | ||
247 | // -- TPC -- | |
248 | Int_t gTPCBins = 15; | |
249 | TH1F* gTPCCharge = 0; | |
250 | TH1F* gTPCQMax = 0; | |
251 | TH1F* gTPCQMaxOverCharge = 0; | |
ea48ba6e | 252 | |
922c1000 | 253 | TH1F* gTPCPt = 0; // KK |
254 | TH1F* gTPCEta = 0; | |
255 | TH1F* gTPCPsi = 0; | |
256 | TH1F* gTPCnClusters = 0; | |
257 | TH1F* gTPCMult = 0; | |
258 | ||
c5e3aa8e | 259 | // -- PHOS -- |
260 | TEveElementList* gPHOSElementList = 0; | |
922c1000 | 261 | Int_t gPHOSHistoCount =0; |
cfa641b1 | 262 | // -- EMCAL |
263 | TEveElementList* gEMCALElementList = 0; | |
ff64d287 | 264 | TGeoNode* gEMCALNode = 0; |
09cdbe4c | 265 | Int_t gEMCALHistoCount =0; |
cfa641b1 | 266 | |
1d8ae8b6 | 267 | // --- Flag if eventloop is running |
268 | Bool_t gEventLoopStarted = kFALSE; | |
f1fefc07 | 269 | |
cfa641b1 | 270 | |
271 | //Container for gGeoManager till it is broken | |
272 | TGeoManager *fGeoManager = 0; | |
9e78371d | 273 | // ----------------------------------------------------------------- |
274 | // -- Methods -- | |
275 | // ----------------------------------------------------------------- | |
276 | ||
1d8ae8b6 | 277 | Int_t initializeEveViewer( Bool_t TPCMode, Bool_t MUONMode, Bool_t TRDMode ); |
9e78371d | 278 | |
1d8ae8b6 | 279 | void nextEvent(); |
5de5a293 | 280 | |
ea9a0e13 | 281 | Int_t processEvent(); |
9e78371d | 282 | |
c5e3aa8e | 283 | Int_t processPHOSClusters( AliHLTHOMERBlockDesc* block); |
922c1000 | 284 | Int_t processPHOSDigits(AliHLTHOMERBlockDesc* block); |
9e78371d | 285 | |
cfa641b1 | 286 | Int_t processEMCALClusters( AliHLTHOMERBlockDesc* block); |
287 | ||
9e78371d | 288 | Int_t processEsdTracks( AliHLTHOMERBlockDesc* block, TEveTrackList* cont ); |
289 | ||
290 | Int_t processHLTRDLST( AliHLTHOMERBlockDesc* block ); | |
291 | ||
1d8ae8b6 | 292 | Int_t processROOTTOBJ( AliHLTHOMERBlockDesc* block, TEveText* text ); |
293 | ||
49993c6f | 294 | Int_t processTPCClusters( AliHLTHOMERBlockDesc * block, TEvePointSet *cont, TEvePointSetArray *contCol = NULL ); |
1d8ae8b6 | 295 | |
c5e3aa8e | 296 | Int_t processTRDClusters( AliHLTHOMERBlockDesc * block, TEvePointSet *cont, TEvePointSetArray *contCol); |
1d8ae8b6 | 297 | |
ff64d287 | 298 | Int_t processTRDHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas ); |
299 | ||
300 | Int_t processITSHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas ); | |
301 | ||
922c1000 | 302 | Int_t processPHOSHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas ); |
303 | ||
ff64d287 | 304 | Int_t processSSDHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas, TCanvas * canvas1 ); |
1d8ae8b6 | 305 | |
ff64d287 | 306 | Int_t processPrimVertexHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas ); |
cfa641b1 | 307 | |
ff64d287 | 308 | Int_t processSPDVertexHistograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas ); |
cfa641b1 | 309 | |
ff64d287 | 310 | Int_t processV0Histograms( AliHLTHOMERBlockDesc * block, TCanvas * canvas ); |
9e78371d | 311 | |
ff64d287 | 312 | Int_t processTRDCalibHistograms( AliHLTHOMERBlockDesc *block, TCanvas *canvas ); |
cfa641b1 | 313 | |
ff64d287 | 314 | Int_t processMUONClusters( AliHLTHOMERBlockDesc* block ); |
c5e3aa8e | 315 | |
ff64d287 | 316 | Int_t processMUONTracks( AliHLTHOMERBlockDesc* block ); |
317 | ||
318 | Int_t processITSClusters( AliHLTHOMERBlockDesc* block, TEvePointSet* cont ); | |
319 | ||
320 | Int_t processITSHist( AliHLTHOMERBlockDesc* block ); | |
9e78371d | 321 | |
09cdbe4c | 322 | Int_t processBlock( AliHLTHOMERBlockDesc* block ); |
323 | Int_t processAsyncBlock( AliHLTHOMERBlockDesc* block ); | |
324 | Int_t updateDisplay(); | |
325 | ||
cfa641b1 | 326 | void writeToFile(); |
327 | ||
328 | ||
9e78371d | 329 | // ################################################################# |
330 | // ################################################################# | |
331 | // ################################################################# | |
332 | ||
333 | // ----------------------------------------------------------------- | |
1d8ae8b6 | 334 | void 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 | // ------------------------------------------------------------------------- |
403 | Int_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 | // ----------------------------------------------------------------- |
728 | void 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 | 747 | Int_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 | 907 | Int_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 | 992 | Int_t processITSHist(AliHLTHOMERBlockDesc* /*block*/) { |
f1fefc07 | 993 | return 0; |
994 | } | |
1d8ae8b6 | 995 | |
9e78371d | 996 | // ----------------------------------------------------------------- |
1d8ae8b6 | 997 | Int_t processHLTRDLST(AliHLTHOMERBlockDesc* /*block*/) { |
9e78371d | 998 | return 0; |
999 | } | |
1000 | ||
1001 | // ----------------------------------------------------------------- | |
1d8ae8b6 | 1002 | Int_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 | // ----------------------------------------------------------------- | |
1024 | Int_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 | // // ----------------------------------------------------------------- | |
1107 | Int_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 | 1129 | Int_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 | 1155 | Int_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 | 1190 | Int_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 | // ----------------------------------------------------------------- | |
1228 | Int_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 | 1255 | Int_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 | // ----------------------------------------------------------------- |
1312 | Int_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 | // ----------------------------------------------------------------- |
1366 | Int_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 | // ----------------------------------------------------------------- | |
1399 | Int_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 | // ----------------------------------------------------------------- |
1440 | Int_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 | 1475 | Int_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 | // ----------------------------------------------------------------- |
1502 | Int_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 | // ----------------------------------------------------------------- | |
1545 | Int_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 | ||
1572 | Int_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 | // ----------------------------------------------------------------- | |
1598 | Int_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 | //*-------------------------------------------------------------------------------------- |
1651 | Int_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 | 1688 | void 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 | // ----------------------------------------------------------------- |
1715 | void loopEvent() { | |
1716 | eventTimer.SetCommand("nextEvent()"); | |
1717 | eventTimer.Start(6000); | |
1718 | } | |
1719 | ||
1720 | // ----------------------------------------------------------------- | |
1721 | void stopLoopEvent() { | |
1722 | eventTimer.Stop(); | |
1723 | } | |
1724 | ||
1725 | ||
1726 | // ----------------------------------------------------------------- | |
1727 | void loopEventFast() { | |
1728 | eventTimerFast.SetCommand("nextEvent()"); | |
1729 | eventTimerFast.Start(500); | |
1730 | } | |
1731 | ||
1732 | // ----------------------------------------------------------------- | |
1733 | void stopLoopEventFast() { | |
1734 | eventTimerFast.Stop(); | |
1735 | } | |
1736 | ||
1d8ae8b6 | 1737 | // ----------------------------------------------------------------- |
1738 | void 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 | ||
1940 | Int_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 |