G4PhysicsVector Class Reference

#include <G4PhysicsVector.hh>

Inheritance diagram for G4PhysicsVector:

Public Member Functions
	G4PhysicsVector (G4bool spline=false)
	G4PhysicsVector (const G4PhysicsVector &)
G4PhysicsVector &	operator= (const G4PhysicsVector &)
G4bool	operator== (const G4PhysicsVector &right) const
G4bool	operator!= (const G4PhysicsVector &right) const
virtual	~G4PhysicsVector ()
G4double	Value (G4double theEnergy, std::size_t &lastidx) const
G4double	LogVectorValue (const G4double theEnergy, const G4double theLogEnergy) const
G4double	Value (G4double theEnergy) const
G4double	GetValue (G4double theEnergy, G4bool &isOutRange) const
G4double	operator[] (const std::size_t index) const
G4double	operator() (const std::size_t index) const
void	PutValue (std::size_t index, G4double theValue)
virtual void	ScaleVector (G4double factorE, G4double factorV)
G4double	Energy (std::size_t index) const
G4double	GetMaxEnergy () const
G4double	GetLowEdgeEnergy (std::size_t binNumber) const
std::size_t	GetVectorLength () const
std::size_t	FindBin (const G4double energy, const std::size_t idx) const
std::size_t	ComputeLogVectorBin (const G4double logenergy) 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 (std::size_t index)

Protected Attributes
G4PhysicsVectorType	type = T_G4PhysicsVector
G4double	edgeMin = 0.0
G4double	edgeMax = 0.0
G4double	invdBin = 0.0
G4double	baseBin = 0.0
G4int	verboseLevel = 0
std::size_t	numberOfNodes = 0
G4PVDataVector	dataVector
G4PVDataVector	binVector
G4PVDataVector	secDerivative

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

Detailed Description

Definition at line 60 of file G4PhysicsVector.hh.

Constructor & Destructor Documentation

G4PhysicsVector() [1/2]

G4PhysicsVector::G4PhysicsVector ( G4bool  spline = false )

explicit

Definition at line 44 of file G4PhysicsVector.cc.

  : useSpline(val)
{}

G4PhysicsVector() [2/2]

G4PhysicsVector::G4PhysicsVector

(

const G4PhysicsVector &

right

)

Definition at line 54 of file G4PhysicsVector.cc.

{
  invdBin      = right.invdBin;
  baseBin      = right.baseBin;
  verboseLevel = right.verboseLevel;
 
  DeleteData();
  CopyData(right);
}

~G4PhysicsVector()

G4PhysicsVector::~G4PhysicsVector ( )

virtual

Definition at line 50 of file G4PhysicsVector.cc.

{}

Member Function Documentation

ComputeLogVectorBin()

std::size_t G4PhysicsVector::ComputeLogVectorBin ( const G4double  logenergy ) const

inline

ComputeSecDerivatives()

void G4PhysicsVector::ComputeSecDerivatives

(

)

Definition at line 443 of file G4PhysicsVector.cc.

{
  //  A simplified method of computation of second derivatives
 
  if(3 > numberOfNodes)  // cannot compute derivatives for less than 4 bins
  {
    useSpline = false;
    return;
  }
 
  if(!SplinePossible())
  {
    return;
  }
 
  useSpline = true;
 
  std::size_t n = numberOfNodes - 1;
 
  for(std::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];
}

Referenced by ComputeSecondDerivatives(), and FillSecondDerivatives().

ComputeSecondDerivatives()

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

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

CopyData()

void G4PhysicsVector::CopyData ( const G4PhysicsVector &  vec )

protected

Definition at line 105 of file G4PhysicsVector.cc.

{
  type          = vec.type;
  edgeMin       = vec.edgeMin;
  edgeMax       = vec.edgeMax;
  numberOfNodes = vec.numberOfNodes;
  useSpline     = vec.useSpline;
 
  std::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];
    }
  }
}

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

DeleteData()

void G4PhysicsVector::DeleteData ( )

protected

Definition at line 97 of file G4PhysicsVector.cc.

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

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

DumpValues()

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

Definition at line 261 of file G4PhysicsVector.cc.

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

Referenced by G4Cerenkov::DumpPhysicsTable(), G4Scintillation::DumpPhysicsTable(), G4OpWLS::DumpPhysicsTable(), and G4OpWLS2::DumpPhysicsTable().

Energy()

G4double G4PhysicsVector::Energy ( std::size_t  index ) const

inline

Referenced by G4EmCorrections::BarkasCorrection(), G4DiffuseElasticV2::BuildAngleTable(), G4KokoulinMuonNuclearXS::BuildCrossSectionTable(), G4LossTableBuilder::BuildInverseRangeTable(), G4VRangeToEnergyConverter::BuildLossTable(), G4Cerenkov::BuildPhysicsTable(), G4Scintillation::BuildPhysicsTable(), G4OpWLS::BuildPhysicsTable(), G4OpWLS2::BuildPhysicsTable(), G4LossTableBuilder::BuildRangeTable(), G4PenelopeBremsstrahlungFS::BuildScaledXSTable(), G4LossTableBuilder::BuildTableForModel(), G4JAEAElasticScatteringModel::ComputeCrossSectionPerAtom(), G4JAEAPolarizedElasticScatteringModel::ComputeCrossSectionPerAtom(), G4LivermoreComptonModel::ComputeCrossSectionPerAtom(), G4LivermorePolarizedComptonModel::ComputeCrossSectionPerAtom(), G4LivermorePolarizedRayleighModel::ComputeCrossSectionPerAtom(), G4LivermoreRayleighModel::ComputeCrossSectionPerAtom(), G4LowEPComptonModel::ComputeCrossSectionPerAtom(), G4LowEPPolarizedComptonModel::ComputeCrossSectionPerAtom(), G4PenelopeRayleighModelMI::CrossSectionPerVolume(), G4PAIModelData::CrossSectionPerVolume(), G4PAIPhotData::CrossSectionPerVolume(), G4PAIModelData::DEDXPerVolume(), G4PAIPhotData::DEDXPerVolume(), G4EmModelManager::DumpModelList(), G4EmModelManager::FillDEDXVector(), G4EmModelManager::FillLambdaVector(), G4HadElementSelector::G4HadElementSelector(), G4LivermorePhotoElectricModel::GetBindingEnergy(), G4PAIPhotData::GetPlasmonRatio(), G4PAIPhotData::Initialise(), G4PAIModelData::Initialise(), G4eeToHadronsModel::Initialise(), G4eplusTo2GammaOKVIModel::Initialise(), G4WentzelVIModel::Initialise(), G4DNABornExcitationModel2::Initialise(), G4HadronXSDataTable::Initialise(), G4NeutronCaptureXS::IsoCrossSection(), G4GDMLWriteMaterials::PropertyVectorWrite(), G4PAIPhotData::SampleAlongStepPhotonTransfer(), G4PAIPhotData::SampleAlongStepPlasmonTransfer(), G4PAIPhotData::SampleAlongStepTransfer(), G4PAIModelData::SampleAlongStepTransfer(), G4PAIPhotData::SamplePostStepPhotonTransfer(), G4PAIPhotData::SamplePostStepPlasmonTransfer(), G4PAIPhotData::SamplePostStepTransfer(), G4PAIModelData::SamplePostStepTransfer(), G4DiffuseElasticV2::SampleTableThetaCMS(), and G4VEnergyLossProcess::SetLambdaTable().

FillSecondDerivatives()

void G4PhysicsVector::FillSecondDerivatives

(

)

Definition at line 361 of file G4PhysicsVector.cc.

{
  // Computation of second derivatives using "Not-a-knot" endpoint conditions
  // B.I. Kvasov "Methods of shape-preserving spline approximation"
  // World Scientific, 2000
 
  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;
}

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

FindBin()

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

inline

Referenced by G4PAIModelData::CrossSectionPerVolume(), G4PAIPhotData::CrossSectionPerVolume(), G4PAIModelData::DEDXPerVolume(), G4PAIPhotData::DEDXPerVolume(), G4SPSEneDistribution::GetArbEneWeight(), G4PAIPhotData::GetPlasmonRatio(), G4PAIPhotData::SampleAlongStepPhotonTransfer(), G4PAIPhotData::SampleAlongStepPlasmonTransfer(), G4PAIPhotData::SampleAlongStepTransfer(), G4PAIModelData::SampleAlongStepTransfer(), G4PAIPhotData::SamplePostStepPhotonTransfer(), G4PAIPhotData::SamplePostStepPlasmonTransfer(), G4PAIPhotData::SamplePostStepTransfer(), G4PAIModelData::SamplePostStepTransfer(), G4DiffuseElasticV2::SampleTableThetaCMS(), and Value().

FindLinearEnergy()

G4double G4PhysicsVector::FindLinearEnergy

(

G4double

rand

)

const

Definition at line 542 of file G4PhysicsVector.cc.

{
  if(1 >= numberOfNodes)
  {
    return 0.0;
  }
  G4double y      = rand * dataVector[numberOfNodes - 1];
  std::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;
}

Referenced by G4AdjointPrimaryGenerator::SampleDistanceAlongBackRayAndComputeWeightCorrection().

GetLowEdgeEnergy()

G4double G4PhysicsVector::GetLowEdgeEnergy

(

std::size_t

binNumber

)

const

Definition at line 136 of file G4PhysicsVector.cc.

{
  return binVector[binNumber];
}

Referenced by G4EMDissociation::ApplyYourself(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VXTRenergyLoss::BuildAngleTable(), G4DiffuseElastic::BuildAngleTable(), G4NuclNuclDiffuseElastic::BuildAngleTable(), G4hRDEnergyLoss::BuildDEDXTable(), G4VXTRenergyLoss::BuildEnergyTable(), G4VXTRenergyLoss::BuildGlobalAngleTable(), G4VLEPTSModel::BuildMeanFreePathTable(), G4VRangeToEnergyConverter::BuildRangeVector(), G4hhElastic::BuildTableT(), G4AdjointCSManager::BuildTotalSigmaTables(), G4ForwardXrayTR::BuildXrayTRtables(), G4PenelopeIonisationXSHandler::BuildXSTable(), G4VRangeToEnergyConverter::ConvertCutToKineticEnergy(), G4PenelopeRayleighModel::DumpFormFactorTable(), G4PenelopeRayleighModelMI::DumpFormFactorTable(), G4SPSRandomGenerator::GenRandEnergy(), G4SPSRandomGenerator::GenRandPhi(), G4SPSRandomGenerator::GenRandPosPhi(), G4SPSRandomGenerator::GenRandPosTheta(), G4SPSRandomGenerator::GenRandTheta(), G4SPSRandomGenerator::GenRandX(), G4SPSRandomGenerator::GenRandY(), G4SPSRandomGenerator::GenRandZ(), G4ForwardXrayTR::GetEnergyTR(), G4VXTRenergyLoss::GetMeanFreePath(), G4VXTRenergyLoss::GetXTRrandomEnergy(), G4NeutronElectronElXsc::Initialise(), G4NeutronElectronElModel::Initialise(), G4InitXscPAI::IntegralCherenkov(), G4InitXscPAI::IntegralPAIdEdx(), G4InitXscPAI::IntegralPAIxSection(), G4InitXscPAI::IntegralPlasmon(), G4PenelopeCrossSection::NormalizeShellCrossSections(), G4ForwardXrayTR::PostStepDoIt(), G4XNNElasticLowE::Print(), G4XnpElasticLowE::Print(), G4XnpTotalLowE::Print(), G4DiffuseElastic::SampleTableThetaCMS(), and G4NuclNuclDiffuseElastic::SampleTableThetaCMS().

GetMaxEnergy()

G4double G4PhysicsVector::GetMaxEnergy ( ) const

inline

Referenced by G4EmModelManager::FillLambdaVector(), G4Scintillation::GetScintillationYieldByParticleType(), G4PAIModelData::SampleAlongStepTransfer(), G4PAIPhotData::SamplePostStepPhotonTransfer(), G4PAIPhotData::SamplePostStepPlasmonTransfer(), G4PAIPhotData::SamplePostStepTransfer(), and G4PAIModelData::SamplePostStepTransfer().

GetType()

G4PhysicsVectorType G4PhysicsVector::GetType ( ) const

inline

GetValue()

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

inline

Referenced by G4XNNElasticLowE::CrossSection(), G4XnpElasticLowE::CrossSection(), G4XnpTotalLowE::CrossSection(), G4XResonance::CrossSection(), G4PartialWidthTable::Dump(), G4ChargeExchangeProcess::GetElementCrossSection(), G4XNNElasticLowE::Print(), G4XnpElasticLowE::Print(), and G4XnpTotalLowE::Print().

GetVectorLength()

std::size_t G4PhysicsVector::GetVectorLength ( ) const

inline

Referenced by G4LossTableBuilder::BuildDEDXTable(), G4LossTableBuilder::BuildInverseRangeTable(), G4Cerenkov::BuildPhysicsTable(), G4Scintillation::BuildPhysicsTable(), G4OpWLS::BuildPhysicsTable(), G4OpWLS2::BuildPhysicsTable(), G4LossTableBuilder::BuildRangeTable(), G4AdjointCSManager::BuildTotalSigmaTables(), G4PenelopeIonisationXSHandler::BuildXSTable(), G4JAEAElasticScatteringModel::ComputeCrossSectionPerAtom(), G4JAEAPolarizedElasticScatteringModel::ComputeCrossSectionPerAtom(), G4LivermoreComptonModel::ComputeCrossSectionPerAtom(), G4LivermoreGammaConversionModelRC::ComputeCrossSectionPerAtom(), G4LivermoreNuclearGammaConversionModel::ComputeCrossSectionPerAtom(), G4LivermorePolarizedComptonModel::ComputeCrossSectionPerAtom(), G4LivermorePolarizedGammaConversionModel::ComputeCrossSectionPerAtom(), G4LivermorePolarizedRayleighModel::ComputeCrossSectionPerAtom(), G4LivermoreRayleighModel::ComputeCrossSectionPerAtom(), G4LowEPComptonModel::ComputeCrossSectionPerAtom(), G4LowEPPolarizedComptonModel::ComputeCrossSectionPerAtom(), G4PAIModelData::CrossSectionPerVolume(), G4PAIPhotData::CrossSectionPerVolume(), G4PAIModelData::DEDXPerVolume(), G4PAIPhotData::DEDXPerVolume(), G4PenelopeRayleighModel::DumpFormFactorTable(), G4PenelopeRayleighModelMI::DumpFormFactorTable(), G4EmModelManager::DumpModelList(), G4EmModelManager::FillDEDXVector(), G4EmModelManager::FillLambdaVector(), G4SPSRandomGenerator::GenRandEnergy(), G4SPSRandomGenerator::GenRandPhi(), G4SPSRandomGenerator::GenRandPosPhi(), G4SPSRandomGenerator::GenRandPosTheta(), G4SPSRandomGenerator::GenRandTheta(), G4SPSRandomGenerator::GenRandX(), G4SPSRandomGenerator::GenRandY(), G4SPSRandomGenerator::GenRandZ(), G4SPSEneDistribution::GetArbEneWeight(), G4PenelopeCrossSection::GetHardCrossSection(), G4PenelopeCrossSection::GetNormalizedShellCrossSection(), G4PAIPhotData::GetPlasmonRatio(), G4PenelopeCrossSection::GetShellCrossSection(), G4PenelopeCrossSection::GetSoftStoppingPower(), G4PenelopeCrossSection::GetTotalCrossSection(), G4eeToHadronsModel::Initialise(), G4GDMLWriteMaterials::PropertyVectorWrite(), G4PAIPhotData::SampleAlongStepPhotonTransfer(), G4PAIPhotData::SampleAlongStepPlasmonTransfer(), G4PAIPhotData::SampleAlongStepTransfer(), G4PAIModelData::SampleAlongStepTransfer(), G4PAIPhotData::SamplePostStepPhotonTransfer(), G4PAIPhotData::SamplePostStepPlasmonTransfer(), G4PAIPhotData::SamplePostStepTransfer(), G4PAIModelData::SamplePostStepTransfer(), and G4VEnergyLossProcess::SetLambdaTable().

IsFilledVectorExist()

G4bool G4PhysicsVector::IsFilledVectorExist ( ) const

inline

Referenced by G4Cerenkov::GetAverageNumberOfPhotons().

LogVectorValue()

G4double G4PhysicsVector::LogVectorValue ( const G4double  theEnergy, const G4double  theLogEnergy  ) const

inline

Referenced by G4GammaGeneralProcess::ComputeGeneralLambda(), G4GammaGeneralProcess::GetProbability(), G4ParticleInelasticXS::IsoCrossSection(), G4NeutronCaptureXS::IsoCrossSection(), and G4NeutronInelasticXS::IsoCrossSection().

operator!=()

G4bool G4PhysicsVector::operator!=

(

const G4PhysicsVector &

right

)

const

Definition at line 90 of file G4PhysicsVector.cc.

{
  return (this != &right);
}

operator()()

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

inline

operator=()

G4PhysicsVector & G4PhysicsVector::operator=

(

const G4PhysicsVector &

right

)

Definition at line 66 of file G4PhysicsVector.cc.

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

operator==()

G4bool G4PhysicsVector::operator==

(

const G4PhysicsVector &

right

)

const

Definition at line 83 of file G4PhysicsVector.cc.

{
  return (this == &right);
}

operator[]()

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

inline

PrintPutValueError()

void G4PhysicsVector::PrintPutValueError ( std::size_t  index )

protected

Definition at line 563 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");
}

Referenced by G4PhysicsFreeVector::PutValue().

PutValue()

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

inline

Referenced by G4RToEConvForGamma::BuildAbsorptionLengthVector(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4KokoulinMuonNuclearXS::BuildCrossSectionTable(), G4hRDEnergyLoss::BuildDEDXTable(), G4LossTableBuilder::BuildDEDXTable(), G4VXTRenergyLoss::BuildEnergyTable(), G4VXTRenergyLoss::BuildGlobalAngleTable(), G4VRangeToEnergyConverter::BuildLossTable(), G4VLEPTSModel::BuildMeanFreePathTable(), G4VLEPTSModel::BuildPhysicsTable(), G4ChargeExchangeProcess::BuildPhysicsTable(), G4LossTableBuilder::BuildRangeTable(), G4VRangeToEnergyConverter::BuildRangeVector(), G4LossTableBuilder::BuildTableForModel(), G4AdjointCSManager::BuildTotalSigmaTables(), G4ForwardXrayTR::BuildXrayTRtables(), G4EmModelManager::FillDEDXVector(), G4EmModelManager::FillLambdaVector(), G4NeutronElectronElXsc::G4NeutronElectronElXsc(), G4XNNElasticLowE::G4XNNElasticLowE(), G4XnpElasticLowE::G4XnpElasticLowE(), G4XnpTotalLowE::G4XnpTotalLowE(), G4NeutronElectronElXsc::Initialise(), G4PAIPhotData::Initialise(), G4PAIModelData::Initialise(), G4eeToHadronsModel::Initialise(), G4eplusTo2GammaOKVIModel::Initialise(), G4WentzelVIModel::Initialise(), G4DNABornExcitationModel2::Initialise(), G4HadronXSDataTable::Initialise(), G4InitXscPAI::IntegralCherenkov(), G4InitXscPAI::IntegralPAIdEdx(), G4InitXscPAI::IntegralPAIxSection(), G4InitXscPAI::IntegralPlasmon(), G4VRangeToEnergyConverter::operator=(), G4ChannelingECHARM::ReadFromECHARM(), and G4ChannelingMaterialData::SetBR().

Retrieve()

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

virtual

Reimplemented in G4PhysicsLinearVector, and G4PhysicsLogVector.

Definition at line 176 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() || numberOfNodes < 2)
    {
      return false;
    }
    // contents
    G4int siz = 0;
    fIn >> siz;
    if(fIn.fail() || siz != G4int(numberOfNodes))
    {
      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
  std::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(std::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;
}

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

ScaleVector()

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

virtual

Reimplemented in G4PhysicsLinearVector, and G4PhysicsLogVector.

Definition at line 271 of file G4PhysicsVector.cc.

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

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

SetSpline()

void G4PhysicsVector::SetSpline ( G4bool  )

inline

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4LossTableBuilder::BuildDEDXTable(), G4LossTableBuilder::BuildInverseRangeTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4LossTableBuilder::BuildRangeTable(), G4LossTableBuilder::BuildTableForModel(), G4EmElementSelector::G4EmElementSelector(), G4HadElementSelector::G4HadElementSelector(), G4eplusTo2GammaOKVIModel::Initialise(), G4DNABornExcitationModel2::Initialise(), G4HadronXSDataTable::Initialise(), G4GammaGeneralProcess::InitialiseProcess(), G4VEmProcess::LambdaPhysicsVector(), G4VEnergyLossProcess::LambdaPhysicsVector(), and G4PenelopeBremsstrahlungAngular::PrepareTables().

SetVerboseLevel()

void G4PhysicsVector::SetVerboseLevel ( G4int  value )

inline

Store()

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

Definition at line 143 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
  std::size_t size = dataVector.size();
  fOut.write((char*) (&size), sizeof size);
 
  G4double* value = new G4double[2 * size];
  for(std::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 ) const

inline

Value() [2/2]

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

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

Referenced by G4EmCorrections::BarkasCorrection(), G4LossTableBuilder::BuildRangeTable(), G4Track::CalculateVelocityForOpticalPhoton(), G4JAEAElasticScatteringModel::ComputeCrossSectionPerAtom(), G4JAEAPolarizedElasticScatteringModel::ComputeCrossSectionPerAtom(), G4LivermoreComptonModel::ComputeCrossSectionPerAtom(), G4LivermoreGammaConversionModelRC::ComputeCrossSectionPerAtom(), G4LivermoreNuclearGammaConversionModel::ComputeCrossSectionPerAtom(), G4LivermorePolarizedComptonModel::ComputeCrossSectionPerAtom(), G4LivermorePolarizedGammaConversionModel::ComputeCrossSectionPerAtom(), G4LivermorePolarizedRayleighModel::ComputeCrossSectionPerAtom(), G4LivermoreRayleighModel::ComputeCrossSectionPerAtom(), G4LowEPComptonModel::ComputeCrossSectionPerAtom(), G4LowEPPolarizedComptonModel::ComputeCrossSectionPerAtom(), G4PenelopeGammaConversionModel::ComputeCrossSectionPerAtom(), G4PenelopePhotoElectricModel::ComputeCrossSectionPerAtom(), G4PenelopeRayleighModel::ComputeCrossSectionPerAtom(), G4PenelopeRayleighModelMI::ComputeCrossSectionPerAtom(), G4BoldyshevTripletModel::ComputeCrossSectionPerAtom(), G4eplusTo2GammaOKVIModel::ComputeCrossSectionPerAtom(), G4LivermoreGammaConversion5DModel::ComputeCrossSectionPerAtom(), G4LivermoreGammaConversionModel::ComputeCrossSectionPerAtom(), G4eeToHadronsModel::ComputeCrossSectionPerElectron(), G4VRangeToEnergyConverter::ConvertCutToKineticEnergy(), G4eplusTo2GammaOKVIModel::CrossSectionPerVolume(), G4DNABornExcitationModel2::CrossSectionPerVolume(), G4EmCorrections::EffectiveChargeCorrection(), G4eeToHadronsModel::GenerateCMPhoton(), G4Cerenkov::GetAverageNumberOfPhotons(), G4ChannelingMaterialData::GetBR(), G4FastPathHadronicCrossSection::fastPathEntry::GetCrossSection(), G4PenelopeIonisationXSHandler::GetDensityCorrection(), G4ChannelingECHARM::GetEC(), G4NeutronElectronElXsc::GetElementCrossSection(), G4KokoulinMuonNuclearXS::GetElementCrossSection(), G4PenelopeCrossSection::GetHardCrossSection(), G4OpAbsorption::GetMeanFreePath(), G4OpMieHG::GetMeanFreePath(), G4OpRayleigh::GetMeanFreePath(), G4OpWLS::GetMeanFreePath(), G4OpWLS2::GetMeanFreePath(), G4PenelopeCrossSection::GetNormalizedShellCrossSection(), G4SPSEneDistribution::GetProbability(), G4Scintillation::GetScintillationYieldByParticleType(), G4PenelopePhotoElectricModel::GetShellCrossSection(), G4PenelopeCrossSection::GetShellCrossSection(), G4PenelopeCrossSection::GetSoftStoppingPower(), G4PenelopeCrossSection::GetTotalCrossSection(), G4ElementData::GetValueForElement(), G4NeutronElectronElXsc::Initialise(), G4PAIPhotData::Initialise(), G4eeToHadronsModel::Initialise(), G4EmCorrections::KShellCorrection(), G4EmCorrections::LShellCorrection(), G4Cerenkov::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4PenelopeBremsstrahlungAngular::PrepareTables(), G4PAIModelData::SampleAlongStepTransfer(), G4PenelopeBremsstrahlungAngular::SampleDirection(), G4PAIModelData::SamplePostStepTransfer(), G4PenelopeRayleighModel::SampleSecondaries(), G4PenelopeRayleighModelMI::SampleSecondaries(), G4eplusTo2GammaOKVIModel::SampleSecondaries(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::SetDEDXTable(), and G4EmCorrections::ShellCorrection().

Friends And Related Function Documentation

operator<<

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

friend

Definition at line 499 of file G4PhysicsVector.cc.

{
  // binning
  G4int prec = out.precision();
  out << std::setprecision(12) << pv.edgeMin << " " << pv.edgeMax << " "
      << pv.numberOfNodes << G4endl;
 
  // contents
  out << pv.dataVector.size() << G4endl;
  for(std::size_t i = 0; i < pv.dataVector.size(); ++i)
  {
    out << pv.binVector[i] << "  " << pv.dataVector[i] << G4endl;
  }
  out << std::setprecision(prec);
 
  return out;
}

Member Data Documentation

baseBin

G4double G4PhysicsVector::baseBin = 0.0

protected

Definition at line 206 of file G4PhysicsVector.hh.

Referenced by G4PhysicsLinearVector::G4PhysicsLinearVector(), G4PhysicsLogVector::G4PhysicsLogVector(), G4PhysicsVector(), operator=(), G4PhysicsLinearVector::Retrieve(), G4PhysicsLogVector::Retrieve(), G4PhysicsLinearVector::ScaleVector(), and G4PhysicsLogVector::ScaleVector().

binVector

G4PVDataVector G4PhysicsVector::binVector

protected

Definition at line 212 of file G4PhysicsVector.hh.

Referenced by ComputeSecDerivatives(), ComputeSecondDerivatives(), CopyData(), DumpValues(), FillSecondDerivatives(), FindLinearEnergy(), G4PhysicsFreeVector::G4PhysicsFreeVector(), G4PhysicsLinearVector::G4PhysicsLinearVector(), G4PhysicsLogVector::G4PhysicsLogVector(), G4PhysicsOrderedFreeVector::G4PhysicsOrderedFreeVector(), GetLowEdgeEnergy(), G4PhysicsOrderedFreeVector::GetMaxLowEdgeEnergy(), G4PhysicsOrderedFreeVector::GetMinLowEdgeEnergy(), G4PhysicsOrderedFreeVector::InsertValues(), G4PhysicsFreeVector::PutValue(), G4PhysicsLinearVector::Retrieve(), G4PhysicsLogVector::Retrieve(), Retrieve(), ScaleVector(), G4PhysicsLinearVector::ScaleVector(), G4PhysicsLogVector::ScaleVector(), and Store().

dataVector

G4PVDataVector G4PhysicsVector::dataVector

protected

Definition at line 211 of file G4PhysicsVector.hh.

Referenced by ComputeSecDerivatives(), ComputeSecondDerivatives(), CopyData(), DumpValues(), FillSecondDerivatives(), FindLinearEnergy(), G4PhysicsFreeVector::G4PhysicsFreeVector(), G4PhysicsLinearVector::G4PhysicsLinearVector(), G4PhysicsLogVector::G4PhysicsLogVector(), G4PhysicsOrderedFreeVector::G4PhysicsOrderedFreeVector(), G4PhysicsOrderedFreeVector::GetMaxValue(), G4PhysicsOrderedFreeVector::GetMinValue(), G4PhysicsOrderedFreeVector::InsertValues(), G4PhysicsFreeVector::PutValue(), Retrieve(), ScaleVector(), Store(), and Value().

edgeMax

G4double G4PhysicsVector::edgeMax = 0.0

protected

Definition at line 203 of file G4PhysicsVector.hh.

Referenced by CopyData(), G4PhysicsFreeVector::G4PhysicsFreeVector(), G4PhysicsLinearVector::G4PhysicsLinearVector(), G4PhysicsLogVector::G4PhysicsLogVector(), G4PhysicsOrderedFreeVector::GetEnergy(), G4PhysicsOrderedFreeVector::InsertValues(), G4PhysicsFreeVector::PutValue(), Retrieve(), ScaleVector(), Store(), and Value().

edgeMin

G4double G4PhysicsVector::edgeMin = 0.0

protected

Definition at line 202 of file G4PhysicsVector.hh.

Referenced by CopyData(), G4PhysicsFreeVector::G4PhysicsFreeVector(), G4PhysicsLinearVector::G4PhysicsLinearVector(), G4PhysicsLogVector::G4PhysicsLogVector(), G4PhysicsOrderedFreeVector::GetEnergy(), G4PhysicsOrderedFreeVector::InsertValues(), G4PhysicsFreeVector::PutValue(), G4PhysicsLinearVector::Retrieve(), G4PhysicsLogVector::Retrieve(), Retrieve(), ScaleVector(), G4PhysicsLinearVector::ScaleVector(), G4PhysicsLogVector::ScaleVector(), Store(), and Value().

invdBin

G4double G4PhysicsVector::invdBin = 0.0

protected

Definition at line 205 of file G4PhysicsVector.hh.

Referenced by G4PhysicsLinearVector::G4PhysicsLinearVector(), G4PhysicsLogVector::G4PhysicsLogVector(), G4PhysicsVector(), operator=(), G4PhysicsLinearVector::Retrieve(), G4PhysicsLogVector::Retrieve(), G4PhysicsLinearVector::ScaleVector(), and G4PhysicsLogVector::ScaleVector().

numberOfNodes

std::size_t G4PhysicsVector::numberOfNodes = 0

protected

Definition at line 209 of file G4PhysicsVector.hh.

Referenced by ComputeSecDerivatives(), ComputeSecondDerivatives(), CopyData(), DumpValues(), FillSecondDerivatives(), FindLinearEnergy(), G4PhysicsFreeVector::G4PhysicsFreeVector(), G4PhysicsLinearVector::G4PhysicsLinearVector(), G4PhysicsLogVector::G4PhysicsLogVector(), G4PhysicsOrderedFreeVector::InsertValues(), PrintPutValueError(), G4PhysicsFreeVector::PutValue(), Retrieve(), Store(), and Value().

secDerivative

G4PVDataVector G4PhysicsVector::secDerivative

protected

Definition at line 213 of file G4PhysicsVector.hh.

Referenced by ComputeSecDerivatives(), ComputeSecondDerivatives(), CopyData(), DeleteData(), FillSecondDerivatives(), Retrieve(), and ScaleVector().

type

G4PhysicsVectorType G4PhysicsVector::type = T_G4PhysicsVector

protected

Definition at line 199 of file G4PhysicsVector.hh.

Referenced by CopyData(), G4PhysicsFreeVector::G4PhysicsFreeVector(), G4PhysicsLinearVector::G4PhysicsLinearVector(), G4PhysicsLogVector::G4PhysicsLogVector(), G4PhysicsOrderedFreeVector::G4PhysicsOrderedFreeVector(), and PrintPutValueError().

verboseLevel

G4int G4PhysicsVector::verboseLevel = 0

protected

Definition at line 208 of file G4PhysicsVector.hh.

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

---

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

• G4PhysicsVector.hh
• G4PhysicsVector.cc