#include <G4ChebyshevApproximation.hh>

Public Member Functions
G4double	ChebyshevEvaluation (G4double x) const

void	DerivativeChebyshevCof (G4double derCof[]) const

	G4ChebyshevApproximation (const G4ChebyshevApproximation &)=delete

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

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

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

G4double	GetChebyshevCof (G4int number) const

void	IntegralChebyshevCof (G4double integralCof[]) const

G4ChebyshevApproximation &	operator= (const G4ChebyshevApproximation &)=delete

	~G4ChebyshevApproximation ()

Private Attributes
G4double *	fChebyshevCof

G4double	fDiff

function	fFunction

G4double	fMean

G4int	fNumber

Detailed Description

Definition at line 47 of file G4ChebyshevApproximation.hh.

Constructor & Destructor Documentation

◆ G4ChebyshevApproximation() [1/4]

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

Definition at line 40 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;
}

References fChebyshevCof, fDiff, fFunction, fMean, fNumber, and pi.

◆ G4ChebyshevApproximation() [2/4]

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

Definition at line 80 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
}

References DerivativeChebyshevCof(), FatalException, fChebyshevCof, fDiff, fFunction, fMean, fNumber, G4Exception(), and pi.

◆ G4ChebyshevApproximation() [3/4]

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

Definition at line 135 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
}

References fChebyshevCof, fDiff, fFunction, fMean, fNumber, IntegralChebyshevCof(), and pi.

◆ ~G4ChebyshevApproximation()

G4ChebyshevApproximation::~G4ChebyshevApproximation ( )

Definition at line 180 of file G4ChebyshevApproximation.cc.

{
  delete[] fChebyshevCof;
}

References fChebyshevCof.

◆ G4ChebyshevApproximation() [4/4]

G4ChebyshevApproximation::G4ChebyshevApproximation ( const G4ChebyshevApproximation & )

delete

Member Function Documentation

◆ ChebyshevEvaluation()

G4double G4ChebyshevApproximation::ChebyshevEvaluation ( G4double x ) const

Definition at line 205 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];
}

References FatalException, fChebyshevCof, fDiff, fMean, fNumber, and G4Exception().

◆ DerivativeChebyshevCof()

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

Definition at line 231 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;
  }
}

References fChebyshevCof, fDiff, and fNumber.

Referenced by G4ChebyshevApproximation().

◆ GetChebyshevCof()

G4double G4ChebyshevApproximation::GetChebyshevCof ( G4int number ) const

Definition at line 190 of file G4ChebyshevApproximation.cc.

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

References FatalException, fChebyshevCof, fNumber, and G4Exception().

◆ IntegralChebyshevCof()

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

Definition at line 255 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
}