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

// $Id: AliHLTEMCALOnlineDisplayTH2D.cxx 34906 2009-09-21 11:28:15Z odjuvsla $

/**************************************************************************
 * This file is property of and copyright by the Experimental Nuclear     *
 * Physics Group, Dep. of Physics                                         *
 * University of Oslo, Norway, 2007                                       *
 *                                                                        *
 * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
 * Contributors are mentioned in the code where appropriate.              *
 * Please report bugs to perthi@fys.uio.no                                *
 *                                                                        *
 * 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 "AliHLTEMCALOnlineDisplayTH2D.h"
#include "AliHLTEMCALOnlineDisplay.h"
#include "AliHLTEMCALOnlineDisplayEventTab.h"
//#include "AliHLTEMCALBase.h"

#include <iostream>

using namespace std;

// #define PX_MIN 85
// #define PX_MAX 688
// #define PZ_MIN 60
// #define PZ_MAX 380

/*
#define PXMIN 55
#define PXMAX 420
#define PZMIN 34
#define PZMAX 251
*/

AliHLTEMCALOnlineDisplayTH2D::AliHLTEMCALOnlineDisplayTH2D()
{

}


AliHLTEMCALOnlineDisplayTH2D::AliHLTEMCALOnlineDisplayTH2D(AliHLTEMCALOnlineDisplay *onlineDisplayPtr, const char* name, 
							 const char* title, Int_t nbinsx, 
							 Double_t xlow, Double_t xup, Int_t nbinsy, 
							 Double_t ylow, Double_t yup) : TH2D(name, title, nbinsx, 
											     xlow, xup, nbinsy, 
											     ylow, yup),
											fRunNumber(0) 
											//		fIsSetRunNumber(false)
{
  fOnlineDisplayPtr = onlineDisplayPtr;
}


AliHLTEMCALOnlineDisplayTH2D::~AliHLTEMCALOnlineDisplayTH2D()
{
  
}


/*
  void
  AliHLTEMCAL2DHistogram::ExecuteEvent(Int_t event, Int_t px, Int_t pz)
  {
  if(event == 61) // CRAP PTH, use root enumerator instead 
  {
  int zbin;
  int xbin;
  EvaluateBinPosition( GetObjectInfo(px, pz),  &zbin, &xbin);
  printf("\nThe bin that was double clicked was z = %d, x = %d\n", zbin, xbin);
 
  HandleDoubleClick(zbin, xbin);
  }
}
*/

void
AliHLTEMCALOnlineDisplayTH2D::EvaluateBinPosition(const char *info, int *z, int *x)
{
  float zpos;
  float xpos;
  float bincnt;
  sscanf(info,"(x=%f, y=%f, binx=%d, biny=%d, binc=%2.4f)\n", &zpos, &xpos, z, x, &bincnt);
  cout << __FILE__ << ":" << __LINE__ <<": z= "<< *z <<", x="<< *x <<", zpos = " << zpos <<", xpos ="<< xpos << ", bincnt = "<< bincnt  << endl; 
  
  
}


void
AliHLTEMCALOnlineDisplayTH2D::ExecuteEvent(Int_t event, Int_t px, Int_t pz)
{
  int zbin;
  int xbin;

  if(event == 61)
    {
      EvaluateBinPosition( GetObjectInfo(px, pz),  &zbin, &xbin);

      for(int gain = 0; gain < NGAINS; gain++)
	{
	  cout << __FILE__ << ":" << __LINE__ << ": zbin =" << zbin <<", xbin ="<< xbin << endl; 
	  char gainLabel[100];
	  char label[256];
	  fOnlineDisplayPtr->Gain2Text(gain,gainLabel);
	  sprintf(label, "%s_EMCAL_HLT_Online_rawdatadisplay",gainLabel);
	  fgRawDataCanvasPtr[gain] = new TCanvas(label, label, 1200, 1000); ;
	  fgRawDataCanvasPtr[gain]->Divide(ZROWS, XCOLS); 

	  int cnt = 0;
    
	  for(int z= 1; z > -2; z--)
	    {
	      for(int x=-1; x < XCOLS -1; x ++)
		{
		  fOnlineDisplayPtr->Gain2Text(gain,gainLabel);

		  if( fRunNumber >= 0)
		    {
		      sprintf(label, "(z = %d, x = %d) %s , run %d",  zbin + z, (xbin + x)%64 , gainLabel, fRunNumber);
		    }
		  else
		    {
		      sprintf(label, "(z = %d, x = %d) %s, unknow run number",  zbin + z, ( xbin + x)%64,  gainLabel); 
		    }


		  cnt ++;
		  fgRawDataPlotsPtr[cnt][gain] = new TH1D(label, label, ALTROMAXSAMPLES, 0, ALTROMAXSAMPLES -1);
		  fgRawDataCanvasPtr[gain]->cd(cnt);	 
		  fgRawDataPlotsPtr[cnt][gain]->SetFillColor(1);
		  fgRawDataPlotsPtr[cnt][gain]->Reset();   
		  Int_t nSamples = fOnlineDisplayPtr->fgEventTabPtr->GetRawData( fgRawDataPlotsPtr[cnt][gain], xbin +x, zbin +z, gain); 
		  fgRawDataPlotsPtr[cnt][gain]->GetXaxis()->SetRangeUser(0, nSamples);
		  fgRawDataPlotsPtr[cnt][gain]->GetYaxis()->SetRangeUser(fgRawDataPlotsPtr[cnt][gain]->GetMinimum() - fgRawDataPlotsPtr[cnt][gain]->GetMinimum()*0.1, fgRawDataPlotsPtr[cnt][gain]->GetMaximum() + fgRawDataPlotsPtr[cnt][gain]->GetMaximum()*0.1 + 5); 
		  fgRawDataPlotsPtr[cnt][gain]->SetXTitle("Time / samples");
		  fgRawDataPlotsPtr[cnt][gain]->SetYTitle("Amplitude / ADC counts");
		  fgRawDataPlotsPtr[cnt][gain]->Draw();
		}
	    }

	  sprintf(label, "%s_EMCAL_HLT__Online_rawdatadisplay",gainLabel);
	  fgRawDataCanvasSinglePtr[gain] = new TCanvas(label, label, 1200, 1000); ;  
	  fgRawDataCanvasSinglePtr[gain]->cd();
	  //	  sprintf(label, "Z_%d_X_%d__%s",  tmpZBin, tmpXBin, gainLabel);

	  
	  if( fRunNumber >= 0)
	    {
	      sprintf(label, "(z = %d, x = %d) %s , run %d", zbin , xbin%64, gainLabel, fRunNumber);
	    }
	  else
	    {
	      sprintf(label, "(z = %d, x = %d) %s, unknow run number", zbin , xbin%64, gainLabel); 
	    }


	  fgRawDataPlotsSinglePtr[gain] = new TH1D(label, label, ALTROMAXSAMPLES, 0, ALTROMAXSAMPLES -1);
	  fgRawDataPlotsSinglePtr[gain]->SetFillColor(1);
	  fgRawDataPlotsSinglePtr[gain]->Reset();   
	  Int_t nSamples = fOnlineDisplayPtr->fgEventTabPtr->GetRawData(fgRawDataPlotsSinglePtr[gain], xbin, zbin , gain); 
	  fgRawDataPlotsSinglePtr[gain]->GetXaxis()->SetRangeUser(0, nSamples - 1);
	  fgRawDataPlotsSinglePtr[gain]->GetYaxis()->SetRangeUser(fgRawDataPlotsSinglePtr[gain]->GetMinimum() - fgRawDataPlotsSinglePtr[gain]->GetMinimum()*0.1, fgRawDataPlotsSinglePtr[gain]->GetMaximum() + fgRawDataPlotsSinglePtr[gain]->GetMaximum()*0.1 + 5); 
	  //SetXTitle(const char* title)
	  fgRawDataPlotsSinglePtr[gain]->SetXTitle("Time/samples");
	  fgRawDataPlotsSinglePtr[gain]->SetYTitle("Amplitude/ADC counts");

	  fgRawDataPlotsSinglePtr[gain]->Draw();

		  //	      fgRawDataPlotsPtr[cnt]->GetYaxis()->SetRangeUser(-30, fgRawDataPlotsPtr[cnt]->GetMaximum() + fgRawDataPlotsPtr[cnt]->GetMaximum()*0.1 + 5); 

	  fgRawDataCanvasPtr[gain]->Update();
	  
	}
    }
}


/*
int
AliHLTEMCALOnlineDisplayTH2D::GetXBin(Int_t px)
{
  float tmpBinRange = GetXaxis()->GetLast() -  GetXaxis()->GetFirst();
  float tmpPixelRange =   PXMAX  -   PXMIN;
  float tmpPixRelative = (px - PXMIN)/tmpPixelRange ;
  int xBin = ((int)((tmpPixRelative)*tmpBinRange) +  (float)GetXaxis()->GetFirst());
  return xBin;
}

int
AliHLTEMCALOnlineDisplayTH2D::GetZBin(Int_t pz)
{
  float tmpBinRange = GetYaxis()->GetLast() -  GetYaxis()->GetFirst();
  float tmpPixelRange =   PZMAX  -   PZMIN;
  float tmpPixRelative = (pz - PZMIN)/tmpPixelRange;
  int zBin = (int)((1-tmpPixRelative)*tmpBinRange);
  return zBin;
}
*/
Commit	Line	Data
fcbe44bf	1	// $Id: AliHLTEMCALOnlineDisplayTH2D.cxx 34906 2009-09-21 11:28:15Z odjuvsla $
	2
	3	/**************************************************************************
	4	* This file is property of and copyright by the Experimental Nuclear *
	5	* Physics Group, Dep. of Physics *
	6	* University of Oslo, Norway, 2007 *
	7	* *
	8	* Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
	9	* Contributors are mentioned in the code where appropriate. *
	10	* Please report bugs to perthi@fys.uio.no *
	11	* *
	12	* Permission to use, copy, modify and distribute this software and its *
	13	* documentation strictly for non-commercial purposes is hereby granted *
	14	* without fee, provided that the above copyright notice appears in all *
	15	* copies and that both the copyright notice and this permission notice *
	16	* appear in the supporting documentation. The authors make no claims *
	17	* about the suitability of this software for any purpose. It is *
	18	* provided "as is" without express or implied warranty. *
	19	**************************************************************************/
	20	#include "AliHLTEMCALOnlineDisplayTH2D.h"
	21	#include "AliHLTEMCALOnlineDisplay.h"
	22	#include "AliHLTEMCALOnlineDisplayEventTab.h"
	23	//#include "AliHLTEMCALBase.h"
	24
	25	#include <iostream>
	26
	27	using namespace std;
	28
	29	// #define PX_MIN 85
	30	// #define PX_MAX 688
	31	// #define PZ_MIN 60
	32	// #define PZ_MAX 380
	33
	34	/*
	35	#define PXMIN 55
	36	#define PXMAX 420
	37	#define PZMIN 34
	38	#define PZMAX 251
	39	*/
	40
	41	AliHLTEMCALOnlineDisplayTH2D::AliHLTEMCALOnlineDisplayTH2D()
	42	{
	43
	44	}
	45
	46
	47	AliHLTEMCALOnlineDisplayTH2D::AliHLTEMCALOnlineDisplayTH2D(AliHLTEMCALOnlineDisplay onlineDisplayPtr, const char name,
	48	const char* title, Int_t nbinsx,
	49	Double_t xlow, Double_t xup, Int_t nbinsy,
	50	Double_t ylow, Double_t yup) : TH2D(name, title, nbinsx,
	51	xlow, xup, nbinsy,
	52	ylow, yup),
	53	fRunNumber(0)
	54	// fIsSetRunNumber(false)
	55	{
	56	fOnlineDisplayPtr = onlineDisplayPtr;
	57	}
	58
	59
	60	AliHLTEMCALOnlineDisplayTH2D::~AliHLTEMCALOnlineDisplayTH2D()
	61	{
	62
	63	}
	64
65
66	/*
67	void
68	AliHLTEMCAL2DHistogram::ExecuteEvent(Int_t event, Int_t px, Int_t pz)
69	{
70	if(event == 61) // CRAP PTH, use root enumerator instead
71	{
72	int zbin;
73	int xbin;
74	EvaluateBinPosition( GetObjectInfo(px, pz), &zbin, &xbin);
75	printf("\nThe bin that was double clicked was z = %d, x = %d\n", zbin, xbin);
76
77	HandleDoubleClick(zbin, xbin);
78	}
79	}
80	*/
81
82	void
83	AliHLTEMCALOnlineDisplayTH2D::EvaluateBinPosition(const char info, int z, int *x)
84	{
85	float zpos;
86	float xpos;
87	float bincnt;
88	sscanf(info,"(x=%f, y=%f, binx=%d, biny=%d, binc=%2.4f)\n", &zpos, &xpos, z, x, &bincnt);
89	cout << __FILE__ << ":" << __LINE__ <<": z= "<< z <<", x="<< x <<", zpos = " << zpos <<", xpos ="<< xpos << ", bincnt = "<< bincnt << endl;
90
91
92
93	}
94
95
96	void
97	AliHLTEMCALOnlineDisplayTH2D::ExecuteEvent(Int_t event, Int_t px, Int_t pz)
98	{
99	int zbin;
100	int xbin;
101
102	if(event == 61)
103	{
104	EvaluateBinPosition( GetObjectInfo(px, pz), &zbin, &xbin);
105
106	for(int gain = 0; gain < NGAINS; gain++)
107	{
108	cout << __FILE__ << ":" << __LINE__ << ": zbin =" << zbin <<", xbin ="<< xbin << endl;
109	char gainLabel[100];
110	char label[256];
111	fOnlineDisplayPtr->Gain2Text(gain,gainLabel);
112	sprintf(label, "%s_EMCAL_HLT_Online_rawdatadisplay",gainLabel);
113	fgRawDataCanvasPtr[gain] = new TCanvas(label, label, 1200, 1000); ;
114	fgRawDataCanvasPtr[gain]->Divide(ZROWS, XCOLS);
115
116	int cnt = 0;
117
118	for(int z= 1; z > -2; z--)
119	{
120	for(int x=-1; x < XCOLS -1; x ++)
121	{
122	fOnlineDisplayPtr->Gain2Text(gain,gainLabel);
123
124	if( fRunNumber >= 0)
125	{
126	sprintf(label, "(z = %d, x = %d) %s , run %d", zbin + z, (xbin + x)%64 , gainLabel, fRunNumber);
127	}
128	else
129	{
130	sprintf(label, "(z = %d, x = %d) %s, unknow run number", zbin + z, ( xbin + x)%64, gainLabel);
131	}
132
133
134	cnt ++;
135	fgRawDataPlotsPtr[cnt][gain] = new TH1D(label, label, ALTROMAXSAMPLES, 0, ALTROMAXSAMPLES -1);
136	fgRawDataCanvasPtr[gain]->cd(cnt);
137	fgRawDataPlotsPtr[cnt][gain]->SetFillColor(1);
138	fgRawDataPlotsPtr[cnt][gain]->Reset();
139	Int_t nSamples = fOnlineDisplayPtr->fgEventTabPtr->GetRawData( fgRawDataPlotsPtr[cnt][gain], xbin +x, zbin +z, gain);
140	fgRawDataPlotsPtr[cnt][gain]->GetXaxis()->SetRangeUser(0, nSamples);
141	fgRawDataPlotsPtr[cnt][gain]->GetYaxis()->SetRangeUser(fgRawDataPlotsPtr[cnt][gain]->GetMinimum() - fgRawDataPlotsPtr[cnt][gain]->GetMinimum()0.1, fgRawDataPlotsPtr[cnt][gain]->GetMaximum() + fgRawDataPlotsPtr[cnt][gain]->GetMaximum()0.1 + 5);
142	fgRawDataPlotsPtr[cnt][gain]->SetXTitle("Time / samples");
143	fgRawDataPlotsPtr[cnt][gain]->SetYTitle("Amplitude / ADC counts");
144	fgRawDataPlotsPtr[cnt][gain]->Draw();
145	}
146	}
147
148	sprintf(label, "%s_EMCAL_HLT__Online_rawdatadisplay",gainLabel);
149	fgRawDataCanvasSinglePtr[gain] = new TCanvas(label, label, 1200, 1000); ;
150	fgRawDataCanvasSinglePtr[gain]->cd();
151	// sprintf(label, "Z_%d_X_%d__%s", tmpZBin, tmpXBin, gainLabel);
152
153
154	if( fRunNumber >= 0)
155	{
156	sprintf(label, "(z = %d, x = %d) %s , run %d", zbin , xbin%64, gainLabel, fRunNumber);
157	}
158	else
159	{
160	sprintf(label, "(z = %d, x = %d) %s, unknow run number", zbin , xbin%64, gainLabel);
161	}
162
163
164
165	fgRawDataPlotsSinglePtr[gain] = new TH1D(label, label, ALTROMAXSAMPLES, 0, ALTROMAXSAMPLES -1);
166	fgRawDataPlotsSinglePtr[gain]->SetFillColor(1);
167	fgRawDataPlotsSinglePtr[gain]->Reset();
168	Int_t nSamples = fOnlineDisplayPtr->fgEventTabPtr->GetRawData(fgRawDataPlotsSinglePtr[gain], xbin, zbin , gain);
169	fgRawDataPlotsSinglePtr[gain]->GetXaxis()->SetRangeUser(0, nSamples - 1);
170	fgRawDataPlotsSinglePtr[gain]->GetYaxis()->SetRangeUser(fgRawDataPlotsSinglePtr[gain]->GetMinimum() - fgRawDataPlotsSinglePtr[gain]->GetMinimum()0.1, fgRawDataPlotsSinglePtr[gain]->GetMaximum() + fgRawDataPlotsSinglePtr[gain]->GetMaximum()0.1 + 5);
171	//SetXTitle(const char* title)
172	fgRawDataPlotsSinglePtr[gain]->SetXTitle("Time/samples");
173	fgRawDataPlotsSinglePtr[gain]->SetYTitle("Amplitude/ADC counts");
174
175	fgRawDataPlotsSinglePtr[gain]->Draw();
176
177	// fgRawDataPlotsPtr[cnt]->GetYaxis()->SetRangeUser(-30, fgRawDataPlotsPtr[cnt]->GetMaximum() + fgRawDataPlotsPtr[cnt]->GetMaximum()*0.1 + 5);
178
179	fgRawDataCanvasPtr[gain]->Update();
180
181	}
182	}
183	}
184
185
186
187	/*
188	int
189	AliHLTEMCALOnlineDisplayTH2D::GetXBin(Int_t px)
190	{
191	float tmpBinRange = GetXaxis()->GetLast() - GetXaxis()->GetFirst();
192	float tmpPixelRange = PXMAX - PXMIN;
193	float tmpPixRelative = (px - PXMIN)/tmpPixelRange ;
194	int xBin = ((int)((tmpPixRelative)*tmpBinRange) + (float)GetXaxis()->GetFirst());
195	return xBin;
196	}
197
198	int
199	AliHLTEMCALOnlineDisplayTH2D::GetZBin(Int_t pz)
200	{
201	float tmpBinRange = GetYaxis()->GetLast() - GetYaxis()->GetFirst();
202	float tmpPixelRange = PZMAX - PZMIN;
203	float tmpPixRelative = (pz - PZMIN)/tmpPixelRange;
204	int zBin = (int)((1-tmpPixRelative)*tmpBinRange);
205	return zBin;
206	}
207	*/