G4NeutronHPInterpolator Class Reference

#include <G4NeutronHPInterpolator.hh>

Public Member Functions
	G4NeutronHPInterpolator ()
	~G4NeutronHPInterpolator ()
G4double	Lin (G4double x, G4double x1, G4double x2, G4double y1, G4double y2)
G4double	Interpolate (G4InterpolationScheme aScheme, G4double x, G4double x1, G4double x2, G4double y1, G4double y2) const
G4double	GetBinIntegral (const G4InterpolationScheme &aScheme, const G4double x1, const G4double x2, const G4double y1, const G4double y2)
G4double	GetWeightedBinIntegral (const G4InterpolationScheme &aScheme, const G4double x1, const G4double x2, const G4double y1, const G4double y2)

Detailed Description

Definition at line 41 of file G4NeutronHPInterpolator.hh.

Constructor & Destructor Documentation

G4NeutronHPInterpolator::G4NeutronHPInterpolator ( )

inline

Definition at line 45 of file G4NeutronHPInterpolator.hh.

{}

G4NeutronHPInterpolator::~G4NeutronHPInterpolator ( )

inline

Definition at line 46 of file G4NeutronHPInterpolator.hh.

   {
    //  G4cout <<"deleted the interpolator"<<G4endl;
   }

Member Function Documentation

G4double G4NeutronHPInterpolator::GetBinIntegral	(	const G4InterpolationScheme &	aScheme,
		const G4double	x1,
		const G4double	x2,
		const G4double	y1,
		const G4double	y2
	)

Definition at line 33 of file G4NeutronHPInterpolator.cc.

References test::a, test::b, CHISTO, CLINLIN, CLINLOG, CLOGLIN, CLOGLOG, HISTO, LINLIN, LINLOG, LOGLIN, LOGLOG, UHISTO, ULINLIN, ULINLOG, ULOGLIN, and ULOGLOG.

Referenced by G4NeutronHPVector::GetMeanX(), G4NeutronHPVector::IntegrateAndNormalise(), and G4NeutronHPContAngularPar::Sample().

  { // inline again later on @@@@
    G4double result = 0;
    if(aScheme==HISTO||aScheme==CHISTO||aScheme==UHISTO)
    {
      result = y1*(x2-x1);
    }
    else if(aScheme==LINLIN||aScheme==CLINLIN||aScheme==ULINLIN)
    {
      result = 0.5*(y2+y1)*(x2-x1);
    }
    else if(aScheme==LINLOG||aScheme==CLINLOG||aScheme==ULINLOG)
    {
      if(x1==0) result = y1;
      else if(x2==0) result = y2;
      else
      {
        G4double b = (y2-y1)/(std::log(x2)-std::log(x1));
        G4double a = y1 - b*std::log(x1);
        result = (a-b)*(x2-x1) + b*(x2*std::log(x2)-x1*std::log(x1));
      }
    }
    else if(aScheme==LOGLIN||aScheme==CLOGLIN||aScheme==ULOGLIN)
    {
      if(y1==0||y2==0) result =0;
      else
      {
        G4double b = (std::log(y2)-std::log(y1))/(x2-x1);
        G4double a = std::log(y1) - b*x1;
        //***************************************************************
        //EMendoza:
        //result = (std::exp(a)/b)*(std::exp(b*x2)-std::exp(b*x1));
        //***************************************************************
        if(b!=0){
          result = (std::exp(a)/b)*(std::exp(b*x2)-std::exp(b*x1));
        }
        else{
          result=y2*(x2-x1);
        }
        //***************************************************************
      }
    }
    else if(aScheme==LOGLOG||aScheme==CLOGLOG||aScheme==ULOGLOG)
    {
      if(x1==0) result = y1;
      else if(x2==0) result = y2;
      else if(y1==0||y2==0) result =0;
      else
      {      
        G4double b = (std::log(y2)-std::log(y1))/(std::log(x2)-std::log(x1));
        G4double a = std::log(y1) - b*std::log(x1);;
        result = (std::exp(a)/(b+1))*(std::pow(x2,b+1)-std::pow(x1,b+1));
      }
    }
    else
    {
      throw G4HadronicException(__FILE__, __LINE__, "Unknown interpolation scheme in G4NeutronHPVector::Integrate");
    }
    return result;
  }

G4double G4NeutronHPInterpolator::GetWeightedBinIntegral	(	const G4InterpolationScheme &	aScheme,
		const G4double	x1,
		const G4double	x2,
		const G4double	y1,
		const G4double	y2
	)

Definition at line 95 of file G4NeutronHPInterpolator.cc.

References test::a, test::b, CHISTO, CLINLIN, CLINLOG, CLOGLIN, CLOGLOG, HISTO, LINLIN, LINLOG, LOGLIN, LOGLOG, UHISTO, ULINLIN, ULINLOG, ULOGLIN, and ULOGLOG.

Referenced by G4NeutronHPVector::GetMeanX(), and G4NeutronHPContAngularPar::Sample().

  { // inline again later on @@@@
    G4double result = 0;
    if(aScheme==HISTO||aScheme==CHISTO||aScheme==UHISTO)
    {
      result = 0.5*y1*(x2*x2-x1*x1);
    }
    else if(aScheme==LINLIN||aScheme==CLINLIN||aScheme==ULINLIN)
    {
      //        G4double b = (y2-y1)/(x2-x1);
      //        G4double a = y1 - b*x1;
      //        result = 0.5*a*(x2*x2-x1*x1) + (b/3.)*(x2*x2*x2-x1*x1*x1);
      //  Factor out x2-x1 to avoid divide by zero
      
      result = (y1*x2 - y2*x1)*(x2 + x1)/2. + (y2-y1)*(x2*x2 + x2*x1 + x1*x1)/3.;
    }
    else if(aScheme==LINLOG||aScheme==CLINLOG||aScheme==ULINLOG)
    {
      if(x1==0) result = y1;
      else if(x2==0) result = y2;
      else
      {
        G4double b = (y2-y1)/(std::log(x2)-std::log(x1));
        G4double a = y1 - b*std::log(x1);
        result = ( x2*x2/2. * (a-b/2.+b*std::log(x2)) )
                -( x1*x1/2. * (a-b/2.+b*std::log(x1)) );
      }
    }
    else if(aScheme==LOGLIN||aScheme==CLOGLIN||aScheme==ULOGLIN)
    {
      if(y1==0||y2==0) result = 0;
      else
      {
        G4double b = (std::log(y2)-std::log(y1))/(x2-x1);
        G4double a = std::log(y1) - b*x1;
        result = std::exp(a)/(b*b)*( std::exp(b*x2)*(b*x2-1.) - std::exp(b*x1)*(b*x1-1.) );
      }
    }
    else if(aScheme==LOGLOG||aScheme==CLOGLOG||aScheme==ULOGLOG)
    {
      if(x1==0) result = y1;
      else if(x2==0) result = y2;
      if(y1==0||y2==0) result = 0;
      else
      {
        G4double b = (std::log(y2)-std::log(y1))/(std::log(x2)-std::log(x1));
        G4double a = std::log(y1) - b*std::log(x1);;
        result = std::exp(a)/(b+2.)*( std::pow(x2, b+2.) - std::pow(x1, b+2) );
      }
    }
    else
    {
      throw G4HadronicException(__FILE__, __LINE__, "Unknown interpolation scheme in G4NeutronHPVector::Integrate");
    }
    return result;
  }

G4double G4NeutronHPInterpolator::Interpolate ( G4InterpolationScheme  aScheme, G4double  x, G4double  x1, G4double  x2, G4double  y1, G4double  y2  ) const

inline

Definition at line 85 of file G4NeutronHPInterpolator.hh.

References CSTART_, G4cout, and G4endl.

Referenced by G4NeutronHPAngularP::GetCosTh(), CCalDataSet::getCrossSection(), G4NeutronHPVector::GetXsec(), G4NeutronHPPartial::GetY(), G4NeutronHPContAngularPar::Merge(), G4NeutronHPVector::Merge(), G4NeutronHPContAngularPar::Sample(), G4NeutronHPLabAngularEnergy::Sample(), G4NeutronHPLegendreStore::Sample(), G4NeutronHPDiscreteTwoBody::Sample(), G4NeutronHPPartial::Sample(), G4NeutronHPLegendreStore::SampleDiscreteTwoBody(), G4NeutronHPLegendreStore::SampleElastic(), and G4NeutronHPLegendreStore::SampleMax().

{
  G4double result(0);
  G4int theScheme = aScheme;
  theScheme = theScheme%CSTART_;
  switch(theScheme)
  {
    case 1:
      //080809
      //result = Histogram(x, x1, x2, y1, y2);
      result = LinearLinear(x, x1, x2, y1, y2);
      break;
    case 2:
      result = LinearLinear(x, x1, x2, y1, y2);
      break;
    case 3:
      result = LinearLogarithmic(x, x1, x2, y1, y2);
      break;
    case 4:
      result = LogarithmicLinear(x, x1, x2, y1, y2);
      break;
    case 5:
      result = LogarithmicLogarithmic(x, x1, x2, y1, y2);
      break;
    case 6:
      result = Random(x, x1, x2, y1, y2);
      break;
    default:
      G4cout << "theScheme = "<<theScheme<<G4endl;
      throw G4HadronicException(__FILE__, __LINE__, "G4NeutronHPInterpolator::Carthesian Invalid InterpolationScheme");
      break;
  }
  return result;
}

G4double G4NeutronHPInterpolator::Lin ( G4double  x, G4double  x1, G4double  x2, G4double  y1, G4double  y2  )

inline

Definition at line 51 of file G4NeutronHPInterpolator.hh.

Referenced by G4NeutronHPVector::Get50percentBorder(), G4NeutronHPLabAngularEnergy::Sample(), G4NeutronHPVector::SampleLin(), and G4NeutronHPVector::ThinOut().

  {
    G4double slope=0, off=0;
    if(x2-x1==0) return (y2+y1)/2.;
    slope = (y2-y1)/(x2-x1);
    off = y2-x2*slope;
    G4double y = x*slope+off;
    return y;
  }

---

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

• G4NeutronHPInterpolator.hh
• G4NeutronHPInterpolator.cc