G4Physics2DVector Class Reference

#include <G4Physics2DVector.hh>

Collaboration diagram for G4Physics2DVector:

Public Member Functions
	G4Physics2DVector ()
	G4Physics2DVector (size_t nx, size_t ny)
	G4Physics2DVector (const G4Physics2DVector &)
G4Physics2DVector &	operator= (const G4Physics2DVector &)
	~G4Physics2DVector ()
G4double	Value (G4double x, G4double y, size_t &lastidx, size_t &lastidy) const
G4double	Value (G4double x, G4double y) const
void	PutX (size_t idx, G4double value)
void	PutY (size_t idy, G4double value)
void	PutValue (size_t idx, size_t idy, G4double value)
void	PutVectors (const std::vector< G4double > &vecX, const std::vector< G4double > &vecY)
void	ScaleVector (G4double factor)
G4double	FindLinearX (G4double rand, G4double y, size_t &lastidy) const
G4double	FindLinearX (G4double rand, G4double y) const
G4double	GetX (size_t index) const
G4double	GetY (size_t index) const
G4double	GetValue (size_t idx, size_t idy) const
size_t	FindBinLocationX (G4double x, size_t lastidx) const
size_t	FindBinLocationY (G4double y, size_t lastidy) const
size_t	GetLengthX () const
size_t	GetLengthY () const
G4PhysicsVectorType	GetType () const
void	SetBicubicInterpolation (G4bool)
void	Store (std::ofstream &fOut)
G4bool	Retrieve (std::ifstream &fIn)
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const

Protected Member Functions
void	PrepareVectors ()
void	ClearVectors ()
void	CopyData (const G4Physics2DVector &vec)
G4double	BicubicInterpolation (G4double x, G4double y, size_t idx, size_t idy) const
size_t	FindBinLocation (G4double z, const G4PV2DDataVector &) const
size_t	FindBin (G4double z, const G4PV2DDataVector &, size_t idz, size_t idzmax) const

Private Member Functions
G4double	InterpolateLinearX (G4PV2DDataVector &v, G4double rand) const
G4double	DerivativeX (size_t idx, size_t idy, G4double fac) const
G4double	DerivativeY (size_t idx, size_t idy, G4double fac) const
G4double	DerivativeXY (size_t idx, size_t idy, G4double fac) const
G4int	operator== (const G4Physics2DVector &right) const
G4int	operator!= (const G4Physics2DVector &right) const

Private Attributes
G4PhysicsVectorType	type
size_t	numberOfXNodes
size_t	numberOfYNodes
G4PV2DDataVector	xVector
G4PV2DDataVector	yVector
std::vector< G4PV2DDataVector * >	value
G4int	verboseLevel
G4bool	useBicubic

Detailed Description

Definition at line 62 of file G4Physics2DVector.hh.

Constructor & Destructor Documentation

G4Physics2DVector() [1/3]

G4Physics2DVector::G4Physics2DVector

(

)

Definition at line 43 of file G4Physics2DVector.cc.

 : type(T_G4PhysicsFreeVector),
   numberOfXNodes(0), numberOfYNodes(0),
   verboseLevel(0), useBicubic(false)
{}

G4Physics2DVector() [2/3]

G4Physics2DVector::G4Physics2DVector ( size_t  nx, size_t  ny  )

explicit

Definition at line 51 of file G4Physics2DVector.cc.

 : type(T_G4PhysicsFreeVector),
   numberOfXNodes(nx), numberOfYNodes(ny),
   verboseLevel(0), useBicubic(false)
{
  PrepareVectors();
}

Here is the call graph for this function:

G4Physics2DVector() [3/3]

G4Physics2DVector::G4Physics2DVector

(

const G4Physics2DVector &

right

)

Definition at line 68 of file G4Physics2DVector.cc.

{
  type         = right.type;

  numberOfXNodes = right.numberOfXNodes;
  numberOfYNodes = right.numberOfYNodes;

  verboseLevel = right.verboseLevel;
  useBicubic   = right.useBicubic;

  xVector      = right.xVector;
  yVector      = right.yVector;

  PrepareVectors();
  CopyData(right);
}

Here is the call graph for this function:

~G4Physics2DVector()

G4Physics2DVector::~G4Physics2DVector

(

)

Definition at line 61 of file G4Physics2DVector.cc.

{
  ClearVectors();
}

Here is the call graph for this function:

Member Function Documentation

BicubicInterpolation()

G4double G4Physics2DVector::BicubicInterpolation ( G4double  x, G4double  y, size_t  idx, size_t  idy  ) const

protected

Definition at line 189 of file G4Physics2DVector.cc.

{
    // Bicubic interpolation according to 
    // 1. H.M. Antia, "Numerical Methods for Scientists and Engineers",
    //    MGH, 1991. 
    // 2. W.H. Press et al., "Numerical recipes. The Art of Scientific 
    //    Computing", Cambridge University Press, 2007. 
    G4double x1 = xVector[idx];
    G4double x2 = xVector[idx+1];
    G4double y1 = yVector[idy];
    G4double y2 = yVector[idy+1];
    G4double f1 = GetValue(idx,   idy);
    G4double f2 = GetValue(idx+1, idy);
    G4double f3 = GetValue(idx+1, idy+1);
    G4double f4 = GetValue(idx,   idy+1);

    G4double dx = x2 - x1;
    G4double dy = y2 - y1;

    G4double h1 = (x - x1)/dx;
    G4double h2 = (y - y1)/dy;   

    G4double h12 = h1*h1;
    G4double h13 = h12*h1;
    G4double h22 = h2*h2;
    G4double h23 = h22*h2;

    // Three derivatives at each of four points (1-4) defining the 
    // subregion are computed by numerical centered differencing from 
    // the functional values already tabulated on the grid. 

    G4double f1x = DerivativeX(idx, idy, dx);
    G4double f2x = DerivativeX(idx+1, idy, dx);
    G4double f3x = DerivativeX(idx+1, idy+1, dx);
    G4double f4x = DerivativeX(idx, idy+1, dx);

    G4double f1y = DerivativeY(idx, idy, dy);
    G4double f2y = DerivativeY(idx+1, idy, dy);
    G4double f3y = DerivativeY(idx+1, idy+1, dy);
    G4double f4y = DerivativeY(idx, idy+1, dy);

    G4double dxy = dx*dy;
    G4double f1xy = DerivativeXY(idx, idy, dxy);
    G4double f2xy = DerivativeXY(idx+1, idy, dxy);
    G4double f3xy = DerivativeXY(idx+1, idy+1, dxy);
    G4double f4xy = DerivativeXY(idx, idy+1, dxy);

    return 
      f1 + f1y*h2 + (3*(f4-f1) - 2*f1y - f4y)*h22 + (2*(f1 - f4) + f1y + f4y)*h23
      + f1x*h1 + f1xy*h1*h2 +(3*(f4x - f1x) - 2*f1xy - f4xy)*h1*h22
      + (2*(f1x - f4x) + f1xy + f4xy)*h1*h23
      + (3*(f2 - f1) - 2*f1x - f2x)*h12 + (3*f2y - 3*f1y - 2*f1xy - f2xy)*h12*h2
      + (9*(f1 - f2 + f3 - f4) + 6*f1x + 3*f2x - 3*f3x - 6*f4x + 6*f1y - 6*f2y
     - 3*f3y + 3*f4y + 4*f1xy + 2*f2xy + f3xy + 2*f4xy)*h12*h22
      + (6*(-f1 + f2 - f3 + f4) - 4*f1x - 2*f2x + 2*f3x + 4*f4x - 3*f1y
     + 3*f2y + 3*f3y - 3*f4y - 2*f1xy - f2xy - f3xy - 2*f4xy)*h12*h23
      + (2*(f1 - f2) + f1x + f2x)*h13 + (2*(f1y - f2y) + f1xy + f2xy)*h13*h2
      + (6*(-f1 + f2 -f3 + f4) + 3*(-f1x - f2x + f3x + f4x) - 4*f1y
     + 4*f2y + 2*f3y - 2*f4y - 2*f1xy - 2*f2xy - f3xy - f4xy)*h13*h22
      + (4*(f1 - f2 + f3 - f4) + 2*(f1x + f2x - f3x - f4x) 
     + 2*(f1y - f2y - f3y + f4y) + f1xy + f2xy + f3xy + f4xy)*h13*h23;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ClearVectors()

void G4Physics2DVector::ClearVectors ( )

protected

Definition at line 122 of file G4Physics2DVector.cc.

{
  for(size_t j=0; j<numberOfYNodes; ++j) {
    delete value[j];
  }
}

Here is the caller graph for this function:

CopyData()

void G4Physics2DVector::CopyData ( const G4Physics2DVector &  vec )

protected

Definition at line 131 of file G4Physics2DVector.cc.

{
  for(size_t i=0; i<numberOfXNodes; ++i) {
    xVector[i] = right.xVector[i];
  }
  for(size_t j=0; j<numberOfYNodes; ++j) {
    yVector[j] = right.yVector[j];
    G4PV2DDataVector* v0 = right.value[j];
    for(size_t i=0; i<numberOfXNodes; ++i) { 
      PutValue(i,j,(*v0)[i]); 
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

DerivativeX()

G4double G4Physics2DVector::DerivativeX ( size_t  idx, size_t  idy, G4double  fac  ) const

inlineprivate

Here is the caller graph for this function:

DerivativeXY()

G4double G4Physics2DVector::DerivativeXY ( size_t  idx, size_t  idy, G4double  fac  ) const

inlineprivate

Here is the caller graph for this function:

DerivativeY()

G4double G4Physics2DVector::DerivativeY ( size_t  idx, size_t  idy, G4double  fac  ) const

inlineprivate

Here is the caller graph for this function:

FindBin()

size_t G4Physics2DVector::FindBin ( G4double  z, const G4PV2DDataVector &  , size_t  idz, size_t  idzmax  ) const

inlineprotected

FindBinLocation()

size_t G4Physics2DVector::FindBinLocation ( G4double  z, const G4PV2DDataVector &  v  ) const

protected

Definition at line 361 of file G4Physics2DVector.cc.

{
  size_t bin;
  size_t binmax = v.size() - 2; 

  if(z <= v[0])           { bin = 0; }
  else if(z >= v[binmax]) { bin = binmax; }
  else {
    bin = std::lower_bound(v.begin(), v.end(), z) - v.begin() - 1;
  }
  return bin;
}

FindBinLocationX()

size_t G4Physics2DVector::FindBinLocationX ( G4double  x, size_t  lastidx  ) const

inline

Here is the caller graph for this function:

FindBinLocationY()

size_t G4Physics2DVector::FindBinLocationY ( G4double  y, size_t  lastidy  ) const

inline

Here is the caller graph for this function:

FindLinearX() [1/2]

G4double G4Physics2DVector::FindLinearX	(	G4double	rand,
		G4double	y,
		size_t &	lastidy
	)		const

Definition at line 377 of file G4Physics2DVector.cc.

{
  G4double y = yy;

  // no interpolation outside the table
  if(y < yVector[0]) { 
    y = yVector[0]; 
  } else if(y > yVector[numberOfYNodes - 1]) { 
    y = yVector[numberOfYNodes - 1]; 
  }

  // find bins
  idy = FindBinLocationY(y, idy);

  G4double x1 = InterpolateLinearX(*(value[idy]), rand);
  G4double x2 = InterpolateLinearX(*(value[idy+1]), rand);
  G4double res = x1;
  G4double del = yVector[idy+1] - yVector[idy];
  if(del != 0.0) {
    res += (x2 - x1)*(y - yVector[idy])/del;
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindLinearX() [2/2]

G4double G4Physics2DVector::FindLinearX ( G4double  rand, G4double  y  ) const

inline

GetLengthX()

size_t G4Physics2DVector::GetLengthX ( ) const

inline

Here is the caller graph for this function:

GetLengthY()

size_t G4Physics2DVector::GetLengthY ( ) const

inline

Here is the caller graph for this function:

GetType()

G4PhysicsVectorType G4Physics2DVector::GetType ( ) const

inline

GetValue()

G4double G4Physics2DVector::GetValue ( size_t  idx, size_t  idy  ) const

inline

Here is the caller graph for this function:

GetVerboseLevel()

G4int G4Physics2DVector::GetVerboseLevel ( ) const

inline

GetX()

G4double G4Physics2DVector::GetX ( size_t  index ) const

inline

Here is the caller graph for this function:

GetY()

G4double G4Physics2DVector::GetY ( size_t  index ) const

inline

Here is the caller graph for this function:

InterpolateLinearX()

G4double G4Physics2DVector::InterpolateLinearX ( G4PV2DDataVector &  v, G4double  rand  ) const

private

Definition at line 404 of file G4Physics2DVector.cc.

{
  size_t nn = v.size();
  if(1 >= nn) { return 0.0; }
  size_t n1 = 0;
  size_t n2 = nn/2;
  size_t n3 = nn - 1;
  G4double y = rand*v[n3];
  while (n1 + 1 != n3)
    {
      if (y > v[n2])
    { n1 = n2; }
      else
    { n3 = n2; }
      n2 = (n3 + n1 + 1)/2;
    }
  G4double res = xVector[n1];
  G4double del = v[n3] - v[n1];
  if(del > 0.0) {
    res += (y - v[n1])*(xVector[n3] - res)/del;
  }
  return res;
}

Here is the caller graph for this function:

operator!=()

G4int G4Physics2DVector::operator!= ( const G4Physics2DVector &  right ) const

private

operator=()

G4Physics2DVector & G4Physics2DVector::operator=

(

const G4Physics2DVector &

right

)

Definition at line 87 of file G4Physics2DVector.cc.

{
  if (&right==this)  { return *this; }
  ClearVectors();

  type         = right.type;

  numberOfXNodes = right.numberOfXNodes;
  numberOfYNodes = right.numberOfYNodes;

  verboseLevel = right.verboseLevel;
  useBicubic   = right.useBicubic;

  PrepareVectors();
  CopyData(right);

  return *this;
}

Here is the call graph for this function:

operator==()

G4int G4Physics2DVector::operator== ( const G4Physics2DVector &  right ) const

private

PrepareVectors()

void G4Physics2DVector::PrepareVectors ( )

protected

Definition at line 108 of file G4Physics2DVector.cc.

{
  xVector.resize(numberOfXNodes,0.);
  yVector.resize(numberOfYNodes,0.);
  value.resize(numberOfYNodes,0);
  for(size_t j=0; j<numberOfYNodes; ++j) {
    G4PV2DDataVector* v = new G4PV2DDataVector();
    v->resize(numberOfXNodes,0.);
    value[j] = v;
  }
}

Here is the caller graph for this function:

PutValue()

void G4Physics2DVector::PutValue ( size_t  idx, size_t  idy, G4double  value  )

inline

Here is the caller graph for this function:

PutVectors()

void G4Physics2DVector::PutVectors	(	const std::vector< G4double > &	vecX,
		const std::vector< G4double > &	vecY
	)

Definition at line 256 of file G4Physics2DVector.cc.

{
  ClearVectors();
  numberOfXNodes = vecX.size();
  numberOfYNodes = vecY.size();
  PrepareVectors();
  for(size_t i = 0; i<numberOfXNodes; ++i) {
    xVector[i] = vecX[i];
  }
  for(size_t j = 0; j<numberOfYNodes; ++j) {
    yVector[j] = vecY[j];
  }
}

Here is the call graph for this function:

PutX()

void G4Physics2DVector::PutX ( size_t  idx, G4double  value  )

inline

Here is the caller graph for this function:

PutY()

void G4Physics2DVector::PutY ( size_t  idy, G4double  value  )

inline

Here is the caller graph for this function:

Retrieve()

G4bool G4Physics2DVector::Retrieve

(

std::ifstream &

fIn

)

Definition at line 302 of file G4Physics2DVector.cc.

{
  // initialisation
  ClearVectors();

  // binning
  G4int k;
  in >> k >> numberOfXNodes >> numberOfYNodes;
  if (in.fail() || 0 >= numberOfXNodes || 0 >= numberOfYNodes || 
      numberOfXNodes >= INT_MAX || numberOfYNodes >= INT_MAX) { 
    if( 0 >= numberOfXNodes || numberOfXNodes >= INT_MAX) {
      numberOfXNodes = 0;
    }
    if( 0 >= numberOfYNodes || numberOfYNodes >= INT_MAX) {
      numberOfYNodes = 0;
    }
    return false; 
  }
  PrepareVectors();
  type = G4PhysicsVectorType(k); 

  // contents
  G4double val;
  for(size_t i = 0; i<numberOfXNodes; ++i) {
    in >> xVector[i];
    if (in.fail())  { return false; }
  }
  for(size_t j = 0; j<numberOfYNodes; ++j) {
    in >> yVector[j];
    if (in.fail())  { return false; }
  }
  for(size_t j = 0; j<numberOfYNodes; ++j) {
    for(size_t i = 0; i<numberOfXNodes; ++i) {
      in >> val;
      if (in.fail())  { return false; }
      PutValue(i, j, val);
    }
  }
  in.close();
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScaleVector()

void G4Physics2DVector::ScaleVector

(

G4double

factor

)

Definition at line 347 of file G4Physics2DVector.cc.

{
  G4double val;
  for(size_t j = 0; j<numberOfYNodes; ++j) {
    for(size_t i = 0; i<numberOfXNodes; ++i) {
      val = GetValue(i, j)*factor;
      PutValue(i, j, val);
    }
  }
}

Here is the call graph for this function:

SetBicubicInterpolation()

void G4Physics2DVector::SetBicubicInterpolation ( G4bool  )

inline

Here is the caller graph for this function:

SetVerboseLevel()

void G4Physics2DVector::SetVerboseLevel ( G4int  value )

inline

Store()

void G4Physics2DVector::Store

(

std::ofstream &

fOut

)

Definition at line 273 of file G4Physics2DVector.cc.

{
  // binning
  G4int prec = out.precision();
  out << G4int(type) << " " << numberOfXNodes << " " << numberOfYNodes 
      << G4endl; 
  out << std::setprecision(5);

  // contents
  for(size_t i = 0; i<numberOfXNodes-1; ++i) {
    out << xVector[i] << "  ";
  }
  out << xVector[numberOfXNodes-1] << G4endl;
  for(size_t j = 0; j<numberOfYNodes-1; ++j) {
    out << yVector[j] << "  ";
  }
  out << yVector[numberOfYNodes-1] << G4endl;
  for(size_t j = 0; j<numberOfYNodes; ++j) {
    for(size_t i = 0; i<numberOfXNodes-1; ++i) {
      out << GetValue(i, j) << "  ";
    }
    out << GetValue(numberOfXNodes-1,j) << G4endl;
  }
  out.precision(prec);
  out.close();
}

Here is the call graph for this function:

Value() [1/2]

G4double G4Physics2DVector::Value	(	G4double	x,
		G4double	y,
		size_t &	lastidx,
		size_t &	lastidy
	)		const

Definition at line 147 of file G4Physics2DVector.cc.

{
  G4double x = xx;
  G4double y = yy;

  // no interpolation outside the table
  if(x < xVector[0]) { 
    x = xVector[0]; 
  } else if(x > xVector[numberOfXNodes - 1]) { 
    x = xVector[numberOfXNodes - 1]; 
  }
  if(y < yVector[0]) { 
    y = yVector[0]; 
  } else if(y > yVector[numberOfYNodes - 1]) { 
    y = yVector[numberOfYNodes - 1]; 
  }

  // find bins
  idx = FindBinLocationX(x, idx);
  idy = FindBinLocationY(y, idy);

  // interpolate
  if(useBicubic) {
    return BicubicInterpolation(x, y, idx, idy);
  } else {
    G4double x1 = xVector[idx];
    G4double x2 = xVector[idx+1];
    G4double y1 = yVector[idy];
    G4double y2 = yVector[idy+1];
    G4double v11= GetValue(idx,   idy);
    G4double v12= GetValue(idx+1, idy);
    G4double v21= GetValue(idx,   idy+1);
    G4double v22= GetValue(idx+1, idy+1);
    return ((y2 - y)*(v11*(x2 - x) + v12*(x - x1)) + 
        ((y - y1)*(v21*(x2 - x) + v22*(x - x1))))/((x2 - x1)*(y2 - y1)); 
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Value() [2/2]

G4double G4Physics2DVector::Value	(	G4double	x,
		G4double	y
	)		const

Member Data Documentation

numberOfXNodes

size_t G4Physics2DVector::numberOfXNodes

private

Definition at line 170 of file G4Physics2DVector.hh.

numberOfYNodes

size_t G4Physics2DVector::numberOfYNodes

private

Definition at line 171 of file G4Physics2DVector.hh.

type

G4PhysicsVectorType G4Physics2DVector::type

private

Definition at line 168 of file G4Physics2DVector.hh.

useBicubic

G4bool G4Physics2DVector::useBicubic

private

Definition at line 178 of file G4Physics2DVector.hh.

value

std::vector<G4PV2DDataVector*> G4Physics2DVector::value

private

Definition at line 175 of file G4Physics2DVector.hh.

verboseLevel

G4int G4Physics2DVector::verboseLevel

private

Definition at line 177 of file G4Physics2DVector.hh.

xVector

G4PV2DDataVector G4Physics2DVector::xVector

private

Definition at line 173 of file G4Physics2DVector.hh.

yVector

G4PV2DDataVector G4Physics2DVector::yVector

private

Definition at line 174 of file G4Physics2DVector.hh.

---

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

• G4Physics2DVector.hh
• G4Physics2DVector.cc