G4PhysicsVector Class Reference

#include <G4PhysicsVector.hh>

Inheritance diagram for G4PhysicsVector:

Collaboration diagram for G4PhysicsVector:

Public Member Functions
	G4PhysicsVector (G4bool spline=false)
	G4PhysicsVector (const G4PhysicsVector &)
G4PhysicsVector &	operator= (const G4PhysicsVector &)
virtual	~G4PhysicsVector ()
G4double	Value (G4double theEnergy, size_t &lastidx) const
G4double	Value (G4double theEnergy) const
G4double	GetValue (G4double theEnergy, G4bool &isOutRange) const
G4int	operator== (const G4PhysicsVector &right) const
G4int	operator!= (const G4PhysicsVector &right) const
G4double	operator[] (const size_t binNumber) const
G4double	operator() (const size_t binNumber) const
void	PutValue (size_t index, G4double theValue)
virtual void	ScaleVector (G4double factorE, G4double factorV)
G4double	Energy (size_t index) const
G4double	GetMaxEnergy () const
G4double	GetLowEdgeEnergy (size_t binNumber) const
size_t	GetVectorLength () const
size_t	FindBin (G4double energy, size_t idx) const
void	FillSecondDerivatives ()
void	ComputeSecDerivatives ()
void	ComputeSecondDerivatives (G4double firstPointDerivative, G4double endPointDerivative)
G4double	FindLinearEnergy (G4double rand) const
G4bool	IsFilledVectorExist () const
G4PhysicsVectorType	GetType () const
void	SetSpline (G4bool)
virtual G4bool	Store (std::ofstream &fOut, G4bool ascii=false)
virtual G4bool	Retrieve (std::ifstream &fIn, G4bool ascii=false)
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel (G4int)

Protected Member Functions
void	DeleteData ()
void	CopyData (const G4PhysicsVector &vec)

Protected Attributes
G4PhysicsVectorType	type
G4double	edgeMin
G4double	edgeMax
size_t	numberOfNodes
G4PVDataVector	dataVector
G4PVDataVector	binVector
G4PVDataVector	secDerivative
G4double	dBin
G4double	baseBin
G4int	verboseLevel

Private Member Functions
G4bool	SplinePossible ()
G4double	LinearInterpolation (size_t idx, G4double energy) const
G4double	SplineInterpolation (size_t idx, G4double energy) const
G4double	Interpolation (size_t idx, G4double energy) const
size_t	FindBinLocation (G4double theEnergy) const

Private Attributes
G4bool	useSpline

Friends
std::ostream &	operator<< (std::ostream &, const G4PhysicsVector &)

Detailed Description

Definition at line 76 of file G4PhysicsVector.hh.

Constructor & Destructor Documentation

G4PhysicsVector() [1/2]

G4PhysicsVector::G4PhysicsVector

(

G4bool

spline = false

)

Definition at line 61 of file G4PhysicsVector.cc.

 : type(T_G4PhysicsVector),
   edgeMin(0.), edgeMax(0.), numberOfNodes(0),
   useSpline(false), 
   dBin(0.), baseBin(0.),
   verboseLevel(0)
{
}

G4PhysicsVector() [2/2]

G4PhysicsVector::G4PhysicsVector

(

const G4PhysicsVector &

right

)

Definition at line 78 of file G4PhysicsVector.cc.

{
  dBin         = right.dBin;
  baseBin      = right.baseBin;
  verboseLevel = right.verboseLevel;

  DeleteData();
  CopyData(right);
}

Here is the call graph for this function:

~G4PhysicsVector()

G4PhysicsVector::~G4PhysicsVector ( )

virtual

Definition at line 72 of file G4PhysicsVector.cc.

{
}

Member Function Documentation

ComputeSecDerivatives()

void G4PhysicsVector::ComputeSecDerivatives

(

)

Definition at line 431 of file G4PhysicsVector.cc.

{
  if(3 > numberOfNodes)  // cannot compute derivatives for less than 4 bins
  {
    useSpline = false;
    return;
  }

  if(!SplinePossible())  { return; }

  useSpline = true;

  size_t n = numberOfNodes-1;

  for(size_t i=1; i<n; ++i)
  {
    secDerivative[i] =
      3.0*((dataVector[i+1]-dataVector[i])/(binVector[i+1]-binVector[i]) -
           (dataVector[i]-dataVector[i-1])/(binVector[i]-binVector[i-1]))
      /(binVector[i+1]-binVector[i-1]);
  }
  secDerivative[n] = secDerivative[n-1];
  secDerivative[0] = secDerivative[1];
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeSecondDerivatives()

void G4PhysicsVector::ComputeSecondDerivatives	(	G4double	firstPointDerivative,
		G4double	endPointDerivative
	)

Definition at line 294 of file G4PhysicsVector.cc.

{
  if(4 > numberOfNodes)   // cannot compute derivatives for less than 4 bins
  {
    ComputeSecDerivatives();
    return;
  }

  if(!SplinePossible()) { return; }

  useSpline = true;

  G4int n = numberOfNodes-1;

  G4double* u = new G4double [n];
  
  G4double p, sig, un;

  u[0] = (6.0/(binVector[1]-binVector[0]))
    * ((dataVector[1]-dataVector[0])/(binVector[1]-binVector[0])
       - firstPointDerivative);
 
  secDerivative[0] = - 0.5;

  // Decomposition loop for tridiagonal algorithm. secDerivative[i]
  // and u[i] are used for temporary storage of the decomposed factors.

  for(G4int i=1; i<n; ++i)
  {
    sig = (binVector[i]-binVector[i-1]) / (binVector[i+1]-binVector[i-1]);
    p = sig*(secDerivative[i-1]) + 2.0;
    secDerivative[i] = (sig - 1.0)/p;
    u[i] = (dataVector[i+1]-dataVector[i])/(binVector[i+1]-binVector[i])
         - (dataVector[i]-dataVector[i-1])/(binVector[i]-binVector[i-1]);
    u[i] = 6.0*u[i]/(binVector[i+1]-binVector[i-1]) - sig*u[i-1]/p;
  }

  sig = (binVector[n-1]-binVector[n-2]) / (binVector[n]-binVector[n-2]);
  p = sig*secDerivative[n-2] + 2.0;
  un = (6.0/(binVector[n]-binVector[n-1]))
    *(endPointDerivative - 
      (dataVector[n]-dataVector[n-1])/(binVector[n]-binVector[n-1])) - u[n-1]/p;
  secDerivative[n] = un/(secDerivative[n-1] + 2.0);

  // The back-substitution loop for the triagonal algorithm of solving
  // a linear system of equations.
   
  for(G4int k=n-1; k>0; --k)
  {
    secDerivative[k] *= 
      (secDerivative[k+1] - 
       u[k]*(binVector[k+1]-binVector[k-1])/(binVector[k+1]-binVector[k]));
  }
  secDerivative[0] = 0.5*(u[0] - secDerivative[1]);

  delete [] u;
}

Here is the call graph for this function:

CopyData()

void G4PhysicsVector::CopyData ( const G4PhysicsVector &  vec )

protected

Definition at line 126 of file G4PhysicsVector.cc.

{
  type = vec.type;
  edgeMin = vec.edgeMin;
  edgeMax = vec.edgeMax;
  numberOfNodes = vec.numberOfNodes;
  useSpline = vec.useSpline;

  size_t i;
  dataVector.resize(numberOfNodes);
  for(i=0; i<numberOfNodes; ++i) { 
    dataVector[i] = (vec.dataVector)[i];
  }
  binVector.resize(numberOfNodes);
  for(i=0; i<numberOfNodes; ++i) { 
    binVector[i] = (vec.binVector)[i];
  }
  if(0 < (vec.secDerivative).size()) {
    secDerivative.resize(numberOfNodes);
    for(i=0; i<numberOfNodes; ++i){ 
      secDerivative[i] = (vec.secDerivative)[i];
    }
  }
}

Here is the caller graph for this function:

DeleteData()

void G4PhysicsVector::DeleteData ( )

protected

Definition at line 118 of file G4PhysicsVector.cc.

{
  useSpline = false;
  secDerivative.clear();
}

Here is the caller graph for this function:

Energy()

G4double G4PhysicsVector::Energy ( size_t  index ) const

inline

FillSecondDerivatives()

void G4PhysicsVector::FillSecondDerivatives

(

)

Definition at line 359 of file G4PhysicsVector.cc.

{
  if(5 > numberOfNodes)  // cannot compute derivatives for less than 4 points
  {
    ComputeSecDerivatives();
    return;
  }

  if(!SplinePossible()) { return; }

  useSpline = true;
 
  G4int n = numberOfNodes-1;

  G4double* u = new G4double [n];
  
  G4double p, sig;

  u[1] = ((dataVector[2]-dataVector[1])/(binVector[2]-binVector[1]) -
          (dataVector[1]-dataVector[0])/(binVector[1]-binVector[0]));
  u[1] = 6.0*u[1]*(binVector[2]-binVector[1])
    / ((binVector[2]-binVector[0])*(binVector[2]-binVector[0]));
 
  // Decomposition loop for tridiagonal algorithm. secDerivative[i]
  // and u[i] are used for temporary storage of the decomposed factors.

  secDerivative[1] = (2.0*binVector[1]-binVector[0]-binVector[2])
    / (2.0*binVector[2]-binVector[0]-binVector[1]);

  for(G4int i=2; i<n-1; ++i)
  {
    sig = (binVector[i]-binVector[i-1]) / (binVector[i+1]-binVector[i-1]);
    p = sig*secDerivative[i-1] + 2.0;
    secDerivative[i] = (sig - 1.0)/p;
    u[i] = (dataVector[i+1]-dataVector[i])/(binVector[i+1]-binVector[i])
         - (dataVector[i]-dataVector[i-1])/(binVector[i]-binVector[i-1]);
    u[i] = (6.0*u[i]/(binVector[i+1]-binVector[i-1])) - sig*u[i-1]/p;
  }

  sig = (binVector[n-1]-binVector[n-2]) / (binVector[n]-binVector[n-2]);
  p = sig*secDerivative[n-3] + 2.0;
  u[n-1] = (dataVector[n]-dataVector[n-1])/(binVector[n]-binVector[n-1])
    - (dataVector[n-1]-dataVector[n-2])/(binVector[n-1]-binVector[n-2]);
  u[n-1] = 6.0*sig*u[n-1]/(binVector[n]-binVector[n-2])
    - (2.0*sig - 1.0)*u[n-2]/p;  

  p = (1.0+sig) + (2.0*sig-1.0)*secDerivative[n-2];
  secDerivative[n-1] = u[n-1]/p;

  // The back-substitution loop for the triagonal algorithm of solving
  // a linear system of equations.
   
  for(G4int k=n-2; k>1; --k)
  {
    secDerivative[k] *= 
      (secDerivative[k+1] - 
       u[k]*(binVector[k+1]-binVector[k-1])/(binVector[k+1]-binVector[k]));
  }
  secDerivative[n] = (secDerivative[n-1] - (1.0-sig)*secDerivative[n-2])/sig;
  sig = 1.0 - ((binVector[2]-binVector[1])/(binVector[2]-binVector[0]));
  secDerivative[1] *= (secDerivative[2] - u[1]/(1.0-sig));
  secDerivative[0]  = (secDerivative[1] - sig*secDerivative[2])/(1.0-sig);

  delete [] u;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindBin()

size_t G4PhysicsVector::FindBin ( G4double  energy, size_t  idx  ) const

inline

Here is the caller graph for this function:

FindBinLocation()

size_t G4PhysicsVector::FindBinLocation ( G4double  theEnergy ) const

inlineprivate

FindLinearEnergy()

G4double G4PhysicsVector::FindLinearEnergy

(

G4double

rand

)

const

Definition at line 516 of file G4PhysicsVector.cc.

{
  if(1 >= numberOfNodes) { return 0.0; }
  G4double y = rand*dataVector[numberOfNodes-1];
  size_t bin = std::lower_bound(dataVector.begin(), dataVector.end(), y)
             - dataVector.begin() - 1;
  bin = std::min(bin, numberOfNodes-2);
  G4double res = binVector[bin];
  G4double del = dataVector[bin+1] - dataVector[bin];
  if(del > 0.0) { 
    res += (y - dataVector[bin])*(binVector[bin+1] - res)/del;  
  }
  return res;
}

Here is the caller graph for this function:

GetLowEdgeEnergy()

G4double G4PhysicsVector::GetLowEdgeEnergy

(

size_t

binNumber

)

const

Definition at line 153 of file G4PhysicsVector.cc.

{
  return binVector[binNumber];
}

GetMaxEnergy()

G4double G4PhysicsVector::GetMaxEnergy ( ) const

inline

Here is the caller graph for this function:

GetType()

G4PhysicsVectorType G4PhysicsVector::GetType ( ) const

inline

GetValue()

G4double G4PhysicsVector::GetValue ( G4double  theEnergy, G4bool &  isOutRange  ) const

inline

Here is the caller graph for this function:

GetVectorLength()

size_t G4PhysicsVector::GetVectorLength ( ) const

inline

GetVerboseLevel()

G4int G4PhysicsVector::GetVerboseLevel ( G4int  )

inline

Interpolation()

G4double G4PhysicsVector::Interpolation ( size_t  idx, G4double  energy  ) const

inlineprivate

Here is the caller graph for this function:

IsFilledVectorExist()

G4bool G4PhysicsVector::IsFilledVectorExist ( ) const

inline

Here is the caller graph for this function:

LinearInterpolation()

G4double G4PhysicsVector::LinearInterpolation ( size_t  idx, G4double  energy  ) const

inlineprivate

operator!=()

G4int G4PhysicsVector::operator!=

(

const G4PhysicsVector &

right

)

const

Definition at line 111 of file G4PhysicsVector.cc.

{
  return (this != &right);
}

operator()()

G4double G4PhysicsVector::operator() ( const size_t  binNumber ) const

inline

operator=()

G4PhysicsVector & G4PhysicsVector::operator=

(

const G4PhysicsVector &

right

)

Definition at line 90 of file G4PhysicsVector.cc.

{
  if (&right==this)  { return *this; }
  dBin         = right.dBin;
  baseBin      = right.baseBin;
  verboseLevel = right.verboseLevel;

  DeleteData();
  CopyData(right);
  return *this;
}

Here is the call graph for this function:

operator==()

G4int G4PhysicsVector::operator==

(

const G4PhysicsVector &

right

)

const

Definition at line 104 of file G4PhysicsVector.cc.

{
  return (this == &right);
}

operator[]()

G4double G4PhysicsVector::operator[] ( const size_t  binNumber ) const

inline

PutValue()

void G4PhysicsVector::PutValue ( size_t  index, G4double  theValue  )

inline

Retrieve()

G4bool G4PhysicsVector::Retrieve ( std::ifstream &  fIn, G4bool  ascii = false  )

virtual

Reimplemented in G4PhysicsLogVector, G4PhysicsLinearVector, and G4PhysicsLnVector.

Definition at line 193 of file G4PhysicsVector.cc.

{
  // clear properties;
  dataVector.clear();
  binVector.clear();
  secDerivative.clear();

  // retrieve in ascii mode
  if (ascii){
    // binning
    fIn >> edgeMin >> edgeMax >> numberOfNodes; 
    if (fIn.fail())  { return false; }
    // contents
    G4int siz=0;
    fIn >> siz;
    if (fIn.fail())  { return false; }
    if (siz<=0)
    {
#ifdef G4VERBOSE  
      G4cerr << "G4PhysicsVector::Retrieve():";
      G4cerr << " Invalid vector size: " << siz << G4endl;
#endif
      return false;
    }

    binVector.reserve(siz);
    dataVector.reserve(siz);
    G4double vBin, vData;

    for(G4int i = 0; i < siz ; i++)
    {
      vBin = 0.;
      vData= 0.;
      fIn >> vBin >> vData;
      if (fIn.fail())  { return false; }
      binVector.push_back(vBin);
      dataVector.push_back(vData);
    }

    // to remove any inconsistency 
    numberOfNodes = siz;
    edgeMin = binVector[0];
    edgeMax = binVector[numberOfNodes-1];
    return true ;
  }

  // retrieve in binary mode
  // binning
  fIn.read((char*)(&edgeMin), sizeof edgeMin);
  fIn.read((char*)(&edgeMax), sizeof edgeMax);
  fIn.read((char*)(&numberOfNodes), sizeof numberOfNodes ); 
 
  // contents
  size_t size;
  fIn.read((char*)(&size), sizeof size); 
 
  G4double* value = new G4double[2*size];
  fIn.read((char*)(value),  2*size*(sizeof(G4double)) );
  if (G4int(fIn.gcount()) != G4int(2*size*(sizeof(G4double))) )
  {
    delete [] value;
    return false;
  }

  binVector.reserve(size);
  dataVector.reserve(size);
  for(size_t i = 0; i < size; ++i)
  {
    binVector.push_back(value[2*i]);
    dataVector.push_back(value[2*i+1]);
  }
  delete [] value;

  // to remove any inconsistency 
  numberOfNodes = size;
  edgeMin = binVector[0];
  edgeMax = binVector[numberOfNodes-1];

  return true;
}

Here is the caller graph for this function:

ScaleVector()

void G4PhysicsVector::ScaleVector ( G4double  factorE, G4double  factorV  )

virtual

Reimplemented in G4PhysicsLogVector, G4PhysicsLinearVector, and G4PhysicsLnVector.

Definition at line 277 of file G4PhysicsVector.cc.

{
  size_t n = dataVector.size();
  size_t i;
  for(i=0; i<n; ++i) {
    binVector[i]  *= factorE;
    dataVector[i] *= factorV; 
  }
  secDerivative.clear();

  edgeMin *= factorE;
  edgeMax *= factorE;
}

Here is the caller graph for this function:

SetSpline()

void G4PhysicsVector::SetSpline ( G4bool  )

inline

Here is the caller graph for this function:

SetVerboseLevel()

void G4PhysicsVector::SetVerboseLevel ( G4int  value )

inline

SplineInterpolation()

G4double G4PhysicsVector::SplineInterpolation ( size_t  idx, G4double  energy  ) const

inlineprivate

SplinePossible()

G4bool G4PhysicsVector::SplinePossible ( )

private

Definition at line 459 of file G4PhysicsVector.cc.

{
  G4bool result = true;
  for(size_t j=1; j<numberOfNodes; ++j)
  {
    if(binVector[j] <= binVector[j-1])  { 
      result = false; 
      useSpline = false;
      secDerivative.clear();
      break;
    }
  }  
  secDerivative.resize(numberOfNodes,0.0);
  return result;
}

Here is the caller graph for this function:

Store()

G4bool G4PhysicsVector::Store ( std::ofstream &  fOut, G4bool  ascii = false  )

virtual

Definition at line 160 of file G4PhysicsVector.cc.

{
  // Ascii mode
  if (ascii)
  {
    fOut << *this;
    return true;
  } 
  // Binary Mode

  // binning
  fOut.write((char*)(&edgeMin), sizeof edgeMin);
  fOut.write((char*)(&edgeMax), sizeof edgeMax);
  fOut.write((char*)(&numberOfNodes), sizeof numberOfNodes);

  // contents
  size_t size = dataVector.size(); 
  fOut.write((char*)(&size), sizeof size);

  G4double* value = new G4double[2*size];
  for(size_t i = 0; i < size; ++i)
  {
    value[2*i]  =  binVector[i];
    value[2*i+1]=  dataVector[i];
  }
  fOut.write((char*)(value), 2*size*(sizeof (G4double)));
  delete [] value;

  return true;
}

Value() [1/2]

G4double G4PhysicsVector::Value	(	G4double	theEnergy,
		size_t &	lastidx
	)		const

Definition at line 498 of file G4PhysicsVector.cc.

{
  G4double y;
  if(theEnergy <= edgeMin) {
    lastIdx = 0; 
    y = dataVector[0]; 
  } else if(theEnergy >= edgeMax) { 
    lastIdx = numberOfNodes-1; 
    y = dataVector[lastIdx]; 
  } else {
    lastIdx = FindBin(theEnergy, lastIdx);
    y = Interpolation(lastIdx, theEnergy);
  }
  return y;
}

Here is the call graph for this function:

Value() [2/2]

G4double G4PhysicsVector::Value ( G4double  theEnergy ) const

inline

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  out, const G4PhysicsVector &  pv  )

friend

Definition at line 479 of file G4PhysicsVector.cc.

{
  // binning
  out << std::setprecision(12) << pv.edgeMin << " "
      << pv.edgeMax << " " << pv.numberOfNodes << G4endl; 

  // contents
  out << pv.dataVector.size() << G4endl; 
  for(size_t i = 0; i < pv.dataVector.size(); i++)
  {
    out << pv.binVector[i] << "  " << pv.dataVector[i] << G4endl;
  }
  out << std::setprecision(6);

  return out;
}

Member Data Documentation

baseBin

G4double G4PhysicsVector::baseBin

protected

Definition at line 237 of file G4PhysicsVector.hh.

binVector

G4PVDataVector G4PhysicsVector::binVector

protected

Definition at line 215 of file G4PhysicsVector.hh.

dataVector

G4PVDataVector G4PhysicsVector::dataVector

protected

Definition at line 214 of file G4PhysicsVector.hh.

dBin

G4double G4PhysicsVector::dBin

protected

Definition at line 236 of file G4PhysicsVector.hh.

edgeMax

G4double G4PhysicsVector::edgeMax

protected

Definition at line 210 of file G4PhysicsVector.hh.

edgeMin

G4double G4PhysicsVector::edgeMin

protected

Definition at line 209 of file G4PhysicsVector.hh.

numberOfNodes

size_t G4PhysicsVector::numberOfNodes

protected

Definition at line 212 of file G4PhysicsVector.hh.

secDerivative

G4PVDataVector G4PhysicsVector::secDerivative

protected

Definition at line 216 of file G4PhysicsVector.hh.

type

G4PhysicsVectorType G4PhysicsVector::type

protected

Definition at line 207 of file G4PhysicsVector.hh.

useSpline

G4bool G4PhysicsVector::useSpline

private

Definition at line 232 of file G4PhysicsVector.hh.

verboseLevel

G4int G4PhysicsVector::verboseLevel

protected

Definition at line 239 of file G4PhysicsVector.hh.

---

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

• G4PhysicsVector.hh
• G4PhysicsVector.cc