lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.4.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2017-12-08 12:52:30 +01:00
parent 98e455a940
commit fc6af9e721
2166 changed files with 276760 additions and 100873 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/radioactive_decay/src/G4ECDecay.cc
+6 -4
View File
@@ -84,11 +84,13 @@ G4DecayProducts* G4ECDecay::DecayIt(G4double)
case KshellEC:
shellIndex = 0;
break;
case LshellEC:
shellIndex = G4int(G4UniformRand()*3) + 1;
case LshellEC: //default PL1/PL=0.995 PL2/PL=0.005 from Fe55 Allowed transition
if (G4UniformRand() < 0.995) shellIndex =1;
else shellIndex =2;
break;
case MshellEC:
shellIndex = G4int(G4UniformRand()*3) + 4;
case MshellEC: //default PM1/PM=0.995 PM2/PM=0.005 from Fe55 Allowed transition
if (G4UniformRand() < 0.995) shellIndex =4;
else shellIndex =5;
break;
default:
G4Exception("G4ECDecay::DecayIt()", "HAD_RDM_009",
source/processes/hadronic/models/radioactive_decay/src/G4ITDecay.cc
-2
View File
@@ -85,8 +85,6 @@ G4DecayProducts* G4ITDecay::DecayIt(G4double)
G4DecayProducts* products = new G4DecayProducts(parentParticle);
// Let G4PhotonEvaporation do the decay
// but first pass nuclear polarization from end of previous IT decay to
// start of next one
G4Fragment parentNucleus(parentA, parentZ, atRest);
G4Fragment* eOrGamma = photonEvaporation->EmittedFragment(&parentNucleus);
source/processes/hadronic/models/radioactive_decay/src/G4Radioactivation.cc
+1027
View File
File diff suppressed because it is too large Load Diff
source/processes/hadronic/models/radioactive_decay/src/G4RadioactivationMessenger.cc
+267
View File
@@ -0,0 +1,267 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
////////////////////////////////////////////////////////////////////////////////
// //
// File: G4RadioactivationMessenger.cc //
// Author: D.H. Wright (SLAC) //
// Date: 29 August 2017 //
// Description: messenger class for biased version of G4RadioactiveDecay. //
// Based on the code of F. Lei and P.R. Truscott. //
// //
////////////////////////////////////////////////////////////////////////////////
#include "G4RadioactivationMessenger.hh"
#include "G4NuclearLevelData.hh"
#include <sstream>
G4RadioactivationMessenger::G4RadioactivationMessenger(G4Radioactivation* theRadioactivationContainer1)
:theRadioactivationContainer(theRadioactivationContainer1)
{
grdmDirectory = new G4UIdirectory("/grdm/");
grdmDirectory->SetGuidance("Controls the biased version of radioactive decay");
/*
// Command to define the limits on nuclei the RDM will treat
nucleuslimitsCmd = new G4UIcmdWithNucleusLimits("/grdm/nucleusLimits",this);
nucleuslimitsCmd->SetGuidance
("Set the atomic weight and number limits for the RDM.");
nucleuslimitsCmd->SetParameterName("aMin","aMax","zMin","zMax",true);
// Command to contols whether beta decay will be treated faithfully or
// in fast mode (no longer used)
fbetaCmd = new G4UIcmdWithABool ("/grdm/fBeta",this);
fbetaCmd->SetGuidance("false: use 3-body decay, true: use histogram method");
fbetaCmd->SetParameterName("fBeta",true);
fbetaCmd->SetDefaultValue(false);
// Command to select a logical volume for RDM
avolumeCmd = new G4UIcmdWithAString("/grdm/selectVolume",this);
avolumeCmd->SetGuidance
("Suppply a logical volumes name to add it to the RDM apply list");
avolumeCmd->SetParameterName("aVolume",false);
// Command to de-select a logical volume for RDM
deavolumeCmd = new G4UIcmdWithAString("/grdm/deselectVolume",this);
deavolumeCmd->SetGuidance
("Suppply a logical volumes name to remove it from the RDM apply list");
deavolumeCmd->SetParameterName("aVolume",false);
// Command to select all logical volumes for RDM
allvolumesCmd = new G4UIcmdWithoutParameter("/grdm/allVolumes",this);
allvolumesCmd->SetGuidance
(" apply RDM to all logical volumes. No parameter required.");
// Command to de-selete a logical volume for RDM.
deallvolumesCmd = new G4UIcmdWithoutParameter("/grdm/noVolumes",this);
deallvolumesCmd->SetGuidance(" RDM is not applied to any logical volumes");
*/
// Command to use branching ratio biasing or not
brbiasCmd = new G4UIcmdWithABool ("/grdm/BRbias",this);
brbiasCmd->SetGuidance("false: no biasing; true: all branches are treated as equal");
brbiasCmd->SetParameterName("BRBias",true);
brbiasCmd->SetDefaultValue(true);
/*
// Command to apply internal conversion or not
icmCmd = new G4UIcmdWithABool ("/grdm/applyICM",this);
icmCmd->SetGuidance("True: ICM is applied; false: no");
icmCmd->SetParameterName("applyICM",true);
icmCmd->SetDefaultValue(true);
// Command to apply atomic relaxation or not
armCmd = new G4UIcmdWithABool ("/grdm/applyARM",this);
armCmd->SetGuidance("True: ARM is applied; false: no");
armCmd->SetParameterName("applyARM",true);
armCmd->SetDefaultValue(true);
*/
// Command to set the half-life thresold for isomer production
hlthCmd = new G4UIcmdWithADoubleAndUnit("/grdm/hlThreshold",this);
hlthCmd->SetGuidance("Set the h-l threshold for isomer production");
hlthCmd->SetParameterName("hlThreshold",false);
hlthCmd->SetUnitCategory("Time");
// Command to define the incident particle source time profile
sourcetimeprofileCmd = new G4UIcmdWithAString("/grdm/sourceTimeProfile",this);
sourcetimeprofileCmd->SetGuidance
("Supply the name of the ascii file containing the source particle time profile");
sourcetimeprofileCmd->SetParameterName("STimeProfile",true);
sourcetimeprofileCmd->SetDefaultValue("source.data");
// Command to define the incident particle source time profile
decaybiasprofileCmd = new G4UIcmdWithAString("/grdm/decayBiasProfile",this);
decaybiasprofileCmd->SetGuidance
("Supply the name of the ascii file containing the decay bias time profile");
decaybiasprofileCmd->SetParameterName("DBiasProfile",true);
decaybiasprofileCmd->SetDefaultValue("bias.data");
/*
// Command to set the directional bias (collimation) vector
colldirCmd = new G4UIcmdWith3Vector("/grdm/decayDirection",this);
colldirCmd->SetGuidance("Supply the direction vector for decay products");
colldirCmd->SetParameterName("X","Y","Z",false);
// Command to set the directional bias (collimation) half angle ("cone")
collangleCmd = new G4UIcmdWithADoubleAndUnit("/grdm/decayHalfAngle",this);
collangleCmd->SetGuidance
("Supply maximum angle from direction vector for decay products");
collangleCmd->SetParameterName("halfAngle",false);
collangleCmd->SetUnitCategory("Angle");
*/
// Command to set nuclei spliting parameter
splitnucleiCmd = new G4UIcmdWithAnInteger("/grdm/splitNuclei",this);
splitnucleiCmd->SetGuidance("Set number of spliting for the isotopes.");
splitnucleiCmd->SetParameterName("NSplit",true);
splitnucleiCmd->SetDefaultValue(1);
splitnucleiCmd->SetRange("NSplit>=1");
/*
// Command to set verbosity
verboseCmd = new G4UIcmdWithAnInteger("/grdm/verbose",this);
verboseCmd->SetGuidance("Set verbose level: 0, 1, 2 or 3");
verboseCmd->SetParameterName("VerboseLevel",true);
verboseCmd->SetDefaultValue(1);
verboseCmd->SetRange("VerboseLevel>=0");
//This commansd allows the user to define its own decay datafile for
// a given isotope
//
userDecayDataCmd = new G4UIcommand("/grdm/setRadioactiveDecayFile",this);
G4UIparameter* Z_para= new G4UIparameter("Z_isotope",'i',true);
Z_para->SetParameterRange("Z_isotope > 0");
Z_para->SetGuidance("Z: Charge number of isotope");
G4UIparameter* A_para= new G4UIparameter("A_isotope",'i',true);
A_para->SetParameterRange("A_isotope > 1");
A_para->SetGuidance("A: mass number of isotope");
G4UIparameter* FileName_para= new G4UIparameter("file_name",'s',true);
FileName_para->SetGuidance("Name of the user data file");
userDecayDataCmd->SetParameter(Z_para);
userDecayDataCmd->SetParameter(A_para);
userDecayDataCmd->SetParameter(FileName_para);
// Command allowing user-defined evaporation data file to be used
// a given isotope
userEvaporationDataCmd = new G4UIcommand("/grdm/setPhotoEvaporationFile",this);
userEvaporationDataCmd->SetParameter(Z_para);
userEvaporationDataCmd->SetParameter(A_para);
userEvaporationDataCmd->SetParameter(FileName_para);
*/
}
G4RadioactivationMessenger::~G4RadioactivationMessenger()
{
delete grdmDirectory;
// delete nucleuslimitsCmd;
delete sourcetimeprofileCmd;
delete decaybiasprofileCmd;
// delete fbetaCmd;
delete brbiasCmd;
delete splitnucleiCmd;
// delete verboseCmd;
// delete avolumeCmd;
// delete deavolumeCmd;
// delete allvolumesCmd;
// delete deallvolumesCmd;
// delete icmCmd;
// delete armCmd;
delete hlthCmd;
// delete userDecayDataCmd;
// delete userEvaporationDataCmd;
// delete colldirCmd;
// delete collangleCmd;
}
void G4RadioactivationMessenger::SetNewValue(G4UIcommand* command, G4String newValues)
{
// if (command==nucleuslimitsCmd) {theRadioactivationContainer->
// SetNucleusLimits(nucleuslimitsCmd->GetNewNucleusLimitsValue(newValues));
/*
} else if (command==fbetaCmd) {theRadioactivationContainer->
SetFBeta(fbetaCmd->GetNewBoolValue(newValues));
} else if (command==avolumeCmd) {theRadioactivationContainer->
SelectAVolume(newValues);
} else if (command==deavolumeCmd) {theRadioactivationContainer->
DeselectAVolume(newValues);
} else if (command==allvolumesCmd) {theRadioactivationContainer->
SelectAllVolumes();
} else if (command==deallvolumesCmd) {theRadioactivationContainer->
DeselectAllVolumes();
*/
if (command==brbiasCmd) {theRadioactivationContainer->
SetBRBias(brbiasCmd->GetNewBoolValue(newValues));
} else if (command==sourcetimeprofileCmd) {theRadioactivationContainer->
SetSourceTimeProfile(newValues);
} else if (command==decaybiasprofileCmd) {theRadioactivationContainer->
SetDecayBias(newValues);
} else if (command==splitnucleiCmd) {theRadioactivationContainer->
SetSplitNuclei(splitnucleiCmd->GetNewIntValue(newValues));
/*
} else if (command==verboseCmd) {theRadioactivationContainer->
SetVerboseLevel(verboseCmd->GetNewIntValue(newValues));
} else if (command==icmCmd ) {theRadioactivationContainer->
SetICM(icmCmd->GetNewBoolValue(newValues));
} else if (command==armCmd ) {theRadioactivationContainer->
SetARM(armCmd->GetNewBoolValue(newValues));
*/
} else if (command==hlthCmd ) {theRadioactivationContainer->
SetHLThreshold(hlthCmd->GetNewDoubleValue(newValues));
/*
} else if (command ==userDecayDataCmd) {
G4int Z,A;
G4String file_name;
const char* nv = (const char*)newValues;
std::istringstream is(nv);
is >> Z >> A >> file_name;
theRadioactivationContainer->AddUserDecayDataFile(Z,A,file_name);
} else if (command ==userEvaporationDataCmd) {
G4int Z,A;
G4String file_name;
const char* nv = (const char*)newValues;
std::istringstream is(nv);
is >> Z >> A >> file_name;
G4NuclearLevelData::GetInstance()->AddPrivateData(Z,A,file_name);
} else if (command==colldirCmd) {theRadioactivationContainer->
SetDecayDirection(colldirCmd->GetNew3VectorValue(newValues));
} else if (command==collangleCmd) {theRadioactivationContainer->
SetDecayHalfAngle(collangleCmd->GetNewDoubleValue(newValues));
*/
}
}
source/processes/hadronic/models/radioactive_decay/src/G4RadioactiveDecay.cc
+91 -62
View File
@@ -125,6 +125,7 @@
#include "G4LogicalVolumeStore.hh"
#include "G4NuclearLevelData.hh"
#include "G4DeexPrecoParameters.hh"
#include "G4EmParameters.hh"
#include "G4LevelManager.hh"
#include "G4ThreeVector.hh"
#include "G4Electron.hh"
@@ -136,9 +137,6 @@
#include "G4HadronicProcessType.hh"
#include "G4HadronicException.hh"
#include "G4LossTableManager.hh"
#include "G4VAtomDeexcitation.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhotonEvaporation.hh"
#include <vector>
@@ -178,7 +176,7 @@ G4RadioactiveDecay::G4RadioactiveDecay(const G4String& processName)
// photonEvaporation->SetVerboseLevel(2);
photonEvaporation->RDMForced(true);
photonEvaporation->SetICM(true);
// Reset the list of user defined data files
theUserRadioactiveDataFiles.clear();
@@ -217,6 +215,16 @@ G4RadioactiveDecay::G4RadioactiveDecay(const G4String& processName)
}
void G4RadioactiveDecay::ProcessDescription(std::ostream& outFile) const
{
outFile << "The radioactive decay process (G4RadioactiveDecay) handles the\n"
<< "alpha, beta+, beta-, electron capture and isomeric transition\n"
<< "decays of nuclei (G4GenericIon) with masses A > 4.\n"
<< "The required half-lives and decay schemes are retrieved from\n"
<< "the RadioactiveDecay database which was derived from ENSDF.\n";
}
G4RadioactiveDecay::~G4RadioactiveDecay()
{
delete theRadioactiveDecaymessenger;
@@ -362,23 +370,21 @@ G4RadioactiveDecay::IsRateTableReady(const G4ParticleDefinition& aParticle)
// Check whether the radioactive decay rates table for the ion has already
// been calculated.
G4String aParticleName = aParticle.GetParticleName();
for (size_t i = 0; i < theDecayRateTableVector.size(); i++) {
if (theDecayRateTableVector[i].GetIonName() == aParticleName) return true;
for (size_t i = 0; i < theParentChainTable.size(); i++) {
if (theParentChainTable[i].GetIonName() == aParticleName) return true;
}
return false;
}
// GetDecayRateTable
// retrieve the decayratetable for the specified aParticle
void
G4RadioactiveDecay::GetDecayRateTable(const G4ParticleDefinition& aParticle)
G4RadioactiveDecay::GetChainsFromParent(const G4ParticleDefinition& aParticle)
{
G4String aParticleName = aParticle.GetParticleName();
for (size_t i = 0; i < theDecayRateTableVector.size(); i++) {
if (theDecayRateTableVector[i].GetIonName() == aParticleName) {
theDecayRateVector = theDecayRateTableVector[i].GetItsRates();
for (size_t i = 0; i < theParentChainTable.size(); i++) {
if (theParentChainTable[i].GetIonName() == aParticleName) {
theDecayRateVector = theParentChainTable[i].GetItsRates();
}
}
#ifdef G4VERBOSE
@@ -720,7 +726,7 @@ G4double G4RadioactiveDecay::GetMeanFreePath (const G4Track& aTrack, G4double,
////////////////////////////////////////////////////////////////////////
// //
// BuildPhysicsTable - initialization of atomic de-excitation //
// BuildPhysicsTable - enable print of parameters //
// //
////////////////////////////////////////////////////////////////////////
@@ -728,28 +734,54 @@ void G4RadioactiveDecay::BuildPhysicsTable(const G4ParticleDefinition&)
{
if (!isInitialised) {
isInitialised = true;
G4LossTableManager* theManager = G4LossTableManager::Instance();
G4VAtomDeexcitation* p = theManager->AtomDeexcitation();
if (!p) {
G4ExceptionDescription ed;
ed << " Atomic deexcitation is not defined.";
G4Exception("G4RadioactiveDecay::BuildPhysicsTable", "HAD_RDM_001",
FatalException, ed);
/*
p = new G4UAtomicDeexcitation();
p->SetFluo(true);
p->SetAuger(true);
p->InitialiseAtomicDeexcitation();
theManager->SetAtomDeexcitation(p);
*/
}
G4DeexPrecoParameters* param = G4NuclearLevelData::GetInstance()->GetParameters();
param->SetUseFilesNEW(true);
param->SetCorrelatedGamma(true);
if(G4Threading::IsMasterThread()) { StreamInfo(G4cout, "\n"); }
}
}
////////////////////////////////////////////////////////////////////////
// //
// StreamInfo - stream out parameters //
// //
////////////////////////////////////////////////////////////////////////
void G4RadioactiveDecay::StreamInfo(std::ostream& os, const G4String& endline)
{
G4DeexPrecoParameters* deex =
G4NuclearLevelData::GetInstance()->GetParameters();
G4EmParameters* emparam = G4EmParameters::Instance();
G4int prec = os.precision(5);
os << "======================================================================="
<< endline;
os << "====== Radioactive Decay Physics Parameters ========"
<< endline;
os << "======================================================================="
<< endline;
os << "Max life time "
<< deex->GetMaxLifeTime()/CLHEP::ps << " ps" << endline;
os << "Internal e- conversion flag "
<< deex->GetInternalConversionFlag() << endline;
os << "Stored internal conversion coefficients "
<< deex->StoreICLevelData() << endline;
os << "Enable correlated gamma emission "
<< deex->CorrelatedGamma() << endline;
os << "Max 2J for sampling of angular correlations "
<< deex->GetTwoJMAX() << endline;
os << "Atomic de-excitation enabled "
<< emparam->Fluo() << endline;
os << "Auger electron emission enabled "
<< emparam->Auger() << endline;
os << "Auger cascade enabled "
<< emparam->AugerCascade() << endline;
os << "Check EM cuts disabled for atomic de-excitation "
<< emparam->DeexcitationIgnoreCut() << endline;
os << "Use Bearden atomic level energies "
<< emparam->BeardenFluoDir() << endline;
os << "======================================================================="
<< endline;
os.precision(prec);
}
////////////////////////////////////////////////////////////////////////////////
// //
// LoadDecayTable loads the decay scheme from the RadioactiveDecay database //
@@ -934,6 +966,7 @@ G4RadioactiveDecay::LoadDecayTable(const G4ParticleDefinition& theParentNucleus)
// indicated in the last column.
a /= 1000.;
c /= 1000.;
b/=100.;
daughterFloatLevel = G4Ions::FloatLevelBase(daughterFloatFlag.back());
switch (theDecayMode) {
@@ -1139,17 +1172,17 @@ G4RadioactiveDecay::SetDecayRate(G4int theZ, G4int theA, G4double theE,
// Why not make this a method of G4RadioactiveDecayRate? (e.g. SetParameters)
{
//fill the decay rate vector
theDecayRate.SetZ(theZ);
theDecayRate.SetA(theA);
theDecayRate.SetE(theE);
theDecayRate.SetGeneration(theG);
theDecayRate.SetDecayRateC(theCoefficients);
theDecayRate.SetTaos(theTaos);
ratesToDaughter.SetZ(theZ);
ratesToDaughter.SetA(theA);
ratesToDaughter.SetE(theE);
ratesToDaughter.SetGeneration(theG);
ratesToDaughter.SetDecayRateC(theCoefficients);
ratesToDaughter.SetTaos(theTaos);
}
void
G4RadioactiveDecay::AddDecayRateTable(const G4ParticleDefinition& theParentNucleus)
void G4RadioactiveDecay::
CalculateChainsFromParent(const G4ParticleDefinition& theParentNucleus)
{
// Use extended Bateman equation to calculate the radioactivities of all
// progeny of theParentNucleus. The coefficients required to do this are
@@ -1178,12 +1211,12 @@ G4RadioactiveDecay::AddDecayRateTable(const G4ParticleDefinition& theParentNucle
taos.push_back(tao);
G4int nEntry = 0;
// Fill the decay rate container (G4RadioactiveDecayRate) with the parent
// isotope data
SetDecayRate(Z,A,E,nGeneration,Acoeffs,taos); // Fill TP with parent lifetime
// Fill the decay rate container (G4RadioactiveDecayRatesToDaughter) with
// the parent isotope data
SetDecayRate(Z,A,E,nGeneration,Acoeffs,taos);
// store the decay rate in decay rate vector
theDecayRateVector.push_back(theDecayRate);
theDecayRateVector.push_back(ratesToDaughter);
nEntry++;
// Now start treating the secondary generations.
@@ -1232,7 +1265,7 @@ G4RadioactiveDecay::AddDecayRateTable(const G4ParticleDefinition& theParentNucle
while (!stable) { /* Loop checking, 01.09.2015, D.Wright */
loop++;
if (loop > 10000) {
G4Exception("G4RadioactiveDecay::AddDecayRateTable()", "HAD_RDM_100", JustWarning, ed);
G4Exception("G4RadioactiveDecay::CalculateChainsFromParent()", "HAD_RDM_100", JustWarning, ed);
break;
}
nGeneration++;
@@ -1244,7 +1277,7 @@ G4RadioactiveDecay::AddDecayRateTable(const G4ParticleDefinition& theParentNucle
RP = theDecayRateVector[j].GetDecayRateC();
TP = theDecayRateVector[j].GetTaos();
if (GetVerboseLevel() > 0) {
G4cout << "G4RadioactiveDecay::AddDecayRateTable : daughters of ("
G4cout << "G4RadioactiveDecay::CalculateChainsFromParent: daughters of ("
<< ZP << ", " << AP << ", " << EP
<< ") are being calculated, generation = " << nGeneration
<< G4endl;
@@ -1430,7 +1463,7 @@ G4RadioactiveDecay::AddDecayRateTable(const G4ParticleDefinition& theParentNucle
theRate = -aRate1;
Acoeffs.push_back(theRate);
SetDecayRate (Z,A,E,nGeneration,Acoeffs,taos);
theDecayRateVector.push_back(theDecayRate);
theDecayRateVector.push_back(ratesToDaughter);
nEntry++;
} // there are entries in the table
} // nuclide is OK to decay
@@ -1449,13 +1482,13 @@ G4RadioactiveDecay::AddDecayRateTable(const G4ParticleDefinition& theParentNucle
// fill the first part of the decay rate table
// which is the name of the original particle (isotope)
theDecayRateTable.SetIonName(theParentNucleus.GetParticleName());
chainsFromParent.SetIonName(theParentNucleus.GetParticleName());
// now fill the decay table with the newly completed decay rate vector
theDecayRateTable.SetItsRates(theDecayRateVector);
chainsFromParent.SetItsRates(theDecayRateVector);
// finally add the decayratetable to the tablevector
theDecayRateTableVector.push_back(theDecayRateTable);
theParentChainTable.push_back(chainsFromParent);
}
////////////////////////////////////////////////////////////////////////////////
@@ -1736,13 +1769,9 @@ G4RadioactiveDecay::DecayIt(const G4Track& theTrack, const G4Step&)
if (GetVerboseLevel()>0)
G4cout << "DecayIt: Variance Reduction version " << G4endl;
#endif
if (!IsRateTableReady(*theParticleDef)) {
// if the decayrates are not ready, calculate them and
// add to the rate table vector
AddDecayRateTable(*theParticleDef);
}
//retrieve the rates
GetDecayRateTable(*theParticleDef);
// Get decay chains for the given nuclide
if (!IsRateTableReady(*theParticleDef)) CalculateChainsFromParent(*theParticleDef);
GetChainsFromParent(*theParticleDef);
// declare some of the variables required in the implementation
G4ParticleDefinition* parentNucleus;
@@ -1866,19 +1895,19 @@ G4RadioactiveDecay::DecayIt(const G4Track& theTrack, const G4Step&)
tempprods = DoDecay(*parentNucleus);
}
// save the secondaries for buffers
numberOfSecondaries = tempprods->entries();
currentTime = finalGlobalTime + theDecayTime;
for (index = 0; index < numberOfSecondaries; index++) {
asecondaryparticle = tempprods->PopProducts();
if (asecondaryparticle->GetDefinition()->GetBaryonNumber() < 5) {
if (asecondaryparticle->GetDefinition()->GetPDGStable() ) {
pw.push_back(weight);
ptime.push_back(currentTime);
secondaryparticles.push_back(asecondaryparticle);
}
//Generate gammas and XRays from excited nucleus, added by L.Desorgher
else if (((const G4Ions*)(asecondaryparticle->GetDefinition()))->GetExcitationEnergy()>0. && weight>0.){//Compute the gamma
} else if (((const G4Ions*)(asecondaryparticle->GetDefinition()))->GetExcitationEnergy() > 0.
&& weight > 0.) {
// Compute the gamma
// Generate gammas and XRays from excited nucleus, added by L.Desorgher
G4ParticleDefinition* apartDef =asecondaryparticle->GetDefinition();
AddDeexcitationSpectrumForBiasMode(apartDef,weight,currentTime,pw,ptime,secondaryparticles);
}
source/processes/hadronic/models/radioactive_decay/src/G4RadioactiveDecayBase.cc
+1072
View File
File diff suppressed because it is too large Load Diff
source/processes/hadronic/models/radioactive_decay/src/G4RadioactiveDecayBaseMessenger.cc
+246
View File
@@ -0,0 +1,246 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
////////////////////////////////////////////////////////////////////////////////
// //
// File: G4RadioactiveDecayBaseMessenger.cc //
// Author: D.H. Wright (SLAC) //
// Date: 29 August 2017 //
// Description: messenger class for the non-biased version of //
// G4RadioactiveDecay. Based on the code of F. Lei and //
// P.R. Truscott. //
// //
////////////////////////////////////////////////////////////////////////////////
#include "G4RadioactiveDecayBaseMessenger.hh"
#include "G4NuclearLevelData.hh"
#include <sstream>
G4RadioactiveDecayBaseMessenger::G4RadioactiveDecayBaseMessenger
(G4RadioactiveDecayBase* theRadioactiveDecayContainer1)
:theRadioactiveDecayContainer(theRadioactiveDecayContainer1)
{
// main directory for control of the RDM
grdmDirectory = new G4UIdirectory("/grdm/");
grdmDirectory->SetGuidance("Controls for the Radioactive Decay Module.");
// Command to define the limits on nucleus the RDM will treat.
nucleuslimitsCmd = new
G4UIcmdWithNucleusLimits("/grdm/nucleusLimits",this);
nucleuslimitsCmd->SetGuidance
("Set the atomic weight and number limits for the RDM.");
nucleuslimitsCmd->SetParameterName("aMin","aMax","zMin","zMax",true);
// Command controlling whether beta decay will be treated faithfully or
// in fast mode (obsolete)
fbetaCmd = new G4UIcmdWithABool ("/grdm/fBeta",this);
// fbetaCmd->SetGuidance("false: use 3-body decay, true: use histogram method");
fbetaCmd->SetGuidance("Fast (approximate) beta decay no longer used.");
fbetaCmd->SetGuidance("Kept for backward compatibility.");
fbetaCmd->SetParameterName("fBeta",true);
fbetaCmd->SetDefaultValue(false);
// Select a logical volume for RDM
avolumeCmd = new
G4UIcmdWithAString("/grdm/selectVolume",this);
avolumeCmd->SetGuidance
("Suppply a logical volumes name to add it to the RDM apply list");
avolumeCmd->SetParameterName("aVolume",false);
// De-select a logical volume for RDM
deavolumeCmd = new
G4UIcmdWithAString("/grdm/deselectVolume",this);
deavolumeCmd->SetGuidance
("Suppply a logical volumes name to remove it from the RDM apply list");
deavolumeCmd->SetParameterName("aVolume",false);
// Select all logical volumes for RDM
allvolumesCmd = new
G4UIcmdWithoutParameter("/grdm/allVolumes",this);
allvolumesCmd->SetGuidance
(" apply RDM to all logical volumes. No parameter required.");
// allvolumeCmd->SetParameterName("AddAVolume",true);
// De-select all logical volumes for RDM
deallvolumesCmd = new
G4UIcmdWithoutParameter("/grdm/noVolumes",this);
deallvolumesCmd->SetGuidance
(" RDM is not applied to any logical volumes");
// deallvolumesCmd->SetParameterName("RemoveAVolume",true);z
// Command to invoke internal conversion or not
icmCmd = new G4UIcmdWithABool ("/grdm/applyICM",this);
icmCmd->SetGuidance("Command not active; kept for backward compatibility.");
icmCmd->SetGuidance("Internal conversion is always turned on.");
icmCmd->SetParameterName("applyICM",true);
icmCmd->SetDefaultValue(true);
// Command to invoke atomic relaxation or not
armCmd = new G4UIcmdWithABool ("/grdm/applyARM",this);
armCmd->SetGuidance("True: ARM is applied; false: no");
armCmd->SetParameterName("applyARM",true);
armCmd->SetDefaultValue(true);
//armCmd->AvailableForStates(G4State_PreInit);
// Command to set the directional bias (collimation) vector
colldirCmd = new G4UIcmdWith3Vector("/grdm/decayDirection",this);
colldirCmd->SetGuidance("Supply the direction vector for decay products");
colldirCmd->SetParameterName("X","Y","Z",false);
// Command to set the directional bias (collimation) half angle ("cone")
collangleCmd = new G4UIcmdWithADoubleAndUnit("/grdm/decayHalfAngle",this);
collangleCmd->SetGuidance
("Supply maximum angle from direction vector for decay products");
collangleCmd->SetParameterName("halfAngle",false);
collangleCmd->SetUnitCategory("Angle");
// This command setup the verbose level of radioactive decay
verboseCmd = new G4UIcmdWithAnInteger("/grdm/verbose",this);
verboseCmd->SetGuidance("Set verbose level: 0, 1, 2 or 3");
verboseCmd->SetParameterName("VerboseLevel",true);
verboseCmd->SetDefaultValue(1);
verboseCmd->SetRange("VerboseLevel>=0");
// Use a user-defined decay datafile for a given isotope
userDecayDataCmd = new G4UIcommand("/grdm/setRadioactiveDecayFile",this);
userDecayDataCmd->SetGuidance("Supply user-defined radioactive decay data file");
G4UIparameter* Z_para= new G4UIparameter("Z_isotope",'i',true);
Z_para->SetParameterRange("Z_isotope > 0");
Z_para->SetGuidance("Z: Charge number of isotope");
G4UIparameter* A_para= new G4UIparameter("A_isotope",'i',true);
A_para->SetParameterRange("A_isotope > 1");
A_para->SetGuidance("A: mass number of isotope");
G4UIparameter* FileName_para= new G4UIparameter("file_name",'s',true);
FileName_para->SetGuidance("Name of the user data file");
userDecayDataCmd->SetParameter(Z_para);
userDecayDataCmd->SetParameter(A_para);
userDecayDataCmd->SetParameter(FileName_para);
// Use a user-defined evaporation data file for a given isotope
userEvaporationDataCmd = new G4UIcommand("/grdm/setPhotoEvaporationFile",this);
userEvaporationDataCmd->SetGuidance("Supply user-defined photon evaporation data file");
G4UIparameter* Zpara= new G4UIparameter("Z_isotope",'i',true);
Zpara->SetParameterRange("Z_isotope > 0");
Zpara->SetGuidance("Z: Charge number of isotope");
G4UIparameter* Apara= new G4UIparameter("A_isotope",'i',true);
Apara->SetParameterRange("A_isotope > 1");
Apara->SetGuidance("A: mass number of isotope");
G4UIparameter* FileNamepara= new G4UIparameter("file_name",'s',true);
FileNamepara->SetGuidance("Name of the user data file");
userEvaporationDataCmd->SetParameter(Zpara);
userEvaporationDataCmd->SetParameter(Apara);
userEvaporationDataCmd->SetParameter(FileNamepara);
}
G4RadioactiveDecayBaseMessenger::~G4RadioactiveDecayBaseMessenger ()
{
delete grdmDirectory;
delete nucleuslimitsCmd;
delete fbetaCmd;
delete verboseCmd;
delete avolumeCmd;
delete deavolumeCmd;
delete allvolumesCmd;
delete deallvolumesCmd;
delete icmCmd;
delete armCmd;
delete userDecayDataCmd;
delete userEvaporationDataCmd;
delete colldirCmd;
delete collangleCmd;
}
void
G4RadioactiveDecayBaseMessenger::SetNewValue(G4UIcommand *command, G4String newValues)
{
if (command==nucleuslimitsCmd) {
theRadioactiveDecayContainer->
SetNucleusLimits(nucleuslimitsCmd->GetNewNucleusLimitsValue(newValues));
} else if (command==fbetaCmd) {
theRadioactiveDecayContainer->
SetFBeta(fbetaCmd->GetNewBoolValue(newValues));
} else if (command==avolumeCmd) {
theRadioactiveDecayContainer->SelectAVolume(newValues);
} else if (command==deavolumeCmd) {
theRadioactiveDecayContainer->DeselectAVolume(newValues);
} else if (command==allvolumesCmd) {
theRadioactiveDecayContainer->SelectAllVolumes();
} else if (command==deallvolumesCmd) {
theRadioactiveDecayContainer->DeselectAllVolumes();
} else if (command==verboseCmd) {
theRadioactiveDecayContainer->
SetVerboseLevel(verboseCmd->GetNewIntValue(newValues));
} else if (command==icmCmd) {
theRadioactiveDecayContainer->
SetICM(icmCmd->GetNewBoolValue(newValues));
} else if (command==armCmd) {
theRadioactiveDecayContainer->
SetARM(armCmd->GetNewBoolValue(newValues));
} else if (command ==userDecayDataCmd) {
G4int Z,A;
G4String file_name;
const char* nv = (const char*)newValues;
std::istringstream is(nv);
is >> Z >> A >> file_name;
theRadioactiveDecayContainer->AddUserDecayDataFile(Z,A,file_name);
} else if (command ==userEvaporationDataCmd) {
G4int Z,A;
G4String file_name;
const char* nv = (const char*)newValues;
std::istringstream is(nv);
is >> Z >> A >> file_name;
G4NuclearLevelData::GetInstance()->AddPrivateData(Z,A,file_name);
} else if (command==colldirCmd) {
theRadioactiveDecayContainer->
SetDecayDirection(colldirCmd->GetNew3VectorValue(newValues));
} else if (command==collangleCmd) {
theRadioactiveDecayContainer->
SetDecayHalfAngle(collangleCmd->GetNewDoubleValue(newValues));
}
}
source/processes/hadronic/models/radioactive_decay/src/G4RadioactiveDecayRateVector.cc → source/processes/hadronic/models/radioactive_decay/src/G4RadioactiveDecayChainsFromParent.cc
+10 -20
View File
@@ -24,25 +24,23 @@
// ********************************************************************
//
#include "G4RadioactiveDecayRateVector.hh"
#include "G4RadioactiveDecayChainsFromParent.hh"
G4RadioactiveDecayRateVector::G4RadioactiveDecayRateVector()
{
;
//do nothing at the momment
}
G4RadioactiveDecayChainsFromParent::G4RadioactiveDecayChainsFromParent()
{}
G4RadioactiveDecayRateVector::G4RadioactiveDecayRateVector(const G4RadioactiveDecayRateVector &right)
G4RadioactiveDecayChainsFromParent::
G4RadioactiveDecayChainsFromParent(const G4RadioactiveDecayChainsFromParent& right)
{
ionName = right.ionName;
itsRates = right.itsRates;
}
G4RadioactiveDecayRateVector & G4RadioactiveDecayRateVector::operator=(const G4RadioactiveDecayRateVector &right)
G4RadioactiveDecayChainsFromParent&
G4RadioactiveDecayChainsFromParent::operator=(const G4RadioactiveDecayChainsFromParent& right)
{
if (this != &right) {
ionName = right.ionName;
@@ -52,15 +50,7 @@ G4RadioactiveDecayRateVector & G4RadioactiveDecayRateVector::operator=(const G4R
}
G4RadioactiveDecayRateVector::~G4RadioactiveDecayRateVector()
{ ;}
G4RadioactiveDecayChainsFromParent::~G4RadioactiveDecayChainsFromParent()
{}
source/processes/hadronic/models/radioactive_decay/src/G4RadioactiveDecayRate.cc → source/processes/hadronic/models/radioactive_decay/src/G4RadioactiveDecayRatesToDaughter.cc
+10 -8
View File
@@ -23,21 +23,21 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// G4RadioactiveDecayRate.cc
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4DecayTable.hh"
#include "G4DecayProducts.hh"
#include "G4RadioactiveDecayRate.hh"
#include "G4RadioactiveDecayRatesToDaughter.hh"
G4RadioactiveDecayRate::G4RadioactiveDecayRate()
G4RadioactiveDecayRatesToDaughter::G4RadioactiveDecayRatesToDaughter()
: Z(0), A(0), E(0.0), generation(0), verboseLevel(0)
{}
G4RadioactiveDecayRate::G4RadioactiveDecayRate(const G4RadioactiveDecayRate& right)
G4RadioactiveDecayRatesToDaughter::
G4RadioactiveDecayRatesToDaughter(const G4RadioactiveDecayRatesToDaughter& right)
{
Z = right.Z;
A = right.A;
@@ -48,7 +48,9 @@ G4RadioactiveDecayRate::G4RadioactiveDecayRate(const G4RadioactiveDecayRate& rig
verboseLevel = right.verboseLevel;
}
G4RadioactiveDecayRate & G4RadioactiveDecayRate::operator=(const G4RadioactiveDecayRate &right)
G4RadioactiveDecayRatesToDaughter& G4RadioactiveDecayRatesToDaughter::
operator=(const G4RadioactiveDecayRatesToDaughter& right)
{
if (this != &right) {
Z = right.Z;
@@ -63,11 +65,11 @@ G4RadioactiveDecayRate & G4RadioactiveDecayRate::operator=(const G4RadioactiveDe
}
G4RadioactiveDecayRate::~G4RadioactiveDecayRate()
{ ;}
G4RadioactiveDecayRatesToDaughter::~G4RadioactiveDecayRatesToDaughter()
{}
void G4RadioactiveDecayRate::DumpInfo()
void G4RadioactiveDecayRatesToDaughter::DumpInfo()
{
G4cout << " Z: " << Z << " A: " << A << " E: " << E <<G4endl;
G4cout << " Generation: " << generation << G4endl;