G4RadioactiveDecay Class Reference

#include <G4RadioactiveDecay.hh>

Inheritance diagram for G4RadioactiveDecay:

Public Member Functions
	G4RadioactiveDecay (const G4String &processName="RadioactiveDecay")
	~G4RadioactiveDecay ()
virtual void	ProcessDescription (std::ostream &outFile) const
G4bool	IsApplicable (const G4ParticleDefinition &)
G4DecayTable *	GetDecayTable (const G4ParticleDefinition *)
void	SelectAVolume (const G4String &aVolume)
void	DeselectAVolume (const G4String &aVolume)
void	SelectAllVolumes ()
void	DeselectAllVolumes ()
void	SetARM (G4bool arm)
G4DecayTable *	LoadDecayTable (const G4ParticleDefinition &theParentNucleus)
void	AddUserDecayDataFile (G4int Z, G4int A, G4String filename)
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
void	SetNucleusLimits (G4NucleusLimits theNucleusLimits1)
G4NucleusLimits	GetNucleusLimits () const
void	SetDecayDirection (const G4ThreeVector &theDir)
const G4ThreeVector &	GetDecayDirection () const
void	SetDecayHalfAngle (G4double halfAngle=0.*CLHEP::deg)
G4double	GetDecayHalfAngle () const
void	SetDecayCollimation (const G4ThreeVector &theDir, G4double halfAngle=0.*CLHEP::deg)
void	SetThresholdForVeryLongDecayTime (const G4double inputThreshold)
G4double	GetThresholdForVeryLongDecayTime () const
void	BuildPhysicsTable (const G4ParticleDefinition &)
G4VParticleChange *	DecayIt (const G4Track &theTrack, const G4Step &theStep)
Public Member Functions inherited from G4VRestDiscreteProcess
	G4VRestDiscreteProcess (const G4String &, G4ProcessType aType=fNotDefined)
	G4VRestDiscreteProcess (G4VRestDiscreteProcess &)
virtual	~G4VRestDiscreteProcess ()
G4VRestDiscreteProcess &	operator= (const G4VRestDiscreteProcess &)=delete
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)
Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
	G4VProcess (const G4VProcess &right)
virtual	~G4VProcess ()
G4VProcess &	operator= (const G4VProcess &)=delete
G4bool	operator== (const G4VProcess &right) const
G4bool	operator!= (const G4VProcess &right) const
virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)=0
G4double	GetCurrentInteractionLength () const
void	SetPILfactor (G4double value)
G4double	GetPILfactor () const
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4bool	IsApplicable (const G4ParticleDefinition &)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	PreparePhysicsTable (const G4ParticleDefinition &)
virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
const G4String &	GetProcessName () const
G4ProcessType	GetProcessType () const
void	SetProcessType (G4ProcessType)
G4int	GetProcessSubType () const
void	SetProcessSubType (G4int)
virtual const G4VProcess *	GetCreatorProcess () const
virtual void	StartTracking (G4Track *)
virtual void	EndTracking ()
virtual void	SetProcessManager (const G4ProcessManager *)
virtual const G4ProcessManager *	GetProcessManager ()
virtual void	ResetNumberOfInteractionLengthLeft ()
G4double	GetNumberOfInteractionLengthLeft () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4bool	isAtRestDoItIsEnabled () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
virtual void	DumpInfo () const
virtual void	ProcessDescription (std::ostream &outfile) const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
virtual void	SetMasterProcess (G4VProcess *masterP)
const G4VProcess *	GetMasterProcess () const
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Protected Member Functions
void	DecayAnalog (const G4Track &theTrack)
G4DecayProducts *	DoDecay (const G4ParticleDefinition &theParticleDef)
void	CollimateDecay (G4DecayProducts *products)
void	CollimateDecayProduct (G4DynamicParticle *product)
G4ThreeVector	ChooseCollimationDirection () const
G4double	GetMeanFreePath (const G4Track &theTrack, G4double previousStepSize, G4ForceCondition *condition)
G4double	GetMeanLifeTime (const G4Track &theTrack, G4ForceCondition *condition)
virtual G4double	GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)=0
virtual G4double	GetMeanLifeTime (const G4Track &aTrack, G4ForceCondition *condition)=0
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)
void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes
G4ParticleChangeForRadDecay	fParticleChangeForRadDecay
G4RadioactiveDecayMessenger *	theRadioactiveDecayMessenger
G4PhotonEvaporation *	photonEvaporation
std::vector< G4String >	ValidVolumes
bool	isAllVolumesMode
DecayTableMap *	dkmap
Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager = nullptr
G4VParticleChange *	pParticleChange = nullptr
G4ParticleChange	aParticleChange
G4double	theNumberOfInteractionLengthLeft = -1.0
G4double	currentInteractionLength = -1.0
G4double	theInitialNumberOfInteractionLength = -1.0
G4String	theProcessName
G4String	thePhysicsTableFileName
G4ProcessType	theProcessType = fNotDefined
G4int	theProcessSubType = -1
G4double	thePILfactor = 1.0
G4int	verboseLevel = 0
G4bool	enableAtRestDoIt = true
G4bool	enableAlongStepDoIt = true
G4bool	enablePostStepDoIt = true

Static Protected Attributes
static const G4double	levelTolerance = 10.0*eV

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Detailed Description

Definition at line 63 of file G4RadioactiveDecay.hh.

Constructor & Destructor Documentation

G4RadioactiveDecay()

G4RadioactiveDecay::G4RadioactiveDecay

(

const G4String &

processName = "RadioactiveDecay"

)

Definition at line 113 of file G4RadioactiveDecay.cc.

 : G4VRestDiscreteProcess(processName, fDecay), isInitialised(false),
   forceDecayDirection(0.,0.,0.), forceDecayHalfAngle(0.*deg), dirPath(""),
   verboseLevel(1),
   fThresholdForVeryLongDecayTime( 1.0e+27*CLHEP::nanosecond )  // Longer than twice Universe's age
{
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 1) {
    G4cout << "G4RadioactiveDecay constructor: processName = " << processName
           << G4endl;
  }
#endif
 
  SetProcessSubType(fRadioactiveDecay);
 
  theRadioactiveDecayMessenger = new G4RadioactiveDecayMessenger(this);
  pParticleChange = &fParticleChangeForRadDecay;
 
  // Set up photon evaporation for use in G4ITDecay
  photonEvaporation = new G4PhotonEvaporation();
  photonEvaporation->RDMForced(true);
  photonEvaporation->SetICM(true);
 
  // DHW G4DeexPrecoParameters* deex = G4NuclearLevelData::GetInstance()->GetParameters();
  // DHW deex->SetCorrelatedGamma(true);
 
  // Check data directory
  const char* path_var = G4FindDataDir("G4RADIOACTIVEDATA");
  if (!path_var) {
    G4Exception("G4RadioactiveDecay()","HAD_RDM_200",FatalException,
                "Environment variable G4RADIOACTIVEDATA is not set");
  } else {
    dirPath = path_var;   // convert to string
    std::ostringstream os;
    os << dirPath << "/z1.a3";   // used as a dummy 
    std::ifstream testFile;
    testFile.open(os.str() );
    if (!testFile.is_open() )
      G4Exception("G4RadioactiveDecay()","HAD_RDM_201",FatalException,
                  "Environment variable G4RADIOACTIVEDATA is set, but does not point to correct directory");
  }
 
  // Reset the list of user defined data files
  theUserRadioactiveDataFiles.clear();
 
  // Instantiate the map of decay tables
#ifdef G4MULTITHREADED
  G4AutoLock lk(&G4RadioactiveDecay::radioactiveDecayMutex);
  NumberOfInstances()++;
  if(!master_dkmap) master_dkmap = new DecayTableMap;
#endif
  dkmap = new DecayTableMap;
 
  // Apply default values
  applyARM = true;
 
  // RDM applies to all logical volumes by default
  isAllVolumesMode = true;
  SelectAllVolumes();
  G4HadronicProcessStore::Instance()->RegisterExtraProcess(this);
}

~G4RadioactiveDecay()

G4RadioactiveDecay::~G4RadioactiveDecay

(

)

Definition at line 185 of file G4RadioactiveDecay.cc.

{
  delete theRadioactiveDecayMessenger;
  delete photonEvaporation;
  for (DecayTableMap::iterator i = dkmap->begin(); i != dkmap->end(); i++) {
    delete i->second;
  }
  dkmap->clear();
  delete dkmap;
#ifdef G4MULTITHREADED
  G4AutoLock lk(&G4RadioactiveDecay::radioactiveDecayMutex);
  --NumberOfInstances();
  if(NumberOfInstances()==0)
  {
    for (DecayTableMap::iterator i = master_dkmap->begin(); i != master_dkmap->end(); i++) {
      delete i->second;
    }
    master_dkmap->clear();
    delete master_dkmap;
  }
#endif
}

Member Function Documentation

AddUserDecayDataFile()

void G4RadioactiveDecay::AddUserDecayDataFile	(	G4int	Z,
		G4int	A,
		G4String	filename
	)

Definition at line 917 of file G4RadioactiveDecay.cc.

{
  if (Z < 1 || A < 2) G4cout << "Z and A not valid!" << G4endl;
 
  std::ifstream DecaySchemeFile(filename);
  if (DecaySchemeFile) {
    G4int ID_ion = A*1000 + Z;
    theUserRadioactiveDataFiles[ID_ion] = filename;
  } else {
    G4ExceptionDescription ed;
    ed << filename << " does not exist! " << G4endl;
    G4Exception("G4RadioactiveDecay::AddUserDecayDataFile()", "HAD_RDM_001",
                FatalException, ed);
  }
}

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

BuildPhysicsTable()

void G4RadioactiveDecay::BuildPhysicsTable ( const G4ParticleDefinition &  )

virtual

Reimplemented from G4VProcess.

Definition at line 449 of file G4RadioactiveDecay.cc.

{
  if (!isInitialised) {
    isInitialised = true;
#ifdef G4VERBOSE
    if(G4HadronicParameters::Instance()->GetVerboseLevel() > 0  &&
       G4Threading::IsMasterThread()) { StreamInfo(G4cout, "\n"); }
#endif
  }
  G4HadronicProcessStore::
   Instance()->RegisterParticleForExtraProcess(this,G4GenericIon::GenericIon());
}

ChooseCollimationDirection()

G4ThreeVector G4RadioactiveDecay::ChooseCollimationDirection ( ) const

protected

Definition at line 1312 of file G4RadioactiveDecay.cc.

                                                                   {
  if (origin == forceDecayDirection) return origin; // Don't do collimation
  if (forceDecayHalfAngle == 180.*deg) return origin;
 
  G4ThreeVector dir = forceDecayDirection;
 
  // Return direction offset by random throw
  if (forceDecayHalfAngle > 0.) {
    // Generate uniform direction around central axis
    G4double phi = 2.*pi*G4UniformRand();
    G4double cosMin = std::cos(forceDecayHalfAngle);
    G4double cosTheta = (1.-cosMin)*G4UniformRand() + cosMin;   // [cosMin,1.)
    
    dir.setPhi(dir.phi()+phi);
    dir.setTheta(dir.theta()+std::acos(cosTheta));
  }
 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    G4cout << " ChooseCollimationDirection returns " << dir << G4endl;
#endif
 
  return dir;
}

Referenced by CollimateDecayProduct().

CollimateDecay()

void G4RadioactiveDecay::CollimateDecay ( G4DecayProducts *  products )

protected

Definition at line 1267 of file G4RadioactiveDecay.cc.

                                                                 {
 
  if (origin == forceDecayDirection) return;    // No collimation requested
  if (180.*deg == forceDecayHalfAngle) return;
  if (0 == products || 0 == products->entries()) return;
 
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 1) G4cout << "Begin of CollimateDecay..." << G4endl;
#endif
 
  // Particles suitable for directional biasing (for if-blocks below)
  static const G4ParticleDefinition* electron = G4Electron::Definition();
  static const G4ParticleDefinition* positron = G4Positron::Definition();
  static const G4ParticleDefinition* neutron  = G4Neutron::Definition();
  static const G4ParticleDefinition* gamma    = G4Gamma::Definition();
  static const G4ParticleDefinition* alpha    = G4Alpha::Definition();
  static const G4ParticleDefinition* triton  = G4Triton::Definition();
  static const G4ParticleDefinition* proton   = G4Proton::Definition();
 
  G4ThreeVector newDirection;       // Re-use to avoid memory churn
  for (G4int i=0; i<products->entries(); i++) {
    G4DynamicParticle* daughter = (*products)[i];
    const G4ParticleDefinition* daughterType =
                                  daughter->GetParticleDefinition();
    if (daughterType == electron || daughterType == positron ||
    daughterType == neutron || daughterType == gamma ||
    daughterType == alpha || daughterType == triton || daughterType == proton) CollimateDecayProduct(daughter);
  }
}

Referenced by DoDecay().

CollimateDecayProduct()

void G4RadioactiveDecay::CollimateDecayProduct ( G4DynamicParticle *  product )

protected

Definition at line 1297 of file G4RadioactiveDecay.cc.

                                                                          {
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 1) {
    G4cout << "CollimateDecayProduct for daughter "
       << daughter->GetParticleDefinition()->GetParticleName() << G4endl;
  }
#endif
 
  G4ThreeVector collimate = ChooseCollimationDirection();
  if (origin != collimate) daughter->SetMomentumDirection(collimate);
}

Referenced by CollimateDecay().

DecayAnalog()

void G4RadioactiveDecay::DecayAnalog ( const G4Track &  theTrack )

protected

Definition at line 1107 of file G4RadioactiveDecay.cc.

{
  const G4DynamicParticle* theParticle = theTrack.GetDynamicParticle();
  const G4ParticleDefinition* theParticleDef = theParticle->GetDefinition();
  G4DecayProducts* products = DoDecay(*theParticleDef);
 
  // Check if the product is the same as input and kill the track if
  // necessary to prevent infinite loop (11/05/10, F.Lei)
  if (products->entries() == 1) {
    fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
    fParticleChangeForRadDecay.ProposeTrackStatus(fStopAndKill);
    fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
    ClearNumberOfInteractionLengthLeft();
    delete products;
    return;
  }
 
  G4double energyDeposit = 0.0;
  G4double finalGlobalTime = theTrack.GetGlobalTime();
  G4double finalLocalTime = theTrack.GetLocalTime();
 
  // Get parent particle information and boost the decay products to the
  // laboratory frame
 
  // ParentEnergy used for the boost should be the total energy of the nucleus
  // of the parent ion without the energy of the shell electrons
  // (correction for bug 1359 by L. Desorgher)
  G4double ParentEnergy = theParticle->GetKineticEnergy()
                        + theParticle->GetParticleDefinition()->GetPDGMass();
  G4ThreeVector ParentDirection(theParticle->GetMomentumDirection());
 
  if (theTrack.GetTrackStatus() == fStopButAlive) {
    // this condition seems to be always True, further investigation is needed (L.Desorgher)
 
    // The particle is decayed at rest
    // Since the time is for the particle at rest, need to add additional time
    // lapsed between particle coming to rest and the actual decay.  This time
    // is sampled with the mean-life of the particle.  Need to protect the case 
    // PDGTime < 0.  (F.Lei 11/05/10)
    G4double temptime = -std::log(G4UniformRand() ) *
                        theParticleDef->GetPDGLifeTime();
    if (temptime < 0.) temptime = 0.;
    finalGlobalTime += temptime;
    finalLocalTime += temptime;
    energyDeposit += theParticle->GetKineticEnergy();
    
    // Kill the parent particle, and ignore its decay, if it decays later than the
    // threshold fThresholdForVeryLongDecayTime (whose default value corresponds
    // to more than twice the age of the universe).
    // This kind of cut has been introduced (in April 2021) in order to avoid to
    // account energy depositions happening after many billions of years in
    // ordinary materials used in calorimetry, in particular Tungsten and Lead
    // (via their natural unstable, but very long lived, isotopes, such as
    // W183, W180 and Pb204).
    // Note that the cut is not on the average, mean lifetime, but on the actual
    // sampled global decay time.
    if ( finalGlobalTime > fThresholdForVeryLongDecayTime ) {
      fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
      fParticleChangeForRadDecay.ProposeTrackStatus(fStopAndKill) ;
      fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
      ClearNumberOfInteractionLengthLeft();
      delete products;
      return;
    }     
  }
  products->Boost(ParentEnergy, ParentDirection);
 
  // Add products in theParticleChangeForRadDecay.
  G4int numberOfSecondaries = products->entries();
  fParticleChangeForRadDecay.SetNumberOfSecondaries(numberOfSecondaries);
 
  if (GetVerboseLevel() > 1) {
    G4cout << "G4RadioactiveDecay::DecayAnalog: Decay vertex :";
    G4cout << " Time: " << finalGlobalTime/ns << "[ns]";
    G4cout << " X:" << (theTrack.GetPosition()).x() /cm << "[cm]";
    G4cout << " Y:" << (theTrack.GetPosition()).y() /cm << "[cm]";
    G4cout << " Z:" << (theTrack.GetPosition()).z() /cm << "[cm]";
    G4cout << G4endl;
    G4cout << "G4Decay::DecayIt : decay products in Lab. Frame" << G4endl;
    products->DumpInfo();
    products->IsChecked();
  }
 
  const G4int modelID_forIT = G4PhysicsModelCatalog::GetModelID( "model_RDM_IT" );
  G4int modelID = modelID_forIT + 10*theRadDecayMode;
  const G4int modelID_forAtomicRelaxation =
    G4PhysicsModelCatalog::GetModelID( "model_RDM_AtomicRelaxation" );
  for ( G4int index = 0; index < numberOfSecondaries; ++index ) {
    G4Track* secondary = new G4Track( products->PopProducts(), finalGlobalTime,
                                      theTrack.GetPosition() );
    secondary->SetWeight( theTrack.GetWeight() );
    secondary->SetCreatorModelID( modelID );
    // Change for atomics relaxation
    if ( theRadDecayMode == IT  &&  index > 0 ) {
      if ( index == numberOfSecondaries-1 ) {
    secondary->SetCreatorModelID( modelID_forIT );
      } else {
    secondary->SetCreatorModelID( modelID_forAtomicRelaxation) ;
      }
    } else if ( theRadDecayMode >= KshellEC  &&  theRadDecayMode <= NshellEC  &&
        index < numberOfSecondaries-1 ) {
      secondary->SetCreatorModelID( modelID_forAtomicRelaxation );
    }
    secondary->SetGoodForTrackingFlag();
    secondary->SetTouchableHandle( theTrack.GetTouchableHandle() );
    fParticleChangeForRadDecay.AddSecondary( secondary );
  }
 
  delete products;
 
  // Kill the parent particle
  fParticleChangeForRadDecay.ProposeTrackStatus(fStopAndKill) ;
  fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(energyDeposit);
  fParticleChangeForRadDecay.ProposeLocalTime(finalLocalTime);
 
  // Reset NumberOfInteractionLengthLeft.
  ClearNumberOfInteractionLengthLeft();
}

Referenced by G4Radioactivation::DecayIt(), and DecayIt().

DecayIt()

G4VParticleChange * G4RadioactiveDecay::DecayIt	(	const G4Track &	theTrack,
		const G4Step &	theStep
	)

Definition at line 940 of file G4RadioactiveDecay.cc.

{
  // Initialize G4ParticleChange object, get particle details and decay table
  fParticleChangeForRadDecay.Initialize(theTrack);
  fParticleChangeForRadDecay.ProposeWeight(theTrack.GetWeight());
  const G4DynamicParticle* theParticle = theTrack.GetDynamicParticle();
  const G4ParticleDefinition* theParticleDef = theParticle->GetDefinition();
 
  // First check whether RDM applies to the current logical volume
  if (!isAllVolumesMode) {
    if (!std::binary_search(ValidVolumes.begin(), ValidVolumes.end(),
                     theTrack.GetVolume()->GetLogicalVolume()->GetName())) {
#ifdef G4VERBOSE
      if (GetVerboseLevel()>1) {
        G4cout <<"G4RadioactiveDecay::DecayIt : "
               << theTrack.GetVolume()->GetLogicalVolume()->GetName()
               << " is not selected for the RDM"<< G4endl;
        G4cout << " There are " << ValidVolumes.size() << " volumes" << G4endl;
        G4cout << " The Valid volumes are " << G4endl;
        for (std::size_t i = 0; i< ValidVolumes.size(); ++i)
                                  G4cout << ValidVolumes[i] << G4endl;
      }
#endif
      fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
 
      // Kill the parent particle.
      fParticleChangeForRadDecay.ProposeTrackStatus(fStopAndKill) ;
      fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
      ClearNumberOfInteractionLengthLeft();
      return &fParticleChangeForRadDecay;
    }
  }
 
  // Now check if particle is valid for RDM
  if (!(IsApplicable(*theParticleDef) ) ) { 
    // Particle is not an ion or is outside the nucleuslimits for decay
#ifdef G4VERBOSE
    if (GetVerboseLevel() > 1) {
      G4cout << "G4RadioactiveDecay::DecayIt : "
             << theParticleDef->GetParticleName() 
             << " is not an ion or is outside (Z,A) limits set for the decay. " 
             << " Set particle change accordingly. "
             << G4endl;
    }
#endif
    fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
 
    // Kill the parent particle
    fParticleChangeForRadDecay.ProposeTrackStatus(fStopAndKill) ;
    fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
    ClearNumberOfInteractionLengthLeft();
    return &fParticleChangeForRadDecay;
  }
 
  G4DecayTable* theDecayTable = GetDecayTable(theParticleDef);
 
  if (theDecayTable == 0 || theDecayTable->entries() == 0) {
    // No data in the decay table.  Set particle change parameters
    // to indicate this.
#ifdef G4VERBOSE
    if (GetVerboseLevel() > 1) {
      G4cout << "G4RadioactiveDecay::DecayIt : "
             << "decay table not defined for "
             << theParticleDef->GetParticleName() 
             << ". Set particle change accordingly. "
             << G4endl;
    }
#endif
    fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
 
    // Kill the parent particle.
    fParticleChangeForRadDecay.ProposeTrackStatus(fStopAndKill) ;
    fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
    ClearNumberOfInteractionLengthLeft();
    return &fParticleChangeForRadDecay;
 
  } else { 
    // Data found.  Try to decay nucleus
 
/*
    G4double energyDeposit = 0.0;
    G4double finalGlobalTime = theTrack.GetGlobalTime();
    G4double finalLocalTime = theTrack.GetLocalTime();
    G4int index;
    G4ThreeVector currentPosition;
    currentPosition = theTrack.GetPosition();
 
    G4DecayProducts* products = DoDecay(*theParticleDef);
 
    // If the product is the same as the input kill the track if
    // necessary to prevent infinite loop (11/05/10, F.Lei)
    if (products->entries() == 1) {
      fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
      fParticleChangeForRadDecay.ProposeTrackStatus(fStopAndKill);
      fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
      ClearNumberOfInteractionLengthLeft();
      return &fParticleChangeForRadDecay;
    }
 
    // Get parent particle information and boost the decay products to the
    // laboratory frame based on this information.
 
    // The Parent Energy used for the boost should be the total energy of
    // the nucleus of the parent ion without the energy of the shell electrons
    // (correction for bug 1359 by L. Desorgher)
    G4double ParentEnergy = theParticle->GetKineticEnergy()
                          + theParticle->GetParticleDefinition()->GetPDGMass();
    G4ThreeVector ParentDirection(theParticle->GetMomentumDirection());
 
    if (theTrack.GetTrackStatus() == fStopButAlive) {
      // This condition seems to be always True, further investigation is needed
      // (L.Desorgher)
      // The particle is decayed at rest.
      // since the time is still for rest particle in G4 we need to add the
      // additional time lapsed between the particle come to rest and the
      // actual decay.  This time is simply sampled with the mean-life of
      // the particle.  But we need to protect the case PDGTime < 0.
      // (F.Lei 11/05/10)
      G4double temptime = -std::log( G4UniformRand())
                          *theParticleDef->GetPDGLifeTime();
      if (temptime < 0.) temptime = 0.; 
      finalGlobalTime += temptime;
      finalLocalTime += temptime;
      energyDeposit += theParticle->GetKineticEnergy();
    }
    products->Boost(ParentEnergy, ParentDirection);
 
    // Add products in theParticleChangeForRadDecay.
    G4int numberOfSecondaries = products->entries();
    fParticleChangeForRadDecay.SetNumberOfSecondaries(numberOfSecondaries);
 
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1) {
      G4cout <<"G4RadioactiveDecay::DecayIt : Decay vertex :";
      G4cout <<" Time: " <<finalGlobalTime/ns <<"[ns]";
      G4cout <<" X:" <<(theTrack.GetPosition()).x() /cm <<"[cm]";
      G4cout <<" Y:" <<(theTrack.GetPosition()).y() /cm <<"[cm]";
      G4cout <<" Z:" <<(theTrack.GetPosition()).z() /cm <<"[cm]";
      G4cout << G4endl;
      G4cout <<"G4Decay::DecayIt  : decay products in Lab. Frame" <<G4endl;
      products->DumpInfo();
      products->IsChecked();
    }
#endif
    for (index=0; index < numberOfSecondaries; index++) {
      G4Track* secondary = new G4Track(products->PopProducts(),
                                       finalGlobalTime, currentPosition);
      secondary->SetGoodForTrackingFlag();
      secondary->SetTouchableHandle(theTrack.GetTouchableHandle());
      fParticleChangeForRadDecay.AddSecondary(secondary);
    }
    delete products;
 
    // Kill the parent particle
    fParticleChangeForRadDecay.ProposeTrackStatus(fStopAndKill) ;
    fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(energyDeposit); 
    fParticleChangeForRadDecay.ProposeLocalTime(finalLocalTime);
    // Reset NumberOfInteractionLengthLeft.
    ClearNumberOfInteractionLengthLeft();
*/
    // Decay without variance reduction 
    DecayAnalog(theTrack);
    return &fParticleChangeForRadDecay ;
  }
} 

DeselectAllVolumes()

void G4RadioactiveDecay::DeselectAllVolumes

(

)

Definition at line 332 of file G4RadioactiveDecay.cc.

{
  ValidVolumes.clear();
  isAllVolumesMode=false;
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 1) G4cout << "RDM removed from all volumes" << G4endl; 
#endif
}

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

DeselectAVolume()

void G4RadioactiveDecay::DeselectAVolume

(

const G4String &

aVolume

)

Definition at line 273 of file G4RadioactiveDecay.cc.

{
  G4LogicalVolumeStore* theLogicalVolumes = G4LogicalVolumeStore::GetInstance();
  G4LogicalVolume* volume = nullptr;
  volume = theLogicalVolumes->GetVolume(aVolume);
  if (volume != nullptr)
  {
    auto location= std::find(ValidVolumes.cbegin(),ValidVolumes.cend(),aVolume);
    if (location != ValidVolumes.cend() )
    {
      ValidVolumes.erase(location);
      std::sort(ValidVolumes.begin(), ValidVolumes.end());
      isAllVolumesMode = false;
      if (GetVerboseLevel() > 0)
        G4cout << " G4RadioactiveDecay::DeselectAVolume: " << aVolume
               << " is removed from list " << G4endl;
    }
    else
    {
      G4ExceptionDescription ed;
      ed << aVolume << " is not in the list.  No action taken." << G4endl;
      G4Exception("G4RadioactiveDecay::DeselectAVolume()", "HAD_RDM_300",
                  JustWarning, ed);
    }
  }
  else
  {
    G4ExceptionDescription ed;
    ed << aVolume << " is not a valid logical volume name.  No action taken." 
       << G4endl;
    G4Exception("G4RadioactiveDecay::DeselectAVolume()", "HAD_RDM_300",
                JustWarning, ed);
  }
}

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

DoDecay()

G4DecayProducts * G4RadioactiveDecay::DoDecay ( const G4ParticleDefinition &  theParticleDef )

protected

Definition at line 1228 of file G4RadioactiveDecay.cc.

{
  G4DecayProducts* products = 0;
  G4DecayTable* theDecayTable = GetDecayTable(&theParticleDef);
 
  // Choose a decay channel.
  // G4DecayTable::SelectADecayChannel checks to see if sum of daughter masses
  // exceeds parent mass. Pass it the parent mass + maximum Q value to account
  // for difference in mass defect.
  G4double parentPlusQ = theParticleDef.GetPDGMass() + 30.*MeV;
  G4VDecayChannel* theDecayChannel = theDecayTable->SelectADecayChannel(parentPlusQ);
 
  if (theDecayChannel == 0) {
    // Decay channel not found.
    G4ExceptionDescription ed;
    ed << " Cannot determine decay channel for " << theParticleDef.GetParticleName() << G4endl;
    G4Exception("G4RadioactiveDecay::DoDecay", "HAD_RDM_013",
                FatalException, ed);
  } else {
    // A decay channel has been identified, so execute the DecayIt.
#ifdef G4VERBOSE
    if (GetVerboseLevel() > 1) {
      G4cout << "G4RadioactiveDecay::DoIt : selected decay channel addr: "
             << theDecayChannel << G4endl;
    }
#endif
    theRadDecayMode = (static_cast<G4NuclearDecay*>(theDecayChannel))->GetDecayMode();
    products = theDecayChannel->DecayIt(theParticleDef.GetPDGMass() );
 
    // Apply directional bias if requested by user
    CollimateDecay(products);
  }
 
  return products;
}

Referenced by DecayAnalog(), and G4Radioactivation::DecayIt().

GetDecayDirection()

const G4ThreeVector & G4RadioactiveDecay::GetDecayDirection ( ) const

inline

Definition at line 131 of file G4RadioactiveDecay.hh.

                                                          {
      return forceDecayDirection; 
    }

GetDecayHalfAngle()

G4double G4RadioactiveDecay::GetDecayHalfAngle ( ) const

inline

Definition at line 139 of file G4RadioactiveDecay.hh.

{return forceDecayHalfAngle;}

GetDecayTable()

G4DecayTable * G4RadioactiveDecay::GetDecayTable

(

const G4ParticleDefinition *

aNucleus

)

Definition at line 231 of file G4RadioactiveDecay.cc.

{
  G4String key = aNucleus->GetParticleName();
  DecayTableMap::iterator table_ptr = dkmap->find(key);
 
  G4DecayTable* theDecayTable = 0;
  if (table_ptr == dkmap->end() ) {                   // If table not there,     
    theDecayTable = LoadDecayTable(*aNucleus);        // load from file and
    if(theDecayTable) (*dkmap)[key] = theDecayTable;  // store in library 
  } else {
    theDecayTable = table_ptr->second;
  }
  return theDecayTable;
}

Referenced by DecayIt(), and DoDecay().

GetMeanFreePath()

G4double G4RadioactiveDecay::GetMeanFreePath ( const G4Track &  theTrack, G4double  previousStepSize, G4ForceCondition *  condition  )

protectedvirtual

Implements G4VRestDiscreteProcess.

Definition at line 384 of file G4RadioactiveDecay.cc.

{
  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
  const G4ParticleDefinition* aParticleDef = aParticle->GetDefinition();
  G4double tau = aParticleDef->GetPDGLifeTime();
  G4double aMass = aParticle->GetMass();
 
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2) {
    G4cout << "G4RadioactiveDecay::GetMeanFreePath() " << G4endl;
    G4cout << "  KineticEnergy: " << aParticle->GetKineticEnergy()/GeV
           << " GeV, Mass: " << aMass/GeV << " GeV, tau: " << tau << " ns "
           << G4endl;
  }
#endif
  G4double pathlength = DBL_MAX;
  if (tau != -1) {
    // Ion can decay
 
    if (tau < -1000.0) {
      pathlength = DBL_MIN;  // nuclide had very short lifetime or wasn't in table
 
    } else if (tau < 0.0) {
      G4cout << aParticleDef->GetParticleName() << " has lifetime " << tau << G4endl;
      G4ExceptionDescription ed;
      ed << "Ion has negative lifetime " << tau
         << " but is not stable.  Setting mean free path to DBL_MAX" << G4endl; 
      G4Exception("G4RadioactiveDecay::GetMeanFreePath()", "HAD_RDM_011",
                   JustWarning, ed);
      pathlength = DBL_MAX;
 
    } else {
      // Calculate mean free path
      G4double betaGamma = aParticle->GetTotalMomentum()/aMass;
      pathlength = c_light*tau*betaGamma;
 
      if (pathlength < DBL_MIN) {
        pathlength = DBL_MIN;
#ifdef G4VERBOSE
        if (GetVerboseLevel() > 2) {
          G4cout << "G4Decay::GetMeanFreePath: "
                 << aParticleDef->GetParticleName()
                 << " stops, kinetic energy = "
                 << aParticle->GetKineticEnergy()/keV <<" keV " << G4endl;
        }
#endif
      }
    }
  }
 
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2) {
    G4cout << "mean free path: "<< pathlength/m << " m" << G4endl;
  }
#endif
  return  pathlength;
}

GetMeanLifeTime()

G4double G4RadioactiveDecay::GetMeanLifeTime ( const G4Track &  theTrack, G4ForceCondition *  condition  )

protectedvirtual

Implements G4VRestDiscreteProcess.

Definition at line 348 of file G4RadioactiveDecay.cc.

{
  G4double meanlife = 0.;
  const G4DynamicParticle* theParticle = theTrack.GetDynamicParticle();
  const G4ParticleDefinition* theParticleDef = theParticle->GetDefinition();
  G4double theLife = theParticleDef->GetPDGLifeTime();
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2) {
    G4cout << "G4RadioactiveDecay::GetMeanLifeTime() " << G4endl;
    G4cout << "KineticEnergy: " << theParticle->GetKineticEnergy()/GeV
           << " GeV, Mass: " << theParticle->GetMass()/GeV
           << " GeV, Life time: " << theLife/ns << " ns " << G4endl;
  }
#endif
  if (theParticleDef->GetPDGStable()) {meanlife = DBL_MAX;}
  else if (theLife < 0.0) {meanlife = DBL_MAX;}
  else {meanlife = theLife;}
  // Set meanlife to zero for excited istopes which are not in the
  // RDM database
  if (((const G4Ions*)(theParticleDef))->GetExcitationEnergy() > 0. &&
                                        meanlife == DBL_MAX) {meanlife = 0.;}
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2)
    G4cout << " mean life time: " << meanlife/s << " s " << G4endl;
#endif
 
  return meanlife;
}

Referenced by G4Radioactivation::GetMeanLifeTime().

GetNucleusLimits()

G4NucleusLimits G4RadioactiveDecay::GetNucleusLimits ( ) const

inline

Definition at line 125 of file G4RadioactiveDecay.hh.

{return theNucleusLimits;}

GetThresholdForVeryLongDecayTime()

G4double G4RadioactiveDecay::GetThresholdForVeryLongDecayTime ( ) const

inline

Definition at line 153 of file G4RadioactiveDecay.hh.

{return fThresholdForVeryLongDecayTime;}

GetVerboseLevel()

G4int G4RadioactiveDecay::GetVerboseLevel ( ) const

inline

Definition at line 115 of file G4RadioactiveDecay.hh.

{return verboseLevel;}

Referenced by BuildPhysicsTable(), G4Radioactivation::CalculateChainsFromParent(), ChooseCollimationDirection(), CollimateDecay(), CollimateDecayProduct(), G4Radioactivation::ConvolveSourceTimeProfile(), DecayAnalog(), G4Radioactivation::DecayIt(), DecayIt(), DeselectAllVolumes(), DeselectAVolume(), DoDecay(), G4Radioactivation::G4Radioactivation(), G4RadioactiveDecay(), G4Radioactivation::GetChainsFromParent(), G4Radioactivation::GetDecayTime(), GetMeanFreePath(), GetMeanLifeTime(), LoadDecayTable(), SelectAllVolumes(), SelectAVolume(), G4Radioactivation::SetDecayBias(), and G4Radioactivation::SetSourceTimeProfile().

IsApplicable()

G4bool G4RadioactiveDecay::IsApplicable ( const G4ParticleDefinition &  aParticle )

virtual

Reimplemented from G4VProcess.

Definition at line 209 of file G4RadioactiveDecay.cc.

{
  // All particles other than G4Ions, are rejected by default
  if (((const G4Ions*)(&aParticle))->GetExcitationEnergy() > 0.) {return true;}
  if (aParticle.GetParticleName() == "GenericIon") {
    return true;
  } else if (!(aParticle.GetParticleType() == "nucleus")
             || aParticle.GetPDGLifeTime() < 0. ) {
    return false;
  }
 
  // Determine whether the nuclide falls into the correct A and Z range
  G4int A = ((const G4Ions*) (&aParticle))->GetAtomicMass();
  G4int Z = ((const G4Ions*) (&aParticle))->GetAtomicNumber();
 
  if (A > theNucleusLimits.GetAMax() || A < theNucleusLimits.GetAMin())
    {return false;}
  else if (Z > theNucleusLimits.GetZMax() || Z < theNucleusLimits.GetZMin())
    {return false;}
  return true;
}

Referenced by G4Radioactivation::CalculateChainsFromParent(), G4Radioactivation::DecayIt(), and DecayIt().

LoadDecayTable()

G4DecayTable * G4RadioactiveDecay::LoadDecayTable

(

const G4ParticleDefinition &

theParentNucleus

)

Definition at line 523 of file G4RadioactiveDecay.cc.

{
  // Generate input data file name using Z and A of the parent nucleus
  // file containing radioactive decay data.
  G4int A = ((const G4Ions*)(&theParentNucleus))->GetAtomicMass();
  G4int Z = ((const G4Ions*)(&theParentNucleus))->GetAtomicNumber();
 
  G4double levelEnergy = ((const G4Ions*)(&theParentNucleus))->GetExcitationEnergy();
  G4Ions::G4FloatLevelBase floatingLevel =
    ((const G4Ions*)(&theParentNucleus))->GetFloatLevelBase();
 
#ifdef G4MULTITHREADED
  G4AutoLock lk(&G4RadioactiveDecay::radioactiveDecayMutex);
 
  G4String key = theParentNucleus.GetParticleName();
  DecayTableMap::iterator master_table_ptr = master_dkmap->find(key);
 
  if (master_table_ptr != master_dkmap->end() ) {   // If table is there              
    return master_table_ptr->second;
  }
#endif
 
  //Check if data have been provided by the user
  G4String file = theUserRadioactiveDataFiles[1000*A+Z];
 
  if (file == "") {
    std::ostringstream os;
    os << dirPath << "/z" << Z << ".a" << A << '\0';
    file = os.str();
  }
 
  G4DecayTable* theDecayTable = new G4DecayTable();
  G4bool found(false);     // True if energy level matches one in table
 
  std::ifstream DecaySchemeFile;
  DecaySchemeFile.open(file);
 
  if (DecaySchemeFile.good()) {
    // Initialize variables used for reading in radioactive decay data
    G4bool floatMatch(false);
    const G4int nMode = G4RadioactiveDecayModeSize;
    G4double modeTotalBR[nMode] = {0.0};
    G4double modeSumBR[nMode];
    for (G4int i = 0; i < nMode; i++) {
      modeSumBR[i] = 0.0;
    }
 
    char inputChars[120]={' '};
    G4String inputLine;
    G4String recordType("");
    G4String floatingFlag("");
    G4String daughterFloatFlag("");
    G4Ions::G4FloatLevelBase daughterFloatLevel;
    G4RadioactiveDecayMode theDecayMode;
    G4double decayModeTotal(0.0);
    G4double parentExcitation(0.0);
    G4double a(0.0);
    G4double b(0.0);
    G4double c(0.0);
    G4double dummy(0.0);
    G4BetaDecayType betaType(allowed);
 
    // Loop through each data file record until you identify the decay
    // data relating to the nuclide of concern.
 
    G4bool complete(false);  // bool insures only one set of values read for any
                             // given parent energy level
    G4int loop = 0;
    while (!complete && !DecaySchemeFile.getline(inputChars, 120).eof()) {  /* Loop checking, 01.09.2015, D.Wright */
      loop++;
      if (loop > 100000) {
        G4Exception("G4RadioactiveDecay::LoadDecayTable()", "HAD_RDM_100",
                    JustWarning, "While loop count exceeded");
        break;
      }
 
      inputLine = inputChars;
      G4StrUtil::rstrip(inputLine);
      if (inputChars[0] != '#' && inputLine.length() != 0) {
        std::istringstream tmpStream(inputLine);
 
        if (inputChars[0] == 'P') {
          // Nucleus is a parent type.  Check excitation level to see if it
          // matches that of theParentNucleus
          tmpStream >> recordType >> parentExcitation >> floatingFlag >> dummy;
          // "dummy" takes the place of half-life
          //  Now read in from ENSDFSTATE in particle category
 
          if (found) {
            complete = true;
          } else {
            // Take first level which matches excitation energy regardless of floating level
            found = (std::abs(parentExcitation*keV - levelEnergy) < levelTolerance);
            if (floatingLevel != noFloat) {
              // If floating level specificed, require match of both energy and floating level
              floatMatch = (floatingLevel == G4Ions::FloatLevelBase(floatingFlag.back()) );
              if (!floatMatch) found = false;
            }
          }
 
        } else if (found) {
          // The right part of the radioactive decay data file has been found.  Search
          // through it to determine the mode of decay of the subsequent records.
 
          // Store for later the total decay probability for each decay mode 
          if (inputLine.length() < 72) {
            tmpStream >> theDecayMode >> dummy >> decayModeTotal;
            switch (theDecayMode) {
              case IT:
                {
                G4ITDecay* anITChannel = new G4ITDecay(&theParentNucleus, decayModeTotal,
                                                       0.0, 0.0, photonEvaporation);
//                anITChannel->SetHLThreshold(halflifethreshold);
                anITChannel->SetARM(applyARM);
                theDecayTable->Insert(anITChannel);
//                anITChannel->DumpNuclearInfo();
                }
                break;
              case BetaMinus:
                modeTotalBR[BetaMinus] = decayModeTotal; break;
              case BetaPlus:
                modeTotalBR[BetaPlus] = decayModeTotal; break;
              case KshellEC:
                modeTotalBR[KshellEC] = decayModeTotal; break;
              case LshellEC:
                modeTotalBR[LshellEC] = decayModeTotal; break;
              case MshellEC:
                modeTotalBR[MshellEC] = decayModeTotal; break;
              case NshellEC:
                modeTotalBR[NshellEC] = decayModeTotal; break;
              case Alpha:
                modeTotalBR[Alpha] = decayModeTotal; break;
              case Proton:
                modeTotalBR[Proton] = decayModeTotal; break;
              case Neutron:
                modeTotalBR[Neutron] = decayModeTotal; break;
              case SpFission:
                modeTotalBR[SpFission] = decayModeTotal; break;
              case BDProton:
                /* Not yet implemented */  break;
              case BDNeutron:
                /* Not yet implemented */  break;
              case Beta2Minus:
                /* Not yet implemented */  break;
              case Beta2Plus:
                /* Not yet implemented */  break;
              case Proton2:
                /* Not yet implemented */  break;
              case Neutron2:
                /* Not yet implemented */  break;
              case Triton:
                modeTotalBR[Triton] = decayModeTotal; break;
              case RDM_ERROR:
 
              default:
                G4Exception("G4RadioactiveDecay::LoadDecayTable()", "HAD_RDM_000",
                            FatalException, "Selected decay mode does not exist");
            }  // switch
 
          } else {
            if (inputLine.length() < 84) {
              tmpStream >> theDecayMode >> a >> daughterFloatFlag >> b >> c;
              betaType = allowed;
            } else {
              tmpStream >> theDecayMode >> a >> daughterFloatFlag >> b >> c >> betaType;
            }
 
            // Allowed transitions are the default. Forbidden transitions are
            // indicated in the last column.
            a /= 1000.;
            c /= 1000.;
            b /= 100.;
            daughterFloatLevel = G4Ions::FloatLevelBase(daughterFloatFlag.back());
 
            switch (theDecayMode) {
              case BetaMinus:
              {
                G4BetaMinusDecay* aBetaMinusChannel =
                  new G4BetaMinusDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                       daughterFloatLevel, betaType);
//              aBetaMinusChannel->DumpNuclearInfo();
//                aBetaMinusChannel->SetHLThreshold(halflifethreshold);
                theDecayTable->Insert(aBetaMinusChannel);
                modeSumBR[BetaMinus] += b;
              }
              break;
 
              case BetaPlus:
              {
                G4BetaPlusDecay* aBetaPlusChannel =
                  new G4BetaPlusDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                      daughterFloatLevel, betaType);
//              aBetaPlusChannel->DumpNuclearInfo();
//                aBetaPlusChannel->SetHLThreshold(halflifethreshold);
                theDecayTable->Insert(aBetaPlusChannel);
                modeSumBR[BetaPlus] += b;
              }
              break;
 
              case KshellEC:  // K-shell electron capture
              {
                G4ECDecay* aKECChannel =
                  new G4ECDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                daughterFloatLevel, KshellEC);
//              aKECChannel->DumpNuclearInfo();
//                aKECChannel->SetHLThreshold(halflifethreshold);
                aKECChannel->SetARM(applyARM);
                theDecayTable->Insert(aKECChannel);
                modeSumBR[KshellEC] += b;
              }
              break;
 
              case LshellEC:  // L-shell electron capture
              {
                G4ECDecay* aLECChannel =
                  new G4ECDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                daughterFloatLevel, LshellEC);
//              aLECChannel->DumpNuclearInfo();
//                aLECChannel->SetHLThreshold(halflifethreshold);
                aLECChannel->SetARM(applyARM);
                theDecayTable->Insert(aLECChannel);
                modeSumBR[LshellEC] += b;
              }
              break;
 
              case MshellEC:  // M-shell electron capture
              {
                G4ECDecay* aMECChannel =
                  new G4ECDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                daughterFloatLevel, MshellEC);
//              aMECChannel->DumpNuclearInfo();
//                aMECChannel->SetHLThreshold(halflifethreshold);
                aMECChannel->SetARM(applyARM);
                theDecayTable->Insert(aMECChannel);
                modeSumBR[MshellEC] += b;
              }
              break;
 
              case NshellEC:  // N-shell electron capture
              {
                G4ECDecay* aNECChannel =
                  new G4ECDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                daughterFloatLevel, NshellEC);
//              aNECChannel->DumpNuclearInfo();
//                aNECChannel->SetHLThreshold(halflifethreshold);
                aNECChannel->SetARM(applyARM);
                theDecayTable->Insert(aNECChannel);
                modeSumBR[NshellEC] += b;
              }
              break;
 
              case Alpha:
              {
                G4AlphaDecay* anAlphaChannel =
                  new G4AlphaDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                   daughterFloatLevel);
//              anAlphaChannel->DumpNuclearInfo();
//                anAlphaChannel->SetHLThreshold(halflifethreshold);
                theDecayTable->Insert(anAlphaChannel);
                modeSumBR[Alpha] += b;
              }
              break;
 
          case Proton:
              {
                G4ProtonDecay* aProtonChannel =
                  new G4ProtonDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                    daughterFloatLevel);
//              aProtonChannel->DumpNuclearInfo();
//                aProtonChannel->SetHLThreshold(halflifethreshold);
                theDecayTable->Insert(aProtonChannel);
                modeSumBR[Proton] += b;
              }
              break;
 
              case Neutron:
              {
                G4NeutronDecay* aNeutronChannel =
                  new G4NeutronDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                     daughterFloatLevel);
//              aNeutronChannel->DumpNuclearInfo();
//                aNeutronChannel->SetHLThreshold(halflifethreshold);
                theDecayTable->Insert(aNeutronChannel);
                modeSumBR[Neutron] += b;
              }
              break;
 
              case SpFission:
              {
                G4SFDecay* aSpontFissChannel =
//                  new G4SFDecay(&theParentNucleus, decayModeTotal, 0.0, 0.0);
                  new G4SFDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                daughterFloatLevel);
                theDecayTable->Insert(aSpontFissChannel);
                modeSumBR[SpFission] += b;
              }
              break;
 
              case BDProton:
                  // Not yet implemented
                  // G4cout << " beta-delayed proton decay, a = " << a << ", b = " << b << ", c = " << c << G4endl;
                  break;
 
              case BDNeutron:
                  // Not yet implemented
                  // G4cout << " beta-delayed neutron decay, a = " << a << ", b = " << b << ", c = " << c << G4endl;
                  break;
 
              case Beta2Minus:
                  // Not yet implemented
                  // G4cout << " Double beta- decay, a = " << a << ", b = " << b << ", c = " << c << G4endl;
                  break;
 
              case Beta2Plus:
                  // Not yet implemented
                  // G4cout << " Double beta+ decay, a = " << a << ", b = " << b << ", c = " << c << G4endl;
                  break;
 
              case Proton2:
                  // Not yet implemented
                  // G4cout << " Double proton decay, a = " << a << ", b = " << b << ", c = " << c << G4endl;
                  break;
 
              case Neutron2:
                  // Not yet implemented
                  // G4cout << " Double beta- decay, a = " << a << ", b = " << b << ", c = " << c << G4endl;
                  break;
 
              case Triton:
                {
                    G4TritonDecay* aTritonChannel =
                    new G4TritonDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                     daughterFloatLevel);
                    //              anAlphaChannel->DumpNuclearInfo();
                    //                anAlphaChannel->SetHLThreshold(halflifethreshold);
                    theDecayTable->Insert(aTritonChannel);
                    modeSumBR[Triton] += b;
                }
              break;
 
              case RDM_ERROR:
 
              default:
                G4Exception("G4RadioactiveDecay::LoadDecayTable()", "HAD_RDM_000",
                            FatalException, "Selected decay mode does not exist");
            }  // switch
          }  // line < 72
        }  // if char == P
      }  // if char != #
    }  // While
 
    // Go through the decay table and make sure that the branching ratios are
    // correctly normalised.
 
    G4VDecayChannel* theChannel = 0;
    G4NuclearDecay* theNuclearDecayChannel = 0;
    G4String mode = "";
 
    G4double theBR = 0.0;
    for (G4int i = 0; i < theDecayTable->entries(); i++) {
      theChannel = theDecayTable->GetDecayChannel(i);
      theNuclearDecayChannel = static_cast<G4NuclearDecay*>(theChannel);
      theDecayMode = theNuclearDecayChannel->GetDecayMode();
 
      if (theDecayMode != IT) {
    theBR = theChannel->GetBR();
    theChannel->SetBR(theBR*modeTotalBR[theDecayMode]/modeSumBR[theDecayMode]);
      }
    }
  }  // decay file exists
 
  DecaySchemeFile.close();
 
  if (!found && levelEnergy > 0) {
    // Case where IT cascade for excited isotopes has no entries in RDM database
    // Decay mode is isomeric transition.
    G4ITDecay* anITChannel = new G4ITDecay(&theParentNucleus, 1.0, 0.0, 0.0,
                                           photonEvaporation);
//    anITChannel->SetHLThreshold(halflifethreshold);
    anITChannel->SetARM(applyARM);
    theDecayTable->Insert(anITChannel);
  }
 
  if (theDecayTable && GetVerboseLevel() > 1) {
    theDecayTable->DumpInfo();
  }
 
#ifdef G4MULTITHREADED
  //(*master_dkmap)[key] = theDecayTable;                  // store in master library 
#endif
  return theDecayTable;
}

Referenced by GetDecayTable(), and G4Radioactivation::GetDecayTable1().

ProcessDescription()

void G4RadioactiveDecay::ProcessDescription ( std::ostream &  outFile ) const

virtual

Reimplemented from G4VProcess.

Reimplemented in G4Radioactivation.

Definition at line 175 of file G4RadioactiveDecay.cc.

{
  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";
}

SelectAllVolumes()

void G4RadioactiveDecay::SelectAllVolumes

(

)

Definition at line 309 of file G4RadioactiveDecay.cc.

{
  G4LogicalVolumeStore* theLogicalVolumes = G4LogicalVolumeStore::GetInstance();
  G4LogicalVolume* volume = nullptr;
  ValidVolumes.clear();
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    G4cout << " RDM Applies to all Volumes"  << G4endl;
#endif
  for (std::size_t i = 0; i < theLogicalVolumes->size(); ++i){
    volume = (*theLogicalVolumes)[i];
    ValidVolumes.push_back(volume->GetName());    
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1)
      G4cout << "       RDM Applies to Volume " << volume->GetName() << G4endl;
#endif
  }
  std::sort(ValidVolumes.begin(), ValidVolumes.end());
  // sort needed in order to allow binary_search
  isAllVolumesMode=true;
}

Referenced by G4RadioactiveDecay(), and G4RadioactiveDecayMessenger::SetNewValue().

SelectAVolume()

void G4RadioactiveDecay::SelectAVolume

(

const G4String &

aVolume

)

Definition at line 247 of file G4RadioactiveDecay.cc.

{
  G4LogicalVolumeStore* theLogicalVolumes = G4LogicalVolumeStore::GetInstance();
  G4LogicalVolume* volume = nullptr;
  volume = theLogicalVolumes->GetVolume(aVolume);
  if (volume != nullptr)
  {
    ValidVolumes.push_back(aVolume);
    std::sort(ValidVolumes.begin(), ValidVolumes.end());
    // sort need for performing binary_search
 
    if (GetVerboseLevel() > 0)
      G4cout << " Radioactive decay applied to " << aVolume << G4endl;
  }
  else
  {
    G4ExceptionDescription ed;
    ed << aVolume << " is not a valid logical volume name."
       << " Decay not activated for it."
       << G4endl;
    G4Exception("G4RadioactiveDecay::SelectAVolume()", "HAD_RDM_300",
                JustWarning, ed);
  }
}

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

SetARM()

void G4RadioactiveDecay::SetARM ( G4bool  arm )

inline

Definition at line 103 of file G4RadioactiveDecay.hh.

{applyARM = arm;}

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

SetDecayCollimation()

void G4RadioactiveDecay::SetDecayCollimation ( const G4ThreeVector &  theDir, G4double  halfAngle = 0.*CLHEP::deg  )

inline

Definition at line 143 of file G4RadioactiveDecay.hh.

                                                                      {
      SetDecayDirection(theDir);
      SetDecayHalfAngle(halfAngle);
    }

SetDecayDirection()

void G4RadioactiveDecay::SetDecayDirection ( const G4ThreeVector &  theDir )

inline

Definition at line 127 of file G4RadioactiveDecay.hh.

                                                               {
      forceDecayDirection = theDir.unit();
    }

Referenced by SetDecayCollimation(), and G4RadioactiveDecayMessenger::SetNewValue().

SetDecayHalfAngle()

void G4RadioactiveDecay::SetDecayHalfAngle ( G4double  halfAngle = 0.*CLHEP::deg )

inline

Definition at line 135 of file G4RadioactiveDecay.hh.

                                                                  {
      forceDecayHalfAngle = std::min(std::max(0.*CLHEP::deg,halfAngle),180.*CLHEP::deg);
    }

Referenced by SetDecayCollimation(), and G4RadioactiveDecayMessenger::SetNewValue().

SetNucleusLimits()

void G4RadioactiveDecay::SetNucleusLimits ( G4NucleusLimits  theNucleusLimits1 )

inline

Definition at line 118 of file G4RadioactiveDecay.hh.

      {theNucleusLimits = theNucleusLimits1 ;}

SetThresholdForVeryLongDecayTime()

void G4RadioactiveDecay::SetThresholdForVeryLongDecayTime ( const G4double  inputThreshold )

inline

Definition at line 150 of file G4RadioactiveDecay.hh.

                                                                                {
      fThresholdForVeryLongDecayTime = std::max( 0.0, inputThreshold );
    }

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

SetVerboseLevel()

void G4RadioactiveDecay::SetVerboseLevel ( G4int  value )

inline

Definition at line 112 of file G4RadioactiveDecay.hh.

{verboseLevel = value;}

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

Member Data Documentation

dkmap

DecayTableMap* G4RadioactiveDecay::dkmap

protected

Definition at line 189 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay(), GetDecayTable(), G4Radioactivation::GetDecayTable1(), and ~G4RadioactiveDecay().

fParticleChangeForRadDecay

G4ParticleChangeForRadDecay G4RadioactiveDecay::fParticleChangeForRadDecay

protected

Definition at line 178 of file G4RadioactiveDecay.hh.

Referenced by DecayAnalog(), G4Radioactivation::DecayIt(), DecayIt(), and G4RadioactiveDecay().

isAllVolumesMode

bool G4RadioactiveDecay::isAllVolumesMode

protected

Definition at line 184 of file G4RadioactiveDecay.hh.

Referenced by G4Radioactivation::DecayIt(), DecayIt(), DeselectAllVolumes(), DeselectAVolume(), G4RadioactiveDecay(), and SelectAllVolumes().

levelTolerance

const G4double G4RadioactiveDecay::levelTolerance = 10.0*eV

staticprotected

Definition at line 186 of file G4RadioactiveDecay.hh.

Referenced by G4Radioactivation::CalculateChainsFromParent(), and LoadDecayTable().

photonEvaporation

G4PhotonEvaporation* G4RadioactiveDecay::photonEvaporation

protected

Definition at line 181 of file G4RadioactiveDecay.hh.

Referenced by G4Radioactivation::AddDeexcitationSpectrumForBiasMode(), G4Radioactivation::CalculateChainsFromParent(), G4RadioactiveDecay(), LoadDecayTable(), and ~G4RadioactiveDecay().

theRadioactiveDecayMessenger

G4RadioactiveDecayMessenger* G4RadioactiveDecay::theRadioactiveDecayMessenger

protected

Definition at line 180 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay(), and ~G4RadioactiveDecay().

ValidVolumes

std::vector<G4String> G4RadioactiveDecay::ValidVolumes

protected

Definition at line 183 of file G4RadioactiveDecay.hh.

Referenced by G4Radioactivation::DecayIt(), DecayIt(), DeselectAllVolumes(), DeselectAVolume(), SelectAllVolumes(), and SelectAVolume().

---

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

• G4RadioactiveDecay.hh
• G4RadioactiveDecay.cc