#include <G4PhysicsVector.hh>

Inheritance diagram for G4PhysicsVector:

Public Member Functions
	G4PhysicsVector (G4bool spline=false)

	G4PhysicsVector (const G4PhysicsVector &)

G4PhysicsVector &	operator= (const G4PhysicsVector &)

virtual	~G4PhysicsVector ()

void *	operator new (size_t)

void	operator delete (void *)

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

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

Detailed Description

Definition at line 77 of file G4PhysicsVector.hh.

Constructor & Destructor Documentation

G4PhysicsVector::G4PhysicsVector ( G4bool spline = false )

Definition at line 63 of file G4PhysicsVector.cc.

References fpPVAllocator.

  : type(T_G4PhysicsVector),
    edgeMin(0.), edgeMax(0.), numberOfNodes(0),
    useSpline(false), 
    dBin(0.), baseBin(0.),
    verboseLevel(0)
 {
   if (!fpPVAllocator) fpPVAllocator = new G4Allocator<G4PhysicsVector>;
   // g4pow = G4Pow::GetInstance();
 }

G4PhysicsVector::G4PhysicsVector ( const G4PhysicsVector & right )

Definition at line 82 of file G4PhysicsVector.cc.

References baseBin, CopyData(), dBin, DeleteData(), and verboseLevel.

 {
   //  g4pow = G4Pow::GetInstance();
 
   dBin         = right.dBin;
   baseBin      = right.baseBin;
   verboseLevel = right.verboseLevel;
 
   DeleteData();
   CopyData(right);
 }

G4PhysicsVector::~G4PhysicsVector ( )

virtual

Definition at line 76 of file G4PhysicsVector.cc.

77 {

78 }

Member Function Documentation

void G4PhysicsVector::ComputeSecDerivatives ( )

Definition at line 439 of file G4PhysicsVector.cc.

References binVector, dataVector, n, numberOfNodes, and secDerivative.

Referenced by ComputeSecondDerivatives(), and FillSecondDerivatives().

 {
   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];
 }

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

Definition at line 302 of file G4PhysicsVector.cc.

References binVector, ComputeSecDerivatives(), dataVector, n, numberOfNodes, and secDerivative.

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

void G4PhysicsVector::CopyData ( const G4PhysicsVector & vec )

protected

Definition at line 132 of file G4PhysicsVector.cc.

References binVector, dataVector, edgeMax, edgeMin, numberOfNodes, secDerivative, and type.

Referenced by G4PhysicsVector(), and operator=().

 {
   type = vec.type;
   edgeMin = vec.edgeMin;
   edgeMax = vec.edgeMax;
   numberOfNodes = vec.numberOfNodes;
   useSpline = vec.useSpline;
 
   size_t i;
   dataVector.clear();
   for(i=0; i<(vec.dataVector).size(); i++){ 
     dataVector.push_back( (vec.dataVector)[i] );
   }
   binVector.clear();
   for(i=0; i<(vec.binVector).size(); i++){ 
     binVector.push_back( (vec.binVector)[i] );
   }
   secDerivative.clear();
   for(i=0; i<(vec.secDerivative).size(); i++){ 
     secDerivative.push_back( (vec.secDerivative)[i] );
   }
 }

void G4PhysicsVector::DeleteData ( )

protected

Definition at line 124 of file G4PhysicsVector.cc.

References secDerivative.

Referenced by G4PhysicsVector(), and operator=().

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

G4double G4PhysicsVector::Energy ( size_t index ) const

inline

Referenced by G4EmCorrections::BarkasCorrection(), G4KokoulinMuonNuclearXS::BuildCrossSectionTable(), WLSPrimaryGeneratorAction::BuildEmissionSpectrum(), G4LossTableBuilder::BuildInverseRangeTable(), G4VRangeToEnergyConverter::BuildLossTable(), G4ePolarizedIonisation::BuildPhysicsTable(), G4LossTableBuilder::BuildRangeTable(), G4PenelopeBremsstrahlungFS::BuildScaledXSTable(), G4LossTableBuilder::BuildTableForModel(), G4Scintillation::BuildThePhysicsTable(), G4LivermoreRayleighModel::ComputeCrossSectionPerAtom(), G4LivermoreComptonModel::ComputeCrossSectionPerAtom(), G4EmModelManager::DumpModelList(), G4EmModelManager::FillDEDXVector(), G4EmModelManager::FillLambdaVector(), G4NeutronElasticXS::GetElementCrossSection(), G4NeutronCaptureXS::GetElementCrossSection(), G4NeutronInelasticXS::GetElementCrossSection(), G4GDMLWriteMaterials::PropertyVectorWrite(), G4PAIPhotData::SampleAlongStepPhotonTransfer(), G4PAIPhotData::SampleAlongStepPlasmonTransfer(), G4PAIPhotData::SampleAlongStepTransfer(), G4PAIModelData::SampleAlongStepTransfer(), and G4VEnergyLossProcess::SetLambdaTable().

void G4PhysicsVector::FillSecondDerivatives ( )

Definition at line 367 of file G4PhysicsVector.cc.

References binVector, ComputeSecDerivatives(), dataVector, n, numberOfNodes, and secDerivative.

Referenced by G4LossTableBuilder::BuildDEDXTable(), G4VEnergyLossProcess::BuildDEDXTable(), G4LossTableBuilder::BuildInverseRangeTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4LossTableBuilder::BuildRangeTable(), and G4LossTableBuilder::BuildTableForModel().

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

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

inline

Referenced by Value().

G4double G4PhysicsVector::FindLinearEnergy ( G4double rand ) const

Definition at line 529 of file G4PhysicsVector.cc.

References binVector, and dataVector.

 {
   if(1 >= numberOfNodes) { return 0.0; }
   size_t n1 = 0;
   size_t n2 = numberOfNodes/2;
   size_t n3 = numberOfNodes - 1;
   G4double y = rand*dataVector[n3];
   while (n1 + 1 != n3)
     {
       if (y > dataVector[n2])
     { n1 = n2; }
       else
     { n3 = n2; }
       n2 = (n3 + n1 + 1)/2;
     }
   G4double res = binVector[n1];
   G4double del = dataVector[n3] - dataVector[n1];
   if(del > 0.0) { 
     res += (y - dataVector[n1])*(binVector[n3] - res)/del;  
   }
   return res;
 }

G4double G4PhysicsVector::GetLowEdgeEnergy ( size_t binNumber ) const

Definition at line 157 of file G4PhysicsVector.cc.

References binVector.

Referenced by G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4NuclNuclDiffuseElastic::BuildAngleTable(), G4DiffuseElastic::BuildAngleTable(), G4VXTRenergyLoss::BuildAngleTable(), G4PolarizedCompton::BuildAsymmetryTable(), G4eplusPolarizedAnnihilation::BuildAsymmetryTable(), G4eLowEnergyLoss::BuildDEDXTable(), G4hRDEnergyLoss::BuildDEDXTable(), G4VXTRenergyLoss::BuildEnergyTable(), G4VXTRenergyLoss::BuildGlobalAngleTable(), G4RDVeLowEnergyLoss::BuildInverseRangeTable(), G4PAIPhotonModel::BuildPAIonisationTable(), G4VRangeToEnergyConverter::BuildRangeVector(), G4AdjointCSManager::BuildTotalSigmaTables(), G4ForwardXrayTR::BuildXrayTRtables(), G4PenelopeIonisationXSHandler::BuildXSTable(), G4VRangeToEnergyConverter::ConvertCutToKineticEnergy(), G4PenelopeRayleighModel::DumpFormFactorTable(), G4SPSRandomGenerator::GenRandEnergy(), G4SPSRandomGenerator::GenRandPhi(), G4SPSRandomGenerator::GenRandPosPhi(), G4SPSRandomGenerator::GenRandPosTheta(), G4SPSRandomGenerator::GenRandTheta(), G4SPSRandomGenerator::GenRandX(), G4SPSRandomGenerator::GenRandY(), G4SPSRandomGenerator::GenRandZ(), G4PAIPhotonModel::GetAlongStepTransfer(), G4ForwardXrayTR::GetEnergyTR(), G4VXTRenergyLoss::GetMeanFreePath(), G4PAIPhotonModel::GetPostStepTransfer(), G4VXTRenergyLoss::GetXTRrandomEnergy(), G4eeToHadronsModel::Initialise(), G4InitXscPAI::IntegralCherenkov(), G4InitXscPAI::IntegralPAIdEdx(), G4InitXscPAI::IntegralPAIxSection(), G4InitXscPAI::IntegralPlasmon(), G4PenelopeCrossSection::NormalizeShellCrossSections(), G4ForwardXrayTR::PostStepDoIt(), G4XNNElasticLowE::Print(), G4XnpTotalLowE::Print(), G4XnpElasticLowE::Print(), G4NuclNuclDiffuseElastic::SampleTableThetaCMS(), and G4DiffuseElastic::SampleTableThetaCMS().

 {
   return binVector[binNumber];
 }

G4double G4PhysicsVector::GetMaxEnergy ( ) const

inline

Referenced by G4EmModelManager::FillLambdaVector(), G4NeutronInelasticXS::GetElementCrossSection(), and G4Scintillation::GetScintillationYieldByParticleType().

G4PhysicsVectorType G4PhysicsVector::GetType ( ) const

inline

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

inline

size_t G4PhysicsVector::GetVectorLength ( ) const

inline

G4int G4PhysicsVector::GetVerboseLevel ( G4int )

inline

G4bool G4PhysicsVector::IsFilledVectorExist ( ) const

inline

void G4PhysicsVector::operator delete ( void * )

inline

void* G4PhysicsVector::operator new ( size_t )

inline

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

Definition at line 117 of file G4PhysicsVector.cc.

 {
   return (this != &right);
 }

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

inline

G4PhysicsVector & G4PhysicsVector::operator= ( const G4PhysicsVector & right )

Definition at line 96 of file G4PhysicsVector.cc.

References baseBin, CopyData(), dBin, DeleteData(), and verboseLevel.

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

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

Definition at line 110 of file G4PhysicsVector.cc.

 {
   return (this == &right);
 }

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

inline

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

inline

Referenced by G4RToEConvForGamma::BuildAbsorptionLengthVector(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4PolarizedCompton::BuildAsymmetryTable(), G4eplusPolarizedAnnihilation::BuildAsymmetryTable(), G4KokoulinMuonNuclearXS::BuildCrossSectionTable(), G4LossTableBuilder::BuildDEDXTable(), G4eLowEnergyLoss::BuildDEDXTable(), G4hRDEnergyLoss::BuildDEDXTable(), G4VXTRenergyLoss::BuildEnergyTable(), G4VXTRenergyLoss::BuildGlobalAngleTable(), G4RDVeLowEnergyLoss::BuildInverseRangeTable(), G4PAIPhotonModel::BuildLambdaVector(), G4VRangeToEnergyConverter::BuildLossTable(), G4PAIPhotonModel::BuildPAIonisationTable(), G4ChargeExchangeProcess::BuildPhysicsTable(), G4ePolarizedIonisation::BuildPhysicsTable(), G4RDVeLowEnergyLoss::BuildRangeCoeffATable(), G4RDVeLowEnergyLoss::BuildRangeCoeffBTable(), G4RDVeLowEnergyLoss::BuildRangeCoeffCTable(), G4LossTableBuilder::BuildRangeTable(), G4VRangeToEnergyConverter::BuildRangeVector(), G4LossTableBuilder::BuildTableForModel(), G4AdjointCSManager::BuildTotalSigmaTables(), G4ForwardXrayTR::BuildXrayTRtables(), G4EmModelManager::FillDEDXVector(), G4EmModelManager::FillLambdaVector(), G4XNNElasticLowE::G4XNNElasticLowE(), G4XnpElasticLowE::G4XnpElasticLowE(), G4XnpTotalLowE::G4XnpTotalLowE(), G4eeToHadronsModel::Initialise(), G4PAIPhotData::Initialise(), G4PAIModelData::Initialise(), G4InitXscPAI::IntegralCherenkov(), G4InitXscPAI::IntegralPAIdEdx(), G4InitXscPAI::IntegralPAIxSection(), G4InitXscPAI::IntegralPlasmon(), and G4VRangeToEnergyConverter::operator=().

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

virtual

Reimplemented in G4PhysicsLogVector, G4PhysicsLinearVector, and G4PhysicsLnVector.

Definition at line 197 of file G4PhysicsVector.cc.

References binVector, dataVector, edgeMax, edgeMin, G4cerr, G4endl, numberOfNodes, and secDerivative.

Referenced by G4PhysicsLnVector::Retrieve(), G4PhysicsLinearVector::Retrieve(), G4PhysicsLogVector::Retrieve(), and G4PhysicsTable::RetrievePhysicsTable().

 {
   // 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;
 }

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

virtual

Reimplemented in G4PhysicsLogVector, G4PhysicsLinearVector, and G4PhysicsLnVector.

Definition at line 281 of file G4PhysicsVector.cc.

References binVector, dataVector, edgeMax, edgeMin, n, and secDerivative.

Referenced by G4PhysicsLnVector::ScaleVector(), G4PhysicsLinearVector::ScaleVector(), and G4PhysicsLogVector::ScaleVector().

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

void G4PhysicsVector::SetSpline ( G4bool )

inline

Referenced by G4LossTableBuilder::BuildDEDXTable(), G4VEnergyLossProcess::BuildDEDXTable(), G4LossTableBuilder::BuildInverseRangeTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4LossTableBuilder::BuildRangeTable(), G4LossTableBuilder::BuildTableForModel(), OpNoviceDetectorConstruction::Construct(), G4EmElementSelector::G4EmElementSelector(), G4HadronNucleonXsc::InitialiseKaonNucleonTotXsc(), G4VEnergyLossProcess::LambdaPhysicsVector(), G4VEmProcess::LambdaPhysicsVector(), G4eeTo3PiModel::PhysicsVector(), G4ee2KNeutralModel::PhysicsVector(), G4ee2KChargedModel::PhysicsVector(), G4eeToTwoPiModel::PhysicsVector(), G4eeToPGammaModel::PhysicsVector(), and G4PenelopeBremsstrahlungAngular::PrepareTables().

void G4PhysicsVector::SetVerboseLevel ( G4int value )

inline

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

virtual

Definition at line 164 of file G4PhysicsVector.cc.

References binVector, dataVector, edgeMax, edgeMin, and numberOfNodes.

 {
   // 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 511 of file G4PhysicsVector.cc.

References dataVector, edgeMax, edgeMin, and FindBin().

Referenced by G4EmCorrections::BarkasCorrection(), G4LossTableBuilder::BuildRangeTable(), G4Track::CalculateVelocityForOpticalPhoton(), G4LivermoreRayleighModel::ComputeCrossSectionPerAtom(), G4LivermoreGammaConversionModel::ComputeCrossSectionPerAtom(), G4LivermoreComptonModel::ComputeCrossSectionPerAtom(), G4PenelopeGammaConversionModel::ComputeCrossSectionPerAtom(), G4PenelopeRayleighModel::ComputeCrossSectionPerAtom(), G4PenelopePhotoElectricModel::ComputeCrossSectionPerAtom(), G4VRangeToEnergyConverter::ConvertCutToKineticEnergy(), G4EmCorrections::EffectiveChargeCorrection(), G4PenelopeIonisationXSHandler::GetDensityCorrection(), G4NeutronElasticXS::GetElementCrossSection(), G4NeutronCaptureXS::GetElementCrossSection(), G4NeutronInelasticXS::GetElementCrossSection(), G4PenelopeCrossSection::GetHardCrossSection(), G4HadronNucleonXsc::GetKmNeutronTotXscVector(), G4HadronNucleonXsc::GetKmProtonTotXscVector(), G4HadronNucleonXsc::GetKpNeutronTotXscVector(), G4HadronNucleonXsc::GetKpProtonTotXscVector(), G4PenelopeCrossSection::GetNormalizedShellCrossSection(), G4SPSEneDistribution::GetProbability(), G4Scintillation::GetScintillationYieldByParticleType(), G4PenelopeCrossSection::GetShellCrossSection(), G4PenelopePhotoElectricModel::GetShellCrossSection(), G4PenelopeCrossSection::GetSoftStoppingPower(), G4PenelopeCrossSection::GetTotalCrossSection(), G4ElementData::GetValueForElement(), G4PAIPhotData::Initialise(), G4PAIModelData::Initialise(), G4EmCorrections::KShellCorrection(), G4EmCorrections::LShellCorrection(), G4Cerenkov::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4PenelopeBremsstrahlungAngular::PrepareTables(), G4PenelopeBremsstrahlungAngular::SampleDirection(), G4PenelopeRayleighModel::SampleSecondaries(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::SetDEDXTable(), and G4EmCorrections::ShellCorrection().

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

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 491 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;
 }