G4FissionProductYieldDist.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:   G4FissionProductYieldDist.hh
 * Author: B. Wendt ([email protected])
 *
 * Created on May 11, 2011, 12:04 PM
 */
 
#ifndef G4FISSIONPRODUCTYIELDDIST_HH
#define G4FISSIONPRODUCTYIELDDIST_HH
 
#include "G4DynamicParticle.hh"
#include "G4DynamicParticleVector.hh"
#include "G4ENDFTapeRead.hh"
#include "G4ENDFYieldDataContainer.hh"
#include "G4FFGEnumerations.hh"
#include "G4FPYNubarValues.hh"
#include "G4FPYSamplingOps.hh"
#include "G4FPYTreeStructures.hh"
#include "G4Gamma.hh"
#include "G4IonTable.hh"
#include "G4Ions.hh"
#include "G4ParticleHPNames.hh"
#include "G4ReactionProduct.hh"
#include "globals.hh"
 
/** G4FissionProductYieldDist is the base class for storing all the fission
 *  data and generating fission events. */
class G4FissionProductYieldDist
{
  public:
    // Constructor definition
    /** Default constructor
     *  - Usage:
     *      - \p WhichIsotope: Isotope number of the element in ZZZAAA form
     *      - \p WhichMetaState: \p GROUND_STATE, \p META_1, or \p META_2
     *      - \p WhichCause: \p SPONTANEOUS or \p N_INDUCED
     *      - \p WhichYieldType: \p INDEPENDENT or \p CUMULATIVE
     *
     *  - Notes:
     */
    G4FissionProductYieldDist(G4int WhichIsotope, G4FFGEnumerations::MetaState WhichMetaState,
                              G4FFGEnumerations::FissionCause WhichCause,
                              G4FFGEnumerations::YieldType WhichYieldType,
                              std::istringstream& dataStream);
    /** Overloaded constructor
     *  - Usage:
     *      - \p WhichIsotope: Isotope number of the element in ZZZAAA form
     *      - \p WhichMetaState: \p GROUND_STATE, \p META_1, or \p META_2
     *      - \p WhichCause: \p SPONTANEOUS or \p N_INDUCED
     *      - \p WhichYieldType: \p INDEPENDENT or \p CUMULATIVE
     *      - \p Verbosity: Verbosity level
     *
     *  - Notes:
     */
    G4FissionProductYieldDist(G4int WhichIsotope, G4FFGEnumerations::MetaState WhichMetaState,
                              G4FFGEnumerations::FissionCause WhichCause,
                              G4FFGEnumerations::YieldType WhichYieldType, G4int Verbosity,
                              std::istringstream& dataStream);
 
  private:
    /** Initialize is a common function called by all constructors. */
    void Initialize(std::istringstream& dataStream);
 
#ifdef G4MULTITHREADED
    static G4Mutex fissprodMutex;
#endif
 
  public:
    // Functions
    /** Generates a fission event using default sampling and returns the pointer
     *  to that fission event.
     *  - Usage: No arguments required
     *
     *  - Notes:
     *      - The fission products are loaded into FissionContainer in the
     *        following order:
     *          - First daughter product
     *          - Second daughter product
     *          - Alpha particles
     *          - Neutrons
     *          - Gamma rays
     *      - The last particle will have a NULL NextFragment pointer
     */
    G4DynamicParticleVector* G4GetFission();
    /** Selects a fission fragment at random from the probability tree and
     *  returns the \p G4Ions pointer.
     *  - Usage: No arguments required
     *
     *  - Notes:
     */
    G4Ions* G4GetFissionProduct();
    /** Set the alpha production behavior for fission event generation.
     *  - Usage:
     *      - if \p AlphaProduction is negative then alpha particles are sampled
     *        randomly.
     *
     *  - 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 energy of the incident particle
     *  - Usage:
     *      - \p WhatIncidentEnergy: Kinetic energy, if any, of the incident
     *      neutron in GeV
     *
     *  - Notes:
     */
    void G4SetEnergy(G4double WhatIncidentEnergy);
    /** Sets the probability of ternary fission
     *  - Usage:
     *      - \p WhatTernaryProbability: Probability of generating a ternary
     *        fission event.
     *
     *  - Notes:
     */
    void G4SetTernaryProbability(G4double TernaryProbability);
    /** 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
     *  G4FissionProductYieldDist references
     */
    const G4int Isotope_;
    /** MetaState information of the isotope that G4FissionProductYieldDist
     *  references
     *  \n Possible values are \p GROUND_STATE, \p META_1, or \p META_2
     */
    const G4FFGEnumerations::MetaState MetaState_;
    /** The cause of fission: \p SPONTANEOUS or \p N_INDUCED. */
    const G4FFGEnumerations::FissionCause Cause_;
    /** The type of yield to be used: \p INDEPENDET or \p CUMULATIVE */
    const G4FFGEnumerations::YieldType YieldType_;
 
    // Datafile variables
    /** Name of the fission yield product data file that
     *  G4FissionProductYieldDist references
     */
    G4ENDFTapeRead* ENDFData_;
 
    // Fission generation variables
    /** Contains the \p G4Ions pointer to an alpha particle */
    G4Ions* AlphaDefinition_;
    /** Controls whether alpha particles are emitted, and how many */
    G4double AlphaProduction_;
    /** Sets the ternary fission probability. Valid ranges are [0, 1] */
    G4double TernaryProbability_;
    /** Contains the \p g4ParticleDefinition pointer to a gamma particle */
    G4Gamma* GammaDefinition_;
    /** Kinetic energy, if any, of the incident particle in GeV. */
    G4double IncidentEnergy_;
    /** Sets the mean gamma energy, in MeV, produced by the fission of the
     *  isotope described by Isotope_
     */
    G4double MeanGammaEnergy_;
    /** Contains the G4ParticleDefinition pointer to a neutron, cast as a
     *  G4Ion for compatibility*/
    G4Ions* NeutronDefinition_;
    /** Nubar for the isotope and incident neutron energy that
     *  G4FissionProductYieldDist references.
     */
    G4double Nubar_;
    /** Width of the gaussian distribution that samples nubar for the
     *  isotope and incident neutron energy that G4FissionProductYieldDist
     *  references.
     */
    G4double NubarWidth_;
    /** Counter for the number of protons available to the fission event */
    G4int RemainingZ_;
    /** Counter for the number of nucleons available to the fission event */
    G4int RemainingA_;
    /** Container for the energy remaining to be assigned in the fission generation */
    G4double RemainingEnergy_;
    /** Verbosity level */
    G4int Verbosity_;
 
    // Pointers to the field of trees and relevant normalization data
    /** An array, or 'field', of the probability trees */
    ProbabilityTree* Trees_;
    /** Defines the smallest Z particle in the field of trees */
    G4Ions* SmallestZ_;
    /** Defines the smallest A particle in the field of trees */
    G4Ions* SmallestA_;
    /** Defines the largest Z particle in the field of trees. */
    G4Ions* LargestZ_;
    /** Defines the largest Z particle in the field of trees */
    G4Ions* LargestA_;
    /** Number of specific energy groups */
    G4int YieldEnergyGroups_;
    /** Energy values of each energy */
    G4double* YieldEnergies_;
    /** Variable for ensuring that the input data is normalized */
    G4double* MaintainNormalizedData_;
    /** A running total of all the probabilities */
    G4double* DataTotal_;
    /** The number of trees in the field */
    G4int TreeCount_;
    /** A run-time counter for the total number of branches stored */
    G4int BranchCount_;
 
    // Pointers to runtime classes that G4FissionProductYieldDist needs to
    // function properly
    /** Pointer to \p G4IonTable
     *  \n All \p G4Ions are created using
     *  \p G4IonTable
     */
    G4IonTable* IonTable_;
    /** Pointer to \p G4NeutronHPNames
     * \n Provides access to the list of element names included in Geant4
     */
    G4ParticleHPNames* ElementNames_;
    /** Pointer to the \p CLHEP library random engine */
    G4FPYSamplingOps* RandomEngine_;
 
    // Functions
    /** Checks to make sure that alpha overpopulation will not occur, which
     *  could result in an unsolvable zero momentum in the LAB system.
     */
    void CheckAlphaSanity();
    /** Returns the \p G4Ions definitions pointer for the particle whose
     *  probability segment contains the (0, 1] random number \p RandomParticle
     */
    G4Ions* FindParticle(G4double RandomParticle);
    /** Returns the \p G4Ions definitions pointer for the particle whose
     *  probability segment contains the (0, 1] random number \p RandomParticle
     *  by extrapolating values using the current data set.
     *  This function exists so that that different models of extrapolation
     *  may be more easily implemented in the future.
     */
    G4Ions* FindParticleExtrapolation(G4double RandomParticle, G4bool LowerEnergyGroupExists);
    /** Returns the \p G4Ions definitions pointer for the particle whose
     *  probability segment contains the (0, 1] random number \p RandomParticle
     *  by interpolating values in the current data set.
     *  This function exists so that that different models of interpolation
     *  may be more easily implemented in the future.
     */
    G4Ions* FindParticleInterpolation(G4double RandomParticle, G4int LowerEnergyGroup);
    /** Returns the \p G4Ions definitions pointer for the particle whose
     *  probability segment contains the (0, 1] random number \p RandomParticle
     *  by searching through a branch. Both the extrapolation and interpolation
     *  schemes currently use this function to identify the particle.
     */
    G4Ions* FindParticleBranchSearch(ProbabilityBranch* Branch, G4double RandomParticle,
                                     G4int EnergyGroup1, G4int EnergyGroup2);
    /** Generates a \p G4DynamicParticleVector with the fission alphas
     */
    virtual void GenerateAlphas(std::vector<G4ReactionProduct*>* Alphas);
    /** Generate a linked chain of neutrons and return the pointer to the last
     * neutron in the chain.
     */
    virtual void GenerateNeutrons(std::vector<G4ReactionProduct*>* Neutrons);
    /** Selects a fission product from the probability tree, limited by the
     *  number of nucleons available to the system
     */
    virtual G4Ions* GetFissionProduct() = 0;
    /** Returns the \p G4Ions definition pointer to the isotope defined by
     *  \p Product and \p MetaState.
     *  Searches the \p ParticleTable for the particle defined by \p Product
     *  (ZZZAAA) and \p MetaState and returns the \p G4Ions
     *  pointer to that particle. If the particle does not exist then it is
     *  created in \p G4ParticleTable and the pointer to the new particle is
     *  returned.
     */
    G4Ions* GetParticleDefinition(G4int Product, G4FFGEnumerations::MetaState MetaState);
    /** Generates the directory location for the data file referenced by
     *  G4FissionProductYieldDist
     */
    G4String MakeDirectoryName();
    /** Generates the appropriate file name for the isotope requested */
    G4String MakeFileName(G4int Isotope, G4FFGEnumerations::MetaState MetaState);
    /** Creates a \p G4DynamicParticle from an existing \p G4ReactionProduct */
    G4DynamicParticle* MakeG4DynamicParticle(G4ReactionProduct*);
    /** Generates the unique name for an isotope/isomer defined by \p Isotope\
     *  and \p MetaState in the following format: ZZZ_AAAmX_NAME
     */
    G4String MakeIsotopeName(G4int Isotope, G4FFGEnumerations::MetaState MetaState);
    /** Dynamically allocates and initializes the 'field' of 'trees' with the
     *  'trunks'
     */
    virtual void MakeTrees();
    /** Reads in the probability data from the data file */
    virtual void ReadProbabilities();
    /** Renormalizes the data in a ProbabilityTree.
     *  Traverses the tree structure and renormalizes all the probability data
     *  into probability segments, ensuring that no segment overlaps the
     *  other.
     */
    void Renormalize(ProbabilityBranch* Branch);
    /** Sample the energy of the alpha particles. The energy used by the alpha
     *  particles is subtracted from the available energy
     */
    void SampleAlphaEnergies(std::vector<G4ReactionProduct*>* Alphas);
    /** Samples the energy of the gamma rays */
    void SampleGammaEnergies(std::vector<G4ReactionProduct*>* Gammas);
    /** Sample the energy of the neutrons using the Watt fission spectrum. The
     *  kinetic energy consumed is returned.
     */
    void SampleNeutronEnergies(std::vector<G4ReactionProduct*>* Neutrons);
    /** Sets the nubar values for the isotope referenced by
     *  G4FissionProductYieldDistdefined from the data sets defined in
     *  SpecialOps.hh
     */
    void SetNubar();
    /** Sorts information for a potential new particle into the correct tree */
    virtual void SortProbability(G4ENDFYieldDataContainer* YieldData);
 
    // Destructor function(s)
  public:
    /** Default deconstructor. It is a virtual function since
     *  G4FissionProductYieldDist is a parent class
     */
    virtual ~G4FissionProductYieldDist();
 
  protected:
    /** Recursively burns each branch in a probability tree. */
    void BurnTree(ProbabilityBranch* Branch);
};
 
#endif /* G4FISSIONPRODUCTYIELDDIST_HH */