e4d79eaf2ea12e6803c06308badefe98a1a1bcb1
[u/mrichter/AliRoot.git] / HLT / PHOS / OnlineDisplay / AliHLTPHOSOnlineDisplay.cxx
1 #include  "AliHLTPHOSOnlineDisplay.h"
2 #include  "AliHLTDataTypes.h"
3 #include  "AliHLTPHOSRcuCellEnergyDataStruct.h"
4 #include  <vector>
5 #include  "stdio.h"
6 #include <string>
7 #include <sys/ipc.h>
8 #include <errno.h>
9 #include "TH2.h"
10 #include "TCanvas.h"
11 #include "AliHLTPHOSRcuCellAccumulatedEnergyDataStruct.h"
12 #include "AliHLTPHOSCommonDefs.h"
13
14 //#include "TGMatrixLayout.h"
15
16 /**************************************************************************
17  * This file is property of and copyright by the Experimental Nuclear     *
18  * Physics Group, Dep. of Physics                                         *
19  * University of Oslo, Norway, 2007                                       *
20  *                                                                        * 
21  * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
22  * Contributors are mentioned in the code where appropriate.              *
23  * Please report bugs to perthi@fys.uio.no                                * 
24  *                                                                        *
25  * Permission to use, copy, modify and distribute this software and its   *
26  * documentation strictly for non-commercial purposes is hereby granted   *
27  * without fee, provided that the above copyright notice appears in all   *
28  * copies and that both the copyright notice and this permission notice   *
29  * appear in the supporting documentation. The authors make no claims     *
30  * about the suitability of this software for any purpose. It is          *
31  * provided "as is" without express or implied warranty.                  *
32  **************************************************************************/
33
34 #ifndef __CINT__
35 # include <stdexcept>
36 # include <TSystem.h>
37 # include <TApplication.h>
38 # include "TStyle.h" 
39 #endif
40 #include <iostream>
41
42
43 #define MAX_BIN_VALUE 1023
44
45
46 AliHLTPHOSGetEventButton*  AliHLTPHOSOnlineDisplay::fgEventButtPtr     = 0;           /**<Button to get a new event from the HLT online stream*/
47 AliHLTPHOSOnlineDisplay*   AliHLTPHOSOnlineDisplay::fgInstancePtr      = 0;           /**<The one an only instance of PhosOnlineDisplay*/
48 HOMERReader*               AliHLTPHOSOnlineDisplay::fgHomerReaderPtr   = 0;           /**<Homer reader that fetches events from the HLT online stream*/
49 HOMERReader*               AliHLTPHOSOnlineDisplay::fgHomerReadersPtr[MAX_HOSTS];     /**<Homer reader that fetches events from the HLT online stream*/
50 HOMERReader*               AliHLTPHOSOnlineDisplay::fgCalibReadersPtr[MAX_HOSTS];     /**<Homer reader that fetches histograms from the HLT online stream*/
51 HOMERReader*               AliHLTPHOSOnlineDisplay::fgChannelRawReadersPtr[MAX_HOSTS];
52 TH2D*                      AliHLTPHOSOnlineDisplay::fgLegoPlotLGPtr      = 0;         /**<2D histogram for low gain channels*/
53 TH2D*                      AliHLTPHOSOnlineDisplay::fgLegoPlotHGPtr      = 0;         /**<2D histogram for high gain channels*/
54 TH2D*                      AliHLTPHOSOnlineDisplay::fgCalibHistPtr[N_GAINS];          /**<2D histogram for low gain channels*/
55 TH2I*                      AliHLTPHOSOnlineDisplay::fgHitsHistPtr[N_GAINS];           /**<2D histogram for low gain channels*/
56 TH2D*                      AliHLTPHOSOnlineDisplay::fgAveragePtr[N_GAINS];            /**<Accumuated energy/hits*/
57 char*                      AliHLTPHOSOnlineDisplay::fgDefaultDet       = "SOHP";      /**<PHOS written backwards*/
58 char*                      AliHLTPHOSOnlineDisplay::fgDefaultDataType  = "RENELLEC";  /**<CELLENER (Celle energy) written backwards*/  
59 int                        AliHLTPHOSOnlineDisplay::fgEvntCnt          = 0;           /**<Event Counter*/
60 TCanvas*                   AliHLTPHOSOnlineDisplay::fgCanvasHGPtr      = 0;           /**<Canvas to plot fgLegoplot for High gain channels*/ 
61 TCanvas*                   AliHLTPHOSOnlineDisplay::fgCanvasLGPtr      = 0;           /**<Canvas to plot fgLegoplot for Low gain channels*/ 
62 TCanvas*                   AliHLTPHOSOnlineDisplay::fgTestCanvasPtr    = 0;
63 Bool_t                     AliHLTPHOSOnlineDisplay::fgAccumulate       = kFALSE ;     /**<If set to kFALSE reset fgLegoplot between event, kTRUE adds current energies to previous plot*/
64 Bool_t                     AliHLTPHOSOnlineDisplay::fgSyncronize       = kFALSE ;
65 unsigned int               AliHLTPHOSOnlineDisplay::fgNHosts           = 0;
66 unsigned int               AliHLTPHOSOnlineDisplay::fgNPorts           = 0;
67 char*                      AliHLTPHOSOnlineDisplay::fgHosts[MAX_HOSTS];
68 short unsigned int*        AliHLTPHOSOnlineDisplay::fgPorts            =0; 
69
70
71 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fFrame1            = 0; 
72 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fF1                = 0;         
73 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fF2                = 0;
74 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fF3                = 0;
75 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fF4                = 0;
76 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fF5                = 0;
77 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fSubF1             = 0;
78 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fSubF2             = 0;
79 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fSubF3             = 0;
80 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fSubF4             = 0;
81 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fSubF5             = 0;
82 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fSubF6             = 0;
83 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fSubF7             = 0;
84 TGCompositeFrame*          AliHLTPHOSOnlineDisplay::fSubF8             = 0;
85
86 TGTab*                     AliHLTPHOSOnlineDisplay::fTab               = 0;
87 TGTab*                     AliHLTPHOSOnlineDisplay::fSubTab1           = 0;
88 TGTab*                     AliHLTPHOSOnlineDisplay::fSubTab2           = 0;
89 TGTab*                     AliHLTPHOSOnlineDisplay::fSubTab3           = 0;
90
91 TGTab*                     AliHLTPHOSOnlineDisplay::fSubTabModule[N_MODULES];
92 TGTab*                     AliHLTPHOSOnlineDisplay::fSubSubTabRcu[N_MODULES][N_RCUS_PER_MODULE]; 
93
94 TH1D*                      AliHLTPHOSOnlineDisplay::fgChannelDataPlotPtr[N_ZROWS_RCU][N_XCOLUMNS_RCU];
95
96 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fTest              = 0;
97
98 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc1               = 0; 
99 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc2               = 0; 
100 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc3               = 0; 
101 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc4               = 0;
102 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc5               = 0; 
103 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc6               = 0;
104 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc7               = 0; 
105 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc8               = 0; 
106 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc9               = 0; 
107 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc10              = 0;
108 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc11              = 0; 
109 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc12              = 0;
110 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc13              = 0; 
111 TRootEmbeddedCanvas*       AliHLTPHOSOnlineDisplay::fEc14              = 0;
112 using namespace std;
113
114
115 AliHLTPHOSOnlineDisplay*
116 AliHLTPHOSOnlineDisplay::Instance() 
117 {
118   if (!fgInstancePtr) fgInstancePtr = new AliHLTPHOSOnlineDisplay();
119   return fgInstancePtr;
120 }
121
122 AliHLTPHOSOnlineDisplay::AliHLTPHOSOnlineDisplay()
123 {
124   char **tmp;
125   cout << "creating new PHOS Onlinedisplay" << endl;
126   fgLegoPlotLGPtr  = 0;
127   fgLegoPlotHGPtr  = 0;
128
129   fgHomerReaderPtr = new  HOMERReader(fgNHosts, (const char**)fgHosts,  fgPorts);
130
131   for(int i = 0; i <fgNHosts; i++)
132     {
133       fgHomerReadersPtr[i] =      new  HOMERReader(fgHosts[i], fgPorts[i]); 
134       fgCalibReadersPtr[i] =      new  HOMERReader(fgHosts[i], fgPorts[i]);
135       fgChannelRawReadersPtr[i] = new  HOMERReader(fgHosts[i], fgPorts[i]);
136     }
137  
138  InitDisplay();
139
140 }
141
142
143 AliHLTPHOSOnlineDisplay::~AliHLTPHOSOnlineDisplay()
144 {
145
146 }
147
148 void
149 AliHLTPHOSOnlineDisplay::InitDisplay()
150 {
151   char tmpHistoName[256];
152
153   fgLegoPlotHGPtr = new TH2D("Homer","HLT: #pi^{0} 5 - 30Gev HG, High gain",  
154                              N_XCOLUMNS_MOD*N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES,  
155                              N_ZROWS_MOD,               0, N_ZROWS_MOD);
156   fgLegoPlotHGPtr->SetMaximum( MAX_BIN_VALUE);
157   fgLegoPlotHGPtr->Reset();
158
159   fgLegoPlotLGPtr = new TH2D("Homer","HLT: #pi^{0} 5 - 30Gev LG, Low gain",  
160                              N_XCOLUMNS_MOD* N_MODULES , 0, N_XCOLUMNS_MOD* N_MODULES,  
161                              N_ZROWS_MOD,          0, N_ZROWS_MOD);
162   fgLegoPlotLGPtr->SetMaximum( MAX_BIN_VALUE); 
163   fgLegoPlotLGPtr->Reset();
164
165   for(int gain = 0; gain< N_GAINS; gain ++)
166     {
167       sprintf(tmpHistoName, "HLT gain %d", gain);
168       fgCalibHistPtr[gain] = new TH2D(tmpHistoName, tmpHistoName,  
169                                       N_XCOLUMNS_MOD*N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES , 
170                                       N_ZROWS_MOD,         0, N_ZROWS_MOD);
171       fgCalibHistPtr[gain]->Reset(); 
172      
173       sprintf(tmpHistoName, "Calibration Data HLT: #pi^{0} 5 - 30GeV gain %d", gain);
174       fgHitsHistPtr[gain] = new TH2I(tmpHistoName, tmpHistoName,  
175                                     N_XCOLUMNS_MOD* N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES,  
176                                     N_ZROWS_MOD,          0, N_ZROWS_MOD);
177       fgHitsHistPtr[gain]->SetMaximum( MAX_BIN_VALUE); 
178       fgHitsHistPtr[gain]->Reset();
179
180       sprintf(tmpHistoName, "Average Data HLT: #pi^{0} 5 - 30GeV gain %d", gain);
181       fgAveragePtr[gain] = new TH2D(tmpHistoName,tmpHistoName,  
182                                     N_XCOLUMNS_MOD* N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES,  
183                                     N_ZROWS_MOD,          0, N_ZROWS_MOD);
184       fgAveragePtr[gain]->SetMaximum( MAX_BIN_VALUE); 
185       fgAveragePtr[gain]->Reset();
186     }
187
188   char tmpChDtaName[256];
189
190   for(int z = 0; z < N_ZROWS_RCU; z ++)
191     {
192       for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
193         {
194           sprintf(tmpHistoName, "blablaz%d x%d",z, x);
195           fgChannelDataPlotPtr[z][x] = new TH1D(tmpHistoName, tmpHistoName, 300, 0, 299);
196           fgChannelDataPlotPtr[z][x]->SetMaximum(MAX_BIN_VALUE); 
197           fgChannelDataPlotPtr[z][x]->Reset();
198         }
199     }
200
201   gStyle->SetPalette(1);
202   fTab = new TGTab(this, 100, 100);
203   TGLayoutHints *fL1 = new TGLayoutHints(kLHintsBottom | kLHintsExpandX |
204                                          kLHintsExpandY, 2, 2, 15, 1);
205
206   TGCompositeFrame *tf = fTab->AddTab("Event display");
207            fSubTab1 = new TGTab(tf, 100, 100);
208            TGCompositeFrame *tf2 = fSubTab1->AddTab("LEGO");  
209            fSubF1 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
210            fEc1 = new TRootEmbeddedCanvas("ec1", fSubF1, 100, 100);
211            fSubF1->AddFrame(fEc1, fL1);
212            fEc2 = new TRootEmbeddedCanvas("ec2", fSubF1, 100, 100);
213            fSubF1->AddFrame(fEc2, fL1);
214            tf2->AddFrame(fSubF1, fL1);
215
216            tf2 = fSubTab1->AddTab("SCAT"); 
217            fSubF2 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
218            tf2->AddFrame(fSubF2, fL1);
219            fEc3 = new TRootEmbeddedCanvas("ec3", fSubF2, 100, 100);
220            fSubF2->AddFrame(fEc3, fL1);
221            fEc4 = new TRootEmbeddedCanvas("ec4", fSubF2, 100, 100);
222            fSubF2->AddFrame(fEc4, fL1);
223
224            tf2 = fSubTab1->AddTab("SURF"); 
225            fSubF3 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
226            tf2->AddFrame(fSubF3, fL1);
227            fEc5 = new TRootEmbeddedCanvas("ec5", fSubF3, 100, 100);
228            fSubF3->AddFrame(fEc5, fL1);
229            fEc6 = new TRootEmbeddedCanvas("ec6", fSubF3, 100, 100);
230            fSubF3->AddFrame(fEc6, fL1);
231            fSubTab1->Resize();
232            tf->AddFrame(fSubTab1, fL1);
233
234   tf = fTab->AddTab("Calibration data");
235      
236            fSubTab2 = new TGTab(tf, 100, 100);
237
238            tf2 = fSubTab2->AddTab("Accumulated energy");   
239            fSubF4 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
240
241            fEc7 = new TRootEmbeddedCanvas("ec7", fSubF4, 100, 100);
242            fSubF4->AddFrame(fEc7, fL1);
243
244            fEc8 = new TRootEmbeddedCanvas("ec8", fSubF4, 100, 100);
245            fSubF4->AddFrame(fEc8, fL1);
246
247            tf2->AddFrame(fSubF4, fL1);
248            
249            tf2 = fSubTab2->AddTab("SCAT (hits)"); 
250            fSubF5 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
251            tf2->AddFrame(fSubF5, fL1);
252            fEc9 = new TRootEmbeddedCanvas("ec9", fSubF5, 100, 100);
253            fSubF5->AddFrame(fEc9, fL1);
254            fEc10 = new TRootEmbeddedCanvas("ec10", fSubF5, 100, 100);
255            fSubF5->AddFrame(fEc10, fL1);
256
257            tf2 = fSubTab2->AddTab("SURF"); 
258            fSubF6 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
259            tf2->AddFrame(fSubF6, fL1);
260            fEc11 = new TRootEmbeddedCanvas("ec11", fSubF6, 100, 100);
261            fSubF6->AddFrame(fEc11, fL1);
262            fEc12 = new TRootEmbeddedCanvas("ec12", fSubF6, 100, 100);
263            fSubF6->AddFrame(fEc12, fL1);
264
265            tf2 = fSubTab2->AddTab("acummulated energy / hits"); 
266            fSubF7 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
267            tf2->AddFrame(fSubF7, fL1);
268            fEc13 = new TRootEmbeddedCanvas("ec13", fSubF7, 100, 100);
269            fSubF7->AddFrame(fEc13, fL1);
270            fEc14 = new TRootEmbeddedCanvas("ec14", fSubF7, 100, 100);
271            fSubF7->AddFrame(fEc14, fL1);
272
273            fSubTab2->Resize();
274            tf->AddFrame(fSubTab2, fL1);
275
276
277   tf = fTab->AddTab("Raw Data Display");
278
279            fSubTab3 = new TGTab(tf, 100, 100);
280            TGLayoutHints *hints = new TGLayoutHints(kLHintsNormal, 0, 0, 0, 0); 
281
282            char tmpTabName[256];
283            char tmpCanvasName[256];
284                    sprintf(tmpTabName, "Raw data");
285                    tf2 = fSubTab3->AddTab(tmpTabName);
286                    fgEventButtPtr = new  AliHLTPHOSGetEventButton(tf, "Get Rawdata2xxxxx", 'r');
287                    AliHLTPHOSGetEventButton*       EventButtPtr2 = new  AliHLTPHOSGetEventButton(tf, "Get Rawdata", 'r'); 
288                    EventButtPtr2->Move(200, 200); 
289
290   tf = fTab->AddTab("Tab 4");
291
292   AddFrame(fTab, fL1);
293
294   fgEventButtPtr = new  AliHLTPHOSGetEventButton(fSubF1, "get event", 'e');
295   fgEventButtPtr = new  AliHLTPHOSGetEventButton(fSubF4, "update histograms", 'h');
296
297   MapSubwindows();
298   Resize();
299   SetWindowName("online display");
300   MapWindow();
301   MoveResize(100,100,1200,1000);
302 }
303
304
305 int
306 AliHLTPHOSOnlineDisplay::ScanArguments(int argc, char** argv)
307 {
308   for(int i=0; i< MAX_HOSTS; i++)
309     {
310       fgHosts[i] = new char[256];
311     }
312
313   fgPorts = new short unsigned[100];
314
315   Bool_t hostIsSet = kFALSE;
316   Bool_t portIsSet = kFALSE;
317   int iResult=0;
318   TString argument="";
319
320   for (int i=0; i<argc && iResult>=0; i++) 
321     {
322       argument=argv[i];
323       
324       if (argument.IsNull()) 
325         {
326           continue;
327         }
328       
329       if (argument.CompareTo("-sync")==0)
330         {
331           cout << "setting Synchronize to true" << endl;
332           fgSyncronize = kTRUE;
333         }  
334
335       
336       if (argument.CompareTo("-acc")==0)
337         {
338           cout << "setting Accumulate to true" << endl;
339           fgAccumulate = kTRUE;
340         }  
341       
342  
343       if (argument.CompareTo("-host")==0) 
344         {
345           if(i+1 <= argc)
346             {
347               i++;
348               sprintf(fgHosts[fgNHosts],"%s", argv[i]);
349               fgNHosts ++; 
350               hostIsSet = kTRUE; 
351               if(i+1 <= argc)
352                 {
353                   argument=argv[i+1];
354                   if(argument.CompareTo("-port")==0)
355                   {
356                     i++;
357                     if(i+1 <= argc)
358                       {
359                         i++;
360                         fgPorts[fgNPorts] = atoi(argv[i]);      
361                         cout << "A setting port to   " << fgPorts[fgNPorts]  <<endl; 
362                         fgNPorts ++;
363                         portIsSet = kTRUE;
364                       }
365                   }
366                   
367                   else
368                     {
369                       fgPorts[fgNPorts] =  DEFAULT_EVENT_PORT;  
370                       cout << "B setting port to   " << fgPorts[fgNPorts]  <<endl; 
371                       fgNPorts ++;
372                       portIsSet = kTRUE;
373                     }
374                 }
375
376             }
377
378         }
379     }
380
381   if(hostIsSet != kTRUE ||  portIsSet != kTRUE)
382     {
383       if(hostIsSet == kFALSE)
384         {
385           printf("\nERROR: no hostname is specified\n");
386         }
387       
388       if( portIsSet == kFALSE)
389         {
390           printf("ERROR: no port spcified\n");
391         }
392       printf("\nYou must specify at least one host \n\n");
393       printf("*****************************************************************\n");
394       printf("\nUsage: ./onlinedisplay  -host  <hostname>   -port  <port>");
395       printf("\n-port is optional, if not set  port 42001 will be used\n");
396       printf("*****************************************************************\n\n\n");
397       iResult = -1;
398     }
399   
400   else
401     {
402       iResult = 0;
403     }
404
405   return iResult;
406 }//end ScanArguments
407
408
409 int
410 AliHLTPHOSOnlineDisplay::GetNextEvent()
411 {
412   HOMERReader* CurrentReaderPtr;
413
414   if(fgAccumulate == kFALSE)
415     {
416       cout <<"resetting fgLegoplot" << endl;
417       if(fgLegoPlotHGPtr !=0)
418         {
419           fgLegoPlotHGPtr->Reset(); 
420         }
421
422       if(fgLegoPlotLGPtr !=0)
423         {
424           fgLegoPlotLGPtr->Reset();
425         }  
426     }
427
428   int ret = 0;
429   unsigned long ndx;
430   const AliHLTComponentBlockData* iter = NULL;   
431   Bool_t nextSwitch=kTRUE; 
432   cout << "homerreader connectionstatus  =" <<fgHomerReaderPtr->GetConnectionStatus() << endl;;
433
434   int nLoops=0;
435   if(fgSyncronize == kTRUE)
436     {
437       nLoops = 1;
438     }
439   else
440     {
441       nLoops =  fgNHosts; 
442     }
443   
444   for(int reader = 0; reader <  nLoops; reader ++)
445     {
446       if(fgSyncronize == kTRUE)
447         {
448           CurrentReaderPtr =fgHomerReaderPtr;
449         }
450       else
451         {
452           CurrentReaderPtr =fgHomerReadersPtr[reader];
453         }
454       ret =CurrentReaderPtr->ReadNextEvent();  
455       cout << "Event ID =\t " << reader <<" = "<< CurrentReaderPtr->GetEventID() << endl;;
456   
457       if( ret ) 
458         {
459           int ndx = fgHomerReaderPtr->GetErrorConnectionNdx();
460           printf( "------------ TRY AGAIN --------------->Error reading event from source %d: %s (%d)\n", ndx, strerror(ret), ret );
461           cout << "HOMER getconncetioNdx  status = " << ndx << endl;
462           return ret; 
463         }
464   
465       unsigned long blockCnt = CurrentReaderPtr->GetBlockCnt();
466       
467       for ( unsigned long i = 0; i < blockCnt; i++ ) 
468         {
469           char tmp1[9], tmp2[5];
470           memset( tmp1, 0, 9 );
471           memset( tmp2, 0, 5);
472           void *tmp11 = tmp1;
473           ULong64_t* tmp12 = (ULong64_t*)tmp11;
474           *tmp12 =fgHomerReadersPtr[reader]->GetBlockDataType( i );
475           void *tmp21 = tmp2;
476           ULong_t* tmp22 = (ULong_t*)tmp21;
477           *tmp22 = CurrentReaderPtr->GetBlockDataOrigin( i );
478           cout << "Dataype for block:  "<< i<<"  is:  "<< tmp1<<tmp2 <<endl;
479         }
480
481       unsigned long blk = CurrentReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF );
482
483       while ( blk != ~(unsigned long)0 ) 
484         {
485           Int_t moduleID;
486           const AliHLTPHOSRcuCellEnergyDataStruct* cellEnergiesPtr = (const AliHLTPHOSRcuCellEnergyDataStruct*) CurrentReaderPtr->GetBlockData( blk );  
487           moduleID = cellEnergiesPtr->fModuleID ;
488           Int_t tmpCount = cellEnergiesPtr->fCnt;
489           Int_t tmpZ;
490           Int_t tmpX;
491           Int_t tmpGain;
492           
493           //      for(int i= 0; i<tmpCount; i++)
494           for(int i= 0; i <= tmpCount; i++)
495             {
496               tmpZ = cellEnergiesPtr->fValidData[i].fZ;
497               tmpX = cellEnergiesPtr->fValidData[i].fX;
498               tmpGain =  cellEnergiesPtr->fValidData[i].fGain;
499               
500               if(tmpGain == HIGH_GAIN)
501                 {
502                   fgLegoPlotHGPtr->Fill(moduleID*N_XCOLUMNS_MOD + tmpX +  N_XCOLUMNS_RCU*cellEnergiesPtr->fRcuX,  
503                                       tmpZ + N_ZROWS_RCU*cellEnergiesPtr->fRcuZ, cellEnergiesPtr->fValidData[i].fEnergy);
504                 }
505                   
506               else if(tmpGain == LOW_GAIN)
507                 {
508                   fgLegoPlotLGPtr->Fill(moduleID*N_XCOLUMNS_MOD + tmpX +  N_XCOLUMNS_RCU*cellEnergiesPtr->fRcuX,
509                                       tmpZ + N_ZROWS_RCU*cellEnergiesPtr->fRcuZ,    cellEnergiesPtr->fValidData[i].fEnergy);
510                 }
511             }
512                 
513           blk = CurrentReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF, blk+1);
514         }
515     }
516   UpdateDisplay();
517   fgEvntCnt ++;
518 }
519
520 int 
521 AliHLTPHOSOnlineDisplay::GetNextEventRaw()
522 {
523   cout << "AliHLTPHOSOnlineDisplay::GetNextEventRaw():updating RawdataDisplay" << endl;
524   int ret = 0;
525   unsigned long ndx;
526   const AliHLTComponentBlockData* iter = NULL;
527   for(int reader = 0; reader <  fgNHosts; reader ++)
528     {
529       ret = fgChannelRawReadersPtr[reader]->ReadNextEvent();  
530       if( ret ) 
531         {
532           int ndx = fgChannelRawReadersPtr[reader]->GetErrorConnectionNdx();
533           printf( "------------ TRY AGAIN --------------->Error reading event from source %d: %s (%d)\n", ndx, strerror(ret), ret );
534           cout << "HOMER getconncetioNdx  status = " << ndx << endl;
535           return ret; 
536         }
537       
538       unsigned long blockCnt = fgChannelRawReadersPtr[reader]->GetBlockCnt();
539       cout << "AliHLTPHOSOnlineDisplay::NextEventRaw():  blockCnt  = " << blockCnt << endl;
540
541       for ( unsigned long i = 0; i < blockCnt; i++ ) 
542         {
543           char tmp1[9], tmp2[5];
544           memset( tmp1, 0, 9 );
545           memset( tmp2, 0, 5);
546           void *tmp11 = tmp1;
547           ULong64_t* tmp12 = (ULong64_t*)tmp11;
548           *tmp12 =fgChannelRawReadersPtr[reader]->GetBlockDataType( i );
549           void *tmp21 = tmp2;
550           ULong_t* tmp22 = (ULong_t*)tmp21;
551           *tmp22 = fgChannelRawReadersPtr[reader]->GetBlockDataOrigin( i );
552           cout << "Dataype is: "<< tmp1<<"   "<<tmp2 <<endl;
553         }
554       
555       unsigned long blk = fgChannelRawReadersPtr[reader]->FindBlockNdx("ATADNAHC","SOHP", 0xeFFFFFFF );
556
557       while ( blk != ~(unsigned long)0 ) 
558         {
559           cout << ":GetNextEventRaw(): updating block " << endl;
560           AliHLTUInt16_t moduleID;
561           const AliHLTPHOSRcuChannelDataStruct* rcuChannelDataPtr = (const AliHLTPHOSRcuChannelDataStruct*)fgChannelRawReadersPtr[reader]->GetBlockData( blk ); 
562           moduleID = rcuChannelDataPtr->fModuleID ;
563           int tmpx;
564           int tmpz;
565           AliHLTUInt32_t tmpChCnt =0;
566           AliHLTUInt16_t tmpSampleCnt =0;
567
568           tmpChCnt = rcuChannelDataPtr->fNValidChannels;
569           cout << "tmpChCnt = " << tmpChCnt << endl; 
570
571           for( AliHLTUInt32_t ch =0; ch < tmpChCnt; ch ++)
572             {
573               {
574                 tmpz =  rcuChannelDataPtr->fValidData[ch].fZ;
575                 tmpx =  rcuChannelDataPtr->fValidData[ch].fX;   
576                 tmpSampleCnt =  rcuChannelDataPtr->fValidData[ch].fNSamples;
577
578                 for(AliHLTUInt16_t sample =0; sample <tmpSampleCnt; sample ++)
579                   {
580                     if(  rcuChannelDataPtr->fValidData[ch].fGain  == 0)
581                       {
582                         fgChannelDataPlotPtr[tmpz][tmpx]->SetBinContent(sample,  rcuChannelDataPtr->fValidData[ch].fChannelData[sample]);
583                       }
584                   }
585               }
586             }
587
588           blk = fgChannelRawReadersPtr[reader]->FindBlockNdx("ATADNAHC","SOHP", 0xeFFFFFFF, blk+1);
589
590         } 
591     }
592   
593   UpdateChanneRawDataDisplay();
594   fgEvntCnt ++;
595 }
596
597
598
599 int
600 AliHLTPHOSOnlineDisplay::GetHistogram()
601 {
602   fgCalibHistPtr[LOW_GAIN]->Reset(); 
603   fgCalibHistPtr[HIGH_GAIN]->Reset();
604  
605   int ret = 0;
606   unsigned long ndx;
607   const AliHLTComponentBlockData* iter = NULL;   
608   Bool_t nextSwitch=kTRUE; 
609
610   for(int reader = 0; reader <  fgNHosts; reader ++)
611     {
612       ret =fgCalibReadersPtr[reader]->ReadNextEvent(); ;  
613       if( ret ) 
614         {
615           int ndx = fgCalibReadersPtr[reader]->GetErrorConnectionNdx();
616           printf( "------------ TRY AGAIN --------------->Error reading event from source %d: %s (%d)\n", ndx, strerror(ret), ret );
617           cout << "HOMER getconncetioNdx  status = " << ndx << endl;
618           return ret; 
619         }
620       
621       unsigned long blockCnt = fgCalibReadersPtr[reader]->GetBlockCnt();
622       cout << "AliHLTPHOSOnlineDisplay::GetHistogram():  blockCnt  = " << blockCnt << endl;
623
624       for ( unsigned long i = 0; i < blockCnt; i++ ) 
625         {
626           char tmp1[9], tmp2[5];
627           memset( tmp1, 0, 9 );
628           memset( tmp2, 0, 5);
629           void *tmp11 = tmp1;
630           ULong64_t* tmp12 = (ULong64_t*)tmp11;
631           *tmp12 =fgCalibReadersPtr[reader]->GetBlockDataType( i );
632           void *tmp21 = tmp2;
633           ULong_t* tmp22 = (ULong_t*)tmp21;
634           *tmp22 = fgCalibReadersPtr[reader]->GetBlockDataOrigin( i );
635           cout << "Dataype is: "<< tmp1<<"   "<<tmp2 <<endl;
636         }
637       
638       unsigned long blk = fgCalibReadersPtr[reader]->FindBlockNdx("UCCARENE","SOHP", 0xFFFFFFFF );
639       //      int tmpWhileCnt = 0;
640   
641
642
643       while ( blk != ~(unsigned long)0 ) 
644         {
645           cout << "GetHistogram: updating block " << endl;
646           AliHLTUInt16_t moduleID;
647           const AliHLTPHOSRcuCellAccumulatedEnergyDataStruct* accCellEnergiesPtr = (const AliHLTPHOSRcuCellAccumulatedEnergyDataStruct*)fgCalibReadersPtr[reader]->GetBlockData( blk ); 
648           moduleID = accCellEnergiesPtr->fModuleID ;
649           //      int RcuXOffset = (accCellEnergiesPtr->fRcuX)*N_XCOLUMNS_RCU;
650           //      int RcuZOffset = (accCellEnergiesPtr->fRcuZ)*N_ZROWS_RCU;
651           cout << "(X,Z) =" << "("<< (int)accCellEnergiesPtr->fRcuX <<" , " <<  (int)accCellEnergiesPtr->fRcuZ << ") " << endl;
652           
653           int tmpx;
654           int tmpz;
655
656           for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
657             for(int z = 0; z <N_ZROWS_RCU; z ++)
658               {
659                 {
660                   for(int gain = 0; gain < N_GAINS; gain ++)
661                     {
662                       tmpx = moduleID*N_XCOLUMNS_MOD + (accCellEnergiesPtr->fRcuX)*N_XCOLUMNS_RCU + x;
663                       tmpz = (accCellEnergiesPtr->fRcuZ)*N_ZROWS_RCU +z;
664
665                       fgCalibHistPtr[gain]->Fill(tmpx, tmpz, accCellEnergiesPtr->fAccumulatedEnergies[x][z][gain] );
666                       fgHitsHistPtr[gain]->Fill(tmpx, tmpz, accCellEnergiesPtr->fHits[x][z][gain] );
667                       
668                       if(fgHitsHistPtr[gain]->GetBinContent(tmpx, tmpz) > 0)
669                         {
670                           fgAveragePtr[gain]->SetBinContent(tmpx, tmpz, fgCalibHistPtr[gain]->GetBinContent(tmpx, tmpz)/fgHitsHistPtr[gain]->GetBinContent(tmpx, tmpz));
671                         }
672                     }
673                 }
674               }
675
676           blk = fgCalibReadersPtr[reader]->FindBlockNdx("UCCARENE","SOHP", 0xFFFFFFFF, blk+1);
677           //      tmpWhileCnt ++;
678         } 
679     }
680   
681   UpdateHistograms();
682   fgEvntCnt ++;
683 }
684
685
686 void
687 AliHLTPHOSOnlineDisplay::UpdateDisplay()
688 {
689   fgCanvasHGPtr =  fEc1->GetCanvas();
690   fgCanvasHGPtr->cd();
691   fgLegoPlotHGPtr->Draw("LEGO2Z");
692   fgCanvasHGPtr->Update();
693   fgCanvasLGPtr = fEc2->GetCanvas();
694   fgCanvasLGPtr->cd();
695   fgLegoPlotLGPtr->Draw("LEGO2Z");
696   fgCanvasLGPtr->Update();
697
698   fgCanvasHGPtr =  fEc3->GetCanvas();
699   fgCanvasHGPtr->cd();
700   fgLegoPlotHGPtr->Draw("SCAT");
701   fgCanvasHGPtr->Update();
702   fgCanvasLGPtr = fEc4->GetCanvas();
703   fgCanvasLGPtr->cd();
704   fgLegoPlotLGPtr->Draw("SCAT");
705   fgCanvasLGPtr->Update();
706
707   fgCanvasHGPtr =  fEc5->GetCanvas();
708   fgCanvasHGPtr->cd();
709   fgLegoPlotHGPtr->Draw("CONTZ");
710   fgCanvasHGPtr->Update();
711   fgCanvasLGPtr = fEc6->GetCanvas();
712   fgCanvasLGPtr->cd();
713   fgLegoPlotLGPtr->Draw("CONTZ");
714   fgCanvasLGPtr->Update();
715 }
716
717 void
718 AliHLTPHOSOnlineDisplay::UpdateHistograms()
719 {
720   fgCanvasHGPtr =  fEc7->GetCanvas();
721   fgCanvasHGPtr->cd();
722   fgCalibHistPtr[HIGH_GAIN]->Draw("LEGO2Z");
723   fgCanvasHGPtr->Update();
724
725   fgCanvasLGPtr = fEc8->GetCanvas();
726   fgCanvasLGPtr->cd();
727   fgCalibHistPtr[LOW_GAIN]->Draw("LEGO2Z");
728   fgCanvasLGPtr->Update();
729
730   fgCanvasHGPtr =  fEc9->GetCanvas();
731   fgCanvasHGPtr->cd();
732   fgHitsHistPtr[HIGH_GAIN]->Draw("SCAT");
733   fgCanvasHGPtr->Update();
734
735   fgCanvasLGPtr = fEc10->GetCanvas();
736   fgCanvasLGPtr->cd();
737   fgHitsHistPtr[LOW_GAIN]->Draw("SCAT");
738   fgCanvasLGPtr->Update();
739
740   fgCanvasHGPtr =  fEc11->GetCanvas();
741   fgCanvasHGPtr->cd();
742   fgCalibHistPtr[HIGH_GAIN]->Draw("COLZ");
743   fgCanvasHGPtr->Update();
744
745   fgCanvasLGPtr = fEc12->GetCanvas();
746   fgCanvasLGPtr->cd();
747   fgCalibHistPtr[LOW_GAIN]->Draw("COLZ");
748   fgCanvasLGPtr->Update();
749
750
751   fgCanvasLGPtr = fEc13->GetCanvas();
752   fgCanvasLGPtr->cd();
753   fgAveragePtr[HIGH_GAIN]->Draw("COLZ");
754   fgCanvasLGPtr->Update();
755
756   fgCanvasHGPtr = fEc14->GetCanvas();
757   fgCanvasHGPtr->cd();
758   fgAveragePtr[LOW_GAIN]->Draw("COLZ");
759   fgCanvasHGPtr->Update();
760
761 }
762
763
764 void 
765 AliHLTPHOSOnlineDisplay::UpdateChanneRawDataDisplay()
766 {
767   fgTestCanvasPtr = new TCanvas("TEST", "testcanvas", 1200, 1000);  
768   //  fgTestCanvasPtr->Divide(N_ZROWS_RCU, N_XCOLUMNS_RCU, 0, 0);
769   fgTestCanvasPtr->Divide(N_XCOLUMNS_RCU, N_ZROWS_RCU, 0, 0);
770
771   for(int z = 0; z < N_ZROWS_RCU; z ++)
772     {
773       for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
774         {
775           //      fgTestCanvasPtr->cd(x*N_ZROWS_RCU +z + 1);
776           fgTestCanvasPtr->cd(z*N_XCOLUMNS_RCU +x + 1);
777
778           fgChannelDataPlotPtr[z][x]->Draw();
779         } 
780     }
781
782   fgTestCanvasPtr->Update();
783
784 }
785
786
787
788