G4FissionFragmentGenerator Class Reference

#include <G4FissionFragmentGenerator.hh>

Public Member Functions
	G4FissionFragmentGenerator (void)
	G4FissionFragmentGenerator (G4int Verbosity)
G4DynamicParticleVector *	G4GenerateFission (void)
G4DynamicParticleVector *	G4GenerateFission (const G4HadProjectile &Projectile)
const std::vector< G4DynamicParticleVector * >	G4GenerateFission (G4long NumberOfFissions, const G4HadProjectile &Projectile)
G4Ions *	G4GenerateFissionProduct (void)
G4double	G4GetAlphaProduction (void)
G4double	G4GetTernaryProbability (void)
G4FFGEnumerations::FissionCause	G4GetCause (void)
G4double	G4GetIncidentEnergy (void)
G4int	G4GetIsotope (void)
G4FFGEnumerations::MetaState	G4GetMetaState (void)
G4FFGEnumerations::FissionSamplingScheme	G4GetSamplingScheme (void)
G4FFGEnumerations::YieldType	G4GetYieldType (void)
bool	InitializeFissionProductYieldClass (std::istringstream &dataFile)
void	G4SetAlphaProduction (G4double WhatAlphaProduction)
void	G4SetTernaryProbability (G4double WhatTernaryProbability)
void	G4SetCause (G4FFGEnumerations::FissionCause WhichCause)
void	G4SetIncidentEnergy (G4double WhatIncidentEnergy)
void	G4SetIsotope (G4int WhichIsotope)
void	G4SetMetaState (G4FFGEnumerations::MetaState WhichMetaState)
void	G4SetSamplingScheme (G4FFGEnumerations::FissionSamplingScheme NewScheme)
void	G4SetYieldType (G4FFGEnumerations::YieldType WhichYieldType)
void	G4SetVerbosity (G4int WhatVerbosity)
	~G4FissionFragmentGenerator ()

Static Public Member Functions
static G4int	G4MakeIsotopeCode (G4int Z, G4int A, G4int M)

Protected Member Functions
void	Initialize (void)

Protected Attributes
G4int	Isotope_
G4FFGEnumerations::MetaState	MetaState_
G4FFGEnumerations::FissionCause	Cause_
G4double	IncidentEnergy_
G4FFGEnumerations::YieldType	YieldType_
G4double	TernaryProbability_
G4double	AlphaProduction_
G4bool	IsReconstructionNeeded_
G4int	Verbosity_
G4FFGEnumerations::FissionSamplingScheme	SamplingScheme_
G4FissionProductYieldDist *	YieldData_

Detailed Description

G4FissionFragmentGenerator is the front end class to be used by the user for handling all fission event generation.

This class is intended to be instantiated for one type of fission event for as specific isotope/isomer, fission type, and incident neutron energy. For this reason no functions exist to change or modify these values once the class in constructed. A new class must be created by the user for each type of fission event, if such functionality is desired.

Definition at line 54 of file G4FissionFragmentGenerator.hh.

Constructor & Destructor Documentation

G4FissionFragmentGenerator() [1/2]

G4FissionFragmentGenerator::G4FissionFragmentGenerator

(

void

)

Default constructor

• Usage: No arguments required
• Notes:
  • There are methods that should be called to set operating parameters before generating any fission events with G4FissionFragmentGenerator. These are:
    • G4SetIsotope()
    • G4SetMetaState()
    • G4SetCause()
    • G4SetIncidentEnergy()
    • G4SetYieldType()
    • G4SetAlphaProduction()
    • G4SetAlphaProductionProbability()
    • G4SetSamplingScheme()
  • If any or all of these parameters are not set by the user, then default values will be used.
    • Isotope: 92238
    • Metastable state: GROUND_STATE
    • Cause: SPONTANEOUS
    • Incident energy: 0.025 eV
    • Yield type: INDEPENDENT
    • Alpha production: 0
    • Alpha production probability: 0
    • Sampling scheme: NORMAL

Definition at line 54 of file G4FissionFragmentGenerator.cc.

{
    // Set the default verbosity
    Verbosity_ = G4FFGDefaultValues::Verbosity;
    
    // Initialize the class
    Initialize();
}

G4FissionFragmentGenerator() [2/2]

G4FissionFragmentGenerator::G4FissionFragmentGenerator

(

G4int

Verbosity

)

Overloaded constructor

• Usage:
  • Verbosity: Verbosity level
• Notes:
  • Refer to the documentation for the default constructor for setting up the operating parameters.

Definition at line 64 of file G4FissionFragmentGenerator.cc.

{
    // Set the verbosity
    Verbosity_ = Verbosity;
    
    // Initialize the class
    Initialize();
}

~G4FissionFragmentGenerator()

G4FissionFragmentGenerator::~G4FissionFragmentGenerator

(

)

Default deconstructor

Definition at line 759 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    delete YieldData_;
 
G4FFG_FUNCTIONLEAVE__
}

Member Function Documentation

G4GenerateFission() [1/3]

G4DynamicParticleVector * G4FissionFragmentGenerator::G4GenerateFission

(

const G4HadProjectile &

Projectile

)

Generates a single fission event

• Usage: -Projectile: G4HadProjectile of the fission-inducing particle
• Notes:
  • Generates a single fission event by calling the overloaded function and passing an argument of '1'

Definition at line 114 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    // Call the overloaded function and generate 1 fission
    std::vector< G4DynamicParticleVector* > FissionEvent = G4GenerateFission(1, Projectile);
    G4DynamicParticleVector* const Container = FissionEvent[0];
 
G4FFG_FUNCTIONLEAVE__
    return Container;
}

G4GenerateFission() [2/3]

const std::vector< G4DynamicParticleVector * > G4FissionFragmentGenerator::G4GenerateFission	(	G4long	NumberOfFissions,
		const G4HadProjectile &	Projectile
	)

Generates NumberOfFissions fission events

• Usage: -NumberOfFissions: The number of fission events to generate
• Notes:
  • Generates NumberOfFissions fission events

Definition at line 127 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
 
    //TK Modified 131107
    //std::vector< G4DynamicParticleVector* > FissionEvents(NumberOfFissions);
    std::vector< G4DynamicParticleVector* > FissionEvents(0);
 
    if(Projectile.GetDefinition() == G4Neutron::Neutron())
    {
        if(IsReconstructionNeeded_ == TRUE)
        {
            // TODO Eliminate potential need for restructuring during run phase
            //InitializeFissionProductYieldClass();
        }
 
        for(G4long i = 0; i < NumberOfFissions; i++)
        {
            FissionEvents.push_back(YieldData_->G4GetFission());
            // FIXME Use particle momentum in balance equation
            // FissionEvents.push_back(YieldData_->G4GetFission(Projectile.Get4Momentum()));
        }
    } else
    {
        FissionEvents.push_back(NULL);
    }
 
G4FFG_FUNCTIONLEAVE__
    return FissionEvents;
}

G4GenerateFission() [3/3]

G4DynamicParticleVector * G4FissionFragmentGenerator::G4GenerateFission

(

void

)

Generates a single fission event

• Usage: No arguments required
• Notes:
  • Generates a single fission event by calling the overloaded function and passing an argument of '1'

Definition at line 97 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    const G4HadProjectile Projectile(G4DynamicParticle(G4Neutron::Neutron(),
                                                       G4ThreeVector(0, 0, 0),
                                                       G4FFGDefaultValues::ThermalNeutronEnergy));
 
    // Call the overloaded function and generate 1 fission
    std::vector< G4DynamicParticleVector* > FissionEvent = G4GenerateFission(1, Projectile);
    G4DynamicParticleVector* Container = FissionEvent[0];
 
G4FFG_FUNCTIONLEAVE__
    return Container;
}

Referenced by G4GenerateFission().

G4GenerateFissionProduct()

G4Ions * G4FissionFragmentGenerator::G4GenerateFissionProduct

(

void

)

Returns a randomly sampled fission product

Definition at line 161 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    if(IsReconstructionNeeded_ == TRUE)
    {
        // TODO Eliminate potential need for restructuring during run phase
        //InitializeFissionProductYieldClass();
    }
    
    G4Ions* Product = YieldData_->G4GetFissionProduct();
 
G4FFG_FUNCTIONLEAVE__
    return Product;
}

G4GetAlphaProduction()

G4double G4FissionFragmentGenerator::G4GetAlphaProduction

(

void

)

Returns the production rate of alpha particles for fission events

Definition at line 178 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
G4FFG_FUNCTIONLEAVE__
    return AlphaProduction_;
}

G4GetCause()

G4FFGEnumerations::FissionCause G4FissionFragmentGenerator::G4GetCause

(

void

)

Returns the FissionCause of the fission event.

Definition at line 196 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
G4FFG_FUNCTIONLEAVE__
    return Cause_;
}

G4GetIncidentEnergy()

G4double G4FissionFragmentGenerator::G4GetIncidentEnergy

(

void

)

Returns the energy of the fission inducing particle.

Definition at line 205 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
G4FFG_FUNCTIONLEAVE__
    return IncidentEnergy_;
}

G4GetIsotope()

G4int G4FissionFragmentGenerator::G4GetIsotope

(

void

)

Returns the code of the fission isotope in ZZZAAA format.

Definition at line 214 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
G4FFG_FUNCTIONLEAVE__
    return Isotope_;
}

G4GetMetaState()

G4FFGEnumerations::MetaState G4FissionFragmentGenerator::G4GetMetaState

(

void

)

Returns the MetaState of the fission isotope.

Definition at line 223 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
G4FFG_FUNCTIONLEAVE__
    return MetaState_;
}

G4GetSamplingScheme()

G4FFGEnumerations::FissionSamplingScheme G4FissionFragmentGenerator::G4GetSamplingScheme

(

void

)

Returns the FissionSamplingScheme that is currently in use.

Definition at line 232 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
G4FFG_FUNCTIONLEAVE__
    return SamplingScheme_;
}

G4GetTernaryProbability()

G4double G4FissionFragmentGenerator::G4GetTernaryProbability

(

void

)

Returns the probability of ternary fission

Definition at line 187 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
G4FFG_FUNCTIONLEAVE__
    return TernaryProbability_;
}

G4GetYieldType()

G4FFGEnumerations::YieldType G4FissionFragmentGenerator::G4GetYieldType

(

void

)

Returns the yield type that is currently in use

Definition at line 241 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
G4FFG_FUNCTIONLEAVE__
    return YieldType_;
}

G4MakeIsotopeCode()

G4int G4FissionFragmentGenerator::G4MakeIsotopeCode ( G4int  Z, G4int  A, G4int  M  )

static

Converts the Z, A and M of an isotope into an integer representation

Definition at line 250 of file G4FissionFragmentGenerator.cc.

{
    // Sanity check;
    A %= 1000;
    Z %= 1000;
    M %= 10;
 
    return (A + Z * 1000) * 10 + M;
}

Referenced by G4WendtFissionFragmentGenerator::ApplyYourself(), and G4WendtFissionFragmentGenerator::InitializeANucleus().

G4SetAlphaProduction()

void G4FissionFragmentGenerator::G4SetAlphaProduction

(

G4double

WhatAlphaProduction

)

Sets the number of alpha particles produced in fission.

• Usage:
  • if AlphaProduction is negative then alpha particles are sampled on a Gaussian with a mean of abs(AlphaProduction).
• Notes:
  • The maximum number of alpha particles that may be created is physically limited by the nucleons present in the parent nucleus. Setting the AlphaProduction too high will have unpredictable results on the sampling of the fission products.

Definition at line 261 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    AlphaProduction_ = WhatAlphaProduction;
    if(YieldData_ != NULL)
    {
        YieldData_->G4SetAlphaProduction(AlphaProduction_);
    }
 
    if(Verbosity_ & G4FFGEnumerations::UPDATES)
    {
        G4FFG_SPACING__
        G4FFG_LOCATION__
        
        G4cout << " -- Alpha production set to " << AlphaProduction_ << G4endl;
    }
 
G4FFG_FUNCTIONLEAVE__
}

G4SetCause()

void G4FissionFragmentGenerator::G4SetCause

(

G4FFGEnumerations::FissionCause

WhichCause

)

Sets the cause of fission event.

• Usage:
  • WhichCause: SPONTANEOUS, N_INDUCED, P_INDUCED, or G_INDUCED
• Notes:

Definition at line 305 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    G4bool IsValidCause = (WhichCause == G4FFGEnumerations::SPONTANEOUS
                           || WhichCause == G4FFGEnumerations::NEUTRON_INDUCED );
    G4bool IsSameCause = (Cause_ == WhichCause);
    
    if(!IsSameCause && IsValidCause)
    {
        Cause_ = WhichCause;
        if(Cause_ == G4FFGEnumerations::SPONTANEOUS)
        {
            IncidentEnergy_ = 0;
        }
        IsReconstructionNeeded_ = TRUE;
    }
    
    if(Verbosity_ != G4FFGEnumerations::SILENT)
    {
        G4String CauseString;
        switch(WhichCause)
        {
            case G4FFGEnumerations::SPONTANEOUS:
                CauseString = "SPONTANEOUS";
                break;
            case G4FFGEnumerations::NEUTRON_INDUCED:
                CauseString = "NEUTRON_INDUCED";
                break;
            case G4FFGEnumerations::PROTON_INDUCED:
                CauseString = "PROTON_INDUCED";
                break;
            case G4FFGEnumerations::GAMMA_INDUCED:
                CauseString = "GAMMA_INDUCED";
                break;
        }
        
        if(Verbosity_ & G4FFGEnumerations::WARNING)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
            
            if(IsValidCause)
            {
                if(IsSameCause && YieldData_ != NULL)
                {
                    G4cout << " -- Already set to use " << CauseString << " as the fission cause. Yield data class will not be reconstructed." << G4endl;
                } else if(YieldData_ == NULL)
                {
                    G4cout << " -- Yield data class not yet constructed. " << CauseString << " will be applied when it is constructed." << G4endl;
                }
            } else
            {
                G4cout << " -- Invalid cause of fission" << G4endl;
            }
        }
        
        if((Verbosity_ & G4FFGEnumerations::UPDATES)
           && IsValidCause)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
            
            G4cout << " -- Fission cause set to " << CauseString << "." << G4endl;
        }
    }
 
G4FFG_FUNCTIONLEAVE__
}

Referenced by G4WendtFissionFragmentGenerator::InitializeANucleus().

G4SetIncidentEnergy()

void G4FissionFragmentGenerator::G4SetIncidentEnergy

(

G4double

WhatIncidentEnergy

)

Sets the incident energy, if any, of the particle that cause fission.

• Usage:
  • WhatIncidentEnergy: Kinetic energy of the particle with units applied;
• Notes:

Definition at line 376 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    if(Cause_ != G4FFGEnumerations::SPONTANEOUS)
    {
        IncidentEnergy_ = WhatIncidentEnergy;
        if(YieldData_ != NULL)
        {
            YieldData_->G4SetEnergy(IncidentEnergy_);
        }
    }
    
    if(Verbosity_ != G4FFGEnumerations::SILENT)
    {
        std::ostringstream EnergyString;
        if(IncidentEnergy_ / GeV > 1)
        {
            EnergyString << IncidentEnergy_ / GeV << " GeV";
        } else if(IncidentEnergy_ / MeV > 1)
        {
            EnergyString << IncidentEnergy_ / MeV << " MeV";
        } else if(IncidentEnergy_ / keV > 1)
        {
            EnergyString << IncidentEnergy_ / keV << " keV";
        } else
        {
            EnergyString << IncidentEnergy_ / eV << " eV";
        }
            
        if(Verbosity_ & G4FFGEnumerations::ENERGY_INFO
           || Verbosity_ & G4FFGEnumerations::WARNING)
        {
            if(Cause_ == G4FFGEnumerations::SPONTANEOUS && IncidentEnergy_ != 0)
            {
                G4FFG_SPACING__
                G4FFG_LOCATION__
                
                G4cout << " -- Cannot set a non-zero energy for spontaneous fission" << G4endl;
            } else if(YieldData_ == NULL)
            {
                G4FFG_SPACING__
                G4FFG_LOCATION__
                
                G4cout << " -- Yield data class not yet constructed. " << EnergyString.str() << " will be applied when it is constructed." << G4endl;
                
            }
        }
        
        if(Verbosity_ & G4FFGEnumerations::ENERGY_INFO
           || Verbosity_ & G4FFGEnumerations::UPDATES)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
            
            G4cout << " -- Incident neutron energy set to " << EnergyString.str() << "." << G4endl;
        }
    }
 
G4FFG_FUNCTIONLEAVE__
}

Referenced by G4WendtFissionFragmentGenerator::InitializeANucleus().

G4SetIsotope()

void G4FissionFragmentGenerator::G4SetIsotope

(

G4int

WhichIsotope

)

Sets the fission isotope

• Usage:
  • WhichIsotope: Code of the isotope in ZZZAAA format
• Notes:

Definition at line 439 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    G4bool IsSameIsotope = (Isotope_ == WhichIsotope);
 
    if(!IsSameIsotope)
    {
        Isotope_ = WhichIsotope;
        IsReconstructionNeeded_ = TRUE;
    }
    
    if(Verbosity_ != G4FFGEnumerations::SILENT)
    {
        if(Verbosity_ & G4FFGEnumerations::WARNING)
        {
            if(IsSameIsotope && YieldData_ != NULL)
            {
                G4FFG_SPACING__
                G4FFG_LOCATION__
                
                G4cout << " -- Isotope " << Isotope_ << " already in use. Yield data class will not be reconstructed." << G4endl;
            } else if(YieldData_ == NULL)
            {
                G4FFG_SPACING__
                G4FFG_LOCATION__
                
                G4cout << " -- Yield data class not yet constructed. The isotope will be set to " << Isotope_ << " when it is constructed." << G4endl;
            }
        }
        
        if(Verbosity_ & G4FFGEnumerations::UPDATES)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
            
            G4cout << " -- Isotope set to " << Isotope_ << "." << G4endl;
        }
    }
 
G4FFG_FUNCTIONLEAVE__
}

Referenced by G4WendtFissionFragmentGenerator::InitializeANucleus().

G4SetMetaState()

void G4FissionFragmentGenerator::G4SetMetaState

(

G4FFGEnumerations::MetaState

WhichMetaState

)

Sets the metastable state of the fission isotope.

• Usage:
  • WhichMetaState: GROUND_STATE, META_1, or META_2
• Notes:

Definition at line 483 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    G4bool IsValidMetaState = (WhichMetaState >= G4FFGEnumerations::MetaStateFirst
                               && WhichMetaState <= G4FFGEnumerations::MetaStateLast);
    G4bool IsSameMetaState = (MetaState_ == WhichMetaState);
    
    if(!IsSameMetaState && IsValidMetaState)
    {
        MetaState_ = WhichMetaState;
        IsReconstructionNeeded_ = TRUE;
    }
    
    if(Verbosity_ != G4FFGEnumerations::SILENT)
    {
        G4String MetaName;
        switch(MetaState_)
        {
            case G4FFGEnumerations::GROUND_STATE:
                MetaName = "GROUND_STATE";
                break;
                
            case G4FFGEnumerations::META_1:
                MetaName = "META_1";
                break;
                
            case G4FFGEnumerations::META_2:
                MetaName = "META_2";
                break;
        }
        
        if(Verbosity_ & G4FFGEnumerations::WARNING)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
 
            std::ostringstream Temp;
            if(IsValidMetaState)
            {
                if(IsSameMetaState && YieldData_ != NULL)
                {
                    G4cout << " -- Already set to use " << MetaName << " as the metastable state. Yield data class will not be reconstructed" << G4endl;
                } else if(YieldData_ == NULL)
                {
                    G4cout << " -- Yield data class not yet constructed. " << MetaName << " will be applied when it is constructed." << G4endl;
                }
            } else
            {
                G4cout << " -- Invalid metastable state." << G4endl;
            }
        }
        
        if(Verbosity_ & G4FFGEnumerations::UPDATES
           && IsValidMetaState)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
            
            G4cout << " -- Metastable state set to " << MetaName << "." << G4endl;
        }
    }
 
G4FFG_FUNCTIONLEAVE__
}

Referenced by G4WendtFissionFragmentGenerator::InitializeANucleus().

G4SetSamplingScheme()

void G4FissionFragmentGenerator::G4SetSamplingScheme

(

G4FFGEnumerations::FissionSamplingScheme

NewScheme

)

Set the sampling scheme.

• Usage:
  • NewScheme: The G4FissionSamplingScheme value for the sampling scheme to use.
• Notes:
  • NORMAL: Sets the parameters of this class to sample fission events without any biasing.
  • LIGHT_FRAGMENT: Sets the parameters of this class to bias the fragment generation by always selecting a light fragment (A < 115) first.
  • WENDT: Sets the parameters of this class to sample fission events according to the Wendt sampling scheme. Please refer to the code documentation for G4FPYWendtSamplingDist for a more detailed explanation.

Definition at line 550 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    G4bool IsValidScheme = (NewScheme >= G4FFGEnumerations::FissionSamplingSchemeFirst
                            && NewScheme <= G4FFGEnumerations::FissionSamplingSchemeLast);
    G4bool IsSameScheme = (NewScheme == SamplingScheme_);
 
    if(!IsSameScheme && IsValidScheme)
    {
        SamplingScheme_ = NewScheme;
        IsReconstructionNeeded_ = TRUE;
    }
    
    if(Verbosity_ != G4FFGEnumerations::SILENT)
    {
        G4String SchemeString;
        switch(SamplingScheme_)
        {
            case G4FFGEnumerations::NORMAL:
                SchemeString = "NORMAL";
                break;
                
            case G4FFGEnumerations::LIGHT_FRAGMENT:
                SchemeString = "LIGHT_FRAGMENT";
                break;
 
            default:
                SchemeString = "UNSUPPORTED";
                break;
        }
        
        if(Verbosity_ & G4FFGEnumerations::WARNING)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
            
            if(IsValidScheme)
            {
                if(IsSameScheme && YieldData_ != NULL)
                {
                    G4cout << " -- Already set to use " << SchemeString << " as the sampling scheme. Yield data class will not be reconstructed." << G4endl;
                } else if(YieldData_ == NULL)
                {
                    G4cout << " -- Yield data class not yet constructed. " << SchemeString << " will be applied when it is constructed." << G4endl;
                }
            } else
            {
                G4cout << " -- Invalid sampling scheme." << G4endl;
            }
        }
        
        if((Verbosity_ & G4FFGEnumerations::UPDATES)
           && IsValidScheme)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
            
            G4cout << " -- Sampling scheme set to " << SchemeString << "." << G4endl;
        }
    }
 
G4FFG_FUNCTIONLEAVE__
}

Referenced by G4WendtFissionFragmentGenerator::InitializeANucleus().

G4SetTernaryProbability()

void G4FissionFragmentGenerator::G4SetTernaryProbability

(

G4double

WhatTernaryProbability

)

Sets the probability of ternary fission

• Usage:
  • WhatAlphaProductionProbability: Probability of generating alpha particles for a fission event. 1 = 100% chance of alpha production
• Notes:

Definition at line 283 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    TernaryProbability_ = WhatTernaryProbability;
    if(YieldData_ != NULL)
    {
        YieldData_->G4SetTernaryProbability(TernaryProbability_);
    }
 
    if(Verbosity_ & G4FFGEnumerations::UPDATES)
    {
        G4FFG_SPACING__
        G4FFG_LOCATION__
        
        G4cout << " -- Ternary fission probability set to " << TernaryProbability_ << G4endl;
    }
 
G4FFG_FUNCTIONLEAVE__
}

G4SetVerbosity()

void G4FissionFragmentGenerator::G4SetVerbosity

(

G4int

WhatVerbosity

)

Sets the verbosity levels

• Usage:
  • WhichVerbosity: Combination of levels
• Notes:
  • SILENT: All verbose output is repressed
  • UPDATES: Only high-level internal changes are reported
  • DAUGHTER_INFO: Displays information about daughter product sampling
  • NEUTRON_INFO: Displays information about neutron sampling
  • GAMMA_INFO: Displays information about gamma sampling
  • ALPHA_INFO: Displays information about alpha sampling
  • MOMENTUM_INFO: Displays information about momentum balancing
  • EXTRAPOLATION_INTERPOLATION_INFO: Displays information about any data extrapolation or interpolation that occurs
  • DEBUG: Reports program flow as it steps through functions
  • PRINT_ALL: Displays any and all output

Definition at line 682 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    Verbosity_ = Verbosity;
    
    if(YieldData_ != NULL)
    {
        YieldData_->G4SetVerbosity(Verbosity_);
    }
 
G4FFG_FUNCTIONLEAVE__
}

G4SetYieldType()

void G4FissionFragmentGenerator::G4SetYieldType

(

G4FFGEnumerations::YieldType

WhichYieldType

)

Sets the ENDF yield type to be used for the data

• Usage:
  • WhichYieldType: INDEPENDENT or COMULATIVE
• Notes:

Definition at line 616 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    G4bool IsValidYieldType = (WhichYieldType == G4FFGEnumerations::INDEPENDENT
                               ||WhichYieldType == G4FFGEnumerations::CUMULATIVE);
    G4bool IsSameYieldType = (YieldType_ == WhichYieldType);
 
    if(!IsSameYieldType && IsValidYieldType)
    {
        YieldType_ = WhichYieldType;
        IsReconstructionNeeded_ = TRUE;
    }
    
    if(Verbosity_ != G4FFGEnumerations::SILENT)
    {
        G4String YieldString;
        switch((int)YieldType_)
        {
        case G4FFGEnumerations::INDEPENDENT:
            YieldString = "INDEPENDENT";
            break;
        
        case G4FFGEnumerations::SPONTANEOUS:
            YieldString = "SPONTANEOUS";
            break;
 
        default:
            YieldString = "UNSUPPORTED";
            break;
        }
        
        if(Verbosity_ & G4FFGEnumerations::WARNING)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
            
            if(IsValidYieldType)
            {
                
                if(IsSameYieldType && YieldData_ != NULL)
                {
                } else if(YieldData_ == NULL)
                {
                    G4cout << " -- Yield data class not yet constructed. Yield type " << YieldString << " will be applied when it is constructed." << G4endl;
                }
            } else
            {
                G4cout << " -- Invalid yield type." << G4endl;
            }
        }
        
        if((Verbosity_ & G4FFGEnumerations::UPDATES)
           && IsValidYieldType)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
            
            G4cout << " -- Yield type set to " << YieldString << G4endl;
        }
    }
 
G4FFG_FUNCTIONLEAVE__
}

Referenced by G4WendtFissionFragmentGenerator::InitializeANucleus().

Initialize()

void G4FissionFragmentGenerator::Initialize ( void  )

protected

Initialize is a common function called by all constructors.

Definition at line 74 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    // Initialize the class descriptor variables to the default values. These
    // will be used unless the user redefines them.
    Isotope_ = G4FFGDefaultValues::Isotope;
    MetaState_ = G4FFGDefaultValues::MetaState;
    Cause_ = G4FFGDefaultValues::FissionCause;
    IncidentEnergy_ = G4FFGDefaultValues::ThermalNeutronEnergy;
    YieldType_ = G4FFGDefaultValues::YieldType;
    TernaryProbability_ = G4FFGDefaultValues::TernaryProbability;
    AlphaProduction_ = G4FFGDefaultValues::AlphaProduction;
    SamplingScheme_ = G4FFGDefaultValues::SamplingScheme;
 
    // No data class has been created yet
    YieldData_ = NULL;
    IsReconstructionNeeded_ = TRUE;
 
G4FFG_FUNCTIONLEAVE__
}

Referenced by G4FissionFragmentGenerator().

InitializeFissionProductYieldClass()

bool G4FissionFragmentGenerator::InitializeFissionProductYieldClass

(

std::istringstream &

dataFile

)

Initializes a new G4FPY...Dist class based on the class descriptor variables of G4FissionFragmentGenerator.

Definition at line 697 of file G4FissionFragmentGenerator.cc.

{
G4FFG_FUNCTIONENTER__
 
    if(YieldData_ != NULL)
    {
        delete YieldData_;
    
        if(Verbosity_ & G4FFGEnumerations::UPDATES)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
            
            G4cout << " -- Old yield data class deleted." << G4endl;
        }
    }
 
    try
    {
        if(SamplingScheme_ == G4FFGEnumerations::NORMAL)
        {
            YieldData_ = new G4FPYNormalFragmentDist(Isotope_,
                                                     MetaState_,
                                                     Cause_,
                                                     YieldType_,
                                                     Verbosity_,
                                                     dataStream);
        } else
        {
            YieldData_ = new G4FPYBiasedLightFragmentDist(Isotope_,
                                                          MetaState_,
                                                          Cause_,
                                                          YieldType_,
                                                          Verbosity_,
                                                          dataStream);
        }
 
        if(AlphaProduction_ != 0 && TernaryProbability_ != 0)
        {
            YieldData_->G4SetTernaryProbability(TernaryProbability_);
            YieldData_->G4SetAlphaProduction(AlphaProduction_);
        }
 
        if(Verbosity_ & G4FFGEnumerations::UPDATES)
        {
            G4FFG_SPACING__
            G4FFG_LOCATION__
 
            G4cout << " -- Yield data class constructed with defined values." << G4endl;
        }
    } catch (std::exception& e)
    {
        YieldData_ = NULL;
    }
 
    IsReconstructionNeeded_ = FALSE;
 
G4FFG_FUNCTIONLEAVE__
    return YieldData_;
}

Referenced by G4WendtFissionFragmentGenerator::InitializeANucleus().

Member Data Documentation

AlphaProduction_

G4double G4FissionFragmentGenerator::AlphaProduction_

protected

Controls whether alpha particles are emitted, and how many

Definition at line 261 of file G4FissionFragmentGenerator.hh.

Referenced by G4GetAlphaProduction(), G4SetAlphaProduction(), Initialize(), and InitializeFissionProductYieldClass().

Cause_

G4FFGEnumerations::FissionCause G4FissionFragmentGenerator::Cause_

protected

The cause of fission: SPONTANEOUS or N_INDUCED.

Definition at line 253 of file G4FissionFragmentGenerator.hh.

Referenced by G4GetCause(), G4SetCause(), G4SetIncidentEnergy(), Initialize(), and InitializeFissionProductYieldClass().

IncidentEnergy_

G4double G4FissionFragmentGenerator::IncidentEnergy_

protected

Kinetic energy, if any, of the incident particle in GeV.

Definition at line 255 of file G4FissionFragmentGenerator.hh.

Referenced by G4GetIncidentEnergy(), G4SetCause(), G4SetIncidentEnergy(), and Initialize().

Isotope_

G4int G4FissionFragmentGenerator::Isotope_

protected

Number in ZZZAAA format of the isotope that G4FissionFragmentGenerator references

Definition at line 246 of file G4FissionFragmentGenerator.hh.

Referenced by G4GetIsotope(), G4SetIsotope(), Initialize(), and InitializeFissionProductYieldClass().

IsReconstructionNeeded_

G4bool G4FissionFragmentGenerator::IsReconstructionNeeded_

protected

If Isotope_, MetaState_, Cause_, or IncidentEnergy_ are changed in the middle of a run then the class pointed at by YieldData_ will need to be reconstructed

Definition at line 266 of file G4FissionFragmentGenerator.hh.

Referenced by G4GenerateFission(), G4GenerateFissionProduct(), G4SetCause(), G4SetIsotope(), G4SetMetaState(), G4SetYieldType(), Initialize(), and InitializeFissionProductYieldClass().

MetaState_

G4FFGEnumerations::MetaState G4FissionFragmentGenerator::MetaState_

protected

MetaState information of the isotope that G4FissionFragmentGenerator references
A value of 0 refers to the ground state

Definition at line 251 of file G4FissionFragmentGenerator.hh.

Referenced by G4GetMetaState(), G4SetMetaState(), Initialize(), and InitializeFissionProductYieldClass().

SamplingScheme_

G4FFGEnumerations::FissionSamplingScheme G4FissionFragmentGenerator::SamplingScheme_

protected

The sampling scheme that is used: NORMAL, LIGHT_FRAGMENT, or WENDT.

Definition at line 274 of file G4FissionFragmentGenerator.hh.

Referenced by G4GetSamplingScheme(), Initialize(), and InitializeFissionProductYieldClass().

TernaryProbability_

G4double G4FissionFragmentGenerator::TernaryProbability_

protected

Sets the ternary fission probability. Valid ranges are [0, 1]

Definition at line 259 of file G4FissionFragmentGenerator.hh.

Referenced by G4GetTernaryProbability(), G4SetTernaryProbability(), Initialize(), and InitializeFissionProductYieldClass().

Verbosity_

G4int G4FissionFragmentGenerator::Verbosity_

protected

Verbosity level

Definition at line 268 of file G4FissionFragmentGenerator.hh.

Referenced by G4FissionFragmentGenerator(), G4SetAlphaProduction(), G4SetCause(), G4SetIncidentEnergy(), G4SetIsotope(), G4SetMetaState(), G4SetTernaryProbability(), G4SetVerbosity(), G4SetYieldType(), and InitializeFissionProductYieldClass().

YieldData_

G4FissionProductYieldDist* G4FissionFragmentGenerator::YieldData_

protected

Pointer to G4FissionProductYieldDist class that holds all the probabilistic yield data

Definition at line 278 of file G4FissionFragmentGenerator.hh.

Referenced by G4GenerateFission(), G4GenerateFissionProduct(), G4SetAlphaProduction(), G4SetCause(), G4SetIncidentEnergy(), G4SetIsotope(), G4SetMetaState(), G4SetTernaryProbability(), G4SetVerbosity(), G4SetYieldType(), Initialize(), InitializeFissionProductYieldClass(), and ~G4FissionFragmentGenerator().

YieldType_

G4FFGEnumerations::YieldType G4FissionFragmentGenerator::YieldType_

protected

The type of yield to be used: INDEPENDET or CUMULATIVE

Definition at line 257 of file G4FissionFragmentGenerator.hh.

Referenced by G4GetYieldType(), G4SetYieldType(), Initialize(), and InitializeFissionProductYieldClass().

---

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

• G4FissionFragmentGenerator.hh
• G4FissionFragmentGenerator.cc