---

IgSoIdealTrack Class Reference

Represents an ideal track (i.e., a perfect helix) as a NURB. More...

#include <Ig_Extensions/IgOpenInventor/interface/IgSoIdealTrack.h>

Inheritance diagram for IgSoIdealTrack:

List of all members.

Public Member Functions
	IgSoIdealTrack (void)
void	initialise (double vx, double vy, double vz, double px, double py, double pz, float t0, int pid)
void	initialise (double vx, double vy, double vz, double px, double py, double pz, float t0, IgParticleChar *pc)
void	initialise (double *vx, double *vy, double *vz, double *px, double *py, double *pz, float *t0, IgParticleChar *pc)
	initialize the track using one of the initTrack methods vx vertex location in the x dimension vy vertex location in the y dimension vz vertex location in the z dimension px momentum (at the vertex) in the x direction py momentum (at the vertex) in the y direction pz momentum (at the vertex) in the z direction t0 time of the creation of the vertex pc the type of particle
float	pt (void) const
float	ptot (void) const
Static Public Member Functions
static float	getBField (void)
static float	getRMax (void)
static float	getZMax (void)
static void	initClass (void)
static void	setBField (float val)
static void	setRMax (float val)
static void	setZMax (float val)
Public Attributes
SoSFFloat	dt
SoSFString	particleType
SoSFFloat	phi
SoSFFloat	radius
SoSFFloat	t0
SoSFFloat	tend
SoSFFloat	tstart
SoSFVec3f	vertex
SoSFFloat	zeta
Protected Member Functions
float	angleToTime (float angle)
void	initEndPts (void)
virtual void	refresh (void)
float	timeToAngle (float time)
SbVec2f	timeToXY (float time)
float	timeToZ (float time)
float	zToTime (float z)
virtual	~IgSoIdealTrack (void)
Protected Attributes
float	m_charge
IgParticleChar *	m_particleChar
float	m_pt
float	m_ptot
Private Member Functions
	SO_KIT_CATALOG_ENTRY_HEADER (debugPoints)
	SO_KIT_CATALOG_ENTRY_HEADER (debugStyle)
	SO_KIT_CATALOG_ENTRY_HEADER (curve)
	SO_KIT_CATALOG_ENTRY_HEADER (points)
	SO_KIT_CATALOG_ENTRY_HEADER (complexity)
	SO_KIT_CATALOG_ENTRY_HEADER (style)
	SO_KIT_CATALOG_ENTRY_HEADER (material)
	SO_KIT_HEADER (IgSoIdealTrack)
Static Private Attributes
static float	bfield = 4.0F
static float	rmax = 1.4F
static float	zmax = 3.2F

---

Detailed Description

Represents an ideal track (i.e., a perfect helix) as a NURB.

Author:

G. Alverson

IgSoIdealTrack is a dynamic kit in that it checks against a global time to determine how it represents a track. As the time changes, the track grows to match.

Times are measured in 0.01 nanosecond ticks, magnetic fields in Tesla, and distances in meters.

Definition at line 36 of file IgSoIdealTrack.h.

---

Constructor & Destructor Documentation

IgSoIdealTrack::IgSoIdealTrack

(

void

)

Definition at line 65 of file IgSoIdealTrack.cc.

References dt, FALSE, particleType, phi, radius, IgSoShapeKit::setUpConnections(), t0, tend, TRUE, tstart, vertex, and zeta.

: m_particleChar (IgParticleChar::getByName("muon")),
m_ptot (1.F),
m_pt (0.5F),
m_charge (-1.F)
{
        SO_KIT_CONSTRUCTOR (IgSoIdealTrack);
        SO_KIT_ADD_FIELD (phi,          (0.0F));
        SO_KIT_ADD_FIELD (radius,               (1.0F));
        SO_KIT_ADD_FIELD (zeta,         (0.01F));
        SO_KIT_ADD_FIELD (vertex,               (0.0F, 0.0F, 0.0F));
        SO_KIT_ADD_FIELD (t0,           (0.0F));
        SO_KIT_ADD_FIELD (dt,           (1.0F));
        SO_KIT_ADD_FIELD (tstart,               (0.0F));
        SO_KIT_ADD_FIELD (tend,         (500.F));
        SO_KIT_ADD_FIELD (particleType, ("unknown"));
        SO_KIT_ADD_CATALOG_ENTRY (material, SoMaterial, FALSE, separator,\x0, TRUE);
        SO_KIT_ADD_CATALOG_ENTRY (style, SoDrawStyle, FALSE, separator,\x0, TRUE);
        SO_KIT_ADD_CATALOG_ENTRY (complexity, SoComplexity, FALSE, separator,\x0, TRUE);
        SO_KIT_ADD_CATALOG_ENTRY (points, SoCoordinate4, FALSE, separator,\x0, TRUE);
        SO_KIT_ADD_CATALOG_ENTRY (curve, SoNurbsCurve, FALSE, separator,\x0, TRUE);
#ifdef IG_DEBUG_PTS
        SO_KIT_ADD_CATALOG_ENTRY (debugStyle, SoDrawStyle, FALSE, separator,\x0, TRUE);
        SO_KIT_ADD_CATALOG_ENTRY (debugPoints, SoPointSet, FALSE, separator,\x0, TRUE);
#endif // IG_DEBUG_PTS
        SO_KIT_INIT_INSTANCE ();
        setUpConnections (true, true);
}

IgSoIdealTrack::~IgSoIdealTrack

(

void

)

[protected, virtual]

Definition at line 94 of file IgSoIdealTrack.cc.

References dt.

{
    if (dt.isConnected ())
      dt.disconnect ();
}

---

Member Function Documentation

float IgSoIdealTrack::angleToTime

(

float

angle

)

[protected]

Definition at line 354 of file IgSoIdealTrack.cc.

References IgParticleChar::getMass(), m_particleChar, m_pt, m_ptot, phi, radius, funct::sqrt(), and tstart.

Referenced by initEndPts(), and refresh().

{
        float phi = this->phi.getValue ();
        float radius = this->radius.getValue ();
        float tstart = this->tstart.getValue ();
        float mass = m_particleChar->getMass ();
        float betat = m_pt / sqrt (mass * mass + m_ptot * m_ptot);
        return tstart - (radius * (angle - phi)) / (betat * SPEEDOLIGHT);
}

float IgSoIdealTrack::getBField

(

void

)

[inline, static]

Definition at line 118 of file IgSoIdealTrack.h.

References bfield.

{ return bfield; }

float IgSoIdealTrack::getRMax

(

void

)

[inline, static]

Definition at line 119 of file IgSoIdealTrack.h.

References rmax.

{ return rmax; }

float IgSoIdealTrack::getZMax

(

void

)

[inline, static]

Definition at line 120 of file IgSoIdealTrack.h.

References zmax.

{ return zmax; }

void IgSoIdealTrack::initClass

(

void

)

[static]

Reimplemented from IgSoShapeKit.

Definition at line 59 of file IgSoIdealTrack.cc.

References IgParticleChar::initParticles().

Referenced by initNodes(), and initShapes().

{
        SO_KIT_INIT_CLASS (IgSoIdealTrack, IgSoShapeKit, "IgSoShapeKit");
        IgParticleChar::initParticles ();
}

void IgSoIdealTrack::initEndPts

(

void

)

[protected]

Definition at line 494 of file IgSoIdealTrack.cc.

References funct::abs(), angleToTime(), bfield, funct::cos(), dt, f, IgParticleChar::getMass(), infinity, m_charge, m_particleChar, m_pt, m_ptot, phi, funct::pow(), radius, rmax, s, funct::sin(), funct::sqrt(), tend, timeToAngle(), timeToZ(), tstart, vertex, zeta, zmax, and zToTime().

Referenced by initialise().

{
        float   radius = this->radius.getValue ();
        float   zeta = this->zeta.getValue ();
        SbVec3f vertex = this->vertex.getValue ();
        float   phi = this->phi.getValue ();
        double  xc = vertex [0] + radius * sin (phi);
        double  yc = vertex [1] - radius * cos (phi);
        double  delPhi;  // end pt of track & total arc length in x-y plane
        double  x1;
        double  y1;
        double  z1;
        if ( radius == std::numeric_limits<double>::infinity() )
        {
                // find intersection with cylinder: straight line case
                if (zeta==0)
                {
                        // no z momentum, must intersect side
                        double s = -cos(phi)*vertex[0] - sin(phi)*vertex[1]+ sqrt( pow(rmax,2) - pow(vertex[0],2)
                                - pow(vertex[1],2)+ pow( cos(phi)*vertex[0]+sin(phi)*vertex[1], 2));
                        x1 = vertex[0] + s * cos(phi);
                        y1 = vertex[1] + s * sin(phi);
                        z1 = vertex[3];
                        float mass = m_particleChar->getMass ();
                        tend = s / ( sqrt(1.F - pow(zeta,2) ) * m_ptot / sqrt ( m_ptot*m_ptot + mass*mass) * SPEEDOLIGHT ); 
                }
                else if (m_pt ==0)
                {
                        // no pt, must be parallel to z axis
                        x1 = vertex[0]; y1 = vertex[1];
                        z1 = zeta>0 ? zmax : -zmax;
                        tend = zToTime (z1);
                }
                else
                {
                        double s = -cos(phi)*vertex[0] - sin(phi)*vertex[1] + sqrt( pow(rmax,2) - pow(vertex[0],2)
                                - pow(vertex[1],2) + pow( cos(phi)*vertex[0]+sin(phi)*vertex[1], 2));

                        double zint =  s * zeta/sqrt( 1.f - pow(zeta,2)  ) + vertex[2];
                        if ( abs(zint) > zmax )
                        {
                                zint = zint > 0.F ? zmax : -zmax;
                                s = (zint - vertex[2]) * sqrt( 1 - pow(zeta,2) ) / zeta;
                        }
                        x1 = s * cos(phi) + vertex[0]; y1 = s * sin(phi) + vertex[1]; z1 = zint;
                        tend = zToTime (z1);
                }
                dt = tend.getValue () - tstart.getValue ();
        }
        else
        {

                // See if there is an intersection between our helix and the
                // visible edge boundary cylinder
                if (xc == 0 && yc == 0)
                {
                        // concentric with z-axis
                        if (fabs (radius) >= rmax)
                                // outside max radius
                                return;

                        x1 = vertex [0];
                        y1 = vertex [1];
                        delPhi = - 2. * copysign (1.0, m_charge * bfield) * M_PI * 2;

                        if (m_pt == 0.0)
                        {
                                // z1 = pz
                                z1 = copysign (zmax, zeta * m_charge * bfield);
                                delPhi = 0.0;
                        }
                        else
                        {
                                z1 = vertex [2] - delPhi * zeta;
                                if (fabs (z1) > zmax)
                                        delPhi = -(copysign (zmax, z1) - vertex [2]) / zeta;
                        }
                }
                else
                {
                        double x2, y2, delPhi1, delPhi2;
                        double gamma = yc ? -xc / yc : FLT_MAX;
                        double delta = (rmax * rmax - radius * radius - xc * xc - yc * yc) / (2 * yc);
                        double det = 4 * gamma * gamma * delta * delta
                                - 4 * (1 + gamma * gamma) * (delta * delta - radius * radius);

                        if (det >= 0)
                        {
                                // have intersection
                                det = sqrt (det);
                                x1 = (-2 * gamma * delta + det) / (2 * (1 + gamma * gamma));
                                x2 = (-2 * gamma * delta - det) / (2 * (1 + gamma * gamma));
                                y1 = gamma * x1 + delta;
                                y2 = gamma * x2 + delta;
                                x1 = xc + x1;
                                x2 = xc + x2;
                                y1 = yc + y1;
                                y2 = yc + y2;

                                // Determine which intersection it is... : pos for neg charge.
                                delPhi1 = atan2 (-(x1 - xc) / radius, (y1 - yc) / radius) - phi;
                                delPhi2 = atan2 (-(x2 - xc) / radius, (y2 - yc) / radius) - phi;

                                if (m_charge * bfield < 0)
                                {
                                        // arc increases wrt time for negative charge
                                        if (delPhi1 < 0)
                                                delPhi1 += M_PI*2;
                                        if (delPhi2 < 0)
                                                delPhi2 += M_PI*2;
                                }
                                else
                                {
                                        // arc decreases wrt time for positive charge
                                        if (delPhi1 > 0)
                                                delPhi1 -= M_PI*2;
                                        if (delPhi2 > 0)
                                                delPhi2 -= M_PI*2;
                                }

                                if ((m_charge * bfield < 0 && delPhi1 < delPhi2)
                                        || (m_charge * bfield > 0 && delPhi1 > delPhi2))
                                        delPhi = delPhi1;
                                else
                                {
                                        x1 = x2;
                                        y1 = y2;
                                        delPhi = delPhi2;
                                }
                        }
                        else
                        {
                                // just put in two loops or z intersection
                                delPhi = -2.0 * copysign (1.0, m_charge * bfield) * M_PI*2;
                                x1 = vertex [0];
                                y1 = vertex [1];
                                z1 = timeToZ (angleToTime (delPhi + phi));

                                if (fabs (z1) > zmax)
                                {
                                        z1 = copysign (zmax, z1);
                                        delPhi = timeToAngle (zToTime (z1 - vertex [2])) - phi;
                                }
                        }
                }

                if (delPhi)
                        tend = angleToTime (delPhi + phi);
                else
                        tend = zToTime (z1);

                dt = tend.getValue () - tstart.getValue ();
        }
}

void IgSoIdealTrack::initialise	(	double	vx,
		double	vy,
		double	vz,
		double	px,
		double	py,
		double	pz,
		float	t0,
		int	pid
	)

Definition at line 449 of file IgSoIdealTrack.cc.

References IgParticleChar::getByGeantID(), and initialise().

{ initialise (vx, vy, vz, px, py, pz, t0, IgParticleChar::getByGeantID (pid)); }

void IgSoIdealTrack::initialise	(	double	vx,
		double	vy,
		double	vz,
		double	px,
		double	py,
		double	pz,
		float	t0,
		IgParticleChar *	pc
	)

Definition at line 455 of file IgSoIdealTrack.cc.

References bfield, IgParticleChar::getCharge(), IgParticleChar::getName(), infinity, initEndPts(), m_charge, m_particleChar, m_pt, m_ptot, particleType, phi, radius, tstart, vertex, and zeta.

{
        m_particleChar = pc;
        m_charge = pc->getCharge ();
        particleType = pc->getName ();

        SbVec3f vec3 = SbVec3f (px, py, pz);
        SbVec2f vec2 = SbVec2f (px, py);
        m_ptot = vec3.length ();
        m_pt = vec2.length ();

        double radius, zeta;
        // 100*SPEEDOFLIGHT gives right factor for p [GeV/c], B[Tesla], R[m], q[electron charges] (about 0.3)
        double qB = SPEEDOLIGHT * 100 * bfield * m_charge;  
        if (qB != 0)
        {
                radius = m_pt / qB;
                zeta = pz / qB;
        }
        else
        {
                radius = std::numeric_limits<double>::infinity();
                zeta = pz / m_ptot;
        }


        this->vertex = SbVec3f (vx, vy, vz);
        this->radius = static_cast<float>(radius);
        this->zeta = static_cast<float>(zeta);
        this->phi = static_cast<float>( px == 0.0 && px == 0.0 ? 0.0 : atan2(py, px) );
        this->t0 = t0;
        this->tstart = t0;

        initEndPts ();
}

void IgSoIdealTrack::initialise	(	double *	vx,
		double *	vy,
		double *	vz,
		double *	px,
		double *	py,
		double *	pz,
		float *	t0,
		IgParticleChar *	pc
	)

initialize the track using one of the initTrack methods vx vertex location in the x dimension vy vertex location in the y dimension vz vertex location in the z dimension px momentum (at the vertex) in the x direction py momentum (at the vertex) in the y direction pz momentum (at the vertex) in the z direction t0 time of the creation of the vertex pc the type of particle

Definition at line 443 of file IgSoIdealTrack.cc.

Referenced by initialise(), VisTrackTwig::update(), VisTkIdealHelixTracksTwig::update(), VisTrackingParticleTwig::update(), VisMuonTwig::update(), and VisSimTrackTwig::update().

{ initialise (*vx, *vy, *vz, *px, *py, *pz, *t0, pc); }

float IgSoIdealTrack::pt

(

void

)

const [inline]

Definition at line 117 of file IgSoIdealTrack.h.

References m_pt.

Referenced by refresh().

{ return m_pt; }

float IgSoIdealTrack::ptot

(

void

)

const [inline]

Definition at line 116 of file IgSoIdealTrack.h.

References m_ptot.

{ return m_ptot; }

void IgSoIdealTrack::refresh

(

void

)

[protected, virtual]

Reimplemented from IgSoShapeKit.

Definition at line 101 of file IgSoIdealTrack.cc.

References angle(), angleToTime(), bfield, funct::cos(), GenMuonPlsPt100GeV_cfg::cout, dt, lat::endl(), IgParticleChar::getMaterial(), IgParticleChar::getStyle(), i, int, m_charge, m_particleChar, m_pt, m_ptot, particleType, phi, pt(), radius, funct::sin(), funct::sqrt(), t0, tend, timeToAngle(), timeToXY(), timeToZ(), tstart, vertex, and zeta.

{
        // Initialise local variables (and members for the converters)
        float   radius  = this->radius.getValue ();
        float   zeta    = this->zeta.getValue ();
        SbVec3f vertex  = this->vertex.getValue ();
        float   phi     = this->phi.getValue ();
        float   tstart  = this->tstart.getValue ();
        float   tend    = this->tend.getValue ();

        float   t0      = this->t0.getValue ();
        float   dt      = this->dt.getValue ();

//      if (t0 < tstart)
//              t0 = tstart;
        if (t0 > tend)
                t0 = tend;

        float t1 = dt+t0;
        if (t1 > tend)
                t1 = tend;
//      if (t1 < tstart)
//              t1 = tstart;

        if (!fabs (tend - tstart) || !fabs (t1 - t0))
        {
                setPart ("material",    m_particleChar->getMaterial ());
                setPart ("style",       m_particleChar->getStyle ());
                setPart ("complexity",  0);
                setPart ("points",      0);
                setPart ("curve",       0);
#ifdef IG_DEBUG_PTS
                setPart ("debugStyle",  0);
                setPart ("debugPoints", 0);
#endif // IG_DEBUG_PTS
                return;
        }

#ifdef IG_DEBUG_PTS
        SoDrawStyle     *debugStyle = new SoDrawStyle;
        SoPointSet      *debugPoints = new SoPointSet;
        SoVertexProperty        *debugVtx = new SoVertexProperty;
#endif // IG_DEBUG_PTS

        SoComplexity    *complexity = new SoComplexity;
        SoCoordinate4   *points = new SoCoordinate4;
        SoNurbsCurve    *curve = new  SoNurbsCurve;
        complexity->value = 0.6F;
        int             npoints = 0;
        int             nknots = 0;
        int             nknot = 0;
        std::vector<SbVec4f> ctlPoints;
        std::vector<float>      knots;

        if ( bfield == 0 || m_charge == 0 )
        {
                // Calculate the start & end points
                float z0, z1, x0, y0, x1, y1;
                z0 = timeToZ (t0);
                z1 = timeToZ (t1);
                SbVec2f xy0( timeToXY(t0) );
                SbVec2f xy1( timeToXY( t1 ) );
                xy0.getValue( x0, y0 );
                xy1.getValue( x1, y1 );

                // Calculate the control points & knot vector
                npoints = 2;
                nknots = 4;
                ctlPoints.resize(static_cast<int>(npoints));
                knots.resize(static_cast<int>(nknots)); // #ctlPoints + NORDER
                knots[0] = 0; knots[1] = 0; knots[2] = 1; knots[3] = 1;
                ctlPoints[0].setValue( x0, y0, z0, 1.F  );
                ctlPoints[1].setValue( x1, y1, z1, 1.F );

                // Set the coordinates
                points->point.setValues (0, npoints, &ctlPoints[0]);

                // Rebuild the curve
                curve->numControlPoints = npoints;
                curve->knotVector.setValues (0, nknots, &knots[0]);

        }
        else
        {
                // invert r=p/qB
                m_pt =  SPEEDOLIGHT * 100.F * bfield * m_charge * radius;
                float pz = SPEEDOLIGHT * 100.F * bfield * m_charge * zeta;
                m_ptot = sqrt (m_pt * m_pt + pz * pz);

                // Calculate the start & end points
                float x0, x1, y0, y1, z0, z1;
                float phi0 = timeToAngle (t0);
                float phi1 = timeToAngle (t1);
                float delPhi = phi1 - phi0;

                // Until we implement adjustable vector for control points,
                // truncate curve at 2 loops
                if (fabs (delPhi) > maxAngle)
                {
                        delPhi = static_cast<float>(copysign (maxAngle, delPhi));
                        phi1 = delPhi + phi0;
                        t1 = angleToTime (phi1);
                }

                if (delPhi == 0)
                {
                        z0 = timeToZ (t0);
                        z1 = timeToZ (t1);
                }
                else
                {
                        z0 = vertex [2] - (phi0 - phi) * zeta;
                        z1 = vertex [2] - (phi1 - phi) * zeta;
                }

                float xc = vertex [0] + radius * sin (phi);
                float yc = vertex [1] - radius * cos (phi);
                x0 = xc - radius * sin (phi0);
                y0 = yc + radius * cos (phi0);
                x1 = xc - radius * sin (phi1);
                y1 = yc + radius * cos (phi1);

                // Calculate the control points & knot vector
                // actually 2*(maxAngle/maxNurbAngle + 1), but avoid rounding prob
                ctlPoints.resize (static_cast<int>(2*(maxAngle/maxNurbAngle +2)));
                // #ctlPoints + NORDER
                knots.resize (static_cast<int>(2*(maxAngle/maxNurbAngle +2)+NORDER)); 

                // the first knot value has multiplicity NORDER (=3), put one in
                // now, and let the normal routine put in the additional NORDER-1.
                knots [nknots++] = static_cast<float>(nknot);

                if (fabs (delPhi) < maxNurbAngle)
                {
                        // if less than the max arc covered in one nurb segment, just use the points.
                        ctlPoints [npoints++] = SbVec4f (x0, y0, z0, 1.0);

                        // knot values for this point: nknots for NORDER-1 terms
                        knots [nknots++] = static_cast<float>(nknot);
                        knots [nknots++] = static_cast<float>(nknot++);

                        ctlPoints [npoints++] =
                                SbVec4f (xc - sin (delPhi/2.F + phi0) * radius / fabs (cos (delPhi/2.F)),
                                yc + cos (delPhi/2.F + phi0) * radius / fabs (cos (delPhi/2.F)),
                                (z0 + z1) / 2.F,
                                1.F)
                                * fabs (cos (delPhi / 2.F));
                }
                else
                {
                        // Must generate some filler points
                        //
                        //   x--------------------------------x
                        //               ||
                        //               \/
                        //   x-----o-----x------o----x---o----x
                        //
                        //   (one segment becomes three in this example.
                        //    nfill=1 => nfill=3, w/ 2 x points (normal weight)
                        //    and  3 o points to insert

                        int nfill = 1 + (int) (fabs (delPhi) / maxNurbAngle ); // ensure at least one fill division
                        if (nfill == 1)
                                // ensure at least 5 points
                                nfill = 2;
                        double delAngle = delPhi / nfill;
                        double delZ = (z1 - z0) / delPhi; // change in z wrt angle

                        for (int i = 0; i < nfill; ++i)
                        {
                                double angle = phi0 + i * delAngle;

                                if (i == 0)
                                        // put the first point at exactly the right point
                                        ctlPoints [npoints++] = SbVec4f (x0, y0, z0, 1.0F);
                                else
                                        ctlPoints [npoints++] = SbVec4f (xc - radius * sin (angle),
                                        yc + radius * cos (angle),
                                        z0 + delZ * (angle - phi0),
                                        1.0F);

                                // put in the knot values for this point: nknots for NORDER-1 terms
                                knots [nknots++] = static_cast<float>(nknot);
                                knots [nknots++] = static_cast<float>(nknot++);

                                ctlPoints [npoints++] =
                                        SbVec4f (xc - radius * sin (angle + delAngle/2.F) / fabs (cos (delAngle/2.F)),
                                        yc + radius * cos (angle + delAngle/2.F) / fabs (cos (delAngle/2.F)),
                                        z0 + delZ * (angle + delAngle/2.F - phi0),
                                        1.0F)
                                        * fabs (cos (delAngle/2.F));
                        }
                }

                // The end point
                ctlPoints [npoints++] = SbVec4f (x1, y1, z1, 1.0F);
                knots [nknots++] = static_cast<float>(nknot);
                knots [nknots++] = static_cast<float>(nknot);
                knots [nknots++] = static_cast<float>(nknot);
                // Set the coordinates
                points->point.setValues (0, npoints, &ctlPoints[0]);

                // Rebuild the curve
                curve->numControlPoints = npoints;
                curve->knotVector.setValues (0, nknots, &knots[0]);
        }
#ifdef IG_DEBUG_PTS
        //          Add debugging polymarkers for control points
        for (int i = 0; i < npoints; ++i)
        {
                SbVec3f pt;
                ctlPoints [i].getReal (pt);
                debugVtx->vertex.set1Value (i, pt);
        }

        debugStyle->pointSize = 4;
        debugStyle->style = SoDrawStyle::LINES;
        debugPoints->vertexProperty = debugVtx;
        setPart ("debugStyle",  debugStyle);
        setPart ("debugPoints", debugPoints);
#endif // IG_DEBUG_PTS



        setPart ("material",    m_particleChar->getMaterial ());
        setPart ("style",               m_particleChar->getStyle ());
        setPart ("complexity",  complexity);
        setPart ("points",              points);
        setPart ("curve",               curve);


#if 0 //DEBUG
        std::cout << "IgSoIdealTrack particle name: " << particleType.getValue ().getString ()
                << " material: " << m_particleChar->getMaterial()
                << std::endl;
#endif //DEBUG
}

void IgSoIdealTrack::setBField

(

float

val

)

[inline, static]

Definition at line 113 of file IgSoIdealTrack.h.

References bfield.

Referenced by VisTrackTwig::update(), VisTkIdealHelixTracksTwig::update(), and VisMuonTwig::update().

{ bfield = val; }

void IgSoIdealTrack::setRMax

(

float

val

)

[inline, static]

Definition at line 114 of file IgSoIdealTrack.h.

References rmax.

Referenced by VisTrackTwig::update(), VisTkIdealHelixTracksTwig::update(), and VisMuonTwig::update().

{ rmax = val; }

void IgSoIdealTrack::setZMax

(

float

val

)

[inline, static]

Definition at line 115 of file IgSoIdealTrack.h.

References zmax.

Referenced by VisTrackTwig::update(), VisTkIdealHelixTracksTwig::update(), and VisMuonTwig::update().

{ zmax = val; }

IgSoIdealTrack::SO_KIT_CATALOG_ENTRY_HEADER

(

debugPoints

)

[private]

IgSoIdealTrack::SO_KIT_CATALOG_ENTRY_HEADER

(

debugStyle

)

[private]

IgSoIdealTrack::SO_KIT_CATALOG_ENTRY_HEADER

(

curve

)

[private]

IgSoIdealTrack::SO_KIT_CATALOG_ENTRY_HEADER

(

points

)

[private]

IgSoIdealTrack::SO_KIT_CATALOG_ENTRY_HEADER

(

complexity

)

[private]

IgSoIdealTrack::SO_KIT_CATALOG_ENTRY_HEADER

(

style

)

[private]

IgSoIdealTrack::SO_KIT_CATALOG_ENTRY_HEADER

(

material

)

[private]

IgSoIdealTrack::SO_KIT_HEADER

(

IgSoIdealTrack

)

[private]

float IgSoIdealTrack::timeToAngle

(

float

time

)

[protected]

Definition at line 340 of file IgSoIdealTrack.cc.

References IgParticleChar::getMass(), m_particleChar, m_pt, m_ptot, phi, radius, funct::sqrt(), and tstart.

Referenced by initEndPts(), refresh(), and timeToXY().

{
        float phi = this->phi.getValue ();
        float radius = this->radius.getValue ();
        float tstart = this->tstart.getValue ();
        float mass = m_particleChar->getMass ();
        float betat = m_pt / sqrt (mass * mass + m_ptot * m_ptot);
        if (fabs (radius))
                return phi - betat * SPEEDOLIGHT * (time - tstart) / radius;
        else
                return phi;
}

SbVec2f IgSoIdealTrack::timeToXY

(

float

time

)

[protected]

Definition at line 410 of file IgSoIdealTrack.cc.

References angle(), bfield, funct::cos(), IgParticleChar::getMass(), m_charge, m_particleChar, m_pt, m_ptot, phi, radius, funct::sin(), funct::sqrt(), timeToAngle(), tstart, vertex, x, and y.

Referenced by refresh().

{
        if ( bfield ==0 || m_charge == 0 )
        {
                float mass = m_particleChar->getMass ();
                float betat = m_pt / sqrt ( mass*mass + m_ptot * m_ptot );
                float deltaT = time - tstart.getValue();
                float x = vertex.getValue() [0] + cos(phi.getValue()) * betat * deltaT * SPEEDOLIGHT;
                float y = vertex.getValue() [1] + sin(phi.getValue()) * betat * deltaT * SPEEDOLIGHT;
                return SbVec2f ( x, y );
        }
        else
        {
                float angle = timeToAngle (time);
                SbVec3f vertex = this->vertex.getValue ();
                double radius = this->radius.getValue ();
                double phi = this->phi.getValue ();
                double xc = vertex [0] + radius * sin (phi);
                double yc = vertex [1] - radius * cos (phi);
                return SbVec2f (xc - radius * sin (angle), yc + radius * cos (angle));
        }
}

float IgSoIdealTrack::timeToZ

(

float

time

)

[protected]

Definition at line 389 of file IgSoIdealTrack.cc.

References bfield, IgParticleChar::getMass(), m_charge, m_particleChar, m_ptot, funct::sqrt(), tstart, vertex, and zeta.

Referenced by initEndPts(), and refresh().

{
        SbVec3f vertex = this->vertex.getValue ();
        float zeta = this->zeta.getValue ();
        float tstart = this->tstart.getValue ();
        float mass = m_particleChar->getMass ();
        float betaz;
        if ( bfield != 0 && m_charge != 0 )
        {
                betaz = (zeta * SPEEDOLIGHT * 100 * bfield * m_charge)
                        / sqrt (mass * mass + m_ptot * m_ptot); // = pz/E = z component of v
        }
        else
        {
                betaz = zeta * m_ptot / sqrt (mass * mass + m_ptot * m_ptot);
        }

        return (time - tstart) * betaz * SPEEDOLIGHT + vertex [2];
}

float IgSoIdealTrack::zToTime

(

float

z

)

[protected]

Definition at line 365 of file IgSoIdealTrack.cc.

References bfield, IgParticleChar::getMass(), m_charge, m_particleChar, m_ptot, funct::sqrt(), tstart, vertex, and zeta.

Referenced by initEndPts().

{
        SbVec3f vertex = this->vertex.getValue ();
        float zeta = this->zeta.getValue ();
        float tstart = this->tstart.getValue ();
        float mass = m_particleChar->getMass ();

        float betaz;
        if (bfield != 0 && m_charge != 0)
        {
                betaz = (zeta * SPEEDOLIGHT * 100 * bfield * m_charge)
                        / sqrt (mass * mass + m_ptot * m_ptot); // = pz/E = z component of v
        }
        else
        {
                betaz = zeta * m_ptot / sqrt( m_ptot*m_ptot + mass * mass );
        }
        if (fabs (betaz))
                return tstart + (z - vertex [2]) / (betaz * SPEEDOLIGHT);
        else
                return tstart;
}

---

Member Data Documentation

float IgSoIdealTrack::bfield = 4.0F [static, private]

Definition at line 106 of file IgSoIdealTrack.h.

Referenced by getBField(), initEndPts(), initialise(), refresh(), setBField(), timeToXY(), timeToZ(), and zToTime().

SoSFFloat IgSoIdealTrack::dt

Definition at line 62 of file IgSoIdealTrack.h.

Referenced by IgSoIdealTrack(), initEndPts(), refresh(), VisTrackTwig::update(), VisTkIdealHelixTracksTwig::update(), VisMuonTwig::update(), and ~IgSoIdealTrack().

float IgSoIdealTrack::m_charge [protected]

Definition at line 103 of file IgSoIdealTrack.h.

Referenced by initEndPts(), initialise(), refresh(), timeToXY(), timeToZ(), and zToTime().

IgParticleChar* IgSoIdealTrack::m_particleChar [protected]

Definition at line 100 of file IgSoIdealTrack.h.

Referenced by angleToTime(), initEndPts(), initialise(), refresh(), timeToAngle(), timeToXY(), timeToZ(), and zToTime().

float IgSoIdealTrack::m_pt [protected]

Definition at line 102 of file IgSoIdealTrack.h.

Referenced by angleToTime(), initEndPts(), initialise(), pt(), refresh(), timeToAngle(), and timeToXY().

float IgSoIdealTrack::m_ptot [protected]

Definition at line 101 of file IgSoIdealTrack.h.

Referenced by angleToTime(), initEndPts(), initialise(), ptot(), refresh(), timeToAngle(), timeToXY(), timeToZ(), and zToTime().

SoSFString IgSoIdealTrack::particleType

Definition at line 58 of file IgSoIdealTrack.h.

Referenced by IgSoIdealTrack(), initialise(), and refresh().

SoSFFloat IgSoIdealTrack::phi

Definition at line 52 of file IgSoIdealTrack.h.

Referenced by angleToTime(), IgSoIdealTrack(), initEndPts(), initialise(), refresh(), timeToAngle(), and timeToXY().

SoSFFloat IgSoIdealTrack::radius

Definition at line 53 of file IgSoIdealTrack.h.

Referenced by angleToTime(), IgSoIdealTrack(), initEndPts(), initialise(), refresh(), timeToAngle(), timeToXY(), and VisSimTrackTwig::update().

float IgSoIdealTrack::rmax = 1.4F [static, private]

Definition at line 107 of file IgSoIdealTrack.h.

Referenced by getRMax(), initEndPts(), and setRMax().

SoSFFloat IgSoIdealTrack::t0

Definition at line 61 of file IgSoIdealTrack.h.

Referenced by IgSoIdealTrack(), refresh(), VisTrackTwig::update(), VisTkIdealHelixTracksTwig::update(), and VisMuonTwig::update().

SoSFFloat IgSoIdealTrack::tend

Definition at line 57 of file IgSoIdealTrack.h.

Referenced by IgSoIdealTrack(), initEndPts(), and refresh().

SoSFFloat IgSoIdealTrack::tstart

Definition at line 56 of file IgSoIdealTrack.h.

Referenced by angleToTime(), IgSoIdealTrack(), initEndPts(), initialise(), refresh(), timeToAngle(), timeToXY(), timeToZ(), and zToTime().

SoSFVec3f IgSoIdealTrack::vertex

Definition at line 55 of file IgSoIdealTrack.h.

Referenced by IgSoIdealTrack(), initEndPts(), initialise(), refresh(), timeToXY(), timeToZ(), and zToTime().

SoSFFloat IgSoIdealTrack::zeta

Definition at line 54 of file IgSoIdealTrack.h.

Referenced by IgSoIdealTrack(), initEndPts(), initialise(), refresh(), timeToZ(), and zToTime().

float IgSoIdealTrack::zmax = 3.2F [static, private]

Definition at line 108 of file IgSoIdealTrack.h.

Referenced by getZMax(), initEndPts(), and setZMax().

---

The documentation for this class was generated from the following files:

• Iguana/Inventor/interface/IgSoIdealTrack.h
• Iguana/Inventor/src/IgSoIdealTrack.cc

---