The G4DNAPTBExcitationModel class This class implements the PTB excitation model. More...

#include <G4DNAPTBExcitationModel.hh>

Inheritance diagram for G4DNAPTBExcitationModel:

Public Member Functions
virtual G4double	CrossSectionPerVolume (const G4Material material, const G4String &materialName, const G4ParticleDefinition p, G4double ekin, G4double emin, G4double emax)
	CrossSectionPerVolume Retrieve the cross section corresponding to the current material, particle and energy. More...

	G4DNAPTBExcitationModel (const G4String &applyToMaterial="all", const G4ParticleDefinition *p=0, const G4String &nam="DNAPTBExcitationModel")
	G4DNAPTBExcitationModel 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 &= (new G4DataVector()), G4ParticleChangeForGamma *fpChangeForGamme=nullptr)
	Initialise Set the materials for which the model can be used and defined the energy limits. 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 If the model is selected for the ModelInterface then the SampleSecondaries method will be called. The method sets the incident particle characteristics after the ModelInterface. 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	~G4DNAPTBExcitationModel ()
	~G4DNAPTBExcitationModel 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...

virtual void	ReadDiffCSFile (const G4String &materialName, const G4String &particleName, const G4String &path, const G4double scaleFactor)
	ReadDiffCSFile Virtual method that need to be implemented if one wish to use the differential cross sections. The read method for that kind of information is not standardized yet. More...

Private Types
typedef std::map< G4String, G4double, std::less< G4String > >	MapMeanEnergy

Private Member Functions
	G4DNAPTBExcitationModel (const G4DNAPTBExcitationModel &)

G4DNAPTBExcitationModel &	operator= (const G4DNAPTBExcitationModel &right)

Private Attributes
std::map< G4String, std::map< G4String, G4double > >	fHighEnergyLimits
	List the high energy limits. 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...

MapMeanEnergy	tableMeanEnergyPTB
	map: [materialName]=energyValue More...

G4int	verboseLevel
	verbose level More...

G4DNAWaterExcitationStructure	waterStructure

Detailed Description

The G4DNAPTBExcitationModel class This class implements the PTB excitation model.

Definition at line 50 of file G4DNAPTBExcitationModel.hh.

Member Typedef Documentation

◆ ItCompoMapData

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

protectedinherited

Definition at line 185 of file G4VDNAModel.hh.

◆ MapMeanEnergy

typedef std::map<G4String,G4double,std::less<G4String> > G4DNAPTBExcitationModel::MapMeanEnergy

private

Definition at line 120 of file G4DNAPTBExcitationModel.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.

Constructor & Destructor Documentation

◆ G4DNAPTBExcitationModel() [1/2]

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

G4DNAPTBExcitationModel Constructor.

Parameters

applyToMaterial
p
nam

Definition at line 36 of file G4DNAPTBExcitationModel.cc.

    : G4VDNAModel(nam, applyToMaterial)
{
    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
 
    // initialisation of mean energy loss for each material
    tableMeanEnergyPTB["THF"] = 8.01*eV;
    tableMeanEnergyPTB["PY"] = 7.61*eV;
    tableMeanEnergyPTB["PU"] = 7.61*eV;
    tableMeanEnergyPTB["TMP"] = 8.01*eV;
 
    if( verboseLevel>0 )
    {
        G4cout << "PTB excitation model is constructed " << G4endl;
    }
}

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

◆ ~G4DNAPTBExcitationModel()

G4DNAPTBExcitationModel::~G4DNAPTBExcitationModel ( )

virtual

~G4DNAPTBExcitationModel Destructor

Definition at line 62 of file G4DNAPTBExcitationModel.cc.

{ 
 
}

◆ G4DNAPTBExcitationModel() [2/2]

G4DNAPTBExcitationModel::G4DNAPTBExcitationModel ( const G4DNAPTBExcitationModel & )

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 G4DNAPTBElasticModel::Initialise(), 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 G4DNAPTBExcitationModel::CrossSectionPerVolume	(	const G4Material *	material,
		const G4String &	materialName,
		const G4ParticleDefinition *	p,
		G4double	ekin,
		G4double	emin,
		G4double	emax
	)

virtual

CrossSectionPerVolume Retrieve the cross section corresponding to the current material, particle and energy.

Parameters

material
materialName
p
ekin
emin
emax

Returns: the cross section value

Implements G4VDNAModel.

Definition at line 186 of file G4DNAPTBExcitationModel.cc.

{
    if (verboseLevel > 3)
        G4cout << "Calling CrossSectionPerVolume() of G4DNAPTBExcitationModel" << G4endl;
 
    // Get the name of the current particle
    G4String particleName = particleDefinition->GetParticleName();
 
    // initialise variables
    G4double lowLim = 0;
    G4double highLim = 0;
    G4double sigma=0;
 
    // Get the low energy limit for the current particle
    lowLim = GetLowELimit(materialName, particleName);
 
    // Get the high energy limit for the current particle
    highLim = GetHighELimit(materialName, particleName);
 
    // Check that we are in the correct energy range
    if (ekin >= lowLim && ekin < highLim)
    {
        // Get the map with all the data tables
        TableMapData* tableData = GetTableData();
 
        // Retrieve the cross section value
        sigma = (*tableData)[materialName][particleName]->FindValue(ekin);
 
        if (verboseLevel > 2)
        {
            G4cout << "__________________________________" << G4endl;
            G4cout << "°°° G4DNAPTBExcitationModel - XS INFO START" << G4endl;
            G4cout << "°°° Kinetic energy(eV)=" << ekin/eV << " particle : " << particleName << G4endl;
            G4cout << "°°° Cross section per "<< materialName <<" molecule (cm^2)=" << sigma/cm/cm << G4endl;
            G4cout << "°°° G4DNAPTBExcitationModel - XS INFO END" << G4endl;
        }
 
    }
 
    // Return the cross section value
    return sigma;
}

References cm, eV, 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 G4DNAPTBElasticModel::CrossSectionPerVolume(), CrossSectionPerVolume(), G4DNAPTBIonisationModel::CrossSectionPerVolume(), G4DNAPTBElasticModel::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 G4DNAPTBElasticModel::CrossSectionPerVolume(), CrossSectionPerVolume(), G4DNAPTBIonisationModel::CrossSectionPerVolume(), G4DNAPTBElasticModel::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 G4DNAPTBElasticModel::CrossSectionPerVolume(), CrossSectionPerVolume(), G4DNAPTBIonisationModel::CrossSectionPerVolume(), and G4VDNAModel::RandomSelectShell().

◆ Initialise()

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

virtual

Initialise Set the materials for which the model can be used and defined the energy limits.

Implements G4VDNAModel.

Definition at line 69 of file G4DNAPTBExcitationModel.cc.

{
    if (verboseLevel > 3)
        G4cout << "Calling G4DNAPTBExcitationModel::Initialise()" << G4endl;
 
    G4double scaleFactor = 1e-16*cm*cm;
    G4double scaleFactorBorn = (1.e-22 / 3.343) * m*m;
 
    G4ParticleDefinition* electronDef = G4Electron::ElectronDefinition();
 
    //*******************************************************
    // Cross section data
    //*******************************************************
 
    if(particle == electronDef)
    {
        G4String particleName = particle->GetParticleName();
 
        AddCrossSectionData("THF",
                            particleName,
                            "dna/sigma_excitation_e-_PTB_THF",
                            scaleFactor);
        SetLowELimit("THF", particleName, 9.*eV);
        SetHighELimit("THF", particleName, 1.*keV);
 
        AddCrossSectionData("PY",
                            particleName,
                            "dna/sigma_excitation_e-_PTB_PY",
                            scaleFactor);
        SetLowELimit("PY", particleName, 9.*eV);
        SetHighELimit("PY", particleName, 1.*keV);
 
        AddCrossSectionData("PU",
                            particleName,
                            "dna/sigma_excitation_e-_PTB_PU",
                            scaleFactor);
        SetLowELimit("PU", particleName, 9.*eV);
        SetHighELimit("PU", particleName, 1.*keV);
 
        AddCrossSectionData("TMP",
                            particleName,
                            "dna/sigma_excitation_e-_PTB_TMP",
                            scaleFactor);
        SetLowELimit("TMP", particleName, 9.*eV);
        SetHighELimit("TMP", particleName, 1.*keV);
 
        AddCrossSectionData("G4_WATER",
                            particleName,
                            "dna/sigma_excitation_e_born",
                            scaleFactorBorn);
        SetLowELimit("G4_WATER", particleName, 9.*eV);
        SetHighELimit("G4_WATER", particleName, 1.*keV);
 
        // DNA materials
        //
        AddCrossSectionData("backbone_THF",
                            particleName,
                            "dna/sigma_excitation_e-_PTB_THF",
                            scaleFactor*33./30);
        SetLowELimit("backbone_THF", particleName, 9.*eV);
        SetHighELimit("backbone_THF", particleName, 1.*keV);
 
        AddCrossSectionData("cytosine_PY",
                            particleName,
                            "dna/sigma_excitation_e-_PTB_PY",
                            scaleFactor*42./30);
        SetLowELimit("cytosine_PY", particleName, 9.*eV);
        SetHighELimit("cytosine_PY", particleName, 1.*keV);
 
        AddCrossSectionData("thymine_PY",
                            particleName,
                            "dna/sigma_excitation_e-_PTB_PY",
                            scaleFactor*48./30);
        SetLowELimit("thymine_PY", particleName, 9.*eV);
        SetHighELimit("thymine_PY", particleName, 1.*keV);
 
        AddCrossSectionData("adenine_PU",
                            particleName,
                            "dna/sigma_excitation_e-_PTB_PU",
                            scaleFactor*50./44);
        SetLowELimit("adenine_PU", particleName, 9.*eV);
        SetHighELimit("adenine_PU", particleName, 1.*keV);
 
        AddCrossSectionData("guanine_PU",
                            particleName,
                            "dna/sigma_excitation_e-_PTB_PU",
                            scaleFactor*56./44);
        SetLowELimit("guanine_PU", particleName, 9.*eV);
        SetHighELimit("guanine_PU", particleName, 1.*keV);
 
        AddCrossSectionData("backbone_TMP",
                            particleName,
                            "dna/sigma_excitation_e-_PTB_TMP",
                            scaleFactor*33./50);
        SetLowELimit("backbone_TMP", particleName, 9.*eV);
        SetHighELimit("backbone_TMP", particleName, 1.*keV);
    }
 
    //*******************************************************
    // Load data
    //*******************************************************
 
    LoadCrossSectionData(particle->GetParticleName() );
 
    //*******************************************************
    // Verbose
    //*******************************************************
 
    if( verboseLevel>0 )
    {
        G4cout << "PTB excitation model is initialized " << G4endl;
    }
}

References G4VDNAModel::AddCrossSectionData(), cm, G4Electron::ElectronDefinition(), eV, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), keV, G4VDNAModel::LoadCrossSectionData(), m, 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().

◆ 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 G4DNAPTBElasticModel::Initialise(), Initialise(), and G4DNAPTBIonisationModel::Initialise().

◆ operator=()

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

private

◆ 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 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 G4VDNAModel::ReadDiffCSFile	(	const G4String &	materialName,
		const G4String &	particleName,
		const G4String &	path,
		const G4double	scaleFactor
	)

protectedvirtualinherited

ReadDiffCSFile Virtual method that need to be implemented if one wish to use the differential cross sections. The read method for that kind of information is not standardized yet.

Parameters

materialName
particleName
path
scaleFactor

Reimplemented in G4DNAPTBIonisationModel, and G4DNAPTBElasticModel.

Definition at line 126 of file G4VDNAModel.cc.

{
    G4String text("ReadDiffCSFile must be implemented in the model class using a differential cross section data file");
 
    G4Exception("G4VDNAModel::ReadDiffCSFile","em0003",
                FatalException, text);
}

References FatalException, and G4Exception().

Referenced by G4VDNAModel::LoadCrossSectionData().

◆ SampleSecondaries()

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

virtual

SampleSecondaries If the model is selected for the ModelInterface then the SampleSecondaries method will be called. The method sets the incident particle characteristics after the ModelInterface.

Parameters

materialName
particleChangeForGamma
tmin
tmax

Implements G4VDNAModel.

Definition at line 236 of file G4DNAPTBExcitationModel.cc.

{
    if (verboseLevel > 3)
        G4cout << "Calling SampleSecondaries() of G4DNAPTBExcitationModel" << G4endl;
 
    // Get the incident particle kinetic energy
    G4double k = aDynamicParticle->GetKineticEnergy();
 
    if(materialName!="G4_WATER")
    {
        // Retrieve the excitation energy for the current material
        G4double excitationEnergy = tableMeanEnergyPTB[materialName];
 
        // Calculate the new energy of the particle
        G4double newEnergy = k - excitationEnergy;
 
        // Check that the new energy is above zero before applying it the particle.
        // Otherwise, do nothing.
        if (newEnergy > 0)
        {
            particleChangeForGamma->ProposeMomentumDirection(aDynamicParticle->GetMomentumDirection());
            particleChangeForGamma->SetProposedKineticEnergy(newEnergy);
            particleChangeForGamma->ProposeLocalEnergyDeposit(excitationEnergy);
        }
    }
    else
    {
        const G4String& particleName = aDynamicParticle->GetDefinition()->GetParticleName();
 
        G4int level = RandomSelectShell(k,particleName, materialName);
        G4double excitationEnergy = waterStructure.ExcitationEnergy(level);
        G4double newEnergy = k - excitationEnergy;
 
        if (newEnergy > 0)
        {
            particleChangeForGamma->ProposeMomentumDirection(aDynamicParticle->GetMomentumDirection());
            particleChangeForGamma->SetProposedKineticEnergy(newEnergy);
            particleChangeForGamma->ProposeLocalEnergyDeposit(excitationEnergy);
        }
 
        const G4Track * theIncomingTrack = particleChangeForGamma->GetCurrentTrack();
        G4DNAChemistryManager::Instance()->CreateWaterMolecule(eExcitedMolecule,
                                                               level,
                                                               theIncomingTrack);
    }
}

References G4DNAChemistryManager::CreateWaterMolecule(), eExcitedMolecule, G4DNAWaterExcitationStructure::ExcitationEnergy(), G4cout, G4endl, G4ParticleChangeForGamma::GetCurrentTrack(), G4DynamicParticle::GetDefinition(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMomentumDirection(), G4ParticleDefinition::GetParticleName(), G4DNAChemistryManager::Instance(), G4VParticleChange::ProposeLocalEnergyDeposit(), G4ParticleChangeForGamma::ProposeMomentumDirection(), G4VDNAModel::RandomSelectShell(), G4ParticleChangeForGamma::SetProposedKineticEnergy(), tableMeanEnergyPTB, verboseLevel, and waterStructure.

◆ 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 G4DNAPTBElasticModel::Initialise(), G4DNADummyModel::Initialise(), 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 G4DNAPTBElasticModel::Initialise(), G4DNADummyModel::Initialise(), Initialise(), and G4DNAPTBIonisationModel::Initialise().

Field Documentation

◆ 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().

◆ 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().

◆ tableMeanEnergyPTB

MapMeanEnergy G4DNAPTBExcitationModel::tableMeanEnergyPTB

private

map: [materialName]=energyValue

Definition at line 121 of file G4DNAPTBExcitationModel.hh.

Referenced by G4DNAPTBExcitationModel(), and SampleSecondaries().

◆ verboseLevel

G4int G4DNAPTBExcitationModel::verboseLevel

private

verbose level

Definition at line 116 of file G4DNAPTBExcitationModel.hh.

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

◆ waterStructure

G4DNAWaterExcitationStructure G4DNAPTBExcitationModel::waterStructure

private

Definition at line 118 of file G4DNAPTBExcitationModel.hh.

Referenced by SampleSecondaries().

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

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

Public Member Functions

Protected Types

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ItCompoMapData

◆ MapMeanEnergy

◆ RatioMapData

◆ TableMapData

Constructor & Destructor Documentation

◆ G4DNAPTBExcitationModel() [1/2]

◆ ~G4DNAPTBExcitationModel()

◆ G4DNAPTBExcitationModel() [2/2]

Member Function Documentation

◆ AddCrossSectionData() [1/2]

◆ AddCrossSectionData() [2/2]

◆ BuildApplyToMatVect()

◆ CrossSectionPerVolume()

◆ EnableForMaterialAndParticle()

◆ GetHighELimit()

◆ GetLowELimit()

◆ GetName()

◆ GetTableData()

◆ Initialise()

◆ IsMaterialDefine()

◆ IsMaterialExistingInModel()

◆ IsParticleExistingInModelForMaterial()

◆ LoadCrossSectionData()

◆ operator=()

◆ RandomSelectShell()

◆ ReadAndSaveCSFile()

◆ ReadDiffCSFile()

◆ SampleSecondaries()

◆ SetHighELimit()

◆ SetLowELimit()

Field Documentation

◆ fHighEnergyLimits

◆ fLowEnergyLimits

◆ fModelCSFiles

◆ fModelDiffCSFiles

◆ fModelMaterials

◆ fModelParticles

◆ fModelScaleFactors

◆ fName

◆ fStringOfMaterials

◆ fTableData

◆ tableMeanEnergyPTB

◆ verboseLevel

◆ waterStructure