#include <G4ChebyshevApproximation.hh>

Public Member Functions
	G4ChebyshevApproximation (function pFunction, G4int n, G4double a, G4double b)

	G4ChebyshevApproximation (function pFunction, G4int n, G4int m, G4double a, G4double b)

	G4ChebyshevApproximation (function pFunction, G4double a, G4double b, G4int n)

	~G4ChebyshevApproximation ()

G4double	GetChebyshevCof (G4int number) const

G4double	ChebyshevEvaluation (G4double x) const

void	DerivativeChebyshevCof (G4double derCof[]) const

void	IntegralChebyshevCof (G4double integralCof[]) const

Detailed Description

Definition at line 128 of file G4ChebyshevApproximation.hh.

Constructor & Destructor Documentation

◆ G4ChebyshevApproximation() [1/3]

G4ChebyshevApproximation::G4ChebyshevApproximation	(	function	pFunction,
		G4int	n,
		G4double	a,
		G4double	b
	)

Definition at line 39 of file G4ChebyshevApproximation.cc.

   : fFunction(pFunction), fNumber(n),
     fChebyshevCof(new G4double[fNumber]),
     fMean(0.5*(b+a)), fDiff(0.5*(b-a))
{
   G4int i=0, j=0 ;
   G4double  rootSum=0.0, cofj=0.0 ;
   G4double* tempFunction = new G4double[fNumber] ;
   G4double weight = 2.0/fNumber ;
   G4double cof = 0.5*weight*pi ;    // pi/n
   
   for (i=0;i<fNumber;i++)
   {
      rootSum = std::cos(cof*(i+0.5)) ;
      tempFunction[i]= fFunction(rootSum*fDiff+fMean) ;
   }
   for (j=0;j<fNumber;j++) 
   {
      cofj = cof*j ;
      rootSum = 0.0 ;
      
      for (i=0;i<fNumber;i++)
      {
         rootSum += tempFunction[i]*std::cos(cofj*(i+0.5)) ;
      }
      fChebyshevCof[j] = weight*rootSum ;
   }
   delete[] tempFunction ;
}

◆ G4ChebyshevApproximation() [2/3]

G4ChebyshevApproximation::G4ChebyshevApproximation	(	function	pFunction,
		G4int	n,
		G4int	m,
		G4double	a,
		G4double	b
	)

Definition at line 79 of file G4ChebyshevApproximation.cc.

   : fFunction(pFunction), fNumber(nx),
     fChebyshevCof(new G4double[fNumber]),
     fMean(0.5*(b+a)), fDiff(0.5*(b-a))
{
   if(nx <= mx)
   {
      G4Exception("G4ChebyshevApproximation::G4ChebyshevApproximation()",
                  "InvalidCall", FatalException, "Invalid arguments !") ;
   }
   G4int i=0, j=0 ;
   G4double  rootSum = 0.0, cofj=0.0;   
   G4double* tempFunction = new G4double[fNumber] ;
   G4double weight = 2.0/fNumber ;
   G4double cof = 0.5*weight*pi ;    // pi/nx
   
   for (i=0;i<fNumber;i++)
   {
      rootSum = std::cos(cof*(i+0.5)) ;
      tempFunction[i] = fFunction(rootSum*fDiff+fMean) ;
   }
   for (j=0;j<fNumber;j++) 
   {
      cofj = cof*j ;
      rootSum = 0.0 ;
      
      for (i=0;i<fNumber;i++)
      {
         rootSum += tempFunction[i]*std::cos(cofj*(i+0.5)) ;
      }
      fChebyshevCof[j] = weight*rootSum ; // corresponds to pFunction
   }
   // Chebyshev coefficients for (mx)-derivative of pFunction
   
   for(i=1;i<=mx;i++)
   {
      DerivativeChebyshevCof(tempFunction) ;
      fNumber-- ;
      for(j=0;j<fNumber;j++)
      {
        fChebyshevCof[j] = tempFunction[j] ; // corresponds to (i)-derivative
      }
   }
   delete[] tempFunction ;   // delete of dynamically allocated tempFunction
}

◆ G4ChebyshevApproximation() [3/3]

G4ChebyshevApproximation::G4ChebyshevApproximation	(	function	pFunction,
		G4double	a,
		G4double	b,
		G4int	n
	)

Definition at line 133 of file G4ChebyshevApproximation.cc.

   : fFunction(pFunction), fNumber(n),
     fChebyshevCof(new G4double[fNumber]),
     fMean(0.5*(b+a)), fDiff(0.5*(b-a))
{
   G4int i=0, j=0;
   G4double  rootSum=0.0, cofj=0.0;
   G4double* tempFunction = new G4double[fNumber] ;
   G4double weight = 2.0/fNumber;
   G4double cof = 0.5*weight*pi ;    // pi/n
   
   for (i=0;i<fNumber;i++)
   {
      rootSum = std::cos(cof*(i+0.5)) ;
      tempFunction[i]= fFunction(rootSum*fDiff+fMean) ;
   }
   for (j=0;j<fNumber;j++) 
   {
      cofj = cof*j ;
      rootSum = 0.0 ;
      
      for (i=0;i<fNumber;i++)
      {
         rootSum += tempFunction[i]*std::cos(cofj*(i+0.5)) ;
      }
      fChebyshevCof[j] = weight*rootSum ; // corresponds to pFunction
   }
   // Chebyshev coefficients for integral of pFunction
   
   IntegralChebyshevCof(tempFunction) ;
   for(j=0;j<fNumber;j++)
   {
      fChebyshevCof[j] = tempFunction[j] ; // corresponds to integral
   }
   delete[] tempFunction ;   // delete of dynamically allocated tempFunction
}

◆ ~G4ChebyshevApproximation()

G4ChebyshevApproximation::~G4ChebyshevApproximation ( )

Definition at line 179 of file G4ChebyshevApproximation.cc.

{
   delete[] fChebyshevCof ;
}

Member Function Documentation

◆ ChebyshevEvaluation()

G4double G4ChebyshevApproximation::ChebyshevEvaluation ( G4double x ) const

Definition at line 207 of file G4ChebyshevApproximation.cc.

{
   G4double evaluate = 0.0, evaluate2 = 0.0, temp = 0.0,
            xReduced = 0.0, xReduced2 = 0.0 ;
 
   if ((x-fMean+fDiff)*(x-fMean-fDiff) > 0.0) 
   {
      G4Exception("G4ChebyshevApproximation::ChebyshevEvaluation()",
                  "InvalidCall", FatalException, "Invalid argument !") ;
   }
   xReduced = (x-fMean)/fDiff ;
   xReduced2 = 2.0*xReduced ;
   for (G4int i=fNumber-1;i>=1;i--) 
   {
     temp = evaluate ;
     evaluate  = xReduced2*evaluate - evaluate2 + fChebyshevCof[i] ;
     evaluate2 = temp ;
   }
   return xReduced*evaluate - evaluate2 + 0.5*fChebyshevCof[0] ;
}

◆ DerivativeChebyshevCof()

void G4ChebyshevApproximation::DerivativeChebyshevCof ( G4double derCof[] ) const

Definition at line 234 of file G4ChebyshevApproximation.cc.

{
   G4double cof = 1.0/fDiff ;
   derCof[fNumber-1] = 0.0 ;
   derCof[fNumber-2] = 2*(fNumber-1)*fChebyshevCof[fNumber-1] ;
   for(G4int i=fNumber-3;i>=0;i--)
   {
      derCof[i] = derCof[i+2] + 2*(i+1)*fChebyshevCof[i+1] ;  
   }
   for(G4int j=0;j<fNumber;j++)
   {
      derCof[j] *= cof ;
   }
}

Referenced by G4ChebyshevApproximation().

◆ GetChebyshevCof()

G4double G4ChebyshevApproximation::GetChebyshevCof ( G4int number ) const

Definition at line 191 of file G4ChebyshevApproximation.cc.

{
   if(number < 0 && number >= fNumber)
   {
      G4Exception("G4ChebyshevApproximation::GetChebyshevCof()",
                  "InvalidCall", FatalException, "Argument out of range !") ;
   }
   return fChebyshevCof[number] ;
}

◆ IntegralChebyshevCof()

void G4ChebyshevApproximation::IntegralChebyshevCof ( G4double integralCof[] ) const

Definition at line 259 of file G4ChebyshevApproximation.cc.

{
   G4double cof = 0.5*fDiff, sum = 0.0, factor = 1.0 ;
   for(G4int i=1;i<fNumber-1;i++)
   {
      integralCof[i] = cof*(fChebyshevCof[i-1] - fChebyshevCof[i+1])/i ;
      sum += factor*integralCof[i] ;
      factor = -factor ;
   }
   integralCof[fNumber-1] = cof*fChebyshevCof[fNumber-2]/(fNumber-1) ;
   sum += factor*integralCof[fNumber-1] ;
   integralCof[0] = 2.0*sum ;                // set the constant of integration
}                                         