G4FissionFragmentGenerator.hh

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
/*
 * File:   G4FissionFragmentGenerator.hh
 * Author: B. Wendt ([email protected])
 *
 * Created on May 11, 2011, 12:04 PM
 */
 
#ifndef G4FISSIONFRAGMENTGENERATOR_HH
#define G4FISSIONFRAGMENTGENERATOR_HH
 
#include "G4FFGEnumerations.hh"
#include "G4FissionProductYieldDist.hh"
#include "G4HadFinalState.hh"
#include "G4HadProjectile.hh"
#include "G4Ions.hh"
#include "G4TableTemplate.hh"
#include "globals.hh"
 
/** 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.
 */
class G4FissionFragmentGenerator
{
  public:
    // Constructor definition
    /** 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: \p 92238
     *          - Metastable state: \p GROUND_STATE
     *          - Cause: \p SPONTANEOUS
     *          - Incident energy: \p 0.025 eV
     *          - Yield type: \p INDEPENDENT
     *          - Alpha production: \p 0
     *          - Alpha production probability: \p 0
     *          - Sampling scheme: \p NORMAL
     */
    G4FissionFragmentGenerator();
    /** Overloaded constructor
     *  - Usage:
     *      - \p Verbosity: Verbosity level
     *
     *  - Notes:
            - Refer to the documentation for the default constructor for
     *        setting up the operating parameters.
     */
    G4FissionFragmentGenerator(G4int Verbosity);
 
  protected:
    /** Initialize is a common function called by all constructors. */
    void Initialize();
 
  public:
    // Functions
    /** 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'
     */
    G4DynamicParticleVector* G4GenerateFission();
    /** Generates a single fission event
     *  - Usage:
     *      -\p Projectile: G4HadProjectile of the fission-inducing particle
     *
     *  - Notes:
     *      - Generates a single fission event by calling the overloaded function
     *        and passing an argument of '1'
     */
    G4DynamicParticleVector* G4GenerateFission(const G4HadProjectile& Projectile);
    /** Generates NumberOfFissions fission events
     *  - Usage:
     *      -\p NumberOfFissions: The number of fission events to generate
     *
     *  - Notes:
     *      - Generates \p NumberOfFissions fission events
     */
    const std::vector<G4DynamicParticleVector*>
    G4GenerateFission(G4long NumberOfFissions, const G4HadProjectile& Projectile);
    /** Returns a randomly sampled fission product */
    G4Ions* G4GenerateFissionProduct();
    /** Returns the production rate of alpha particles for fission events */
    G4double G4GetAlphaProduction();
    /** Returns the probability of ternary fission */
    G4double G4GetTernaryProbability();
    /** Returns the FissionCause of the fission event. */
    G4FFGEnumerations::FissionCause G4GetCause();
    /** Returns the energy of the fission inducing particle. */
    G4double G4GetIncidentEnergy();
    /** Returns the code of the fission isotope in ZZZAAA format. */
    G4int G4GetIsotope();
    /** Returns the MetaState of the fission isotope. */
    G4FFGEnumerations::MetaState G4GetMetaState();
    /** Returns the FissionSamplingScheme that is currently in use. */
    G4FFGEnumerations::FissionSamplingScheme G4GetSamplingScheme();
    /** Returns the yield type that is currently in use */
    G4FFGEnumerations::YieldType G4GetYieldType();
    /** Initializes a new \p G4FPY...Dist class based on the class descriptor
     *  variables of G4FissionFragmentGenerator.
     */
    bool InitializeFissionProductYieldClass(std::istringstream& dataFile);
    /** Converts the Z, A and M of an isotope into an integer representation **/
    static G4int G4MakeIsotopeCode(G4int Z, G4int A, G4int M);
    /** Sets the number of alpha particles produced in fission.
     *  - Usage:
     *      - if \p AlphaProduction is negative then alpha particles are sampled
     *        on a Gaussian with a mean of \p 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.
     */
    void G4SetAlphaProduction(G4double WhatAlphaProduction);
    /** Sets the probability of ternary fission
     *  - Usage:
     *      - \p WhatAlphaProductionProbability: Probability of generating alpha
     *      particles for a fission event. 1 = 100% chance of alpha production
     *
     *  - Notes:
     */
    void G4SetTernaryProbability(G4double WhatTernaryProbability);
    /** Sets the cause of fission event.
     *  - Usage:
     *      - \p WhichCause: \p SPONTANEOUS, \p N_INDUCED, \p P_INDUCED, or
     *      \p G_INDUCED
     *
     *  - Notes:
     */
    void G4SetCause(G4FFGEnumerations::FissionCause WhichCause);
    /** Sets the incident energy, if any, of the particle that cause fission.
     *  - Usage:
     *      - \p WhatIncidentEnergy: Kinetic energy of the particle with units applied;
     *
     *  - Notes:
     */
    void G4SetIncidentEnergy(G4double WhatIncidentEnergy);
    /** Sets the fission isotope
     *  - Usage:
     *      - \p WhichIsotope: Code of the isotope in ZZZAAA format
     *
     *  - Notes:
     */
    void G4SetIsotope(G4int WhichIsotope);
    /** Sets the metastable state of the fission isotope.
     *  - Usage:
     *      - \p WhichMetaState: \p GROUND_STATE, \p META_1, or \p META_2
     *
     *  - Notes:
     */
    void G4SetMetaState(G4FFGEnumerations::MetaState WhichMetaState);
    /** Set the sampling scheme.
     *  - Usage:
     *      - NewScheme: The G4FissionSamplingScheme value for the sampling
     *        scheme to use.
     *
     *  - Notes:
     *      - \p NORMAL: Sets the parameters of this class to sample fission
     *           events without any biasing.
     *      - \p LIGHT_FRAGMENT: Sets the parameters of this class to bias the
     *           fragment generation by always selecting a light fragment
     *           (A < 115) first.
     *      - \p 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.
     */
    void G4SetSamplingScheme(G4FFGEnumerations::FissionSamplingScheme NewScheme);
    /** Sets the ENDF yield type to be used for the data
     *  - Usage:
     *      - \p WhichYieldType: \p INDEPENDENT or \p COMULATIVE
     *
     *  - Notes:
     */
    void G4SetYieldType(G4FFGEnumerations::YieldType WhichYieldType);
    /** Sets the verbosity levels
     *  - Usage:
     *      - \p WhichVerbosity: Combination of  levels
     *
     *  - Notes:
     *      - \p SILENT: All verbose output is repressed
     *      - \p UPDATES: Only high-level internal changes are reported
     *      - \p DAUGHTER_INFO: Displays information about daughter product sampling
     *      - \p NEUTRON_INFO: Displays information about neutron sampling
     *      - \p GAMMA_INFO: Displays information about gamma sampling
     *      - \p ALPHA_INFO: Displays information about alpha sampling
     *      - \p MOMENTUM_INFO: Displays information about momentum balancing
     *      - \p EXTRAPOLATION_INTERPOLATION_INFO: Displays information about any data extrapolation
     * or interpolation that occurs
     *      - \p DEBUG: Reports program flow as it steps through functions
     *      - \p PRINT_ALL: Displays any and all output
     */
    void G4SetVerbosity(G4int WhatVerbosity);
 
  protected:
    // Variables
    // Class descriptor variables
    /** Number in ZZZAAA format of the isotope that
     *  G4FissionFragmentGenerator references
     */
    G4int Isotope_;
    /** MetaState information of the isotope that G4FissionFragmentGenerator
     *  references
     *  \n A value of 0 refers to the ground state
     */
    G4FFGEnumerations::MetaState MetaState_;
    /** The cause of fission: \p SPONTANEOUS or \p N_INDUCED. */
    G4FFGEnumerations::FissionCause Cause_;
    /** Kinetic energy, if any, of the incident particle in GeV. */
    G4double IncidentEnergy_;
    /** The type of yield to be used: \p INDEPENDET or \p CUMULATIVE */
    G4FFGEnumerations::YieldType YieldType_;
    /** Sets the ternary fission probability. Valid ranges are [0, 1] */
    G4double TernaryProbability_;
    /** Controls whether alpha particles are emitted, and how many */
    G4double AlphaProduction_;
    /** 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
     */
    G4bool IsReconstructionNeeded_;
    /** Verbosity level */
    G4int Verbosity_;
 
    // Defines the current sampling scheme and the respective class
    /** The sampling scheme that is used: \p NORMAL, \p LIGHT_FRAGMENT, or
     *  \p WENDT.
     */
    G4FFGEnumerations::FissionSamplingScheme SamplingScheme_;
    /** Pointer to G4FissionProductYieldDist class that holds all the
     *  probabilistic yield data
     */
    G4FissionProductYieldDist* YieldData_;
 
    // Destructor function(s)
  public:
    /** Default deconstructor */
    ~G4FissionFragmentGenerator();
};
 
#endif /* G4FISSIONFRAGMENTGENERATOR_HH */