#include <G4AdjointInterpolator.hh>

Public Member Functions
	~G4AdjointInterpolator ()

G4double	LinearInterpolation (G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)

G4double	LogarithmicInterpolation (G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)

G4double	ExponentialInterpolation (G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)

G4double	Interpolation (G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2, G4String InterPolMethod="Log")

size_t	FindPosition (G4double &x, std::vector< G4double > &x_vec, size_t ind_min=0, size_t ind_max=0)

size_t	FindPositionForLogVector (G4double &x, std::vector< G4double > &x_vec)

G4double	Interpolate (G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec, G4String InterPolMethod="Log")

G4double	InterpolateWithIndexVector (G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec, std::vector< size_t > &index_vec, G4double x0, G4double dx)

G4double	InterpolateForLogVector (G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec)

	G4AdjointInterpolator (G4AdjointInterpolator &)=delete

G4AdjointInterpolator &	operator= (const G4AdjointInterpolator &right)=delete

Static Public Member Functions
static G4AdjointInterpolator *	GetAdjointInterpolator ()

static G4AdjointInterpolator *	GetInstance ()

Detailed Description

Definition at line 41 of file G4AdjointInterpolator.hh.

Constructor & Destructor Documentation

◆ ~G4AdjointInterpolator()

G4AdjointInterpolator::~G4AdjointInterpolator ( )

Definition at line 51 of file G4AdjointInterpolator.cc.

51{}

◆ G4AdjointInterpolator()

G4AdjointInterpolator::G4AdjointInterpolator ( G4AdjointInterpolator & )

delete

Member Function Documentation

◆ ExponentialInterpolation()

G4double G4AdjointInterpolator::ExponentialInterpolation	(	G4double &	x,
		G4double &	x1,
		G4double &	x2,
		G4double &	y1,
		G4double &	y2 )

Definition at line 75 of file G4AdjointInterpolator.cc.

{
  G4double B   = (std::log(y2) - std::log(y1)) / (x2 - x1);
  G4double A   = y1 * std::exp(-B * x1);
  G4double res = A * std::exp(B * x);
  return res;
}

Referenced by Interpolation().

◆ FindPosition()

size_t G4AdjointInterpolator::FindPosition	(	G4double &	x,
		std::vector< G4double > &	x_vec,
		size_t	ind_min = 0,
		size_t	ind_max = 0 )

Definition at line 114 of file G4AdjointInterpolator.cc.

{
  // most rapid method could be used probably
 
  size_t ndim = x_vec.size();
  size_t ind1 = 0;
  size_t ind2 = ndim - 1;
 
  if(ndim > 1)
  {
    if(x_vec[0] < x_vec[1])
    {  // increasing
      do
      {
        size_t midBin = (ind1 + ind2) / 2;
        if(x < x_vec[midBin])
          ind2 = midBin;
        else
          ind1 = midBin;
      } while(ind2 - ind1 > 1);
    }
    else
    {
      do
      {
        size_t midBin = (ind1 + ind2) / 2;
        if(x < x_vec[midBin])
          ind1 = midBin;
        else
          ind2 = midBin;
      } while(ind2 - ind1 > 1);
    }
  }
 
  return ind1;
}

Referenced by G4AdjointCSMatrix::AddData(), FindPositionForLogVector(), Interpolate(), and InterpolateWithIndexVector().

◆ FindPositionForLogVector()

size_t G4AdjointInterpolator::FindPositionForLogVector	(	G4double &	x,
		std::vector< G4double > &	x_vec )

Definition at line 155 of file G4AdjointInterpolator.cc.

{
  // most rapid method could be used probably
  return FindPosition(log_x, log_x_vec);
}

Referenced by InterpolateForLogVector(), and G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ GetAdjointInterpolator()

G4AdjointInterpolator * G4AdjointInterpolator::GetAdjointInterpolator ( )

static

Definition at line 32 of file G4AdjointInterpolator.cc.

{
  return GetInstance();
}

◆ GetInstance()

G4AdjointInterpolator * G4AdjointInterpolator::GetInstance ( )

static

Definition at line 38 of file G4AdjointInterpolator.cc.

{
  if(!fInstance)
  {
    fInstance = new G4AdjointInterpolator;
  }
  return fInstance;
}

Referenced by G4AdjointCSMatrix::AddData(), GetAdjointInterpolator(), and G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ Interpolate()

G4double G4AdjointInterpolator::Interpolate	(	G4double &	x,
		std::vector< G4double > &	x_vec,
		std::vector< G4double > &	y_vec,
		G4String	InterPolMethod = "Log" )

Definition at line 163 of file G4AdjointInterpolator.cc.

{
  size_t i = FindPosition(x, x_vec);
  return Interpolation(x, x_vec[i], x_vec[i + 1], y_vec[i], y_vec[i + 1],
                       InterPolMethod);
}

Referenced by G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ InterpolateForLogVector()

G4double G4AdjointInterpolator::InterpolateForLogVector	(	G4double &	x,
		std::vector< G4double > &	x_vec,
		std::vector< G4double > &	y_vec )

Definition at line 198 of file G4AdjointInterpolator.cc.

{
  size_t i = FindPositionForLogVector(log_x, log_x_vec);
 
  G4double log_y = LinearInterpolation(log_x, log_x_vec[i], log_x_vec[i + 1],
                                       log_y_vec[i], log_y_vec[i + 1]);
  return log_y;
}

Referenced by G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ InterpolateWithIndexVector()

G4double G4AdjointInterpolator::InterpolateWithIndexVector	(	G4double &	x,
		std::vector< G4double > &	x_vec,
		std::vector< G4double > &	y_vec,
		std::vector< size_t > &	index_vec,
		G4double	x0,
		G4double	dx )

Definition at line 174 of file G4AdjointInterpolator.cc.

{
  size_t ind = 0;
  if(x > x0)
    ind = int((x - x0) / dx);
  if(ind >= index_vec.size() - 1)
    ind = index_vec.size() - 2;
  size_t ind1 = index_vec[ind];
  size_t ind2 = index_vec[ind + 1];
  if(ind1 > ind2)
  {
    size_t ind11 = ind1;
    ind1         = ind2;
    ind2         = ind11;
  }
  ind = FindPosition(x, x_vec, ind1, ind2);
  return Interpolation(x, x_vec[ind], x_vec[ind + 1], y_vec[ind],
                       y_vec[ind + 1], "Lin");
}

◆ Interpolation()

G4double G4AdjointInterpolator::Interpolation	(	G4double &	x,
		G4double &	x1,
		G4double &	x2,
		G4double &	y1,
		G4double &	y2,
		G4String	InterPolMethod = "Log" )

Definition at line 85 of file G4AdjointInterpolator.cc.

{
  if(InterPolMethod == "Log")
  {
    return LogarithmicInterpolation(x, x1, x2, y1, y2);
  }
  else if(InterPolMethod == "Lin")
  {
    return LinearInterpolation(x, x1, x2, y1, y2);
  }
  else if(InterPolMethod == "Exp")
  {
    return ExponentialInterpolation(x, x1, x2, y1, y2);
  }
  else
  {
    G4ExceptionDescription ed;
    ed << "The interpolation method that you invoked does not exist!\n";
    G4Exception("G4AdjointInterpolator::Interpolation", "adoint001",
                FatalException, ed);
    return 0.;
  }
}

Referenced by Interpolate(), and InterpolateWithIndexVector().

◆ LinearInterpolation()

G4double G4AdjointInterpolator::LinearInterpolation	(	G4double &	x,
		G4double &	x1,
		G4double &	x2,
		G4double &	y1,
		G4double &	y2 )

Definition at line 54 of file G4AdjointInterpolator.cc.

{
  G4double res = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
  return res;
}

Referenced by InterpolateForLogVector(), Interpolation(), LogarithmicInterpolation(), and G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ LogarithmicInterpolation()

G4double G4AdjointInterpolator::LogarithmicInterpolation	(	G4double &	x,
		G4double &	x1,
		G4double &	x2,
		G4double &	y1,
		G4double &	y2 )

Definition at line 63 of file G4AdjointInterpolator.cc.

{
  if(y1 <= 0. || y2 <= 0. || x1 <= 0.)
    return LinearInterpolation(x, x1, x2, y1, y2);
  G4double B   = std::log(y2 / y1) / std::log(x2 / x1);
  G4double A   = y1 / std::pow(x1, B);
  G4double res = A * std::pow(x, B);
  return res;
}