[u/mrichter/AliRoot.git] / EVE / Alieve / JetPlaneGL.cxx

// $Header$

#include "JetPlaneGL.h"
#include <Alieve/JetPlane.h>
#include <Reve/GLUtilNS.h>

#include <TGLRnrCtx.h>
#include <TGLSelectRecord.h>
#include <TGLIncludes.h>

#include "TGLUtil.h"
#include "TGLAxis.h"

#include <TColor.h>
#include <TStyle.h>
#include <TROOT.h>

using namespace Reve;
using namespace Alieve;

//______________________________________________________________________
// JetPlaneGL
//

ClassImp(JetPlaneGL)

JetPlaneGL::JetPlaneGL() : TGLObject(), fM(0)
{
  fDLCache = kFALSE; // Disable display list -- axis pain.
}

JetPlaneGL::~JetPlaneGL()
{}

/**************************************************************************/

Bool_t JetPlaneGL::SetModel(TObject* obj, const Option_t* /*opt*/)
{
  if(SetModelCheckClass(obj, Alieve::JetPlane::Class())) {
    fM = dynamic_cast<JetPlane*>(obj);
    return kTRUE;
  }
  return kFALSE;
}

void JetPlaneGL::SetBBox()
{
  // !! This ok if master sub-classed from TAttBBox
  SetAxisAlignedBBox(((JetPlane*)fExternalObj)->AssertBBox());
}

/**************************************************************************/

void JetPlaneGL::DirectDraw(TGLRnrCtx & /*rnrCtx*/) const
{

  Float_t minEta = (fM->fMinEta)*(fM->fEtaScale);
  Float_t maxEta = (fM->fMaxEta)*(fM->fEtaScale);
  Float_t minPhi = (fM->fMinPhi)*(fM->fPhiScale);
  Float_t maxPhi = (fM->fMaxPhi)*(fM->fPhiScale);
  Float_t phiCoord, etaCoord, dPhi, dEta;
  Double_t eta, phi, E, x, y;

  // Show frame for Eta-Phi coordinates

  glBegin(GL_LINE_LOOP);
  glVertex3f( minEta, minPhi, 0);
  glVertex3f( maxEta, minPhi, 0);
  glVertex3f( maxEta, maxPhi, 0);
  glVertex3f( minEta, maxPhi, 0);
  glEnd();

  // Show grid in Eta-Phi coordinates

  dPhi = (maxPhi-minPhi)/(fM->fNPhiDiv - 1);
  dEta = (maxEta-minEta)/(fM->fNEtaDiv - 1);

  for (int count=1; count < fM->fNPhiDiv-1; count++)
  {
    phiCoord = minPhi + count*dPhi;
    glBegin(GL_LINES);
    glVertex3f( minEta, phiCoord, 0);
    glVertex3f( maxEta, phiCoord, 0);
    glEnd();
  }

  for (int count=1; count < fM->fNEtaDiv-1; count++)
  {
    etaCoord = minEta + count*dEta;
    glBegin(GL_LINES);
    glVertex3f( etaCoord, minPhi, 0);
    glVertex3f( etaCoord, maxPhi, 0);
    glEnd();
  }

  // Show axis tick marks and labels

  {
    GLUtilNS::GL_Capability_Switch lights_off(GL_LIGHTING, false);

    TGLAxis ap;
    ap.SetLineColor(fM->fGridColor);
    ap.SetTextColor(fM->fGridColor);
    TGLVector3 start, end;

    start.Set(minEta, minPhi, 0);
    end.Set(maxEta, minPhi, 0);
    ap.PaintGLAxis(start.CArr(), end.CArr(), fM->fMinEta, fM->fMaxEta, 205);

    start.Set(maxEta, minPhi, 0);
    end.Set(maxEta, maxPhi, 0);
    ap.PaintGLAxis(start.CArr(), end.CArr(), fM->fMinPhi, fM->fMaxPhi, 205);

  }

  // Finding the maximum energy

  std::vector<AliAODTrack>::iterator k = fM->fTracks.begin();
  std::vector<AliAODJet>::iterator   j = fM->fJets.begin();

  Double_t eJetMax = 0., eTrackMax = 0., eMax;

  while (j != fM->fJets.end())
  {
    if (j->E() > eJetMax) eJetMax = j->E();
    ++j;
  }

  while (k != fM->fTracks.end())
  {
    if (k->E() > eTrackMax) eTrackMax = k->E();
    ++k;
  }

  eMax = eJetMax > eTrackMax ? eJetMax : eTrackMax;

  // Rendering Jets and Tracks in the Eta-Phi plane

  Int_t     nCol = gStyle->GetNumberOfColors();
  Float_t col[4] = { 0., 0., 0., 0.75};

  glBlendFunc(GL_SRC_ALPHA,GL_ONE);
  TGLUtil::SetDrawQuality(6);


  glPushName(0);
  if (fM->fRnrJets)
  {
    glEnable(GL_BLEND);		   // Turn Blending On
    glDisable(GL_DEPTH_TEST); // Turn Depth Testing Off
    UInt_t jetid = 0;


    j = fM->fJets.begin();

    while (j != fM->fJets.end())
    {
      eta = j->Eta();
      phi = j->Phi();
      E   = j->E();

      x = eta*(fM->fEtaScale);
      y = phi*(fM->fPhiScale);

      Int_t colBin = TMath::Min((Int_t) ((nCol-2)*E*
					 TMath::Power(10.,fM->fEnergyColorScale)/(eMax)),nCol-2);
      Int_t colIdx = gStyle->GetColorPalette(colBin);
      TColor* c    = gROOT->GetColor(colIdx);

      if(c)
      {
	col[0] = c->GetRed();
	col[1] = c->GetGreen();
	col[2] = c->GetBlue();
      }

      glLoadName(jetid);
      TGLUtil::DrawLine( TGLVertex3(x,y,0.),
			 TGLVector3(0.,0.,TMath::Log(E + 1.)*fM->fEnergyScale),
			 TGLUtil::kLineHeadArrow, 25.0, col);

      ++j; ++jetid;
    }
  }

  col[3] = 1.0;

  glPushName(1);
  if(fM->fRnrTracks)
  {
    glDisable(GL_BLEND);		   // Turn Blending Off
    glEnable(GL_DEPTH_TEST);	 // Turn Depth Testing On
    UInt_t trackid = 0;


    k = fM->fTracks.begin();

    while (k != fM->fTracks.end())
    {
      eta = k->Eta();
      phi = k->Phi();
      E   = k->E();

      if (E < 0.)
      {
	//			printf(" WARNING: Particle with negative energy has been found.\n");
	//			printf(" PARTICLE NOT DISPLAYED. TrackID: %i\n", trackid);
	++k; ++trackid;
	continue;
      }

      x = eta*(fM->fEtaScale);
      y = phi*(fM->fPhiScale);

      Int_t colBin = TMath::Min((Int_t) ((nCol-2)*E*
					 TMath::Power(10.,fM->fEnergyColorScale)/(eMax)),nCol-2);
      Int_t colIdx = gStyle->GetColorPalette(colBin);
      TColor* c    = gROOT->GetColor(colIdx);

      if(c)
      {
	col[0] = c->GetRed();
	col[1] = c->GetGreen();
	col[2] = c->GetBlue();
      }

      glLoadName(trackid);
      TGLUtil::DrawLine( TGLVertex3(x,y,0.),
			 TGLVector3(0.,0.,TMath::Log(E + 1.)*fM->fEnergyScale),
			 TGLUtil::kLineHeadArrow, 5.0, col);

      ++k; ++trackid;
    }
  }

  glPopName();
  TGLUtil::ResetDrawQuality();


}

/**************************************************************************/

void JetPlaneGL::ProcessSelection(TGLRnrCtx & /*rnrCtx*/, TGLSelectRecord & rec)
{
  //   printf("beep %u\n", rec.GetN());
  //   rec.Print();
  static Int_t jet1State;
  static Int_t jet2State;
  static Int_t track1State;
  static Int_t track2State;

  if (fM->fOneSelection)
  {
    printf("\n");

    if (rec.GetN() == 2)
    {
      AliAODJet v = fM->fJets[rec.GetItem(1)];
      printf("Jet 4-momentum: %f, %f, %f, %f \n", v.Px(),v.Py(),v.Pz(),v.Pt() );
      printf("Eta-Phi values: %f, %f\n", v.Eta(), v.Phi());
    }

    if (rec.GetN() == 3)
    {
      AliAODTrack v = fM->fTracks[rec.GetItem(2)];
      printf("Track 4-momentum: %f, %f, %f, %f \n", v.Px(),v.Py(),v.Pz(),v.Pt() );
      printf("Eta-Phi values: %f, %f\n", v.Eta(), v.Phi());
    }
  }

  if (fM->fTwoSelection)
  {

    if ( fM->fSelectionFlag == 1)
    {
      if (rec.GetN() == 2)
      {
	fM->SetJet1(&(fM->fJets[rec.GetItem(1)]));
        jet1State = 1;
	track1State = 0;
      }

      if (rec.GetN() == 3)
      {
	fM->SetTrack1(&(fM->fTracks[rec.GetItem(1)]));
	jet1State = 0;
	track1State = 1;
      }

      fM->SetSelectionFlag(2);

      return;
    }

    if ( fM->fSelectionFlag == 2)
    {
      printf("\n");
      if (rec.GetN() == 2)
      {
	fM->SetJet2(&(fM->fJets[rec.GetItem(1)]));
        jet2State = 1;
	track2State = 0;
      }

      if (rec.GetN() == 3)
      {
	fM->SetTrack2(&(fM->fTracks[rec.GetItem(1)]));
	jet2State = 0;
	track2State = 1;
      }

      printf("Jet: %i, Track: %i \n", jet1State, track1State);
      printf("Jet: %i, Track: %i \n\n", jet2State, track2State);

      if(jet1State && jet2State)
      {
	Double_t Eta1, Eta2, Phi1, Phi2, d;

	Eta1 = (fM->GetJet1()).Eta();
	Eta2 = (fM->GetJet2()).Eta();
	Phi1 = (fM->GetJet1()).Phi();
        Phi2 = (fM->GetJet2()).Phi();

	d = TMath::Sqrt(TMath::Power(Eta2-Eta1,2) + TMath::Power(Phi2-Phi1,2));

	printf("Eta-Phi: %f, %f\n", Eta1, Phi1 );
	printf("Eta-Phi: %f, %f\n", Eta2, Phi2 );
	printf("Eta-Phi Distance: %f\n", d);
      }

      fM->SetSelectionFlag(1);
    }

  }

}
Commit	Line	Data
4673ff03	1	// $Header$
	2
	3	#include "JetPlaneGL.h"
	4	#include <Alieve/JetPlane.h>
	5	#include <Reve/GLUtilNS.h>
	6
	7	#include <TGLRnrCtx.h>
	8	#include <TGLSelectRecord.h>
	9	#include <TGLIncludes.h>
	10
	11	#include "TGLUtil.h"
	12	#include "TGLAxis.h"
	13
	14	#include <TColor.h>
	15	#include <TStyle.h>
	16	#include <TROOT.h>
	17
	18	using namespace Reve;
	19	using namespace Alieve;
	20
	21	//______________________________________________________________________
	22	// JetPlaneGL
	23	//
	24
	25	ClassImp(JetPlaneGL)
	26
	27	JetPlaneGL::JetPlaneGL() : TGLObject(), fM(0)
	28	{
	29	fDLCache = kFALSE; // Disable display list -- axis pain.
	30	}
	31
	32	JetPlaneGL::~JetPlaneGL()
	33	{}
	34
	35	/**************************************************************************/
	36
	37	Bool_t JetPlaneGL::SetModel(TObject* obj, const Option_t* /opt/)
	38	{
	39	if(SetModelCheckClass(obj, Alieve::JetPlane::Class())) {
	40	fM = dynamic_cast<JetPlane*>(obj);
	41	return kTRUE;
	42	}
	43	return kFALSE;
	44	}
	45
	46	void JetPlaneGL::SetBBox()
	47	{
	48	// !! This ok if master sub-classed from TAttBBox
	49	SetAxisAlignedBBox(((JetPlane*)fExternalObj)->AssertBBox());
	50	}
	51
	52	/**************************************************************************/
	53
	54	void JetPlaneGL::DirectDraw(TGLRnrCtx & /rnrCtx/) const
	55	{
	56
	57	Float_t minEta = (fM->fMinEta)*(fM->fEtaScale);
	58	Float_t maxEta = (fM->fMaxEta)*(fM->fEtaScale);
	59	Float_t minPhi = (fM->fMinPhi)*(fM->fPhiScale);
	60	Float_t maxPhi = (fM->fMaxPhi)*(fM->fPhiScale);
	61	Float_t phiCoord, etaCoord, dPhi, dEta;
	62	Double_t eta, phi, E, x, y;
	63
	64	// Show frame for Eta-Phi coordinates
65
66	glBegin(GL_LINE_LOOP);
67	glVertex3f( minEta, minPhi, 0);
68	glVertex3f( maxEta, minPhi, 0);
69	glVertex3f( maxEta, maxPhi, 0);
70	glVertex3f( minEta, maxPhi, 0);
71	glEnd();
72
73	// Show grid in Eta-Phi coordinates
74
75	dPhi = (maxPhi-minPhi)/(fM->fNPhiDiv - 1);
76	dEta = (maxEta-minEta)/(fM->fNEtaDiv - 1);
77
78	for (int count=1; count < fM->fNPhiDiv-1; count++)
79	{
80	phiCoord = minPhi + count*dPhi;
81	glBegin(GL_LINES);
82	glVertex3f( minEta, phiCoord, 0);
83	glVertex3f( maxEta, phiCoord, 0);
84	glEnd();
85	}
86
87	for (int count=1; count < fM->fNEtaDiv-1; count++)
88	{
89	etaCoord = minEta + count*dEta;
90	glBegin(GL_LINES);
91	glVertex3f( etaCoord, minPhi, 0);
92	glVertex3f( etaCoord, maxPhi, 0);
93	glEnd();
94	}
95
96	// Show axis tick marks and labels
97
98	{
99	GLUtilNS::GL_Capability_Switch lights_off(GL_LIGHTING, false);
100
101	TGLAxis ap;
102	ap.SetLineColor(fM->fGridColor);
103	ap.SetTextColor(fM->fGridColor);
104	TGLVector3 start, end;
105
106	start.Set(minEta, minPhi, 0);
107	end.Set(maxEta, minPhi, 0);
108	ap.PaintGLAxis(start.CArr(), end.CArr(), fM->fMinEta, fM->fMaxEta, 205);
109
110	start.Set(maxEta, minPhi, 0);
111	end.Set(maxEta, maxPhi, 0);
112	ap.PaintGLAxis(start.CArr(), end.CArr(), fM->fMinPhi, fM->fMaxPhi, 205);
113
114	}
115
116	// Finding the maximum energy
117
118	std::vector<AliAODTrack>::iterator k = fM->fTracks.begin();
119	std::vector<AliAODJet>::iterator j = fM->fJets.begin();
120
121	Double_t eJetMax = 0., eTrackMax = 0., eMax;
122
123	while (j != fM->fJets.end())
124	{
125	if (j->E() > eJetMax) eJetMax = j->E();
126	++j;
127	}
128
129	while (k != fM->fTracks.end())
130	{
131	if (k->E() > eTrackMax) eTrackMax = k->E();
132	++k;
133	}
134
135	eMax = eJetMax > eTrackMax ? eJetMax : eTrackMax;
136
137	// Rendering Jets and Tracks in the Eta-Phi plane
138
139	Int_t nCol = gStyle->GetNumberOfColors();
140	Float_t col[4] = { 0., 0., 0., 0.75};
141
142	glBlendFunc(GL_SRC_ALPHA,GL_ONE);
143	TGLUtil::SetDrawQuality(6);
144
145
146	glPushName(0);
147	if (fM->fRnrJets)
148	{
149	glEnable(GL_BLEND); // Turn Blending On
150	glDisable(GL_DEPTH_TEST); // Turn Depth Testing Off
151	UInt_t jetid = 0;
152
153
154	j = fM->fJets.begin();
155
156	while (j != fM->fJets.end())
157	{
158	eta = j->Eta();
159	phi = j->Phi();
160	E = j->E();
161
162	x = eta*(fM->fEtaScale);
163	y = phi*(fM->fPhiScale);
164
165	Int_t colBin = TMath::Min((Int_t) ((nCol-2)E
166	TMath::Power(10.,fM->fEnergyColorScale)/(eMax)),nCol-2);
167	Int_t colIdx = gStyle->GetColorPalette(colBin);
168	TColor* c = gROOT->GetColor(colIdx);
169
170	if(c)
171	{
172	col[0] = c->GetRed();
173	col[1] = c->GetGreen();
174	col[2] = c->GetBlue();
175	}
176
177	glLoadName(jetid);
178	TGLUtil::DrawLine( TGLVertex3(x,y,0.),
179	TGLVector3(0.,0.,TMath::Log(E + 1.)*fM->fEnergyScale),
180	TGLUtil::kLineHeadArrow, 25.0, col);
181
182	++j; ++jetid;
183	}
184	}
185
186	col[3] = 1.0;
187
188	glPushName(1);
189	if(fM->fRnrTracks)
190	{
191	glDisable(GL_BLEND); // Turn Blending Off
192	glEnable(GL_DEPTH_TEST); // Turn Depth Testing On
193	UInt_t trackid = 0;
194
195
196	k = fM->fTracks.begin();
197
198	while (k != fM->fTracks.end())
199	{
200	eta = k->Eta();
201	phi = k->Phi();
202	E = k->E();
203
204	if (E < 0.)
205	{
206	// printf(" WARNING: Particle with negative energy has been found.\n");
207	// printf(" PARTICLE NOT DISPLAYED. TrackID: %i\n", trackid);
208	++k; ++trackid;
209	continue;
210	}
211
212	x = eta*(fM->fEtaScale);
213	y = phi*(fM->fPhiScale);
214
215	Int_t colBin = TMath::Min((Int_t) ((nCol-2)E
216	TMath::Power(10.,fM->fEnergyColorScale)/(eMax)),nCol-2);
217	Int_t colIdx = gStyle->GetColorPalette(colBin);
218	TColor* c = gROOT->GetColor(colIdx);
219
220	if(c)
221	{
222	col[0] = c->GetRed();
223	col[1] = c->GetGreen();
224	col[2] = c->GetBlue();
225	}
226
227	glLoadName(trackid);
228	TGLUtil::DrawLine( TGLVertex3(x,y,0.),
229	TGLVector3(0.,0.,TMath::Log(E + 1.)*fM->fEnergyScale),
230	TGLUtil::kLineHeadArrow, 5.0, col);
231
232	++k; ++trackid;
233	}
234	}
235
236	glPopName();
237	TGLUtil::ResetDrawQuality();
238
239
240
241	}
242
243	/**************************************************************************/
244
245	void JetPlaneGL::ProcessSelection(TGLRnrCtx & /rnrCtx/, TGLSelectRecord & rec)
246	{
247	// printf("beep %u\n", rec.GetN());
248	// rec.Print();
249	static Int_t jet1State;
250	static Int_t jet2State;
251	static Int_t track1State;
252	static Int_t track2State;
253
254	if (fM->fOneSelection)
255	{
256	printf("\n");
257
258	if (rec.GetN() == 2)
259	{
260	AliAODJet v = fM->fJets[rec.GetItem(1)];
261	printf("Jet 4-momentum: %f, %f, %f, %f \n", v.Px(),v.Py(),v.Pz(),v.Pt() );
262	printf("Eta-Phi values: %f, %f\n", v.Eta(), v.Phi());
263	}
264
265	if (rec.GetN() == 3)
266	{
267	AliAODTrack v = fM->fTracks[rec.GetItem(2)];
268	printf("Track 4-momentum: %f, %f, %f, %f \n", v.Px(),v.Py(),v.Pz(),v.Pt() );
269	printf("Eta-Phi values: %f, %f\n", v.Eta(), v.Phi());
270	}
271	}
272
273	if (fM->fTwoSelection)
274	{
275
276	if ( fM->fSelectionFlag == 1)
277	{
278	if (rec.GetN() == 2)
279	{
280	fM->SetJet1(&(fM->fJets[rec.GetItem(1)]));
281	jet1State = 1;
282	track1State = 0;
283	}
284
285	if (rec.GetN() == 3)
286	{
287	fM->SetTrack1(&(fM->fTracks[rec.GetItem(1)]));
288	jet1State = 0;
289	track1State = 1;
290	}
291
292	fM->SetSelectionFlag(2);
293
294	return;
295	}
296
297	if ( fM->fSelectionFlag == 2)
298	{
299	printf("\n");
300	if (rec.GetN() == 2)
301	{
302	fM->SetJet2(&(fM->fJets[rec.GetItem(1)]));
303	jet2State = 1;
304	track2State = 0;
305	}
306
307	if (rec.GetN() == 3)
308	{
309	fM->SetTrack2(&(fM->fTracks[rec.GetItem(1)]));
310	jet2State = 0;
311	track2State = 1;
312	}
313
314	printf("Jet: %i, Track: %i \n", jet1State, track1State);
315	printf("Jet: %i, Track: %i \n\n", jet2State, track2State);
316
317	if(jet1State && jet2State)
318	{
319	Double_t Eta1, Eta2, Phi1, Phi2, d;
320
321	Eta1 = (fM->GetJet1()).Eta();
322	Eta2 = (fM->GetJet2()).Eta();
323	Phi1 = (fM->GetJet1()).Phi();
324	Phi2 = (fM->GetJet2()).Phi();
325
326	d = TMath::Sqrt(TMath::Power(Eta2-Eta1,2) + TMath::Power(Phi2-Phi1,2));
327
328	printf("Eta-Phi: %f, %f\n", Eta1, Phi1 );
329	printf("Eta-Phi: %f, %f\n", Eta2, Phi2 );
330	printf("Eta-Phi Distance: %f\n", d);
331	}
332
333	fM->SetSelectionFlag(1);
334	}
335
336	}
337
338	}
339
340
341
342