The G4DNAPTBElasticModel class This class implements the elastic model for the DNA materials and precursors. More...

#include <G4DNAPTBElasticModel.hh>

Inheritance diagram for G4DNAPTBElasticModel:

Public Member Functions
virtual G4double	CrossSectionPerVolume (const G4Material material, const G4String &materialName, const G4ParticleDefinition p, G4double ekin, G4double emin, G4double emax)
	CrossSectionPerVolume This method is mandatory for any model class. It finds and return the cross section value for the current material, particle and energy values. The number of molecule per volume is not used here but in the G4DNAModelInterface class. More...

	G4DNAPTBElasticModel (const G4String &applyToMaterial="all", const G4ParticleDefinition *p=0, const G4String &nam="DNAPTBElasticModel")
	G4DNAPTBElasticModel Constructor. More...

G4double	GetHighELimit (const G4String &material, const G4String &particle)
	GetHighEnergyLimit. More...

G4double	GetLowELimit (const G4String &material, const G4String &particle)
	GetLowEnergyLimit. More...

G4String	GetName ()
	GetName. More...

virtual void	Initialise (const G4ParticleDefinition particle, const G4DataVector &, G4ParticleChangeForGamma fpChangeForGamme=nullptr)
	Initialise Mandatory method for every model class. The material/particle for which the model can be used have to be added here through the AddCrossSectionData method. Then the LoadCrossSectionData method must be called to trigger the load process. Scale factors to be applied to the cross section can be defined here. More...

G4bool	IsMaterialDefine (const G4String &materialName)
	IsMaterialDefine Check if the given material is defined in the simulation. More...

G4bool	IsMaterialExistingInModel (const G4String &materialName)
	IsMaterialExistingInModel Check if the given material is defined in the current model class. More...

G4bool	IsParticleExistingInModelForMaterial (const G4String &particleName, const G4String &materialName)
	IsParticleExistingInModelForMaterial To check two things: 1- is the material existing in model ? 2- if yes, is the particle defined for that material ? More...

virtual void	SampleSecondaries (std::vector< G4DynamicParticle * > , const G4MaterialCutsCouple , const G4String &materialName, const G4DynamicParticle , G4ParticleChangeForGamma particleChangeForGamma, G4double tmin, G4double tmax)
	SampleSecondaries Method called after CrossSectionPerVolume if the process is the one which is selected (according to the sampling on the calculated path length). Here, the characteristics of the incident and created (if any) particle(s) are set (energy, momentum ...). More...

void	SetHighELimit (const G4String &material, const G4String &particle, G4double lim)
	SetHighEnergyLimit. More...

void	SetLowELimit (const G4String &material, const G4String &particle, G4double lim)
	SetLowEnergyLimit. More...

virtual	~G4DNAPTBElasticModel ()
	~G4DNAPTBElasticModel Destructor More...

Protected Types
typedef std::map< G4String, G4double >::const_iterator	ItCompoMapData

typedef std::map< G4String, std::map< G4String, G4double > >	RatioMapData

typedef std::map< G4String, std::map< G4String, G4DNACrossSectionDataSet *, std::less< G4String > > >	TableMapData

Protected Member Functions
void	AddCrossSectionData (G4String materialName, G4String particleName, G4String fileCS, G4double scaleFactor)
	AddCrossSectionData Method used during the initialization of the model class to add a new material. It adds a material to the model and fills vectors with informations. Not every model needs differential cross sections. More...

void	AddCrossSectionData (G4String materialName, G4String particleName, G4String fileCS, G4String fileDiffCS, G4double scaleFactor)
	AddCrossSectionData Method used during the initialization of the model class to add a new material. It adds a material to the model and fills vectors with informations. More...

std::vector< G4String >	BuildApplyToMatVect (const G4String &materials)
	BuildApplyToMatVect Build the material name vector which is used to know the materials the user want to include in the model. More...

void	EnableForMaterialAndParticle (const G4String &materialName, const G4String &particleName)
	EnableMaterialAndParticle. More...

TableMapData *	GetTableData ()
	GetTableData. More...

void	LoadCrossSectionData (const G4String &particleName)
	LoadCrossSectionData Method to loop on all the registered materials in the model and load the corresponding data. More...

G4int	RandomSelectShell (G4double k, const G4String &particle, const G4String &materialName)
	RandomSelectShell Method to randomely select a shell from the data table uploaded. The size of the table (number of columns) is used to determine the total number of possible shells. More...

void	ReadAndSaveCSFile (const G4String &materialName, const G4String &particleName, const G4String &file, G4double scaleFactor)
	ReadAndSaveCSFile Read and save a "simple" cross section file : use of G4DNACrossSectionDataSet->loadData() More...

Private Types
typedef std::map< G4String, std::map< G4String, std::map< double, std::map< double, double > > > >	TriDimensionMap

typedef std::map< G4String, std::map< G4String, std::map< double, std::vector< double > > > >	VecMap

Private Member Functions
	G4DNAPTBElasticModel (G4DNAPTBElasticModel &)

G4double	LinLinInterpolate (G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2)
	LinLinInterpolate. More...

G4double	LinLogInterpolate (G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2)
	LinLogInterpolate. More...

G4double	LogLogInterpolate (G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2)
	LogLogInterpolate. More...

G4DNAPTBElasticModel &	operator= (const G4DNAPTBElasticModel &right)

G4double	QuadInterpolator (G4double e11, G4double e12, G4double e21, G4double e22, G4double x11, G4double x12, G4double x21, G4double x22, G4double t1, G4double t2, G4double t, G4double e)
	QuadInterpolator. More...

G4double	RandomizeCosTheta (G4double k, const G4String &materialName)
	RandomizeCosTheta. More...

void	ReadDiffCSFile (const G4String &materialName, const G4String &particleName, const G4String &file, const G4double)
	ReadDiffCSFile Method to read the differential cross section files. This method is not standard yet so every model must implement its own. More...

G4double	Theta (G4ParticleDefinition *fParticleDefinition, G4double k, G4double integrDiff, const G4String &materialName)
	Theta To return an angular theta value from the differential file. This method uses interpolations to calculate the theta value. More...

Private Attributes
TriDimensionMap	diffCrossSectionData
	A map: [materialName][particleName]=DiffCrossSectionTable. More...

VecMap	eValuesVect

std::map< G4String, std::map< G4String, G4double > >	fHighEnergyLimits
	List the high energy limits. More...

G4double	fKillBelowEnergy
	energy kill limit More...

std::map< G4String, std::map< G4String, G4double > >	fLowEnergyLimits
	List the low energy limits. More...

std::vector< G4String >	fModelCSFiles
	List the cross section data files. More...

std::vector< G4String >	fModelDiffCSFiles
	List the differential corss section data files. More...

std::vector< G4String >	fModelMaterials
	List the materials that can be activated (and will be by default) within the model. More...

std::vector< G4String >	fModelParticles
	List the particles that can be activated within the model. More...

std::vector< G4double >	fModelScaleFactors
	List the model scale factors (they could change with material) More...

G4String	fName
	model name More...

const G4String	fStringOfMaterials
	fStringOfMaterials The user can decide to specify by hand which are the materials the be activated among those implemented in the model. If the user does then only the specified materials contained in this string variable will be activated. The string is like: mat1/mat2/mat3/mat4 More...

TableMapData	fTableData
	fTableData It contains the cross section data and can be used like: dataTable=fTableData[material][particle] More...

std::map< G4String, double >	killBelowEnergyTable
	map to save the different energy kill limits for the materials More...

std::map< G4String, std::map< G4String, std::vector< double > > >	tValuesVec
	map with vectors containing all the incident (T) energy of the differential file More...

G4int	verboseLevel
	verbose level More...

Detailed Description

The G4DNAPTBElasticModel class This class implements the elastic model for the DNA materials and precursors.

Definition at line 48 of file G4DNAPTBElasticModel.hh.

Member Typedef Documentation

◆ ItCompoMapData

typedef std::map<G4String,G4double>::const_iterator G4VDNAModel::ItCompoMapData

protectedinherited

Definition at line 185 of file G4VDNAModel.hh.

◆ RatioMapData

typedef std::map<G4String,std::map<G4String, G4double> > G4VDNAModel::RatioMapData

protectedinherited

Definition at line 184 of file G4VDNAModel.hh.

◆ TableMapData

typedef std::map<G4String, std::map<G4String,G4DNACrossSectionDataSet*,std::less<G4String> > > G4VDNAModel::TableMapData

protectedinherited

Definition at line 183 of file G4VDNAModel.hh.

◆ TriDimensionMap

typedef std::map<G4String, std::map<G4String, std::map<double, std::map<double, double> > > > G4DNAPTBElasticModel::TriDimensionMap

private

Definition at line 125 of file G4DNAPTBElasticModel.hh.

◆ VecMap

typedef std::map<G4String, std::map<G4String, std::map<double, std::vector<double> > > > G4DNAPTBElasticModel::VecMap

private

Definition at line 128 of file G4DNAPTBElasticModel.hh.

Constructor & Destructor Documentation

◆ G4DNAPTBElasticModel() [1/2]

G4DNAPTBElasticModel::G4DNAPTBElasticModel	(	const G4String &	applyToMaterial = `"all"`,
		const G4ParticleDefinition *	p = `0`,
		const G4String &	nam = `"DNAPTBElasticModel"`
	)

G4DNAPTBElasticModel Constructor.

Parameters

applyToMaterial
p
nam

Definition at line 38 of file G4DNAPTBElasticModel.cc.

    : G4VDNAModel(nam, applyToMaterial)
{
    fKillBelowEnergy = 10*eV; // will be override by the limits defined for each material
 
    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 << "PTB Elastic model is constructed " << G4endl;
    }
}

References eV, fKillBelowEnergy, G4cout, G4endl, and verboseLevel.

◆ ~G4DNAPTBElasticModel()

G4DNAPTBElasticModel::~G4DNAPTBElasticModel ( )

virtual

~G4DNAPTBElasticModel Destructor

Definition at line 60 of file G4DNAPTBElasticModel.cc.

{
 
}

◆ G4DNAPTBElasticModel() [2/2]

G4DNAPTBElasticModel::G4DNAPTBElasticModel ( G4DNAPTBElasticModel & )

private

Member Function Documentation

◆ AddCrossSectionData() [1/2]

void G4VDNAModel::AddCrossSectionData	(	G4String	materialName,
		G4String	particleName,
		G4String	fileCS,
		G4double	scaleFactor
	)

protectedinherited

AddCrossSectionData Method used during the initialization of the model class to add a new material. It adds a material to the model and fills vectors with informations. Not every model needs differential cross sections.

Parameters

materialName
particleName
fileCS
scaleFactor

Definition at line 67 of file G4VDNAModel.cc.

{
    fModelMaterials.push_back(materialName);
    fModelParticles.push_back(particleName);
    fModelCSFiles.push_back(fileCS);
    fModelScaleFactors.push_back(scaleFactor);
}

References G4VDNAModel::fModelCSFiles, G4VDNAModel::fModelMaterials, G4VDNAModel::fModelParticles, and G4VDNAModel::fModelScaleFactors.

◆ AddCrossSectionData() [2/2]

void G4VDNAModel::AddCrossSectionData	(	G4String	materialName,
		G4String	particleName,
		G4String	fileCS,
		G4String	fileDiffCS,
		G4double	scaleFactor
	)

protectedinherited

AddCrossSectionData Method used during the initialization of the model class to add a new material. It adds a material to the model and fills vectors with informations.

Parameters

materialName
particleName
fileCS
fileDiffCS
scaleFactor

Definition at line 58 of file G4VDNAModel.cc.

{
    fModelMaterials.push_back(materialName);
    fModelParticles.push_back(particleName);
    fModelCSFiles.push_back(fileCS);
    fModelDiffCSFiles.push_back(fileDiffCS);
    fModelScaleFactors.push_back(scaleFactor);
}

References G4VDNAModel::fModelCSFiles, G4VDNAModel::fModelDiffCSFiles, G4VDNAModel::fModelMaterials, G4VDNAModel::fModelParticles, and G4VDNAModel::fModelScaleFactors.

Referenced by Initialise(), G4DNAPTBExcitationModel::Initialise(), and G4DNAPTBIonisationModel::Initialise().

◆ BuildApplyToMatVect()

std::vector< G4String > G4VDNAModel::BuildApplyToMatVect ( const G4String & materials )

protectedinherited

BuildApplyToMatVect Build the material name vector which is used to know the materials the user want to include in the model.

Parameters

materials

Returns: a vector with all the material names

Definition at line 139 of file G4VDNAModel.cc.

{
    // output material vector
    std::vector<G4String> materialVect;
 
    // if we don't find any "/" then it means we only have one "material" (could be the "all" option)
    if(materials.find("/")==std::string::npos)
    {
        // we add the material to the output vector
        materialVect.push_back(materials);
    }
    // if we have several materials listed in the string then we must retrieve them
    else
    {
        G4String materialsNonIdentified = materials;
 
        while(materialsNonIdentified.find_first_of("/") != std::string::npos)
        {
            // we select the first material and stop at the "/" caracter
            G4String mat = materialsNonIdentified.substr(0, materialsNonIdentified.find_first_of("/"));
            materialVect.push_back(mat);
 
            // we remove the previous material from the materialsNonIdentified string
            materialsNonIdentified = materialsNonIdentified.substr(materialsNonIdentified.find_first_of("/")+1,
                                                                   materialsNonIdentified.size()-materialsNonIdentified.find_first_of("/"));
        }
 
        // we don't find "/" anymore, it means we only have one material string left
        // we get it
        materialVect.push_back(materialsNonIdentified);
    }
 
    return materialVect;
}

Referenced by G4VDNAModel::LoadCrossSectionData().

◆ CrossSectionPerVolume()

G4double G4DNAPTBElasticModel::CrossSectionPerVolume	(	const G4Material *	material,
		const G4String &	materialName,
		const G4ParticleDefinition *	p,
		G4double	ekin,
		G4double	emin,
		G4double	emax
	)

virtual

CrossSectionPerVolume This method is mandatory for any model class. It finds and return the cross section value for the current material, particle and energy values. The number of molecule per volume is not used here but in the G4DNAModelInterface class.

Parameters

material
materialName
p
ekin
emin
emax

Returns: the cross section value

Implements G4VDNAModel.

Definition at line 295 of file G4DNAPTBElasticModel.cc.

{
    if (verboseLevel > 3)
        G4cout << "Calling CrossSectionPerVolume() of G4DNAPTBElasticModel" << G4endl;
 
    // Get the name of the current particle
    const G4String& particleName = p->GetParticleName();
 
    // set killBelowEnergy value for current material
    fKillBelowEnergy = GetLowELimit(materialName, particleName);
 
    // initialise the return value (cross section) to zero
    G4double sigma(0);
 
    // check if we are below the high energy limit
    if (ekin < GetHighELimit(materialName, particleName) )
    {
        // This is used to kill the particle if its kinetic energy is below fKillBelowEnergy.
        // If the energy is lower then we return a maximum cross section and thus the SampleSecondaries method will be called for sure.
        // SampleSecondaries will remove the particle from the simulation.
        //
        //SI : XS must not be zero otherwise sampling of secondaries method ignored
        if (ekin < fKillBelowEnergy) return DBL_MAX;
 
        // Get the tables with the cross section data
        TableMapData* tableData = GetTableData();
 
        // Retrieve the cross section value
        sigma = (*tableData)[materialName][particleName]->FindValue(ekin);
    }
 
    if (verboseLevel > 2)
    {
        G4cout << "__________________________________" << G4endl;
        G4cout << "°°° G4DNAPTBElasticModel - XS INFO START" << G4endl;
        G4cout << "°°° Kinetic energy(eV)=" << ekin/eV << " particle : " << particleName << G4endl;
        G4cout << "°°° Cross section per molecule (cm^2)=" << sigma/cm/cm << G4endl;
        G4cout << "°°° G4DNAPTBElasticModel - XS INFO END" << G4endl;
    }
 
    // Return the cross section
    return sigma;
}

References cm, DBL_MAX, eV, fKillBelowEnergy, G4cout, G4endl, G4VDNAModel::GetHighELimit(), G4VDNAModel::GetLowELimit(), G4ParticleDefinition::GetParticleName(), G4VDNAModel::GetTableData(), and verboseLevel.

◆ EnableForMaterialAndParticle()

void G4VDNAModel::EnableForMaterialAndParticle	(	const G4String &	materialName,
		const G4String &	particleName
	)

protectedinherited

EnableMaterialAndParticle.

Parameters

materialName
particleName	Meant to fill fTableData with 0 for the specified material and particle, therefore allowing the ModelInterface class to proceed with the material and particle even if no data are registered here. The data should obviously be registered somewhere in the child class. This method is here to allow an easy use of the no-ModelInterface dna models within the ModelInterface system.

Definition at line 134 of file G4VDNAModel.cc.

{
    fTableData[materialName][particleName] = 0;
}

References G4VDNAModel::fTableData.

Referenced by G4DNAVacuumModel::Initialise(), and G4DNADummyModel::Initialise().

◆ GetHighELimit()

G4double G4VDNAModel::GetHighELimit	(	const G4String &	material,
		const G4String &	particle
	)

inlineinherited

GetHighEnergyLimit.

Parameters

material
particle

Returns: fHighEnergyLimits[material][particle]

Definition at line 153 of file G4VDNAModel.hh.

153{return fHighEnergyLimits[material][particle];}

G4VDNAModel::fHighEnergyLimits

std::map< G4String, std::map< G4String, G4double > > fHighEnergyLimits

List the high energy limits.

Definition: G4VDNAModel.hh:301

eplot.material

string material

Definition: eplot.py:19

References G4VDNAModel::fHighEnergyLimits, and eplot::material.

Referenced by CrossSectionPerVolume(), G4DNAPTBExcitationModel::CrossSectionPerVolume(), G4DNAPTBIonisationModel::CrossSectionPerVolume(), SampleSecondaries(), and G4DNAPTBIonisationModel::SampleSecondaries().

◆ GetLowELimit()

G4double G4VDNAModel::GetLowELimit	(	const G4String &	material,
		const G4String &	particle
	)

inlineinherited

GetLowEnergyLimit.

Parameters

material
particle

Returns: fLowEnergyLimits[material][particle]

Definition at line 161 of file G4VDNAModel.hh.

161{return fLowEnergyLimits[material][particle];}

G4VDNAModel::fLowEnergyLimits

std::map< G4String, std::map< G4String, G4double > > fLowEnergyLimits

List the low energy limits.

Definition: G4VDNAModel.hh:300

References G4VDNAModel::fLowEnergyLimits, and eplot::material.

Referenced by CrossSectionPerVolume(), G4DNAPTBExcitationModel::CrossSectionPerVolume(), G4DNAPTBIonisationModel::CrossSectionPerVolume(), SampleSecondaries(), and G4DNAPTBIonisationModel::SampleSecondaries().

◆ GetName()

G4String G4VDNAModel::GetName ( )

inlineinherited

GetName.

Returns: the name of the model

Definition at line 145 of file G4VDNAModel.hh.

145{return fName;}

G4VDNAModel::fName

G4String fName

model name

Definition: G4VDNAModel.hh:303

References G4VDNAModel::fName.

Referenced by G4VDNAModel::IsMaterialDefine().

◆ GetTableData()

TableMapData * G4VDNAModel::GetTableData ( )

inlineprotectedinherited

GetTableData.

Returns: a pointer to a map with the following structure: [materialName][particleName]=G4DNACrossSectionDataSet*

Definition at line 193 of file G4VDNAModel.hh.

193{return &fTableData;}

References G4VDNAModel::fTableData.

Referenced by CrossSectionPerVolume(), G4DNAPTBExcitationModel::CrossSectionPerVolume(), G4DNAPTBIonisationModel::CrossSectionPerVolume(), and G4VDNAModel::RandomSelectShell().

◆ Initialise()

void G4DNAPTBElasticModel::Initialise	(	const G4ParticleDefinition *	particle,
		const G4DataVector &	,
		G4ParticleChangeForGamma *	fpChangeForGamme = `nullptr`
	)

virtual

Initialise Mandatory method for every model class. The material/particle for which the model can be used have to be added here through the AddCrossSectionData method. Then the LoadCrossSectionData method must be called to trigger the load process. Scale factors to be applied to the cross section can be defined here.

Implements G4VDNAModel.

Definition at line 67 of file G4DNAPTBElasticModel.cc.

{
    if (verboseLevel > 3)
        G4cout << "Calling G4DNAPTBElasticModel::Initialise()" << G4endl;
 
    G4double scaleFactor = 1e-16*cm*cm;
 
    G4ParticleDefinition* electronDef = G4Electron::ElectronDefinition();
 
    //*******************************************************
    // Cross section data
    //*******************************************************
 
    if(particle == electronDef)
    {
        G4String particleName = particle->GetParticleName();
 
        AddCrossSectionData("THF",
                            particleName,
                            "dna/sigma_elastic_e-_PTB_THF",
                            "dna/sigmadiff_cumulated_elastic_e-_PTB_THF",
                            scaleFactor);
        SetLowELimit("THF", particleName, 10*eV);
        SetHighELimit("THF", particleName, 1*keV);
 
        AddCrossSectionData("PY",
                            particleName,
                            "dna/sigma_elastic_e-_PTB_PY",
                            "dna/sigmadiff_cumulated_elastic_e-_PTB_PY",
                            scaleFactor);
        SetLowELimit("PY", particleName, 10*eV);
        SetHighELimit("PY", particleName, 1*keV);
 
        AddCrossSectionData("PU",
                            particleName,
                            "dna/sigma_elastic_e-_PTB_PU",
                            "dna/sigmadiff_cumulated_elastic_e-_PTB_PU",
                            scaleFactor);
        SetLowELimit("PU", particleName, 10*eV);
        SetHighELimit("PU", particleName, 1*keV);
 
        AddCrossSectionData("TMP",
                            particleName,
                            "dna/sigma_elastic_e-_PTB_TMP",
                            "dna/sigmadiff_cumulated_elastic_e-_PTB_TMP",
                            scaleFactor);
        SetLowELimit("TMP", particleName, 10*eV);
        SetHighELimit("TMP", particleName, 1*keV);
 
        AddCrossSectionData("G4_WATER",
                            particleName,
                            "dna/sigma_elastic_e_champion",
                            "dna/sigmadiff_cumulated_elastic_e_champion",
                            scaleFactor);
        SetLowELimit("G4_WATER", particleName, 10*eV);
        SetHighELimit("G4_WATER", particleName, 1*keV);
 
        // DNA materials
        //
        AddCrossSectionData("backbone_THF",
                            particleName,
                            "dna/sigma_elastic_e-_PTB_THF",
                            "dna/sigmadiff_cumulated_elastic_e-_PTB_THF",
                            scaleFactor*33./30);
        SetLowELimit("backbone_THF", particleName, 10*eV);
        SetHighELimit("backbone_THF", particleName, 1*keV);
 
        AddCrossSectionData("cytosine_PY",
                            particleName,
                            "dna/sigma_elastic_e-_PTB_PY",
                            "dna/sigmadiff_cumulated_elastic_e-_PTB_PY",
                            scaleFactor*42./30);
        SetLowELimit("cytosine_PY", particleName, 10*eV);
        SetHighELimit("cytosine_PY", particleName, 1*keV);
 
        AddCrossSectionData("thymine_PY",
                            particleName,
                            "dna/sigma_elastic_e-_PTB_PY",
                            "dna/sigmadiff_cumulated_elastic_e-_PTB_PY",
                            scaleFactor*48./30);
        SetLowELimit("thymine_PY", particleName, 10*eV);
        SetHighELimit("thymine_PY", particleName, 1*keV);
 
        AddCrossSectionData("adenine_PU",
                            particleName,
                            "dna/sigma_elastic_e-_PTB_PU",
                            "dna/sigmadiff_cumulated_elastic_e-_PTB_PU",
                            scaleFactor*50./44);
        SetLowELimit("adenine_PU", particleName, 10*eV);
        SetHighELimit("adenine_PU", particleName, 1*keV);
 
        AddCrossSectionData("guanine_PU",
                            particleName,
                            "dna/sigma_elastic_e-_PTB_PU",
                            "dna/sigmadiff_cumulated_elastic_e-_PTB_PU",
                            scaleFactor*56./44);
        SetLowELimit("guanine_PU", particleName, 10*eV);
        SetHighELimit("guanine_PU", particleName, 1*keV);
 
        AddCrossSectionData("backbone_TMP",
                            particleName,
                            "dna/sigma_elastic_e-_PTB_TMP",
                            "dna/sigmadiff_cumulated_elastic_e-_PTB_TMP",
                            scaleFactor*33./50);
        SetLowELimit("backbone_TMP", particleName, 10*eV);
        SetHighELimit("backbone_TMP", particleName, 1*keV);
    }
 
    //*******************************************************
    // Load the data
    //*******************************************************
 
    LoadCrossSectionData(particle->GetParticleName() );
 
    //*******************************************************
    // Verbose output
    //*******************************************************
 
    if (verboseLevel > 2)
        G4cout << "Loaded cross section files for PTB Elastic model" << G4endl;
 
    if( verboseLevel>0 )
    {
        G4cout << "PTB Elastic model is initialized " << G4endl;
    }
}

References G4VDNAModel::AddCrossSectionData(), cm, G4Electron::ElectronDefinition(), eV, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), keV, G4VDNAModel::LoadCrossSectionData(), G4VDNAModel::SetHighELimit(), G4VDNAModel::SetLowELimit(), and verboseLevel.

◆ IsMaterialDefine()

G4bool G4VDNAModel::IsMaterialDefine ( const G4String & materialName )

inherited

IsMaterialDefine Check if the given material is defined in the simulation.

Parameters

materialName

Returns: true if the material is defined in the simulation

Definition at line 237 of file G4VDNAModel.cc.

{
    // Check if the given material is defined in the simulation
 
    G4bool exist (false);
 
    double matTableSize = G4Material::GetMaterialTable()->size();
 
    for(int i=0;i<matTableSize;i++)
    {
        if(materialName == G4Material::GetMaterialTable()->at(i)->GetName())
        {
            exist = true;
            return exist;
        }
    }
 
    return exist;
}

References G4Material::GetMaterialTable(), and G4VDNAModel::GetName().

◆ IsMaterialExistingInModel()

G4bool G4VDNAModel::IsMaterialExistingInModel ( const G4String & materialName )

inherited

IsMaterialExistingInModel Check if the given material is defined in the current model class.

Parameters

materialName

Returns: true if the material is defined in the model

Definition at line 257 of file G4VDNAModel.cc.

{
    // Check if the given material is defined in the current model class
 
    if (fTableData.find(materialName) == fTableData.end())
    {
        return false;
    }
    else
    {
        return true;
    }
}

References G4VDNAModel::fTableData.

Referenced by G4VDNAModel::IsParticleExistingInModelForMaterial().

◆ IsParticleExistingInModelForMaterial()

G4bool G4VDNAModel::IsParticleExistingInModelForMaterial	(	const G4String &	particleName,
		const G4String &	materialName
	)

inherited

IsParticleExistingInModelForMaterial To check two things: 1- is the material existing in model ? 2- if yes, is the particle defined for that material ?

Parameters

particleName
materialName

Returns: true if the particle/material couple is defined in the model

Definition at line 271 of file G4VDNAModel.cc.

{
    // To check two things:
    // 1- is the material existing in model ?
    // 2- if yes, is the particle defined for that material ?
 
    if(IsMaterialExistingInModel(materialName))
    {
        if (fTableData[materialName].find(particleName) == fTableData[materialName].end())
        {
            return false;
        }
        else return true;
    }
    else return false;
}

References G4VDNAModel::fTableData, and G4VDNAModel::IsMaterialExistingInModel().

◆ LinLinInterpolate()

G4double G4DNAPTBElasticModel::LinLinInterpolate	(	G4double	e1,
		G4double	e2,
		G4double	e,
		G4double	xs1,
		G4double	xs2
	)

private

LinLinInterpolate.

Parameters

e1
e2
e
xs1
xs2

Returns

Definition at line 470 of file G4DNAPTBElasticModel.cc.

{
    G4double d1 = xs1;
    G4double d2 = xs2;
    G4double value = (d1 + (d2 - d1)*(e - e1)/ (e2 - e1));
    return value;
}

References d1, d2, e1, and e2.

Referenced by QuadInterpolator().

◆ LinLogInterpolate()

G4double G4DNAPTBElasticModel::LinLogInterpolate	(	G4double	e1,
		G4double	e2,
		G4double	e,
		G4double	xs1,
		G4double	xs2
	)

private

LinLogInterpolate.

Parameters

e1
e2
e
xs1
xs2

Returns

Definition at line 456 of file G4DNAPTBElasticModel.cc.

{
    G4double d1 = std::log(xs1);
    G4double d2 = std::log(xs2);
    G4double value = std::exp(d1 + (d2 - d1)*(e - e1)/ (e2 - e1));
    return value;
}

References d1, d2, e1, and e2.

◆ LoadCrossSectionData()

void G4VDNAModel::LoadCrossSectionData ( const G4String & particleName )

protectedinherited

LoadCrossSectionData Method to loop on all the registered materials in the model and load the corresponding data.

Definition at line 75 of file G4VDNAModel.cc.

{
    G4String fileElectron, fileDiffElectron;
    G4String materialName, modelParticleName;
    G4double scaleFactor;
 
    // construct applyToMatVect with materials specified by the user
    std::vector<G4String> applyToMatVect = BuildApplyToMatVect(fStringOfMaterials);
 
    // iterate on each material contained into the fStringOfMaterials variable (through applyToMatVect)
    for(unsigned int i=0;i<applyToMatVect.size();++i)
    {
        // We have selected a material coming from applyToMatVect
        // We try to find if this material correspond to a model registered material
        // If it is, then isMatFound becomes true
        G4bool isMatFound = false;
 
        // We iterate on each model registered materials to load the CS data
        // We have to do a for loop because of the "all" option
        // applyToMatVect[i] == "all" implies applyToMatVect.size()=1 and we want to iterate on all registered materials
        for(unsigned int j=0;j<fModelMaterials.size();++j)
        {
            if(applyToMatVect[i] == fModelMaterials[j] || applyToMatVect[i] == "all")
            {
                isMatFound = true;
                materialName = fModelMaterials[j];
                modelParticleName = fModelParticles[j];
                fileElectron = fModelCSFiles[j];
                if(!fModelDiffCSFiles.empty()) fileDiffElectron = fModelDiffCSFiles[j];
                scaleFactor = fModelScaleFactors[j];
 
                ReadAndSaveCSFile(materialName, modelParticleName, fileElectron, scaleFactor);
 
                if(!fModelDiffCSFiles.empty()) ReadDiffCSFile(materialName, modelParticleName, fileDiffElectron, scaleFactor);
 
            }
        }
 
        // check if we found a correspondance, if not: fatal error
        if(!isMatFound)
        {
            std::ostringstream oss;
            oss << applyToMatVect[i] << " material was not found. It means the material specified in the UserPhysicsList is not a model material for ";
            oss << particleName;
            G4Exception("G4VDNAModel::LoadCrossSectionData","em0003",
                        FatalException, oss.str().c_str());
            return;
        }
    }
}

References G4VDNAModel::BuildApplyToMatVect(), FatalException, G4VDNAModel::fModelCSFiles, G4VDNAModel::fModelDiffCSFiles, G4VDNAModel::fModelMaterials, G4VDNAModel::fModelParticles, G4VDNAModel::fModelScaleFactors, G4VDNAModel::fStringOfMaterials, G4Exception(), G4VDNAModel::ReadAndSaveCSFile(), and G4VDNAModel::ReadDiffCSFile().

Referenced by Initialise(), G4DNAPTBExcitationModel::Initialise(), and G4DNAPTBIonisationModel::Initialise().

◆ LogLogInterpolate()

G4double G4DNAPTBElasticModel::LogLogInterpolate	(	G4double	e1,
		G4double	e2,
		G4double	e,
		G4double	xs1,
		G4double	xs2
	)

private

LogLogInterpolate.

Parameters

e1
e2
e
xs1
xs2

Returns

Definition at line 484 of file G4DNAPTBElasticModel.cc.

{
    G4double a = (std::log10(xs2)-std::log10(xs1)) / (std::log10(e2)-std::log10(e1));
    G4double b = std::log10(xs2) - a*std::log10(e2);
    G4double sigma = a*std::log10(e) + b;
    G4double value = (std::pow(10.,sigma));
    return value;
}

References e1, and e2.

◆ operator=()

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

private

◆ QuadInterpolator()

G4double G4DNAPTBElasticModel::QuadInterpolator	(	G4double	e11,
		G4double	e12,
		G4double	e21,
		G4double	e22,
		G4double	x11,
		G4double	x12,
		G4double	x21,
		G4double	x22,
		G4double	t1,
		G4double	t2,
		G4double	t,
		G4double	e
	)

private

QuadInterpolator.

Parameters

e11
e12
e21
e22
x11
x12
x21
x22
t1
t2
t
e

Returns

Definition at line 499 of file G4DNAPTBElasticModel.cc.

{
    // Log-Log
 /*
  G4double interpolatedvalue1 = LogLogInterpolate(e11, e12, e, xs11, xs12);
  G4double interpolatedvalue2 = LogLogInterpolate(e21, e22, e, xs21, xs22);
  G4double value = LogLogInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
 
 
  // Lin-Log
  G4double interpolatedvalue1 = LinLogInterpolate(e11, e12, e, xs11, xs12);
  G4double interpolatedvalue2 = LinLogInterpolate(e21, e22, e, xs21, xs22);
  G4double value = LinLogInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
*/
 
    // Lin-Lin
    G4double interpolatedvalue1 = LinLinInterpolate(e11, e12, e, xs11, xs12);
    G4double interpolatedvalue2 = LinLinInterpolate(e21, e22, e, xs21, xs22);
    G4double value = LinLinInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
 
    return value;
}

References LinLinInterpolate().

Referenced by Theta().

◆ RandomizeCosTheta()

G4double G4DNAPTBElasticModel::RandomizeCosTheta	(	G4double	k,
		const G4String &	materialName
	)

private

RandomizeCosTheta.

Parameters

k
materialName

Returns

Definition at line 529 of file G4DNAPTBElasticModel.cc.

{
    G4double integrdiff=0;
    G4double uniformRand=G4UniformRand();
    integrdiff = uniformRand;
 
    G4double theta=0.;
    G4double cosTheta=0.;
    theta = Theta(G4Electron::ElectronDefinition(),k/eV,integrdiff, materialName);
 
    cosTheta= std::cos(theta*pi/180);
 
    return cosTheta;
}

References G4Electron::ElectronDefinition(), eV, G4UniformRand, pi, Theta(), and anonymous_namespace{G4HadPhaseSpaceGenbod.cc}::uniformRand().

Referenced by SampleSecondaries().

◆ RandomSelectShell()

G4int G4VDNAModel::RandomSelectShell	(	G4double	k,
		const G4String &	particle,
		const G4String &	materialName
	)

protectedinherited

RandomSelectShell Method to randomely select a shell from the data table uploaded. The size of the table (number of columns) is used to determine the total number of possible shells.

Parameters

k
particle
materialName

Returns: the selected shell

Definition at line 182 of file G4VDNAModel.cc.

{
    G4int level = 0;
 
    TableMapData* tableData = GetTableData();
 
    std::map< G4String,G4DNACrossSectionDataSet*,std::less<G4String> >::iterator pos;
    pos = (*tableData)[materialName].find(particle);
 
    if (pos != (*tableData)[materialName].end())
    {
        G4DNACrossSectionDataSet* table = pos->second;
 
        if (table != 0)
        {
            G4double* valuesBuffer = new G4double[table->NumberOfComponents()];
            const size_t n(table->NumberOfComponents());
            size_t i(n);
            G4double value = 0.;
 
            while (i>0)
            {
                i--;
                valuesBuffer[i] = table->GetComponent(i)->FindValue(k);
                value += valuesBuffer[i];
            }
 
            value *= G4UniformRand();
 
            i = n;
 
            while (i > 0)
            {
                i--;
 
                if (valuesBuffer[i] > value)
                {
                    delete[] valuesBuffer;
                    return i;
                }
                value -= valuesBuffer[i];
            }
 
            if (valuesBuffer) delete[] valuesBuffer;
 
        }
    }
    else
    {
        G4Exception("G4VDNAModel::RandomSelectShell","em0002",
                    FatalException,"Model not applicable to particle type.");
    }
    return level;
}

References FatalException, G4VEMDataSet::FindValue(), G4Exception(), G4UniformRand, G4DNACrossSectionDataSet::GetComponent(), G4VDNAModel::GetTableData(), CLHEP::detail::n, G4DNACrossSectionDataSet::NumberOfComponents(), and pos.

Referenced by G4DNAPTBExcitationModel::SampleSecondaries(), and G4DNAPTBIonisationModel::SampleSecondaries().

◆ ReadAndSaveCSFile()

void G4VDNAModel::ReadAndSaveCSFile	(	const G4String &	materialName,
		const G4String &	particleName,
		const G4String &	file,
		G4double	scaleFactor
	)

protectedinherited

ReadAndSaveCSFile Read and save a "simple" cross section file : use of G4DNACrossSectionDataSet->loadData()

Parameters

materialName
particleName
file
scaleFactor

Definition at line 174 of file G4VDNAModel.cc.

{
    fTableData[materialName][particleName] = new G4DNACrossSectionDataSet(new G4LogLogInterpolation, eV, scaleFactor);
    fTableData[materialName][particleName]->LoadData(file);
}

References eV, geant4_check_module_cycles::file, and G4VDNAModel::fTableData.

Referenced by G4VDNAModel::LoadCrossSectionData().

◆ ReadDiffCSFile()

void G4DNAPTBElasticModel::ReadDiffCSFile	(	const G4String &	materialName,
		const G4String &	particleName,
		const G4String &	file,
		const	G4double
	)

privatevirtual

ReadDiffCSFile Method to read the differential cross section files. This method is not standard yet so every model must implement its own.

Parameters

materialName
particleName
file

Reimplemented from G4VDNAModel.

Definition at line 197 of file G4DNAPTBElasticModel.cc.

{
    // Method to read and save the information contained within the differential cross section files.
    // This method is not yet standard.
 
    // get the path of the G4LEDATA data folder
    char *path = std::getenv("G4LEDATA");
    // if it is not found then quit and print error message
    if(!path)
    {
        G4Exception("G4DNAPTBElasticModel::ReadAllDiffCSFiles","em0006",
                    FatalException,"G4LEDATA environment variable not set.");
        return;
    }
 
    // build the fullFileName path of the data file
    std::ostringstream fullFileName;
    fullFileName << path <<"/"<< file<<".dat";
 
    // open the data file
    std::ifstream diffCrossSection (fullFileName.str().c_str());
    // error if file is not there
    std::stringstream endPath;
    if (!diffCrossSection)
    {
        endPath << "Missing data file: "<<file;
        G4Exception("G4DNAPTBElasticModel::Initialise","em0003",
                    FatalException, endPath.str().c_str());
    }
 
    tValuesVec[materialName][particleName].push_back(0.);
 
    G4String line;
 
    // read the file line by line until we reach the end of file point
    while(std::getline(diffCrossSection, line))
    {
        // check if the line is comment or empty
        //
        std::istringstream testIss(line);
        G4String test;
        testIss >> test;
        // check first caracter to determine if following information is data or comments
        if(test=="#")
        {
            // skip the line by beginning a new while loop.
            continue;
        }
        // check if line is empty
        else if(line.empty())
        {
            // skip the line by beginning a new while loop.
            continue;
        }
        //
        // end of the check
 
        // transform the line into a iss
        std::istringstream iss(line);
 
        // Variables to be filled by the input file
        double tDummy;
        double eDummy;
 
        // fill the variables with the content of the line
        iss>>tDummy>>eDummy;
 
        // SI : mandatory Vecm initialization
 
        // Fill two vectors contained in maps of types:
        // [materialName][particleName]=vector
        // [materialName][particleName][T]=vector
        // to list all the incident energies (tValues) and all the output energies (eValues) within the file
        //
        // Check if we already have the current T value in the vector.
        // If not then add it
        if (tDummy != tValuesVec[materialName][particleName].back())
        {
            // Add the current T value
            tValuesVec[materialName][particleName].push_back(tDummy);
 
            // Make it correspond to a default zero E value
            eValuesVect[materialName][particleName][tDummy].push_back(0.);
        }
 
        // Put the differential cross section value of the input file within the diffCrossSectionData map
        iss>>diffCrossSectionData[materialName][particleName][tDummy][eDummy];
 
        // If the current E value (eDummy) is different from the one already registered in the eVector then add it to the vector
        if (eDummy != eValuesVect[materialName][particleName][tDummy].back()) eValuesVect[materialName][particleName][tDummy].push_back(eDummy);
    }
}

References diffCrossSectionData, eValuesVect, FatalException, geant4_check_module_cycles::file, G4Exception(), mcscore::test(), and tValuesVec.

◆ SampleSecondaries()

void G4DNAPTBElasticModel::SampleSecondaries	(	std::vector< G4DynamicParticle * > *	,
		const G4MaterialCutsCouple *	,
		const G4String &	materialName,
		const G4DynamicParticle *	aDynamicElectron,
		G4ParticleChangeForGamma *	particleChangeForGamma,
		G4double	tmin,
		G4double	tmax
	)

virtual

SampleSecondaries Method called after CrossSectionPerVolume if the process is the one which is selected (according to the sampling on the calculated path length). Here, the characteristics of the incident and created (if any) particle(s) are set (energy, momentum ...).

Parameters

materialName
particleChangeForGamma
tmin
tmax

Implements G4VDNAModel.

Definition at line 346 of file G4DNAPTBElasticModel.cc.

{
    if (verboseLevel > 3)
        G4cout << "Calling SampleSecondaries() of G4DNAPTBElasticModel" << G4endl;
 
    G4double electronEnergy0 = aDynamicElectron->GetKineticEnergy();
 
    const G4String& particleName = aDynamicElectron->GetParticleDefinition()->GetParticleName();
 
    // set killBelowEnergy value for material
    fKillBelowEnergy = GetLowELimit(materialName, particleName);
 
    // If the particle (electron here) energy is below the kill limit then we remove it from the simulation
    if (electronEnergy0 < fKillBelowEnergy)
    {
        particleChangeForGamma->SetProposedKineticEnergy(0.);
        particleChangeForGamma->ProposeTrackStatus(fStopAndKill);
        particleChangeForGamma->ProposeLocalEnergyDeposit(electronEnergy0);
    }
    // If we are above the kill limite and below the high limit then we proceed
    else if (electronEnergy0>= fKillBelowEnergy && electronEnergy0 < GetHighELimit(materialName, particleName) )
    {
        // Random sampling of the cosTheta
        G4double cosTheta = RandomizeCosTheta(electronEnergy0, materialName);
 
        // Random sampling of phi
        G4double phi = 2. * pi * G4UniformRand();
 
        G4ThreeVector zVers = aDynamicElectron->GetMomentumDirection();
        G4ThreeVector xVers = zVers.orthogonal();
        G4ThreeVector yVers = zVers.cross(xVers);
 
        G4double xDir = std::sqrt(1. - cosTheta*cosTheta);
        G4double yDir = xDir;
        xDir *= std::cos(phi);
        yDir *= std::sin(phi);
 
        // Particle direction after ModelInterface
        G4ThreeVector zPrikeVers((xDir*xVers + yDir*yVers + cosTheta*zVers));
 
        // Give the new direction
        particleChangeForGamma->ProposeMomentumDirection(zPrikeVers.unit()) ;
 
        // Update the energy which does not change here
        particleChangeForGamma->SetProposedKineticEnergy(electronEnergy0);
    }
}

References CLHEP::Hep3Vector::cross(), fKillBelowEnergy, fStopAndKill, G4cout, G4endl, G4UniformRand, G4VDNAModel::GetHighELimit(), G4DynamicParticle::GetKineticEnergy(), G4VDNAModel::GetLowELimit(), G4DynamicParticle::GetMomentumDirection(), G4DynamicParticle::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), CLHEP::Hep3Vector::orthogonal(), pi, G4VParticleChange::ProposeLocalEnergyDeposit(), G4ParticleChangeForGamma::ProposeMomentumDirection(), G4VParticleChange::ProposeTrackStatus(), RandomizeCosTheta(), G4ParticleChangeForGamma::SetProposedKineticEnergy(), CLHEP::Hep3Vector::unit(), and verboseLevel.

◆ SetHighELimit()

void G4VDNAModel::SetHighELimit	(	const G4String &	material,
		const G4String &	particle,
		G4double	lim
	)

inlineinherited

SetHighEnergyLimit.

Parameters

material
particle
lim

Definition at line 169 of file G4VDNAModel.hh.

169{fHighEnergyLimits[material][particle]=lim;}

References G4VDNAModel::fHighEnergyLimits, and eplot::material.

Referenced by Initialise(), G4DNADummyModel::Initialise(), G4DNAPTBExcitationModel::Initialise(), and G4DNAPTBIonisationModel::Initialise().

◆ SetLowELimit()

void G4VDNAModel::SetLowELimit	(	const G4String &	material,
		const G4String &	particle,
		G4double	lim
	)

inlineinherited

SetLowEnergyLimit.

Parameters

material
particle
lim

Definition at line 177 of file G4VDNAModel.hh.

177{fLowEnergyLimits[material][particle]=lim;}

References G4VDNAModel::fLowEnergyLimits, and eplot::material.

Referenced by Initialise(), G4DNADummyModel::Initialise(), G4DNAPTBExcitationModel::Initialise(), and G4DNAPTBIonisationModel::Initialise().

◆ Theta()

G4double G4DNAPTBElasticModel::Theta	(	G4ParticleDefinition *	fParticleDefinition,
		G4double	k,
		G4double	integrDiff,
		const G4String &	materialName
	)

private

Theta To return an angular theta value from the differential file. This method uses interpolations to calculate the theta value.

Parameters

fParticleDefinition
k
integrDiff
materialName

Returns: a theta value

Definition at line 402 of file G4DNAPTBElasticModel.cc.

{  
    G4double theta = 0.;
    G4double valueT1 = 0;
    G4double valueT2 = 0;
    G4double valueE21 = 0;
    G4double valueE22 = 0;
    G4double valueE12 = 0;
    G4double valueE11 = 0;
    G4double xs11 = 0;
    G4double xs12 = 0;
    G4double xs21 = 0;
    G4double xs22 = 0;
    G4String particleName = particleDefinition->GetParticleName();
 
    if (particleDefinition == G4Electron::ElectronDefinition())
    {
        std::vector<double>::iterator t2 = std::upper_bound(tValuesVec[materialName][particleName].begin(),tValuesVec[materialName][particleName].end(), k);
        std::vector<double>::iterator t1 = t2-1;
 
        std::vector<double>::iterator e12 = std::upper_bound(eValuesVect[materialName][particleName][(*t1)].begin(),eValuesVect[materialName][particleName][(*t1)].end(), integrDiff);
        std::vector<double>::iterator e11 = e12-1;
 
        std::vector<double>::iterator e22 = std::upper_bound(eValuesVect[materialName][particleName][(*t2)].begin(),eValuesVect[materialName][particleName][(*t2)].end(), integrDiff);
        std::vector<double>::iterator e21 = e22-1;
 
        valueT1  =*t1;
        valueT2  =*t2;
        valueE21 =*e21;
        valueE22 =*e22;
        valueE12 =*e12;
        valueE11 =*e11;
 
        xs11 = diffCrossSectionData[materialName][particleName][valueT1][valueE11];
        xs12 = diffCrossSectionData[materialName][particleName][valueT1][valueE12];
        xs21 = diffCrossSectionData[materialName][particleName][valueT2][valueE21];
        xs22 = diffCrossSectionData[materialName][particleName][valueT2][valueE22];
    }
 
    if (xs11==0 && xs12==0 && xs21==0 && xs22==0) return (0.);
 
    theta = QuadInterpolator   ( valueE11, valueE12,
                                 valueE21, valueE22,
                                 xs11, xs12,
                                 xs21, xs22,
                                 valueT1, valueT2,
                                 k, integrDiff );
 
    return theta;
}

References diffCrossSectionData, G4Electron::ElectronDefinition(), eValuesVect, G4ParticleDefinition::GetParticleName(), QuadInterpolator(), and tValuesVec.

Referenced by RandomizeCosTheta().

Field Documentation

◆ diffCrossSectionData

TriDimensionMap G4DNAPTBElasticModel::diffCrossSectionData

private

A map: [materialName][particleName]=DiffCrossSectionTable.

Definition at line 126 of file G4DNAPTBElasticModel.hh.

Referenced by ReadDiffCSFile(), and Theta().

◆ eValuesVect

VecMap G4DNAPTBElasticModel::eValuesVect

private

map with vectors containing all the output energy (E) of the differential file

Definition at line 129 of file G4DNAPTBElasticModel.hh.

Referenced by ReadDiffCSFile(), and Theta().

◆ fHighEnergyLimits

std::map<G4String, std::map<G4String, G4double> > G4VDNAModel::fHighEnergyLimits

privateinherited

List the high energy limits.

Definition at line 301 of file G4VDNAModel.hh.

Referenced by G4VDNAModel::GetHighELimit(), and G4VDNAModel::SetHighELimit().

◆ fKillBelowEnergy

G4double G4DNAPTBElasticModel::fKillBelowEnergy

private

energy kill limit

Definition at line 123 of file G4DNAPTBElasticModel.hh.

Referenced by CrossSectionPerVolume(), G4DNAPTBElasticModel(), and SampleSecondaries().

◆ fLowEnergyLimits

std::map<G4String, std::map<G4String, G4double> > G4VDNAModel::fLowEnergyLimits

privateinherited

List the low energy limits.

Definition at line 300 of file G4VDNAModel.hh.

Referenced by G4VDNAModel::GetLowELimit(), and G4VDNAModel::SetLowELimit().

◆ fModelCSFiles

std::vector<G4String> G4VDNAModel::fModelCSFiles

privateinherited

List the cross section data files.

Definition at line 296 of file G4VDNAModel.hh.

Referenced by G4VDNAModel::AddCrossSectionData(), and G4VDNAModel::LoadCrossSectionData().

◆ fModelDiffCSFiles

std::vector<G4String> G4VDNAModel::fModelDiffCSFiles

privateinherited

List the differential corss section data files.

Definition at line 297 of file G4VDNAModel.hh.

Referenced by G4VDNAModel::AddCrossSectionData(), and G4VDNAModel::LoadCrossSectionData().

◆ fModelMaterials

std::vector<G4String> G4VDNAModel::fModelMaterials

privateinherited

List the materials that can be activated (and will be by default) within the model.

Definition at line 294 of file G4VDNAModel.hh.

Referenced by G4VDNAModel::AddCrossSectionData(), and G4VDNAModel::LoadCrossSectionData().

◆ fModelParticles

std::vector<G4String> G4VDNAModel::fModelParticles

privateinherited

List the particles that can be activated within the model.

Definition at line 295 of file G4VDNAModel.hh.

Referenced by G4VDNAModel::AddCrossSectionData(), and G4VDNAModel::LoadCrossSectionData().

◆ fModelScaleFactors

std::vector<G4double> G4VDNAModel::fModelScaleFactors

privateinherited

List the model scale factors (they could change with material)

Definition at line 298 of file G4VDNAModel.hh.

Referenced by G4VDNAModel::AddCrossSectionData(), and G4VDNAModel::LoadCrossSectionData().

◆ fName

G4String G4VDNAModel::fName

privateinherited

model name

Definition at line 303 of file G4VDNAModel.hh.

Referenced by G4VDNAModel::GetName().

◆ fStringOfMaterials

const G4String G4VDNAModel::fStringOfMaterials

privateinherited

fStringOfMaterials The user can decide to specify by hand which are the materials the be activated among those implemented in the model. If the user does then only the specified materials contained in this string variable will be activated. The string is like: mat1/mat2/mat3/mat4

Definition at line 286 of file G4VDNAModel.hh.

Referenced by G4VDNAModel::LoadCrossSectionData().

◆ fTableData

TableMapData G4VDNAModel::fTableData

privateinherited

fTableData It contains the cross section data and can be used like: dataTable=fTableData[material][particle]

Definition at line 292 of file G4VDNAModel.hh.

Referenced by G4VDNAModel::EnableForMaterialAndParticle(), G4VDNAModel::GetTableData(), G4VDNAModel::IsMaterialExistingInModel(), G4VDNAModel::IsParticleExistingInModelForMaterial(), G4VDNAModel::ReadAndSaveCSFile(), and G4VDNAModel::~G4VDNAModel().

◆ killBelowEnergyTable

std::map<G4String, double > G4DNAPTBElasticModel::killBelowEnergyTable

private

map to save the different energy kill limits for the materials

Definition at line 122 of file G4DNAPTBElasticModel.hh.

◆ tValuesVec

std::map<G4String, std::map<G4String, std::vector<double> > > G4DNAPTBElasticModel::tValuesVec

private

map with vectors containing all the incident (T) energy of the differential file

Definition at line 130 of file G4DNAPTBElasticModel.hh.

Referenced by ReadDiffCSFile(), and Theta().

◆ verboseLevel

G4int G4DNAPTBElasticModel::verboseLevel

private

verbose level

Definition at line 121 of file G4DNAPTBElasticModel.hh.

Referenced by CrossSectionPerVolume(), G4DNAPTBElasticModel(), Initialise(), and SampleSecondaries().

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

source/processes/electromagnetic/dna/models/include/G4DNAPTBElasticModel.hh
source/processes/electromagnetic/dna/models/src/G4DNAPTBElasticModel.cc

Public Member Functions

Protected Types

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ItCompoMapData

◆ RatioMapData

◆ TableMapData

◆ TriDimensionMap

◆ VecMap

Constructor & Destructor Documentation

◆ G4DNAPTBElasticModel() [1/2]

◆ ~G4DNAPTBElasticModel()

◆ G4DNAPTBElasticModel() [2/2]

Member Function Documentation

◆ AddCrossSectionData() [1/2]

◆ AddCrossSectionData() [2/2]

◆ BuildApplyToMatVect()

◆ CrossSectionPerVolume()

◆ EnableForMaterialAndParticle()

◆ GetHighELimit()

◆ GetLowELimit()

◆ GetName()

◆ GetTableData()

◆ Initialise()

◆ IsMaterialDefine()

◆ IsMaterialExistingInModel()

◆ IsParticleExistingInModelForMaterial()

◆ LinLinInterpolate()

◆ LinLogInterpolate()

◆ LoadCrossSectionData()

◆ LogLogInterpolate()

◆ operator=()

◆ QuadInterpolator()

◆ RandomizeCosTheta()

◆ RandomSelectShell()

◆ ReadAndSaveCSFile()

◆ ReadDiffCSFile()

◆ SampleSecondaries()

◆ SetHighELimit()

◆ SetLowELimit()

◆ Theta()

Field Documentation

◆ diffCrossSectionData

◆ eValuesVect

◆ fHighEnergyLimits

◆ fKillBelowEnergy

◆ fLowEnergyLimits

◆ fModelCSFiles

◆ fModelDiffCSFiles

◆ fModelMaterials

◆ fModelParticles

◆ fModelScaleFactors

◆ fName

◆ fStringOfMaterials

◆ fTableData

◆ killBelowEnergyTable

◆ tValuesVec

◆ verboseLevel