#include <G4RadioactiveDecayBase.hh>

Inheritance diagram for G4RadioactiveDecayBase:

Public Member Functions
	G4RadioactiveDecayBase (const G4String &processName="RadioactiveDecayBase")

	~G4RadioactiveDecayBase ()

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	SetICM (G4bool icm)

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	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 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

G4RadioactiveDecayBaseMessenger *	theRadioactiveDecayBaseMessenger

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 64 of file G4RadioactiveDecayBase.hh.

Constructor & Destructor Documentation

◆ G4RadioactiveDecayBase()

G4RadioactiveDecayBase::G4RadioactiveDecayBase ( const G4String & processName = "RadioactiveDecayBase" )

Definition at line 109 of file G4RadioactiveDecayBase.cc.

 : G4VRestDiscreteProcess(processName, fDecay), isInitialised(false),
   forceDecayDirection(0.,0.,0.), forceDecayHalfAngle(0.*deg), dirPath(""),
   verboseLevel(1)
{
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 1) {
    G4cout << "G4RadioactiveDecayBase constructor: processName = " << processName
           << G4endl;
  }
#endif
 
  SetProcessSubType(fRadioactiveDecay);
 
  theRadioactiveDecayBaseMessenger = new G4RadioactiveDecayBaseMessenger(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
  char* path_var = std::getenv("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(&G4RadioactiveDecayBase::radioactiveDecayMutex);
  NumberOfInstances()++;
  if(!master_dkmap) master_dkmap = new DecayTableMap;
#endif
  dkmap = new DecayTableMap;
 
  // Apply default values
  applyARM = true;
  applyICM = true;  // Always on; keep only for backward compatibility
 
  // RDM applies to all logical volumes by default
  isAllVolumesMode = true;
  SelectAllVolumes();
  G4HadronicProcessStore::Instance()->RegisterExtraProcess(this);
}

◆ ~G4RadioactiveDecayBase()

G4RadioactiveDecayBase::~G4RadioactiveDecayBase ( )

Definition at line 181 of file G4RadioactiveDecayBase.cc.

{
  delete theRadioactiveDecayBaseMessenger;
  delete photonEvaporation;
  for (DecayTableMap::iterator i = dkmap->begin(); i != dkmap->end(); i++) {
    delete i->second;
  }
  dkmap->clear();
  delete dkmap;
#ifdef G4MULTITHREADED
  G4AutoLock lk(&G4RadioactiveDecayBase::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 G4RadioactiveDecayBase::AddUserDecayDataFile	(	G4int	Z,
		G4int	A,
		G4String	filename
	)

Definition at line 898 of file G4RadioactiveDecayBase.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("G4RadioactiveDecayBase::AddUserDecayDataFile()", "HAD_RDM_001",
                FatalException, ed);
  }
}

Referenced by G4RadioactiveDecayBaseMessenger::SetNewValue().

◆ BuildPhysicsTable()

void G4RadioactiveDecayBase::BuildPhysicsTable ( const G4ParticleDefinition & )

virtual

Reimplemented from G4VProcess.

Definition at line 444 of file G4RadioactiveDecayBase.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 G4RadioactiveDecayBase::ChooseCollimationDirection ( ) const

protected

Definition at line 1265 of file G4RadioactiveDecayBase.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 G4RadioactiveDecayBase::CollimateDecay ( G4DecayProducts * products )

protected

Definition at line 1221 of file G4RadioactiveDecayBase.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 G4RadioactiveDecayBase::CollimateDecayProduct ( G4DynamicParticle * product )

protected

Definition at line 1250 of file G4RadioactiveDecayBase.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 G4RadioactiveDecayBase::DecayAnalog ( const G4Track & theTrack )

protected

Definition at line 1088 of file G4RadioactiveDecayBase.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();
    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();
  }
  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();
  }
 
  for (G4int index = 0; index < numberOfSecondaries; index++) {
    G4Track* secondary = new G4Track(products->PopProducts(), finalGlobalTime,
                                     theTrack.GetPosition() );
    secondary->SetCreatorModelIndex(theRadDecayMode);
    //Change for atomics relaxation
    if (theRadDecayMode == IT  && index>0){
    if (index == numberOfSecondaries-1) secondary->SetCreatorModelIndex(IT);
         else secondary->SetCreatorModelIndex(30);
    }
    else if (theRadDecayMode >= KshellEC && theRadDecayMode <= NshellEC
                                                             && index <numberOfSecondaries-1){
        secondary->SetCreatorModelIndex(30);
    }
    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 * G4RadioactiveDecayBase::DecayIt	(	const G4Track &	theTrack,
		const G4Step &	theStep
	)

Definition at line 921 of file G4RadioactiveDecayBase.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 (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 G4RadioactiveDecayBase::DeselectAllVolumes ( )

Definition at line 327 of file G4RadioactiveDecayBase.cc.

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

Referenced by G4RadioactiveDecayBaseMessenger::SetNewValue().

◆ DeselectAVolume()

void G4RadioactiveDecayBase::DeselectAVolume ( const G4String aVolume )

Definition at line 269 of file G4RadioactiveDecayBase.cc.

{
  G4LogicalVolumeStore* theLogicalVolumes;
  G4LogicalVolume* volume;
  theLogicalVolumes = G4LogicalVolumeStore::GetInstance();
  for (size_t i = 0; i < theLogicalVolumes->size(); i++) {
    volume = (*theLogicalVolumes)[i];
    if (volume->GetName() == aVolume) {
      std::vector<G4String>::iterator location;
      location = std::find(ValidVolumes.begin(),ValidVolumes.end(),aVolume);
      if (location != ValidVolumes.end() ) {
        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("G4RadioactiveDecayBase::DeselectAVolume()", "HAD_RDM_300",
                    JustWarning, ed);
      }
    } else if (i ==  theLogicalVolumes->size()) {
      G4ExceptionDescription ed;
      ed << aVolume << " is not a valid logical volume name.  No action taken." 
         << G4endl;
      G4Exception("G4RadioactiveDecayBase::DeselectAVolume()", "HAD_RDM_300",
                  JustWarning, ed);
    }
  }
}

Referenced by G4RadioactiveDecayBaseMessenger::SetNewValue().

◆ DoDecay()

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

protected

Definition at line 1182 of file G4RadioactiveDecayBase.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 & G4RadioactiveDecayBase::GetDecayDirection ( ) const

inline

Definition at line 135 of file G4RadioactiveDecayBase.hh.

                                                          {
      return forceDecayDirection; 
    }

◆ GetDecayHalfAngle()

G4double G4RadioactiveDecayBase::GetDecayHalfAngle ( ) const

inline

Definition at line 143 of file G4RadioactiveDecayBase.hh.

143{return forceDecayHalfAngle;}

◆ GetDecayTable()

G4DecayTable * G4RadioactiveDecayBase::GetDecayTable ( const G4ParticleDefinition * aNucleus )

Definition at line 227 of file G4RadioactiveDecayBase.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 G4RadioactiveDecayBase::GetMeanFreePath	(	const G4Track &	theTrack,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

protectedvirtual

Implements G4VRestDiscreteProcess.

Definition at line 379 of file G4RadioactiveDecayBase.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 G4RadioactiveDecayBase::GetMeanLifeTime	(	const G4Track &	theTrack,
		G4ForceCondition *	condition
	)

protectedvirtual

Implements G4VRestDiscreteProcess.

Definition at line 343 of file G4RadioactiveDecayBase.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 G4RadioactiveDecayBase::GetNucleusLimits ( ) const

inline

Definition at line 129 of file G4RadioactiveDecayBase.hh.

129{return theNucleusLimits;}

◆ GetVerboseLevel()

G4int G4RadioactiveDecayBase::GetVerboseLevel ( ) const

inline

◆ IsApplicable()

G4bool G4RadioactiveDecayBase::IsApplicable ( const G4ParticleDefinition & aParticle )

virtual

Reimplemented from G4VProcess.

Definition at line 205 of file G4RadioactiveDecayBase.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 * G4RadioactiveDecayBase::LoadDecayTable ( const G4ParticleDefinition & theParentNucleus )

Definition at line 511 of file G4RadioactiveDecayBase.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(&G4RadioactiveDecayBase::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 = 12;
    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;
      inputLine = inputLine.strip(1);
      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[1] = decayModeTotal; break;
              case BetaPlus:
                modeTotalBR[2] = decayModeTotal; break;
              case KshellEC:
                modeTotalBR[3] = decayModeTotal; break;
              case LshellEC:
                modeTotalBR[4] = decayModeTotal; break;
              case MshellEC:
                modeTotalBR[5] = decayModeTotal; break;
              case NshellEC:
                modeTotalBR[6] = decayModeTotal; break;
              case Alpha:
                modeTotalBR[7] = decayModeTotal; break;
              case Proton:
                modeTotalBR[8] = decayModeTotal; break;
              case Neutron:
                modeTotalBR[9] = decayModeTotal; break;
              case BDProton:
                break;
              case BDNeutron:
                break;
              case Beta2Minus:
                break;
              case Beta2Plus:
                break;
              case Proton2:
                break;
              case Neutron2:
                break;
              case SpFission:
                modeTotalBR[10] = decayModeTotal; break;
              case Triton:
                modeTotalBR[11] = 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[1] += 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[2] += 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[3] += 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[4] += 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[5] += 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[6] += b;
              }
              break;
 
              case Alpha:
              {
                G4AlphaDecay* anAlphaChannel =
                  new G4AlphaDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                   daughterFloatLevel);
//              anAlphaChannel->DumpNuclearInfo();
//                anAlphaChannel->SetHLThreshold(halflifethreshold);
                theDecayTable->Insert(anAlphaChannel);
                modeSumBR[7] += b;
              }
              break;
 
          case Proton:
              {
                G4ProtonDecay* aProtonChannel =
                  new G4ProtonDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                    daughterFloatLevel);
//              aProtonChannel->DumpNuclearInfo();
//                aProtonChannel->SetHLThreshold(halflifethreshold);
                theDecayTable->Insert(aProtonChannel);
                modeSumBR[8] += b;
              }
              break;
 
              case Neutron:
              {
                G4NeutronDecay* aNeutronChannel =
                  new G4NeutronDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                     daughterFloatLevel);
//              aNeutronChannel->DumpNuclearInfo();
//                aNeutronChannel->SetHLThreshold(halflifethreshold);
                theDecayTable->Insert(aNeutronChannel);
                modeSumBR[9] += 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 SpFission:
              {
                G4SFDecay* aSpontFissChannel =
//                  new G4SFDecay(&theParentNucleus, decayModeTotal, 0.0, 0.0);
                  new G4SFDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                daughterFloatLevel);
                theDecayTable->Insert(aSpontFissChannel);
                modeSumBR[10] += b;
              }
              break;
              case Triton:
                {
                    G4TritonDecay* aTritonChannel =
                    new G4TritonDecay(&theParentNucleus, b, c*MeV, a*MeV,
                                     daughterFloatLevel);
                    //              anAlphaChannel->DumpNuclearInfo();
                    //                anAlphaChannel->SetHLThreshold(halflifethreshold);
                    theDecayTable->Insert(aTritonChannel);
                    modeSumBR[11] += 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 G4RadioactiveDecayBase::ProcessDescription ( std::ostream & outFile ) const

virtual

Reimplemented from G4VProcess.

Reimplemented in G4Radioactivation.

Definition at line 171 of file G4RadioactiveDecayBase.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 G4RadioactiveDecayBase::SelectAllVolumes ( )

Definition at line 303 of file G4RadioactiveDecayBase.cc.

{
  G4LogicalVolumeStore* theLogicalVolumes;
  G4LogicalVolume* volume;
  theLogicalVolumes = G4LogicalVolumeStore::GetInstance();
  ValidVolumes.clear();
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    G4cout << " RDM Applies to all Volumes"  << G4endl;
#endif
  for (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 G4RadioactiveDecayBase(), and G4RadioactiveDecayBaseMessenger::SetNewValue().

◆ SelectAVolume()

void G4RadioactiveDecayBase::SelectAVolume ( const G4String aVolume )

Definition at line 243 of file G4RadioactiveDecayBase.cc.

{
  G4LogicalVolumeStore* theLogicalVolumes;
  G4LogicalVolume* volume;
  theLogicalVolumes = G4LogicalVolumeStore::GetInstance();
  for (size_t i = 0; i < theLogicalVolumes->size(); i++) {
    volume = (*theLogicalVolumes)[i];
    if (volume->GetName() == aVolume) {
      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 if (i == theLogicalVolumes->size() ) {
      G4ExceptionDescription ed;
      ed << aVolume << " is not a valid logical volume name.  Decay not activated for it."
         << G4endl;
      G4Exception("G4RadioactiveDecayBase::SelectAVolume()", "HAD_RDM_300",
                  JustWarning, ed);
    }
  }
}

Referenced by G4RadioactiveDecayBaseMessenger::SetNewValue().

◆ SetARM()

void G4RadioactiveDecayBase::SetARM ( G4bool arm )

inline

Definition at line 107 of file G4RadioactiveDecayBase.hh.

107{applyARM = arm;}

Referenced by G4RadioactiveDecayBaseMessenger::SetNewValue().

◆ SetDecayCollimation()

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

inline

Definition at line 147 of file G4RadioactiveDecayBase.hh.

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

◆ SetDecayDirection()

void G4RadioactiveDecayBase::SetDecayDirection ( const G4ThreeVector & theDir )

inline

Definition at line 131 of file G4RadioactiveDecayBase.hh.

                                                               {
      forceDecayDirection = theDir.unit();
    }

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

◆ SetDecayHalfAngle()

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

inline

Definition at line 139 of file G4RadioactiveDecayBase.hh.

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

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

◆ SetICM()

void G4RadioactiveDecayBase::SetICM ( G4bool icm )

inline

Definition at line 104 of file G4RadioactiveDecayBase.hh.

104{applyICM = icm;}

Referenced by G4RadioactiveDecayBaseMessenger::SetNewValue().

◆ SetNucleusLimits()

void G4RadioactiveDecayBase::SetNucleusLimits ( G4NucleusLimits theNucleusLimits1 )

inline

Definition at line 122 of file G4RadioactiveDecayBase.hh.

123 {theNucleusLimits = theNucleusLimits1 ;}

◆ SetVerboseLevel()

void G4RadioactiveDecayBase::SetVerboseLevel ( G4int value )

inline

Definition at line 116 of file G4RadioactiveDecayBase.hh.

116{verboseLevel = value;}

Referenced by G4RadioactiveDecayBaseMessenger::SetNewValue().

Member Data Documentation

◆ dkmap

DecayTableMap* G4RadioactiveDecayBase::dkmap

protected

Definition at line 187 of file G4RadioactiveDecayBase.hh.

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

◆ fParticleChangeForRadDecay

G4ParticleChangeForRadDecay G4RadioactiveDecayBase::fParticleChangeForRadDecay

protected

Definition at line 176 of file G4RadioactiveDecayBase.hh.

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

◆ isAllVolumesMode

bool G4RadioactiveDecayBase::isAllVolumesMode

protected

Definition at line 182 of file G4RadioactiveDecayBase.hh.

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

◆ levelTolerance

const G4double G4RadioactiveDecayBase::levelTolerance = 10.0*eV

staticprotected

Definition at line 184 of file G4RadioactiveDecayBase.hh.

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

◆ photonEvaporation

G4PhotonEvaporation* G4RadioactiveDecayBase::photonEvaporation

protected

Definition at line 179 of file G4RadioactiveDecayBase.hh.

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

◆ theRadioactiveDecayBaseMessenger

G4RadioactiveDecayBaseMessenger* G4RadioactiveDecayBase::theRadioactiveDecayBaseMessenger

protected

Definition at line 178 of file G4RadioactiveDecayBase.hh.

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

◆ ValidVolumes

std::vector<G4String> G4RadioactiveDecayBase::ValidVolumes

protected

Definition at line 181 of file G4RadioactiveDecayBase.hh.

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4RadioactiveDecayBase()

◆ ~G4RadioactiveDecayBase()

Member Function Documentation

◆ AddUserDecayDataFile()

◆ BuildPhysicsTable()

◆ ChooseCollimationDirection()

◆ CollimateDecay()

◆ CollimateDecayProduct()

◆ DecayAnalog()

◆ DecayIt()

◆ DeselectAllVolumes()

◆ DeselectAVolume()

◆ DoDecay()

◆ GetDecayDirection()

◆ GetDecayHalfAngle()

◆ GetDecayTable()

◆ GetMeanFreePath()

◆ GetMeanLifeTime()

◆ GetNucleusLimits()

◆ GetVerboseLevel()

◆ IsApplicable()

◆ LoadDecayTable()

◆ ProcessDescription()

◆ SelectAllVolumes()

◆ SelectAVolume()

◆ SetARM()

◆ SetDecayCollimation()

◆ SetDecayDirection()

◆ SetDecayHalfAngle()

◆ SetICM()

◆ SetNucleusLimits()

◆ SetVerboseLevel()

Member Data Documentation

◆ dkmap

◆ fParticleChangeForRadDecay

◆ isAllVolumesMode

◆ levelTolerance

◆ photonEvaporation

◆ theRadioactiveDecayBaseMessenger

◆ ValidVolumes