G4DNADingfelderChargeIncreaseModel Class Reference

#include <G4DNADingfelderChargeIncreaseModel.hh>

Inheritance diagram for G4DNADingfelderChargeIncreaseModel:

Collaboration diagram for G4DNADingfelderChargeIncreaseModel:

Public Member Functions
	G4DNADingfelderChargeIncreaseModel (const G4ParticleDefinition *p=0, const G4String &nam="DNADingfelderChargeIncreaseModel")
virtual	~G4DNADingfelderChargeIncreaseModel ()
virtual void	Initialise (const G4ParticleDefinition *, const G4DataVector &)
virtual G4double	CrossSectionPerVolume (const G4Material *material, const G4ParticleDefinition *p, G4double ekin, G4double emin, G4double emax)
virtual void	SampleSecondaries (std::vector< G4DynamicParticle *> *, const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double tmin, G4double maxEnergy)
void	SelectStationary (G4bool input)
Public Member Functions inherited from G4VEmModel
	G4VEmModel (const G4String &nam)
virtual	~G4VEmModel ()
virtual void	InitialiseLocal (const G4ParticleDefinition *, G4VEmModel *masterModel)
virtual void	InitialiseForMaterial (const G4ParticleDefinition *, const G4Material *)
virtual void	InitialiseForElement (const G4ParticleDefinition *, G4int Z)
virtual G4double	ComputeDEDXPerVolume (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=DBL_MAX)
virtual G4double	GetPartialCrossSection (const G4Material *, G4int, const G4ParticleDefinition *, G4double)
virtual G4double	ComputeCrossSectionPerAtom (const G4ParticleDefinition *, G4double kinEnergy, G4double Z, G4double A=0., G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
virtual G4double	ComputeCrossSectionPerShell (const G4ParticleDefinition *, G4int Z, G4int shellIdx, G4double kinEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
virtual G4double	ChargeSquareRatio (const G4Track &)
virtual G4double	GetChargeSquareRatio (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
virtual G4double	GetParticleCharge (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
virtual void	StartTracking (G4Track *)
virtual void	CorrectionsAlongStep (const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double &eloss, G4double &niel, G4double length)
virtual G4double	Value (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy)
virtual G4double	MinPrimaryEnergy (const G4Material *, const G4ParticleDefinition *, G4double cut=0.0)
virtual G4double	MinEnergyCut (const G4ParticleDefinition *, const G4MaterialCutsCouple *)
virtual void	SetupForMaterial (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
virtual void	DefineForRegion (const G4Region *)
virtual void	ModelDescription (std::ostream &outFile) const
void	InitialiseElementSelectors (const G4ParticleDefinition *, const G4DataVector &)
std::vector< G4EmElementSelector * > *	GetElementSelectors ()
void	SetElementSelectors (std::vector< G4EmElementSelector *> *)
G4double	ComputeDEDX (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=DBL_MAX)
G4double	CrossSection (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
G4double	ComputeMeanFreePath (const G4ParticleDefinition *, G4double kineticEnergy, const G4Material *, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
G4double	ComputeCrossSectionPerAtom (const G4ParticleDefinition *, const G4Element *, G4double kinEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
G4int	SelectIsotopeNumber (const G4Element *)
const G4Element *	SelectRandomAtom (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
const G4Element *	SelectRandomAtom (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
G4int	SelectRandomAtomNumber (const G4Material *)
void	SetParticleChange (G4VParticleChange *, G4VEmFluctuationModel *f=0)
void	SetCrossSectionTable (G4PhysicsTable *, G4bool isLocal)
G4ElementData *	GetElementData ()
G4PhysicsTable *	GetCrossSectionTable ()
G4VEmFluctuationModel *	GetModelOfFluctuations ()
G4VEmAngularDistribution *	GetAngularDistribution ()
void	SetAngularDistribution (G4VEmAngularDistribution *)
G4double	HighEnergyLimit () const
G4double	LowEnergyLimit () const
G4double	HighEnergyActivationLimit () const
G4double	LowEnergyActivationLimit () const
G4double	PolarAngleLimit () const
G4double	SecondaryThreshold () const
G4bool	LPMFlag () const
G4bool	DeexcitationFlag () const
G4bool	ForceBuildTableFlag () const
G4bool	UseAngularGeneratorFlag () const
void	SetAngularGeneratorFlag (G4bool)
void	SetHighEnergyLimit (G4double)
void	SetLowEnergyLimit (G4double)
void	SetActivationHighEnergyLimit (G4double)
void	SetActivationLowEnergyLimit (G4double)
G4bool	IsActive (G4double kinEnergy)
void	SetPolarAngleLimit (G4double)
void	SetSecondaryThreshold (G4double)
void	SetLPMFlag (G4bool val)
void	SetDeexcitationFlag (G4bool val)
void	SetForceBuildTable (G4bool val)
void	SetMasterThread (G4bool val)
G4bool	IsMaster () const
G4double	MaxSecondaryKinEnergy (const G4DynamicParticle *dynParticle)
const G4String &	GetName () const
void	SetCurrentCouple (const G4MaterialCutsCouple *)
const G4Element *	GetCurrentElement () const
const G4Isotope *	GetCurrentIsotope () const
G4bool	IsLocked () const
void	SetLocked (G4bool)

Protected Attributes
G4ParticleChangeForGamma *	fParticleChangeForGamma
Protected Attributes inherited from G4VEmModel
G4ElementData *	fElementData
G4VParticleChange *	pParticleChange
G4PhysicsTable *	xSectionTable
const std::vector< G4double > *	theDensityFactor
const std::vector< G4int > *	theDensityIdx
size_t	idxTable

Private Member Functions
G4double	PartialCrossSection (G4double energy, G4int level, const G4ParticleDefinition *particle)
G4double	Sum (G4double energy, const G4ParticleDefinition *particle)
G4int	RandomSelect (G4double energy, const G4ParticleDefinition *particle)
G4int	NumberOfFinalStates (G4ParticleDefinition *particleDefinition, G4int finalStateIndex)
G4ParticleDefinition *	OutgoingParticleDefinition (G4ParticleDefinition *particleDefinition, G4int finalStateIndex)
G4double	WaterBindingEnergyConstant (G4ParticleDefinition *aParticleDefinition, G4int finalStateIndex)
G4double	OutgoingParticleBindingEnergyConstant (G4ParticleDefinition *particleDefinition, G4int finalStateIndex)
G4double	IncomingParticleBindingEnergyConstant (G4ParticleDefinition *particleDefinition, G4int finalStateIndex)
G4DNADingfelderChargeIncreaseModel &	operator= (const G4DNADingfelderChargeIncreaseModel &right)
	G4DNADingfelderChargeIncreaseModel (const G4DNADingfelderChargeIncreaseModel &)

Private Attributes
const std::vector< G4double > *	fpMolWaterDensity
std::map< G4String, G4double, std::less< G4String > >	lowEnergyLimit
std::map< G4String, G4double, std::less< G4String > >	highEnergyLimit
G4bool	isInitialised
G4bool	statCode
G4int	verboseLevel
G4int	numberOfPartialCrossSections [2]
G4double	f0 [2][2]
G4double	a0 [2][2]
G4double	a1 [2][2]
G4double	b0 [2][2]
G4double	b1 [2][2]
G4double	c0 [2][2]
G4double	d0 [2][2]
G4double	x0 [2][2]
G4double	x1 [2][2]

Additional Inherited Members
Protected Member Functions inherited from G4VEmModel
G4ParticleChangeForLoss *	GetParticleChangeForLoss ()
G4ParticleChangeForGamma *	GetParticleChangeForGamma ()
virtual G4double	MaxSecondaryEnergy (const G4ParticleDefinition *, G4double kineticEnergy)
const G4MaterialCutsCouple *	CurrentCouple () const
void	SetCurrentElement (const G4Element *)
Static Protected Attributes inherited from G4VEmModel
static const G4double	inveplus = 1.0/CLHEP::eplus

Detailed Description

Definition at line 41 of file G4DNADingfelderChargeIncreaseModel.hh.

Constructor & Destructor Documentation

G4DNADingfelderChargeIncreaseModel() [1/2]

G4DNADingfelderChargeIncreaseModel::G4DNADingfelderChargeIncreaseModel	(	const G4ParticleDefinition *	p = 0,
		const G4String &	nam = "DNADingfelderChargeIncreaseModel"
	)

Definition at line 40 of file G4DNADingfelderChargeIncreaseModel.cc.

                                                                                            :
    G4VEmModel(nam), isInitialised(false)
{
  //  nistwater = G4NistManager::Instance()->FindOrBuildMaterial("G4_WATER");
  fpMolWaterDensity = 0;

  numberOfPartialCrossSections[0] = 0;
  numberOfPartialCrossSections[1] = 0;

  verboseLevel = 0;
  // Verbosity scale:
  // 0 = nothing
  // 1 = warning for energy non-conservation
  // 2 = details of energy budget
  // 3 = calculation of cross sections, file openings, sampling of atoms
  // 4 = entering in methods

  if (verboseLevel > 0)
  {
    G4cout << "Dingfelder charge increase model is constructed " << G4endl;
  }
  fParticleChangeForGamma = 0;

  // Selection of stationary mode

  statCode = false;
}

~G4DNADingfelderChargeIncreaseModel()

G4DNADingfelderChargeIncreaseModel::~G4DNADingfelderChargeIncreaseModel ( )

virtual

Definition at line 71 of file G4DNADingfelderChargeIncreaseModel.cc.

{}

G4DNADingfelderChargeIncreaseModel() [2/2]

G4DNADingfelderChargeIncreaseModel::G4DNADingfelderChargeIncreaseModel ( const G4DNADingfelderChargeIncreaseModel &  )

private

Member Function Documentation

CrossSectionPerVolume()

G4double G4DNADingfelderChargeIncreaseModel::CrossSectionPerVolume ( const G4Material *  material, const G4ParticleDefinition *  p, G4double  ekin, G4double  emin, G4double  emax  )

virtual

Reimplemented from G4VEmModel.

Definition at line 198 of file G4DNADingfelderChargeIncreaseModel.cc.

{
  if (verboseLevel > 3)
  {
    G4cout
        << "Calling CrossSectionPerVolume() of G4DNADingfelderChargeIncreaseModel"
        << G4endl;
  }

  // Calculate total cross section for model

  G4DNAGenericIonsManager *instance;
  instance = G4DNAGenericIonsManager::Instance();

  if (
      particleDefinition != instance->GetIon("hydrogen")
      &&
      particleDefinition != instance->GetIon("alpha+")
      &&
      particleDefinition != instance->GetIon("helium")
  )

  return 0;

  G4double lowLim = 0;
  G4double highLim = 0;
  G4double totalCrossSection = 0.;

  G4double waterDensity = (*fpMolWaterDensity)[material->GetIndex()];

  if(waterDensity!= 0.0)
  //  if (material == nistwater || material->GetBaseMaterial() == nistwater)
  {
    const G4String& particleName = particleDefinition->GetParticleName();

    std::map< G4String,G4double,std::less<G4String> >::iterator pos1;
    pos1 = lowEnergyLimit.find(particleName);

    if (pos1 != lowEnergyLimit.end())
    {
      lowLim = pos1->second;
    }

    std::map< G4String,G4double,std::less<G4String> >::iterator pos2;
    pos2 = highEnergyLimit.find(particleName);

    if (pos2 != highEnergyLimit.end())
    {
      highLim = pos2->second;
    }

    if (k >= lowLim && k < highLim)
    {
      //HYDROGEN
      if (particleDefinition == instance->GetIon("hydrogen"))
      {
        const G4double aa = 2.835;
        const G4double bb = 0.310;
        const G4double cc = 2.100;
        const G4double dd = 0.760;
        const G4double fac = 1.0e-18;
        const G4double rr = 13.606 * eV;

        G4double t = k / (proton_mass_c2/electron_mass_c2);
        G4double x = t / rr;
        G4double temp = 4.0 * pi * Bohr_radius/nm * Bohr_radius/nm * fac;
        G4double sigmal = temp * cc * (std::pow(x,dd));
        G4double sigmah = temp * (aa * std::log(1.0 + x) + bb) / x;
        totalCrossSection = 1.0/(1.0/sigmal + 1.0/sigmah) *m*m;
      }
      else
      {
        totalCrossSection = Sum(k,particleDefinition);
      }
    }

    if (verboseLevel > 2)
    {
      G4cout << "__________________________________" << G4endl;
      G4cout << "G4DNADingfelderChargeIncreaseModel - XS INFO START" << G4endl;
      G4cout << "Kinetic energy(eV)=" << k/eV << " particle : " << particleName << G4endl;
      G4cout << "Cross section per water molecule (cm^2)=" << totalCrossSection/cm/cm << G4endl;
      G4cout << "Cross section per water molecule (cm^-1)=" << totalCrossSection*waterDensity/(1./cm) << G4endl;
      //      G4cout << " - Cross section per water molecule (cm^-1)=" << sigma*material->GetAtomicNumDensityVector()[1]/(1./cm) << G4endl;
      G4cout << "G4DNADingfelderChargeIncreaseModel - XS INFO END" << G4endl;
    }

  }

  return totalCrossSection*waterDensity;
//    return totalCrossSection*material->GetAtomicNumDensityVector()[1];

}

Here is the call graph for this function:

IncomingParticleBindingEnergyConstant()

G4double G4DNADingfelderChargeIncreaseModel::IncomingParticleBindingEnergyConstant ( G4ParticleDefinition *  particleDefinition, G4int  finalStateIndex  )

private

Definition at line 408 of file G4DNADingfelderChargeIncreaseModel.cc.

{
  G4DNAGenericIonsManager * instance(G4DNAGenericIonsManager::Instance());
  if (particleDefinition == instance->GetIon("hydrogen"))
    return 13.6 * eV;

  if (particleDefinition == instance->GetIon("alpha+"))
  {
    // Binding energy for    He+ -> He++ + e-    54.509 eV
    // Binding energy for    He  -> He+  + e-    24.587 eV
    return 54.509 * eV;
  }

  if (particleDefinition == instance->GetIon("helium"))
  {
    // Binding energy for    He+ -> He++ + e-    54.509 eV
    // Binding energy for    He  -> He+  + e-    24.587 eV

    if (finalStateIndex == 0)
      return 24.587 * eV;
    return (54.509 + 24.587) * eV;
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Initialise()

void G4DNADingfelderChargeIncreaseModel::Initialise ( const G4ParticleDefinition *  particle, const G4DataVector &    )

virtual

Implements G4VEmModel.

Definition at line 76 of file G4DNADingfelderChargeIncreaseModel.cc.

{

  if (verboseLevel > 3)
  {
    G4cout << "Calling G4DNADingfelderChargeIncreaseModel::Initialise()"
        << G4endl;
  }

  // Energy limits

  G4DNAGenericIonsManager *instance;
  instance = G4DNAGenericIonsManager::Instance();
  G4ParticleDefinition* hydrogenDef = instance->GetIon("hydrogen");
  G4ParticleDefinition* alphaPlusDef = instance->GetIon("alpha+");
  G4ParticleDefinition* heliumDef = instance->GetIon("helium");

  G4String hydrogen;
  G4String alphaPlus;
  G4String helium;

  // LIMITS

  hydrogen = hydrogenDef->GetParticleName();
  lowEnergyLimit[hydrogen] = 100. * eV;
  highEnergyLimit[hydrogen] = 100. * MeV;

  alphaPlus = alphaPlusDef->GetParticleName();
  lowEnergyLimit[alphaPlus] = 1. * keV;
  highEnergyLimit[alphaPlus] = 400. * MeV;

  helium = heliumDef->GetParticleName();
  lowEnergyLimit[helium] = 1. * keV;
  highEnergyLimit[helium] = 400. * MeV;

  //

  if (particle==hydrogenDef)
  {
    SetLowEnergyLimit(lowEnergyLimit[hydrogen]);
    SetHighEnergyLimit(highEnergyLimit[hydrogen]);
  }

  if (particle==alphaPlusDef)
  {
    SetLowEnergyLimit(lowEnergyLimit[alphaPlus]);
    SetHighEnergyLimit(highEnergyLimit[alphaPlus]);
  }

  if (particle==heliumDef)
  {
    SetLowEnergyLimit(lowEnergyLimit[helium]);
    SetHighEnergyLimit(highEnergyLimit[helium]);
  }

  // Final state

  //ALPHA+

  f0[0][0]=1.;
  a0[0][0]=2.25;
  a1[0][0]=-0.75;
  b0[0][0]=-32.10;
  c0[0][0]=0.600;
  d0[0][0]=2.40;
  x0[0][0]=4.60;

  x1[0][0]=-1.;
  b1[0][0]=-1.;

  numberOfPartialCrossSections[0]=1;

  //HELIUM

  f0[0][1]=1.;
  a0[0][1]=2.25;
  a1[0][1]=-0.75;
  b0[0][1]=-30.93;
  c0[0][1]=0.590;
  d0[0][1]=2.35;
  x0[0][1]=4.29;

  f0[1][1]=1.;
  a0[1][1]=2.25;
  a1[1][1]=-0.75;
  b0[1][1]=-32.61;
  c0[1][1]=0.435;
  d0[1][1]=2.70;
  x0[1][1]=4.45;

  x1[0][1]=-1.;
  b1[0][1]=-1.;

  x1[1][1]=-1.;
  b1[1][1]=-1.;

  numberOfPartialCrossSections[1]=2;

  //

  if( verboseLevel>0 )
  {
    G4cout << "Dingfelder charge increase model is initialized " << G4endl
    << "Energy range: "
    << LowEnergyLimit() / keV << " keV - "
    << HighEnergyLimit() / MeV << " MeV for "
    << particle->GetParticleName()
    << G4endl;
  }

  // Initialize water density pointer
  fpMolWaterDensity = G4DNAMolecularMaterial::Instance()->GetNumMolPerVolTableFor(G4Material::GetMaterial("G4_WATER"));

  if (isInitialised)
  { return;}
  fParticleChangeForGamma = GetParticleChangeForGamma();
  isInitialised = true;
}

Here is the call graph for this function:

NumberOfFinalStates()

G4int G4DNADingfelderChargeIncreaseModel::NumberOfFinalStates ( G4ParticleDefinition *  particleDefinition, G4int  finalStateIndex  )

private

Definition at line 366 of file G4DNADingfelderChargeIncreaseModel.cc.

{
    G4DNAGenericIonsManager* instance;
  instance = G4DNAGenericIonsManager::Instance();
  if (particleDefinition == instance->GetIon("hydrogen"))
    return 2;
  if (particleDefinition == instance->GetIon("alpha+"))
    return 2;

  if (particleDefinition == instance->GetIon("helium"))
  {
    if (finalStateIndex == 0)
      return 2;
    return 3;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

private

OutgoingParticleBindingEnergyConstant()

G4double G4DNADingfelderChargeIncreaseModel::OutgoingParticleBindingEnergyConstant ( G4ParticleDefinition *  particleDefinition, G4int  finalStateIndex  )

private

OutgoingParticleDefinition()

G4ParticleDefinition * G4DNADingfelderChargeIncreaseModel::OutgoingParticleDefinition ( G4ParticleDefinition *  particleDefinition, G4int  finalStateIndex  )

private

Definition at line 388 of file G4DNADingfelderChargeIncreaseModel.cc.

{
  G4DNAGenericIonsManager * instance(G4DNAGenericIonsManager::Instance());
  if (particleDefinition == instance->GetIon("hydrogen"))
    return G4Proton::Proton();
  if (particleDefinition == instance->GetIon("alpha+"))
    return instance->GetIon("alpha++");

  if (particleDefinition == instance->GetIon("helium"))
  {
    if (finalStateIndex == 0)
      return instance->GetIon("alpha+");
    return instance->GetIon("alpha++");
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PartialCrossSection()

G4double G4DNADingfelderChargeIncreaseModel::PartialCrossSection ( G4double  energy, G4int  level, const G4ParticleDefinition *  particle  )

private

Definition at line 439 of file G4DNADingfelderChargeIncreaseModel.cc.

{
  G4int particleTypeIndex = 0;
  G4DNAGenericIonsManager *instance;
  instance = G4DNAGenericIonsManager::Instance();

  if (particleDefinition == instance->GetIon("alpha+"))
    particleTypeIndex = 0;
  if (particleDefinition == instance->GetIon("helium"))
    particleTypeIndex = 1;

  //
  // sigma(T) = f0 10 ^ y(log10(T/eV))
  //
  //         /  a0 x + b0                    x < x0
  //         |
  // y(x) = <   a0 x + b0 - c0 (x - x0)^d0   x0 <= x < x1
  //         |
  //         \  a1 x + b1                    x >= x1
  //
  //
  // f0, a0, a1, b0, b1, c0, d0, x0, x1 are parameters that change for protons and helium (0, +, ++)
  //
  // f0 has been added to the code in order to manage partial (shell-dependent) cross sections (if no shell dependence is present. f0=1. Sum of f0 over the considered shells should give 1)
  //
  // From Rad. Phys. and Chem. 59 (2000) 255-275, M. Dingfelder et al.
  // Inelastic-collision cross sections of liquid water for interactions of energetic proton
  //

  if (x1[index][particleTypeIndex] < x0[index][particleTypeIndex])
  {
    //
    // if x1 < x0 means that x1 and b1 will be calculated with the following formula (this piece of code is run on all alphas and not on protons)
    //
    // x1 = x0 + ((a0 - a1)/(c0 * d0)) ^ (1 / (d0 - 1))
    //
    // b1 = (a0 - a1) * x1 + b0 - c0 * (x1 - x0) ^ d0
    //

    x1[index][particleTypeIndex] = x0[index][particleTypeIndex]
        + std::pow((a0[index][particleTypeIndex] - a1[index][particleTypeIndex])
                       / (c0[index][particleTypeIndex]
                           * d0[index][particleTypeIndex]),
                   1. / (d0[index][particleTypeIndex] - 1.));
    b1[index][particleTypeIndex] = (a0[index][particleTypeIndex]
        - a1[index][particleTypeIndex]) * x1[index][particleTypeIndex]
        + b0[index][particleTypeIndex]
        - c0[index][particleTypeIndex]
            * std::pow(x1[index][particleTypeIndex]
                           - x0[index][particleTypeIndex],
                       d0[index][particleTypeIndex]);
  }

  G4double x(std::log10(k / eV));
  G4double y;

  if (x < x0[index][particleTypeIndex])
    y = a0[index][particleTypeIndex] * x + b0[index][particleTypeIndex];
  else if (x < x1[index][particleTypeIndex])
    y = a0[index][particleTypeIndex] * x + b0[index][particleTypeIndex]
        - c0[index][particleTypeIndex]
            * std::pow(x - x0[index][particleTypeIndex],
                       d0[index][particleTypeIndex]);
  else
    y = a1[index][particleTypeIndex] * x + b1[index][particleTypeIndex];

  return f0[index][particleTypeIndex] * std::pow(10., y) * m * m;

}

Here is the call graph for this function:

Here is the caller graph for this function:

RandomSelect()

G4int G4DNADingfelderChargeIncreaseModel::RandomSelect ( G4double  energy, const G4ParticleDefinition *  particle  )

private

Definition at line 513 of file G4DNADingfelderChargeIncreaseModel.cc.

{
  G4int particleTypeIndex = 0;
  G4DNAGenericIonsManager *instance;
  instance = G4DNAGenericIonsManager::Instance();

  if (particleDefinition == instance->GetIon("hydrogen"))
    return 0;
  if (particleDefinition == instance->GetIon("alpha+"))
    particleTypeIndex = 0;
  if (particleDefinition == instance->GetIon("helium"))
    particleTypeIndex = 1;

  const G4int n = numberOfPartialCrossSections[particleTypeIndex];
  G4double* values(new G4double[n]);
  G4double value = 0;
  G4int i = n;

  while (i > 0)
  {
    i--;
    values[i] = PartialCrossSection(k, i, particleDefinition);
    value += values[i];
  }

  value *= G4UniformRand();

  i = n;
  while (i > 0)
  {
    i--;

    if (values[i] > value)
      break;

    value -= values[i];
  }

  delete[] values;

  return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SampleSecondaries()

void G4DNADingfelderChargeIncreaseModel::SampleSecondaries ( std::vector< G4DynamicParticle *> *  fvect, const G4MaterialCutsCouple *  , const G4DynamicParticle *  aDynamicParticle, G4double  tmin, G4double  maxEnergy  )

virtual

Implements G4VEmModel.

Definition at line 298 of file G4DNADingfelderChargeIncreaseModel.cc.

{
  if (verboseLevel > 3)
  {
    G4cout
        << "Calling SampleSecondaries() of G4DNADingfelderChargeIncreaseModel"
        << G4endl;
  }
  
  if (!statCode) fParticleChangeForGamma->ProposeLocalEnergyDeposit(0.);
  
  G4ParticleDefinition* definition = aDynamicParticle->GetDefinition();

  G4double particleMass = definition->GetPDGMass();

  G4double inK = aDynamicParticle->GetKineticEnergy();

  G4int finalStateIndex = RandomSelect(inK,definition);

  G4int n = NumberOfFinalStates(definition,finalStateIndex);

  G4double outK = 0.;
  
  if (!statCode) outK = inK - IncomingParticleBindingEnergyConstant(definition,finalStateIndex);

  else outK = inK;
  
  if (statCode) 
    fParticleChangeForGamma->ProposeLocalEnergyDeposit(IncomingParticleBindingEnergyConstant(definition,finalStateIndex));

  fParticleChangeForGamma->ProposeTrackStatus(fStopAndKill);

  G4DNAGenericIonsManager* instance;
  instance = G4DNAGenericIonsManager::Instance();

  G4double electronK;
  if (definition == instance->GetIon("hydrogen")) electronK = inK*electron_mass_c2/proton_mass_c2;
  else electronK = inK*electron_mass_c2/(particleMass);

  if (outK<0)
  {
    G4Exception("G4DNADingfelderChargeIncreaseModel::SampleSecondaries","em0004",
        FatalException,"Final kinetic energy is negative.");
  }

  G4DynamicParticle* dp = new G4DynamicParticle(OutgoingParticleDefinition(definition,finalStateIndex),
      aDynamicParticle->GetMomentumDirection(),
      outK);

  fvect->push_back(dp);

  n = n - 1;

  while (n>0)
  {
    n--;
    fvect->push_back(new G4DynamicParticle
        (G4Electron::Electron(), aDynamicParticle->GetMomentumDirection(), electronK) );
  }
}

Here is the call graph for this function:

SelectStationary()

void G4DNADingfelderChargeIncreaseModel::SelectStationary ( G4bool  input )

inline

Definition at line 122 of file G4DNADingfelderChargeIncreaseModel.hh.

{ 
    statCode = input; 
}        

Sum()

G4double G4DNADingfelderChargeIncreaseModel::Sum ( G4double  energy, const G4ParticleDefinition *  particle  )

private

Definition at line 559 of file G4DNADingfelderChargeIncreaseModel.cc.

{
  G4int particleTypeIndex = 0;
  G4DNAGenericIonsManager *instance;
  instance = G4DNAGenericIonsManager::Instance();

  if (particleDefinition == instance->GetIon("alpha+"))
    particleTypeIndex = 0;
  if (particleDefinition == instance->GetIon("helium"))
    particleTypeIndex = 1;

  G4double totalCrossSection = 0.;

  for (G4int i = 0; i < numberOfPartialCrossSections[particleTypeIndex]; i++)
  {
    totalCrossSection += PartialCrossSection(k, i, particleDefinition);
  }
  return totalCrossSection;
}

Here is the call graph for this function:

Here is the caller graph for this function:

WaterBindingEnergyConstant()

G4double G4DNADingfelderChargeIncreaseModel::WaterBindingEnergyConstant ( G4ParticleDefinition *  aParticleDefinition, G4int  finalStateIndex  )

private

Member Data Documentation

a0

G4double G4DNADingfelderChargeIncreaseModel::a0[2][2]

private

Definition at line 93 of file G4DNADingfelderChargeIncreaseModel.hh.

a1

G4double G4DNADingfelderChargeIncreaseModel::a1[2][2]

private

Definition at line 94 of file G4DNADingfelderChargeIncreaseModel.hh.

b0

G4double G4DNADingfelderChargeIncreaseModel::b0[2][2]

private

Definition at line 95 of file G4DNADingfelderChargeIncreaseModel.hh.

b1

G4double G4DNADingfelderChargeIncreaseModel::b1[2][2]

private

Definition at line 96 of file G4DNADingfelderChargeIncreaseModel.hh.

c0

G4double G4DNADingfelderChargeIncreaseModel::c0[2][2]

private

Definition at line 97 of file G4DNADingfelderChargeIncreaseModel.hh.

d0

G4double G4DNADingfelderChargeIncreaseModel::d0[2][2]

private

Definition at line 98 of file G4DNADingfelderChargeIncreaseModel.hh.

f0

G4double G4DNADingfelderChargeIncreaseModel::f0[2][2]

private

Definition at line 92 of file G4DNADingfelderChargeIncreaseModel.hh.

fParticleChangeForGamma

G4ParticleChangeForGamma* G4DNADingfelderChargeIncreaseModel::fParticleChangeForGamma

protected

Definition at line 69 of file G4DNADingfelderChargeIncreaseModel.hh.

fpMolWaterDensity

const std::vector<G4double>* G4DNADingfelderChargeIncreaseModel::fpMolWaterDensity

private

Definition at line 74 of file G4DNADingfelderChargeIncreaseModel.hh.

highEnergyLimit

std::map<G4String,G4double,std::less<G4String> > G4DNADingfelderChargeIncreaseModel::highEnergyLimit

private

Definition at line 77 of file G4DNADingfelderChargeIncreaseModel.hh.

isInitialised

G4bool G4DNADingfelderChargeIncreaseModel::isInitialised

private

Definition at line 79 of file G4DNADingfelderChargeIncreaseModel.hh.

lowEnergyLimit

std::map<G4String,G4double,std::less<G4String> > G4DNADingfelderChargeIncreaseModel::lowEnergyLimit

private

Definition at line 76 of file G4DNADingfelderChargeIncreaseModel.hh.

numberOfPartialCrossSections

G4int G4DNADingfelderChargeIncreaseModel::numberOfPartialCrossSections[2]

private

Definition at line 90 of file G4DNADingfelderChargeIncreaseModel.hh.

statCode

G4bool G4DNADingfelderChargeIncreaseModel::statCode

private

Definition at line 79 of file G4DNADingfelderChargeIncreaseModel.hh.

verboseLevel

G4int G4DNADingfelderChargeIncreaseModel::verboseLevel

private

Definition at line 80 of file G4DNADingfelderChargeIncreaseModel.hh.

x0

G4double G4DNADingfelderChargeIncreaseModel::x0[2][2]

private

Definition at line 99 of file G4DNADingfelderChargeIncreaseModel.hh.

x1

G4double G4DNADingfelderChargeIncreaseModel::x1[2][2]

private

Definition at line 100 of file G4DNADingfelderChargeIncreaseModel.hh.

---

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

• G4DNADingfelderChargeIncreaseModel.hh
• G4DNADingfelderChargeIncreaseModel.cc