#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 ()

	G4ChebyshevApproximation (const G4ChebyshevApproximation &)=delete

G4ChebyshevApproximation &	operator= (const G4ChebyshevApproximation &)=delete

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 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;
}

◆ 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
}

◆ 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
}

◆ ~G4ChebyshevApproximation()

G4ChebyshevApproximation::~G4ChebyshevApproximation ( )

Definition at line 180 of file G4ChebyshevApproximation.cc.

{
  delete[] 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];
}

◆ 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;
  }
}

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];
}

◆ 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
}