[u/mrichter/AliRoot.git] / HLT / EMCAL / OnlineDisplay / AliHLTEMCALOnlineDisplayFourierTab.cxx

// $Id: AliHLTEMCALOnlineDisplayFourierTab.cxx 35108 2009-09-30 01:58:37Z phille $

/**************************************************************************
 * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved.      *
 *                                                                        *
 * Authors: Per Thomas Hille for the ALICE                                *
 * offline/HLT Project. Contributors are mentioned in the code where      *
 * appropriate.                                                           *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

#include "AliHLTEMCALOnlineDisplayFourierTab.h"
#include <iostream>
#include "TGFrame.h"
#include "AliHLTEMCALGetEventButton.h"
//#include "AliHLTEMCALCommonDefs.h"
#include "AliHLTDataTypes.h"
#include "AliHLTHOMERData.h"
#include "AliHLTHOMERReader.h"
#include "AliHLTHOMERWriter.h"
//#include "AliHLTEMCALRcuCellEnergyDataStruct.h"
//#include "AliHLTEMCALRcuCellEnergyDataStruct.h"
//#include "AliHLTEMCALRcuCellEnergyDataStruct.h" 
#include "AliHLTEMCALOnlineDisplay.h"

//#include "AliHLTEMCALSharedMemoryInterfacev2.h"
#include "AliHLTEMCALSharedMemoryInterface.h"

#include "AliHLTCaloFourier.h"
#include "AliHLTEMCALOnlineDisplayTH2D.h"


#include "AliHLTCaloRcuFFTDataStruct.h"
#include "TStyle.h"

#define SAMPLINGFREQUENCY 10

using namespace std;

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

//TEveBoxSet* gAliEveBoxSet = 0;

AliHLTEMCALOnlineDisplayFourierTab::AliHLTEMCALOnlineDisplayFourierTab()
{
  // See header file for documentation
  cout << "ERROR: You cannot create a onlinedisplay Tab without arguments" << endl;
}


AliHLTEMCALOnlineDisplayFourierTab::AliHLTEMCALOnlineDisplayFourierTab(AliHLTEMCALOnlineDisplay * const onlineDisplayPtr, TGTab  *tabPtr, 
								     const AliHLTHOMERReader * homerSyncPtr, const AliHLTHOMERReader * const homerPtrs[MAXHOSTS], int nHosts) :  AliHLTEMCALOnlineDisplayTab(), fEvtCnt(0)
{     
  // See header file for documentation
  // gStyle->SetOptLogy();
  // gStyle->SetOptStat(false);
  

  fShmPtr = new AliHLTEMCALSharedMemoryInterface();
  fOnlineDisplayPtr =  onlineDisplayPtr;

  //fFourierPtr = new AliHLTEMCALFourier();
  fFourierPtr = new AliHLTCaloFourier();

  for(int gain = 0; gain < NGAINS; gain ++ )
    {
      fFourierHistoNew[gain] = 0;
      fFourierHistoOld[gain] = 0;
      fFourierHistoAccumulated[gain] = 0;
    }

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

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

    }

  fgNHosts = nHosts;
  InitDisplay(tabPtr);
}


AliHLTEMCALOnlineDisplayFourierTab::~AliHLTEMCALOnlineDisplayFourierTab()

{
  // See header file for documentation
}


int
AliHLTEMCALOnlineDisplayFourierTab::GetNextEvent()
{
  // See header file for documentation
  //  ResetDisplay();
  DoGetNextEvent();
  //  FillHistograms();
  UpdateDisplay();
  fEvtCnt ++;
  // fgEvntCnt ++;

 
}


void 
AliHLTEMCALOnlineDisplayFourierTab::ReadBlockData(AliHLTHOMERReader * const homeReaderPtr)
{ 
  // See header file for documentation
  //  AliHLTEMCALValidCellDataStruct *currentChannel =0;
  cout << "AliHLTEMCALOnlineDisplayFourierTab::ReadBlockDat, Reading block data, therere are " <<  homeReaderPtr->GetBlockCnt() << " blocks " <<endl;
  //  unsigned long blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF );

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

//       cout << "AliHLTEMCALOnlineDisplayFourierTab::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;

// 	  if(cellEnergiesPtr->fHasRawData == true)
// 	    {
// 	      Int_t nSamples = 0;
// 	      Int_t* rawPtr = 0;
// 	      rawPtr = fShmPtr->GetRawData(nSamples);
// 	      fFourierPtr->ProcessFourier(rawPtr, nSamples, tmpZ, tmpX, tmpGain, fEvtCnt);
// 	    }
	  
// 	  currentChannel = fShmPtr->NextChannel();
// 	}
//       blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF, blk+1);
//     }

//  FillHistograms(fFourierPtr->GetPSD(), fFourierPtr->GetDataSize());

  unsigned long blk = homeReaderPtr->FindBlockNdx("TREIRUOF","SOHP", 0x0);
  while ( blk != ~(unsigned long)0 ) 
    {  
      //      AliHLTEMCALRcuFFTDataStruct* fftDataPtr = (AliHLTEMCALRcuFFTDataStruct*)homeReaderPtr->GetBlockData( blk );
      AliHLTCaloRcuFFTDataStruct* fftDataPtr = (AliHLTCaloRcuFFTDataStruct*)homeReaderPtr->GetBlockData( blk );

      FillHistograms(*fftDataPtr, fftDataPtr->fDataLength);

      blk = homeReaderPtr->FindBlockNdx("TREIRUOF","SOHP", blk+1);
    }
}


void 
//AliHLTEMCALOnlineDisplayFourierTab::FillHistograms(const AliHLTEMCALRcuFFTDataStruct psd, const int size)
AliHLTEMCALOnlineDisplayFourierTab::FillHistograms(const AliHLTCaloRcuFFTDataStruct psd, const int size) 
{
  // See header file for documentation
  //  gStyle->SetOptLogy();
  //  gStyle->SetOptStat(false);

  char tmpname[256];
  char tmptitle[256];

  int linewidth = 0;
  // double  linewidth = 1.2;

  for(int gain = 0; gain < NGAINS; gain ++ )
    {
      if( fFourierHistoNew[gain] == 0)
	{
	  sprintf(tmptitle, "PSD averaged over all %s channels: Most recent event", Gain2Text(gain, ' ')); 
	  sprintf(tmpname,  "PSD_averaged_over_all_%s_channels__most_recent_event", Gain2Text(gain, '_'));  
	  fFourierHistoNew[gain] = new TH1D(tmpname, tmptitle,  (size/2) +1, 0, SAMPLINGFREQUENCY/2);
	  fFourierHistoNew[gain]->GetXaxis()->SetTitle("f/MHz");
	  fFourierHistoNew[gain]->GetYaxis()->SetTitle("Power (arbitrary units)"); 
	  fFourierHistoNew[gain]->SetLineWidth(linewidth);

	}
      if (fFourierHistoOld[gain] == 0)
	{
	  sprintf(tmptitle, "PSD averaged over all %s channels: Previous event", Gain2Text(gain, ' ')); 
	  sprintf(tmpname,  "PSD_averaged_over_all_%s_channels__previous_event", Gain2Text(gain, '_')); 
	  fFourierHistoOld[gain] = new TH1D(tmpname, tmptitle,  (size/2) +1, 0, SAMPLINGFREQUENCY/2);
	  fFourierHistoOld[gain]->GetXaxis()->SetTitle("f/MHz");
	  fFourierHistoOld[gain]->GetYaxis()->SetTitle("Power (arbitrary units)"); 
	  fFourierHistoOld[gain]->SetLineWidth(linewidth);

	}
      if( fFourierHistoAccumulated[gain] == 0 )
	{
	  sprintf(tmptitle, "PSD averaged over all %s channels: All events", Gain2Text(gain, ' ')); 
	  sprintf(tmpname,  "PSD_averaged_over_all_%s_channels__All_events", Gain2Text(gain, '_')); 
	  fFourierHistoAccumulated[gain] = new TH1D(tmpname, tmptitle,  (size/2) +1, 0, SAMPLINGFREQUENCY/2);
	  fFourierHistoAccumulated[gain]->GetXaxis()->SetTitle("f/MHz");
	  fFourierHistoAccumulated[gain]->GetYaxis()->SetTitle("Power (arbitrary units)"); 
	  fFourierHistoAccumulated[gain]->SetLineWidth(linewidth);

	}

      //       fFourierHistoNew[gain]->Reset();
      //       fFourierHistoOld[gain]->Reset();
      //       fFourierHistoAccumulated[gain]->Reset();
      
      for(int i = 0; i <size/2; i++)
	{
	  fFourierHistoOld[gain]->SetBinContent(i+1,  fFourierHistoNew[gain]->GetBinContent(i+1));
	  fFourierHistoNew[gain]->SetBinContent(i+1,  psd.fGlobalLastPSD[gain][i] );
	  fFourierHistoAccumulated[gain]->SetBinContent(i+1,  psd.fGlobalAccumulatedPSD[gain][i] );
	}

    }
}


void
AliHLTEMCALOnlineDisplayFourierTab::InitDisplay(TGTab  *tabPtr)
{
  // See header file for documentatino
  for(int gain=0; gain < NGAINS; gain++)
    {
      char gainLabel[100];
      char label[256];
 
      //     Gain2Text
      fOnlineDisplayPtr->Gain2Text(gain,gainLabel);
      sprintf(label, "EMCAL Fourier transform %s", gainLabel);
      fgLegoPlotPtr[gain] = new AliHLTEMCALOnlineDisplayTH2D(fOnlineDisplayPtr, label, label, 
      							    NXCOLUMNSMOD*NMODULES , 0, NXCOLUMNSMOD*NMODULES,  
      							    NZROWSMOD,   0, NZROWSMOD);   
	   //    fgLegoPlotPtr[gain]->SetGain(HIGHGAIN);
      fgLegoPlotPtr[gain]->SetMaximum(1023);
      fgLegoPlotPtr[gain]->Reset();
      fgLegoPlotPtr[gain]->GetXaxis()->SetRange(XRANGESTART, XRANGEEND);
 
   }
  

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

  TGCompositeFrame *tf = tabPtr->AddTab("Power spectrum");
  fSubTab1 = new TGTab(tf, 100, 100);
  TGCompositeFrame *tf2 = fSubTab1->AddTab("Most recent event");  
  fSubF1 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
  fEc1 = new TRootEmbeddedCanvas("ecf1", fSubF1, 100, 100);
  fSubF1->AddFrame(fEc1, fL1);
  fEc2 = new TRootEmbeddedCanvas("ecf2", fSubF1, 100, 100);
  fSubF1->AddFrame(fEc2, fL1);
  tf2->AddFrame(fSubF1, fL1);
  
  tf2 = fSubTab1->AddTab("Previous event"); 
  fSubF2 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
  tf2->AddFrame(fSubF2, fL1);
  fEc3 = new TRootEmbeddedCanvas("ecf3", fSubF2, 100, 100);
  fSubF2->AddFrame(fEc3, fL1);
  fEc4 = new TRootEmbeddedCanvas("ecf4", fSubF2, 100, 100);
  fSubF2->AddFrame(fEc4, fL1);
 
  
  tf2 = fSubTab1->AddTab("Accumulated"); 
  fSubF3 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
  tf2->AddFrame(fSubF3, fL1);
  fEc5 = new TRootEmbeddedCanvas("ecf5", fSubF3, 100, 100);
  fSubF3->AddFrame(fEc5, fL1);
  fEc6 = new TRootEmbeddedCanvas("ecf6", fSubF3, 100, 100);
  fSubF3->AddFrame(fEc6, fL1);
  fSubTab1->Resize();
  tf->AddFrame(fSubTab1, fL1);
  

  fgEventButtPtr = new  AliHLTEMCALGetEventButton(fSubF1, "get fourier", 'e');
}


void
AliHLTEMCALOnlineDisplayFourierTab::UpdateDisplay()
{
  // See header file for documentation
  if( fFourierHistoNew[HIGHGAIN])
    {
      fgCanvasPtr[HIGHGAIN] =  fEc1->GetCanvas();
      fgCanvasPtr[HIGHGAIN]->cd();
      gPad->SetLogy();
      //  fgLegoPlotPtr[HIGHGAIN]->Draw("LGZ");
      fFourierHistoNew[HIGHGAIN]->Draw();
      fgCanvasPtr[HIGHGAIN]->Update();
    }

  if( fFourierHistoNew[LOWGAIN])
    {
      fgCanvasPtr[LOWGAIN] = fEc2->GetCanvas();
      fgCanvasPtr[LOWGAIN]->cd();
      gPad->SetLogy();
      //  fgLegoPlotPtr[LOWGAIN]->Draw("HGZ");
      fFourierHistoNew[LOWGAIN]->Draw();
      fgCanvasPtr[LOWGAIN]->Update();
    }
  if( fFourierHistoOld[HIGHGAIN])
    {
      fgCanvasPtr[HIGHGAIN] =  fEc3->GetCanvas();
      fgCanvasPtr[HIGHGAIN]->cd();
      gPad->SetLogy();
      // fgLegoPlotPtr[HIGHGAIN]->Draw("Low gain");
      fFourierHistoOld[HIGHGAIN]->Draw();
      fgCanvasPtr[HIGHGAIN]->Update();
    }

  if( fFourierHistoOld[LOWGAIN])
    {
      fgCanvasPtr[LOWGAIN] = fEc4->GetCanvas();
      fgCanvasPtr[LOWGAIN]->cd();
      //fgLegoPlotPtr[LOWGAIN]->Draw("High gain");
      gPad->SetLogy();
      fFourierHistoOld[LOWGAIN]->Draw();
      fgCanvasPtr[LOWGAIN]->Update();
    }

  if( fFourierHistoAccumulated[HIGHGAIN])
    {
      fgCanvasPtr[HIGHGAIN] =  fEc5->GetCanvas();
      fgCanvasPtr[HIGHGAIN]->cd();
      gPad->SetLogy();
      fFourierHistoAccumulated[HIGHGAIN]->Draw();
      //  fgLegoPlotPtr[HIGHGAIN]->Draw("CONTZ");
      fgCanvasPtr[HIGHGAIN]->Update();
    }

  if( fFourierHistoAccumulated[LOWGAIN])
    {
      fgCanvasPtr[LOWGAIN] = fEc6->GetCanvas();
      fgCanvasPtr[LOWGAIN]->cd();
      gPad->SetLogy();
      //  fgLegoPlotPtr[LOWGAIN]->Draw("CONTZ");
      fFourierHistoAccumulated[LOWGAIN]->Draw();
      fgCanvasPtr[LOWGAIN]->Update();
    }
  
}


const  char* 
AliHLTEMCALOnlineDisplayFourierTab::Gain2Text(const int gain, const char delimeter)
{
  // See header file for documentation
  if(gain ==  LOWGAIN)
    {
      sprintf(fGainText, "low%cgain", delimeter);

    }
  else if(gain ==  HIGHGAIN)
    {
      sprintf(fGainText, "high%cgain", delimeter);
    }
  else
    {
      sprintf(fGainText, "Error, invalid gain");
    }
  return fGainText;
}
Commit	Line	Data
fcbe44bf	1	// $Id: AliHLTEMCALOnlineDisplayFourierTab.cxx 35108 2009-09-30 01:58:37Z phille $
	2
	3	/**************************************************************************
	4	* Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. *
	5	* *
	6	* Authors: Per Thomas Hille for the ALICE *
	7	* offline/HLT Project. Contributors are mentioned in the code where *
	8	* appropriate. *
	9	* *
	10	* Permission to use, copy, modify and distribute this software and its *
	11	* documentation strictly for non-commercial purposes is hereby granted *
	12	* without fee, provided that the above copyright notice appears in all *
	13	* copies and that both the copyright notice and this permission notice *
	14	* appear in the supporting documentation. The authors make no claims *
	15	* about the suitability of this software for any purpose. It is *
	16	* provided "as is" without express or implied warranty. *
	17	**************************************************************************/
	18
	19	#include "AliHLTEMCALOnlineDisplayFourierTab.h"
	20	#include <iostream>
	21	#include "TGFrame.h"
	22	#include "AliHLTEMCALGetEventButton.h"
	23	//#include "AliHLTEMCALCommonDefs.h"
	24	#include "AliHLTDataTypes.h"
	25	#include "AliHLTHOMERData.h"
	26	#include "AliHLTHOMERReader.h"
	27	#include "AliHLTHOMERWriter.h"
	28	//#include "AliHLTEMCALRcuCellEnergyDataStruct.h"
	29	//#include "AliHLTEMCALRcuCellEnergyDataStruct.h"
	30	//#include "AliHLTEMCALRcuCellEnergyDataStruct.h"
	31	#include "AliHLTEMCALOnlineDisplay.h"
	32
	33	//#include "AliHLTEMCALSharedMemoryInterfacev2.h"
	34	#include "AliHLTEMCALSharedMemoryInterface.h"
	35
	36	#include "AliHLTCaloFourier.h"
	37	#include "AliHLTEMCALOnlineDisplayTH2D.h"
	38
	39
	40	#include "AliHLTCaloRcuFFTDataStruct.h"
	41	#include "TStyle.h"
	42
	43	#define SAMPLINGFREQUENCY 10
	44
	45	using namespace std;
	46
	47	// MT Crap
	48	#include <TMath.h>
	49	//#include <TEveManager.h>
	50	//#include <TEveBoxSet.h>
	51
	52	//TEveBoxSet* gAliEveBoxSet = 0;
	53
	54	AliHLTEMCALOnlineDisplayFourierTab::AliHLTEMCALOnlineDisplayFourierTab()
	55	{
	56	// See header file for documentation
	57	cout << "ERROR: You cannot create a onlinedisplay Tab without arguments" << endl;
	58	}
	59
	60
	61	AliHLTEMCALOnlineDisplayFourierTab::AliHLTEMCALOnlineDisplayFourierTab(AliHLTEMCALOnlineDisplay * const onlineDisplayPtr, TGTab *tabPtr,
	62	const AliHLTHOMERReader * homerSyncPtr, const AliHLTHOMERReader * const homerPtrs[MAXHOSTS], int nHosts) : AliHLTEMCALOnlineDisplayTab(), fEvtCnt(0)
	63	{
	64	// See header file for documentation
65	// gStyle->SetOptLogy();
66	// gStyle->SetOptStat(false);
67
68
69	fShmPtr = new AliHLTEMCALSharedMemoryInterface();
70	fOnlineDisplayPtr = onlineDisplayPtr;
71
72	//fFourierPtr = new AliHLTEMCALFourier();
73	fFourierPtr = new AliHLTCaloFourier();
74
75	for(int gain = 0; gain < NGAINS; gain ++ )
76	{
77	fFourierHistoNew[gain] = 0;
78	fFourierHistoOld[gain] = 0;
79	fFourierHistoAccumulated[gain] = 0;
80	}
81
82	for(int i=0; i<MAXHOSTS; i++)
83	{
84	fgHomerReadersPtr[i] = 0;
85	}
86
87	fgHomerReaderPtr = const_cast<AliHLTHOMERReader*>(homerSyncPtr);
88
89	for(int i=0; i<nHosts; i++)
90	{
91	fgHomerReadersPtr[i] = const_cast<AliHLTHOMERReader*>(homerPtrs[i]);
92
93	}
94
95	fgNHosts = nHosts;
96	InitDisplay(tabPtr);
97	}
98
99
100	AliHLTEMCALOnlineDisplayFourierTab::~AliHLTEMCALOnlineDisplayFourierTab()
101
102	{
103	// See header file for documentation
104	}
105
106
107
108	int
109	AliHLTEMCALOnlineDisplayFourierTab::GetNextEvent()
110	{
111	// See header file for documentation
112	// ResetDisplay();
113	DoGetNextEvent();
114	// FillHistograms();
115	UpdateDisplay();
116	fEvtCnt ++;
117	// fgEvntCnt ++;
118
119
120	}
121
122
123
124	void
125	AliHLTEMCALOnlineDisplayFourierTab::ReadBlockData(AliHLTHOMERReader * const homeReaderPtr)
126	{
127	// See header file for documentation
128	// AliHLTEMCALValidCellDataStruct *currentChannel =0;
129	cout << "AliHLTEMCALOnlineDisplayFourierTab::ReadBlockDat, Reading block data, therere are " << homeReaderPtr->GetBlockCnt() << " blocks " <<endl;
130	// unsigned long blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF );
131
132	// while ( blk != ~(unsigned long)0 )
133	// {
134	// Int_t moduleID;
135	// Int_t rcuX = 0;
136	// Int_t rcuZ = 0;
137	// AliHLTEMCALRcuCellEnergyDataStruct* cellEnergiesPtr = (AliHLTEMCALRcuCellEnergyDataStruct*)homeReaderPtr->GetBlockData( blk );
138
139	// unsigned int t = (unsigned int)cellEnergiesPtr;
140
141	// moduleID = cellEnergiesPtr->fModuleID ;
142	// rcuX = cellEnergiesPtr->fRcuX;
143	// rcuZ = cellEnergiesPtr->fRcuZ;
144
145	// cout << "AliHLTEMCALOnlineDisplayFourierTab::ReadBlockData, fModuleID =" <<moduleID << endl;
146
147	// Int_t tmpZ;
148	// Int_t tmpX;
149	// Int_t tmpGain;
150	// int cnt = 0;
151	// Int_t* tmpPtr = 0;
152
153	// fShmPtr->SetMemory(cellEnergiesPtr);
154	// currentChannel = fShmPtr->NextChannel();
155
156	// while(currentChannel != 0)
157	// {
158	// cnt ++;
159	// tmpZ = currentChannel->fZ;
160	// tmpX = currentChannel->fX;
161	// tmpGain = currentChannel->fGain;
162
163	// if(cellEnergiesPtr->fHasRawData == true)
164	// {
165	// Int_t nSamples = 0;
166	// Int_t* rawPtr = 0;
167	// rawPtr = fShmPtr->GetRawData(nSamples);
168	// fFourierPtr->ProcessFourier(rawPtr, nSamples, tmpZ, tmpX, tmpGain, fEvtCnt);
169	// }
170
171	// currentChannel = fShmPtr->NextChannel();
172	// }
173	// blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF, blk+1);
174	// }
175
176	// FillHistograms(fFourierPtr->GetPSD(), fFourierPtr->GetDataSize());
177
178	unsigned long blk = homeReaderPtr->FindBlockNdx("TREIRUOF","SOHP", 0x0);
179	while ( blk != ~(unsigned long)0 )
180	{
181	// AliHLTEMCALRcuFFTDataStruct* fftDataPtr = (AliHLTEMCALRcuFFTDataStruct*)homeReaderPtr->GetBlockData( blk );
182	AliHLTCaloRcuFFTDataStruct* fftDataPtr = (AliHLTCaloRcuFFTDataStruct*)homeReaderPtr->GetBlockData( blk );
183
184	FillHistograms(*fftDataPtr, fftDataPtr->fDataLength);
185
186	blk = homeReaderPtr->FindBlockNdx("TREIRUOF","SOHP", blk+1);
187	}
188	}
189
190
191
192	void
193	//AliHLTEMCALOnlineDisplayFourierTab::FillHistograms(const AliHLTEMCALRcuFFTDataStruct psd, const int size)
194	AliHLTEMCALOnlineDisplayFourierTab::FillHistograms(const AliHLTCaloRcuFFTDataStruct psd, const int size)
195	{
196	// See header file for documentation
197	// gStyle->SetOptLogy();
198	// gStyle->SetOptStat(false);
199
200	char tmpname[256];
201	char tmptitle[256];
202
203	int linewidth = 0;
204	// double linewidth = 1.2;
205
206	for(int gain = 0; gain < NGAINS; gain ++ )
207	{
208	if( fFourierHistoNew[gain] == 0)
209	{
210	sprintf(tmptitle, "PSD averaged over all %s channels: Most recent event", Gain2Text(gain, ' '));
211	sprintf(tmpname, "PSD_averaged_over_all_%s_channels__most_recent_event", Gain2Text(gain, '_'));
212	fFourierHistoNew[gain] = new TH1D(tmpname, tmptitle, (size/2) +1, 0, SAMPLINGFREQUENCY/2);
213	fFourierHistoNew[gain]->GetXaxis()->SetTitle("f/MHz");
214	fFourierHistoNew[gain]->GetYaxis()->SetTitle("Power (arbitrary units)");
215	fFourierHistoNew[gain]->SetLineWidth(linewidth);
216
217	}
218	if (fFourierHistoOld[gain] == 0)
219	{
220	sprintf(tmptitle, "PSD averaged over all %s channels: Previous event", Gain2Text(gain, ' '));
221	sprintf(tmpname, "PSD_averaged_over_all_%s_channels__previous_event", Gain2Text(gain, '_'));
222	fFourierHistoOld[gain] = new TH1D(tmpname, tmptitle, (size/2) +1, 0, SAMPLINGFREQUENCY/2);
223	fFourierHistoOld[gain]->GetXaxis()->SetTitle("f/MHz");
224	fFourierHistoOld[gain]->GetYaxis()->SetTitle("Power (arbitrary units)");
225	fFourierHistoOld[gain]->SetLineWidth(linewidth);
226
227	}
228	if( fFourierHistoAccumulated[gain] == 0 )
229	{
230	sprintf(tmptitle, "PSD averaged over all %s channels: All events", Gain2Text(gain, ' '));
231	sprintf(tmpname, "PSD_averaged_over_all_%s_channels__All_events", Gain2Text(gain, '_'));
232	fFourierHistoAccumulated[gain] = new TH1D(tmpname, tmptitle, (size/2) +1, 0, SAMPLINGFREQUENCY/2);
233	fFourierHistoAccumulated[gain]->GetXaxis()->SetTitle("f/MHz");
234	fFourierHistoAccumulated[gain]->GetYaxis()->SetTitle("Power (arbitrary units)");
235	fFourierHistoAccumulated[gain]->SetLineWidth(linewidth);
236
237	}
238
239	// fFourierHistoNew[gain]->Reset();
240	// fFourierHistoOld[gain]->Reset();
241	// fFourierHistoAccumulated[gain]->Reset();
242
243	for(int i = 0; i <size/2; i++)
244	{
245	fFourierHistoOld[gain]->SetBinContent(i+1, fFourierHistoNew[gain]->GetBinContent(i+1));
246	fFourierHistoNew[gain]->SetBinContent(i+1, psd.fGlobalLastPSD[gain][i] );
247	fFourierHistoAccumulated[gain]->SetBinContent(i+1, psd.fGlobalAccumulatedPSD[gain][i] );
248	}
249
250	}
251	}
252
253
254
255
256	void
257	AliHLTEMCALOnlineDisplayFourierTab::InitDisplay(TGTab *tabPtr)
258	{
259	// See header file for documentatino
260	for(int gain=0; gain < NGAINS; gain++)
261	{
262	char gainLabel[100];
263	char label[256];
264
265	// Gain2Text
266	fOnlineDisplayPtr->Gain2Text(gain,gainLabel);
267	sprintf(label, "EMCAL Fourier transform %s", gainLabel);
268	fgLegoPlotPtr[gain] = new AliHLTEMCALOnlineDisplayTH2D(fOnlineDisplayPtr, label, label,
269	NXCOLUMNSMODNMODULES , 0, NXCOLUMNSMODNMODULES,
270	NZROWSMOD, 0, NZROWSMOD);
271	// fgLegoPlotPtr[gain]->SetGain(HIGHGAIN);
272	fgLegoPlotPtr[gain]->SetMaximum(1023);
273	fgLegoPlotPtr[gain]->Reset();
274	fgLegoPlotPtr[gain]->GetXaxis()->SetRange(XRANGESTART, XRANGEEND);
275
276	}
277
278
279
280	TGLayoutHints *fL1 = new TGLayoutHints(kLHintsBottom \| kLHintsExpandX \|
281	kLHintsExpandY, 2, 2, 15, 1);
282
283	TGCompositeFrame *tf = tabPtr->AddTab("Power spectrum");
284	fSubTab1 = new TGTab(tf, 100, 100);
285	TGCompositeFrame *tf2 = fSubTab1->AddTab("Most recent event");
286	fSubF1 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
287	fEc1 = new TRootEmbeddedCanvas("ecf1", fSubF1, 100, 100);
288	fSubF1->AddFrame(fEc1, fL1);
289	fEc2 = new TRootEmbeddedCanvas("ecf2", fSubF1, 100, 100);
290	fSubF1->AddFrame(fEc2, fL1);
291	tf2->AddFrame(fSubF1, fL1);
292
293	tf2 = fSubTab1->AddTab("Previous event");
294	fSubF2 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
295	tf2->AddFrame(fSubF2, fL1);
296	fEc3 = new TRootEmbeddedCanvas("ecf3", fSubF2, 100, 100);
297	fSubF2->AddFrame(fEc3, fL1);
298	fEc4 = new TRootEmbeddedCanvas("ecf4", fSubF2, 100, 100);
299	fSubF2->AddFrame(fEc4, fL1);
300
301
302	tf2 = fSubTab1->AddTab("Accumulated");
303	fSubF3 = new TGCompositeFrame(tf2, 60, 20, kVerticalFrame);
304	tf2->AddFrame(fSubF3, fL1);
305	fEc5 = new TRootEmbeddedCanvas("ecf5", fSubF3, 100, 100);
306	fSubF3->AddFrame(fEc5, fL1);
307	fEc6 = new TRootEmbeddedCanvas("ecf6", fSubF3, 100, 100);
308	fSubF3->AddFrame(fEc6, fL1);
309	fSubTab1->Resize();
310	tf->AddFrame(fSubTab1, fL1);
311
312
313	fgEventButtPtr = new AliHLTEMCALGetEventButton(fSubF1, "get fourier", 'e');
314	}
315
316
317
318	void
319	AliHLTEMCALOnlineDisplayFourierTab::UpdateDisplay()
320	{
321	// See header file for documentation
322	if( fFourierHistoNew[HIGHGAIN])
323	{
324	fgCanvasPtr[HIGHGAIN] = fEc1->GetCanvas();
325	fgCanvasPtr[HIGHGAIN]->cd();
326	gPad->SetLogy();
327	// fgLegoPlotPtr[HIGHGAIN]->Draw("LGZ");
328	fFourierHistoNew[HIGHGAIN]->Draw();
329	fgCanvasPtr[HIGHGAIN]->Update();
330	}
331
332	if( fFourierHistoNew[LOWGAIN])
333	{
334	fgCanvasPtr[LOWGAIN] = fEc2->GetCanvas();
335	fgCanvasPtr[LOWGAIN]->cd();
336	gPad->SetLogy();
337	// fgLegoPlotPtr[LOWGAIN]->Draw("HGZ");
338	fFourierHistoNew[LOWGAIN]->Draw();
339	fgCanvasPtr[LOWGAIN]->Update();
340	}
341	if( fFourierHistoOld[HIGHGAIN])
342	{
343	fgCanvasPtr[HIGHGAIN] = fEc3->GetCanvas();
344	fgCanvasPtr[HIGHGAIN]->cd();
345	gPad->SetLogy();
346	// fgLegoPlotPtr[HIGHGAIN]->Draw("Low gain");
347	fFourierHistoOld[HIGHGAIN]->Draw();
348	fgCanvasPtr[HIGHGAIN]->Update();
349	}
350
351	if( fFourierHistoOld[LOWGAIN])
352	{
353	fgCanvasPtr[LOWGAIN] = fEc4->GetCanvas();
354	fgCanvasPtr[LOWGAIN]->cd();
355	//fgLegoPlotPtr[LOWGAIN]->Draw("High gain");
356	gPad->SetLogy();
357	fFourierHistoOld[LOWGAIN]->Draw();
358	fgCanvasPtr[LOWGAIN]->Update();
359	}
360
361	if( fFourierHistoAccumulated[HIGHGAIN])
362	{
363	fgCanvasPtr[HIGHGAIN] = fEc5->GetCanvas();
364	fgCanvasPtr[HIGHGAIN]->cd();
365	gPad->SetLogy();
366	fFourierHistoAccumulated[HIGHGAIN]->Draw();
367	// fgLegoPlotPtr[HIGHGAIN]->Draw("CONTZ");
368	fgCanvasPtr[HIGHGAIN]->Update();
369	}
370
371	if( fFourierHistoAccumulated[LOWGAIN])
372	{
373	fgCanvasPtr[LOWGAIN] = fEc6->GetCanvas();
374	fgCanvasPtr[LOWGAIN]->cd();
375	gPad->SetLogy();
376	// fgLegoPlotPtr[LOWGAIN]->Draw("CONTZ");
377	fFourierHistoAccumulated[LOWGAIN]->Draw();
378	fgCanvasPtr[LOWGAIN]->Update();
379	}
380
381	}
382
383
384	const char*
385	AliHLTEMCALOnlineDisplayFourierTab::Gain2Text(const int gain, const char delimeter)
386	{
387	// See header file for documentation
388	if(gain == LOWGAIN)
389	{
390	sprintf(fGainText, "low%cgain", delimeter);
391
392	}
393	else if(gain == HIGHGAIN)
394	{
395	sprintf(fGainText, "high%cgain", delimeter);
396	}
397	else
398	{
399	sprintf(fGainText, "Error, invalid gain");
400	}
401	return fGainText;
402	}