G4PhysicsVector Class Reference

#include <G4PhysicsVector.hh>

Inheritance 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 index) const
G4double	operator() (const size_t index) 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)
G4bool	Store (std::ofstream &fOut, G4bool ascii=false) const
virtual G4bool	Retrieve (std::ifstream &fIn, G4bool ascii=false)
void	DumpValues (G4double unitE=1.0, G4double unitV=1.0) const
void	SetVerboseLevel (G4int value)

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

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

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

Detailed Description

Definition at line 76 of file G4PhysicsVector.hh.

Constructor & Destructor Documentation

G4PhysicsVector::G4PhysicsVector ( G4bool  spline = false )

explicit

Definition at line 61 of file G4PhysicsVector.cc.

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

G4PhysicsVector::G4PhysicsVector

(

const G4PhysicsVector &

right

)

Definition at line 76 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 ( )

virtual

Definition at line 71 of file G4PhysicsVector.cc.

{}

Member Function Documentation

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 caller graph for this function:

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:

void G4PhysicsVector::CopyData ( const G4PhysicsVector &  vec )

protected

Definition at line 124 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:

void G4PhysicsVector::DeleteData ( )

protected

Definition at line 116 of file G4PhysicsVector.cc.

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

Here is the caller graph for this function:

void G4PhysicsVector::DumpValues	(	G4double	unitE = 1.0,
		G4double	unitV = 1.0
	)		const

Definition at line 266 of file G4PhysicsVector.cc.

{
   for (size_t i = 0; i < numberOfNodes; ++i)
   {
     G4cout << binVector[i]/unitE << "   " << dataVector[i]/unitV << G4endl;
   }
}

Here is the caller graph for this function:

G4double G4PhysicsVector::Energy ( size_t  index ) const

inline

Here is the caller graph for this function:

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:

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

inline

Here is the caller graph for this function:

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 call graph for this function:

Here is the caller graph for this function:

G4double G4PhysicsVector::GetLowEdgeEnergy

(

size_t

binNumber

)

const

Definition at line 151 of file G4PhysicsVector.cc.

{
  return binVector[binNumber];
}

Here is the caller graph for this function:

G4double G4PhysicsVector::GetMaxEnergy ( ) const

inline

Here is the caller graph for this function:

G4PhysicsVectorType G4PhysicsVector::GetType ( ) const

inline

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

inline

Here is the caller graph for this function:

size_t G4PhysicsVector::GetVectorLength ( ) const

inline

Here is the caller graph for this function:

G4bool G4PhysicsVector::IsFilledVectorExist ( ) const

inline

G4int G4PhysicsVector::operator!=

(

const G4PhysicsVector &

right

)

const

Definition at line 109 of file G4PhysicsVector.cc.

{
  return (this != &right);
}

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

inline

G4PhysicsVector & G4PhysicsVector::operator=

(

const G4PhysicsVector &

right

)

Definition at line 88 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:

G4int G4PhysicsVector::operator==

(

const G4PhysicsVector &

right

)

const

Definition at line 102 of file G4PhysicsVector.cc.

{
  return (this == &right);
}

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

inline

void G4PhysicsVector::PrintPutValueError ( size_t  index )

protected

Definition at line 533 of file G4PhysicsVector.cc.

{
  G4ExceptionDescription ed;
  ed << "Vector type " << type << " length= " << numberOfNodes 
     << " an attempt to put data at index= " << index;
  G4Exception("G4PhysicsVector::PutValue()","gl0005",FatalException,
          ed,"Memory overwritten");
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

Here is the caller graph for this function:

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

virtual

Reimplemented in G4PhysicsLogVector, and G4PhysicsLinearVector.

Definition at line 191 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() || siz<=0) { 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:

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

virtual

Reimplemented in G4PhysicsLogVector, and G4PhysicsLinearVector.

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 = binVector[0];
  edgeMax = binVector[n-1];
}

Here is the caller graph for this function:

void G4PhysicsVector::SetSpline ( G4bool  )

inline

Here is the caller graph for this function:

void G4PhysicsVector::SetVerboseLevel ( G4int  value )

inline

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

Definition at line 158 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;
}

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:

G4double G4PhysicsVector::Value ( G4double  theEnergy ) const

inline

Friends And Related Function Documentation

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

G4double G4PhysicsVector::baseBin

protected

Definition at line 238 of file G4PhysicsVector.hh.

G4PVDataVector G4PhysicsVector::binVector

protected

Definition at line 215 of file G4PhysicsVector.hh.

G4PVDataVector G4PhysicsVector::dataVector

protected

Definition at line 214 of file G4PhysicsVector.hh.

G4double G4PhysicsVector::dBin

protected

Definition at line 237 of file G4PhysicsVector.hh.

G4double G4PhysicsVector::edgeMax

protected

Definition at line 210 of file G4PhysicsVector.hh.

G4double G4PhysicsVector::edgeMin

protected

Definition at line 209 of file G4PhysicsVector.hh.

size_t G4PhysicsVector::numberOfNodes

protected

Definition at line 212 of file G4PhysicsVector.hh.

G4PVDataVector G4PhysicsVector::secDerivative

protected

Definition at line 216 of file G4PhysicsVector.hh.

G4PhysicsVectorType G4PhysicsVector::type

protected

Definition at line 207 of file G4PhysicsVector.hh.

G4int G4PhysicsVector::verboseLevel

protected

Definition at line 240 of file G4PhysicsVector.hh.

---

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

• geant4.10.03.p01/source/global/management/include/G4PhysicsVector.hh
• geant4.10.03.p01/source/global/management/src/G4PhysicsVector.cc