[u/mrichter/AliRoot.git] / HLT / PHOS / OnlineDisplay / AliHLTPHOSOnlineDisplayEventTab.cxx

#include "AliHLTPHOSOnlineDisplayEventTab.h"
#include <iostream>
#include "TGFrame.h"
#include "AliHLTPHOSGetEventButton.h"
#include "AliHLTPHOSCommonDefs.h"
#include "AliHLTDataTypes.h"
#include "AliHLTHOMERData.h"
#include "AliHLTHOMERReader.h"
#include "AliHLTHOMERWriter.h"
#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
//#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
#include "AliHLTPHOSRcuCellEnergyDataStruct.h" 
#include "AliHLTPHOSOnlineDisplay.h"
#include "AliHLTPHOSSharedMemoryInterface.h"

using namespace std;

// MT Crap
#include <TMath.h>
#include <TEveManager.h>
#include <TEveBoxSet.h>

TEveBoxSet* gAliEveBoxSet = 0;

AliHLTPHOSOnlineDisplayEventTab::AliHLTPHOSOnlineDisplayEventTab()
{
  cout << "ERROR: You cannot create a onlinedisplay Tab without arguments" << endl;
}


AliHLTPHOSOnlineDisplayEventTab::AliHLTPHOSOnlineDisplayEventTab(AliHLTPHOSOnlineDisplay *onlineDisplayPtr, TGTab  *tabPtr, 
								 AliHLTHOMERReader *homerSyncPtr, AliHLTHOMERReader *homerPtrs[MAX_HOSTS], int nHosts) :  AliHLTPHOSOnlineDisplayTab()
{
  fShmPtr = new AliHLTPHOSSharedMemoryInterface();
  fOnlineDisplayPtr =  onlineDisplayPtr;


  for(int gain = 0; gain < N_GAINS; gain ++ )
    {
      fgCanvasPtr[gain] = 0;
      fgLegoPlotPtr[gain] = 0;
 
      for(int mod =0; mod <N_MODULES; mod ++)
	{
	  for(int rcu_x_coord = 0; rcu_x_coord < N_ZRCU_COORD; rcu_x_coord ++)
	    {
	      for(int rcu_z_coord = 0; rcu_z_coord < N_XRCU_COORD; rcu_z_coord ++) 
		{
		  for(int z = 0; z < N_ZROWS_RCU; z ++)
		    {
		      for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
			{
			  fChannelData[mod][rcu_z_coord][rcu_x_coord][x][z][gain] = new int[ALTRO_MAX_SAMPLES];
			  fNChannelSamples[mod][rcu_z_coord][rcu_x_coord][x][z][gain] = 0;
			  fChannelEnergy[mod][rcu_z_coord][rcu_x_coord][x][z][gain] = 0;
			}
		    }	   
		}
	    }
	}
    }

  for(int i=0; i<MAX_HOSTS; i++)
    {
       fgHomerReadersPtr[i] = 0;
    }

  fgHomerReaderPtr = homerSyncPtr;
  
  for(int i=0; i<nHosts; i++)
    {
      fgHomerReadersPtr[i] = homerPtrs[i] ;

    }

  fgNHosts = nHosts;
  InitDisplay(tabPtr);
}


AliHLTPHOSOnlineDisplayEventTab::~AliHLTPHOSOnlineDisplayEventTab()
{

}


Int_t
AliHLTPHOSOnlineDisplayEventTab::GetRawData(TH1D *histPtr, int x, int z, int gain)
{
  int tmpModID = x/64;
  int tmpRcuZ = z/32;
  int tmpRcuX = (x%64)/32;
  int tmpZ = z%28;
  int tmpX = x%32;

  for(int i=0;  i < fNChannelSamples[tmpModID][tmpRcuX][tmpRcuZ][tmpX][tmpZ][gain] ; i++)
    {
      histPtr->SetBinContent(i, fChannelData[tmpModID][tmpRcuX][tmpRcuZ][tmpX][tmpZ][gain][i]);  
    }
  return fNChannelSamples[tmpModID][tmpRcuX][tmpRcuZ][tmpX][tmpZ][gain];
}


int
AliHLTPHOSOnlineDisplayEventTab::GetNextEvent()
{
  ResetDisplay();
  // MT crap
  Bool_t is_first = false;
  if (gAliEveBoxSet == 0)
  {
    is_first = true;
    gAliEveBoxSet = new TEveBoxSet("PHOS module");
    // gAliEveBoxSet->SetSecSelectCommand("Draw()");
    // gAliEveBoxSet->SetSecSelectCommand("phos_histo_draw"); 
    gEve->AddElement(gAliEveBoxSet);
  }
  gAliEveBoxSet->Reset(TEveBoxSet::kBT_AABox, kFALSE, 128);

  DoGetNextEvent();
  UpdateDisplay();

  gAliEveBoxSet->ElementChanged();
  gEve->Redraw3D(is_first);

  fgEvntCnt ++;
}


void
AliHLTPHOSOnlineDisplayEventTab::FindFourierBlocks(AliHLTHOMERReader *homerReaderPtr)
{
 cout << "AliHLTPHOSOnlineDisplayEventTab::FindFourierBlocks" << endl; 
  // unsigned long blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF );
  unsigned long blk = homerReaderPtr->FindBlockNdx(" TREIRUOF","SOHP", 0xFFFFFFFF );

  while ( blk != ~(unsigned long)0 )
    {
      cout << "AliHLTPHOSOnlineDisplayEventTab::FindFourierBlocks(homerReaderPtr) FOUND FOURIER DATA !!!!!!!!!!!!!!" << endl;


      blk = homerReaderPtr->FindBlockNdx("TREIRUOF","SOHP", 0xFFFFFFFF );
    }

}


void 
AliHLTPHOSOnlineDisplayEventTab::ReadBlockData(AliHLTHOMERReader *homeReaderPtr)
{  
  AliHLTPHOSValidCellDataStruct *currentChannel =0;
  cout << "AliHLTPHOSOnlineDisplayEventTab::ReadBlockDat, Reading block data, therere are " <<  homeReaderPtr->GetBlockCnt() << " blocks " <<endl;

  FindFourierBlocks(homeReaderPtr);

  unsigned long blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF );

  //CRAP PT
  //  FindFourierBlocks(homeReaderPtr);

  while ( blk != ~(unsigned long)0 ) 
    {
      Int_t moduleID;
      Int_t rcuX = 0;
      Int_t rcuZ = 0;
      AliHLTPHOSRcuCellEnergyDataStruct* cellEnergiesPtr = (AliHLTPHOSRcuCellEnergyDataStruct*)homeReaderPtr->GetBlockData( blk ); 
      
      unsigned int *t = (unsigned int*)cellEnergiesPtr;
      
      moduleID = cellEnergiesPtr->fModuleID ;
      rcuX = cellEnergiesPtr->fRcuX;
      rcuZ = cellEnergiesPtr->fRcuZ;

      cout << "AliHLTPHOSOnlineDisplayEventTab::ReadBlockData,  fModuleID =" <<moduleID << endl; 

      Int_t tmpZ;
      Int_t tmpX;
      Int_t tmpGain;
      int cnt = 0;
      Int_t* tmpPtr = 0;

      fShmPtr->SetMemory(cellEnergiesPtr);
      currentChannel = fShmPtr->NextChannel();

      while(currentChannel != 0)
	{
	  cnt ++;
	  tmpZ = currentChannel->fZ;
	  tmpX = currentChannel->fX;
	  tmpGain =  currentChannel->fGain;
	  fgLegoPlotPtr[tmpGain]->Fill(moduleID*N_XCOLUMNS_MOD + tmpX +  N_XCOLUMNS_RCU*cellEnergiesPtr->fRcuX,  
				    tmpZ + N_ZROWS_RCU*cellEnergiesPtr->fRcuZ, currentChannel->fEnergy);
	      
	  // CRAP PTH
	  if(tmpGain == HIGH_GAIN)
	    {
	      gAliEveBoxSet->AddBox(2.2*(tmpX + N_XCOLUMNS_RCU*cellEnergiesPtr->fRcuX) - 1.1,
				    0,
				    2.2*(tmpZ + N_ZROWS_RCU*cellEnergiesPtr->fRcuZ) - 1.1,
				    2.2,
				    0.4*140*currentChannel->fEnergy/1024,
				    2.2);
	      gAliEveBoxSet->DigitValue(TMath::Nint(currentChannel->fEnergy));
	    }
 
	  if(cellEnergiesPtr->fHasRawData == true)
	    {
	      Int_t nSamples = 0;
	      Int_t* rawPtr = 0;
	      rawPtr = fShmPtr->GetRawData(nSamples);
	      fNChannelSamples[moduleID][rcuX][rcuZ][tmpX][tmpZ][tmpGain] = nSamples;

	      for(int j= 0; j< nSamples; j++)
		{
		  fChannelData[moduleID][cellEnergiesPtr->fRcuX][cellEnergiesPtr->fRcuZ][tmpX][tmpZ][tmpGain][j] = rawPtr[j];  
		}
	    }
	
	  currentChannel = fShmPtr->NextChannel();
	}
      
      blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF, blk+1);

    }
}


void
AliHLTPHOSOnlineDisplayEventTab::ResetDisplay()
{
  if(fgAccumulate == kFALSE)
    {
      for(int gain=0; gain < N_GAINS; gain++)
	{
	  if(fgLegoPlotPtr[gain] !=0)
	    {
	      fgLegoPlotPtr[gain]->Reset(); 
	    }
	}
    } 
}


void
AliHLTPHOSOnlineDisplayEventTab::InitDisplay(TGTab  *tabPtr)
{
  for(int gain=0; gain < N_GAINS; gain++)
    {
      char gainLabel[100];
      char label[256];
 
      //     Gain2Text
      fOnlineDisplayPtr->Gain2Text(gain,gainLabel);
      sprintf(label, "PHOS HLT Online Display %s", gainLabel);
      fgLegoPlotPtr[gain] = new AliHLTPHOSOnlineDisplayTH2D(fOnlineDisplayPtr, label, label, 
							    N_XCOLUMNS_MOD*N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES,  
							    N_ZROWS_MOD,   0, N_ZROWS_MOD);   
      //   fgLegoPlotPtr[gain]->SetGain(HIGH_GAIN);
      fgLegoPlotPtr[gain]->SetMaximum(1023);
      fgLegoPlotPtr[gain]->Reset();
      fgLegoPlotPtr[gain]->GetXaxis()->SetRange(X_RANGE_START, X_RANGE_END);
    }
  

  TGLayoutHints *fL1 = new TGLayoutHints(kLHintsBottom | kLHintsExpandX |
					 kLHintsExpandY, 2, 2, 15, 1);

  TGCompositeFrame *tf = tabPtr->AddTab("Event display");
  fSubTab1 = new TGTab(tf, 100, 100);
  TGCompositeFrame *tf2 = fSubTab1->AddTab("LEGO");  
  fSubF1 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
  fEc1 = new TRootEmbeddedCanvas("ec1", fSubF1, 100, 100);
  fSubF1->AddFrame(fEc1, fL1);
  fEc2 = new TRootEmbeddedCanvas("ec2", fSubF1, 100, 100);
  fSubF1->AddFrame(fEc2, fL1);
  tf2->AddFrame(fSubF1, fL1);
  
  tf2 = fSubTab1->AddTab("SCAT"); 
  fSubF2 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
  tf2->AddFrame(fSubF2, fL1);
  fEc3 = new TRootEmbeddedCanvas("ec3", fSubF2, 100, 100);
  fSubF2->AddFrame(fEc3, fL1);
  fEc4 = new TRootEmbeddedCanvas("ec4", fSubF2, 100, 100);
  fSubF2->AddFrame(fEc4, fL1);
  
  tf2 = fSubTab1->AddTab("SURF"); 
  fSubF3 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
  tf2->AddFrame(fSubF3, fL1);
  fEc5 = new TRootEmbeddedCanvas("ec5", fSubF3, 100, 100);
  fSubF3->AddFrame(fEc5, fL1);
  fEc6 = new TRootEmbeddedCanvas("ec6", fSubF3, 100, 100);
  fSubF3->AddFrame(fEc6, fL1);
  fSubTab1->Resize();
  tf->AddFrame(fSubTab1, fL1);

  fgEventButtPtr = new  AliHLTPHOSGetEventButton(fSubF1, "get event", 'e');
}


void
AliHLTPHOSOnlineDisplayEventTab::UpdateDisplay()
{
  fgCanvasPtr[HIGH_GAIN] =  fEc1->GetCanvas();
  fgCanvasPtr[HIGH_GAIN]->cd();
  fgLegoPlotPtr[HIGH_GAIN]->Draw("LEGO2Z");
  fgCanvasPtr[HIGH_GAIN]->Update();
  fgCanvasPtr[LOW_GAIN] = fEc2->GetCanvas();
  fgCanvasPtr[LOW_GAIN]->cd();
  fgLegoPlotPtr[LOW_GAIN]->Draw("LEGO2Z");
  fgCanvasPtr[LOW_GAIN]->Update();

  fgCanvasPtr[HIGH_GAIN] =  fEc3->GetCanvas();
  fgCanvasPtr[HIGH_GAIN]->cd();
  fgLegoPlotPtr[HIGH_GAIN]->Draw("SCAT");
  fgCanvasPtr[HIGH_GAIN]->Update();
  fgCanvasPtr[LOW_GAIN] = fEc4->GetCanvas();
  fgCanvasPtr[LOW_GAIN]->cd();
  fgLegoPlotPtr[LOW_GAIN]->Draw("SCAT");
  fgCanvasPtr[LOW_GAIN]->Update();

  fgCanvasPtr[HIGH_GAIN] =  fEc5->GetCanvas();
  fgCanvasPtr[HIGH_GAIN]->cd();
  fgLegoPlotPtr[HIGH_GAIN]->Draw("CONTZ");
  fgCanvasPtr[HIGH_GAIN]->Update();
  fgCanvasPtr[LOW_GAIN] = fEc6->GetCanvas();
  fgCanvasPtr[LOW_GAIN]->cd();
  fgLegoPlotPtr[LOW_GAIN]->Draw("CONTZ");
  fgCanvasPtr[LOW_GAIN]->Update();
}
Commit	Line	Data
	1	#include "AliHLTPHOSOnlineDisplayEventTab.h"
	2	#include <iostream>
	3	#include "TGFrame.h"
	4	#include "AliHLTPHOSGetEventButton.h"
	5	#include "AliHLTPHOSCommonDefs.h"
	6	#include "AliHLTDataTypes.h"
	7	#include "AliHLTHOMERData.h"
	8	#include "AliHLTHOMERReader.h"
	9	#include "AliHLTHOMERWriter.h"
	10	#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
	11	//#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
	12	#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
	13	#include "AliHLTPHOSOnlineDisplay.h"
	14	#include "AliHLTPHOSSharedMemoryInterface.h"
	15
	16	using namespace std;
	17
	18	// MT Crap
	19	#include <TMath.h>
	20	#include <TEveManager.h>
	21	#include <TEveBoxSet.h>
	22
	23	TEveBoxSet* gAliEveBoxSet = 0;
	24
	25	AliHLTPHOSOnlineDisplayEventTab::AliHLTPHOSOnlineDisplayEventTab()
	26	{
	27	cout << "ERROR: You cannot create a onlinedisplay Tab without arguments" << endl;
	28	}
	29
	30
	31	AliHLTPHOSOnlineDisplayEventTab::AliHLTPHOSOnlineDisplayEventTab(AliHLTPHOSOnlineDisplay onlineDisplayPtr, TGTab tabPtr,
	32	AliHLTHOMERReader homerSyncPtr, AliHLTHOMERReader homerPtrs[MAX_HOSTS], int nHosts) : AliHLTPHOSOnlineDisplayTab()
	33	{
	34	fShmPtr = new AliHLTPHOSSharedMemoryInterface();
	35	fOnlineDisplayPtr = onlineDisplayPtr;
	36
	37
	38	for(int gain = 0; gain < N_GAINS; gain ++ )
	39	{
	40	fgCanvasPtr[gain] = 0;
	41	fgLegoPlotPtr[gain] = 0;
	42
	43	for(int mod =0; mod <N_MODULES; mod ++)
	44	{
	45	for(int rcu_x_coord = 0; rcu_x_coord < N_ZRCU_COORD; rcu_x_coord ++)
	46	{
	47	for(int rcu_z_coord = 0; rcu_z_coord < N_XRCU_COORD; rcu_z_coord ++)
	48	{
	49	for(int z = 0; z < N_ZROWS_RCU; z ++)
	50	{
	51	for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
	52	{
	53	fChannelData[mod][rcu_z_coord][rcu_x_coord][x][z][gain] = new int[ALTRO_MAX_SAMPLES];
	54	fNChannelSamples[mod][rcu_z_coord][rcu_x_coord][x][z][gain] = 0;
	55	fChannelEnergy[mod][rcu_z_coord][rcu_x_coord][x][z][gain] = 0;
	56	}
	57	}
	58	}
	59	}
	60	}
	61	}
	62
	63	for(int i=0; i<MAX_HOSTS; i++)
	64	{
	65	fgHomerReadersPtr[i] = 0;
	66	}
	67
	68	fgHomerReaderPtr = homerSyncPtr;
	69
	70	for(int i=0; i<nHosts; i++)
	71	{
	72	fgHomerReadersPtr[i] = homerPtrs[i] ;
	73
	74	}
	75
	76	fgNHosts = nHosts;
	77	InitDisplay(tabPtr);
	78	}
	79
	80
	81	AliHLTPHOSOnlineDisplayEventTab::~AliHLTPHOSOnlineDisplayEventTab()
	82	{
	83
	84	}
	85
	86
	87	Int_t
	88	AliHLTPHOSOnlineDisplayEventTab::GetRawData(TH1D *histPtr, int x, int z, int gain)
	89	{
	90	int tmpModID = x/64;
	91	int tmpRcuZ = z/32;
	92	int tmpRcuX = (x%64)/32;
	93	int tmpZ = z%28;
	94	int tmpX = x%32;
	95
	96	for(int i=0; i < fNChannelSamples[tmpModID][tmpRcuX][tmpRcuZ][tmpX][tmpZ][gain] ; i++)
	97	{
	98	histPtr->SetBinContent(i, fChannelData[tmpModID][tmpRcuX][tmpRcuZ][tmpX][tmpZ][gain][i]);
	99	}
	100	return fNChannelSamples[tmpModID][tmpRcuX][tmpRcuZ][tmpX][tmpZ][gain];
	101	}
	102
	103
	104	int
	105	AliHLTPHOSOnlineDisplayEventTab::GetNextEvent()
	106	{
	107	ResetDisplay();
	108	// MT crap
	109	Bool_t is_first = false;
	110	if (gAliEveBoxSet == 0)
	111	{
	112	is_first = true;
	113	gAliEveBoxSet = new TEveBoxSet("PHOS module");
	114	// gAliEveBoxSet->SetSecSelectCommand("Draw()");
	115	// gAliEveBoxSet->SetSecSelectCommand("phos_histo_draw");
	116	gEve->AddElement(gAliEveBoxSet);
	117	}
	118	gAliEveBoxSet->Reset(TEveBoxSet::kBT_AABox, kFALSE, 128);
	119
	120	DoGetNextEvent();
	121	UpdateDisplay();
	122
	123	gAliEveBoxSet->ElementChanged();
	124	gEve->Redraw3D(is_first);
	125
	126	fgEvntCnt ++;
	127	}
	128
	129
	130	void
	131	AliHLTPHOSOnlineDisplayEventTab::FindFourierBlocks(AliHLTHOMERReader *homerReaderPtr)
	132	{
	133	cout << "AliHLTPHOSOnlineDisplayEventTab::FindFourierBlocks" << endl;
	134	// unsigned long blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF );
	135	unsigned long blk = homerReaderPtr->FindBlockNdx(" TREIRUOF","SOHP", 0xFFFFFFFF );
	136
	137	while ( blk != ~(unsigned long)0 )
	138	{
	139	cout << "AliHLTPHOSOnlineDisplayEventTab::FindFourierBlocks(homerReaderPtr) FOUND FOURIER DATA !!!!!!!!!!!!!!" << endl;
	140
	141
	142	blk = homerReaderPtr->FindBlockNdx("TREIRUOF","SOHP", 0xFFFFFFFF );
	143	}
	144
	145	}
	146
	147
	148	void
	149	AliHLTPHOSOnlineDisplayEventTab::ReadBlockData(AliHLTHOMERReader *homeReaderPtr)
	150	{
	151	AliHLTPHOSValidCellDataStruct *currentChannel =0;
	152	cout << "AliHLTPHOSOnlineDisplayEventTab::ReadBlockDat, Reading block data, therere are " << homeReaderPtr->GetBlockCnt() << " blocks " <<endl;
	153
	154	FindFourierBlocks(homeReaderPtr);
	155
	156	unsigned long blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF );
	157
	158	//CRAP PT
	159	// FindFourierBlocks(homeReaderPtr);
	160
	161	while ( blk != ~(unsigned long)0 )
	162	{
	163	Int_t moduleID;
	164	Int_t rcuX = 0;
	165	Int_t rcuZ = 0;
	166	AliHLTPHOSRcuCellEnergyDataStruct* cellEnergiesPtr = (AliHLTPHOSRcuCellEnergyDataStruct*)homeReaderPtr->GetBlockData( blk );
	167
	168	unsigned int t = (unsigned int)cellEnergiesPtr;
	169
	170	moduleID = cellEnergiesPtr->fModuleID ;
	171	rcuX = cellEnergiesPtr->fRcuX;
	172	rcuZ = cellEnergiesPtr->fRcuZ;
	173
	174	cout << "AliHLTPHOSOnlineDisplayEventTab::ReadBlockData, fModuleID =" <<moduleID << endl;
	175
	176	Int_t tmpZ;
	177	Int_t tmpX;
	178	Int_t tmpGain;
	179	int cnt = 0;
	180	Int_t* tmpPtr = 0;
	181
	182	fShmPtr->SetMemory(cellEnergiesPtr);
	183	currentChannel = fShmPtr->NextChannel();
	184
	185	while(currentChannel != 0)
	186	{
	187	cnt ++;
	188	tmpZ = currentChannel->fZ;
	189	tmpX = currentChannel->fX;
	190	tmpGain = currentChannel->fGain;
	191	fgLegoPlotPtr[tmpGain]->Fill(moduleIDN_XCOLUMNS_MOD + tmpX + N_XCOLUMNS_RCUcellEnergiesPtr->fRcuX,
	192	tmpZ + N_ZROWS_RCU*cellEnergiesPtr->fRcuZ, currentChannel->fEnergy);
	193
	194	// CRAP PTH
	195	if(tmpGain == HIGH_GAIN)
	196	{
	197	gAliEveBoxSet->AddBox(2.2(tmpX + N_XCOLUMNS_RCUcellEnergiesPtr->fRcuX) - 1.1,
	198	0,
	199	2.2(tmpZ + N_ZROWS_RCUcellEnergiesPtr->fRcuZ) - 1.1,
	200	2.2,
	201	0.4140currentChannel->fEnergy/1024,
	202	2.2);
	203	gAliEveBoxSet->DigitValue(TMath::Nint(currentChannel->fEnergy));
	204	}
	205
	206	if(cellEnergiesPtr->fHasRawData == true)
	207	{
	208	Int_t nSamples = 0;
	209	Int_t* rawPtr = 0;
	210	rawPtr = fShmPtr->GetRawData(nSamples);
	211	fNChannelSamples[moduleID][rcuX][rcuZ][tmpX][tmpZ][tmpGain] = nSamples;
	212
	213	for(int j= 0; j< nSamples; j++)
	214	{
	215	fChannelData[moduleID][cellEnergiesPtr->fRcuX][cellEnergiesPtr->fRcuZ][tmpX][tmpZ][tmpGain][j] = rawPtr[j];
	216	}
	217	}
	218
	219	currentChannel = fShmPtr->NextChannel();
	220	}
	221
	222	blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF, blk+1);
	223
	224	}
	225	}
	226
	227
	228
	229
	230	void
	231	AliHLTPHOSOnlineDisplayEventTab::ResetDisplay()
	232	{
	233	if(fgAccumulate == kFALSE)
	234	{
	235	for(int gain=0; gain < N_GAINS; gain++)
	236	{
	237	if(fgLegoPlotPtr[gain] !=0)
	238	{
	239	fgLegoPlotPtr[gain]->Reset();
	240	}
	241	}
	242	}
	243	}
	244
	245
	246	void
	247	AliHLTPHOSOnlineDisplayEventTab::InitDisplay(TGTab *tabPtr)
	248	{
	249	for(int gain=0; gain < N_GAINS; gain++)
	250	{
	251	char gainLabel[100];
	252	char label[256];
	253
	254	// Gain2Text
	255	fOnlineDisplayPtr->Gain2Text(gain,gainLabel);
	256	sprintf(label, "PHOS HLT Online Display %s", gainLabel);
	257	fgLegoPlotPtr[gain] = new AliHLTPHOSOnlineDisplayTH2D(fOnlineDisplayPtr, label, label,
	258	N_XCOLUMNS_MODN_MODULES , 0, N_XCOLUMNS_MODN_MODULES,
	259	N_ZROWS_MOD, 0, N_ZROWS_MOD);
	260	// fgLegoPlotPtr[gain]->SetGain(HIGH_GAIN);
	261	fgLegoPlotPtr[gain]->SetMaximum(1023);
	262	fgLegoPlotPtr[gain]->Reset();
	263	fgLegoPlotPtr[gain]->GetXaxis()->SetRange(X_RANGE_START, X_RANGE_END);
	264	}
	265
	266
	267	TGLayoutHints *fL1 = new TGLayoutHints(kLHintsBottom \| kLHintsExpandX \|
	268	kLHintsExpandY, 2, 2, 15, 1);
	269
	270	TGCompositeFrame *tf = tabPtr->AddTab("Event display");
	271	fSubTab1 = new TGTab(tf, 100, 100);
	272	TGCompositeFrame *tf2 = fSubTab1->AddTab("LEGO");
	273	fSubF1 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
	274	fEc1 = new TRootEmbeddedCanvas("ec1", fSubF1, 100, 100);
	275	fSubF1->AddFrame(fEc1, fL1);
	276	fEc2 = new TRootEmbeddedCanvas("ec2", fSubF1, 100, 100);
	277	fSubF1->AddFrame(fEc2, fL1);
	278	tf2->AddFrame(fSubF1, fL1);
	279
	280	tf2 = fSubTab1->AddTab("SCAT");
	281	fSubF2 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
	282	tf2->AddFrame(fSubF2, fL1);
	283	fEc3 = new TRootEmbeddedCanvas("ec3", fSubF2, 100, 100);
	284	fSubF2->AddFrame(fEc3, fL1);
	285	fEc4 = new TRootEmbeddedCanvas("ec4", fSubF2, 100, 100);
	286	fSubF2->AddFrame(fEc4, fL1);
	287
	288	tf2 = fSubTab1->AddTab("SURF");
	289	fSubF3 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
	290	tf2->AddFrame(fSubF3, fL1);
	291	fEc5 = new TRootEmbeddedCanvas("ec5", fSubF3, 100, 100);
	292	fSubF3->AddFrame(fEc5, fL1);
	293	fEc6 = new TRootEmbeddedCanvas("ec6", fSubF3, 100, 100);
	294	fSubF3->AddFrame(fEc6, fL1);
	295	fSubTab1->Resize();
	296	tf->AddFrame(fSubTab1, fL1);
	297
	298	fgEventButtPtr = new AliHLTPHOSGetEventButton(fSubF1, "get event", 'e');
	299	}
	300
	301
	302
	303	void
	304	AliHLTPHOSOnlineDisplayEventTab::UpdateDisplay()
	305	{
	306	fgCanvasPtr[HIGH_GAIN] = fEc1->GetCanvas();
	307	fgCanvasPtr[HIGH_GAIN]->cd();
	308	fgLegoPlotPtr[HIGH_GAIN]->Draw("LEGO2Z");
	309	fgCanvasPtr[HIGH_GAIN]->Update();
	310	fgCanvasPtr[LOW_GAIN] = fEc2->GetCanvas();
	311	fgCanvasPtr[LOW_GAIN]->cd();
	312	fgLegoPlotPtr[LOW_GAIN]->Draw("LEGO2Z");
	313	fgCanvasPtr[LOW_GAIN]->Update();
	314
	315	fgCanvasPtr[HIGH_GAIN] = fEc3->GetCanvas();
	316	fgCanvasPtr[HIGH_GAIN]->cd();
	317	fgLegoPlotPtr[HIGH_GAIN]->Draw("SCAT");
	318	fgCanvasPtr[HIGH_GAIN]->Update();
	319	fgCanvasPtr[LOW_GAIN] = fEc4->GetCanvas();
	320	fgCanvasPtr[LOW_GAIN]->cd();
	321	fgLegoPlotPtr[LOW_GAIN]->Draw("SCAT");
	322	fgCanvasPtr[LOW_GAIN]->Update();
	323
	324	fgCanvasPtr[HIGH_GAIN] = fEc5->GetCanvas();
	325	fgCanvasPtr[HIGH_GAIN]->cd();
	326	fgLegoPlotPtr[HIGH_GAIN]->Draw("CONTZ");
	327	fgCanvasPtr[HIGH_GAIN]->Update();
	328	fgCanvasPtr[LOW_GAIN] = fEc6->GetCanvas();
	329	fgCanvasPtr[LOW_GAIN]->cd();
	330	fgLegoPlotPtr[LOW_GAIN]->Draw("CONTZ");
	331	fgCanvasPtr[LOW_GAIN]->Update();
	332	}