Logo ROOT  
Reference Guide
TEveTrack.cxx
Go to the documentation of this file.
1 // @(#)root/eve:$Id$
2 // Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 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 "TEveTrack.h"
13 #include "TEveTrackPropagator.h"
14 #include "TEvePointSet.h"
15 
16 #include "TParticle.h"
17 #include "TPolyMarker3D.h"
18 #include "TParticlePDG.h"
19 
20 // Updates
21 #include "TEveManager.h"
22 #include "TEveBrowser.h"
23 #include "TEveTrackProjected.h"
24 #include "TEveVSD.h"
25 
26 #include <iostream>
27 #include <vector>
28 #include <algorithm>
29 #include <functional>
30 
31 /** \class TEveTrack
32 \ingroup TEve
33 Visual representation of a track.
34 
35 If member fDpDs is set, the momentum is reduced on all path-marks that do
36 not fix the momentum according to the distance travelled from the previous
37 pathmark.
38 */
39 
41 
42 ////////////////////////////////////////////////////////////////////////////////
43 /// Default constructor.
44 
46  TEveLine(),
47 
48  fV(),
49  fP(),
50  fPEnd(),
51  fBeta(0),
52  fDpDs(0),
53  fPdg(0),
54  fCharge(0),
55  fLabel(kMinInt),
56  fIndex(kMinInt),
57  fStatus(0),
58  fLockPoints(kFALSE),
59  fPathMarks(),
60  fLastPMIdx(0),
61  fPropagator(0)
62 {
63 }
64 
65 ////////////////////////////////////////////////////////////////////////////////
66 /// Constructor from TParticle.
67 
69  TEveLine(),
70 
71  fV(t->Vx(), t->Vy(), t->Vz()),
72  fP(t->Px(), t->Py(), t->Pz()),
73  fPEnd(),
74  fBeta(t->P()/t->Energy()),
75  fDpDs(0),
76  fPdg(0),
77  fCharge(0),
78  fLabel(label),
79  fIndex(kMinInt),
80  fStatus(t->GetStatusCode()),
81  fLockPoints(kFALSE),
82  fPathMarks(),
83  fLastPMIdx(0),
84  fPropagator(0)
85 {
86  SetPropagator(prop);
88 
89  TParticlePDG* pdgp = t->GetPDG();
90  if (pdgp) {
91  fPdg = pdgp->PdgCode();
92  fCharge = (Int_t) TMath::Nint(pdgp->Charge()/3);
93  }
94 
95  SetName(t->GetName());
96 }
97 
98 ////////////////////////////////////////////////////////////////////////////////
99 
101  TEveLine(),
102 
103  fV(t->Vx(), t->Vy(), t->Vz()),
104  fP(t->Px(), t->Py(), t->Pz()),
105  fPEnd(),
106  fBeta(t->P()/t->Energy()),
107  fDpDs(0),
108  fPdg(0),
109  fCharge(0),
110  fLabel(t->fLabel),
111  fIndex(t->fIndex),
112  fStatus(t->GetStatusCode()),
113  fLockPoints(kFALSE),
114  fPathMarks(),
115  fLastPMIdx(0),
116  fPropagator(0)
117 {
118  // Constructor from TEveUtil Monte Carlo track.
119 
120  SetPropagator(prop);
122 
123  TParticlePDG* pdgp = t->GetPDG();
124  if (pdgp) {
125  fCharge = (Int_t) TMath::Nint(pdgp->Charge()/3);
126  }
127 
128  SetName(t->GetName());
129 }
130 
131 ////////////////////////////////////////////////////////////////////////////////
132 /// Constructor from TEveRecTrack<double> reconstructed track.
133 
135  TEveLine(),
136 
137  fV(t->fV),
138  fP(t->fP),
139  fPEnd(),
140  fBeta(t->fBeta),
141  fDpDs(0),
142  fPdg(0),
143  fCharge(t->fSign),
144  fLabel(t->fLabel),
145  fIndex(t->fIndex),
146  fStatus(t->fStatus),
147  fLockPoints(kFALSE),
148  fPathMarks(),
149  fLastPMIdx(0),
150  fPropagator(0)
151 {
152  SetPropagator(prop);
154 
155  SetName(t->GetName());
156 }
157 
158 ////////////////////////////////////////////////////////////////////////////////
159 /// Constructor from TEveRecTrack<float> reconstructed track.
160 /// It is recommended to use constructor with TEveRecTrack<double> since
161 /// TEveTrackPropagator operates with double type.
162 
164  TEveLine(),
165 
166  fV(t->fV),
167  fP(t->fP),
168  fPEnd(),
169  fBeta(t->fBeta),
170  fDpDs(0),
171  fPdg(0),
172  fCharge(t->fSign),
173  fLabel(t->fLabel),
174  fIndex(t->fIndex),
175  fStatus(t->fStatus),
176  fLockPoints(kFALSE),
177  fPathMarks(),
178  fLastPMIdx(0),
179  fPropagator(0)
180 {
181  SetPropagator(prop);
183 
184  SetName(t->GetName());
185 }
186 
187 ////////////////////////////////////////////////////////////////////////////////
188 /// Copy constructor. Track parameters are copied but the
189 /// extrapolation is not performed so you should still call
190 /// MakeTrack() to do that.
191 /// If points of 't' are locked, they are cloned.
192 
194  TEveLine(),
195  fV(t.fV),
196  fP(t.fP),
197  fPEnd(),
198  fBeta(t.fBeta),
199  fDpDs(t.fDpDs),
200  fPdg(t.fPdg),
201  fCharge(t.fCharge),
202  fLabel(t.fLabel),
203  fIndex(t.fIndex),
204  fStatus(t.fStatus),
205  fLockPoints(t.fLockPoints),
206  fPathMarks(),
207  fLastPMIdx(t.fLastPMIdx),
208  fPropagator(0)
209 {
210  if (fLockPoints)
211  ClonePoints(t);
212 
213  SetPathMarks(t);
215 
216  CopyVizParams(&t);
217 }
218 
219 ////////////////////////////////////////////////////////////////////////////////
220 /// Destructor.
221 
223 {
224  SetPropagator(0);
225 }
226 
227 
228 ////////////////////////////////////////////////////////////////////////////////
229 /// Returns list-tree icon for TEveTrack.
230 
232 {
233  return fgListTreeIcons[4];
234 }
235 
236 ////////////////////////////////////////////////////////////////////////////////
237 /// Compute the bounding box of the track.
238 
240 {
241  if (Size() > 0 || ! fPathMarks.empty())
242  {
243  BBoxInit();
244  Int_t n = Size();
246  for (Int_t i = 0; i < n; ++i, p += 3)
247  {
248  BBoxCheckPoint(p);
249  }
250  for (vPathMark_ci i = fPathMarks.begin(); i != fPathMarks.end(); ++i)
251  {
252  BBoxCheckPoint(i->fV.fX, i->fV.fY,i->fV.fZ);
253  }
254  }
255  else
256  {
257  BBoxZero();
258  }
259 }
260 
261 ////////////////////////////////////////////////////////////////////////////////
262 /// Set standard track title based on most data-member values.
263 
265 {
266  TString idx(fIndex == kMinInt ? "<undef>" : Form("%d", fIndex));
267  TString lbl(fLabel == kMinInt ? "<undef>" : Form("%d", fLabel));
268  SetTitle(Form("Index=%s, Label=%s\nChg=%d, Pdg=%d\n"
269  "pT=%.3f, pZ=%.3f\nV=(%.3f, %.3f, %.3f)",
270  idx.Data(), lbl.Data(), fCharge, fPdg,
271  fP.Perp(), fP.fZ, fV.fX, fV.fY, fV.fZ));
272 }
273 
274 ////////////////////////////////////////////////////////////////////////////////
275 /// Copy track parameters from t. Track-propagator is set, too.
276 /// PathMarks are cleared - you can copy them via SetPathMarks(t).
277 /// If track 't' is locked, you should probably clone its points
278 /// over - use TEvePointSet::ClonePoints(t);
279 
281 {
282  fV = t.fV;
283  fP = t.fP;
284  fBeta = t.fBeta;
285  fPdg = t.fPdg;
286  fCharge = t.fCharge;
287  fLabel = t.fLabel;
288  fIndex = t.fIndex;
289 
290  fPathMarks.clear();
292 }
293 
294 ////////////////////////////////////////////////////////////////////////////////
295 /// Copy path-marks from t.
296 
298 {
299  std::copy(t.RefPathMarks().begin(), t.RefPathMarks().end(),
300  std::back_insert_iterator<vPathMark_t>(fPathMarks));
301 }
302 
303 ////////////////////////////////////////////////////////////////////////////////
304 /// Set track's render style.
305 /// Reference counts of old and new propagator are updated.
306 
308 {
309  if (fPropagator == prop) return;
310  if (fPropagator) fPropagator->DecRefCount(this);
311  fPropagator = prop;
312  if (fPropagator) fPropagator->IncRefCount(this);
313 }
314 
315 ////////////////////////////////////////////////////////////////////////////////
316 /// Set line and marker attributes from TEveTrackList.
317 
319 {
320  SetRnrLine(tl->GetRnrLine());
321  SetLineColor(tl->GetLineColor());
322  SetLineStyle(tl->GetLineStyle());
323  SetLineWidth(tl->GetLineWidth());
324 
325  SetRnrPoints(tl->GetRnrPoints());
329 }
330 
331 ////////////////////////////////////////////////////////////////////////////////
332 /// Calculate track representation based on track data and current
333 /// settings of the propagator.
334 /// If recurse is true, descend into children.
335 
337 {
338  if (!fLockPoints)
339  {
340  Reset(0);
341  fLastPMIdx = 0;
342 
344 
345  const Double_t maxRsq = rTP.GetMaxR() * rTP.GetMaxR();
346  const Double_t maxZ = rTP.GetMaxZ();
347 
348  if ( ! TEveTrackPropagator::IsOutsideBounds(fV, maxRsq, maxZ))
349  {
350  TEveVectorD currP = fP;
351  Bool_t decay = kFALSE;
352  rTP.InitTrack(fV, fCharge);
353  for (vPathMark_i pm = fPathMarks.begin(); pm != fPathMarks.end(); ++pm, ++fLastPMIdx)
354  {
355  Int_t start_point = rTP.GetCurrentPoint();
356 
357  if (rTP.GetFitReferences() && pm->fType == TEvePathMarkD::kReference)
358  {
359  if (TEveTrackPropagator::IsOutsideBounds(pm->fV, maxRsq, maxZ))
360  break;
361  if (rTP.GoToVertex(pm->fV, currP))
362  {
363  currP.fX = pm->fP.fX; currP.fY = pm->fP.fY; currP.fZ = pm->fP.fZ;
364  }
365  else
366  {
367  break;
368  }
369  }
370  else if (rTP.GetFitDaughters() && pm->fType == TEvePathMarkD::kDaughter)
371  {
372  if (TEveTrackPropagator::IsOutsideBounds(pm->fV, maxRsq, maxZ))
373  break;
374  if (rTP.GoToVertex(pm->fV, currP))
375  {
376  currP.fX -= pm->fP.fX; currP.fY -= pm->fP.fY; currP.fZ -= pm->fP.fZ;
377  if (fDpDs != 0)
378  {
379  Double_t dp = fDpDs * rTP.GetTrackLength(start_point);
380  Double_t p = currP.Mag();
381  if (p > dp) currP *= 1.0 - dp / p;
382  }
383  }
384  else
385  {
386  break;
387  }
388  }
389  else if (rTP.GetFitDecay() && pm->fType == TEvePathMarkD::kDecay)
390  {
391  if (TEveTrackPropagator::IsOutsideBounds(pm->fV, maxRsq, maxZ))
392  break;
393  rTP.GoToVertex(pm->fV, currP);
394  decay = kTRUE;
395  ++fLastPMIdx;
396  break;
397  }
398  else if (rTP.GetFitCluster2Ds() && pm->fType == TEvePathMarkD::kCluster2D)
399  {
400  TEveVectorD itsect;
401  if (rTP.IntersectPlane(currP, pm->fV, pm->fP, itsect))
402  {
403  TEveVectorD delta = itsect - pm->fV;
404  TEveVectorD vtopass = pm->fV + pm->fE*(pm->fE.Dot(delta));
405  if (TEveTrackPropagator::IsOutsideBounds(vtopass, maxRsq, maxZ))
406  break;
407  if ( ! rTP.GoToVertex(vtopass, currP))
408  break;
409 
410  if (fDpDs != 0)
411  {
412  Double_t dp = fDpDs * rTP.GetTrackLength(start_point);
413  Double_t p = currP.Mag();
414  if (p > dp) currP *= 1.0 - dp / p;
415  }
416  }
417  else
418  {
419  Warning("TEveTrack::MakeTrack", "Failed to intersect plane for Cluster2D. Ignoring path-mark.");
420  }
421  }
422  else if (rTP.GetFitLineSegments() && pm->fType == TEvePathMarkD::kLineSegment)
423  {
424  if (TEveTrackPropagator::IsOutsideBounds(pm->fV, maxRsq, maxZ))
425  break;
426 
427  if (rTP.GoToLineSegment(pm->fV, pm->fE, currP))
428  {
429  if (fDpDs != 0)
430  {
431  Double_t dp = fDpDs * rTP.GetTrackLength(start_point);
432  Double_t p = currP.Mag();
433  if (p > dp) currP *= 1.0 - dp / p;
434  }
435  }
436  else
437  {
438  break;
439  }
440  }
441  else
442  {
443  if (TEveTrackPropagator::IsOutsideBounds(pm->fV, maxRsq, maxZ))
444  break;
445  }
446  } // loop path-marks
447 
448  if (!decay)
449  {
450  // printf("%s loop to bounds \n",fName.Data() );
451  rTP.GoToBounds(currP);
452  }
453  fPEnd = currP;
454  // make_polyline:
455  rTP.FillPointSet(this);
456  rTP.ResetTrack();
457  }
458  }
459 
460  if (recurse)
461  {
462  for (List_i i=fChildren.begin(); i!=fChildren.end(); ++i)
463  {
464  TEveTrack* t = dynamic_cast<TEveTrack*>(*i);
465  if (t) t->MakeTrack(recurse);
466  }
467  }
468 }
469 
470 ////////////////////////////////////////////////////////////////////////////////
471 /// Copy visualization parameters from element el.
472 
474 {
475  // No local parameters.
476 
477  // const TEveTrack* t = dynamic_cast<const TEveTrack*>(el);
478  // if (t)
479  // {}
480 
482 }
483 
484 ////////////////////////////////////////////////////////////////////////////////
485 /// Write visualization parameters.
486 
487 void TEveTrack::WriteVizParams(std::ostream& out, const TString& var)
488 {
489  TEveLine::WriteVizParams(out, var);
490 
491  // TString t = " " + var + "->";
492 }
493 
494 ////////////////////////////////////////////////////////////////////////////////
495 /// Virtual from TEveProjectable, return TEveTrackProjected class.
496 
498 {
499  return TEveTrackProjected::Class();
500 }
501 
502 namespace
503 {
504  struct Cmp_pathmark_t
505  {
506  bool operator()(TEvePathMarkD const & a, TEvePathMarkD const & b)
507  { return a.fTime < b.fTime; }
508  };
509 }
510 
511 ////////////////////////////////////////////////////////////////////////////////
512 /// Sort registered pat-marks by time.
513 
515 {
516  std::sort(fPathMarks.begin(), fPathMarks.end(), Cmp_pathmark_t());
517 }
518 
519 ////////////////////////////////////////////////////////////////////////////////
520 /// Print registered path-marks.
521 
523 {
524  static const TEveException eh("TEveTrack::PrintPathMarks ");
525 
526  printf("TEveTrack '%s', number of path marks %d, label %d\n",
527  GetName(), (Int_t)fPathMarks.size(), fLabel);
528 
529  for (vPathMark_i pm = fPathMarks.begin(); pm != fPathMarks.end(); ++pm)
530  {
531  printf(" %-9s p: %8f %8f %8f Vertex: %8e %8e %8e %g Extra:%8f %8f %8f\n",
532  pm->TypeName(),
533  pm->fP.fX, pm->fP.fY, pm->fP.fZ,
534  pm->fV.fX, pm->fV.fY, pm->fV.fZ,
535  pm->fE.fX, pm->fE.fY, pm->fE.fZ,
536  pm->fTime);
537  }
538 }
539 
540 //------------------------------------------------------------------------------
541 
542 ////////////////////////////////////////////////////////////////////////////////
543 /// Emits "SecSelected(TEveTrack*)" signal.
544 /// Called from TEveTrackGL on secondary-selection.
545 
547 {
548  Emit("SecSelected(TEveTrack*)", (Longptr_t)track);
549 }
550 
551 /** \class TEveTrackList
552 \ingroup TEve
553 A list of tracks supporting change of common attributes and
554 selection based on track parameters.
555 */
556 
558 
559 ////////////////////////////////////////////////////////////////////////////////
560 /// Constructor. If track-propagator argument is 0, a new default
561 /// one is created.
562 
564  TEveElementList(),
565  TAttMarker(1, 20, 1),
566  TAttLine(1,1,1),
567 
568  fPropagator(0),
569  fRecurse(kTRUE),
570  fRnrLine(kTRUE),
571  fRnrPoints(kFALSE),
572 
573  fMinPt (0), fMaxPt (0), fLimPt (0),
574  fMinP (0), fMaxP (0), fLimP (0)
575 {
576 
577  fChildClass = TEveTrack::Class(); // override member from base TEveElementList
578 
580 
581  if (prop == 0) prop = new TEveTrackPropagator;
582  SetPropagator(prop);
583 }
584 
585 ////////////////////////////////////////////////////////////////////////////////
586 /// Constructor. If track-propagator argument is 0, a new default
587 /// one is created.
588 
591  TAttMarker(1, 20, 1),
592  TAttLine(1,1,1),
593 
594  fPropagator(0),
595  fRecurse(kTRUE),
596  fRnrLine(kTRUE),
597  fRnrPoints(kFALSE),
598 
599  fMinPt (0), fMaxPt (0), fLimPt (0),
600  fMinP (0), fMaxP (0), fLimP (0)
601 {
602  fChildClass = TEveTrack::Class(); // override member from base TEveElementList
603 
605 
606  if (prop == 0) prop = new TEveTrackPropagator;
607  SetPropagator(prop);
608 }
609 
610 ////////////////////////////////////////////////////////////////////////////////
611 /// Destructor.
612 
614 {
615  SetPropagator(0);
616 }
617 
618 ////////////////////////////////////////////////////////////////////////////////
619 /// Set default propagator for tracks.
620 /// This is not enforced onto the tracks themselves but this is the
621 /// propagator that is shown in the TEveTrackListEditor.
622 
624 {
625  if (fPropagator == prop) return;
627  fPropagator = prop;
629 }
630 
631 ////////////////////////////////////////////////////////////////////////////////
632 /// Regenerate the visual representations of tracks.
633 /// The momentum limits are rescanned during the same traversal.
634 
636 {
637  fLimPt = fLimP = 0;
638 
639  for (List_i i=fChildren.begin(); i!=fChildren.end(); ++i)
640  {
641  TEveTrack* track = dynamic_cast<TEveTrack*>(*i);
642  if (track)
643  {
644  track->MakeTrack(recurse);
645 
646  fLimPt = TMath::Max(fLimPt, track->fP.Perp());
647  fLimP = TMath::Max(fLimP, track->fP.Mag());
648  }
649  if (recurse)
650  FindMomentumLimits(*i, recurse);
651  }
652 
655 
657 }
658 
659 ////////////////////////////////////////////////////////////////////////////////
660 /// Loop over children and find highest pT and p of contained TEveTracks.
661 /// These are stored in members fLimPt and fLimP.
662 
664 {
665  fLimPt = fLimP = 0;
666 
667  if (HasChildren())
668  {
669  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
670  {
671  TEveTrack* track = dynamic_cast<TEveTrack*>(*i);
672  if (track)
673  {
674  fLimPt = TMath::Max(fLimPt, track->fP.Perp());
675  fLimP = TMath::Max(fLimP, track->fP.Mag());
676  }
677  if (recurse)
678  FindMomentumLimits(*i, recurse);
679  }
680 
683  }
684 
686 }
687 
688 ////////////////////////////////////////////////////////////////////////////////
689 /// Loop over track elements of argument el and find highest pT and p.
690 /// These are stored in members fLimPt and fLimP.
691 
693 {
694  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
695  {
696  TEveTrack* track = dynamic_cast<TEveTrack*>(*i);
697  if (track)
698  {
699  fLimPt = TMath::Max(fLimPt, track->fP.Perp());
700  fLimP = TMath::Max(fLimP, track->fP.Mag());
701  }
702  if (recurse)
703  FindMomentumLimits(*i, recurse);
704  }
705 }
706 
707 ////////////////////////////////////////////////////////////////////////////////
708 /// Round the momentum limit up to a nice value.
709 
711 {
712  using namespace TMath;
713 
714  if (x < 1e-3) return 1e-3;
715 
716  Double_t fac = Power(10, 1 - Floor(Log10(x)));
717  return Ceil(fac*x) / fac;
718 }
719 
720 ////////////////////////////////////////////////////////////////////////////////
721 /// Set Min/Max cuts so that they are within detected limits.
722 
724 {
725  using namespace TMath;
726 
727  fMinPt = Min(fMinPt, fLimPt);
728  fMaxPt = fMaxPt == 0 ? fLimPt : Min(fMaxPt, fLimPt);
729  fMinP = Min(fMinP, fLimP);
730  fMaxP = fMaxP == 0 ? fLimP : Min(fMaxP, fLimP);
731 }
732 
733 ////////////////////////////////////////////////////////////////////////////////
734 /// Set rendering of track as line for the list and the elements.
735 
737 {
738  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
739  {
740  TEveTrack* track = (TEveTrack*)(*i);
741  if (track->GetRnrLine() == fRnrLine)
742  track->SetRnrLine(rnr);
743  if (fRecurse)
744  SetRnrLine(rnr, *i);
745  }
746  fRnrLine = rnr;
747 }
748 
749 ////////////////////////////////////////////////////////////////////////////////
750 /// Set rendering of track as line for children of el.
751 
753 {
754  TEveTrack* track;
755  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
756  {
757  track = dynamic_cast<TEveTrack*>(*i);
758  if (track && (track->GetRnrLine() == fRnrLine))
759  track->SetRnrLine(rnr);
760  if (fRecurse)
761  SetRnrLine(rnr, *i);
762  }
763 }
764 
765 ////////////////////////////////////////////////////////////////////////////////
766 /// Set rendering of track as points for the list and the elements.
767 
769 {
770  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
771  {
772  TEveTrack* track = (TEveTrack*)(*i);
773  if (track->GetRnrPoints() == fRnrPoints)
774  track->SetRnrPoints(rnr);
775  if (fRecurse)
776  SetRnrPoints(rnr, *i);
777  }
778  fRnrPoints = rnr;
779 }
780 
781 ////////////////////////////////////////////////////////////////////////////////
782 /// Set rendering of track as points for children of el.
783 
785 {
786  TEveTrack* track;
787  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
788  {
789  track = dynamic_cast<TEveTrack*>(*i);
790  if (track)
791  if (track->GetRnrPoints() == fRnrPoints)
792  track->SetRnrPoints(rnr);
793  if (fRecurse)
794  SetRnrPoints(rnr, *i);
795  }
796 }
797 
798 ////////////////////////////////////////////////////////////////////////////////
799 /// Set main (line) color for the list and the elements.
800 
802 {
803  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
804  {
805  TEveTrack* track = (TEveTrack*)(*i);
806  if (track->GetLineColor() == fLineColor)
807  track->SetLineColor(col);
808  if (fRecurse)
809  SetLineColor(col, *i);
810  }
812 }
813 
814 ////////////////////////////////////////////////////////////////////////////////
815 /// Set line color for children of el.
816 
818 {
819  TEveTrack* track;
820  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
821  {
822  track = dynamic_cast<TEveTrack*>(*i);
823  if (track && track->GetLineColor() == fLineColor)
824  track->SetLineColor(col);
825  if (fRecurse)
826  SetLineColor(col, *i);
827  }
828 }
829 
830 ////////////////////////////////////////////////////////////////////////////////
831 /// Set line width for the list and the elements.
832 
834 {
835  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
836  {
837  TEveTrack* track = (TEveTrack*)(*i);
838  if (track->GetLineWidth() == fLineWidth)
839  track->SetLineWidth(width);
840  if (fRecurse)
841  SetLineWidth(width, *i);
842  }
843  fLineWidth = width;
844 }
845 
846 ////////////////////////////////////////////////////////////////////////////////
847 /// Set line width for children of el.
848 
850 {
851  TEveTrack* track;
852  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
853  {
854  track = dynamic_cast<TEveTrack*>(*i);
855  if (track && track->GetLineWidth() == fLineWidth)
856  track->SetLineWidth(width);
857  if (fRecurse)
858  SetLineWidth(width, *i);
859  }
860 }
861 
862 ////////////////////////////////////////////////////////////////////////////////
863 /// Set line style for the list and the elements.
864 
866 {
867  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
868  {
869  TEveTrack* track = (TEveTrack*)(*i);
870  if (track->GetLineStyle() == fLineStyle)
871  track->SetLineStyle(style);
872  if (fRecurse)
873  SetLineStyle(style, *i);
874  }
875  fLineStyle = style;
876 }
877 
878 ////////////////////////////////////////////////////////////////////////////////
879 /// Set line style for children of el.
880 
882 {
883  TEveTrack* track;
884  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
885  {
886  track = dynamic_cast<TEveTrack*>(*i);
887  if (track && track->GetLineStyle() == fLineStyle)
888  track->SetLineStyle(style);
889  if (fRecurse)
890  SetLineStyle(style, *i);
891  }
892 }
893 
894 ////////////////////////////////////////////////////////////////////////////////
895 /// Set marker style for the list and the elements.
896 
898 {
899  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
900  {
901  TEveTrack* track = (TEveTrack*)(*i);
902  if (track->GetMarkerStyle() == fMarkerStyle)
903  track->SetMarkerStyle(style);
904  if (fRecurse)
905  SetMarkerStyle(style, *i);
906  }
908 }
909 
910 ////////////////////////////////////////////////////////////////////////////////
911 /// Set marker style for children of el.
912 
914 {
915  TEveTrack* track;
916  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
917  {
918  track = dynamic_cast<TEveTrack*>(*i);
919  if (track && track->GetMarkerStyle() == fMarkerStyle)
920  track->SetMarkerStyle(style);
921  if (fRecurse)
922  SetMarkerStyle(style, *i);
923  }
924 }
925 
926 ////////////////////////////////////////////////////////////////////////////////
927 /// Set marker color for the list and the elements.
928 
930 {
931  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
932  {
933  TEveTrack* track = (TEveTrack*)(*i);
934  if (track->GetMarkerColor() == fMarkerColor)
935  track->SetMarkerColor(col);
936  if (fRecurse)
937  SetMarkerColor(col, *i);
938  }
939  fMarkerColor = col;
940 }
941 
942 ////////////////////////////////////////////////////////////////////////////////
943 /// Set marker color for children of el.
944 
946 {
947  TEveTrack* track;
948  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
949  {
950  track = dynamic_cast<TEveTrack*>(*i);
951  if (track && track->GetMarkerColor() == fMarkerColor)
952  track->SetMarkerColor(col);
953  if (fRecurse)
954  SetMarkerColor(col, *i);
955  }
956 }
957 
958 ////////////////////////////////////////////////////////////////////////////////
959 /// Set marker size for the list and the elements.
960 
962 {
963  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
964  {
965  TEveTrack* track = (TEveTrack*)(*i);
966  if (track->GetMarkerSize() == fMarkerSize)
967  track->SetMarkerSize(size);
968  if (fRecurse)
969  SetMarkerSize(size, *i);
970  }
971  fMarkerSize = size;
972 }
973 
974 ////////////////////////////////////////////////////////////////////////////////
975 /// Set marker size for children of el.
976 
978 {
979  TEveTrack* track;
980  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
981  {
982  track = dynamic_cast<TEveTrack*>(*i);
983  if (track && track->GetMarkerSize() == fMarkerSize)
984  track->SetMarkerSize(size);
985  if (fRecurse)
986  SetMarkerSize(size, *i);
987  }
988 }
989 
990 ////////////////////////////////////////////////////////////////////////////////
991 /// Select visibility of tracks by transverse momentum.
992 /// If data-member fRecurse is set, the selection is applied
993 /// recursively to all children.
994 
996 {
997  fMinPt = min_pt;
998  fMaxPt = max_pt;
999 
1000  const Double_t minptsq = min_pt*min_pt;
1001  const Double_t maxptsq = max_pt*max_pt;
1002 
1003  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
1004  {
1005  const Double_t ptsq = ((TEveTrack*)(*i))->fP.Perp2();
1006  Bool_t on = ptsq >= minptsq && ptsq <= maxptsq;
1007  (*i)->SetRnrState(on);
1008  if (on && fRecurse)
1009  SelectByPt(min_pt, max_pt, *i);
1010  }
1011 }
1012 
1013 ////////////////////////////////////////////////////////////////////////////////
1014 /// Select visibility of el's children tracks by transverse momentum.
1015 
1017 {
1018  const Double_t minptsq = min_pt*min_pt;
1019  const Double_t maxptsq = max_pt*max_pt;
1020 
1021  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
1022  {
1023  TEveTrack* track = dynamic_cast<TEveTrack*>(*i);
1024  if (track)
1025  {
1026  const Double_t ptsq = track->fP.Perp2();
1027  Bool_t on = ptsq >= minptsq && ptsq <= maxptsq;
1028  track->SetRnrState(on);
1029  if (on && fRecurse)
1030  SelectByPt(min_pt, max_pt, *i);
1031  }
1032  }
1033 }
1034 
1035 ////////////////////////////////////////////////////////////////////////////////
1036 /// Select visibility of tracks by momentum.
1037 /// If data-member fRecurse is set, the selection is applied
1038 /// recursively to all children.
1039 
1041 {
1042  fMinP = min_p;
1043  fMaxP = max_p;
1044 
1045  const Double_t minpsq = min_p*min_p;
1046  const Double_t maxpsq = max_p*max_p;
1047 
1048  for (List_i i=BeginChildren(); i!=EndChildren(); ++i)
1049  {
1050  const Double_t psq = ((TEveTrack*)(*i))->fP.Mag2();
1051  Bool_t on = psq >= minpsq && psq <= maxpsq;
1052  (*i)->SetRnrState(psq >= minpsq && psq <= maxpsq);
1053  if (on && fRecurse)
1054  SelectByP(min_p, max_p, *i);
1055  }
1056 }
1057 
1058 ////////////////////////////////////////////////////////////////////////////////
1059 /// Select visibility of el's children tracks by momentum.
1060 
1062 {
1063  const Double_t minpsq = min_p*min_p;
1064  const Double_t maxpsq = max_p*max_p;
1065 
1066  for (List_i i=el->BeginChildren(); i!=el->EndChildren(); ++i)
1067  {
1068  TEveTrack* track = dynamic_cast<TEveTrack*>(*i);
1069  if (track)
1070  {
1071  const Double_t psq = ((TEveTrack*)(*i))->fP.Mag2();
1072  Bool_t on = psq >= minpsq && psq <= maxpsq;
1073  track->SetRnrState(on);
1074  if (on && fRecurse)
1075  SelectByP(min_p, max_p, *i);
1076  }
1077  }
1078 }
1079 
1080 ////////////////////////////////////////////////////////////////////////////////
1081 /// Find track by label, select it and display it in the editor.
1082 
1084 {
1085  for (List_i i=fChildren.begin(); i!=fChildren.end(); ++i)
1086  {
1087  if (((TEveTrack*)(*i))->GetLabel() == label)
1088  {
1089  TGListTree *lt = gEve->GetLTEFrame()->GetListTree();
1090  TGListTreeItem *mlti = lt->GetSelected();
1091  if (mlti->GetUserData() != this)
1092  mlti = FindListTreeItem(lt);
1093  TGListTreeItem *tlti = (*i)->FindListTreeItem(lt, mlti);
1094  lt->HighlightItem(tlti);
1095  lt->SetSelected(tlti);
1096  gEve->EditElement(*i);
1097  return (TEveTrack*) *i;
1098  }
1099  }
1100  return 0;
1101 }
1102 
1103 ////////////////////////////////////////////////////////////////////////////////
1104 /// Find track by index, select it and display it in the editor.
1105 
1107 {
1108  for (List_i i=fChildren.begin(); i!=fChildren.end(); ++i)
1109  {
1110  if (((TEveTrack*)(*i))->GetIndex() == index)
1111  {
1112  TGListTree *lt = gEve->GetLTEFrame()->GetListTree();
1113  TGListTreeItem *mlti = lt->GetSelected();
1114  if (mlti->GetUserData() != this)
1115  mlti = FindListTreeItem(lt);
1116  TGListTreeItem *tlti = (*i)->FindListTreeItem(lt, mlti);
1117  lt->HighlightItem(tlti);
1118  lt->SetSelected(tlti);
1119  gEve->EditElement(*i);
1120  return (TEveTrack*) *i;
1121  }
1122  }
1123  return 0;
1124 }
1125 
1126 ////////////////////////////////////////////////////////////////////////////////
1127 /// Copy visualization parameters from element el.
1128 
1130 {
1131  const TEveTrackList* m = dynamic_cast<const TEveTrackList*>(el);
1132  if (m)
1133  {
1136  fRecurse = m->fRecurse;
1137  fRnrLine = m->fRnrLine;
1138  fRnrPoints = m->fRnrPoints;
1139  fMinPt = m->fMinPt;
1140  fMaxPt = m->fMaxPt;
1141  fLimPt = m->fLimPt;
1142  fMinP = m->fMinP;
1143  fMaxP = m->fMaxP;
1144  fLimP = m->fLimP;
1145  }
1146 
1148 }
1149 
1150 ////////////////////////////////////////////////////////////////////////////////
1151 /// Write visualization parameters.
1152 
1153 void TEveTrackList::WriteVizParams(std::ostream& out, const TString& var)
1154 {
1155  TEveElement::WriteVizParams(out, var);
1156 
1157  TString t = " " + var + "->";
1159  TAttLine ::SaveLineAttributes (out, var);
1160  out << t << "SetRecurse(" << ToString(fRecurse) << ");\n";
1161  out << t << "SetRnrLine(" << ToString(fRnrLine) << ");\n";
1162  out << t << "SetRnrPoints(" << ToString(fRnrPoints) << ");\n";
1163  // These setters are not available -- need proper AND/OR mode.
1164  // out << t << "SetMinPt(" << fMinPt << ");\n";
1165  // out << t << "SetMaxPt(" << fMaxPt << ");\n";
1166  // out << t << "SetLimPt(" << fLimPt << ");\n";
1167  // out << t << "SetMinP(" << fMinP << ");\n";
1168  // out << t << "SetMaxP(" << fMaxP << ");\n";
1169  // out << t << "SetLimP(" << fLimP << ");\n";
1170 }
1171 
1172 ////////////////////////////////////////////////////////////////////////////////
1173 /// Virtual from TEveProjectable, returns TEveTrackListProjected class.
1174 
1176 {
1178 }
TEveTrackPropagator::IsOutsideBounds
static Bool_t IsOutsideBounds(const TEveVectorD &point, Double_t maxRsqr, Double_t maxZ)
Definition: TEveTrackPropagator.h:352
TEveElement::HasChildren
Bool_t HasChildren() const
Definition: TEveElement.h:171
TEveTrackList::fMaxP
Double_t fMaxP
Definition: TEveTrack.h:159
TEveTrack::SortPathMarksByTime
void SortPathMarksByTime()
Sort registered pat-marks by time.
Definition: TEveTrack.cxx:514
TEveTrack::SetAttLineAttMarker
void SetAttLineAttMarker(TEveTrackList *tl)
Set line and marker attributes from TEveTrackList.
Definition: TEveTrack.cxx:318
TEveLine::SetLineWidth
virtual void SetLineWidth(Width_t lwidth)
Set line-style of the line.
Definition: TEveLine.cxx:106
TAttLine::fLineColor
Color_t fLineColor
Line color.
Definition: TAttLine.h:21
TEveVectorT::Mag
TT Mag() const
Definition: TEveVector.h:99
TEveLine::SetRnrPoints
void SetRnrPoints(Bool_t r)
Set rendering of points. Propagate to projected lines.
Definition: TEveLine.cxx:144
TEveRecTrackT
Definition: TEveVSDStructs.h:130
TPolyMarker3D::Size
virtual Int_t Size() const
Definition: TPolyMarker3D.h:73
m
auto * m
Definition: textangle.C:8
TEvePathMarkT
Special-point on track:
Definition: TEvePathMark.h:23
n
const Int_t n
Definition: legend1.C:16
TEveLine::SetMarkerColor
virtual void SetMarkerColor(Color_t col)
Set marker color. Propagate to projected lines.
Definition: TEveLine.cxx:66
TEveTrackPropagator::GetFitCluster2Ds
Bool_t GetFitCluster2Ds() const
Definition: TEveTrackPropagator.h:327
TEveTrackList::SetMarkerSize
virtual void SetMarkerSize(Size_t s)
Set marker size for the list and the elements.
Definition: TEveTrack.cxx:961
TPolyMarker3D::SetName
virtual void SetName(const char *name)
Change (i.e.
Definition: TPolyMarker3D.cxx:536
TPolyMarker3D::fP
Float_t * fP
Definition: TPolyMarker3D.h:36
TEveElement
Base class for TEveUtil visualization elements, providing hierarchy management, rendering control and...
Definition: TEveElement.h:36
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:100
TEveVectorT::fZ
TT fZ
Definition: TEveVector.h:30
e
#define e(i)
Definition: RSha256.hxx:103
Style_t
short Style_t
Definition: RtypesCore.h:89
TEvePointSet.h
TEveTrack::vPathMark_i
vPathMark_t::iterator vPathMark_i
Definition: TEveTrack.h:43
TEveTrack::WriteVizParams
virtual void WriteVizParams(std::ostream &out, const TString &var)
Write visualization parameters.
Definition: TEveTrack.cxx:487
TGPicture
The TGPicture class implements pictures and icons used in the different GUI elements and widgets.
Definition: TGPicture.h:25
TEveLine::SetLineColor
virtual void SetLineColor(Color_t col)
Set the line color.
Definition: TEveLine.h:48
TEveTrackList::~TEveTrackList
virtual ~TEveTrackList()
Destructor.
Definition: TEveTrack.cxx:613
TEveTrack::vPathMark_ci
vPathMark_t::const_iterator vPathMark_ci
Definition: TEveTrack.h:44
TEveTrack::RefPathMarks
vPathMark_t & RefPathMarks()
Definition: TEveTrack.h:111
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
TEveTrackList::fRecurse
Bool_t fRecurse
Definition: TEveTrack.h:150
TEveTrackList::FindTrackByLabel
TEveTrack * FindTrackByLabel(Int_t label)
Find track by label, select it and display it in the editor.
Definition: TEveTrack.cxx:1083
TParticle
Description of the dynamic properties of a particle.
Definition: TParticle.h:26
TEveTrack::fLabel
Int_t fLabel
Definition: TEveTrack.h:57
TEveTrackList::SetPropagator
void SetPropagator(TEveTrackPropagator *prop)
Set default propagator for tracks.
Definition: TEveTrack.cxx:623
TEveTrackPropagator::GoToVertex
virtual Bool_t GoToVertex(TEveVectorD &v, TEveVectorD &p)
Propagate particle with momentum p to vertex v.
Definition: TEveTrackPropagator.cxx:382
TEvePointSet::SetTitle
virtual void SetTitle(const char *t)
Definition: TEvePointSet.h:69
TEveTrackPropagator::GetFitDaughters
Bool_t GetFitDaughters() const
Definition: TEveTrackPropagator.h:324
TEveTrack::ComputeBBox
virtual void ComputeBBox()
Compute the bounding box of the track.
Definition: TEveTrack.cxx:239
TEveVectorT::Perp
TT Perp() const
Definition: TEveVector.h:102
TString::Data
const char * Data() const
Definition: TString.h:369
TEveTrackList::fRnrPoints
Bool_t fRnrPoints
Definition: TEveTrack.h:153
ROOT::Math::Cephes::P
static double P[]
Definition: SpecFuncCephes.cxx:285
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
Form
char * Form(const char *fmt,...)
TEveElement::CopyVizParams
virtual void CopyVizParams(const TEveElement *el)
Copy visualization parameters from element el.
Definition: TEveElement.cxx:462
TAttMarker::GetMarkerSize
virtual Size_t GetMarkerSize() const
Return the marker size.
Definition: TAttMarker.h:33
TEveLine::WriteVizParams
virtual void WriteVizParams(std::ostream &out, const TString &var)
Write visualization parameters.
Definition: TEveLine.cxx:277
TEveProjection
Base-class for non-linear projections.
Definition: TEveProjections.h:27
TEveTrack::CopyVizParams
virtual void CopyVizParams(const TEveElement *el)
Copy visualization parameters from element el.
Definition: TEveTrack.cxx:473
TEveTrackList::FindTrackByIndex
TEveTrack * FindTrackByIndex(Int_t index)
Find track by index, select it and display it in the editor.
Definition: TEveTrack.cxx:1106
TEveTrackList::fMinP
Double_t fMinP
Definition: TEveTrack.h:158
TEveTrackPropagator::GetCurrentPoint
Int_t GetCurrentPoint() const
Get index of current point on track.
Definition: TEveTrackPropagator.cxx:358
TEveElement::fMainColorPtr
Color_t * fMainColorPtr
Definition: TEveElement.h:99
TEveTrack.h
TEvePathMarkT::kDecay
@ kDecay
Definition: TEvePathMark.h:25
TGListTree::HighlightItem
void HighlightItem(TGListTreeItem *item)
Highlight item.
Definition: TGListTree.cxx:2379
TEveTrack::fP
TEveVectorD fP
Definition: TEveTrack.h:51
TParticlePDG
Description of the static properties of a particle.
Definition: TParticlePDG.h:19
TParticle::GetPDG
TParticlePDG * GetPDG(Int_t mode=0) const
Returns a pointer to the TParticlePDG object using the pdgcode.
Definition: TParticle.cxx:273
TParticlePDG::PdgCode
Int_t PdgCode() const
Definition: TParticlePDG.h:66
TGListTree::GetSelected
TGListTreeItem * GetSelected() const
Definition: TGListTree.h:382
TEveElement::ToString
static const char * ToString(Bool_t b)
Convert Bool_t to string - kTRUE or kFALSE.
Definition: TEveElement.cxx:2067
operator=
Binding & operator=(OUT(*fun)(void))
Definition: TRInterface_Binding.h:15
Float_t
float Float_t
Definition: RtypesCore.h:57
width
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition: TDocParser.cxx:121
TEveTrackPropagator::InitTrack
void InitTrack(const TEveVectorD &v, Int_t charge)
Initialize internal data-members for given particle parameters.
Definition: TEveTrackPropagator.cxx:324
TEveElement::fgListTreeIcons
static const TGPicture * fgListTreeIcons[9]
Definition: TEveElement.h:65
TEveTrackPropagator.h
Int_t
int Int_t
Definition: RtypesCore.h:45
TEvePointSet::SetMarkerSize
virtual void SetMarkerSize(Size_t msize=1)
Set marker size, propagate to projecteds.
Definition: TEvePointSet.cxx:262
kMinInt
const Int_t kMinInt
Definition: RtypesCore.h:113
TAttBBox::BBoxZero
void BBoxZero(Float_t epsilon=0, Float_t x=0, Float_t y=0, Float_t z=0)
Create cube of volume (2*epsilon)^3 at (x,y,z).
Definition: TAttBBox.cxx:42
TEveTrack::fV
TEveVectorD fV
Definition: TEveTrack.h:50
TGListTree
A list tree is a widget that can contain a number of items arranged in a tree structure.
Definition: TGListTree.h:195
TParticlePDG.h
TEveTrackList::fRnrLine
Bool_t fRnrLine
Definition: TEveTrack.h:152
TAttLine::SaveLineAttributes
virtual void SaveLineAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t widdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition: TAttLine.cxx:273
TEveVectorT::fY
TT fY
Definition: TEveVector.h:30
x
Double_t x[n]
Definition: legend1.C:17
TEveTrackList
A list of tracks supporting change of common attributes and selection based on track parameters.
Definition: TEveTrack.h:140
TEvePathMarkT::kReference
@ kReference
Definition: TEvePathMark.h:25
operator()
TRObject operator()(const T1 &t1) const
Definition: TRFunctionImport__oprtr.h:14
TEveTrackList::SetMainColor
virtual void SetMainColor(Color_t c)
Set main (line) color for the list and the elements.
Definition: TEveTrack.cxx:801
TAttMarker::GetMarkerStyle
virtual Style_t GetMarkerStyle() const
Return the marker style.
Definition: TAttMarker.h:32
TEveTrack::fPdg
Int_t fPdg
Definition: TEveTrack.h:55
TEveTrack::fIndex
Int_t fIndex
Definition: TEveTrack.h:58
TEveMCTrack
Definition: TEveVSDStructs.h:43
TEveTrackPropagator::GoToLineSegment
virtual Bool_t GoToLineSegment(const TEveVectorD &s, const TEveVectorD &r, TEveVectorD &p)
Propagate particle with momentum p to line with start point s and vector r to the second point.
Definition: TEveTrackPropagator.cxx:399
TEveElement::fChildren
List_t fChildren
Definition: TEveElement.h:81
TAttLine::fLineWidth
Width_t fLineWidth
Line width.
Definition: TAttLine.h:23
TEveTrackList::fMaxPt
Double_t fMaxPt
Definition: TEveTrack.h:156
TString
Basic string class.
Definition: TString.h:136
TEveTrackProjected.h
TEveElement::List_i
List_t::iterator List_i
Definition: TEveElement.h:72
TEvePointSet::SetMarkerStyle
virtual void SetMarkerStyle(Style_t mstyle=1)
Set marker style, propagate to projecteds.
Definition: TEvePointSet.cxx:241
TEveTrackList::SelectByPt
void SelectByPt(Double_t min_pt, Double_t max_pt)
Select visibility of tracks by transverse momentum.
Definition: TEveTrack.cxx:995
Color_t
short Color_t
Definition: RtypesCore.h:92
TEveTrackPropagator::GetTrackLength
Double_t GetTrackLength(Int_t start_point=0, Int_t end_point=-1) const
Calculate track length from start_point to end_point.
Definition: TEveTrackPropagator.cxx:367
TEveElement::SetRnrState
virtual Bool_t SetRnrState(Bool_t rnr)
Set render state of this element and of its children to the same value.
Definition: TEveElement.cxx:1127
TEvePathMarkT::kLineSegment
@ kLineSegment
Definition: TEvePathMark.h:25
TEveElementList
A list of TEveElements.
Definition: TEveElement.h:433
gEve
R__EXTERN TEveManager * gEve
Definition: TEveManager.h:243
b
#define b(i)
Definition: RSha256.hxx:100
TEveTrackPropagator::ResetTrack
void ResetTrack()
Reset cache holding particle trajectory.
Definition: TEveTrackPropagator.cxx:346
bool
TPolyMarker3D.h
TEvePathMarkT::kDaughter
@ kDaughter
Definition: TEvePathMark.h:25
TAttBBox::BBoxCheckPoint
void BBoxCheckPoint(Float_t x, Float_t y, Float_t z)
Definition: TAttBBox.h:58
style
TCanvas * style()
Definition: style.C:1
TObject::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
TEveTrackList::fPropagator
TEveTrackPropagator * fPropagator
Definition: TEveTrack.h:148
TEveTrackList::RoundMomentumLimit
Double_t RoundMomentumLimit(Double_t x)
Round the momentum limit up to a nice value.
Definition: TEveTrack.cxx:710
TEveLine::GetRnrLine
Bool_t GetRnrLine() const
Definition: TEveLine.h:52
TAttMarker::SaveMarkerAttributes
virtual void SaveMarkerAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t sizdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition: TAttMarker.cxx:343
TEveTrack::fDpDs
Double_t fDpDs
Definition: TEveTrack.h:54
TEveTrack::fPEnd
TEveVectorD fPEnd
Definition: TEveTrack.h:52
TEveTrackPropagator::GetFitLineSegments
Bool_t GetFitLineSegments() const
Definition: TEveTrackPropagator.h:328
TEveTrackList::SelectByP
void SelectByP(Double_t min_p, Double_t max_p)
Select visibility of tracks by momentum.
Definition: TEveTrack.cxx:1040
TMath::Nint
Int_t Nint(T x)
Round to nearest integer. Rounds half integers to the nearest even integer.
Definition: TMath.h:713
TEveTrackPropagator::GetMaxZ
Double_t GetMaxZ() const
Definition: TEveTrackPropagator.h:312
TEveLine::GetRnrPoints
Bool_t GetRnrPoints() const
Definition: TEveLine.h:53
TEveTrack::fLockPoints
Bool_t fLockPoints
Definition: TEveTrack.h:60
TAttLine
Line Attributes class.
Definition: TAttLine.h:18
TMath::Log10
Double_t Log10(Double_t x)
Definition: TMath.h:764
TEveTrack::MakeTrack
virtual void MakeTrack(Bool_t recurse=kTRUE)
Calculate track representation based on track data and current settings of the propagator.
Definition: TEveTrack.cxx:336
TEveTrackList::TEveTrackList
TEveTrackList(const TEveTrackList &)
TParticle::GetName
virtual const char * GetName() const
Return particle name.
Definition: TParticle.cxx:257
TAttLine::GetLineColor
virtual Color_t GetLineColor() const
Return the line color.
Definition: TAttLine.h:33
TGListTree::SetSelected
void SetSelected(TGListTreeItem *item)
Definition: TGListTree.h:353
size
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
TEveTrack::ProjectedClass
virtual TClass * ProjectedClass(const TEveProjection *p) const
Virtual from TEveProjectable, return TEveTrackProjected class.
Definition: TEveTrack.cxx:497
TMath::Floor
Double_t Floor(Double_t x)
Definition: TMath.h:703
TParticlePDG::Charge
Double_t Charge() const
Definition: TParticlePDG.h:68
TEveRefBackPtr::IncRefCount
virtual void IncRefCount(TEveElement *re)
Increase reference count and add re to the list of back-references.
Definition: TEveUtil.cxx:577
a
auto * a
Definition: textangle.C:12
TEveManager::EditElement
void EditElement(TEveElement *element)
Show element in default editor.
Definition: TEveManager.cxx:354
TEvePathMarkT::kCluster2D
@ kCluster2D
Definition: TEvePathMark.h:25
TAttLine::GetLineStyle
virtual Style_t GetLineStyle() const
Return the line style.
Definition: TAttLine.h:34
Width_t
short Width_t
Definition: RtypesCore.h:91
TEveTrackList::SetRnrPoints
void SetRnrPoints(Bool_t r)
Set rendering of track as points for the list and the elements.
Definition: TEveTrack.cxx:768
TEveTrack::fCharge
Int_t fCharge
Definition: TEveTrack.h:56
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:101
TEveLine::SetRnrLine
void SetRnrLine(Bool_t r)
Set rendering of line. Propagate to projected lines.
Definition: TEveLine.cxx:125
TEveTrackList::MakeTracks
void MakeTracks(Bool_t recurse=kTRUE)
Regenerate the visual representations of tracks.
Definition: TEveTrack.cxx:635
TEveTrackList::SanitizeMinMaxCuts
void SanitizeMinMaxCuts()
Set Min/Max cuts so that they are within detected limits.
Definition: TEveTrack.cxx:723
TEveElementList::fChildClass
TClass * fChildClass
Definition: TEveElement.h:439
TEveTrackList::SetMarkerColor
virtual void SetMarkerColor(Color_t c)
Set marker color for the list and the elements.
Definition: TEveTrack.cxx:929
TEveTrackList::GetRnrPoints
Bool_t GetRnrPoints() const
Definition: TEveTrack.h:203
TEveTrackPropagator::GetFitReferences
Bool_t GetFitReferences() const
Definition: TEveTrackPropagator.h:325
TEveTrackPropagator
Holding structure for a number of track rendering parameters.
Definition: TEveTrackPropagator.h:123
TMath::Power
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Definition: TMath.h:735
TEveTrackList::fMinPt
Double_t fMinPt
Definition: TEveTrack.h:155
TEveRefBackPtr::DecRefCount
virtual void DecRefCount(TEveElement *re)
Decrease reference count and remove re from the list of back-references.
Definition: TEveUtil.cxx:586
TEveTrackList::WriteVizParams
virtual void WriteVizParams(std::ostream &out, const TString &var)
Write visualization parameters.
Definition: TEveTrack.cxx:1153
TEveTrackList::SetLineStyle
virtual void SetLineStyle(Style_t s)
Set line style for the list and the elements.
Definition: TEveTrack.cxx:865
TAttMarker
Marker Attributes class.
Definition: TAttMarker.h:19
TEveTrackList::GetRnrLine
Bool_t GetRnrLine() const
Definition: TEveTrack.h:199
TEveTrackPropagator::fgDefault
static TEveTrackPropagator fgDefault
Definition: TEveTrackPropagator.h:343
TEveTrack::PrintPathMarks
void PrintPathMarks()
Print registered path-marks.
Definition: TEveTrack.cxx:522
TAttBBox::BBoxInit
void BBoxInit(Float_t infinity=1e6)
Dynamic Float_t[6] X(min,max), Y(min,max), Z(min,max)
Definition: TAttBBox.cxx:29
TEveVectorT< Double_t >
TEveTrackList::SetRnrLine
void SetRnrLine(Bool_t rnr)
Set rendering of track as line for the list and the elements.
Definition: TEveTrack.cxx:736
TEveGListTreeEditorFrame::GetListTree
TGListTree * GetListTree() const
Definition: TEveBrowser.h:114
TAttMarker::GetMarkerColor
virtual Color_t GetMarkerColor() const
Return the marker color.
Definition: TAttMarker.h:31
TEveTrackList::fLimPt
Double_t fLimPt
Definition: TEveTrack.h:157
TEveTrackList::SetLineWidth
virtual void SetLineWidth(Width_t w)
Set line width for the list and the elements.
Definition: TEveTrack.cxx:833
TObject::Warning
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:879
TEveTrackList::FindMomentumLimits
void FindMomentumLimits(TEveElement *el, Bool_t recurse=kTRUE)
Loop over track elements of argument el and find highest pT and p.
Definition: TEveTrack.cxx:692
TEveVectorT::Perp2
TT Perp2() const
Definition: TEveVector.h:101
TEveLine
An arbitrary polyline with fixed line and marker attributes.
Definition: TEveLine.h:26
TMath::Min
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180
TEveTrackList::fLimP
Double_t fLimP
Definition: TEveTrack.h:160
TEvePointSet::ClonePoints
virtual void ClonePoints(const TEvePointSet &e)
Clone points and all point-related information from point-set 'e'.
Definition: TEvePointSet.cxx:111
TEveTrack
Visual representation of a track.
Definition: TEveTrack.h:33
TEveTrackPropagator::GoToBounds
virtual void GoToBounds(TEveVectorD &p)
Propagate particle to bounds.
Definition: TEveTrackPropagator.cxx:442
TEveTrack::fPathMarks
vPathMark_t fPathMarks
Definition: TEveTrack.h:61
Longptr_t
long Longptr_t
Definition: RtypesCore.h:82
TEveManager::GetLTEFrame
TEveGListTreeEditorFrame * GetLTEFrame() const
Definition: TEveManager.h:138
TEveTrackPropagator::IntersectPlane
Bool_t IntersectPlane(const TEveVectorD &p, const TEveVectorD &point, const TEveVectorD &normal, TEveVectorD &itsect)
Find intersection of currently propagated track with a plane.
Definition: TEveTrackPropagator.cxx:941
TEveTrack::SetPropagator
void SetPropagator(TEveTrackPropagator *prop)
Set track's render style.
Definition: TEveTrack.cxx:307
TEveTrack::fLastPMIdx
Int_t fLastPMIdx
Definition: TEveTrack.h:62
TEveManager.h
TEveTrack::fPropagator
TEveTrackPropagator * fPropagator
Last path-mark index tried in track-propagation.
Definition: TEveTrack.h:64
Double_t
double Double_t
Definition: RtypesCore.h:59
TEveLine::CopyVizParams
virtual void CopyVizParams(const TEveElement *el)
Copy visualization parameters from element el.
Definition: TEveLine.cxx:260
TEveVSD.h
TEveException
Exception class thrown by TEve classes and macros.
Definition: TEveUtil.h:102
TPolyMarker3D::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TPolyMarker3D.h:57
TEveTrack::~TEveTrack
virtual ~TEveTrack()
Destructor.
Definition: TEveTrack.cxx:222
TEveBrowser.h
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
TGListTreeItem::GetUserData
virtual void * GetUserData() const =0
TEveTrackPropagator::GetFitDecay
Bool_t GetFitDecay() const
Definition: TEveTrackPropagator.h:326
TEveVectorT::fX
TT fX
Definition: TEveVector.h:30
TEveElement::SetMainColor
virtual void SetMainColor(Color_t color)
Set main color of the element.
Definition: TEveElement.cxx:1158
TEveElement::WriteVizParams
virtual void WriteVizParams(std::ostream &out, const TString &var)
Write-out visual parameters for this object.
Definition: TEveElement.cxx:521
TEveElement::BeginChildren
List_i BeginChildren()
Definition: TEveElement.h:166
TEveTrack::GetListTreeIcon
virtual const TGPicture * GetListTreeIcon(Bool_t open=kFALSE)
Returns list-tree icon for TEveTrack.
Definition: TEveTrack.cxx:231
TAttMarker::fMarkerColor
Color_t fMarkerColor
Marker color.
Definition: TAttMarker.h:22
TEveTrackList::CopyVizParams
virtual void CopyVizParams(const TEveElement *el)
Copy visualization parameters from element el.
Definition: TEveTrack.cxx:1129
name
char name[80]
Definition: TGX11.cxx:110
TAttMarker::fMarkerStyle
Style_t fMarkerStyle
Marker style.
Definition: TAttMarker.h:23
TEveElement::FindListTreeItem
virtual TGListTreeItem * FindListTreeItem(TGListTree *ltree)
Find any list-tree-item of this element in list-tree 'ltree'.
Definition: TEveElement.cxx:909
TEveTrack::fBeta
Double_t fBeta
Definition: TEveTrack.h:53
TEveTrackPropagator::FillPointSet
void FillPointSet(TEvePointSet *ps) const
Reset ps and populate it with points in propagation cache.
Definition: TEveTrackPropagator.cxx:1005
TEveTrack::SetPathMarks
virtual void SetPathMarks(const TEveTrack &t)
Copy path-marks from t.
Definition: TEveTrack.cxx:297
TEveTrackList::SetMarkerStyle
virtual void SetMarkerStyle(Style_t s)
Set marker style for the list and the elements.
Definition: TEveTrack.cxx:897
TAttLine::GetLineWidth
virtual Width_t GetLineWidth() const
Return the line width.
Definition: TAttLine.h:35
TEveElement::EndChildren
List_i EndChildren()
Definition: TEveElement.h:167
TAttLine::fLineStyle
Style_t fLineStyle
Line style.
Definition: TAttLine.h:22
Class
void Class()
Definition: Class.C:29
TAttMarker::fMarkerSize
Size_t fMarkerSize
Marker size.
Definition: TAttMarker.h:24
TGListTreeItem
Definition: TGListTree.h:27
TEveTrack::SecSelected
virtual void SecSelected(TEveTrack *)
Emits "SecSelected(TEveTrack*)" signal.
Definition: TEveTrack.cxx:546
TEveTrackList::ProjectedClass
virtual TClass * ProjectedClass(const TEveProjection *p) const
Virtual from TEveProjectable, returns TEveTrackListProjected class.
Definition: TEveTrack.cxx:1175
TEvePointSet::Reset
void Reset(Int_t n_points=0, Int_t n_int_ids=0)
Drop all data and set-up the data structures to recive new data.
Definition: TEvePointSet.cxx:148
TEveTrack::SetTrackParams
virtual void SetTrackParams(const TEveTrack &t)
Copy track parameters from t.
Definition: TEveTrack.cxx:280
TEveTrack::SetStdTitle
virtual void SetStdTitle()
Set standard track title based on most data-member values.
Definition: TEveTrack.cxx:264
TEveTrack::TEveTrack
TEveTrack()
Default constructor.
Definition: TEveTrack.cxx:45
TMath::Ceil
Double_t Ceil(Double_t x)
Definition: TMath.h:695
TEveLine::SetLineStyle
virtual void SetLineStyle(Style_t lstyle)
Set line-style of the line.
Definition: TEveLine.cxx:86
TEveTrackList::SetLineColor
virtual void SetLineColor(Color_t c)
Set the line color.
Definition: TEveTrack.h:183
TMath
TMath.
Definition: TMathBase.h:35
TQObject::Emit
void Emit(const char *signal, const T &arg)
Activate signal with single parameter.
Definition: TQObject.h:164
TEveTrackPropagator::GetMaxR
Double_t GetMaxR() const
Definition: TEveTrackPropagator.h:311
TParticle.h
int
Size_t
float Size_t
Definition: RtypesCore.h:96