[u/mrichter/AliRoot.git] / EVE / Reve / Track.cxx

// $Header$

#include "Track.h"
#include "MCHelixLine.hi"

#include <TPolyLine3D.h>
#include <TPolyMarker3D.h>
#include <TColor.h>

// Updates
#include <Reve/RGTopFrame.h>
#include <TCanvas.h>

#include <vector>

using namespace Reve;

//______________________________________________________________________
// Track
//

ClassImp(Reve::Track)

Track::Track() :
  RenderElement(),
  TPolyLine3D(),

  fV(),
  fP(),
  fBeta(0),
  fCharge(0),
  fLabel(0),
  fPathMarks(),

  fRnrStyle(0),

  fName(),
  fTitle()
{}

Track::Track(Reve::MCTrack* t, TrackRnrStyle* rs):
  RenderElement(),
  TPolyLine3D(),

  fV(t->Vx(), t->Vy(), t->Vz()),
  fP(t->Px(), t->Py(), t->Pz()),
  fBeta(t->P()/t->Energy()),
  fCharge(0),
  fLabel(t->label),
  fPathMarks(),

  fRnrStyle(rs),

  fName(t->GetName()),
  fTitle()
{
  fLineColor = fRnrStyle->GetColor();
  fMainColorPtr = &fLineColor;

  TParticlePDG* pdgp = t->GetPDG();
  if(pdgp == 0) {
    t->ResetPdgCode(); pdgp = t->GetPDG();
  }
  fCharge = (Int_t) TMath::Nint(pdgp->Charge()/3);
}

Track::Track(Reve::RecTrack* t, TrackRnrStyle* rs) :
  RenderElement(),
  TPolyLine3D(),

  fV(t->V),
  fP(t->P),
  fBeta(t->beta),
  fCharge(t->sign),
  fLabel(t->label),
  fPathMarks(),

  fRnrStyle(rs),

  fName(t->GetName()),
  fTitle()
{
  fLineColor = fRnrStyle->GetColor();
  fMainColorPtr = &fLineColor;
}

Track::~Track()
{
  for (vpPathMark_i i=fPathMarks.begin(); i!=fPathMarks.end(); ++i)
    delete *i;
}

void Track::Reset(Int_t n_points)
{
  delete [] TPolyLine3D::fP; TPolyLine3D::fP = 0;
  fN = n_points;
  if(fN) TPolyLine3D::fP = new Float_t [3*fN];
  memset(TPolyLine3D::fP, 0, 3*fN*sizeof(Float_t));
  fLastPoint = -1;
}

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

void Track::MakeTrack()
{
  
  TrackRnrStyle& RS((fRnrStyle != 0) ? *fRnrStyle : TrackRnrStyle::fgDefStyle);

  Float_t px = fP.x, py = fP.y, pz = fP.z;  

  MCVertex  mc_v0;
  mc_v0.x = fV.x;
  mc_v0.y = fV.y; 
  mc_v0.z = fV.z; 
  mc_v0.t = 0;

  std::vector<MCVertex> track_points;
  Bool_t decay = kFALSE;

  if ((TMath::Abs(fV.z) > RS.fMaxZ) || (fV.x*fV.x + fV.y*fV.y > RS.fMaxR*RS.fMaxR)) 
    goto make_polyline;
  
  if (fCharge != 0 && TMath::Abs(RS.fMagField) > 1e-5) {

    // Charged particle in magnetic field

    Float_t a = RS.fgkB2C * RS.fMagField * fCharge;
   
    MCHelix helix(fRnrStyle, &mc_v0, TMath::C()*fBeta, &track_points, a); //m->cm
    helix.Init(TMath::Sqrt(px*px+py*py), pz);
   
    if(!fPathMarks.empty()){
      for(std::vector<Reve::PathMark*>::iterator i=fPathMarks.begin(); i!=fPathMarks.end(); ++i) {
	Reve::PathMark* pm = *i;
        
	if(RS.fFitDaughters &&  pm->type == Reve::PathMark::Daughter){
	  if(TMath::Abs(pm->V.z) > RS.fMaxZ 
	     || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
	    goto helix_bounds;

          //printf("%s fit daughter  \n", fName.Data()); 
	  helix.LoopToVertex(fP.x, fP.y, fP.z, pm->V.x, pm->V.y, pm->V.z);
	  fP.x -=  pm->P.x;
	  fP.y -=  pm->P.y;
	  fP.z -=  pm->P.z;
	}
	if(RS.fFitDecay &&  pm->type == Reve::PathMark::Decay){
	  
	  if(TMath::Abs(pm->V.z) > RS.fMaxZ 
	     || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
	    goto helix_bounds;
	  helix.LoopToVertex(fP.x, fP.y, fP.z, pm->V.x, pm->V.y, pm->V.z);
          decay = true;
          break;
	}
      }
    }
  helix_bounds:
    //go to bounds
    if(!decay || RS.fFitDecay == kFALSE){
      helix.LoopToBounds(px,py,pz);
      // printf("%s loop to bounds  \n",fName.Data() );
    }

  } else {

    // Neutral particle or no field

    MCLine line(fRnrStyle, &mc_v0, TMath::C()*fBeta, &track_points);
   
    if(!fPathMarks.empty()){
      for(std::vector<Reve::PathMark*>::iterator i=fPathMarks.begin(); i!=fPathMarks.end(); ++i) {
	Reve::PathMark* pm = *i;

	if(RS.fFitDaughters &&  pm->type == Reve::PathMark::Daughter){
          if(TMath::Abs(pm->V.z) > RS.fMaxZ 
	     || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
	    goto line_bounds;
	  line.GotoVertex(pm->V.x, pm->V.y, pm->V.z);
	  fP.x -=  pm->P.x;
	  fP.y -=  pm->P.y;
	  fP.z -=  pm->P.z;
	}

	if(RS.fFitDecay &&  pm->type == Reve::PathMark::Decay){
	  if(TMath::Abs(pm->V.z) > RS.fMaxZ 
	     || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
	    goto line_bounds;
	  line.GotoVertex(pm->V.x, pm->V.y, pm->V.z);
          decay = true;
	  break;
	}
      }
    }

  line_bounds:
    if(!decay || RS.fFitDecay == kFALSE)
      line.GotoBounds(px,py,pz);

  }
make_polyline:
  Reset(track_points.size());
  for(std::vector<MCVertex>::iterator i=track_points.begin(); i!=track_points.end(); ++i)
    SetNextPoint(i->x, i->y, i->z);
}

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

void Track::ImportHits()
{
  Reve::LoadMacro("hits_from_label.C");
  gROOT->ProcessLine(Form("hits_from_label(%d);", fLabel));
}

void Track::ImportClusters()
{
  Reve::LoadMacro("clusters_from_label.C");
  gROOT->ProcessLine(Form("clusters_from_label(%d);", fLabel));
}


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

//______________________________________________________________________
// TrackRnrStyle
//

ClassImp(Reve::TrackRnrStyle)

Float_t       TrackRnrStyle::fgDefMagField = 5;
const Float_t TrackRnrStyle::fgkB2C        = 0.299792458e-3;
TrackRnrStyle TrackRnrStyle::fgDefStyle;

TrackRnrStyle::TrackRnrStyle() :
  TObject(),

  fColor(1),
  fMagField(fgDefMagField),

  fMaxR  (350),
  fMaxZ  (450),

  fMaxOrbs (0.5),
  fMinAng  (45),
  fDelta   (0.1),

  fFitDaughters(kTRUE),
  fFitDecay    (kTRUE)
{}

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

//______________________________________________________________________
// TrackList
//

ClassImp(Reve::TrackList)

void TrackList::Init()
{
  fMarkerStyle = 6;
  fMarkerColor = 5;
  // fMarker->SetMarkerSize(0.05);

  mRnrStyle = new TrackRnrStyle;
  SetMainColorPtr(&mRnrStyle->fColor);
}

TrackList::TrackList(Int_t n_tracks) :
  RenderElementListBase(),
  TPolyMarker3D(n_tracks),

  fTitle(),

  mRnrStyle   (0),
  fRnrMarkers (kTRUE),
  fRnrTracks  (kTRUE)
{
  Init();
}

TrackList::TrackList(const Text_t* name, Int_t n_tracks) :
  RenderElementListBase(),
  TPolyMarker3D(n_tracks),

  fTitle(),

  mRnrStyle   (0),
  fRnrMarkers (kTRUE),
  fRnrTracks  (kTRUE)
{
  Init();
  SetName(name);
}

void TrackList::Reset(Int_t n_tracks)
{
  delete [] fP; fP = 0;
  fN = n_tracks;
  if(fN) fP = new Float_t [3*fN];
  memset(fP, 0, 3*fN*sizeof(Float_t));
  fLastPoint = -1;
}

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

void TrackList::Paint(Option_t* option)
{
  if(fRnrElement) {
    if(fRnrMarkers) {
      TPolyMarker3D::Paint(option);
    }
    if(fRnrTracks) {
      for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
	if((*i)->GetRnrElement())
	  (*i)->GetObject()->Paint(option);
      }
    }
  }
}

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

void TrackList::AddElement(RenderElement* el)
{
  static const Exc_t eH("TrackList::AddElement ");
  if (dynamic_cast<Track*>(el)  == 0)
    throw(eH + "new element not a Track.");
  RenderElementListBase::AddElement(el);
}

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

void TrackList::SetRnrMarkers(Bool_t rnr)
{
  fRnrMarkers = rnr;
  gReve->Redraw3D();
}

void TrackList::SetRnrTracks(Bool_t rnr)
{

  fRnrTracks = rnr;
  gReve->Redraw3D();
}

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

void TrackList::MakeTracks()
{
  for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
    ((Track*)(*i))->MakeTrack();
  }
  gReve->Redraw3D();
}


void TrackList::MakeMarkers()
{
  Reset(fChildren.size());
  for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
    Track& t = *((Track*)(*i));
    if(t.GetN() > 0)
      SetNextPoint(t.fV.x, t.fV.y, t.fV.z);
  }
  gReve->Redraw3D();
}

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

void TrackList::SetMaxR(Float_t x)
{
  mRnrStyle->fMaxR = x;
  MakeTracks();
  MakeMarkers();
}

void TrackList::SetMaxZ(Float_t x)
{
  mRnrStyle->fMaxZ = x;
  MakeTracks();
  MakeMarkers();
}

void TrackList::SetMaxOrbs(Float_t x)
{
  mRnrStyle->fMaxOrbs = x;
  MakeTracks();
}

void TrackList::SetMinAng(Float_t x)
{
  mRnrStyle->fMinAng = x;
  MakeTracks();
}

void TrackList::SetDelta(Float_t x)
{
  mRnrStyle->fDelta = x;
  MakeTracks();
}

void TrackList::SetFitDaughters(Bool_t x)
{
  mRnrStyle->fFitDaughters = x;
  MakeTracks();
}

void TrackList::SetFitDecay(Bool_t x)
{
  mRnrStyle->fFitDecay = x;
  MakeTracks();
}

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

void TrackList::SelectByPt(Float_t min_pt, Float_t max_pt)
{
  Float_t minptsq = min_pt*min_pt;
  Float_t maxptsq = max_pt*max_pt;
  Float_t ptsq;

  for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
    ptsq = ((Track*)(*i))->fP.Perp2();
    (*i)->SetRnrElement(ptsq >= minptsq && ptsq <= maxptsq);
  }
}

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

void TrackList::ImportHits()
{
  for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
    ((Track*)(*i))->ImportHits();
  }
}

void TrackList::ImportClusters()
{
  for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
    ((Track*)(*i))->ImportClusters();
  }
}
Commit	Line	Data
5a5a1232	1	// $Header$
	2
	3	#include "Track.h"
	4	#include "MCHelixLine.hi"
	5
	6	#include <TPolyLine3D.h>
	7	#include <TPolyMarker3D.h>
	8	#include <TColor.h>
	9
	10	// Updates
	11	#include <Reve/RGTopFrame.h>
	12	#include <TCanvas.h>
	13
	14	#include <vector>
	15
	16	using namespace Reve;
	17
	18	//______________________________________________________________________
	19	// Track
	20	//
	21
	22	ClassImp(Reve::Track)
	23
265ecb21	24	Track::Track() :
	25	RenderElement(),
	26	TPolyLine3D(),
5a5a1232	27
265ecb21	28	fV(),
	29	fP(),
	30	fBeta(0),
	31	fCharge(0),
	32	fLabel(0),
	33	fPathMarks(),
	34
	35	fRnrStyle(0),
	36
	37	fName(),
	38	fTitle()
	39	{}
	40
	41	Track::Track(Reve::MCTrack* t, TrackRnrStyle* rs):
	42	RenderElement(),
	43	TPolyLine3D(),
5a5a1232	44
265ecb21	45	fV(t->Vx(), t->Vy(), t->Vz()),
	46	fP(t->Px(), t->Py(), t->Pz()),
	47	fBeta(t->P()/t->Energy()),
	48	fCharge(0),
	49	fLabel(t->label),
	50	fPathMarks(),
	51
	52	fRnrStyle(rs),
	53
	54	fName(t->GetName()),
	55	fTitle()
	56	{
5a5a1232	57	fLineColor = fRnrStyle->GetColor();
	58	fMainColorPtr = &fLineColor;
	59
5a5a1232	60	TParticlePDG* pdgp = t->GetPDG();
	61	if(pdgp == 0) {
	62	t->ResetPdgCode(); pdgp = t->GetPDG();
	63	}
48dc973d	64	fCharge = (Int_t) TMath::Nint(pdgp->Charge()/3);
5a5a1232	65	}
5a5a1232	66
265ecb21	67	Track::Track(Reve::RecTrack* t, TrackRnrStyle* rs) :
	68	RenderElement(),
	69	TPolyLine3D(),
	70
	71	fV(t->V),
	72	fP(t->P),
	73	fBeta(t->beta),
	74	fCharge(t->sign),
	75	fLabel(t->label),
	76	fPathMarks(),
	77
	78	fRnrStyle(rs),
	79
	80	fName(t->GetName()),
	81	fTitle()
5a5a1232	82	{
5a5a1232	83	fLineColor = fRnrStyle->GetColor();
5a5a1232	84	fMainColorPtr = &fLineColor;
5a5a1232	85	}
	86
	87	Track::~Track()
265ecb21	88	{
	89	for (vpPathMark_i i=fPathMarks.begin(); i!=fPathMarks.end(); ++i)
	90	delete *i;
	91	}
5a5a1232	92
	93	void Track::Reset(Int_t n_points)
	94	{
	95	delete [] TPolyLine3D::fP; TPolyLine3D::fP = 0;
	96	fN = n_points;
	97	if(fN) TPolyLine3D::fP = new Float_t [3*fN];
	98	memset(TPolyLine3D::fP, 0, 3fNsizeof(Float_t));
	99	fLastPoint = -1;
	100	}
	101
	102	/**************************************************************************/
	103
	104	void Track::MakeTrack()
	105	{
	106
	107	TrackRnrStyle& RS((fRnrStyle != 0) ? *fRnrStyle : TrackRnrStyle::fgDefStyle);
	108
	109	Float_t px = fP.x, py = fP.y, pz = fP.z;
	110
	111	MCVertex mc_v0;
	112	mc_v0.x = fV.x;
	113	mc_v0.y = fV.y;
	114	mc_v0.z = fV.z;
	115	mc_v0.t = 0;
	116
	117	std::vector<MCVertex> track_points;
48dc973d	118	Bool_t decay = kFALSE;
5a5a1232	119
	120	if ((TMath::Abs(fV.z) > RS.fMaxZ) \|\| (fV.xfV.x + fV.yfV.y > RS.fMaxR*RS.fMaxR))
	121	goto make_polyline;
	122
01024c63	123	if (fCharge != 0 && TMath::Abs(RS.fMagField) > 1e-5) {
	124
	125	// Charged particle in magnetic field
5a5a1232	126
48dc973d	127	Float_t a = RS.fgkB2C * RS.fMagField * fCharge;
5a5a1232	128
	129	MCHelix helix(fRnrStyle, &mc_v0, TMath::C()*fBeta, &track_points, a); //m->cm
	130	helix.Init(TMath::Sqrt(pxpx+pypy), pz);
	131
	132	if(!fPathMarks.empty()){
	133	for(std::vector<Reve::PathMark*>::iterator i=fPathMarks.begin(); i!=fPathMarks.end(); ++i) {
	134	Reve::PathMark* pm = *i;
	135
	136	if(RS.fFitDaughters && pm->type == Reve::PathMark::Daughter){
	137	if(TMath::Abs(pm->V.z) > RS.fMaxZ
	138	\|\| TMath::Sqrt(pm->V.xpm->V.x + pm->V.ypm->V.y) > RS.fMaxR )
	139	goto helix_bounds;
	140
	141	//printf("%s fit daughter \n", fName.Data());
	142	helix.LoopToVertex(fP.x, fP.y, fP.z, pm->V.x, pm->V.y, pm->V.z);
	143	fP.x -= pm->P.x;
	144	fP.y -= pm->P.y;
	145	fP.z -= pm->P.z;
	146	}
	147	if(RS.fFitDecay && pm->type == Reve::PathMark::Decay){
	148
	149	if(TMath::Abs(pm->V.z) > RS.fMaxZ
	150	\|\| TMath::Sqrt(pm->V.xpm->V.x + pm->V.ypm->V.y) > RS.fMaxR )
	151	goto helix_bounds;
	152	helix.LoopToVertex(fP.x, fP.y, fP.z, pm->V.x, pm->V.y, pm->V.z);
	153	decay = true;
	154	break;
	155	}
	156	}
	157	}
	158	helix_bounds:
	159	//go to bounds
48dc973d	160	if(!decay \|\| RS.fFitDecay == kFALSE){
5a5a1232	161	helix.LoopToBounds(px,py,pz);
	162	// printf("%s loop to bounds \n",fName.Data() );
	163	}
	164
01024c63	165	} else {
	166
	167	// Neutral particle or no field
5a5a1232	168
	169	MCLine line(fRnrStyle, &mc_v0, TMath::C()*fBeta, &track_points);
	170
	171	if(!fPathMarks.empty()){
	172	for(std::vector<Reve::PathMark*>::iterator i=fPathMarks.begin(); i!=fPathMarks.end(); ++i) {
	173	Reve::PathMark* pm = *i;
	174
	175	if(RS.fFitDaughters && pm->type == Reve::PathMark::Daughter){
	176	if(TMath::Abs(pm->V.z) > RS.fMaxZ
	177	\|\| TMath::Sqrt(pm->V.xpm->V.x + pm->V.ypm->V.y) > RS.fMaxR )
	178	goto line_bounds;
	179	line.GotoVertex(pm->V.x, pm->V.y, pm->V.z);
	180	fP.x -= pm->P.x;
	181	fP.y -= pm->P.y;
	182	fP.z -= pm->P.z;
	183	}
	184
	185	if(RS.fFitDecay && pm->type == Reve::PathMark::Decay){
	186	if(TMath::Abs(pm->V.z) > RS.fMaxZ
	187	\|\| TMath::Sqrt(pm->V.xpm->V.x + pm->V.ypm->V.y) > RS.fMaxR )
	188	goto line_bounds;
	189	line.GotoVertex(pm->V.x, pm->V.y, pm->V.z);
	190	decay = true;
	191	break;
	192	}
	193	}
	194	}
	195
	196	line_bounds:
48dc973d	197	if(!decay \|\| RS.fFitDecay == kFALSE)
5a5a1232	198	line.GotoBounds(px,py,pz);
	199
	200	}
	201	make_polyline:
	202	Reset(track_points.size());
	203	for(std::vector<MCVertex>::iterator i=track_points.begin(); i!=track_points.end(); ++i)
	204	SetNextPoint(i->x, i->y, i->z);
	205	}
	206
	207	/**************************************************************************/
	208
48dc973d	209	void Track::ImportHits()
	210	{
	211	Reve::LoadMacro("hits_from_label.C");
	212	gROOT->ProcessLine(Form("hits_from_label(%d);", fLabel));
	213	}
	214
	215	void Track::ImportClusters()
	216	{
	217	Reve::LoadMacro("clusters_from_label.C");
	218	gROOT->ProcessLine(Form("clusters_from_label(%d);", fLabel));
	219	}
	220
	221
	222	/**************************************************************************/
	223	/**************************************************************************/
	224
5a5a1232	225	//______________________________________________________________________
	226	// TrackRnrStyle
	227	//
	228
	229	ClassImp(Reve::TrackRnrStyle)
	230
48dc973d	231	Float_t TrackRnrStyle::fgDefMagField = 5;
48dc973d	232	const Float_t TrackRnrStyle::fgkB2C = 0.299792458e-3;
5a5a1232	233	TrackRnrStyle TrackRnrStyle::fgDefStyle;
5a5a1232	234
265ecb21	235	TrackRnrStyle::TrackRnrStyle() :
265ecb21	236	TObject(),
5a5a1232	237
265ecb21	238	fColor(1),
265ecb21	239	fMagField(fgDefMagField),
5a5a1232	240
265ecb21	241	fMaxR (350),
265ecb21	242	fMaxZ (450),
5a5a1232	243
265ecb21	244	fMaxOrbs (0.5),
	245	fMinAng (45),
	246	fDelta (0.1),
5a5a1232	247
265ecb21	248	fFitDaughters(kTRUE),
	249	fFitDecay (kTRUE)
	250	{}
5a5a1232	251
	252	/**************************************************************************/
	253	/**************************************************************************/
	254
	255	//______________________________________________________________________
	256	// TrackList
	257	//
	258
	259	ClassImp(Reve::TrackList)
	260
	261	void TrackList::Init()
	262	{
	263	fMarkerStyle = 6;
	264	fMarkerColor = 5;
	265	// fMarker->SetMarkerSize(0.05);
	266
5a5a1232	267	mRnrStyle = new TrackRnrStyle;
	268	SetMainColorPtr(&mRnrStyle->fColor);
	269	}
	270
	271	TrackList::TrackList(Int_t n_tracks) :
7d42b6c2	272	RenderElementListBase(),
265ecb21	273	TPolyMarker3D(n_tracks),
	274
	275	fTitle(),
	276
	277	mRnrStyle (0),
	278	fRnrMarkers (kTRUE),
	279	fRnrTracks (kTRUE)
5a5a1232	280	{
	281	Init();
	282	}
	283
	284	TrackList::TrackList(const Text_t* name, Int_t n_tracks) :
7d42b6c2	285	RenderElementListBase(),
265ecb21	286	TPolyMarker3D(n_tracks),
	287
	288	fTitle(),
	289
	290	mRnrStyle (0),
	291	fRnrMarkers (kTRUE),
	292	fRnrTracks (kTRUE)
5a5a1232	293	{
	294	Init();
	295	SetName(name);
	296	}
	297
	298	void TrackList::Reset(Int_t n_tracks)
	299	{
	300	delete [] fP; fP = 0;
	301	fN = n_tracks;
	302	if(fN) fP = new Float_t [3*fN];
	303	memset(fP, 0, 3fNsizeof(Float_t));
	304	fLastPoint = -1;
	305	}
	306
	307	/**************************************************************************/
	308
	309	void TrackList::Paint(Option_t* option)
	310	{
	311	if(fRnrElement) {
	312	if(fRnrMarkers) {
	313	TPolyMarker3D::Paint(option);
	314	}
	315	if(fRnrTracks) {
7d42b6c2	316	for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
5a5a1232	317	if((*i)->GetRnrElement())
	318	(*i)->GetObject()->Paint(option);
	319	}
	320	}
	321	}
	322	}
	323
	324	/**************************************************************************/
	325
	326	void TrackList::AddElement(RenderElement* el)
	327	{
	328	static const Exc_t eH("TrackList::AddElement ");
	329	if (dynamic_cast<Track*>(el) == 0)
	330	throw(eH + "new element not a Track.");
	331	RenderElementListBase::AddElement(el);
	332	}
	333
	334	/**************************************************************************/
	335
	336	void TrackList::SetRnrMarkers(Bool_t rnr)
	337	{
	338	fRnrMarkers = rnr;
	339	gReve->Redraw3D();
	340	}
	341
	342	void TrackList::SetRnrTracks(Bool_t rnr)
	343	{
	344
	345	fRnrTracks = rnr;
	346	gReve->Redraw3D();
	347	}
	348
	349	/**************************************************************************/
	350
	351	void TrackList::MakeTracks()
	352	{
7d42b6c2	353	for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
5a5a1232	354	((Track)(i))->MakeTrack();
	355	}
	356	gReve->Redraw3D();
	357	}
	358
	359
	360	void TrackList::MakeMarkers()
	361	{
7d42b6c2	362	Reset(fChildren.size());
7d42b6c2	363	for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
5a5a1232	364	Track& t = ((Track)(*i));
	365	if(t.GetN() > 0)
	366	SetNextPoint(t.fV.x, t.fV.y, t.fV.z);
	367	}
	368	gReve->Redraw3D();
	369	}
	370
	371	/**************************************************************************/
	372	/*************************************************************************/
	373
	374	void TrackList::SetMaxR(Float_t x)
	375	{
	376	mRnrStyle->fMaxR = x;
	377	MakeTracks();
	378	MakeMarkers();
	379	}
	380
	381	void TrackList::SetMaxZ(Float_t x)
	382	{
	383	mRnrStyle->fMaxZ = x;
	384	MakeTracks();
	385	MakeMarkers();
	386	}
	387
	388	void TrackList::SetMaxOrbs(Float_t x)
	389	{
	390	mRnrStyle->fMaxOrbs = x;
	391	MakeTracks();
	392	}
	393
	394	void TrackList::SetMinAng(Float_t x)
	395	{
	396	mRnrStyle->fMinAng = x;
	397	MakeTracks();
	398	}
	399
	400	void TrackList::SetDelta(Float_t x)
	401	{
	402	mRnrStyle->fDelta = x;
	403	MakeTracks();
	404	}
	405
	406	void TrackList::SetFitDaughters(Bool_t x)
	407	{
	408	mRnrStyle->fFitDaughters = x;
	409	MakeTracks();
	410	}
	411
	412	void TrackList::SetFitDecay(Bool_t x)
	413	{
	414	mRnrStyle->fFitDecay = x;
	415	MakeTracks();
	416	}
	417
	418	/**************************************************************************/
	419	/**************************************************************************/
	420
	421	void TrackList::SelectByPt(Float_t min_pt, Float_t max_pt)
	422	{
	423	Float_t minptsq = min_pt*min_pt;
	424	Float_t maxptsq = max_pt*max_pt;
	425	Float_t ptsq;
	426
7d42b6c2	427	for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
5a5a1232	428	ptsq = ((Track)(i))->fP.Perp2();
	429	(*i)->SetRnrElement(ptsq >= minptsq && ptsq <= maxptsq);
	430	}
	431	}
	432
	433	/**************************************************************************/
	434
b99aed53	435	void TrackList::ImportHits()
5a5a1232	436	{
7d42b6c2	437	for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
b99aed53	438	((Track)(i))->ImportHits();
b99aed53	439	}
5a5a1232	440	}
5a5a1232	441
b99aed53	442	void TrackList::ImportClusters()
5a5a1232	443	{
7d42b6c2	444	for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
b99aed53	445	((Track)(i))->ImportClusters();
b99aed53	446	}
5a5a1232	447	}