#include <G4Radioactivation.hh>

Inheritance diagram for G4Radioactivation:

Public Member Functions
void	AddUserDecayDataFile (G4int Z, G4int A, G4String filename)

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)

G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)

void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

void	CalculateChainsFromParent (const G4ParticleDefinition &)

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

void	DeselectAllVolumes ()

void	DeselectAVolume (const G4String &aVolume)

virtual void	DumpInfo () const

virtual void	EndTracking ()

	G4Radioactivation (const G4String &processName="Radioactivation")

void	GetChainsFromParent (const G4ParticleDefinition &)

G4double	GetCurrentInteractionLength () const

const G4ThreeVector &	GetDecayDirection () const

G4double	GetDecayHalfAngle () const

G4DecayTable *	GetDecayTable (const G4ParticleDefinition *)

G4DecayTable *	GetDecayTable1 (const G4ParticleDefinition *)

const G4VProcess *	GetMasterProcess () const

G4NucleusLimits	GetNucleusLimits () const

G4double	GetNumberOfInteractionLengthLeft () const

const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)

G4double	GetPILfactor () const

virtual const G4ProcessManager *	GetProcessManager ()

const G4String &	GetProcessName () const

G4int	GetProcessSubType () const

G4ProcessType	GetProcessType () const

G4int	GetSplitNuclei ()

std::vector< G4RadioactivityTable * >	GetTheRadioactivityTables ()

G4double	GetThresholdForVeryLongDecayTime () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4int	GetVerboseLevel () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	IsAnalogueMonteCarlo ()

G4bool	IsApplicable (const G4ParticleDefinition &)

G4bool	isAtRestDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

G4bool	IsRateTableReady (const G4ParticleDefinition &)

G4DecayTable *	LoadDecayTable (const G4ParticleDefinition &theParentNucleus)

G4bool	operator!= (const G4VProcess &right) const

G4bool	operator== (const G4VProcess &right) const

virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

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

virtual void	ResetNumberOfInteractionLengthLeft ()

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

void	SelectAllVolumes ()

void	SelectAVolume (const G4String &aVolume)

void	SetAnalogueMonteCarlo (G4bool r)

void	SetARM (G4bool arm)

void	SetBRBias (G4bool r)

void	SetDecayBias (G4String filename)

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

void	SetDecayDirection (const G4ThreeVector &theDir)

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

void	SetDecayRate (G4int, G4int, G4double, G4int, std::vector< G4double >, std::vector< G4double >)

void	SetHLThreshold (G4double hl)

void	SetICM (G4bool icm)

virtual void	SetMasterProcess (G4VProcess *masterP)

void	SetNucleusLimits (G4NucleusLimits theNucleusLimits1)

void	SetPILfactor (G4double value)

virtual void	SetProcessManager (const G4ProcessManager *)

void	SetProcessSubType (G4int)

void	SetProcessType (G4ProcessType)

void	SetSourceTimeProfile (G4String filename)

void	SetSplitNuclei (G4int r)

void	SetThresholdForVeryLongDecayTime (const G4double inputThreshold)

void	SetVerboseLevel (G4int value)

virtual void	StartTracking (G4Track *)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

	~G4Radioactivation ()

Static Public Member Functions
static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions
void	AddDeexcitationSpectrumForBiasMode (G4ParticleDefinition apartDef, G4double weight, G4double currenTime, std::vector< double > &weights_v, std::vector< double > &times_v, std::vector< G4DynamicParticle > &secondaries_v)

G4ThreeVector	ChooseCollimationDirection () const

void	ClearNumberOfInteractionLengthLeft ()

void	CollimateDecay (G4DecayProducts *products)

void	CollimateDecayProduct (G4DynamicParticle *product)

G4double	ConvolveSourceTimeProfile (const G4double, const G4double)

void	DecayAnalog (const G4Track &theTrack)

G4DecayProducts *	DoDecay (const G4ParticleDefinition &theParticleDef)

G4double	GetDecayTime ()

G4int	GetDecayTimeBin (const G4double aDecayTime)

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

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

void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

Protected Attributes
G4ParticleChange	aParticleChange

const G4ProcessManager *	aProcessManager = nullptr

G4double	currentInteractionLength = -1.0

DecayTableMap *	dkmap

G4bool	enableAlongStepDoIt = true

G4bool	enableAtRestDoIt = true

G4bool	enablePostStepDoIt = true

G4ParticleChangeForRadDecay	fParticleChangeForRadDecay

bool	isAllVolumesMode

G4PhotonEvaporation *	photonEvaporation

G4VParticleChange *	pParticleChange = nullptr

G4double	theInitialNumberOfInteractionLength = -1.0

G4double	theNumberOfInteractionLengthLeft = -1.0

G4String	thePhysicsTableFileName

G4double	thePILfactor = 1.0

G4String	theProcessName

G4int	theProcessSubType = -1

G4ProcessType	theProcessType = fNotDefined

G4RadioactivationMessenger *	theRadioactivationMessenger

G4RadioactiveDecayMessenger *	theRadioactiveDecayMessenger

std::vector< G4String >	ValidVolumes

Static Protected Attributes
static const G4double	levelTolerance = 10.0*eV

Private Member Functions
G4VParticleChange *	AtRestDoIt (const G4Track &theTrack, const G4Step &theStep)

G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)

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

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

Private Attributes
G4bool	AnalogueMC

G4bool	applyARM

G4bool	applyICM

G4bool	BRBias

G4RadioactiveDecayChainsFromParent	chainsFromParent

G4double	DBin [100]

G4int	decayWindows [100]

G4String	dirPath

G4double	DProfile [100]

G4ThreeVector	forceDecayDirection

G4double	forceDecayHalfAngle

G4ProcessTable *	fProcessTable = nullptr

G4double	fRemainderLifeTime

G4double	fThresholdForVeryLongDecayTime

G4double	halflifethreshold

G4bool	isInitialised

G4VProcess *	masterProcessShadow = nullptr

G4int	NDecayBin

G4int	NSourceBin

G4int	NSplit

G4RadioactiveDecayRatesToDaughter	ratesToDaughter

G4double	SBin [100]

G4double	SProfile [100]

G4RadioactiveDecayRates	theDecayRateVector

G4NucleusLimits	theNucleusLimits

G4RadioactiveDecayParentChainTable	theParentChainTable

G4RadioactiveDecayMode	theRadDecayMode

std::vector< G4RadioactivityTable * >	theRadioactivityTables

std::map< G4int, G4String >	theUserRadioactiveDataFiles

G4int	verboseLevel

Static Private Attributes
static const G4ThreeVector	origin

Detailed Description

Definition at line 55 of file G4Radioactivation.hh.

Constructor & Destructor Documentation

◆ G4Radioactivation()

G4Radioactivation::G4Radioactivation ( const G4String & processName = "Radioactivation" )

Definition at line 93 of file G4Radioactivation.cc.

 : G4RadioactiveDecay(processName)
{
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 1) {
    G4cout << "G4Radioactivation constructor: processName = " << processName
           << G4endl;
  }
#endif
 
// DHW  SetProcessSubType(fRadioactiveDecay);
  theRadioactivationMessenger = new G4RadioactivationMessenger(this);
 
  // Apply default values.
  NSourceBin  = 1;
  SBin[0]     = 0.* s;
  SBin[1]     = 1.* s;    // Convert to ns
  SProfile[0] = 1.;
  SProfile[1] = 0.;
  NDecayBin   = 1;
  DBin[0]     = 0. * s ;
  DBin[1]     = 1. * s;
  DProfile[0] = 1.;
  DProfile[1] = 0.;
  decayWindows[0] = 0;
  G4RadioactivityTable* rTable = new G4RadioactivityTable() ;
  theRadioactivityTables.push_back(rTable);
  NSplit      = 1;
  AnalogueMC = true;
  BRBias = true;
  halflifethreshold = 1000.*nanosecond;
}

References AnalogueMC, BRBias, DBin, decayWindows, DProfile, G4cout, G4endl, G4RadioactiveDecay::GetVerboseLevel(), halflifethreshold, nanosecond, NDecayBin, NSourceBin, NSplit, s, SBin, SProfile, theRadioactivationMessenger, and theRadioactivityTables.

◆ ~G4Radioactivation()

G4Radioactivation::~G4Radioactivation ( )

Definition at line 139 of file G4Radioactivation.cc.

{
  delete theRadioactivationMessenger;
}

References theRadioactivationMessenger.

Member Function Documentation

◆ AddDeexcitationSpectrumForBiasMode()

void G4Radioactivation::AddDeexcitationSpectrumForBiasMode	(	G4ParticleDefinition *	apartDef,
		G4double	weight,
		G4double	currenTime,
		std::vector< double > &	weights_v,
		std::vector< double > &	times_v,
		std::vector< G4DynamicParticle * > &	secondaries_v
	)

protected

Definition at line 1123 of file G4Radioactivation.cc.

{
  G4double elevel=((const G4Ions*)(apartDef))->GetExcitationEnergy();
  G4double life_time=apartDef->GetPDGLifeTime();
  G4ITDecay* anITChannel = 0;
 
  while (life_time < halflifethreshold && elevel > 0.) {
    anITChannel = new G4ITDecay(apartDef, 100., elevel, elevel, photonEvaporation);
    G4DecayProducts* pevap_products = anITChannel->DecayIt(0.);
    G4int nb_pevapSecondaries = pevap_products->entries();
 
    G4DynamicParticle* a_pevap_secondary = 0;
    G4ParticleDefinition* secDef = 0;
    for (G4int ind = 0; ind < nb_pevapSecondaries; ind++) {
      a_pevap_secondary= pevap_products->PopProducts();
      secDef = a_pevap_secondary->GetDefinition();
 
      if (secDef->GetBaryonNumber() > 4) {
        elevel = ((const G4Ions*)(secDef))->GetExcitationEnergy();
        life_time = secDef->GetPDGLifeTime();
        apartDef = secDef;
        if (secDef->GetPDGStable() ) {
          weights_v.push_back(weight);
          times_v.push_back(currentTime);
          secondaries_v.push_back(a_pevap_secondary);
        }
      } else {
        weights_v.push_back(weight);
        times_v.push_back(currentTime);
        secondaries_v.push_back(a_pevap_secondary);
      }
    }
 
    delete anITChannel;
    delete pevap_products;
  }
}

References G4ITDecay::DecayIt(), G4DecayProducts::entries(), G4ParticleDefinition::GetBaryonNumber(), G4DynamicParticle::GetDefinition(), G4ParticleDefinition::GetPDGLifeTime(), G4ParticleDefinition::GetPDGStable(), G4RadioactiveDecay::photonEvaporation, and G4DecayProducts::PopProducts().

Referenced by DecayIt().

◆ AddUserDecayDataFile()

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

inherited

Definition at line 911 of file G4RadioactiveDecay.cc.

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

References A, FatalException, G4cout, G4endl, G4Exception(), G4RadioactiveDecay::theUserRadioactiveDataFiles, and Z.

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

◆ AlongStepDoIt()

virtual G4VParticleChange * G4VRestDiscreteProcess::AlongStepDoIt	(	const G4Track &	,
		const G4Step &
	)

inlinevirtualinherited

Implements G4VProcess.

Definition at line 87 of file G4VRestDiscreteProcess.hh.

90 { return 0; }

◆ AlongStepGetPhysicalInteractionLength()

virtual G4double G4VRestDiscreteProcess::AlongStepGetPhysicalInteractionLength	(	const G4Track &	,
		G4double	,
		G4double	,
		G4double &	,
		G4GPILSelection *
	)

inlinevirtualinherited

Implements G4VProcess.

Definition at line 78 of file G4VRestDiscreteProcess.hh.

84 { return -1.0; }

◆ AlongStepGPIL()

G4double G4VProcess::AlongStepGPIL	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimumStep,
		G4double &	proposedSafety,
		G4GPILSelection *	selection
	)

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
                             currentMinimumStep, proposedSafety, selection);
}

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ AtRestDoIt()

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

inlineprivatevirtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 177 of file G4Radioactivation.hh.

178 {return DecayIt(theTrack, theStep);}

G4Radioactivation::DecayIt

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

Definition: G4Radioactivation.cc:810

References DecayIt().

◆ AtRestGetPhysicalInteractionLength()

G4double G4RadioactiveDecay::AtRestGetPhysicalInteractionLength	(	const G4Track &	track,
		G4ForceCondition *	condition
	)

inlineprivatevirtualinherited

Reimplemented from G4VRestDiscreteProcess.

Definition at line 240 of file G4RadioactiveDecay.hh.

    {
      fRemainderLifeTime =
        G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(track, condition);
      return fRemainderLifeTime;
    }

References G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4RadioactiveDecay::fRemainderLifeTime.

◆ AtRestGPIL()

G4double G4VProcess::AtRestGPIL	(	const G4Track &	track,
		G4ForceCondition *	condition
	)

inlineinherited

Definition at line 472 of file G4VProcess.hh.

{
  return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
}

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

◆ BuildPhysicsTable()

void G4RadioactiveDecay::BuildPhysicsTable ( const G4ParticleDefinition & )

virtualinherited

Reimplemented from G4VProcess.

Definition at line 448 of file G4RadioactiveDecay.cc.

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

References G4cout, G4GenericIon::GenericIon(), G4RadioactiveDecay::GetVerboseLevel(), G4HadronicProcessStore::Instance(), G4HadronicParameters::Instance(), G4RadioactiveDecay::isInitialised, G4Threading::IsMasterThread(), G4HadronicProcessStore::RegisterParticleForExtraProcess(), and G4RadioactiveDecay::StreamInfo().

◆ BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

◆ CalculateChainsFromParent()

void G4Radioactivation::CalculateChainsFromParent ( const G4ParticleDefinition & theParentNucleus )

Definition at line 341 of file G4Radioactivation.cc.

{
  // Use extended Bateman equation to calculate the radioactivities of all
  // progeny of theParentNucleus.  The coefficients required to do this are 
  // calculated using the method of P. Truscott (Ph.D. thesis and
  // DERA Technical Note DERA/CIS/CIS2/7/36/4/10) 11 January 2000.
  // Coefficients are then added to the decay rate table vector
 
  // Create and initialise variables used in the method.
  theDecayRateVector.clear();
 
  G4int nGeneration = 0;
 
  std::vector<G4double> taos;
 
  // Dimensionless A coefficients of Eqs. 4.24 and 4.25 of the TN
  std::vector<G4double> Acoeffs;
 
  // According to Eq. 4.26 the first coefficient (A_1:1) is -1
  Acoeffs.push_back(-1.);
 
  G4int A = ((const G4Ions*)(&theParentNucleus))->GetAtomicMass();
  G4int Z = ((const G4Ions*)(&theParentNucleus))->GetAtomicNumber();
  G4double E = ((const G4Ions*)(&theParentNucleus))->GetExcitationEnergy();
  G4double tao = theParentNucleus.GetPDGLifeTime();
  if (tao < 0.) tao = 1e-100;
  taos.push_back(tao);
  G4int nEntry = 0;
 
  // Fill the decay rate container (G4RadioactiveDecayRate) with the parent 
  // isotope data
  SetDecayRate(Z,A,E,nGeneration,Acoeffs,taos);   // Fill TP with parent lifetime
 
  // store the decay rate in decay rate vector
  theDecayRateVector.push_back(ratesToDaughter);
  nEntry++;
 
  // Now start treating the secondary generations.
  G4bool stable = false;
//  G4int i;
  G4int j;
  G4VDecayChannel* theChannel = 0;
  G4NuclearDecay* theNuclearDecayChannel = 0;
 
  G4ITDecay* theITChannel = 0;
  G4BetaMinusDecay* theBetaMinusChannel = 0;
  G4BetaPlusDecay* theBetaPlusChannel = 0;
  G4AlphaDecay* theAlphaChannel = 0;
  G4ProtonDecay* theProtonChannel = 0;
  G4TritonDecay* theTritonChannel = 0;
  G4NeutronDecay* theNeutronChannel = 0;
  G4SFDecay* theFissionChannel = 0;
 
  G4RadioactiveDecayMode theDecayMode;
  G4double theBR = 0.0;
  G4int AP = 0;
  G4int ZP = 0;
  G4int AD = 0;
  G4int ZD = 0;
  G4double EP = 0.;
  std::vector<G4double> TP;
  std::vector<G4double> RP;   // A coefficients of the previous generation
  G4ParticleDefinition *theDaughterNucleus;
  G4double daughterExcitation;
  G4double nearestEnergy = 0.0;
  G4int nearestLevelIndex = 0;
  G4ParticleDefinition *aParentNucleus;
  G4IonTable* theIonTable;
  G4DecayTable* parentDecayTable;
  G4double theRate;
  G4double TaoPlus;
  G4int nS = 0;        // Running index of first decay in a given generation
  G4int nT = nEntry;   // Total number of decays accumulated over entire history
  const G4int nMode = G4RadioactiveDecayModeSize;
  G4double brs[nMode];
  //
  theIonTable =
    (G4IonTable*)(G4ParticleTable::GetParticleTable()->GetIonTable());
 
  G4int loop = 0;
  while (!stable) {   /* Loop checking, 01.09.2015, D.Wright */
    loop++;
    if (loop > 10000) {
      G4Exception("G4Radioactivation::CalculateChainsFromParent()", "HAD_RDM_100",
                  JustWarning, "While loop count exceeded");
      break;
    }
    nGeneration++;
    for (j = nS; j < nT; j++) {
      // First time through, get data for parent nuclide
      ZP = theDecayRateVector[j].GetZ();
      AP = theDecayRateVector[j].GetA();
      EP = theDecayRateVector[j].GetE();
      RP = theDecayRateVector[j].GetDecayRateC();
      TP = theDecayRateVector[j].GetTaos();
      if (GetVerboseLevel() > 1) {
        G4cout << "G4RadioactiveDecay::CalculateChainsFromParent: daughters of ("
               << ZP << ", " << AP << ", " << EP
               << ") are being calculated,  generation = " << nGeneration
               << G4endl;
      }
//      G4cout << " Taus = " << G4endl;
//      for (G4int ii = 0; ii < TP.size(); ii++) G4cout << TP[ii] << ", " ;
//      G4cout << G4endl;
 
      aParentNucleus = theIonTable->GetIon(ZP,AP,EP);
      parentDecayTable = GetDecayTable1(aParentNucleus);
 
      G4DecayTable* summedDecayTable = new G4DecayTable();
      // This instance of G4DecayTable is for accumulating BRs and decay
      // channels.  It will contain one decay channel per type of decay
      // (alpha, beta, etc.); its branching ratio will be the sum of all
      // branching ratios for that type of decay of the parent.  If the
      // halflife of a particular channel is longer than some threshold,
      // that channel will be inserted specifically and its branching
      // ratio will not be included in the above sums.
      // This instance is not used to perform actual decays.
 
      for (G4int k = 0; k < nMode; k++) brs[k] = 0.0;
 
      // Go through the decay table and sum all channels having the same decay mode
      for (G4int i = 0; i < parentDecayTable->entries(); i++) {
        theChannel = parentDecayTable->GetDecayChannel(i);
        theNuclearDecayChannel = static_cast<G4NuclearDecay*>(theChannel);
        theDecayMode = theNuclearDecayChannel->GetDecayMode();
        daughterExcitation = theNuclearDecayChannel->GetDaughterExcitation();
        theDaughterNucleus = theNuclearDecayChannel->GetDaughterNucleus() ;
        AD = ((const G4Ions*)(theDaughterNucleus))->GetAtomicMass();
        ZD = ((const G4Ions*)(theDaughterNucleus))->GetAtomicNumber();  
        const G4LevelManager* levelManager =
          G4NuclearLevelData::GetInstance()->GetLevelManager(ZD,AD);
 
        // Check each nuclide to see if it is metastable (lifetime > 1 usec) 
        // If so, add it to the decay chain by inserting its decay channel in
        // summedDecayTable.  If not, just add its BR to sum for that decay mode. 
        if (levelManager->NumberOfTransitions() ) {
          nearestEnergy = levelManager->NearestLevelEnergy(daughterExcitation);
          if (std::abs(daughterExcitation - nearestEnergy) < levelTolerance) {
            // Level half-life is in ns and the threshold is set to 1 micros
            // by default, user can set it via the UI command
            nearestLevelIndex = levelManager->NearestLevelIndex(daughterExcitation);
            if (levelManager->LifeTime(nearestLevelIndex)*ns >= halflifethreshold){
              // save the metastable decay channel 
              summedDecayTable->Insert(theChannel);
            } else {
              brs[theDecayMode] += theChannel->GetBR();
            }
          } else {
            brs[theDecayMode] += theChannel->GetBR();
          }
        } else {
          brs[theDecayMode] += theChannel->GetBR();
        }
 
      } // Combine decay channels (loop i)
 
      brs[BetaPlus] = brs[BetaPlus]+brs[KshellEC]+brs[LshellEC]+brs[MshellEC]+brs[NshellEC];  // Combine beta+ and EC 
      brs[KshellEC] = brs[LshellEC] = brs[MshellEC] = brs[NshellEC] = 0.0;
      for (G4int i = 0; i < nMode; i++) {                 // loop over decay modes
        if (brs[i] > 0.) {
          switch (i) {
          case IT:
            // Decay mode is isomeric transition
            theITChannel = new G4ITDecay(aParentNucleus, brs[IT], 0.0, 0.0,
                                         photonEvaporation);
 
            summedDecayTable->Insert(theITChannel);
            break;
 
          case BetaMinus:
            // Decay mode is beta-
            theBetaMinusChannel = new G4BetaMinusDecay(aParentNucleus, brs[BetaMinus],
                                                       0.*MeV, 0.*MeV,
                                                       noFloat, allowed);
            summedDecayTable->Insert(theBetaMinusChannel);
            break;
 
          case BetaPlus:
            // Decay mode is beta+ + EC.
            theBetaPlusChannel = new G4BetaPlusDecay(aParentNucleus, brs[BetaPlus],
                                                     0.*MeV, 0.*MeV,
                                                     noFloat, allowed);
            summedDecayTable->Insert(theBetaPlusChannel);
            break;
 
          case Alpha:
            // Decay mode is alpha.
            theAlphaChannel = new G4AlphaDecay(aParentNucleus, brs[Alpha], 0.*MeV,
                                               0.*MeV, noFloat);
            summedDecayTable->Insert(theAlphaChannel);
            break;
 
          case Proton:
            // Decay mode is proton.
            theProtonChannel = new G4ProtonDecay(aParentNucleus, brs[Proton], 0.*MeV,
                                                 0.*MeV, noFloat);
            summedDecayTable->Insert(theProtonChannel);
            break;
 
          case Neutron:
            // Decay mode is neutron.
            theNeutronChannel = new G4NeutronDecay(aParentNucleus, brs[Neutron], 0.*MeV,
                                                   0.*MeV, noFloat);
            summedDecayTable->Insert(theNeutronChannel);
            break;
 
          case SpFission:
            // Decay mode is spontaneous fission
            theFissionChannel = new G4SFDecay(aParentNucleus, brs[SpFission], 0.*MeV,
                                              0.*MeV, noFloat);
            summedDecayTable->Insert(theFissionChannel);
            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:
            // Decay mode is Triton.
            theTritonChannel = new G4TritonDecay(aParentNucleus, brs[Triton], 0.*MeV,
                                                0.*MeV, noFloat);
            summedDecayTable->Insert(theTritonChannel);
            break;
 
          default:
            break;
          }
        }
      }
 
      // loop over all branches in summedDecayTable
      //
      for (G4int i = 0; i < summedDecayTable->entries(); i++){
        theChannel = summedDecayTable->GetDecayChannel(i);
        theNuclearDecayChannel = static_cast<G4NuclearDecay*>(theChannel);
        theBR = theChannel->GetBR();
        theDaughterNucleus = theNuclearDecayChannel->GetDaughterNucleus();
 
        // First check if the decay of the original nucleus is an IT channel,
        // if true create a new ground-state nucleus
        if (theNuclearDecayChannel->GetDecayMode() == IT && nGeneration == 1) {
 
          A = ((const G4Ions*)(theDaughterNucleus))->GetAtomicMass();
          Z = ((const G4Ions*)(theDaughterNucleus))->GetAtomicNumber();
          theDaughterNucleus=theIonTable->GetIon(Z,A,0.);
        }
        if (IsApplicable(*theDaughterNucleus) && theBR > 0.0 && 
            aParentNucleus != theDaughterNucleus) { 
          // need to make sure daughter has decay table
          parentDecayTable = GetDecayTable1(theDaughterNucleus);
          if (parentDecayTable->entries() ) {
            A = ((const G4Ions*)(theDaughterNucleus))->GetAtomicMass();
            Z = ((const G4Ions*)(theDaughterNucleus))->GetAtomicNumber();
            E = ((const G4Ions*)(theDaughterNucleus))->GetExcitationEnergy();
 
            TaoPlus = theDaughterNucleus->GetPDGLifeTime();
            if (TaoPlus <= 0.)  TaoPlus = 1e-100;
 
            // first set the taos, one simply need to add to the parent ones
            taos.clear();
            taos = TP;   // load lifetimes of all previous generations 
            size_t k;
            //check that TaoPlus differs from other taos from at least 1.e5 relative difference
            //for (k = 0; k < TP.size(); k++){
            //if (std::abs((TaoPlus-TP[k])/TP[k])<1.e-5 ) TaoPlus=1.00001*TP[k];
            //}
            taos.push_back(TaoPlus);  // add daughter lifetime to list
            // now calculate the coefficiencies
            //
            // they are in two parts, first the less than n ones
            // Eq 4.24 of the TN
            Acoeffs.clear();
            long double ta1,ta2;
            ta2 = (long double)TaoPlus;
            for (k = 0; k < RP.size(); k++){
              ta1 = (long double)TP[k];    // loop over lifetimes of all previous generations
              if (ta1 == ta2) {
                theRate = 1.e100;
              } else {
                theRate = ta1/(ta1-ta2);
              }
              theRate = theRate * theBR * RP[k];
              Acoeffs.push_back(theRate);
            }
 
            // the second part: the n:n coefficiency
            // Eq 4.25 of the TN.  Note Yn+1 is zero apart from Y1 which is -1
            // as treated at line 1013 
            theRate = 0.;
            long double aRate, aRate1;
            aRate1 = 0.L;
            for (k = 0; k < RP.size(); k++){
              ta1 = (long double)TP[k];
              if (ta1 == ta2 ) {
                aRate = 1.e100;
              } else {
                aRate = ta2/(ta1-ta2);
              }
              aRate = aRate * (long double)(theBR * RP[k]);
              aRate1 += aRate;
            }
            theRate = -aRate1;
            Acoeffs.push_back(theRate);           
            SetDecayRate (Z,A,E,nGeneration,Acoeffs,taos);
            theDecayRateVector.push_back(ratesToDaughter);
            nEntry++;
          } // there are entries in the table
        } // nuclide is OK to decay
      } // end of loop (i) over decay table branches
 
      delete summedDecayTable;
 
    } // Getting contents of decay rate vector (end loop on j)
    nS = nT;
    nT = nEntry;
    if (nS == nT) stable = true;
  } // while nuclide is not stable
 
  // end of while loop
  // the calculation completed here
 
 
  // fill the first part of the decay rate table
  // which is the name of the original particle (isotope)
  chainsFromParent.SetIonName(theParentNucleus.GetParticleName()); 
 
  // now fill the decay table with the newly completed decay rate vector
  chainsFromParent.SetItsRates(theDecayRateVector);
 
  // finally add the decayratetable to the tablevector
  theParentChainTable.push_back(chainsFromParent);
}

References A, allowed, Alpha, anonymous_namespace{paraMaker.cc}::AP, BDNeutron, BDProton, Beta2Minus, Beta2Plus, BetaMinus, BetaPlus, chainsFromParent, G4DecayTable::entries(), G4cout, G4endl, G4Exception(), G4RadioactiveDecayModeSize, G4VDecayChannel::GetBR(), G4NuclearDecay::GetDaughterExcitation(), G4NuclearDecay::GetDaughterNucleus(), G4DecayTable::GetDecayChannel(), G4NuclearDecay::GetDecayMode(), GetDecayTable1(), G4NuclearLevelData::GetInstance(), G4IonTable::GetIon(), G4ParticleTable::GetIonTable(), G4NuclearLevelData::GetLevelManager(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGLifeTime(), G4RadioactiveDecay::GetVerboseLevel(), halflifethreshold, G4DecayTable::Insert(), G4RadioactiveDecay::IsApplicable(), IT, JustWarning, KshellEC, G4RadioactiveDecay::levelTolerance, G4LevelManager::LifeTime(), LshellEC, MeV, MshellEC, G4LevelManager::NearestLevelEnergy(), G4LevelManager::NearestLevelIndex(), Neutron, Neutron2, noFloat, ns, NshellEC, G4LevelManager::NumberOfTransitions(), G4RadioactiveDecay::photonEvaporation, Proton, Proton2, ratesToDaughter, SetDecayRate(), G4RadioactiveDecayChainsFromParent::SetIonName(), G4RadioactiveDecayChainsFromParent::SetItsRates(), SpFission, theDecayRateVector, theParentChainTable, Triton, and Z.

Referenced by DecayIt().

◆ ChooseCollimationDirection()

G4ThreeVector G4RadioactiveDecay::ChooseCollimationDirection ( ) const

protectedinherited

Definition at line 1306 of file G4RadioactiveDecay.cc.

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

References deg, G4RadioactiveDecay::forceDecayDirection, G4RadioactiveDecay::forceDecayHalfAngle, G4cout, G4endl, G4UniformRand, G4RadioactiveDecay::GetVerboseLevel(), G4RadioactiveDecay::origin, CLHEP::Hep3Vector::phi(), pi, CLHEP::Hep3Vector::setPhi(), CLHEP::Hep3Vector::setTheta(), and CLHEP::Hep3Vector::theta().

Referenced by G4RadioactiveDecay::CollimateDecayProduct().

◆ ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedinherited

Definition at line 424 of file G4VProcess.hh.

{
  theInitialNumberOfInteractionLength = -1.0; 
  theNumberOfInteractionLengthLeft =  -1.0;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

◆ CollimateDecay()

void G4RadioactiveDecay::CollimateDecay ( G4DecayProducts * products )

protectedinherited

Definition at line 1261 of file G4RadioactiveDecay.cc.

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

References alpha, G4RadioactiveDecay::CollimateDecayProduct(), G4Gamma::Definition(), G4Neutron::Definition(), G4Proton::Definition(), G4Alpha::Definition(), G4Triton::Definition(), G4Electron::Definition(), G4Positron::Definition(), deg, G4InuclParticleNames::electron, G4DecayProducts::entries(), G4RadioactiveDecay::forceDecayDirection, G4RadioactiveDecay::forceDecayHalfAngle, G4cout, G4endl, G4DynamicParticle::GetParticleDefinition(), G4RadioactiveDecay::GetVerboseLevel(), G4InuclParticleNames::neutron, G4RadioactiveDecay::origin, G4InuclParticleNames::positron, G4InuclParticleNames::proton, and G4InuclParticleNames::triton.

Referenced by G4RadioactiveDecay::DoDecay().

◆ CollimateDecayProduct()

void G4RadioactiveDecay::CollimateDecayProduct ( G4DynamicParticle * product )

protectedinherited

Definition at line 1291 of file G4RadioactiveDecay.cc.

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

References G4RadioactiveDecay::ChooseCollimationDirection(), G4cout, G4endl, G4DynamicParticle::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4RadioactiveDecay::GetVerboseLevel(), G4RadioactiveDecay::origin, and G4DynamicParticle::SetMomentumDirection().

Referenced by G4RadioactiveDecay::CollimateDecay().

◆ ConvolveSourceTimeProfile()

G4double G4Radioactivation::ConvolveSourceTimeProfile	(	const G4double	t,
		const G4double	tau
	)

protected

Definition at line 198 of file G4Radioactivation.cc.

{
  G4double convolvedTime = 0.0;
  G4int nbin;
  if ( t > SBin[NSourceBin]) {
    nbin  = NSourceBin;
  } else {
    nbin = 0;
 
    G4int loop = 0;
    while (t > SBin[nbin]) {  // Loop checking, 01.09.2015, D.Wright
      loop++;
      if (loop > 1000) {
        G4Exception("G4Radioactivation::ConvolveSourceTimeProfile()",
                    "HAD_RDM_100", JustWarning, "While loop count exceeded");
        break;
      }
      nbin++;
    }
    nbin--;
  }
 
  // Use expm1 wherever possible to avoid large cancellation errors in
  // 1 - exp(x) for small x
  G4double earg = 0.0;
  if (nbin > 0) {
    for (G4int i = 0; i < nbin; i++) {
      earg = (SBin[i+1] - SBin[i])/tau;
      if (earg < 100.) {
        convolvedTime += SProfile[i] * std::exp((SBin[i] - t)/tau) *
                         std::expm1(earg);
      } else {
        convolvedTime += SProfile[i] *
          (std::exp(-(t-SBin[i+1])/tau)-std::exp(-(t-SBin[i])/tau));
      }
    }
  }
  convolvedTime -= SProfile[nbin] * std::expm1((SBin[nbin] - t)/tau);
  // tau divided out of final result to provide probability of decay in window
 
  if (convolvedTime < 0.)  {
    G4cout << " Convolved time =: " << convolvedTime << " reset to zero! " << G4endl;
    G4cout << " t = " << t << " tau = " << tau << G4endl;
    G4cout << SBin[nbin] << " " << SBin[0] << G4endl;
    convolvedTime = 0.;
  }
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2)
    G4cout << " Convolved time: " << convolvedTime << G4endl;
#endif
  return convolvedTime;
}

References G4cout, G4endl, G4Exception(), G4RadioactiveDecay::GetVerboseLevel(), JustWarning, NSourceBin, SBin, and SProfile.

Referenced by DecayIt().

◆ DecayAnalog()

void G4RadioactiveDecay::DecayAnalog ( const G4Track & theTrack )

protectedinherited

Definition at line 1101 of file G4RadioactiveDecay.cc.

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

References G4ParticleChangeForRadDecay::AddSecondary(), G4DecayProducts::Boost(), G4VProcess::ClearNumberOfInteractionLengthLeft(), cm, G4RadioactiveDecay::DoDecay(), G4DecayProducts::DumpInfo(), G4DecayProducts::entries(), G4RadioactiveDecay::fParticleChangeForRadDecay, fStopAndKill, fStopButAlive, G4RadioactiveDecay::fThresholdForVeryLongDecayTime, G4cout, G4endl, G4UniformRand, G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4DynamicParticle::GetKineticEnergy(), G4Track::GetLocalTime(), G4PhysicsModelCatalog::GetModelID(), G4DynamicParticle::GetMomentumDirection(), G4DynamicParticle::GetParticleDefinition(), G4ParticleDefinition::GetPDGLifeTime(), G4ParticleDefinition::GetPDGMass(), G4Track::GetPosition(), G4Track::GetTouchableHandle(), G4Track::GetTrackStatus(), G4RadioactiveDecay::GetVerboseLevel(), G4Track::GetWeight(), G4DecayProducts::IsChecked(), IT, KshellEC, ns, NshellEC, G4DecayProducts::PopProducts(), G4VParticleChange::ProposeLocalEnergyDeposit(), G4ParticleChangeForDecay::ProposeLocalTime(), G4VParticleChange::ProposeTrackStatus(), G4Track::SetCreatorModelID(), G4Track::SetGoodForTrackingFlag(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetTouchableHandle(), G4Track::SetWeight(), and G4RadioactiveDecay::theRadDecayMode.

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

◆ DecayIt()

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

Definition at line 810 of file G4Radioactivation.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()>0) {
        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 = GetDecayTable1(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
    if (AnalogueMC) {
      G4RadioactiveDecay::DecayAnalog(theTrack);
 
    } else {
      // Proceed with decay using variance reduction 
      G4double energyDeposit = 0.0;
      G4double finalGlobalTime = theTrack.GetGlobalTime();
      G4double finalLocalTime = theTrack.GetLocalTime(); 
      G4int index;
      G4ThreeVector currentPosition;
      currentPosition = theTrack.GetPosition();
 
      G4IonTable* theIonTable;
      G4ParticleDefinition* parentNucleus;
 
      // Get decay chains for the given nuclide
      if (!IsRateTableReady(*theParticleDef)) CalculateChainsFromParent(*theParticleDef);
      GetChainsFromParent(*theParticleDef);
 
      // Declare some of the variables required in the implementation
      G4int PZ;
      G4int PA;
      G4double PE;
      G4String keyName;
      std::vector<G4double> PT;
      std::vector<G4double> PR;
      G4double taotime;
      long double decayRate;
 
      size_t i;
      G4int numberOfSecondaries;
      G4int totalNumberOfSecondaries = 0;
      G4double currentTime = 0.;
      G4int ndecaych;
      G4DynamicParticle* asecondaryparticle;
      std::vector<G4DynamicParticle*> secondaryparticles;
      std::vector<G4double> pw;
      std::vector<G4double> ptime;
      pw.clear();
      ptime.clear();
 
      // Now apply the nucleus splitting
      for (G4int n = 0; n < NSplit; n++) {
        // Get the decay time following the decay probability function 
        // supplied by user  
        G4double theDecayTime = GetDecayTime();
        G4int nbin = GetDecayTimeBin(theDecayTime);
 
        // calculate the first part of the weight function  
        G4double weight1 = 1.; 
        if (nbin == 1) {
          weight1 = 1./DProfile[nbin-1] 
                    *(DBin[nbin]-DBin[nbin-1])/NSplit;   // width of window in ns
        } else if (nbin > 1) {
          // Go from nbin to nbin-2 because flux entries in file alternate between 0 and 1 
          weight1 = 1./(DProfile[nbin]-DProfile[nbin-2])
                    *(DBin[nbin]-DBin[nbin-1])/NSplit;
          // weight1 = (probability of choosing one of the bins)*(time width of bin)/NSplit
        }
        // it should be calculated in seconds
        weight1 /= s ;
        
        // loop over all the possible secondaries of the nucleus
        // the first one is itself.
        for (i = 0; i < theDecayRateVector.size(); i++) {
          PZ = theDecayRateVector[i].GetZ();
          PA = theDecayRateVector[i].GetA();
          PE = theDecayRateVector[i].GetE();
          PT = theDecayRateVector[i].GetTaos();
          PR = theDecayRateVector[i].GetDecayRateC();
 
          // The array of arrays theDecayRateVector contains all possible decay
          // chains of a given parent nucleus (ZP,AP,EP) to a given descendant
          // nuclide (Z,A,E).
          //
          // theDecayRateVector[0] contains the decay parameters of the parent
          // nucleus
          //           PZ = ZP
          //           PA = AP
          //           PE = EP
          //           PT[] = {TP}
          //           PR[] = {RP}
          //
          // theDecayRateVector[1] contains the decay of the parent to the first
          // generation daughter (Z1,A1,E1).
          //           PZ = Z1
          //           PA = A1
          //           PE = E1
          //           PT[] = {TP, T1}
          //           PR[] = {RP, R1}
          //
          // theDecayRateVector[2] contains the decay of the parent to the first
          // generation daughter (Z1,A1,E1) and the decay of the first
          // generation daughter to the second generation daughter (Z2,A2,E2).
          //           PZ = Z2
          //           PA = A2
          //           PE = E2
          //           PT[] = {TP, T1, T2}
          //           PR[] = {RP, R1, R2}
          //
          // theDecayRateVector[3] may contain a branch chain
          //           PZ = Z2a
          //           PA = A2a
          //           PE = E2a
          //           PT[] = {TP, T1, T2a}
          //           PR[] = {RP, R1, R2a}
          //
          // and so on.
 
          // Calculate the decay rate of the isotope.  decayRate is the
          // radioactivity of isotope (PZ,PA,PE) at 'theDecayTime'
          // it will be used to calculate the statistical weight of the 
          // decay products of this isotope
 
          // For each nuclide, calculate all the decay chains which can reach
          // the parent nuclide
          decayRate = 0.L;
          for (G4int j = 0; j < G4int(PT.size() ); j++) {
            taotime = ConvolveSourceTimeProfile(theDecayTime,PT[j]);
            decayRate -= PR[j] * (long double)taotime;  // PRs are Acoeffs, taotime is inverse time
            // Eq.4.23 of of the TN
            // note the negative here is required as the rate in the
            // equation is defined to be negative, 
            // i.e. decay away, but we need positive value here.
 
            // G4cout << j << "\t"<< PT[j]/s << "\t" << PR[j] << "\t" << decayRate << G4endl;       
          }
 
          // At this point any negative decay rates are probably small enough
          // (order 10**-30) that negative values are likely due to cancellation
          // errors.  Set them to zero.
          if (decayRate < 0.0) decayRate = 0.0;
 
          //  G4cout <<theDecayTime/s <<"\t"<<nbin<<G4endl;
          //  G4cout << theTrack.GetWeight() <<"\t"<<weight1<<"\t"<<decayRate<< G4endl;
 
          // Add isotope to the radioactivity tables
          // One table for each observation time window specified in
          // SetDecayBias(G4String filename)
 
          theRadioactivityTables[decayWindows[nbin-1]]
                ->AddIsotope(PZ,PA,PE,weight1*decayRate,theTrack.GetWeight());
 
          // Now calculate the statistical weight
          // One needs to fold the source bias function with the decaytime
          // also need to include the track weight! (F.Lei, 28/10/10)
          G4double weight = weight1*decayRate*theTrack.GetWeight();
 
          // decay the isotope 
          theIonTable = (G4IonTable *)(G4ParticleTable::GetParticleTable()->GetIonTable());
          parentNucleus = theIonTable->GetIon(PZ,PA,PE);
 
          // Create a temprary products buffer.
          // Its contents to be transfered to the products at the end of the loop
          G4DecayProducts* tempprods = 0;
 
          // Decide whether to apply branching ratio bias or not
          if (BRBias) {
            G4DecayTable* decayTable = GetDecayTable1(parentNucleus);
            ndecaych = G4int(decayTable->entries()*G4UniformRand());
            G4VDecayChannel* theDecayChannel = decayTable->GetDecayChannel(ndecaych);
 
            if (theDecayChannel == 0) {
              // Decay channel not found.
 
              if (GetVerboseLevel() > 0) {
                G4cout << " G4RadioactiveDecay::DoIt : cannot determine decay channel ";
                G4cout << " for this nucleus; decay as if no biasing active. ";
                G4cout << G4endl;
                decayTable ->DumpInfo();
              }
 
              tempprods = DoDecay(*parentNucleus);  // DHW 6 Dec 2010 - do decay as if no biasing
                                                    //           to avoid deref of temppprods = 0
            } else {
              // A decay channel has been identified, so execute the DecayIt.
              G4double tempmass = parentNucleus->GetPDGMass();
              tempprods = theDecayChannel->DecayIt(tempmass);
              weight *= (theDecayChannel->GetBR())*(decayTable->entries());
            }
          } else {
            tempprods = DoDecay(*parentNucleus);
          }
 
          // save the secondaries for buffers
          numberOfSecondaries = tempprods->entries();
          currentTime = finalGlobalTime + theDecayTime;
          for (index = 0; index < numberOfSecondaries; index++) {
            asecondaryparticle = tempprods->PopProducts();
            if (asecondaryparticle->GetDefinition()->GetPDGStable() ) {
              pw.push_back(weight);
              ptime.push_back(currentTime);
              secondaryparticles.push_back(asecondaryparticle);
            }
            // Generate gammas and Xrays from excited nucleus, added by L.Desorgher
            else if (((const G4Ions*)(asecondaryparticle->GetDefinition()))
                      ->GetExcitationEnergy() > 0. && weight > 0.) {  //Compute the gamma
              G4ParticleDefinition* apartDef = asecondaryparticle->GetDefinition();
              AddDeexcitationSpectrumForBiasMode(apartDef,weight,currentTime,pw,
                                                 ptime,secondaryparticles);
            }
          }
 
          delete tempprods;
        } // end of i loop
      } // end of n loop 
 
      // now deal with the secondaries in the two stl containers
      // and submmit them back to the tracking manager
      totalNumberOfSecondaries = pw.size();
      fParticleChangeForRadDecay.SetNumberOfSecondaries(totalNumberOfSecondaries);
      for (index=0; index < totalNumberOfSecondaries; index++) { 
        G4Track* secondary = new G4Track(secondaryparticles[index],
                                         ptime[index], currentPosition);
        secondary->SetGoodForTrackingFlag();       
        secondary->SetTouchableHandle(theTrack.GetTouchableHandle());
        secondary->SetWeight(pw[index]);       
        fParticleChangeForRadDecay.AddSecondary(secondary); 
      }
 
      // Kill the parent particle
      fParticleChangeForRadDecay.ProposeTrackStatus(fStopAndKill) ;
      fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(energyDeposit); 
      fParticleChangeForRadDecay.ProposeLocalTime(finalLocalTime);
      // Reset NumberOfInteractionLengthLeft.
      ClearNumberOfInteractionLengthLeft();
    } // end VR decay
 
    return &fParticleChangeForRadDecay;
  }  // end of data found branch 
} 

References AddDeexcitationSpectrumForBiasMode(), G4ParticleChangeForRadDecay::AddSecondary(), AnalogueMC, BRBias, CalculateChainsFromParent(), G4VProcess::ClearNumberOfInteractionLengthLeft(), ConvolveSourceTimeProfile(), DBin, G4RadioactiveDecay::DecayAnalog(), G4VDecayChannel::DecayIt(), decayWindows, G4RadioactiveDecay::DoDecay(), DProfile, G4DecayTable::DumpInfo(), G4DecayProducts::entries(), G4DecayTable::entries(), G4RadioactiveDecay::fParticleChangeForRadDecay, fStopAndKill, G4cout, G4endl, G4UniformRand, G4VDecayChannel::GetBR(), GetChainsFromParent(), G4DecayTable::GetDecayChannel(), GetDecayTable1(), GetDecayTime(), GetDecayTimeBin(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4IonTable::GetIon(), G4ParticleTable::GetIonTable(), G4Track::GetLocalTime(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGStable(), G4Track::GetPosition(), G4Track::GetTouchableHandle(), G4RadioactiveDecay::GetVerboseLevel(), G4Track::GetVolume(), G4Track::GetWeight(), G4ParticleChangeForDecay::Initialize(), G4RadioactiveDecay::isAllVolumesMode, G4RadioactiveDecay::IsApplicable(), IsRateTableReady(), CLHEP::detail::n, NSplit, G4DecayProducts::PopProducts(), G4VParticleChange::ProposeLocalEnergyDeposit(), G4ParticleChangeForDecay::ProposeLocalTime(), G4VParticleChange::ProposeTrackStatus(), G4VParticleChange::ProposeWeight(), s, G4Track::SetGoodForTrackingFlag(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetTouchableHandle(), G4Track::SetWeight(), theDecayRateVector, theRadioactivityTables, and G4RadioactiveDecay::ValidVolumes.

Referenced by AtRestDoIt(), and PostStepDoIt().

◆ DeselectAllVolumes()

void G4RadioactiveDecay::DeselectAllVolumes ( )

inherited

Definition at line 331 of file G4RadioactiveDecay.cc.

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

References G4cout, G4endl, G4RadioactiveDecay::GetVerboseLevel(), G4RadioactiveDecay::isAllVolumesMode, and G4RadioactiveDecay::ValidVolumes.

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

◆ DeselectAVolume()

void G4RadioactiveDecay::DeselectAVolume ( const G4String & aVolume )

inherited

Definition at line 272 of file G4RadioactiveDecay.cc.

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

References G4cout, G4endl, G4Exception(), G4LogicalVolumeStore::GetInstance(), G4RadioactiveDecay::GetVerboseLevel(), G4LogicalVolumeStore::GetVolume(), G4RadioactiveDecay::isAllVolumesMode, JustWarning, and G4RadioactiveDecay::ValidVolumes.

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

◆ DoDecay()

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

protectedinherited

Definition at line 1222 of file G4RadioactiveDecay.cc.

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

References G4RadioactiveDecay::CollimateDecay(), G4VDecayChannel::DecayIt(), FatalException, G4cout, G4endl, G4Exception(), G4RadioactiveDecay::GetDecayTable(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), G4RadioactiveDecay::GetVerboseLevel(), MeV, G4DecayTable::SelectADecayChannel(), and G4RadioactiveDecay::theRadDecayMode.

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

◆ DumpInfo()

void G4VProcess::DumpInfo ( ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4Cerenkov, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 167 of file G4VProcess.cc.

{
  G4cout << "Process Name " << theProcessName ;
  G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
  G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
}

References G4cout, G4endl, G4VProcess::GetProcessTypeName(), G4VProcess::theProcessName, G4VProcess::theProcessSubType, and G4VProcess::theProcessType.

Referenced by G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Scintillation::ProcessDescription(), G4Cerenkov::ProcessDescription(), and G4ProcessManagerMessenger::SetNewValue().

◆ EndTracking()

void G4VProcess::EndTracking ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, G4WrapperProcess, G4FastSimulationManagerProcess, G4VPhononProcess, G4CoupledTransportation, G4Decay, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 102 of file G4VProcess.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
  theNumberOfInteractionLengthLeft = -1.0;
  currentInteractionLength = -1.0;
  theInitialNumberOfInteractionLength=-1.0;
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4BiasingProcessInterface::EndTracking(), G4WrapperProcess::EndTracking(), G4VPhononProcess::EndTracking(), and G4AdjointProcessEquivalentToDirectProcess::EndTracking().

◆ GetChainsFromParent()

void G4Radioactivation::GetChainsFromParent ( const G4ParticleDefinition & aParticle )

Definition at line 173 of file G4Radioactivation.cc.

{
  // Retrieve the decay rate table for the specified aParticle
  G4String aParticleName = aParticle.GetParticleName();
 
  for (size_t i = 0; i < theParentChainTable.size(); i++) {
    if (theParentChainTable[i].GetIonName() == aParticleName) {
      theDecayRateVector = theParentChainTable[i].GetItsRates();
    }
  }
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 1) {
    G4cout << "The DecayRate Table for " << aParticleName << " is selected."
           <<  G4endl;
  }
#endif
}

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4RadioactiveDecay::GetVerboseLevel(), theDecayRateVector, and theParentChainTable.

Referenced by DecayIt().

◆ GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

Referenced by G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), and G4BOptrForceCollision::ProposeOccurenceBiasingOperation().

◆ GetDecayDirection()

const G4ThreeVector & G4RadioactiveDecay::GetDecayDirection ( ) const

inlineinherited

Definition at line 134 of file G4RadioactiveDecay.hh.

                                                          {
      return forceDecayDirection; 
    }

References G4RadioactiveDecay::forceDecayDirection.

◆ GetDecayHalfAngle()

G4double G4RadioactiveDecay::GetDecayHalfAngle ( ) const

inlineinherited

Definition at line 142 of file G4RadioactiveDecay.hh.

142{return forceDecayHalfAngle;}

References G4RadioactiveDecay::forceDecayHalfAngle.

◆ GetDecayTable()

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

inherited

Definition at line 230 of file G4RadioactiveDecay.cc.

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

References G4RadioactiveDecay::dkmap, G4ParticleDefinition::GetParticleName(), and G4RadioactiveDecay::LoadDecayTable().

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

◆ GetDecayTable1()

G4DecayTable * G4Radioactivation::GetDecayTable1 ( const G4ParticleDefinition * aNucleus )

Definition at line 144 of file G4Radioactivation.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;
}

References G4RadioactiveDecay::dkmap, G4ParticleDefinition::GetParticleName(), and G4RadioactiveDecay::LoadDecayTable().

Referenced by CalculateChainsFromParent(), and DecayIt().

◆ GetDecayTime()

G4double G4Radioactivation::GetDecayTime ( )

protected

Definition at line 260 of file G4Radioactivation.cc.

{
  G4double decaytime = 0.;
  G4double rand = G4UniformRand();
  G4int i = 0;
 
  G4int loop = 0;
  while (DProfile[i] < rand) {  /* Loop checking, 01.09.2015, D.Wright */
    // Entries in DProfile[i] are all between 0 and 1 and arranged in inreaseing order
    // Comparison with rand chooses which time bin to sample  
    i++;
    loop++;
    if (loop > 100000) {
      G4Exception("G4Radioactivation::GetDecayTime()", "HAD_RDM_100",
                  JustWarning, "While loop count exceeded");
      break;
    }
  }
 
  rand = G4UniformRand();
  decaytime = DBin[i] + rand*(DBin[i+1]-DBin[i]);
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2)
    G4cout <<" Decay time: " <<decaytime/s <<"[s]" <<G4endl;
#endif
  return  decaytime;        
}

References DBin, DProfile, G4cout, G4endl, G4Exception(), G4UniformRand, G4RadioactiveDecay::GetVerboseLevel(), JustWarning, and s.

Referenced by DecayIt().

◆ GetDecayTimeBin()

G4int G4Radioactivation::GetDecayTimeBin ( const G4double aDecayTime )

protected

Definition at line 289 of file G4Radioactivation.cc.

{
  G4int i = 0;
 
  G4int loop = 0;
  while (aDecayTime > DBin[i] ) {   /* Loop checking, 01.09.2015, D.Wright */
    i++;
    loop++;
    if (loop > 100000) {
      G4Exception("G4Radioactivation::GetDecayTimeBin()", "HAD_RDM_100", 
                  JustWarning, "While loop count exceeded");
      break;
    }
  }
 
  return  i;
}

References DBin, G4Exception(), and JustWarning.

Referenced by DecayIt().

◆ GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

Referenced by G4PolarizedCompton::BuildPhysicsTable(), G4PolarizedIonisation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

◆ GetMeanFreePath()

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

protectedvirtualinherited

Implements G4VRestDiscreteProcess.

Definition at line 383 of file G4RadioactiveDecay.cc.

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

References source.hepunit::c_light, DBL_MAX, DBL_MIN, G4cout, G4endl, G4Exception(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMass(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGLifeTime(), G4DynamicParticle::GetTotalMomentum(), G4RadioactiveDecay::GetVerboseLevel(), GeV, JustWarning, keV, and m.

◆ GetMeanLifeTime()

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

protectedvirtual

Implements G4VRestDiscreteProcess.

Definition at line 313 of file G4Radioactivation.cc.

{
  // For variance reduction time is set to 0 so as to force the particle
  // to decay immediately.
  // In analogue mode it returns the particle's mean-life.
  G4double meanlife = 0.;
  if (AnalogueMC) meanlife = G4RadioactiveDecay::GetMeanLifeTime(theTrack, 0); 
  return meanlife;
}

References AnalogueMC, and G4RadioactiveDecay::GetMeanLifeTime().

◆ GetNucleusLimits()

G4NucleusLimits G4RadioactiveDecay::GetNucleusLimits ( ) const

inlineinherited

Definition at line 128 of file G4RadioactiveDecay.hh.

128{return theNucleusLimits;}

G4RadioactiveDecay::theNucleusLimits

G4NucleusLimits theNucleusLimits

Definition: G4RadioactiveDecay.hh:204

References G4RadioactiveDecay::theNucleusLimits.

◆ GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

◆ GetPhysicsTableFileName()

const G4String & G4VProcess::GetPhysicsTableFileName	(	const G4ParticleDefinition *	particle,
		const G4String &	directory,
		const G4String &	tableName,
		G4bool	ascii = `false`
	)

inherited

Definition at line 181 of file G4VProcess.cc.

{
  G4String thePhysicsTableFileExt;
  if (ascii) thePhysicsTableFileExt = ".asc";
  else       thePhysicsTableFileExt = ".dat";
 
  thePhysicsTableFileName = directory + "/";
  thePhysicsTableFileName += tableName + "." +  theProcessName + ".";
  thePhysicsTableFileName += particle->GetParticleName()
                           + thePhysicsTableFileExt;
  
  return thePhysicsTableFileName;
}

References G4ParticleDefinition::GetParticleName(), G4VProcess::thePhysicsTableFileName, and G4VProcess::theProcessName.

Referenced by export_G4VProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

◆ GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  return thePILfactor;
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

{
  return aProcessManager; 
}

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

◆ GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const

inlineinherited

Definition at line 382 of file G4VProcess.hh.

{
  return theProcessName;
}

References G4VProcess::theProcessName.

◆ GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by G4GammaGeneralProcess::AddEmProcess(), G4DNABrownianTransportation::BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), G4GammaGeneralProcess::GetSubProcessSubType(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

◆ GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const

inlineinherited

Definition at line 388 of file G4VProcess.hh.

{
  return theProcessType;
}

References G4VProcess::theProcessType.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4SteppingManager::DefinePhysicalStepLength(), export_G4VProcess(), G4ProcessTable::Find(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and G4ChannelingOptrChangeCrossSection::StartRun().

◆ GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType aType )

staticinherited

Definition at line 134 of file G4VProcess.cc.

{
  switch (aType)
  {
    case fNotDefined:         return typeNotDefined; break;
    case fTransportation:     return typeTransportation; break;
    case fElectromagnetic:    return typeElectromagnetic; break;
    case fOptical:            return typeOptical; break;
    case fHadronic:           return typeHadronic; break;
    case fPhotolepton_hadron: return typePhotolepton_hadron; break;
    case fDecay:              return typeDecay; break;
    case fGeneral:            return typeGeneral; break;
    case fParameterisation:   return typeParameterisation; break;
    case fUserDefined:        return typeUserDefined; break;
    case fPhonon:             return typePhonon; break;
    default: ;
  }
  return noType;  
}

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

◆ GetSplitNuclei()

G4int G4Radioactivation::GetSplitNuclei ( )

inline

Definition at line 128 of file G4Radioactivation.hh.

128{return NSplit;}

References NSplit.

◆ GetTheRadioactivityTables()

std::vector< G4RadioactivityTable * > G4Radioactivation::GetTheRadioactivityTables ( )

inline

Definition at line 98 of file G4Radioactivation.hh.

99 {return theRadioactivityTables;}

References theRadioactivityTables.

◆ GetThresholdForVeryLongDecayTime()

G4double G4RadioactiveDecay::GetThresholdForVeryLongDecayTime ( ) const

inlineinherited

Definition at line 156 of file G4RadioactiveDecay.hh.

156{return fThresholdForVeryLongDecayTime;}

References G4RadioactiveDecay::fThresholdForVeryLongDecayTime.

◆ GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const

inlineinherited

Definition at line 437 of file G4VProcess.hh.

{
  return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4HadronicProcess::XBiasSecondaryWeight(), and G4HadronicProcess::XBiasSurvivalProbability().

◆ GetVerboseLevel()

G4int G4RadioactiveDecay::GetVerboseLevel ( ) const

inlineinherited

Definition at line 118 of file G4RadioactiveDecay.hh.

118{return verboseLevel;}

G4RadioactiveDecay::verboseLevel

G4int verboseLevel

Definition: G4RadioactiveDecay.hh:233

References G4RadioactiveDecay::verboseLevel.

◆ isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 506 of file G4VProcess.hh.

{
  return enableAlongStepDoIt;
}

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsAnalogueMonteCarlo()

G4bool G4Radioactivation::IsAnalogueMonteCarlo ( )

inline

Definition at line 113 of file G4Radioactivation.hh.

113{return AnalogueMC;}

References AnalogueMC.

◆ IsApplicable()

G4bool G4RadioactiveDecay::IsApplicable ( const G4ParticleDefinition & aParticle )

virtualinherited

Reimplemented from G4VProcess.

Definition at line 208 of file G4RadioactiveDecay.cc.

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

References A, G4NucleusLimits::GetAMax(), G4NucleusLimits::GetAMin(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetPDGLifeTime(), G4NucleusLimits::GetZMax(), G4NucleusLimits::GetZMin(), G4RadioactiveDecay::theNucleusLimits, and Z.

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

◆ isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsRateTableReady()

G4bool G4Radioactivation::IsRateTableReady ( const G4ParticleDefinition & aParticle )

Definition at line 160 of file G4Radioactivation.cc.

{
  // Check whether the radioactive decay rates table for the ion has already
  // been calculated.
  G4String aParticleName = aParticle.GetParticleName();
  for (size_t i = 0; i < theParentChainTable.size(); i++) {
    if (theParentChainTable[i].GetIonName() == aParticleName) return true;
  }
  return false;
}

References G4ParticleDefinition::GetParticleName(), and theParentChainTable.

Referenced by DecayIt().

◆ LoadDecayTable()

G4DecayTable * G4RadioactiveDecay::LoadDecayTable ( const G4ParticleDefinition & theParentNucleus )

inherited

Definition at line 517 of file G4RadioactiveDecay.cc.

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

References A, allowed, Alpha, G4RadioactiveDecay::applyARM, BDNeutron, BDProton, Beta2Minus, Beta2Plus, BetaMinus, BetaPlus, G4RadioactiveDecay::dirPath, G4DecayTable::DumpInfo(), G4DecayTable::entries(), FatalException, geant4_check_module_cycles::file, G4Ions::FloatLevelBase(), G4Exception(), G4RadioactiveDecayModeSize, G4VDecayChannel::GetBR(), G4DecayTable::GetDecayChannel(), G4NuclearDecay::GetDecayMode(), G4ParticleDefinition::GetParticleName(), G4RadioactiveDecay::GetVerboseLevel(), G4DecayTable::Insert(), IT, JustWarning, keV, KshellEC, G4RadioactiveDecay::levelTolerance, LshellEC, MeV, MshellEC, Neutron, Neutron2, noFloat, NshellEC, G4RadioactiveDecay::photonEvaporation, Proton, Proton2, RDM_ERROR, G4StrUtil::rstrip(), G4ECDecay::SetARM(), G4ITDecay::SetARM(), G4VDecayChannel::SetBR(), SpFission, G4RadioactiveDecay::theUserRadioactiveDataFiles, Triton, and Z.

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

◆ operator!=()

G4bool G4VProcess::operator!= ( const G4VProcess & right ) const

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

◆ operator==()

G4bool G4VProcess::operator== ( const G4VProcess & right ) const

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

◆ PostStepDoIt()

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

inlineprivatevirtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 181 of file G4Radioactivation.hh.

182 {return DecayIt(theTrack, theStep);}

References DecayIt().

◆ PostStepGetPhysicalInteractionLength()

G4double G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

virtualinherited

Implements G4VProcess.

Reimplemented in G4MuonicAtomDecay, and G4Decay.

Definition at line 71 of file G4VRestDiscreteProcess.cc.

{
  if ( (previousStepSize < 0.0) || (theNumberOfInteractionLengthLeft<=0.0))
  {
    // beginning of tracking (or just after DoIt() of this process)
    ResetNumberOfInteractionLengthLeft();
  }
  else if ( previousStepSize > 0.0)
  {
    // subtract NumberOfInteractionLengthLeft 
    SubtractNumberOfInteractionLengthLeft(previousStepSize);
  }
  else
  {
    // zero step
    // DO NOTHING
  }
 
  // condition is set to "Not Forced"
  *condition = NotForced;
 
  // get mean free path
  currentInteractionLength = GetMeanFreePath(track,previousStepSize,condition);
 
  G4double value;
  if (currentInteractionLength < DBL_MAX)
  {
    value = theNumberOfInteractionLengthLeft * currentInteractionLength;
  }
  else
  {
    value = DBL_MAX;
  }
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << "G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength() - ";
    G4cout << "[ " << GetProcessName() << "]" << G4endl;
    track.GetDynamicParticle()->DumpInfo();
    G4cout << " in Material  " <<  track.GetMaterial()->GetName() << G4endl;
    G4cout << "InteractionLength= " << value/cm <<"[cm] " << G4endl;
  }
#endif
  return value;
}

References cm, condition(), G4VProcess::currentInteractionLength, DBL_MAX, G4DynamicParticle::DumpInfo(), G4cout, G4endl, G4Track::GetDynamicParticle(), G4Track::GetMaterial(), G4VRestDiscreteProcess::GetMeanFreePath(), G4Material::GetName(), G4VProcess::GetProcessName(), NotForced, G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::SubtractNumberOfInteractionLengthLeft(), G4VProcess::theNumberOfInteractionLengthLeft, and G4VProcess::verboseLevel.

◆ PostStepGPIL()

G4double G4VProcess::PostStepGPIL	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

inlineinherited

Definition at line 479 of file G4VProcess.hh.

{
  return thePILfactor *
      PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
}

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ PreparePhysicsTable()

virtual void G4VProcess::PreparePhysicsTable ( const G4ParticleDefinition & )

inlinevirtualinherited

◆ PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

{
  PreparePhysicsTable(part);
}

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

◆ ProcessDescription()

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

virtual

Reimplemented from G4RadioactiveDecay.

Definition at line 127 of file G4Radioactivation.cc.

{
  outFile << "The G4Radioactivation process performs radioactive decay of\n"
          << "nuclides (G4GenericIon) in biased mode which includes nucleus\n"
          << "duplication, branching ratio biasing, source time convolution\n"
          << "and detector time convolution.  It is designed for use in\n"
          << "activation physics.\n"
          << "The required half-lives and decay schemes are retrieved from\n"
          << "the RadioactiveDecay database which was derived from ENSDF.\n";
}

◆ ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4VITProcess, G4WrapperProcess, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 80 of file G4VProcess.cc.

{
  theNumberOfInteractionLengthLeft =  -1.*G4Log( G4UniformRand() );
  theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
}

References G4Log(), G4UniformRand, G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

◆ RetrievePhysicsTable()

virtual G4bool G4VProcess::RetrievePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	,
		G4bool
	)

inlinevirtualinherited

Reimplemented in G4GammaGeneralProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4WrapperProcess, G4AdjointProcessEquivalentToDirectProcess, and G4BiasingProcessInterface.

Definition at line 211 of file G4VProcess.hh.

212 { return false; }

Referenced by export_G4VProcess(), G4WrapperProcess::RetrievePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::RetrievePhysicsTable(), and G4BiasingProcessInterface::RetrievePhysicsTable().

◆ SelectAllVolumes()

void G4RadioactiveDecay::SelectAllVolumes ( )

inherited

Definition at line 308 of file G4RadioactiveDecay.cc.

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

References G4cout, G4endl, G4LogicalVolumeStore::GetInstance(), G4LogicalVolume::GetName(), G4RadioactiveDecay::GetVerboseLevel(), G4RadioactiveDecay::isAllVolumesMode, and G4RadioactiveDecay::ValidVolumes.

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

◆ SelectAVolume()

void G4RadioactiveDecay::SelectAVolume ( const G4String & aVolume )

inherited

Definition at line 246 of file G4RadioactiveDecay.cc.

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

References G4cout, G4endl, G4Exception(), G4LogicalVolumeStore::GetInstance(), G4RadioactiveDecay::GetVerboseLevel(), G4LogicalVolumeStore::GetVolume(), JustWarning, and G4RadioactiveDecay::ValidVolumes.

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

◆ SetAnalogueMonteCarlo()

void G4Radioactivation::SetAnalogueMonteCarlo ( G4bool r )

inline

Definition at line 106 of file G4Radioactivation.hh.

                                                  {
      AnalogueMC = r;
      if (!AnalogueMC) halflifethreshold = 1e-6*CLHEP::s;
    }

References AnalogueMC, halflifethreshold, and CLHEP::s.

◆ SetARM()

void G4RadioactiveDecay::SetARM ( G4bool arm )

inlineinherited

Definition at line 106 of file G4RadioactiveDecay.hh.

106{applyARM = arm;}

References G4RadioactiveDecay::applyARM.

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

◆ SetBRBias()

void G4Radioactivation::SetBRBias ( G4bool r )

inline

Definition at line 116 of file G4Radioactivation.hh.

                                    {
      BRBias = r;
      AnalogueMC = false;
    }

References AnalogueMC, and BRBias.

◆ SetDecayBias()

void G4Radioactivation::SetDecayBias ( G4String filename )

Definition at line 751 of file G4Radioactivation.cc.

{
  std::ifstream infile(filename, std::ios::in);
  if (!infile) G4Exception("G4Radioactivation::SetDecayBias()", "HAD_RDM_001",
                           FatalException, "Unable to open bias data file" );
 
  G4double bin, flux;
  G4int dWindows = 0;
  G4int i ;
 
  theRadioactivityTables.clear();
 
  NDecayBin = -1;
 
  G4int loop = 0;
  while (infile >> bin >> flux ) {  /* Loop checking, 01.09.2015, D.Wright */
    NDecayBin++;
    loop++;
    if (loop > 10000) {
      G4Exception("G4Radioactivation::SetDecayBias()", "HAD_RDM_100",
                  JustWarning, "While loop count exceeded");
      break;
    }
 
    if (NDecayBin > 99) {
      G4Exception("G4Radioactivation::SetDecayBias()", "HAD_RDM_002",
                  FatalException, "Input bias file too big (>100 rows)" );
    } else {
      DBin[NDecayBin] = bin * s;     // Convert read-in time to ns
      DProfile[NDecayBin] = flux;    // Dimensionless
      if (flux > 0.) {
        decayWindows[NDecayBin] = dWindows;
        dWindows++;
        G4RadioactivityTable *rTable = new G4RadioactivityTable() ;
        theRadioactivityTables.push_back(rTable);
      }
    }
  }
  for ( i = 1; i<= NDecayBin; i++) DProfile[i] += DProfile[i-1];  // Cumulative flux vs i 
  for ( i = 0; i<= NDecayBin; i++) DProfile[i] /= DProfile[NDecayBin];
                             // Normalize so entries increase from 0 to 1
  // converted to accumulated probabilities
 
  AnalogueMC = false;
  infile.close();
 
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2)
    G4cout <<" Decay Bias Profile  Nbin = " << NDecayBin <<G4endl;
#endif
}

References AnalogueMC, DBin, decayWindows, DProfile, FatalException, G4cout, G4endl, G4Exception(), G4RadioactiveDecay::GetVerboseLevel(), JustWarning, NDecayBin, s, and theRadioactivityTables.

◆ SetDecayCollimation()

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

inlineinherited

Definition at line 146 of file G4RadioactiveDecay.hh.

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

References G4RadioactiveDecay::SetDecayDirection(), and G4RadioactiveDecay::SetDecayHalfAngle().

◆ SetDecayDirection()

void G4RadioactiveDecay::SetDecayDirection ( const G4ThreeVector & theDir )

inlineinherited

Definition at line 130 of file G4RadioactiveDecay.hh.

                                                               {
      forceDecayDirection = theDir.unit();
    }

References G4RadioactiveDecay::forceDecayDirection, and CLHEP::Hep3Vector::unit().

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

◆ SetDecayHalfAngle()

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

inlineinherited

Definition at line 138 of file G4RadioactiveDecay.hh.

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

References CLHEP::deg, G4RadioactiveDecay::forceDecayHalfAngle, G4INCL::Math::max(), and G4INCL::Math::min().

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

◆ SetDecayRate()

void G4Radioactivation::SetDecayRate	(	G4int	theZ,
		G4int	theA,
		G4double	theE,
		G4int	theG,
		std::vector< G4double >	theCoefficients,
		std::vector< G4double >	theTaos
	)

Definition at line 326 of file G4Radioactivation.cc.

{ 
  //fill the decay rate vector 
  ratesToDaughter.SetZ(theZ);
  ratesToDaughter.SetA(theA);
  ratesToDaughter.SetE(theE);
  ratesToDaughter.SetGeneration(theG);
  ratesToDaughter.SetDecayRateC(theCoefficients);
  ratesToDaughter.SetTaos(theTaos);
}

References ratesToDaughter, G4RadioactiveDecayRatesToDaughter::SetA(), G4RadioactiveDecayRatesToDaughter::SetDecayRateC(), G4RadioactiveDecayRatesToDaughter::SetE(), G4RadioactiveDecayRatesToDaughter::SetGeneration(), G4RadioactiveDecayRatesToDaughter::SetTaos(), and G4RadioactiveDecayRatesToDaughter::SetZ().

Referenced by CalculateChainsFromParent().

◆ SetHLThreshold()

void G4Radioactivation::SetHLThreshold ( G4double hl )

inline

Definition at line 71 of file G4Radioactivation.hh.

71{halflifethreshold = hl;}

References halflifethreshold.

◆ SetICM()

void G4RadioactiveDecay::SetICM ( G4bool icm )

inlineinherited

Definition at line 103 of file G4RadioactiveDecay.hh.

103{applyICM = icm;}

G4RadioactiveDecay::applyICM

G4bool applyICM

Definition: G4RadioactiveDecay.hh:208

References G4RadioactiveDecay::applyICM.

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

◆ SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess * masterP )

virtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 212 of file G4VProcess.cc.

{
  masterProcessShadow = masterP;
}

References G4VProcess::masterProcessShadow.

Referenced by G4BiasingProcessInterface::SetMasterProcess(), and G4WrapperProcess::SetMasterProcess().

◆ SetNucleusLimits()

void G4RadioactiveDecay::SetNucleusLimits ( G4NucleusLimits theNucleusLimits1 )

inlineinherited

Definition at line 121 of file G4RadioactiveDecay.hh.

122 {theNucleusLimits = theNucleusLimits1 ;}

References G4RadioactiveDecay::theNucleusLimits.

◆ SetPILfactor()

void G4VProcess::SetPILfactor ( G4double value )

inlineinherited

Definition at line 449 of file G4VProcess.hh.

{
  if (value>0.) { thePILfactor = value; }
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager * procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

Referenced by G4ProcessManager::AddProcess(), G4BiasingProcessInterface::SetProcessManager(), and G4WrapperProcess::SetProcessManager().

◆ SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin::G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation::G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung::G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

◆ SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

◆ SetSourceTimeProfile()

void G4Radioactivation::SetSourceTimeProfile ( G4String filename )

Definition at line 702 of file G4Radioactivation.cc.

{
  std::ifstream infile ( filename, std::ios::in );
  if (!infile) {
    G4ExceptionDescription ed;
    ed << " Could not open file " << filename << G4endl; 
    G4Exception("G4Radioactivation::SetSourceTimeProfile()", "HAD_RDM_001",
                FatalException, ed);
  }
 
  G4double bin, flux;
  NSourceBin = -1;
 
  G4int loop = 0;
  while (infile >> bin >> flux) {  /* Loop checking, 01.09.2015, D.Wright */
    loop++;
    if (loop > 10000) {
      G4Exception("G4Radioactivation::SetSourceTimeProfile()", "HAD_RDM_100",
                  JustWarning, "While loop count exceeded");
      break;
    }
 
    NSourceBin++;
    if (NSourceBin > 99) {
      G4Exception("G4Radioactivation::SetSourceTimeProfile()", "HAD_RDM_002",
                  FatalException, "Input source time file too big (>100 rows)");
 
    } else {
      SBin[NSourceBin] = bin * s;    // Convert read-in time to ns
      SProfile[NSourceBin] = flux;   // Dimensionless
    }
  }
 
  AnalogueMC = false;
  infile.close();
 
#ifdef G4VERBOSE
  if (GetVerboseLevel() > 2)
    G4cout <<" Source Timeprofile Nbin = " << NSourceBin <<G4endl;
#endif
}

References AnalogueMC, FatalException, G4cout, G4endl, G4Exception(), G4RadioactiveDecay::GetVerboseLevel(), JustWarning, NSourceBin, s, SBin, and SProfile.

◆ SetSplitNuclei()

void G4Radioactivation::SetSplitNuclei ( G4int r )

inline

Definition at line 122 of file G4Radioactivation.hh.

                                        {
      NSplit = r;
      AnalogueMC = false;
    }

References AnalogueMC, and NSplit.

◆ SetThresholdForVeryLongDecayTime()

void G4RadioactiveDecay::SetThresholdForVeryLongDecayTime ( const G4double inputThreshold )

inlineinherited

Definition at line 153 of file G4RadioactiveDecay.hh.

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

References G4RadioactiveDecay::fThresholdForVeryLongDecayTime, and G4INCL::Math::max().

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

◆ SetVerboseLevel()

void G4RadioactiveDecay::SetVerboseLevel ( G4int value )

inlineinherited

Definition at line 115 of file G4RadioactiveDecay.hh.

115{verboseLevel = value;}

References G4RadioactiveDecay::verboseLevel.

Referenced by G4RadioactiveDecayMessenger::SetNewValue().

◆ StartTracking()

void G4VProcess::StartTracking ( G4Track * )

virtualinherited

Reimplemented in G4ParallelGeometriesLimiterProcess, G4ImportanceProcess, G4WeightCutOffProcess, G4WeightWindowProcess, G4VITProcess, G4DNASecondOrderReaction, G4WrapperProcess, G4FastSimulationManagerProcess, G4ParallelWorldProcess, G4ParallelWorldScoringProcess, G4ScoreSplittingProcess, G4GammaGeneralProcess, G4Decay, G4AdjointProcessEquivalentToDirectProcess, G4eAdjointMultipleScattering, G4DNAElectronHoleRecombination, G4DNAScavengerProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4ITTransportation, G4DNABrownianTransportation, G4CoupledTransportation, G4Transportation, G4BiasingProcessInterface, and G4VPhononProcess.

Definition at line 87 of file G4VProcess.cc.

{
  currentInteractionLength = -1.0;
  theNumberOfInteractionLengthLeft = -1.0;
  theInitialNumberOfInteractionLength = -1.0;
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::StartTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4DNASecondOrderReaction::StartTracking(), G4WrapperProcess::StartTracking(), G4AdjointProcessEquivalentToDirectProcess::StartTracking(), G4DNAElectronHoleRecombination::StartTracking(), G4DNAScavengerProcess::StartTracking(), G4ITTransportation::StartTracking(), G4Transportation::StartTracking(), G4BiasingProcessInterface::StartTracking(), and G4VPhononProcess::StartTracking().

◆ StorePhysicsTable()

virtual G4bool G4VProcess::StorePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	,
		G4bool
	)

inlinevirtualinherited

Reimplemented in G4WrapperProcess, G4GammaGeneralProcess, G4AdjointProcessEquivalentToDirectProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, and G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.hh.

207 { return true; }

Referenced by export_G4VProcess(), G4WrapperProcess::StorePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::StorePhysicsTable(), and G4BiasingProcessInterface::StorePhysicsTable().

◆ StreamInfo()

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

privateinherited

Definition at line 468 of file G4RadioactiveDecay.cc.

{
  G4DeexPrecoParameters* deex =
    G4NuclearLevelData::GetInstance()->GetParameters();
  G4EmParameters* emparam = G4EmParameters::Instance();
 
  G4int prec = os.precision(5);
  os << "======================================================================"
     << endline;
  os << "======          Radioactive Decay Physics Parameters           ======="
     << endline;
  os << "======================================================================"
     << endline;
  os << "Max life time                                     "
     << deex->GetMaxLifeTime()/CLHEP::ps << " ps" << endline;
  os << "Internal e- conversion flag                       "
     << deex->GetInternalConversionFlag() << endline;
  os << "Stored internal conversion coefficients           "
     << deex->StoreICLevelData() << endline;
  os << "Enable correlated gamma emission                  "
     << deex->CorrelatedGamma() << endline;
  os << "Max 2J for sampling of angular correlations       "
     << deex->GetTwoJMAX() << endline;
  os << "Atomic de-excitation enabled                      "
     << emparam->Fluo() << endline;
  os << "Auger electron emission enabled                   "
     << emparam->Auger() << endline;
  os << "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        "
     << fThresholdForVeryLongDecayTime/CLHEP::ns << "  ns" << endline;
  os << "======================================================================"
     << G4endl;
  os.precision(prec);
}

References G4EmParameters::ANSTOFluoDir(), G4EmParameters::Auger(), G4EmParameters::BeardenFluoDir(), G4DeexPrecoParameters::CorrelatedGamma(), G4EmParameters::DeexcitationIgnoreCut(), G4EmParameters::Fluo(), G4RadioactiveDecay::fThresholdForVeryLongDecayTime, G4endl, G4NuclearLevelData::GetInstance(), G4DeexPrecoParameters::GetInternalConversionFlag(), G4DeexPrecoParameters::GetMaxLifeTime(), G4NuclearLevelData::GetParameters(), G4DeexPrecoParameters::GetTwoJMAX(), G4EmParameters::Instance(), CLHEP::ns, CLHEP::prec, CLHEP::ps, and G4DeexPrecoParameters::StoreICLevelData().

Referenced by G4RadioactiveDecay::BuildPhysicsTable().

◆ SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double prevStepSize )

inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

{
  if (currentInteractionLength>0.0)
  {
    theNumberOfInteractionLengthLeft -= prevStepSize/currentInteractionLength;
    if(theNumberOfInteractionLengthLeft<0.)
    {
       theNumberOfInteractionLengthLeft=CLHEP::perMillion;
    }
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
      G4cerr << " [" << theProcessName << "]" <<G4endl;
      G4cerr << " currentInteractionLength = "
             << currentInteractionLength << " [mm]";
      G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
      G4cerr << G4endl;
    }
#endif
    G4String msg = "Negative currentInteractionLength for ";
    msg += theProcessName;
    G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
                "ProcMan201", EventMustBeAborted, msg);
  }
}

References G4VProcess::currentInteractionLength, EventMustBeAborted, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4Decay::PostStepGetPhysicalInteractionLength().

Field Documentation

◆ AnalogueMC

G4bool G4Radioactivation::AnalogueMC

private

Definition at line 154 of file G4Radioactivation.hh.

Referenced by DecayIt(), G4Radioactivation(), GetMeanLifeTime(), IsAnalogueMonteCarlo(), SetAnalogueMonteCarlo(), SetBRBias(), SetDecayBias(), SetSourceTimeProfile(), and SetSplitNuclei().

◆ aParticleChange

G4ParticleChange G4VProcess::aParticleChange

protectedinherited

Definition at line 327 of file G4VProcess.hh.

◆ applyARM

G4bool G4RadioactiveDecay::applyARM

privateinherited

Definition at line 209 of file G4RadioactiveDecay.hh.

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

◆ applyICM

G4bool G4RadioactiveDecay::applyICM

privateinherited

Definition at line 208 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::G4RadioactiveDecay(), and G4RadioactiveDecay::SetICM().

◆ aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr

protectedinherited

Definition at line 319 of file G4VProcess.hh.

Referenced by G4VProcess::GetProcessManager(), and G4VProcess::SetProcessManager().

◆ BRBias

G4bool G4Radioactivation::BRBias

private

Definition at line 155 of file G4Radioactivation.hh.

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

◆ chainsFromParent

G4RadioactiveDecayChainsFromParent G4Radioactivation::chainsFromParent

private

Definition at line 169 of file G4Radioactivation.hh.

Referenced by CalculateChainsFromParent().

◆ currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

◆ DBin

G4double G4Radioactivation::DBin[100]

private

Definition at line 164 of file G4Radioactivation.hh.

Referenced by DecayIt(), G4Radioactivation(), GetDecayTime(), GetDecayTimeBin(), and SetDecayBias().

◆ decayWindows

G4int G4Radioactivation::decayWindows[100]

private

Definition at line 174 of file G4Radioactivation.hh.

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

◆ dirPath

G4String G4RadioactiveDecay::dirPath

privateinherited

Definition at line 217 of file G4RadioactiveDecay.hh.

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

◆ dkmap

DecayTableMap* G4RadioactiveDecay::dkmap

protectedinherited

Definition at line 192 of file G4RadioactiveDecay.hh.

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

◆ DProfile

G4double G4Radioactivation::DProfile[100]

private

Definition at line 165 of file G4Radioactivation.hh.

Referenced by DecayIt(), G4Radioactivation(), GetDecayTime(), and SetDecayBias().

◆ enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true

protectedinherited

Definition at line 360 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ITTransportation::G4ITTransportation(), G4NuclearStopping::G4NuclearStopping(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), G4VITRestDiscreteProcess::G4VITRestDiscreteProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestDiscreteProcess::G4VRestDiscreteProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isAlongStepDoItIsEnabled().

◆ enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true

protectedinherited

Definition at line 359 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4eplusAnnihilation::G4eplusAnnihilation(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VContinuousDiscreteProcess::G4VContinuousDiscreteProcess(), G4VContinuousProcess::G4VContinuousProcess(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), and G4VProcess::isAtRestDoItIsEnabled().

◆ enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true

protectedinherited

Definition at line 361 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4NuclearStopping::G4NuclearStopping(), G4VContinuousProcess::G4VContinuousProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestContinuousProcess::G4VRestContinuousProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isPostStepDoItIsEnabled().

◆ forceDecayDirection

G4ThreeVector G4RadioactiveDecay::forceDecayDirection

privateinherited

Definition at line 212 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::ChooseCollimationDirection(), G4RadioactiveDecay::CollimateDecay(), G4RadioactiveDecay::GetDecayDirection(), and G4RadioactiveDecay::SetDecayDirection().

◆ forceDecayHalfAngle

G4double G4RadioactiveDecay::forceDecayHalfAngle

privateinherited

Definition at line 213 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::ChooseCollimationDirection(), G4RadioactiveDecay::CollimateDecay(), G4RadioactiveDecay::GetDecayHalfAngle(), and G4RadioactiveDecay::SetDecayHalfAngle().

◆ fParticleChangeForRadDecay

G4ParticleChangeForRadDecay G4RadioactiveDecay::fParticleChangeForRadDecay

protectedinherited

Definition at line 181 of file G4RadioactiveDecay.hh.

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

◆ fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

Referenced by G4VProcess::G4VProcess(), and G4VProcess::~G4VProcess().

◆ fRemainderLifeTime

G4double G4RadioactiveDecay::fRemainderLifeTime

privateinherited

Definition at line 232 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::AtRestGetPhysicalInteractionLength().

◆ fThresholdForVeryLongDecayTime

G4double G4RadioactiveDecay::fThresholdForVeryLongDecayTime

privateinherited

Definition at line 236 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::DecayAnalog(), G4RadioactiveDecay::GetThresholdForVeryLongDecayTime(), G4RadioactiveDecay::SetThresholdForVeryLongDecayTime(), and G4RadioactiveDecay::StreamInfo().

◆ halflifethreshold

G4double G4Radioactivation::halflifethreshold

private

Definition at line 158 of file G4Radioactivation.hh.

Referenced by CalculateChainsFromParent(), G4Radioactivation(), SetAnalogueMonteCarlo(), and SetHLThreshold().

◆ isAllVolumesMode

bool G4RadioactiveDecay::isAllVolumesMode

protectedinherited

Definition at line 187 of file G4RadioactiveDecay.hh.

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

◆ isInitialised

G4bool G4RadioactiveDecay::isInitialised

privateinherited

Definition at line 206 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::BuildPhysicsTable().

◆ levelTolerance

const G4double G4RadioactiveDecay::levelTolerance = 10.0*eV

staticprotectedinherited

Definition at line 189 of file G4RadioactiveDecay.hh.

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

◆ masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr

privateinherited

Definition at line 370 of file G4VProcess.hh.

Referenced by G4VProcess::GetMasterProcess(), and G4VProcess::SetMasterProcess().

◆ NDecayBin

G4int G4Radioactivation::NDecayBin

private

Definition at line 163 of file G4Radioactivation.hh.

Referenced by G4Radioactivation(), and SetDecayBias().

◆ NSourceBin

G4int G4Radioactivation::NSourceBin

private

Definition at line 160 of file G4Radioactivation.hh.

Referenced by ConvolveSourceTimeProfile(), G4Radioactivation(), and SetSourceTimeProfile().

◆ NSplit

G4int G4Radioactivation::NSplit

private

Definition at line 156 of file G4Radioactivation.hh.

Referenced by DecayIt(), G4Radioactivation(), GetSplitNuclei(), and SetSplitNuclei().

◆ origin

const G4ThreeVector G4RadioactiveDecay::origin

staticprivateinherited

Definition at line 214 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::ChooseCollimationDirection(), G4RadioactiveDecay::CollimateDecay(), and G4RadioactiveDecay::CollimateDecayProduct().

◆ photonEvaporation

G4PhotonEvaporation* G4RadioactiveDecay::photonEvaporation

protectedinherited

Definition at line 184 of file G4RadioactiveDecay.hh.

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

◆ pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

◆ ratesToDaughter

G4RadioactiveDecayRatesToDaughter G4Radioactivation::ratesToDaughter

private

Definition at line 167 of file G4Radioactivation.hh.

Referenced by CalculateChainsFromParent(), and SetDecayRate().

◆ SBin

G4double G4Radioactivation::SBin[100]

private

Definition at line 161 of file G4Radioactivation.hh.

Referenced by ConvolveSourceTimeProfile(), G4Radioactivation(), and SetSourceTimeProfile().

◆ SProfile

G4double G4Radioactivation::SProfile[100]

private

Definition at line 162 of file G4Radioactivation.hh.

Referenced by ConvolveSourceTimeProfile(), G4Radioactivation(), and SetSourceTimeProfile().

◆ theDecayRateVector

G4RadioactiveDecayRates G4Radioactivation::theDecayRateVector

private

Definition at line 168 of file G4Radioactivation.hh.

Referenced by CalculateChainsFromParent(), DecayIt(), and GetChainsFromParent().

◆ theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0

protectedinherited

Definition at line 338 of file G4VProcess.hh.

Referenced by G4VProcess::ClearNumberOfInteractionLengthLeft(), G4VProcess::EndTracking(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), and G4VProcess::StartTracking().

◆ theNucleusLimits

G4NucleusLimits G4RadioactiveDecay::theNucleusLimits

privateinherited

Definition at line 204 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::GetNucleusLimits(), G4RadioactiveDecay::IsApplicable(), and G4RadioactiveDecay::SetNucleusLimits().

◆ theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0

protectedinherited

Definition at line 331 of file G4VProcess.hh.

◆ theParentChainTable

G4RadioactiveDecayParentChainTable G4Radioactivation::theParentChainTable

private

Definition at line 170 of file G4Radioactivation.hh.

Referenced by CalculateChainsFromParent(), GetChainsFromParent(), and IsRateTableReady().

◆ thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName

protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

◆ thePILfactor

G4double G4VProcess::thePILfactor = 1.0

protectedinherited

Definition at line 352 of file G4VProcess.hh.

Referenced by G4VProcess::AtRestGPIL(), G4VProcess::GetPILfactor(), G4VProcess::PostStepGPIL(), and G4VProcess::SetPILfactor().

◆ theProcessName

G4String G4VProcess::theProcessName

protectedinherited

Definition at line 341 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4VProcess::EndTracking(), G4ImportanceProcess::GetName(), G4WeightCutOffProcess::GetName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4WrapperProcess::RegisterProcess(), G4VProcess::StartTracking(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

◆ theProcessSubType

G4int G4VProcess::theProcessSubType = -1

protectedinherited

Definition at line 349 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VProcess::GetProcessSubType(), and G4VProcess::SetProcessSubType().

◆ theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined

protectedinherited

Definition at line 346 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4VProcess::GetProcessType(), G4WrapperProcess::RegisterProcess(), and G4VProcess::SetProcessType().

◆ theRadDecayMode

G4RadioactiveDecayMode G4RadioactiveDecay::theRadDecayMode

privateinherited

Definition at line 223 of file G4RadioactiveDecay.hh.

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

◆ theRadioactivationMessenger

G4RadioactivationMessenger* G4Radioactivation::theRadioactivationMessenger

protected

Definition at line 150 of file G4Radioactivation.hh.

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

◆ theRadioactiveDecayMessenger

G4RadioactiveDecayMessenger* G4RadioactiveDecay::theRadioactiveDecayMessenger

protectedinherited

Definition at line 183 of file G4RadioactiveDecay.hh.

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

◆ theRadioactivityTables

std::vector<G4RadioactivityTable*> G4Radioactivation::theRadioactivityTables

private

Definition at line 173 of file G4Radioactivation.hh.

Referenced by DecayIt(), G4Radioactivation(), GetTheRadioactivityTables(), and SetDecayBias().

◆ theUserRadioactiveDataFiles

std::map<G4int, G4String> G4RadioactiveDecay::theUserRadioactiveDataFiles

privateinherited

Definition at line 220 of file G4RadioactiveDecay.hh.

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

◆ ValidVolumes

std::vector<G4String> G4RadioactiveDecay::ValidVolumes

protectedinherited

Definition at line 186 of file G4RadioactiveDecay.hh.

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

◆ verboseLevel

G4int G4RadioactiveDecay::verboseLevel

privateinherited

Definition at line 233 of file G4RadioactiveDecay.hh.

Referenced by G4RadioactiveDecay::GetVerboseLevel(), and G4RadioactiveDecay::SetVerboseLevel().

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

source/processes/hadronic/models/radioactive_decay/include/G4Radioactivation.hh
source/processes/hadronic/models/radioactive_decay/src/G4Radioactivation.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4Radioactivation()

◆ ~G4Radioactivation()

Member Function Documentation

◆ AddDeexcitationSpectrumForBiasMode()

◆ AddUserDecayDataFile()

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AlongStepGPIL()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ AtRestGPIL()

◆ BuildPhysicsTable()

◆ BuildWorkerPhysicsTable()

◆ CalculateChainsFromParent()

◆ ChooseCollimationDirection()

◆ ClearNumberOfInteractionLengthLeft()

◆ CollimateDecay()

◆ CollimateDecayProduct()

◆ ConvolveSourceTimeProfile()

◆ DecayAnalog()

◆ DecayIt()

◆ DeselectAllVolumes()

◆ DeselectAVolume()

◆ DoDecay()

◆ DumpInfo()

◆ EndTracking()

◆ GetChainsFromParent()

◆ GetCurrentInteractionLength()

◆ GetDecayDirection()

◆ GetDecayHalfAngle()

◆ GetDecayTable()

◆ GetDecayTable1()

◆ GetDecayTime()

◆ GetDecayTimeBin()

◆ GetMasterProcess()

◆ GetMeanFreePath()

◆ GetMeanLifeTime()

◆ GetNucleusLimits()

◆ GetNumberOfInteractionLengthLeft()

◆ GetPhysicsTableFileName()

◆ GetPILfactor()

◆ GetProcessManager()

◆ GetProcessName()

◆ GetProcessSubType()

◆ GetProcessType()

◆ GetProcessTypeName()

◆ GetSplitNuclei()

◆ GetTheRadioactivityTables()

◆ GetThresholdForVeryLongDecayTime()

◆ GetTotalNumberOfInteractionLengthTraversed()

◆ GetVerboseLevel()

◆ isAlongStepDoItIsEnabled()

◆ IsAnalogueMonteCarlo()

◆ IsApplicable()

◆ isAtRestDoItIsEnabled()

◆ isPostStepDoItIsEnabled()

◆ IsRateTableReady()

◆ LoadDecayTable()

◆ operator!=()

◆ operator==()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PostStepGPIL()

◆ PreparePhysicsTable()

◆ PrepareWorkerPhysicsTable()

◆ ProcessDescription()

◆ ResetNumberOfInteractionLengthLeft()

◆ RetrievePhysicsTable()

◆ SelectAllVolumes()

◆ SelectAVolume()