G4KnotVector Class Reference

#include <G4KnotVector.hh>

Public Member Functions
	G4KnotVector ()
	G4KnotVector (G4int sz)
	~G4KnotVector ()
	G4KnotVector (const G4KnotVector &orig)
G4KnotVector &	operator= (const G4KnotVector &right)
G4int	GetSize () const
G4double	GetKnot (G4int knot_number) const
void	PutKnot (G4int knot_number, G4double value)
G4KnotVector *	MultiplyKnotVector (G4int num, G4double value)
G4double *	MergeKnotVector (const G4double *knots_to_add, G4int add_size)
G4int	CheckKnotVector (G4double val) const
void	ExtractKnotVector (G4KnotVector *kv, G4int upper, G4int lower)
G4int	GetKnotIndex (G4double k_value, G4int order) const

Detailed Description

Definition at line 45 of file G4KnotVector.hh.

Constructor & Destructor Documentation

G4KnotVector() [1/3]

G4KnotVector::G4KnotVector

(

)

Definition at line 39 of file G4KnotVector.cc.

  : k_size(0), knots(0)
{
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
}

Referenced by MultiplyKnotVector().

G4KnotVector() [2/3]

G4KnotVector::G4KnotVector

(

G4int

sz

)

Definition at line 45 of file G4KnotVector.cc.

{
  k_size=sz; 
  knots = new G4double[k_size]; 
  for(G4int a=0;a<k_size;a++)
    { knots[a]=0; }
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
}

~G4KnotVector()

G4KnotVector::~G4KnotVector

(

)

Definition at line 55 of file G4KnotVector.cc.

{
  delete [] knots;
}  

G4KnotVector() [3/3]

G4KnotVector::G4KnotVector

(

const G4KnotVector &

orig

)

Definition at line 60 of file G4KnotVector.cc.

{
  delete [] knots;
  k_size = orig.k_size;
  knots = new G4double[k_size];
  for(register G4int a=0; a < orig.k_size; a++)
    { knots[a] = orig.knots[a]; }
  kCarTolerance = orig.kCarTolerance;
}

Member Function Documentation

CheckKnotVector()

G4int G4KnotVector::CheckKnotVector

(

G4double

val

)

const

Definition at line 170 of file G4KnotVector.cc.

{
  G4int num = 0;
  
  for ( G4int i = 0; i < k_size; i++) 
  {
    //    if ( std::abs(val - knots[i]) < kCarTolerance)
    if ( val == knots[i] )
      num++;
  }
 
  return num;
}

Referenced by MultiplyKnotVector().

ExtractKnotVector()

void G4KnotVector::ExtractKnotVector	(	G4KnotVector *	kv,
		G4int	upper,
		G4int	lower
	)

Definition at line 185 of file G4KnotVector.cc.

{
  delete[] kv->knots;
  kv->k_size = upper-lower;
  kv->knots  = new G4double[kv->k_size];
  
  for ( G4int i = lower; i < upper; i++)
    kv->knots[i-lower] = knots[i];
}

GetKnot()

G4double G4KnotVector::GetKnot ( G4int  knot_number ) const

inline

Referenced by G4BezierSurface::BIntersect().

GetKnotIndex()

G4int G4KnotVector::GetKnotIndex	(	G4double	k_value,
		G4int	order
	)		const

Definition at line 83 of file G4KnotVector.cc.

{
  G4int    i, knot_index;
  G4double knt;
 
  knt = knots[order - 1];
  if ( k_value < knt )
  {
    if (ApxEq( k_value, knt)) 
      k_value = knt;
    else
      return -1;
  }
  
  knt = knots[k_size - order + 1];
  if ( k_value > knt )
  {
    if (ApxEq( k_value, knt)) 
      k_value = knt;
    else
      return -1;
  }
 
  if ( k_value == knots[k_size - order + 1] )
    knot_index = k_size - order - 1;
  else if ( k_value == knots[ order - 1] )
    knot_index = order - 1;
  else
  {
    knot_index = 0;
    
    for ( i = 0; i < k_size - 1; i++)
      if((knots[i]<k_value) && (k_value <= knots[i+1]))
    knot_index = i;  
  }
 
  return knot_index;
}

GetSize()

G4int G4KnotVector::GetSize ( ) const

inline

Referenced by G4BezierSurface::BIntersect(), and MultiplyKnotVector().

MergeKnotVector()

G4double * G4KnotVector::MergeKnotVector	(	const G4double *	knots_to_add,
		G4int	add_size
	)

Definition at line 145 of file G4KnotVector.cc.

{
  G4double *newknots;
  G4int kv1_ptr = 0, 
        kv2_ptr = 0, 
        newptr;
  G4int old_size = k_size;
 
  newknots = new G4double[k_size + add_size];
    
  for ( newptr = 0; newptr < k_size+add_size; newptr++) 
    if ( kv1_ptr >= add_size )
      newknots[newptr] = knots[kv2_ptr++];
    else if ( kv2_ptr >= old_size )
      newknots[newptr] = knots_to_add[kv1_ptr++];
    else if ( knots_to_add[kv1_ptr] < knots[kv2_ptr])
      newknots[newptr] = knots_to_add[kv1_ptr++];
    else
      newknots[newptr] = knots[kv2_ptr++];
  
  return newknots;
}

Referenced by MultiplyKnotVector().

MultiplyKnotVector()

G4KnotVector * G4KnotVector::MultiplyKnotVector	(	G4int	num,
		G4double	value
	)

Definition at line 123 of file G4KnotVector.cc.

{
  G4int n;
  G4double* knots_to_add;
  
  n            = CheckKnotVector( val );
  knots_to_add = new G4double[num-n];   
  
  for (G4int i = 0; i < num - n; i++)
    knots_to_add[i] = val;
  
  G4KnotVector* new_kv = new G4KnotVector();
  new_kv->k_size = num - n + GetSize();
  new_kv->knots  = MergeKnotVector(knots_to_add, num-n);
  
  delete [] knots_to_add;
  
  return new_kv;
}

operator=()

G4KnotVector & G4KnotVector::operator=

(

const G4KnotVector &

right

)

Definition at line 70 of file G4KnotVector.cc.

{
  if (&right == this) return *this;
  delete [] knots;
  k_size = right.k_size;
  knots = new G4double[k_size];
  for(register G4int a=0; a < right.k_size; a++)
    knots[a] = right.knots[a];
  kCarTolerance = right.kCarTolerance;
 
  return *this;
}

PutKnot()

void G4KnotVector::PutKnot ( G4int  knot_number, G4double  value  )

inline

---

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

• G4KnotVector.hh
• G4KnotVector.cc