[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()
{
  fRnrStyle = 0;
}

Track::Track(Reve::MCTrack* t, TrackRnrStyle* rs)
{
  fRnrStyle = rs;

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

  fV.Set(t->Vx(), t->Vy(), t->Vz());
  fP.Set(t->Px(), t->Py(), t->Pz());
  fBeta   = t->P()/t->Energy();

  TParticlePDG* pdgp = t->GetPDG();
  if(pdgp == 0) {
    t->ResetPdgCode(); pdgp = t->GetPDG();
  }

  fCharge = (Int_t) TMath::Nint(pdgp->Charge()/3);
  fLabel  = t->label;
}

Track::Track(Reve::RecTrack* t, TrackRnrStyle* rs)
{
  fRnrStyle = rs;
  fName = t->GetName();
  fLineColor = fRnrStyle->GetColor();
  fMainColorPtr = &fLineColor;

  fV = t->V;
  fP = t->P;
  fBeta   = t->beta;
  fCharge = t->sign;
  fLabel  = t->label; 
}

Track::~Track()
{}

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;

void TrackRnrStyle::Init()
{
  fMagField = fgDefMagField;

  fMaxR  = 350;
  fMaxZ  = 450;

  fMaxOrbs = 0.5;
  fMinAng  = 45;

  fFitDaughters = kTRUE;
  fFitDecay     = kTRUE;

  fDelta  = 0.1; //calculate step size depending on helix radius
}

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

//______________________________________________________________________
// TrackList
//

ClassImp(Reve::TrackList)

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

  fRnrMarkers = kTRUE;
  fRnrTracks  = kTRUE;

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

TrackList::TrackList(Int_t n_tracks) :
  RenderElementListBase(),
  TPolyMarker3D(n_tracks)
{
  Init();
}

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