G4AdjointInterpolator Class Reference

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

Static Public Member Functions
static G4AdjointInterpolator *	GetAdjointInterpolator ()
static G4AdjointInterpolator *	GetInstance ()

Detailed Description

Definition at line 53 of file G4AdjointInterpolator.hh.

Constructor & Destructor Documentation

G4AdjointInterpolator::~G4AdjointInterpolator

(

)

Definition at line 58 of file G4AdjointInterpolator.cc.

{
}

Member Function Documentation

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

Definition at line 86 of file G4AdjointInterpolator.cc.

Referenced by Interpolation().

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

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

Definition at line 116 of file G4AdjointInterpolator.cc.

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

{
   //most rapid nethod could be used probably
   //It is important to put std::vector<G4double>& such that the vector itself is used and not a copy
  
  
  size_t ndim = x_vec.size();
  size_t ind1 = 0;
  size_t ind2 = ndim - 1;
 /* if (ind_max >= ind_min){
    ind1=ind_min;
    ind2=ind_max;
    
  
  }
  */
  
  
  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;
}

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

Definition at line 162 of file G4AdjointInterpolator.cc.

References FindPosition().

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

{
   //most rapid nethod could be used probably
   //It is important to put std::vector<G4double>& such that the vector itself is used and not a copy
  return FindPosition(log_x, log_x_vec);
  /*
  if (log_x_vec.size()>3){ 
    size_t ind=0;
    G4double log_x1=log_x_vec[1];
    G4double d_log =log_x_vec[2]-log_x1;
    G4double dind=(log_x-log_x1)/d_log +1.;
    if (dind <1.) ind=0;
    else if (dind >= double(log_x_vec.size())-2.) ind =log_x_vec.size()-2;
    else ind =size_t(dind);
    return ind;
    
  }
  else  return FindPosition(log_x, log_x_vec);
  */
  
 
}

G4AdjointInterpolator * G4AdjointInterpolator::GetAdjointInterpolator ( )

static

Definition at line 34 of file G4AdjointInterpolator.cc.

References GetInstance().

{
  return GetInstance(); 
}

G4AdjointInterpolator * G4AdjointInterpolator::GetInstance ( void  )

static

Definition at line 41 of file G4AdjointInterpolator.cc.

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

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

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

Definition at line 187 of file G4AdjointInterpolator.cc.

References FindPosition(), and Interpolation().

Referenced by G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

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

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

Definition at line 218 of file G4AdjointInterpolator.cc.

References FindPositionForLogVector(), and LinearInterpolation().

Referenced by G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

{
  //size_t i=0;
  size_t i=FindPositionForLogVector(log_x,log_x_vec);
  /*G4cout<<"In interpolate "<<G4endl;
  G4cout<<i<<G4endl;
  G4cout<<log_x<<G4endl;
  G4cout<<log_x_vec[i]<<G4endl;
  G4cout<<log_x_vec[i+1]<<G4endl;
  G4cout<<log_y_vec[i]<<G4endl;
  G4cout<<log_y_vec[i+1]<<G4endl;*/
  
  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;
}  

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 198 of file G4AdjointInterpolator.cc.

References FindPosition(), int(), and Interpolation().

{
  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");
}                       

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

Definition at line 97 of file G4AdjointInterpolator.cc.

References ExponentialInterpolation(), LinearInterpolation(), and LogarithmicInterpolation().

Referenced by Interpolate(), and InterpolateWithIndexVector().

{
  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 {
    //G4cout<<"The interpolation method that you invoked does not exist!"<<G4endl; 
    return -1111111111.;
  }
}

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

Definition at line 64 of file G4AdjointInterpolator.cc.

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

{
  G4double res = y1+ (x-x1)*(y2-y1)/(x2-x1);
  //G4cout<<"Linear "<<res<<G4endl;
  return res;   
}

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

Definition at line 73 of file G4AdjointInterpolator.cc.

References LinearInterpolation().

Referenced by Interpolation().

{
  if (y1<=0 || y2<=0 || x1<=0) return LinearInterpolation(x,x1,x2,y1,y2);
  G4double B=std::log(y2/y1)/std::log(x2/x1);
  //G4cout<<"x1,x2,y1,y2 "<<x1<<'\t'<<x2<<'\t'<<y1<<'\t'<<y2<<'\t'<<G4endl;
  G4double A=y1/std::pow(x1,B);
  G4double res=A*std::pow(x,B);
 // G4cout<<"Log "<<res<<G4endl;
  return res;
}

---

The documentation for this class was generated from the following files:

• G4AdjointInterpolator.hh
• G4AdjointInterpolator.cc