G4NURBS Class Reference

#include <G4NURBS.hh>

Inheritance diagram for G4NURBS:

Classes
class	CtrlPtsCoordsIterator
class	CtrlPtsIterator
class	KnotsIterator
struct	t_Dir

Public Types
enum	t_direction { U = 0 , V = 1 , DMask = 1 , NofD = 2 }
enum	{   X , Y , Z , W ,   NofC }
enum	t_KnotVectorGenFlag { UserDefined , Regular , RegularRep }
typedef unsigned int	t_index
typedef t_index	t_indKnot
typedef unsigned int	t_indCoord
typedef unsigned int	t_indCtrlPt
typedef t_index	t_inddCtrlPt
typedef G4double	t_doubleCtrlPt[NofC]
typedef G4float	t_floatCtrlPt[NofC]
typedef t_index	t_order
typedef G4Float	t_Knot

Public Member Functions
virtual const char *	Whoami () const =0
virtual	~G4NURBS ()
G4int	GetUorder () const
G4int	GetVorder () const
G4int	GetUnbrKnots () const
G4int	GetVnbrKnots () const
G4int	GetUnbrCtrlPts () const
G4int	GetVnbrCtrlPts () const
G4int	GettotalnbrCtrlPts () const
G4double	GetUmin () const
G4double	GetUmax () const
G4double	GetVmin () const
G4double	GetVmax () const
void	CalcPoint (G4double u, G4double v, G4Point3D &p, G4Vector3D &utan, G4Vector3D &vtan) const
G4int	Getorder (t_direction in_dir) const
G4int	GetnbrKnots (t_direction in_dir) const
G4int	GetnbrCtrlPts (t_direction in_dir) const
G4float	GetfloatKnot (t_direction in_dir, t_indKnot in_index) const
G4double	GetdoubleKnot (t_direction in_dir, t_indKnot in_index) const
t_floatCtrlPt *	GetfloatCtrlPt (t_indCtrlPt in_onedimindex) const
t_floatCtrlPt *	GetfloatCtrlPt (t_inddCtrlPt in_Uindex, t_inddCtrlPt in_Vindex) const
t_doubleCtrlPt *	GetdoubleCtrlPt (t_indCtrlPt in_onedimindex) const
t_doubleCtrlPt *	GetdoubleCtrlPt (t_inddCtrlPt in_Uindex, t_inddCtrlPt in_Vindex) const
G4float *	GetfloatAllKnots (t_direction in_dir) const
G4double *	GetdoubleAllKnots (t_direction in_dir) const
G4float *	GetfloatAllCtrlPts () const
G4double *	GetdoubleAllCtrlPts () const
Public Member Functions inherited from G4Visible
	G4Visible ()
	G4Visible (const G4Visible &)
	G4Visible (const G4VisAttributes *)
virtual	~G4Visible ()
G4Visible &	operator= (const G4Visible &)
G4bool	operator!= (const G4Visible &right) const
const G4VisAttributes *	GetVisAttributes () const
void	SetVisAttributes (const G4VisAttributes *)
void	SetVisAttributes (const G4VisAttributes &)

Static Public Member Functions
static char	Tochar (t_direction in_dir)

Protected Types
enum	t_CheckFlag { NOcheck , check }
typedef Float	G4Float
typedef G4Float	t_Coord
typedef t_Coord	t_CtrlPt[NofC]

Protected Member Functions
	G4NURBS (t_order in_Uorder, t_order in_Vorder, t_inddCtrlPt in_UnbrCtrlPts, t_inddCtrlPt in_VnbrCtrlPts, t_CtrlPt *in_pCtrlPts, t_Knot *in_pUKnots=0, t_Knot *in_pVKnots=0, t_CheckFlag in_CheckFlag=check)
	G4NURBS (t_order in_Uorder, t_order in_Vorder, t_inddCtrlPt in_UnbrCtrlPts, t_inddCtrlPt in_VnbrCtrlPts, t_KnotVectorGenFlag in_UKVGFlag=Regular, t_KnotVectorGenFlag in_VKVGFlag=Regular, t_CheckFlag in_CheckFlag=check)
t_indCtrlPt	To1d (t_inddCtrlPt in_Uindex, t_inddCtrlPt in_Vindex) const

Static Protected Member Functions
static t_floatCtrlPt *	TofloatCtrlPt (const t_CtrlPt &)
static t_doubleCtrlPt *	TodoubleCtrlPt (const t_CtrlPt &)
static G4bool	MakeKnotVector (t_Dir &inout_dirdat, t_KnotVectorGenFlag in_KVGFlag)
static G4bool	MakeKnotVector (t_Dir *p_inoutdirdat, t_KnotVectorGenFlag in_KVGFlag)
static void	CP (G4NURBS::t_CtrlPt &rcp, t_Coord x, t_Coord y, t_Coord z, t_Coord w)
static void	CP (G4NURBS::t_CtrlPt &rcp, t_Coord x, t_Coord y, t_Coord z, t_Coord w, G4Float factor)

Protected Attributes
t_Dir	m [NofD]
t_indCtrlPt	mtotnbrCtrlPts
t_CtrlPt *	mpCtrlPts
Protected Attributes inherited from G4Visible
const G4VisAttributes *	fpVisAttributes
G4bool	fAllocatedVisAttributes

Friends
class	KnotsIterator
class	CtrlPtsCoordsIterator
class	CtrlPtsIterator
std::ostream &	operator<< (std::ostream &inout_OutStream, t_KnotVectorGenFlag in_KVGFlag)

Detailed Description

Definition at line 51 of file G4NURBS.hh.

Member Typedef Documentation

G4Float

typedef Float G4NURBS::G4Float

protected

Definition at line 168 of file G4NURBS.hh.

t_Coord

typedef G4Float G4NURBS::t_Coord

protected

Definition at line 181 of file G4NURBS.hh.

t_CtrlPt

typedef t_Coord G4NURBS::t_CtrlPt[NofC]

protected

Definition at line 182 of file G4NURBS.hh.

t_doubleCtrlPt

typedef G4double G4NURBS::t_doubleCtrlPt[NofC]

Definition at line 110 of file G4NURBS.hh.

t_floatCtrlPt

typedef G4float G4NURBS::t_floatCtrlPt[NofC]

Definition at line 111 of file G4NURBS.hh.

t_indCoord

typedef unsigned int G4NURBS::t_indCoord

Definition at line 90 of file G4NURBS.hh.

t_indCtrlPt

typedef unsigned int G4NURBS::t_indCtrlPt

Definition at line 91 of file G4NURBS.hh.

t_inddCtrlPt

typedef t_index G4NURBS::t_inddCtrlPt

Definition at line 92 of file G4NURBS.hh.

t_index

typedef unsigned int G4NURBS::t_index

Definition at line 84 of file G4NURBS.hh.

t_indKnot

typedef t_index G4NURBS::t_indKnot

Definition at line 87 of file G4NURBS.hh.

t_Knot

typedef G4Float G4NURBS::t_Knot

Definition at line 176 of file G4NURBS.hh.

t_order

typedef t_index G4NURBS::t_order

Definition at line 173 of file G4NURBS.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
X
Y
Z
W
NofC

Definition at line 106 of file G4NURBS.hh.

{ X, Y, Z, W, NofC };   // NofC : number of coordinates

t_CheckFlag

enum G4NURBS::t_CheckFlag

protected

Enumerator
NOcheck
check

Definition at line 280 of file G4NURBS.hh.

{ NOcheck, check } t_CheckFlag;

t_direction

enum G4NURBS::t_direction

Enumerator
U
V
DMask
NofD

Definition at line 71 of file G4NURBS.hh.

  {
    U     = 0,
    V     = 1,
    DMask = 1,  // NofD : Number of Directions 
    NofD  = 2   // DMask : direction mask for fast range control,
  };            // e.g. : m[a_dir & DMask]

t_KnotVectorGenFlag

enum G4NURBS::t_KnotVectorGenFlag

Enumerator
UserDefined
Regular
RegularRep

Definition at line 319 of file G4NURBS.hh.

  { 
    UserDefined, // The user will fill the array (in the child constructor
                 // for instance).
 
    Regular,     // First and last knot repeated order time
                 // other knots regularly spaced, unrepeated.
                 // Typically used for "linear" knots vector
 
    RegularRep   // First and last knot repeated order time
                 // other knots regularly spaced but repeated one time.
                 // Typically used for "circular" knots vector and alikes.
  }; //t_KnotVectorGenFlag

Constructor & Destructor Documentation

~G4NURBS()

G4NURBS::~G4NURBS ( )

virtual

Definition at line 546 of file G4NURBS.cc.

{
  // we must free the two knots vector
  t_direction dir;
  G4int dummy;
  for (dummy=0; (dummy?(dir=V):(dir=U)),(dummy < NofD); dummy++)
  {
    if (m[dir].pKnots)
      delete m[dir].pKnots;  // [m[dir].nbrKnots] if t_Knot become a class
    m[dir].pKnots = 0;
  }
  // now we free the CtrlPts array
  if (mpCtrlPts)
    delete [] mpCtrlPts;    // [mtotnbrCtrlPts] if t_CtrlPt become a class
  mpCtrlPts = 0;
}

G4NURBS() [1/2]

G4NURBS::G4NURBS ( t_order  in_Uorder, t_order  in_Vorder, t_inddCtrlPt  in_UnbrCtrlPts, t_inddCtrlPt  in_VnbrCtrlPts, t_CtrlPt *  in_pCtrlPts, t_Knot *  in_pUKnots = 0, t_Knot *  in_pVKnots = 0, t_CheckFlag  in_CheckFlag = check  )

protected

Definition at line 412 of file G4NURBS.cc.

{
  m[U].order=in_Uorder; m[V].order=in_Vorder;
  m[U].nbrCtrlPts=in_UnbrCtrlPts; m[V].nbrCtrlPts=in_VnbrCtrlPts;
 
  mtotnbrCtrlPts = m[U].nbrCtrlPts * m[V].nbrCtrlPts;
  m[U].nbrKnots = m[U].order + m[U].nbrCtrlPts;
  m[V].nbrKnots = m[V].order + m[V].nbrCtrlPts;
    
  if (in_CheckFlag)
    Conscheck();
 
  // CtrlPts
  if (! (mpCtrlPts = in_pCtrlPts) )
  {
    G4ExceptionDescription ed;
    ed << "A NURBS MUST HAVE CONTROL POINTS!\n"
       << "\teven if they are defined later, the array must be allocated."
       << G4endl;
    G4Exception("G4NURBS::G4NURBS()",
        "greps9003", FatalException, ed);
  }
  //mnbralias = 0;
 
  // Knots
  t_direction dir;
  G4int dummy;
  for (dummy=0; (dummy?(dir=V):(dir=U)),(dummy < NofD); dummy++)
  {
    if ( !(m[dir].pKnots = (dummy?in_pVKnots:in_pUKnots)) )
    {  // make some regular knots between 0 & 1
      if(!MakeKnotVector(m[dir], Regular))
      {
    G4ExceptionDescription ed;
        ed << "Unable to make a Regular knot vector along "
       << G4NURBS::Tochar(dir)
       << " direction."
       << G4endl;
        G4Exception("G4NURBS::G4NURBS()",
            "greps9004", FatalException, ed);
      }
      //m[dir].nbralias = 0;
    }  // end of knots-making
  }  // end for dummy
} // end of G4NURBS::G4NURBS 

G4NURBS() [2/2]

G4NURBS::G4NURBS ( t_order  in_Uorder, t_order  in_Vorder, t_inddCtrlPt  in_UnbrCtrlPts, t_inddCtrlPt  in_VnbrCtrlPts, t_KnotVectorGenFlag  in_UKVGFlag = Regular, t_KnotVectorGenFlag  in_VKVGFlag = Regular, t_CheckFlag  in_CheckFlag = check  )

protected

Definition at line 464 of file G4NURBS.cc.

{
  m[U].order=in_Uorder; m[V].order=in_Vorder;
  m[U].nbrCtrlPts=in_UnbrCtrlPts; m[V].nbrCtrlPts=in_VnbrCtrlPts;
 
  mtotnbrCtrlPts = m[U].nbrCtrlPts * m[V].nbrCtrlPts;
  m[U].nbrKnots = m[U].order + m[U].nbrCtrlPts;
  m[V].nbrKnots = m[V].order + m[V].nbrCtrlPts;
    
  if (in_CheckFlag)
    Conscheck();
 
  // Allocate CtrlPts
  mpCtrlPts = new t_CtrlPt [mtotnbrCtrlPts];
  //mnbralias = 0;
 
  // Knots
  t_direction dir;
  G4int dummy;
  for (dummy=0; (dummy?(dir=V):(dir=U)),(dummy < NofD); dummy++)
  {
    t_KnotVectorGenFlag flag = (dummy?in_VKVGFlag:in_UKVGFlag);
    m[dir].pKnots = 0;  // (allocation under our control)
    if ( flag != UserDefined && !MakeKnotVector(m[dir], flag) )
    {
      G4ExceptionDescription ed;
      ed << "Unable to make knot vector along "
     << G4NURBS::Tochar(dir)
     << " direction. (" << m[dir].nbrKnots 
     << " knots requested for a " 
     << flag 
     << " knots vector)"
     << G4endl;
      G4Exception("G4NURBS::G4NURBS()",
          "greps9005", FatalException, ed);
    }
    //m[dir].nbralias = 0;
  }
}

Member Function Documentation

CalcPoint()

void G4NURBS::CalcPoint	(	G4double	u,
		G4double	v,
		G4Point3D &	p,
		G4Vector3D &	utan,
		G4Vector3D &	vtan
	)		const

Definition at line 659 of file G4NURBS.cc.

{
#define MAXORDER 50
  struct Point4
  {
    G4double x, y, z, w;
  };
 
  G4int i, j, ri, rj;
  G4int ubrkPoint, ufirst;
  G4double bu[MAXORDER], buprime[MAXORDER];
  G4int vbrkPoint, vfirst;
  G4double bv[MAXORDER], bvprime[MAXORDER];
  Point4 r, rutan, rvtan;
 
  r.x = 0.0; r.y = 0.0; r.z = 0.0; r.w = 0.0;
  rutan = r;   rvtan = r;
 
  G4int numU   = GetUnbrCtrlPts();
  G4int numV   = GetVnbrCtrlPts();
  G4int orderU = GetUorder();
  G4int orderV = GetVorder();
  
  /* Evaluate non-uniform basis functions (and derivatives) */
  
  ubrkPoint = FindBreakPoint(u, m[U].pKnots, numU-1, orderU);
  ufirst    = ubrkPoint - orderU + 1;
  BasisFunctions  (u, ubrkPoint, m[U].pKnots, orderU, bu);
  BasisDerivatives(u, ubrkPoint, m[U].pKnots, orderU, buprime);
 
  vbrkPoint = FindBreakPoint(v, m[V].pKnots, numV-1, orderV);
  vfirst    = vbrkPoint - orderV + 1;
  BasisFunctions  (v, vbrkPoint, m[V].pKnots, orderV, bv);
  BasisDerivatives(v, vbrkPoint, m[V].pKnots, orderV, bvprime);
 
  /* Weight control points against the basis functions */
 
  t_doubleCtrlPt *cpoint;
  Point4 cp;
  G4double tmp;
 
  for (i=0; i<orderV; i++)
  {
    for (j=0; j<orderU; j++)
    {
      ri = orderV - 1 - i;
      rj = orderU - 1 - j;
 
      tmp = bu[rj] * bv[ri];
 
      cpoint = GetdoubleCtrlPt(j+ufirst, i+vfirst);
      cp.x = *cpoint[G4NURBS::X];
      cp.y = *cpoint[G4NURBS::Y];
      cp.z = *cpoint[G4NURBS::Z];
      cp.w = *cpoint[G4NURBS::W];
      delete [] cpoint;
 
      r.x += cp.x * tmp;
      r.y += cp.y * tmp;
      r.z += cp.z * tmp;
      r.w += cp.w * tmp;
      
      tmp = buprime[rj] * bv[ri];
      rutan.x += cp.x * tmp;
      rutan.y += cp.y * tmp;
      rutan.z += cp.z * tmp;
      rutan.w += cp.w * tmp;
 
      tmp = bu[rj] * bvprime[ri];
      rvtan.x += cp.x * tmp;
      rvtan.y += cp.y * tmp;
      rvtan.z += cp.z * tmp;
      rvtan.w += cp.w * tmp;
    }
  }
 
  /* Project tangents, using the quotient rule for differentiation */
  
  G4double wsqrdiv = 1.0 / (r.w * r.w);
 
  utan.setX((r.w * rutan.x - rutan.w * r.x) * wsqrdiv);
  utan.setY((r.w * rutan.y - rutan.w * r.y) * wsqrdiv);
  utan.setZ((r.w * rutan.z - rutan.w * r.z) * wsqrdiv);
 
  vtan.setX((r.w * rvtan.x - rvtan.w * r.x) * wsqrdiv);
  vtan.setY((r.w * rvtan.y - rvtan.w * r.y) * wsqrdiv);
  vtan.setZ((r.w * rvtan.z - rvtan.w * r.z) * wsqrdiv);
 
  p.setX(r.x / r.w);
  p.setY(r.y / r.w);
  p.setZ(r.z / r.w);
}

CP() [1/2]

void G4NURBS::CP ( G4NURBS::t_CtrlPt &  rcp, t_Coord  x, t_Coord  y, t_Coord  z, t_Coord  w  )

inlinestaticprotected

Definition at line 520 of file G4NURBS.hh.

{
  rcp[G4NURBS::X]=x;
  rcp[G4NURBS::Y]=y;
  rcp[G4NURBS::Z]=z;
  rcp[G4NURBS::W]=w;    
}

Referenced by G4NURBSbox::G4NURBSbox(), G4NURBScylinder::G4NURBScylinder(), G4NURBShexahedron::G4NURBShexahedron(), G4NURBStube::G4NURBStube(), and G4NURBStubesector::G4NURBStubesector().

CP() [2/2]

void G4NURBS::CP ( G4NURBS::t_CtrlPt &  rcp, t_Coord  x, t_Coord  y, t_Coord  z, t_Coord  w, G4Float  factor  )

inlinestaticprotected

Definition at line 530 of file G4NURBS.hh.

{
  rcp[G4NURBS::X]=factor*x;
  rcp[G4NURBS::Y]=factor*y;
  rcp[G4NURBS::Z]=factor*z;
  rcp[G4NURBS::W]=factor*w; 
}

GetdoubleAllCtrlPts()

G4double * G4NURBS::GetdoubleAllCtrlPts

(

)

const

Definition at line 226 of file G4NURBS.cc.

{
  G4double * p = new G4double [mtotnbrCtrlPts*NofC];
  for (t_indKnot i = 0; i < mtotnbrCtrlPts*NofC; i++)
    p[i] = (G4double)(((t_Coord *)mpCtrlPts)[i]);
  return p;
}

GetdoubleAllKnots()

G4double * G4NURBS::GetdoubleAllKnots

(

t_direction

in_dir

)

const

Definition at line 209 of file G4NURBS.cc.

{
  in_dir = (t_direction)(in_dir & DMask);
  G4double * p = new G4double [m[in_dir].nbrKnots];
  for (t_indKnot i = 0; i < m[in_dir].nbrKnots; i++)
    p[i] = (G4double)m[in_dir].pKnots[i];
  return p;
}

GetdoubleCtrlPt() [1/2]

G4NURBS::t_doubleCtrlPt * G4NURBS::GetdoubleCtrlPt

(

t_indCtrlPt

in_onedimindex

)

const

Definition at line 170 of file G4NURBS.cc.

{
  if ( in_onedimindex < mtotnbrCtrlPts )
    return TodoubleCtrlPt(mpCtrlPts[in_onedimindex]);
  else
  {
    G4cerr << "\nERROR: G4NURBS::getdoubleCtrlPts: index out of range"
           << "\n\t in_onedimindex : " << in_onedimindex
           << " , mtotnbrCtrlPts : " << mtotnbrCtrlPts << G4endl;
    return TodoubleCtrlPt(mpCtrlPts[mtotnbrCtrlPts-1]);  
  }   
}

Referenced by CalcPoint().

GetdoubleCtrlPt() [2/2]

G4NURBS::t_doubleCtrlPt * G4NURBS::GetdoubleCtrlPt	(	t_inddCtrlPt	in_Uindex,
		t_inddCtrlPt	in_Vindex
	)		const

Definition at line 184 of file G4NURBS.cc.

{
  if ( (in_Uindex < m[U].nbrCtrlPts) && (in_Vindex < m[V].nbrCtrlPts) )
    return TodoubleCtrlPt(mpCtrlPts[To1d(in_Uindex, in_Vindex)]);
  else
  {
    G4cerr << "\nERROR: G4NURBS::GetdoubleCtrlPt: index(s) out of range"
           << "\n\t in_Uindex : " << in_Uindex
           << " , in_Vindex : " << in_Vindex
           << " , UnbrCtrlPts : " << m[U].nbrCtrlPts
           << " , VnbrCtrlPts : " << m[V].nbrCtrlPts << G4endl;
    return TodoubleCtrlPt(mpCtrlPts[mtotnbrCtrlPts-1]);  
  }  
}

GetdoubleKnot()

G4double G4NURBS::GetdoubleKnot	(	t_direction	in_dir,
		t_indKnot	in_index
	)		const

Definition at line 123 of file G4NURBS.cc.

{
  in_dir = (t_direction)(in_dir & DMask);
  if ( in_index < m[in_dir].nbrKnots )
    return (G4double)(m[in_dir].pKnots[in_index]);
  else
  {
    G4cerr << "\nERROR: G4NURBS::GetdoubleKnot: index out of range"
           << "\n\t in_dir : " << G4int(in_dir)
           << ", in_index : " << G4int(in_index)
           << "m[in_dir].nbrKnots : " << m[in_dir].nbrKnots
           << G4endl;
    return (G4double)(m[in_dir].pKnots[m[in_dir].nbrKnots-1]); 
  }
}

GetfloatAllCtrlPts()

G4float * G4NURBS::GetfloatAllCtrlPts

(

)

const

Definition at line 218 of file G4NURBS.cc.

{
  G4float * p = new G4float [mtotnbrCtrlPts*NofC];
  for (t_indKnot i = 0; i < mtotnbrCtrlPts*NofC; i++)
    p[i] = (G4float)(((t_Coord *)mpCtrlPts)[i]);
  return p;
}

GetfloatAllKnots()

G4float * G4NURBS::GetfloatAllKnots

(

t_direction

in_dir

)

const

Definition at line 200 of file G4NURBS.cc.

{
  in_dir = (t_direction)(in_dir & DMask);
  G4float * p = new G4float [m[in_dir].nbrKnots];
  for (t_indKnot i = 0; i < m[in_dir].nbrKnots; i++)
    p[i] = (G4float)m[in_dir].pKnots[i];
  return p;
}

GetfloatCtrlPt() [1/2]

G4NURBS::t_floatCtrlPt * G4NURBS::GetfloatCtrlPt

(

t_indCtrlPt

in_onedimindex

)

const

Definition at line 140 of file G4NURBS.cc.

{
  if (in_onedimindex < mtotnbrCtrlPts)
    return TofloatCtrlPt(mpCtrlPts[in_onedimindex]);       
  else
  {
    G4cerr << "\nERROR: G4NURBS::GetfloatCtrlPt: index out of range"
           << "\n\t in_onedimindex : " << in_onedimindex
           << " , mtotnbrCtrlPts : " << mtotnbrCtrlPts << G4endl;
    return TofloatCtrlPt(mpCtrlPts[mtotnbrCtrlPts-1]);  
  }    
}

GetfloatCtrlPt() [2/2]

G4NURBS::t_floatCtrlPt * G4NURBS::GetfloatCtrlPt	(	t_inddCtrlPt	in_Uindex,
		t_inddCtrlPt	in_Vindex
	)		const

Definition at line 154 of file G4NURBS.cc.

{
  if ( (in_Uindex < m[U].nbrCtrlPts) && (in_Vindex < m[V].nbrCtrlPts) )
    return TofloatCtrlPt(mpCtrlPts[To1d(in_Uindex, in_Vindex)]);
  else
  {
    G4cerr << "\nERROR: G4NURBS::GetfloatCtrlPt: index(s) out of range"
           << "\n\t in_Uindex : " << in_Uindex
           << " , in_Vindex : " << in_Vindex
           << " , UnbrCtrlPts : " << m[U].nbrCtrlPts
           << " , VnbrCtrlPts : " << m[V].nbrCtrlPts << G4endl;
    return TofloatCtrlPt(mpCtrlPts[mtotnbrCtrlPts-1]);  
  }   
}

GetfloatKnot()

G4float G4NURBS::GetfloatKnot	(	t_direction	in_dir,
		t_indKnot	in_index
	)		const

Definition at line 108 of file G4NURBS.cc.

{
  in_dir = (t_direction)(in_dir & DMask);
  if ( in_index < m[in_dir].nbrKnots )
    return ((G4float)(m[in_dir].pKnots[in_index])); 
  else
  {
    G4cerr << "\nERROR: G4NURBS::GetfloatKnot: index out of range\n"
           << "\n\t in_dir : " << G4int(in_dir)
           << ", in_index : " << G4int(in_index)
           << "m[in_dir].nbrKnots : " << m[in_dir].nbrKnots << G4endl;
    return ((G4float)m[in_dir].pKnots[m[in_dir].nbrKnots-1]); 
  }
}

GetnbrCtrlPts()

G4int G4NURBS::GetnbrCtrlPts ( G4NURBS::t_direction  in_dir ) const

inline

Definition at line 463 of file G4NURBS.hh.

                                                                   {
  return m[in_dir & DMask].nbrCtrlPts;
} 

GetnbrKnots()

G4int G4NURBS::GetnbrKnots ( G4NURBS::t_direction  in_dir ) const

inline

Definition at line 459 of file G4NURBS.hh.

                                                                 {
  return m[in_dir & DMask].nbrKnots;
}

Referenced by operator<<().

Getorder()

G4int G4NURBS::Getorder ( G4NURBS::t_direction  in_dir ) const

inline

Definition at line 455 of file G4NURBS.hh.

                                                              {
  return m[in_dir & DMask].order;
}

GettotalnbrCtrlPts()

G4int G4NURBS::GettotalnbrCtrlPts ( ) const

inline

Definition at line 437 of file G4NURBS.hh.

{ return mtotnbrCtrlPts; }

GetUmax()

G4double G4NURBS::GetUmax ( ) const

inline

Definition at line 443 of file G4NURBS.hh.

                                       {
  return (G4double) m[U].pKnots[GetUnbrCtrlPts()];
}

GetUmin()

G4double G4NURBS::GetUmin ( ) const

inline

Definition at line 439 of file G4NURBS.hh.

                                       {
  return (G4double) m[U].pKnots[GetUorder()-1];
}

GetUnbrCtrlPts()

G4int G4NURBS::GetUnbrCtrlPts ( ) const

inline

Definition at line 435 of file G4NURBS.hh.

{ return m[U].nbrCtrlPts; }

Referenced by CalcPoint(), GetUmax(), and operator<<().

GetUnbrKnots()

G4int G4NURBS::GetUnbrKnots ( ) const

inline

Definition at line 433 of file G4NURBS.hh.

{ return m[U].nbrKnots; }

GetUorder()

G4int G4NURBS::GetUorder ( ) const

inline

Definition at line 431 of file G4NURBS.hh.

{ return m[U].order; }

Referenced by CalcPoint(), GetUmin(), and operator<<().

GetVmax()

G4double G4NURBS::GetVmax ( ) const

inline

Definition at line 451 of file G4NURBS.hh.

                                       {
  return (G4double) m[V].pKnots[GetVnbrCtrlPts()];
}

GetVmin()

G4double G4NURBS::GetVmin ( ) const

inline

Definition at line 447 of file G4NURBS.hh.

                                       { 
  return (G4double) m[V].pKnots[GetVorder()-1];
}

GetVnbrCtrlPts()

G4int G4NURBS::GetVnbrCtrlPts ( ) const

inline

Definition at line 436 of file G4NURBS.hh.

{ return m[V].nbrCtrlPts; }

Referenced by CalcPoint(), GetVmax(), and operator<<().

GetVnbrKnots()

G4int G4NURBS::GetVnbrKnots ( ) const

inline

Definition at line 434 of file G4NURBS.hh.

{ return m[V].nbrKnots; }

GetVorder()

G4int G4NURBS::GetVorder ( ) const

inline

Definition at line 432 of file G4NURBS.hh.

{ return m[V].order; }

Referenced by CalcPoint(), GetVmin(), and operator<<().

MakeKnotVector() [1/2]

G4bool G4NURBS::MakeKnotVector ( t_Dir &  inout_dirdat, t_KnotVectorGenFlag  in_KVGFlag  )

staticprotected

Definition at line 331 of file G4NURBS.cc.

{
  G4bool isgood = (io_d.order + io_d.nbrCtrlPts == io_d.nbrKnots)
                  && (io_d.pKnots == 0);
  if ( isgood )
  {
    io_d.pKnots = new t_Knot [io_d.nbrKnots];
    if (in_KVGFlag != UserDefined)
    {  // let's do the knots
      t_indKnot indKnot = 0;
      t_index nbrCentralDistinctKnots = io_d.nbrCtrlPts-io_d.order;
      if ( (nbrCentralDistinctKnots % in_KVGFlag) == 0)
      {
        nbrCentralDistinctKnots /= in_KVGFlag; 
        // first and last knots repeated 'order' Times
        for (t_index i=0; i < io_d.order; indKnot++,i++)
        {
          io_d.pKnots[indKnot] = 0;
          io_d.pKnots[indKnot+io_d.nbrCtrlPts] = 1;
        }
 
        t_Knot stepKnot = 1.0/(t_Knot)(nbrCentralDistinctKnots+1);
        t_Knot valKnot = stepKnot;
 
        // central knots
        for (t_indKnot j=0; j<nbrCentralDistinctKnots; valKnot+=stepKnot, j++)
        {
          for (t_indKnot k=0; k<t_indKnot(in_KVGFlag); indKnot++, k++)
            io_d.pKnots[indKnot] = valKnot;
        }
      }
      else isgood = false;
    } // end of knots making
  }  
  return isgood;
}

Referenced by G4NURBS(), and MakeKnotVector().

MakeKnotVector() [2/2]

G4bool G4NURBS::MakeKnotVector ( G4NURBS::t_Dir *  p_inoutdirdat, G4NURBS::t_KnotVectorGenFlag  in_KVGFlag  )

inlinestaticprotected

Definition at line 507 of file G4NURBS.hh.

{
  return MakeKnotVector(*p_inoutdirdat, in_KVGFlag);
}

To1d()

G4NURBS::t_indCtrlPt G4NURBS::To1d ( t_inddCtrlPt  in_Uindex, t_inddCtrlPt  in_Vindex  ) const

inlineprotected

Definition at line 481 of file G4NURBS.hh.

{
  return in_Uindex + in_Vindex*m[U].nbrCtrlPts;
}

Referenced by G4NURBShexahedron::G4NURBShexahedron(), GetdoubleCtrlPt(), and GetfloatCtrlPt().

Tochar()

char G4NURBS::Tochar ( G4NURBS::t_direction  in_dir )

inlinestatic

Definition at line 467 of file G4NURBS.hh.

                                                     {
  return (in_dir != U? 'V': 'U');
}

Referenced by G4NURBS(), and operator<<().

TodoubleCtrlPt()

G4NURBS::t_doubleCtrlPt * G4NURBS::TodoubleCtrlPt ( const t_CtrlPt &  in_krcp )

inlinestaticprotected

Definition at line 498 of file G4NURBS.hh.

{
  G4NURBS::t_doubleCtrlPt *  pcopy = new G4NURBS::t_doubleCtrlPt [4];
  for (G4int indCoord = X; indCoord < NofC; indCoord++)
    (*pcopy)[indCoord] = (G4double)in_krcp[indCoord];
  return pcopy;
}

Referenced by GetdoubleCtrlPt().

TofloatCtrlPt()

G4NURBS::t_floatCtrlPt * G4NURBS::TofloatCtrlPt ( const t_CtrlPt &  in_krcp )

inlinestaticprotected

Definition at line 488 of file G4NURBS.hh.

{
  G4NURBS::t_floatCtrlPt * pcopy = new G4NURBS::t_floatCtrlPt [1];
  for (G4int indCoord = X; indCoord < NofC; indCoord++)
    (*pcopy)[indCoord] = (G4float)in_krcp[indCoord];
  return pcopy;
}

Referenced by GetfloatCtrlPt().

Whoami()

virtual const char * G4NURBS::Whoami ( ) const

pure virtual

Implemented in G4NURBSbox, G4NURBScylinder, G4NURBShexahedron, G4NURBStube, and G4NURBStubesector.

Referenced by operator<<().

Friends And Related Function Documentation

CtrlPtsCoordsIterator

friend class CtrlPtsCoordsIterator

friend

Definition at line 202 of file G4NURBS.hh.

CtrlPtsIterator

friend class CtrlPtsIterator

friend

Definition at line 203 of file G4NURBS.hh.

KnotsIterator

friend class KnotsIterator

friend

Definition at line 201 of file G4NURBS.hh.

operator<<

std::ostream & operator<< ( std::ostream &  inout_OutStream, G4NURBS::t_KnotVectorGenFlag  in_KVGFlag  )

friend

Definition at line 369 of file G4NURBS.cc.

{
  switch (in_f) 
  {
    case G4NURBS::UserDefined: io_ostr << "UserDefined"; break;
    case G4NURBS::Regular:     io_ostr << "Regular"; break;
    case G4NURBS::RegularRep:  io_ostr << "RegularRep"; break;
    default:                   io_ostr << (G4int)in_f;
  }
  return io_ostr;
}

Member Data Documentation

m

t_Dir G4NURBS::m[NofD]

protected

Definition at line 348 of file G4NURBS.hh.

Referenced by CalcPoint(), G4NURBS(), G4NURBScylinder::G4NURBScylinder(), GetdoubleAllKnots(), GetdoubleCtrlPt(), GetdoubleKnot(), GetfloatAllKnots(), GetfloatCtrlPt(), GetfloatKnot(), GetnbrCtrlPts(), GetnbrKnots(), Getorder(), GetUmax(), GetUmin(), GetUnbrCtrlPts(), GetUnbrKnots(), GetUorder(), GetVmax(), GetVmin(), GetVnbrCtrlPts(), GetVnbrKnots(), GetVorder(), G4NURBS::KnotsIterator::KnotsIterator(), To1d(), and ~G4NURBS().

mpCtrlPts

t_CtrlPt* G4NURBS::mpCtrlPts

protected

Definition at line 350 of file G4NURBS.hh.

Referenced by G4NURBS::CtrlPtsCoordsIterator::CtrlPtsCoordsIterator(), G4NURBS::CtrlPtsIterator::CtrlPtsIterator(), G4NURBS(), G4NURBSbox::G4NURBSbox(), G4NURBScylinder::G4NURBScylinder(), G4NURBShexahedron::G4NURBShexahedron(), G4NURBStube::G4NURBStube(), G4NURBStubesector::G4NURBStubesector(), GetdoubleAllCtrlPts(), GetdoubleCtrlPt(), GetfloatAllCtrlPts(), GetfloatCtrlPt(), and ~G4NURBS().

mtotnbrCtrlPts

t_indCtrlPt G4NURBS::mtotnbrCtrlPts

protected

Definition at line 349 of file G4NURBS.hh.

Referenced by G4NURBS::CtrlPtsCoordsIterator::CtrlPtsCoordsIterator(), G4NURBS::CtrlPtsIterator::CtrlPtsIterator(), G4NURBS(), G4NURBStubesector::G4NURBStubesector(), GetdoubleAllCtrlPts(), GetdoubleCtrlPt(), GetfloatAllCtrlPts(), GetfloatCtrlPt(), and GettotalnbrCtrlPts().

---

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

• G4NURBS.hh
• G4NURBS.cc