#include <G4VRadioactiveDecay.hh>

Inheritance diagram for G4VRadioactiveDecay:

Public Member Functions
	G4VRadioactiveDecay (const G4String &processName="RadioactiveDecay", const G4double timeThreshold=-1.0)

	~G4VRadioactiveDecay () override

G4bool	IsApplicable (const G4ParticleDefinition &) override

G4VParticleChange *	AtRestDoIt (const G4Track &theTrack, const G4Step &theStep) override

G4VParticleChange *	PostStepDoIt (const G4Track &theTrack, const G4Step &theStep) override

void	BuildPhysicsTable (const G4ParticleDefinition &) override

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

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

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 G4Ions *)

void	AddUserDecayDataFile (G4int Z, G4int A, const G4String &filename)

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	StreamInfo (std::ostream &os, const G4String &endline)

	G4VRadioactiveDecay (const G4VRadioactiveDecay &right)=delete

G4VRadioactiveDecay &	operator= (const G4VRadioactiveDecay &right)=delete

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 G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

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

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
G4double	GetMeanFreePath (const G4Track &theTrack, G4double previousStepSize, G4ForceCondition *condition) override

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

void	DecayAnalog (const G4Track &theTrack, G4DecayTable *)

G4DecayProducts *	DoDecay (const G4ParticleDefinition &, G4DecayTable *)

void	CollimateDecay (G4DecayProducts *products)

void	CollimateDecayProduct (G4DynamicParticle *product)

G4ThreeVector	ChooseCollimationDirection () const

Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes
G4ParticleChangeForRadDecay	fParticleChangeForRadDecay

G4RadioactiveDecayMessenger *	theRadioactiveDecayMessenger

G4PhotonEvaporation *	photonEvaporation

G4ITDecay *	decayIT

std::vector< G4String >	ValidVolumes

G4bool	isAllVolumesMode {true}

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*CLHEP::eV

static DecayTableMap *	master_dkmap = nullptr

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

Detailed Description

Definition at line 69 of file G4VRadioactiveDecay.hh.

Constructor & Destructor Documentation

◆ G4VRadioactiveDecay() [1/2]

G4VRadioactiveDecay::G4VRadioactiveDecay	(	const G4String &	processName = "RadioactiveDecay",
		const G4double	timeThreshold = -1.0 )

Definition at line 111 of file G4VRadioactiveDecay.cc.

 : G4VRestDiscreteProcess(processName, fDecay),
   fThresholdForVeryLongDecayTime( 1.0*CLHEP::year )
{
  if (GetVerboseLevel() > 1) {
    G4cout << "G4VRadioactiveDecay constructor: processName = " << processName
           << G4endl;
  }
 
  SetProcessSubType(fRadioactiveDecay);
 
  theRadioactiveDecayMessenger = new G4RadioactiveDecayMessenger(this);
  pParticleChange = &fParticleChangeForRadDecay;
 
  // Check data directory
  if (dirPath.empty()) {
    const char* path_var = G4FindDataDir("G4RADIOACTIVEDATA");
    if (nullptr == path_var) {
      G4Exception("G4VRadioactiveDecay()", "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("G4VRadioactiveDecay()","HAD_RDM_201",FatalException,
                    "Environment variable G4RADIOACTIVEDATA is set, but does not point to correct directory");
    }
  }
  // Set up photon evaporation for use in G4ITDecay
  photonEvaporation = new G4PhotonEvaporation();
  photonEvaporation->RDMForced(true);
  photonEvaporation->SetICM(true);
  decayIT = new G4ITDecay(photonEvaporation);
 
  // Instantiate the map of decay tables
  if (nullptr == master_dkmap) {
    master_dkmap = new DecayTableMap();
  }
  if (nullptr == theUserRDataFiles) {
    theUserRDataFiles = new std::map<G4int, G4String>;
  }
 
  // RDM applies to all logical volumes by default
  SelectAllVolumes();
  G4HadronicProcessStore::Instance()->RegisterExtraProcess(this);
 
  // The time threshold for radioactive decays can be set in 3 ways:
  // 1. Via C++ interface: G4HadronicParameters::Instance()->SetTimeThresholdForRadioactiveDecay(value)
  // 2. Via the second parameter of the G4VRadioactiveDecay constructor
  // 3. Via UI command: /process/had/rdm/thresholdForVeryLongDecayTime value
  // If both 1. and 2. are specified (at the moment when the G4VRadioactiveDecay constructor is called),
  // then we take the larger value, to be conservative.
  // If, later on (after invoking the G4VRadioactiveDecay constructor) 3. is specified, 
  // then this value is used (and the eventual values 1. and/or 2. are ignored).
  G4double timeThresholdBis = G4HadronicParameters::Instance()->GetTimeThresholdForRadioactiveDecay();
  if ( timeThreshold > 0.0 || timeThresholdBis > 0.0 ) {
    if ( timeThreshold > timeThresholdBis ) timeThresholdBis = timeThreshold;
    fThresholdForVeryLongDecayTime = timeThresholdBis;
  }
}

Referenced by G4RadioactiveDecay::G4RadioactiveDecay(), G4VRadioactiveDecay(), and operator=().

◆ ~G4VRadioactiveDecay()

G4VRadioactiveDecay::~G4VRadioactiveDecay ( )

override

Definition at line 176 of file G4VRadioactiveDecay.cc.

{
  delete theRadioactiveDecayMessenger;
  delete photonEvaporation;
  delete decayIT;
  if (nullptr != master_dkmap) {
    G4AutoLock lk(&radioactiveDecayMutex);
    if (nullptr != master_dkmap) {
      for (auto const & i : *master_dkmap) {
    delete i.second;
      }
      master_dkmap->clear();
      delete master_dkmap;
      master_dkmap = nullptr;
    }
    delete theUserRDataFiles;
    theUserRDataFiles = nullptr;
    lk.unlock();
  }
}

◆ G4VRadioactiveDecay() [2/2]

G4VRadioactiveDecay::G4VRadioactiveDecay ( const G4VRadioactiveDecay & right )

delete

Member Function Documentation

◆ AddUserDecayDataFile()

void G4VRadioactiveDecay::AddUserDecayDataFile	(	G4int	Z,
		G4int	A,
		const G4String &	filename )

Definition at line 894 of file G4VRadioactiveDecay.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;
    (*theUserRDataFiles)[ID_ion] = filename;
  } else {
    G4ExceptionDescription ed;
    ed << filename << " does not exist! " << G4endl;
    G4Exception("G4VRadioactiveDecay::AddUserDecayDataFile()", "HAD_RDM_001",
                FatalException, ed);
  }
}

◆ AtRestDoIt()

G4VParticleChange * G4VRadioactiveDecay::AtRestDoIt	(	const G4Track &	theTrack,
		const G4Step &	theStep )

overridevirtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 228 of file G4VRadioactiveDecay.cc.

{
  return DecayIt(theTrack, theStep);
}

◆ BuildPhysicsTable()

void G4VRadioactiveDecay::BuildPhysicsTable ( const G4ParticleDefinition & p )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 442 of file G4VRadioactiveDecay.cc.

{
  if (isInitialised) { return; }
  isInitialised = true;
  if (G4HadronicParameters::Instance()->GetVerboseLevel() > 0  &&
      G4Threading::IsMasterThread() && "GenericIon" == p.GetParticleName()) {
    StreamInfo(G4cout, "\n");
  }
  photonEvaporation->Initialise();
  photonEvaporation->RDMForced(true);
  photonEvaporation->SetICM(true);
  decayIT->SetARM(applyARM);
 
  G4HadronicProcessStore::Instance()->RegisterParticleForExtraProcess(this, &p);
  G4HadronicProcessStore::Instance()->PrintInfo(&p);
}

◆ ChooseCollimationDirection()

G4ThreeVector G4VRadioactiveDecay::ChooseCollimationDirection ( ) const

protected

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

protected

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

protected

Definition at line 1181 of file G4VRadioactiveDecay.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 G4VRadioactiveDecay::DecayAnalog	(	const G4Track &	theTrack,
		G4DecayTable *	decayTable )

protected

Definition at line 980 of file G4VRadioactiveDecay.cc.

{
  const G4DynamicParticle* theParticle = theTrack.GetDynamicParticle();
  const G4ParticleDefinition* theParticleDef = theParticle->GetDefinition();
  //G4cout << "DecayIt for " << theParticleDef->GetParticleName() << G4endl;
  G4DecayProducts* products = DoDecay(*theParticleDef, decayTable);
 
  // 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 (nullptr == products || 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 << "G4VRadioactiveDecay::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 G4RadioactiveDecay::DecayIt(), and DecayIt().

◆ DecayIt()

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

virtual

Reimplemented in G4RadioactiveDecay.

Definition at line 918 of file G4VRadioactiveDecay.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 <<"G4VRadioactiveDecay::DecayIt : "
               << theTrack.GetVolume()->GetLogicalVolume()->GetName()
               << " is not selected for the RDM"<< G4endl;
        G4cout << " There are " << ValidVolumes.size() << " volumes" << G4endl;
        G4cout << " The Valid volumes are: ";
    for (auto const & vol : ValidVolumes) { G4cout << vol << " " << G4endl; }
        G4cout << 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
  G4DecayTable* theDecayTable = GetDecayTable(theParticleDef);
  if ( theDecayTable == nullptr || theDecayTable->entries() == 0) { 
    // Particle is not an ion or is outside the nucleuslimits for decay
#ifdef G4VERBOSE
    if (GetVerboseLevel() > 1) {
      G4cout << "G4VRadioactiveDecay::DecayIt : "
             << theParticleDef->GetParticleName() 
             << " is outside (Z,A) limits set for the decay or has no decays." 
             << G4endl;
    }
#endif
    fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
 
    // Kill the parent particle
    fParticleChangeForRadDecay.ProposeTrackStatus(fStopAndKill) ;
    fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
    ClearNumberOfInteractionLengthLeft();
    return &fParticleChangeForRadDecay;
  }
  //G4cout << "DecayIt for " << theParticleDef->GetParticleName() 
  //     << " isAllVolumesMode:" << isAllVolumesMode
  //     << " decayTable=" << theDecayTable << G4endl;
 
  // Data found. Decay nucleus without variance reduction. 
  DecayAnalog(theTrack, theDecayTable);
  return &fParticleChangeForRadDecay;
} 

Referenced by AtRestDoIt(), and PostStepDoIt().

◆ DeselectAllVolumes()

void G4VRadioactiveDecay::DeselectAllVolumes ( )

Definition at line 358 of file G4VRadioactiveDecay.cc.

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

◆ DeselectAVolume()

void G4VRadioactiveDecay::DeselectAVolume ( const G4String & aVolume )

Definition at line 299 of file G4VRadioactiveDecay.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 << " G4VRadioactiveDecay::DeselectAVolume: " << aVolume
               << " is removed from list " << G4endl;
    }
    else
    {
      G4ExceptionDescription ed;
      ed << aVolume << " is not in the list.  No action taken." << G4endl;
      G4Exception("G4VRadioactiveDecay::DeselectAVolume()", "HAD_RDM_300",
                  JustWarning, ed);
    }
  }
  else
  {
    G4ExceptionDescription ed;
    ed << aVolume << " is not a valid logical volume name.  No action taken." 
       << G4endl;
    G4Exception("G4VRadioactiveDecay::DeselectAVolume()", "HAD_RDM_300",
                JustWarning, ed);
  }
}

◆ DoDecay()

G4DecayProducts * G4VRadioactiveDecay::DoDecay	(	const G4ParticleDefinition &	theParticleDef,
		G4DecayTable *	theDecayTable )

protected

Definition at line 1103 of file G4VRadioactiveDecay.cc.

{
  G4DecayProducts* products = nullptr;
 
  // 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 == nullptr) {
    // Decay channel not found.
    G4ExceptionDescription ed;
    ed << " Cannot determine decay channel for " << theParticleDef.GetParticleName() << G4endl;
    G4Exception("G4VRadioactiveDecay::DoDecay", "HAD_RDM_013",
                FatalException, ed);
  } else {
    // A decay channel has been identified, so execute the DecayIt.
#ifdef G4VERBOSE
    if (GetVerboseLevel() > 1) {
      G4cout << "G4VRadioactiveDecay::DoIt : selected decay channel addr: "
             << theDecayChannel << G4endl;
    }
#endif
    theRadDecayMode = static_cast<G4NuclearDecay*>(theDecayChannel)->GetDecayMode();
 
    // for IT decay use local G4ITDecay class
    if (theRadDecayMode == IT) {
      decayIT->SetupDecay(&theParticleDef);
      products = decayIT->DecayIt(0.0);
    } else { 
      // for others decayes use shared  class
      products = theDecayChannel->DecayIt(theParticleDef.GetPDGMass());
    }
 
    // Apply directional bias if requested by user
    CollimateDecay(products);
  }
 
  return products;
}

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

◆ GetDecayDirection()

const G4ThreeVector & G4VRadioactiveDecay::GetDecayDirection ( ) const

inline

Definition at line 143 of file G4VRadioactiveDecay.hh.

                                                          {
      return forceDecayDirection; 
    }

◆ GetDecayHalfAngle()

G4double G4VRadioactiveDecay::GetDecayHalfAngle ( ) const

inline

Definition at line 151 of file G4VRadioactiveDecay.hh.

151{ return forceDecayHalfAngle; }

◆ GetDecayTable()

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

Definition at line 254 of file G4VRadioactiveDecay.cc.

{
  G4String key = aNucleus->GetParticleName();
  auto ptr = master_dkmap->find(key);
 
  G4DecayTable* theDecayTable = nullptr;
  if ( ptr == master_dkmap->end() ) {
    // Load new file if table not there
    const G4Ions* ion = dynamic_cast<const G4Ions*>(aNucleus);
    if (nullptr != ion) {
      theDecayTable = LoadDecayTable(ion);
    }
  } else {
    theDecayTable = ptr->second;
  }
  return theDecayTable;
}

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

◆ GetMeanFreePath()

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

overrideprotectedvirtual

Implements G4VRestDiscreteProcess.

Definition at line 412 of file G4VRadioactiveDecay.cc.

{
  G4double res = DBL_MAX;
  G4double lifeTime = GetMeanLifeTime(aTrack, fc);
  if (lifeTime > 0.0 && lifeTime < DBL_MAX) {
    auto dParticle = aTrack.GetDynamicParticle();
    res = lifeTime*dParticle->GetTotalEnergy()*aTrack.GetVelocity()/dParticle->GetMass(); 
  } else {
    res = lifeTime;
  }
 
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2) {
    G4cout << "G4VRadioactiveDecay::GetMeanFreePath() for "
       << aTrack.GetDefinition()->GetParticleName() << G4endl;
    G4cout << "  kinEnergy(GeV)=" << aTrack.GetKineticEnergy()/CLHEP::GeV
           << " lifeTime(ns)=" << lifeTime
           << " mean free path(cm)=" << res/CLHEP::cm << G4endl;
  }
#endif
  return res;
}

◆ GetMeanLifeTime()

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

overrideprotectedvirtual

Implements G4VRestDiscreteProcess.

Definition at line 369 of file G4VRadioactiveDecay.cc.

{
  G4double meanlife = DBL_MAX;
  const G4ParticleDefinition* theParticleDef = theTrack.GetParticleDefinition();
  if (!IsApplicable(*theParticleDef)) { return meanlife; }
  G4double theLife = theParticleDef->GetPDGLifeTime();
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2) {
    G4cout << "G4VRadioactiveDecay::GetMeanLifeTime() for " 
       << theParticleDef->GetParticleName() << G4endl;
    G4cout << "KineticEnergy(GeV)=" << theTrack.GetKineticEnergy()/CLHEP::GeV
           << " Mass(GeV)=" << theParticleDef->GetPDGMass()/CLHEP::GeV
           << " LifeTime(ns)=" << theLife/CLHEP::ns << G4endl;
  }
#endif
  if (theLife >= 0.0 && theLife <= fThresholdForVeryLongDecayTime) {
    meanlife = theLife;
  } 
 
  if (meanlife == DBL_MAX) {
    const G4Ions* ion = dynamic_cast<const G4Ions*>(theParticleDef);
    if (nullptr != ion && ion->GetExcitationEnergy() > 0.0) {
      meanlife = 0.0;
    }
  }
 
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2)
    G4cout << "G4VRadioactiveDecay::GetMeanLifeTime: " 
       << meanlife/CLHEP::s << " second " << G4endl;
#endif
 
  return meanlife;
}

Referenced by GetMeanFreePath(), and G4RadioactiveDecay::GetMeanLifeTime().

◆ GetNucleusLimits()

G4NucleusLimits G4VRadioactiveDecay::GetNucleusLimits ( ) const

inline

Definition at line 137 of file G4VRadioactiveDecay.hh.

137{ return theNucleusLimits; }

◆ GetThresholdForVeryLongDecayTime()

G4double G4VRadioactiveDecay::GetThresholdForVeryLongDecayTime ( ) const

inline

Definition at line 166 of file G4VRadioactiveDecay.hh.

                                                             {
      return fThresholdForVeryLongDecayTime;
    }

◆ IsApplicable()

G4bool G4VRadioactiveDecay::IsApplicable ( const G4ParticleDefinition & aParticle )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 198 of file G4VRadioactiveDecay.cc.

{
  const G4String& pname = aParticle.GetParticleName();
  if (pname == "GenericIon" || pname == "triton") { return true; }
  // All particles other than G4Ions, are rejected by default
  const G4Ions* p = dynamic_cast<const G4Ions*>(&aParticle);
  if (nullptr == p) { return false; }
 
  // excited isomere may decay via gamma evaporation
  if (p->GetExcitationEnergy() > 0.0) { return true; }
 
  // Check on life time 
  G4double lifeTime = p->GetPDGLifeTime();
  if (lifeTime < 0.0 || lifeTime > fThresholdForVeryLongDecayTime) {
    return false;
  }
 
  // Determine whether the nuclide falls into the correct A and Z range
  G4int A = p->GetAtomicMass();
  G4int Z = p->GetAtomicNumber();
 
  if (A > theNucleusLimits.GetAMax() || A < theNucleusLimits.GetAMin() ||
      Z > theNucleusLimits.GetZMax() || Z < theNucleusLimits.GetZMin()) {
    return false;
  }
 
  return true;
}

Referenced by G4RadioactiveDecay::CalculateChainsFromParent(), G4RadioactiveDecay::DecayIt(), and GetMeanLifeTime().

◆ LoadDecayTable()

G4DecayTable * G4VRadioactiveDecay::LoadDecayTable ( const G4Ions * theIon )

Definition at line 519 of file G4VRadioactiveDecay.cc.

{
  G4AutoLock lk(&radioactiveDecayMutex);
  const G4String key = theIon->GetParticleName();
  auto dtptr = master_dkmap->find(key);
  if (dtptr != master_dkmap->end()) {
    lk.unlock();
    return dtptr->second;
  }
 
  // Generate input data file name using Z and A of the parent nucleus
  // file containing radioactive decay data.
  G4int A = theIon->GetAtomicMass();
  G4int Z = theIon->GetAtomicNumber();
 
  //G4cout << "LoadDecayTable for " << key << " Z=" << Z << " A=" << A << G4endl;
 
  G4double levelEnergy = theIon->GetExcitationEnergy();
  G4Ions::G4FloatLevelBase floatingLevel = theIon->GetFloatLevelBase();
 
  //Check if data have been provided by the user
  G4String file;
  G4int ke = 1000*A + Z;
  auto ptr = theUserRDataFiles->find(ke);
  if (ptr != theUserRDataFiles->end()) {
    file = ptr->second;
  } else {
    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;
    /* Loop checking, 01.09.2015, D.Wright */
    while (!complete && !DecaySchemeFile.getline(inputChars, 120).eof()) {
      loop++;
      if (loop > 100000) {
        G4Exception("G4VRadioactiveDecay::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(theIon, decayModeTotal, 0.0, 0.0);
          theDecayTable->Insert(anITChannel);
                }
                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("G4VRadioactiveDecay::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(theIon, b, c*MeV, a*MeV,
                                       daughterFloatLevel, betaType);
        //aBetaMinusChannel->DumpNuclearInfo();
                theDecayTable->Insert(aBetaMinusChannel);
        modeSumBR[BetaMinus] += b;
              }
              break;
 
              case BetaPlus:
              {
                G4BetaPlusDecay* aBetaPlusChannel =
                  new G4BetaPlusDecay(theIon, b, c*MeV, a*MeV,
                                      daughterFloatLevel, betaType);
        //aBetaPlusChannel->DumpNuclearInfo();
                theDecayTable->Insert(aBetaPlusChannel);
        modeSumBR[BetaPlus] += b;
              }
              break;
 
              case KshellEC:  // K-shell electron capture
              {
                G4ECDecay* aKECChannel =
                  new G4ECDecay(theIon, b, c*MeV, a*MeV,
                                daughterFloatLevel, KshellEC);
        //aKECChannel->DumpNuclearInfo();
                aKECChannel->SetARM(applyARM);
                theDecayTable->Insert(aKECChannel);
                modeSumBR[KshellEC] += b;
              }
              break;
 
              case LshellEC:  // L-shell electron capture
              {
                G4ECDecay* aLECChannel =
                  new G4ECDecay(theIon, b, c*MeV, a*MeV,
                                daughterFloatLevel, LshellEC);
//              aLECChannel->DumpNuclearInfo();
                aLECChannel->SetARM(applyARM);
                theDecayTable->Insert(aLECChannel);
                modeSumBR[LshellEC] += b;
              }
              break;
 
              case MshellEC:  // M-shell electron capture
              {
                G4ECDecay* aMECChannel =
                  new G4ECDecay(theIon, b, c*MeV, a*MeV,
                                daughterFloatLevel, MshellEC);
//              aMECChannel->DumpNuclearInfo();
                aMECChannel->SetARM(applyARM);
                theDecayTable->Insert(aMECChannel);
                modeSumBR[MshellEC] += b;
              }
              break;
 
              case NshellEC:  // N-shell electron capture
              {
                G4ECDecay* aNECChannel =
                  new G4ECDecay(theIon, b, c*MeV, a*MeV,
                                daughterFloatLevel, NshellEC);
//              aNECChannel->DumpNuclearInfo();
                aNECChannel->SetARM(applyARM);
                theDecayTable->Insert(aNECChannel);
                modeSumBR[NshellEC] += b;
              }
              break;
 
              case Alpha:
              {
                G4AlphaDecay* anAlphaChannel =
                  new G4AlphaDecay(theIon, b, c*MeV, a*MeV,
                                   daughterFloatLevel);
//              anAlphaChannel->DumpNuclearInfo();
                theDecayTable->Insert(anAlphaChannel);
                modeSumBR[Alpha] += b;
              }
              break;
 
          case Proton:
              {
                G4ProtonDecay* aProtonChannel =
                  new G4ProtonDecay(theIon, b, c*MeV, a*MeV,
                                    daughterFloatLevel);
//              aProtonChannel->DumpNuclearInfo();
                theDecayTable->Insert(aProtonChannel);
                modeSumBR[Proton] += b;
              }
              break;
 
              case Neutron:
              {
                G4NeutronDecay* aNeutronChannel =
                  new G4NeutronDecay(theIon, b, c*MeV, a*MeV,
                                     daughterFloatLevel);
//              aNeutronChannel->DumpNuclearInfo();
                theDecayTable->Insert(aNeutronChannel);
                modeSumBR[Neutron] += b;
              }
              break;
 
              case SpFission:
              {
                G4SFDecay* aSpontFissChannel =
                  new G4SFDecay(theIon, 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(theIon, b, c*MeV, a*MeV, daughterFloatLevel);
          theDecayTable->Insert(aTritonChannel);
          modeSumBR[Triton] += b;
                }
              break;
 
              case RDM_ERROR:
 
              default:
                G4Exception("G4VRadioactiveDecay::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(theIon, 1.0, 0.0, 0.0);
    theDecayTable->Insert(anITChannel);
  }
 
  if (GetVerboseLevel() > 1) {
    theDecayTable->DumpInfo();
  }
 
  // store in master library 
  (*master_dkmap)[theIon->GetParticleName()] = theDecayTable;
  lk.unlock();
  return theDecayTable;
}

Referenced by GetDecayTable().

◆ operator=()

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

delete

◆ PostStepDoIt()

G4VParticleChange * G4VRadioactiveDecay::PostStepDoIt	(	const G4Track &	theTrack,
		const G4Step &	theStep )

overridevirtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 235 of file G4VRadioactiveDecay.cc.

{
  return DecayIt(theTrack, theStep);
}

◆ ProcessDescription()

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

overridevirtual

Reimplemented from G4VProcess.

Definition at line 242 of file G4VRadioactiveDecay.cc.

{
  outFile << "The radioactive decay process (G4VRadioactiveDecay) 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 G4VRadioactiveDecay::SelectAllVolumes ( )

Definition at line 335 of file G4VRadioactiveDecay.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 G4VRadioactiveDecay().

◆ SelectAVolume()

void G4VRadioactiveDecay::SelectAVolume ( const G4String & aVolume )

Definition at line 273 of file G4VRadioactiveDecay.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("G4VRadioactiveDecay::SelectAVolume()", "HAD_RDM_300",
                JustWarning, ed);
  }
}

◆ SetARM()

void G4VRadioactiveDecay::SetARM ( G4bool arm )

inline

Definition at line 121 of file G4VRadioactiveDecay.hh.

121{ applyARM = arm; }

◆ SetDecayCollimation()

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

inline

Definition at line 155 of file G4VRadioactiveDecay.hh.

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

◆ SetDecayDirection()

void G4VRadioactiveDecay::SetDecayDirection ( const G4ThreeVector & theDir )

inline

Definition at line 139 of file G4VRadioactiveDecay.hh.

                                                               {
      forceDecayDirection = theDir.unit();
    }

Referenced by SetDecayCollimation().

◆ SetDecayHalfAngle()

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

inline

Definition at line 147 of file G4VRadioactiveDecay.hh.

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

Referenced by SetDecayCollimation().

◆ SetNucleusLimits()

void G4VRadioactiveDecay::SetNucleusLimits ( G4NucleusLimits theNucleusLimits1 )

inline

Definition at line 130 of file G4VRadioactiveDecay.hh.

131 { theNucleusLimits = theNucleusLimits1; }

◆ SetThresholdForVeryLongDecayTime()

void G4VRadioactiveDecay::SetThresholdForVeryLongDecayTime ( const G4double inputThreshold )

inline

Definition at line 163 of file G4VRadioactiveDecay.hh.

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

◆ StreamInfo()

void G4VRadioactiveDecay::StreamInfo	(	std::ostream &	os,
		const G4String &	endline )

Definition at line 466 of file G4VRadioactiveDecay.cc.

{
  G4DeexPrecoParameters* deex =
    G4NuclearLevelData::GetInstance()->GetParameters();
  G4EmParameters* emparam = G4EmParameters::Instance();
  G4double minMeanLife = G4NuclideTable::GetInstance()->GetMeanLifeThreshold();
 
  G4long prec = os.precision(5);
  os << "======================================================================"
     << endline;
  os << "======          Radioactive Decay Physics Parameters           ======="
     << endline;
  os << "======================================================================"
     << endline;
  os << "min MeanLife (from G4NuclideTable)                "
     << G4BestUnit(minMeanLife, "Time") << endline;     
  os << "Max life time (from G4DeexPrecoParameters)        "
     << G4BestUnit(deex->GetMaxLifeTime(), "Time") << endline;
  os << "Internal e- conversion flag                       "
     << deex->GetInternalConversionFlag() << endline;
  os << "Stored internal conversion coefficients           "
     << deex->StoreICLevelData() << endline;
  os << "Enabled atomic relaxation mode                    "
     << applyARM << endline;
  os << "Enable correlated gamma emission                  "
     << deex->CorrelatedGamma() << endline;
  os << "Max 2J for sampling of angular correlations       "
     << deex->GetTwoJMAX() << endline;
  os << "Atomic de-excitation enabled                      "
     << emparam->Fluo() << endline;
  os << "Auger electron emission enabled                   "
     << emparam->Auger() << endline;
  os << "Check EM cuts disabled for atomic de-excitation   "
     << emparam->DeexcitationIgnoreCut() << endline;
  os << "Use Bearden atomic level energies                 "
     << emparam->BeardenFluoDir() << endline;
  os << "Use ANSTO fluorescence model                      "
     << emparam->ANSTOFluoDir() << endline;
  os << "Threshold for very long decay time at rest        "
     << G4BestUnit(fThresholdForVeryLongDecayTime, "Time") << endline;
  os << "======================================================================"
     << G4endl;
  os.precision(prec);
}

Referenced by BuildPhysicsTable().

Member Data Documentation

◆ decayIT

G4ITDecay* G4VRadioactiveDecay::decayIT

protected

Definition at line 199 of file G4VRadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::AddDeexcitationSpectrumForBiasMode(), BuildPhysicsTable(), DoDecay(), G4VRadioactiveDecay(), and ~G4VRadioactiveDecay().

◆ fParticleChangeForRadDecay

G4ParticleChangeForRadDecay G4VRadioactiveDecay::fParticleChangeForRadDecay

protected

Definition at line 195 of file G4VRadioactiveDecay.hh.

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

◆ isAllVolumesMode

G4bool G4VRadioactiveDecay::isAllVolumesMode {true}

protected

Definition at line 202 of file G4VRadioactiveDecay.hh.

202{true};

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

◆ levelTolerance

const G4double G4VRadioactiveDecay::levelTolerance = 10.0*CLHEP::eV

staticprotected

Definition at line 204 of file G4VRadioactiveDecay.hh.

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

◆ master_dkmap

DecayTableMap * G4VRadioactiveDecay::master_dkmap = nullptr

staticprotected

Definition at line 207 of file G4VRadioactiveDecay.hh.

Referenced by G4VRadioactiveDecay(), GetDecayTable(), LoadDecayTable(), and ~G4VRadioactiveDecay().

◆ photonEvaporation

G4PhotonEvaporation* G4VRadioactiveDecay::photonEvaporation

protected

Definition at line 198 of file G4VRadioactiveDecay.hh.

Referenced by BuildPhysicsTable(), G4VRadioactiveDecay(), and ~G4VRadioactiveDecay().

◆ theRadioactiveDecayMessenger

G4RadioactiveDecayMessenger* G4VRadioactiveDecay::theRadioactiveDecayMessenger

protected

Definition at line 197 of file G4VRadioactiveDecay.hh.

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

◆ ValidVolumes

std::vector<G4String> G4VRadioactiveDecay::ValidVolumes

protected

Definition at line 201 of file G4VRadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::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

◆ G4VRadioactiveDecay() [1/2]

◆ ~G4VRadioactiveDecay()

◆ G4VRadioactiveDecay() [2/2]

Member Function Documentation

◆ AddUserDecayDataFile()

◆ AtRestDoIt()

◆ BuildPhysicsTable()

◆ ChooseCollimationDirection()

◆ CollimateDecay()

◆ CollimateDecayProduct()

◆ DecayAnalog()

◆ DecayIt()

◆ DeselectAllVolumes()

◆ DeselectAVolume()

◆ DoDecay()

◆ GetDecayDirection()

◆ GetDecayHalfAngle()

◆ GetDecayTable()

◆ GetMeanFreePath()

◆ GetMeanLifeTime()

◆ GetNucleusLimits()

◆ GetThresholdForVeryLongDecayTime()

◆ IsApplicable()

◆ LoadDecayTable()

◆ operator=()

◆ PostStepDoIt()

◆ ProcessDescription()

◆ SelectAllVolumes()

◆ SelectAVolume()

◆ SetARM()

◆ SetDecayCollimation()

◆ SetDecayDirection()

◆ SetDecayHalfAngle()

◆ SetNucleusLimits()

◆ SetThresholdForVeryLongDecayTime()

◆ StreamInfo()

Member Data Documentation

◆ decayIT

◆ fParticleChangeForRadDecay

◆ isAllVolumesMode

◆ levelTolerance

◆ master_dkmap

◆ photonEvaporation

◆ theRadioactiveDecayMessenger

◆ ValidVolumes