Logo ROOT  

Reference Guide
Loading...
Searching...
No Matches
TEveCalo3DGL.cxx
Go to the documentation of this file.
1// @(#)root/eve:$Id$
2// Author: Matevz Tadel 2007
3
4/*************************************************************************
5 * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include "TEveCalo3DGL.h"
13#include "TEveCalo.h"
14
15#include "TMath.h"
16#include "TAxis.h"
17
18#include "TGLRnrCtx.h"
19#include "TGLSelectRecord.h"
20#include "TGLPhysicalShape.h"
21#include "TGLIncludes.h"
22#include "TGLUtil.h"
23#include "TEveRGBAPalette.h"
24#include "TEveUtil.h"
25
26/** \class TEveCalo3DGL
27\ingroup TEve
28OpenGL renderer class for TEveCalo3D.
29*/
30
31
32////////////////////////////////////////////////////////////////////////////////
33/// Constructor.
34
35TEveCalo3DGL::TEveCalo3DGL() :
36 TGLObject(), fM(nullptr)
37{
38 fMultiColor = kTRUE;
39}
40
41////////////////////////////////////////////////////////////////////////////////
42/// Set model object.
43
44Bool_t TEveCalo3DGL::SetModel(TObject* obj, const Option_t* /*opt*/)
45{
46 fM = SetModelDynCast<TEveCalo3D>(obj);
47 return kTRUE;
48}
49
50////////////////////////////////////////////////////////////////////////////////
51/// Set bounding box.
52
53void TEveCalo3DGL::SetBBox()
54{
55 // !! This ok if master sub-classed from TAttBBox
56 SetAxisAlignedBBox(((TEveCalo3D*)fExternalObj)->AssertBBox());
57}
58
59////////////////////////////////////////////////////////////////////////////////
60/// Override from TGLObject.
61/// To account for large point-sizes we modify the projection matrix
62/// during selection and thus we need a direct draw.
63
64Bool_t TEveCalo3DGL::ShouldDLCache(const TGLRnrCtx& rnrCtx) const
65{
66 if (rnrCtx.Highlight() || rnrCtx.Selection()) return kFALSE;
67 return TGLObject::ShouldDLCache(rnrCtx);
68}
69
70////////////////////////////////////////////////////////////////////////////////
71/// Calculate cross-product.
72
73inline void TEveCalo3DGL::CrossProduct(const Float_t a[3], const Float_t b[3],
74 const Float_t c[3], Float_t out[3]) const
75{
76 const Float_t v1[3] = { a[0] - c[0], a[1] - c[1], a[2] - c[2] };
77 const Float_t v2[3] = { b[0] - c[0], b[1] - c[1], b[2] - c[2] };
78
79 out[0] = v1[1] * v2[2] - v1[2] * v2[1];
80 out[1] = v1[2] * v2[0] - v1[0] * v2[2];
81 out[2] = v1[0] * v2[1] - v1[1] * v2[0];
82}
83
84////////////////////////////////////////////////////////////////////////////////
85/// Render end cap grid.
86
87void TEveCalo3DGL::RenderGridEndCap() const
88{
89 using namespace TMath;
90
91 Float_t rB = fM->GetBarrelRadius();
92 Double_t zEF = fM->GetForwardEndCapPos();
93 Double_t zEB = fM->GetBackwardEndCapPos();
94
95 Float_t etaMin = fM->GetEtaMin();
96 Float_t etaMax = fM->GetEtaMax();
97 Float_t transF = fM->GetTransitionEtaForward();
98 Float_t transB = fM->GetTransitionEtaBackward();
99 Float_t phiMin = fM->GetPhiMin();
100 Float_t phiMax = fM->GetPhiMax();
101
102 TAxis *ax = fM->GetData()->GetEtaBins();
103 Int_t nx = ax->GetNbins();
104 TAxis *ay = fM->GetData()->GetPhiBins();
105 Int_t ny = ay->GetNbins();
106
107
108 Float_t r, z, theta, phiU, phiL, eta;
109
110 // eta slices
111 for (Int_t i=0; i<=nx; ++i)
112 {
113 eta = ax->GetBinUpEdge(i);
114 if (eta >= transF && (eta > etaMin && eta < etaMax))
115 {
116 theta = TEveCaloData::EtaToTheta(eta);
117 r = Abs(zEF*Tan(theta));
118 z = Sign(zEF, ax->GetBinLowEdge(i));
119 for (Int_t j=1; j<=ny; ++j)
120 {
121 phiL = ay->GetBinLowEdge(j);
122 phiU = ay->GetBinUpEdge(j);
123 if (TEveUtil::IsU1IntervalContainedByMinMax(phiMin, phiMax, phiL, phiU))
124 {
125 glVertex3f(r*Cos(phiL), r*Sin(phiL), z);
126 glVertex3f(r*Cos(phiU), r*Sin(phiU), z);
127 }
128 }
129 } else if (eta <= transB && (eta > etaMin && eta < etaMax)) {
130 theta = TEveCaloData::EtaToTheta(eta);
131 r = Abs(zEB*Tan(theta));
132 z = Sign(zEB, ax->GetBinLowEdge(i));
133 for (Int_t j=1; j<=ny; ++j)
134 {
135 phiL = ay->GetBinLowEdge(j);
136 phiU = ay->GetBinUpEdge(j);
137 if (TEveUtil::IsU1IntervalContainedByMinMax(phiMin, phiMax, phiL, phiU))
138 {
139 glVertex3f(r*Cos(phiL), r*Sin(phiL), z);
140 glVertex3f(r*Cos(phiU), r*Sin(phiU), z);
141 }
142 }
143 }
144 }
145
146 Float_t r1, r2;
147 // phi slices front
148 if (etaMax > transF)
149 {
150 r1 = zEF*Tan(TEveCaloData::EtaToTheta(etaMax));
151 if (etaMin < transF)
152 r2 = rB;
153 else
154 r2 = zEF*Tan(TEveCaloData::EtaToTheta(etaMin));
155
156 for (Int_t j=1; j<=ny; ++j)
157 {
158 phiL = ay->GetBinLowEdge(j);
159 phiU = ay->GetBinUpEdge(j);
160 if (TEveUtil::IsU1IntervalContainedByMinMax(phiMin, phiMax, phiL, phiU))
161 {
162 glVertex3f( r1*Cos(phiU), r1*Sin(phiU), zEF);
163 glVertex3f( r2*Cos(phiU), r2*Sin(phiU), zEF);
164 glVertex3f( r1*Cos(phiL), r1*Sin(phiL), zEF);
165 glVertex3f( r2*Cos(phiL), r2*Sin(phiL), zEF);
166 }
167 }
168 }
169
170 // phi slices back
171 if (etaMin < transB)
172 {
173 r1 = zEB*Tan(TEveCaloData::EtaToTheta(etaMin));
174 if (etaMax > transB)
175 r2 = rB;
176 else
177 r2 = zEB*Tan(TEveCaloData::EtaToTheta(etaMax));
178
179 r1 = Abs(r1);
180 r2 = Abs(r2);
181 for (Int_t j=1; j<=ny; ++j)
182 {
183 phiL = ay->GetBinLowEdge(j);
184 phiU = ay->GetBinUpEdge(j);
185 if (TEveUtil::IsU1IntervalContainedByMinMax(phiMin, phiMax, phiL, phiU))
186 {
187 glVertex3f(r1*Cos(phiU), r1*Sin(phiU), zEB);
188 glVertex3f(r2*Cos(phiU), r2*Sin(phiU), zEB);
189 glVertex3f(r1*Cos(phiL), r1*Sin(phiL), zEB);
190 glVertex3f(r2*Cos(phiL), r2*Sin(phiL), zEB);
191 }
192 }
193 }
194}
195
196////////////////////////////////////////////////////////////////////////////////
197/// Render barrel grid.
198
199void TEveCalo3DGL::RenderGridBarrel() const
200{
201 using namespace TMath;
202
203 Float_t etaMin = fM->GetEtaMin();
204 Float_t etaMax = fM->GetEtaMax();
205 Float_t transF = fM->GetTransitionEtaForward();
206 Float_t transB = fM->GetTransitionEtaBackward();
207 Float_t phiMin = fM->GetPhiMin();
208 Float_t phiMax = fM->GetPhiMax();
209
210 Float_t rB = fM->GetBarrelRadius();
211 TAxis *ax = fM->GetData()->GetEtaBins();
212 Int_t nx = ax->GetNbins();
213 TAxis *ay = fM->GetData()->GetPhiBins();
214 Int_t ny = ay->GetNbins();
215
216 Float_t z, theta, phiL, phiU, eta, x, y;
217
218 // eta slices
219 for(Int_t i=0; i<=nx; i++)
220 {
221 eta = ax->GetBinUpEdge(i);
222 if (eta<=transF && eta>=transB && (etaMin < eta && eta < etaMax))
223 {
224 theta = TEveCaloData::EtaToTheta(eta);
225 z = rB/Tan(theta);
226 for (Int_t j=1; j<=ny; j++)
227 {
228 phiU = ay->GetBinUpEdge(j);
229 phiL = ay->GetBinLowEdge(j);
230 if (TEveUtil::IsU1IntervalContainedByMinMax(phiMin, phiMax, phiL, phiU))
231 {
232 glVertex3f(rB*Cos(phiL), rB*Sin(phiL), z);
233 glVertex3f(rB*Cos(phiU), rB*Sin(phiU), z);
234 }
235 }
236 }
237 }
238
239 // phi slices
240 Float_t zF, zB;
241
242 if (etaMin > transB)
243 zB = rB/Tan(TEveCaloData::EtaToTheta(etaMin));
244 else
245 zB = fM->GetBackwardEndCapPos();
246
247
248 if (etaMax < transF)
249 zF = rB/Tan(TEveCaloData::EtaToTheta(etaMax));
250 else
251 zF = fM->GetForwardEndCapPos();
252
253 for (Int_t j=1; j<=ny; j++)
254 {
255 phiU = ay->GetBinUpEdge(j);
256 phiL = ay->GetBinLowEdge(j);
257 if (TEveUtil::IsU1IntervalContainedByMinMax(phiMin, phiMax, phiL, phiU))
258 {
259 x = rB * Cos(phiL);
260 y = rB * Sin(phiL);
261 glVertex3f(x, y, zB);
262 glVertex3f(x, y, zF);
263 x = rB * Cos(phiU);
264 y = rB * Sin(phiU);
265 glVertex3f(x, y, zB);
266 glVertex3f(x, y, zF);
267 }
268 }
269}
270
271////////////////////////////////////////////////////////////////////////////////
272/// Draw frame reading eta, phi axis.
273
274void TEveCalo3DGL::RenderGrid(TGLRnrCtx & rnrCtx) const
275{
276 if (rnrCtx.Highlight() || rnrCtx.Selection() || rnrCtx.IsDrawPassOutlineLine()) return;
277
278 Bool_t transparent_p = fM->fFrameTransparency > 0;
279
280 if (transparent_p)
281 {
282 glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT);
283
284 glDepthMask(GL_FALSE);
285 glEnable(GL_BLEND);
286 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
287
288 TGLUtil::ColorTransparency(fM->fFrameColor, fM->fFrameTransparency);
289 }
290
291 TGLCapabilitySwitch lights_off(GL_LIGHTING, kFALSE);
292
293 TGLUtil::LineWidth(fM->GetFrameWidth());
294 glBegin(GL_LINES);
295
296 Float_t etaMin = fM->GetEtaMin();
297 Float_t etaMax = fM->GetEtaMax();
298
299 Float_t transF = fM->GetTransitionEtaForward();
300 Float_t transB = fM->GetTransitionEtaBackward();
301 if (fM->GetRnrBarrelFrame() && (etaMin < transF && etaMax > transB))
302 {
303 RenderGridBarrel();
304 }
305
306 if (fM->GetRnrEndCapFrame() && (etaMax > transF || etaMin < transB))
307 {
308 RenderGridEndCap();
309 }
310
311 glEnd();
312
313 if (transparent_p)
314 {
315 glPopAttrib();
316 }
317}
318
319////////////////////////////////////////////////////////////////////////////////
320/// Render box with given points.
321/// ~~~ {.cpp}
322/// z
323/// |
324/// |
325/// |________y
326/// / 6-------7
327/// / /| /|
328/// x 5-------4 |
329/// | 2-----|-3
330/// |/ |/
331/// 1-------0
332/// ~~~
333
334void TEveCalo3DGL::RenderBox(const Float_t pnts[8]) const
335{
336 const Float_t *p = pnts;
337 Float_t cross[3];
338
339 // bottom: 0123
340 glBegin(GL_POLYGON);
341 CrossProduct(p+3, p+9, p, cross);
342 glNormal3fv(cross);
343 glVertex3fv(p);
344 glVertex3fv(p+3);
345 glVertex3fv(p+6);
346 glVertex3fv(p+9);
347 glEnd();
348 // top: 7654
349 glBegin(GL_POLYGON);
350 CrossProduct(p+21, p+15, p+12, cross);
351 glNormal3fv(cross);
352 glVertex3fv(p+21);
353 glVertex3fv(p+18);
354 glVertex3fv(p+15);
355 glVertex3fv(p+12);
356 glEnd();
357 // back: 0451
358 glBegin(GL_POLYGON);
359 CrossProduct(p+12, p+3, p, cross);
360 glNormal3fv(cross);
361 glVertex3fv(p);
362 glVertex3fv(p+12);
363 glVertex3fv(p+15);
364 glVertex3fv(p+3);
365 glEnd();
366 //front : 3267
367 glBegin(GL_POLYGON);
368 CrossProduct(p+6, p+21, p+9, cross);
369 glNormal3fv(cross);
370 glVertex3fv(p+9);
371 glVertex3fv(p+6);
372 glVertex3fv(p+18);
373 glVertex3fv(p+21);
374 glEnd();
375 // left: 0374
376 glBegin(GL_POLYGON);
377 CrossProduct(p+21, p, p+9, cross);
378 glNormal3fv(cross);
379 glVertex3fv(p);
380 glVertex3fv(p+9);
381 glVertex3fv(p+21);
382 glVertex3fv(p+12);
383 glEnd();
384 // right: 1562
385 glBegin(GL_POLYGON);
386 CrossProduct(p+15, p+6, p+3, cross);
387 glNormal3fv(cross);
388 glVertex3fv(p+3);
389 glVertex3fv(p+15);
390 glVertex3fv(p+18);
391 glVertex3fv(p+6);
392 glEnd();
393}
394
395////////////////////////////////////////////////////////////////////////////////
396/// Render barrel cell.
397
398void TEveCalo3DGL::RenderBarrelCell(const TEveCaloData::CellGeom_t &cellData, Float_t towerH, Float_t& offset ) const
399{
400 using namespace TMath;
401
402 Float_t r1 = fM->GetBarrelRadius() + offset;
403 Float_t r2 = r1 + towerH*Sin(cellData.ThetaMin());
404 Float_t z1In, z1Out, z2In, z2Out;
405
406 z1In = r1/Tan(cellData.ThetaMax());
407 z1Out = r2/Tan(cellData.ThetaMax());
408 z2In = r1/Tan(cellData.ThetaMin());
409 z2Out = r2/Tan(cellData.ThetaMin());
410
411 Float_t cos1 = Cos(cellData.PhiMin());
412 Float_t sin1 = Sin(cellData.PhiMin());
413 Float_t cos2 = Cos(cellData.PhiMax());
414 Float_t sin2 = Sin(cellData.PhiMax());
415
416 Float_t box[24];
417 Float_t* pnts = box;
418 // 0
419 pnts[0] = r1*cos2;
420 pnts[1] = r1*sin2;
421 pnts[2] = z1In;
422 pnts += 3;
423 // 1
424 pnts[0] = r1*cos1;
425 pnts[1] = r1*sin1;
426 pnts[2] = z1In;
427 pnts += 3;
428 // 2
429 pnts[0] = r1*cos1;
430 pnts[1] = r1*sin1;
431 pnts[2] = z2In;
432 pnts += 3;
433 // 3
434 pnts[0] = r1*cos2;
435 pnts[1] = r1*sin2;
436 pnts[2] = z2In;
437 pnts += 3;
438 //---------------------------------------------------
439 // 4
440 pnts[0] = r2*cos2;
441 pnts[1] = r2*sin2;
442 pnts[2] = z1Out;
443 pnts += 3;
444 // 5
445 pnts[0] = r2*cos1;
446 pnts[1] = r2*sin1;
447 pnts[2] = z1Out;
448 pnts += 3;
449 // 6
450 pnts[0] = r2*cos1;
451 pnts[1] = r2*sin1;
452 pnts[2] = z2Out;
453 pnts += 3;
454 // 7
455 pnts[0] = r2*cos2;
456 pnts[1] = r2*sin2;
457 pnts[2] = z2Out;
458
459 RenderBox(box);
460
461 offset += towerH*Sin(cellData.ThetaMin());
462
463}// end RenderBarrelCell
464
465////////////////////////////////////////////////////////////////////////////////
466/// Render an endcap cell.
467
468void TEveCalo3DGL::RenderEndCapCell(const TEveCaloData::CellGeom_t &cellData, Float_t towerH, Float_t& offset ) const
469{
470 using namespace TMath;
471 Float_t z1, r1In, r1Out, z2, r2In, r2Out;
472
473 z1 = (cellData.EtaMin()<0) ? fM->fEndCapPosB - offset : fM->fEndCapPosF + offset;
474 z2 = z1 + TMath::Sign(towerH, cellData.EtaMin());
475
476 r1In = z1*Tan(cellData.ThetaMin());
477 r2In = z2*Tan(cellData.ThetaMin());
478 r1Out = z1*Tan(cellData.ThetaMax());
479 r2Out = z2*Tan(cellData.ThetaMax());
480
481 Float_t cos2 = Cos(cellData.PhiMin());
482 Float_t sin2 = Sin(cellData.PhiMin());
483 Float_t cos1 = Cos(cellData.PhiMax());
484 Float_t sin1 = Sin(cellData.PhiMax());
485
486 Float_t box[24];
487 Float_t* pnts = box;
488 // 0
489 pnts[0] = r1In*cos1;
490 pnts[1] = r1In*sin1;
491 pnts[2] = z1;
492 pnts += 3;
493 // 1
494 pnts[0] = r1In*cos2;
495 pnts[1] = r1In*sin2;
496 pnts[2] = z1;
497 pnts += 3;
498 // 2
499 pnts[0] = r2In*cos2;
500 pnts[1] = r2In*sin2;
501 pnts[2] = z2;
502 pnts += 3;
503 // 3
504 pnts[0] = r2In*cos1;
505 pnts[1] = r2In*sin1;
506 pnts[2] = z2;
507 pnts += 3;
508 //---------------------------------------------------
509 // 4
510 pnts[0] = r1Out*cos1;
511 pnts[1] = r1Out*sin1;
512 pnts[2] = z1;
513 pnts += 3;
514 // 5
515 pnts[0] = r1Out*cos2;
516 pnts[1] = r1Out*sin2;
517 pnts[2] = z1;
518 pnts += 3;
519 // 6
520 pnts[0] = r2Out*cos2;
521 pnts[1] = r2Out*sin2;
522 pnts[2] = z2;
523 pnts += 3;
524 // 7
525 pnts[0] = r2Out*cos1;
526 pnts[1] = r2Out*sin1;
527 pnts[2] = z2;
528
529 RenderBox(box);
530
531 offset += towerH;
532
533} // end RenderEndCapCell
534
535////////////////////////////////////////////////////////////////////////////////
536/// GL rendering.
537
538void TEveCalo3DGL::DirectDraw(TGLRnrCtx &rnrCtx) const
539{
540 if ( fM->GetValueIsColor()) fM->AssertPalette();
541
542 // check if eta phi range has changed
543 if (fM->fCellIdCacheOK == kFALSE)
544 fM->BuildCellIdCache();
545
546 glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT | GL_POLYGON_BIT);
547 glEnable(GL_LIGHTING);
548 glEnable(GL_NORMALIZE);
549 glEnable(GL_BLEND);
550 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
551
552 TEveCaloData::CellData_t cellData;
553 Float_t towerH = 0;
554 Int_t tower = 0;
555 Int_t prevTower = -1;
556 Float_t offset = 0;
557 Int_t cellID = 0;
558
559 if (rnrCtx.SecSelection()) glPushName(0);
560
561 fOffset.assign(fM->fCellList.size(), 0);
562 for (TEveCaloData::vCellId_i i = fM->fCellList.begin(); i != fM->fCellList.end(); ++i)
563 {
564 fM->fData->GetCellData((*i), cellData);
565 tower = i->fTower;
566 if (tower != prevTower)
567 {
568 offset = 0;
569 prevTower = tower;
570 }
571 fOffset[cellID] = offset;
572 fM->SetupColorHeight(cellData.Value(fM->fPlotEt), (*i).fSlice, towerH);
573
574 if (rnrCtx.SecSelection()) glLoadName(cellID);
575
576 if ((cellData.Eta() > 0 && cellData.Eta() < fM->GetTransitionEtaForward()) ||
577 (cellData.Eta() < 0 && cellData.Eta() > fM->GetTransitionEtaBackward()))
578 {
579 RenderBarrelCell(cellData, towerH, offset);
580 }
581 else
582 {
583 RenderEndCapCell(cellData, towerH, offset);
584 }
585 ++cellID;
586 }
587
588 if (rnrCtx.SecSelection()) glPopName();
589
590 RenderGrid(rnrCtx);
591
592 glPopAttrib();
593}
594
595////////////////////////////////////////////////////////////////////////////////
596/// Draw polygons in highlight mode.
597
598void TEveCalo3DGL::DrawHighlight(TGLRnrCtx & rnrCtx, const TGLPhysicalShape* /*pshp*/, Int_t /*lvl*/) const
599{
600 if (fM->fData->GetCellsSelected().empty() && fM->fData->GetCellsHighlighted().empty())
601 {
602 return;
603 }
604
605 glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT | GL_POLYGON_BIT);
606 glDisable(GL_LIGHTING);
607 glDisable(GL_CULL_FACE);
608 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
609
610 TGLUtil::LineWidth(2);
611 TGLUtil::LockColor();
612
613 if (!fM->fData->GetCellsHighlighted().empty())
614 {
615 glColor4ubv(rnrCtx.ColorSet().Selection(3).CArr());
616 DrawSelectedCells(fM->fData->GetCellsHighlighted());
617 }
618 if (!fM->fData->GetCellsSelected().empty())
619 {
620 Float_t dr[2];
621 glGetFloatv(GL_DEPTH_RANGE,dr);
622 glColor4ubv(rnrCtx.ColorSet().Selection(1).CArr());
623 glDepthRange(dr[0], 0.8*dr[1]);
624 DrawSelectedCells(fM->fData->GetCellsSelected());
625 glDepthRange(dr[0], dr[1]);
626 }
627
628 TGLUtil::UnlockColor();
629 glPopAttrib();
630}
631
632////////////////////////////////////////////////////////////////////////////////
633
634void TEveCalo3DGL::DrawSelectedCells(TEveCaloData::vCellId_t cells) const
635{
636 TEveCaloData::CellData_t cellData;
637 Float_t towerH = 0;
638
639 for (TEveCaloData::vCellId_i i = cells.begin(); i != cells.end(); i++)
640 {
641 fM->fData->GetCellData(*i, cellData);
642 fM->SetupColorHeight(cellData.Value(fM->fPlotEt), (*i).fSlice, towerH);
643
644 // find tower with offsets
645 Float_t offset = 0;
646 for (Int_t j = 0; j < (Int_t) fM->fCellList.size(); ++j)
647 {
648 if (fM->fCellList[j].fTower == i->fTower && fM->fCellList[j].fSlice == i->fSlice )
649 {
650 offset = fOffset[j];
651 break;
652 }
653 }
654
655 if (fM->CellInEtaPhiRng(cellData))
656 {
657 if (cellData.Eta() < fM->GetTransitionEtaForward() && cellData.Eta() > fM->GetTransitionEtaBackward())
658 RenderBarrelCell(cellData, towerH, offset);
659 else
660 RenderEndCapCell(cellData, towerH, offset);
661 }
662 }
663}
664
665////////////////////////////////////////////////////////////////////////////////
666/// Processes tower selection.
667/// Virtual function from TGLogicalShape. Called from TGLViewer.
668
669void TEveCalo3DGL::ProcessSelection(TGLRnrCtx& /*rnrCtx*/, TGLSelectRecord& rec)
670{
671 TEveCaloData::vCellId_t sel;
672 if (rec.GetN() > 1)
673 {
674 sel.push_back(fM->fCellList[rec.GetItem(1)]);
675 }
676 fM->fData->ProcessSelection(sel, rec);
677}
r
ROOT::R::TRInterface & r
Definition Object.C:4
b
#define b(i)
Definition RSha256.hxx:100
c
#define c(i)
Definition RSha256.hxx:101
a
#define a(i)
Definition RSha256.hxx:99
Int_t
int Int_t
Signed integer 4 bytes (int).
Definition RtypesCore.h:59
Bool_t
bool Bool_t
Boolean (0=false, 1=true) (bool).
Definition RtypesCore.h:77
kFALSE
constexpr Bool_t kFALSE
Definition RtypesCore.h:108
Double_t
double Double_t
Double 8 bytes.
Definition RtypesCore.h:73
Float_t
float Float_t
Float 4 bytes (float).
Definition RtypesCore.h:71
kTRUE
constexpr Bool_t kTRUE
Definition RtypesCore.h:107
Option_t
const char Option_t
Option string (const char).
Definition RtypesCore.h:80
TAxis
Class to manage histogram axis.
Definition TAxis.h:32
TAxis::GetBinLowEdge
virtual Double_t GetBinLowEdge(Int_t bin) const
Return low edge of bin.
Definition TAxis.cxx:522
TAxis::GetNbins
Int_t GetNbins() const
Definition TAxis.h:127
TAxis::GetBinUpEdge
virtual Double_t GetBinUpEdge(Int_t bin) const
Return up edge of bin.
Definition TAxis.cxx:532
TEveCalo3DGL::SetBBox
void SetBBox() override
Set bounding box.
Definition TEveCalo3DGL.cxx:53
TEveCalo3DGL::fOffset
std::vector< Float_t > fOffset
Definition TEveCalo3DGL.h:41
TEveCalo3DGL::RenderBarrelCell
void RenderBarrelCell(const TEveCaloData::CellGeom_t &cell, Float_t towerH, Float_t &offset) const
Render barrel cell.
Definition TEveCalo3DGL.cxx:398
TEveCalo3DGL::fM
TEveCalo3D * fM
Definition TEveCalo3DGL.h:39
TEveCalo3DGL::RenderBox
void RenderBox(const Float_t pnts[8]) const
Render box with given points.
Definition TEveCalo3DGL.cxx:334
TEveCalo3DGL::DirectDraw
void DirectDraw(TGLRnrCtx &rnrCtx) const override
GL rendering.
Definition TEveCalo3DGL.cxx:538
TEveCalo3DGL::TEveCalo3DGL
TEveCalo3DGL()
Constructor.
Definition TEveCalo3DGL.cxx:35
TEveCalo3DGL::RenderGrid
void RenderGrid(TGLRnrCtx &rnrCtx) const
Draw frame reading eta, phi axis.
Definition TEveCalo3DGL.cxx:274
TEveCalo3DGL::RenderGridEndCap
void RenderGridEndCap() const
Render end cap grid.
Definition TEveCalo3DGL.cxx:87
TEveCalo3DGL::ProcessSelection
void ProcessSelection(TGLRnrCtx &rnrCtx, TGLSelectRecord &rec) override
Processes tower selection.
Definition TEveCalo3DGL.cxx:669
TEveCalo3DGL::DrawHighlight
void DrawHighlight(TGLRnrCtx &rnrCtx, const TGLPhysicalShape *ps, Int_t lvl=-1) const override
Draw polygons in highlight mode.
Definition TEveCalo3DGL.cxx:598
TEveCalo3DGL::DrawSelectedCells
void DrawSelectedCells(TEveCaloData::vCellId_t cells) const
Definition TEveCalo3DGL.cxx:634
TEveCalo3DGL::CrossProduct
void CrossProduct(const Float_t a[3], const Float_t b[3], const Float_t c[3], Float_t out[3]) const
Calculate cross-product.
Definition TEveCalo3DGL.cxx:73
TEveCalo3DGL::ShouldDLCache
Bool_t ShouldDLCache(const TGLRnrCtx &rnrCtx) const override
Override from TGLObject.
Definition TEveCalo3DGL.cxx:64
TEveCalo3DGL::RenderGridBarrel
void RenderGridBarrel() const
Render barrel grid.
Definition TEveCalo3DGL.cxx:199
TEveCalo3DGL::SetModel
Bool_t SetModel(TObject *obj, const Option_t *opt=nullptr) override
Set model object.
Definition TEveCalo3DGL.cxx:44
TEveCalo3DGL::RenderEndCapCell
void RenderEndCapCell(const TEveCaloData::CellGeom_t &cell, Float_t towerH, Float_t &offset) const
Render an endcap cell.
Definition TEveCalo3DGL.cxx:468
TEveCalo3D
Visualization of a calorimeter event data in 3D.
Definition TEveCalo.h:158
TEveCaloData::vCellId_t
std::vector< CellId_t > vCellId_t
Definition TEveCaloData.h:146
TEveCaloData::EtaToTheta
static Float_t EtaToTheta(Float_t eta)
Definition TEveCaloData.cxx:410
TEveCaloData::vCellId_i
std::vector< CellId_t >::iterator vCellId_i
Definition TEveCaloData.h:147
TEveUtil::IsU1IntervalContainedByMinMax
static Bool_t IsU1IntervalContainedByMinMax(Float_t minM, Float_t maxM, Float_t minQ, Float_t maxQ)
Return true if interval Q is contained within interval M for U1 variables.
Definition TEveUtil.cxx:341
TGLColorSet::Selection
TGLColor & Selection(Int_t i)
Definition TGLUtil.h:855
TGLColor::CArr
const UChar_t * CArr() const
Definition TGLUtil.h:800
TGLLogicalShape::fExternalObj
TObject * fExternalObj
! Also plays the role of ID.
Definition TGLLogicalShape.h:49
TGLObject::fMultiColor
Bool_t fMultiColor
Definition TGLObject.h:28
TGLObject::SetModelDynCast
TT * SetModelDynCast(TObject *obj)
Definition TGLObject.h:37
TGLObject::SetAxisAlignedBBox
void SetAxisAlignedBBox(Float_t xmin, Float_t xmax, Float_t ymin, Float_t ymax, Float_t zmin, Float_t zmax)
Set axis-aligned bounding-box.
Definition TGLObject.cxx:85
TGLObject::ShouldDLCache
Bool_t ShouldDLCache(const TGLRnrCtx &rnrCtx) const override
Decide if display-list should be used for this pass rendering, as determined by rnrCtx.
Definition TGLObject.cxx:40
TGLPhysicalShape
Concrete physical shape - a GL drawable.
Definition TGLPhysicalShape.h:32
TGLRnrCtx
The TGLRnrCtx class aggregates data for a given redering context as needed by various parts of the RO...
Definition TGLRnrCtx.h:41
TGLRnrCtx::SecSelection
Bool_t SecSelection() const
Definition TGLRnrCtx.h:224
TGLRnrCtx::ColorSet
TGLColorSet & ColorSet()
Return reference to current color-set (top of the stack).
Definition TGLRnrCtx.cxx:275
TGLRnrCtx::IsDrawPassOutlineLine
Bool_t IsDrawPassOutlineLine() const
Definition TGLRnrCtx.h:207
TGLRnrCtx::Highlight
Bool_t Highlight() const
Definition TGLRnrCtx.h:218
TGLRnrCtx::Selection
Bool_t Selection() const
Definition TGLRnrCtx.h:222
TGLSelectRecordBase::GetItem
UInt_t GetItem(Int_t i) const
Definition TGLSelectRecord.h:56
TGLSelectRecord
Standard selection record including information about containing scene and details ob out selected ob...
Definition TGLSelectRecord.h:75
TGLUtil::LockColor
static UInt_t LockColor()
Prevent further color changes.
Definition TGLUtil.cxx:1660
TGLUtil::ColorTransparency
static void ColorTransparency(Color_t color_index, Char_t transparency=0)
Set color from color_index and ROOT-style transparency (default 0).
Definition TGLUtil.cxx:1732
TGLUtil::UnlockColor
static UInt_t UnlockColor()
Allow color changes.
Definition TGLUtil.cxx:1668
TGLUtil::LineWidth
static Float_t LineWidth()
Get the line-width, taking the global scaling into account.
Definition TGLUtil.cxx:1934
TObject
Mother of all ROOT objects.
Definition TObject.h:42
box
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition fillpatterns.C:1
y
Double_t y[n]
Definition legend1.C:17
x
Double_t x[n]
Definition legend1.C:17
TMath
TMath.
Definition TMathBase.h:35
TMath::Sign
T1 Sign(T1 a, T2 b)
Returns a value with the magnitude of a and the sign of b.
Definition TMathBase.h:174
TMath::Cos
Double_t Cos(Double_t)
Returns the cosine of an angle of x radians.
Definition TMath.h:605
TMath::Sin
Double_t Sin(Double_t)
Returns the sine of an angle of x radians.
Definition TMath.h:599
TMath::Tan
Double_t Tan(Double_t)
Returns the tangent of an angle of x radians.
Definition TMath.h:611
TMath::Abs
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition TMathBase.h:122
v2
@ v2
Definition rootcling_impl.cxx:3557
v1
@ v1
Definition rootcling_impl.cxx:3556
TEveCaloData::CellData_t
Cell data inner structure.
Definition TEveCaloData.h:115
TEveCaloData::CellData_t::Value
Float_t Value(Bool_t) const
Return energy value associated with the cell, usually Et.
Definition TEveCaloData.cxx:71
TEveCaloData::CellGeom_t
Cell geometry inner structure.
Definition TEveCaloData.h:73
TEveCaloData::CellGeom_t::Eta
Float_t Eta() const
Definition TEveCaloData.h:92
TEveCaloData::CellGeom_t::ThetaMin
Float_t ThetaMin() const
Definition TEveCaloData.h:100
TEveCaloData::CellGeom_t::ThetaMax
Float_t ThetaMax() const
Definition TEveCaloData.h:101
TEveCaloData::CellGeom_t::PhiMin
Float_t PhiMin() const
Definition TEveCaloData.h:95
TEveCaloData::CellGeom_t::PhiMax
Float_t PhiMax() const
Definition TEveCaloData.h:96
TEveCaloData::CellGeom_t::EtaMin
Float_t EtaMin() const
Definition TEveCaloData.h:90