Gabriele Cosmo
146 lines
3.1 KiB
C++
146 lines
3.1 KiB
C++
// This code implementation is the intellectual property of
|
|
// the GEANT4 collaboration.
|
|
//
|
|
// By copying, distributing or modifying the Program (or any work
|
|
// based on the Program) you indicate your acceptance of this statement,
|
|
// and all its terms.
|
|
//
|
|
// $Id: G4KnotVector.cc,v 1.2 1999/12/15 14:50:01 gunter Exp $
|
|
// GEANT4 tag $Name: geant4-02-00 $
|
|
//
|
|
|
|
#include "G4KnotVector.hh"
|
|
|
|
G4KnotVector::G4KnotVector()
|
|
{
|
|
knots=(G4double*)0;
|
|
}
|
|
|
|
G4KnotVector::G4KnotVector(const int sz)
|
|
{
|
|
k_size=sz;
|
|
knots = new G4double[k_size];
|
|
for(int a=0;a<k_size;a++)
|
|
knots[a]=0;
|
|
}
|
|
|
|
|
|
G4KnotVector::~G4KnotVector() { delete [] knots;}
|
|
|
|
//Copy constructor
|
|
G4KnotVector::G4KnotVector(const G4KnotVector& old_kv)
|
|
{
|
|
k_size = old_kv.GetSize();
|
|
knots = new G4double[k_size];
|
|
for(register int a=0; a < old_kv.k_size; a++)knots[a]=old_kv.knots[a];
|
|
}
|
|
|
|
int G4KnotVector::GetKnotIndex(G4double k_value,const int order)
|
|
{
|
|
int i, knot_index;
|
|
G4double knt;
|
|
|
|
if ( k_value < ( knt = knots[order - 1]))
|
|
if (ApxEq( k_value, knt))
|
|
k_value = knt;
|
|
else
|
|
return -1;
|
|
|
|
if ( k_value > ( knt = knots[k_size - order + 1]))
|
|
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;
|
|
}
|
|
|
|
|
|
G4KnotVector* G4KnotVector::MultiplyKnotVector(const int num,
|
|
const G4double val)
|
|
{
|
|
int n;
|
|
G4double* knots_to_add;
|
|
|
|
n = CheckKnotVector( val );
|
|
knots_to_add = new G4double[num-n];
|
|
|
|
for (int 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;
|
|
}
|
|
|
|
|
|
G4double* G4KnotVector::MergeKnotVector(const G4double* knots_to_add,
|
|
const int add_size )
|
|
{
|
|
G4double *newknots;
|
|
int kv1_ptr = 0,
|
|
kv2_ptr = 0,
|
|
newptr;
|
|
int 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;
|
|
}
|
|
|
|
|
|
int G4KnotVector::CheckKnotVector(const G4double val)
|
|
{
|
|
int num = 0;
|
|
|
|
for ( int i = 0; i < k_size; i++)
|
|
{
|
|
// if ( abs(val - knots[i]) < kCarTolerance)
|
|
if ( val == knots[i] )
|
|
num++;
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
|
|
void G4KnotVector::ExtractKnotVector( G4KnotVector* kv,
|
|
const int upper,const int lower)
|
|
{
|
|
delete[] kv->knots;
|
|
kv->k_size = upper-lower;
|
|
kv->knots = new G4double[kv->k_size];
|
|
|
|
for ( int i = lower; i < upper; i++)
|
|
kv->knots[i-lower] = knots[i];
|
|
}
|
|
|
|
|