Merge pull request #53 from gridley/betterDocumentation

Better documentation

include/actions/NtAction.h

@@ -3,6 +3,22 @@
 
 #include "AddVariableAction.h"
 
+/**
+ * Add neutronics kernels and variables to MSR simulations automatically.
+ * When writing the multigroup diffusion equation:
+ * \f[
+ *   \frac{1}{v_g}\frac{\partial {\phi}_g}{\partial t}   = \nabla \cdot D_g
+                \nabla {\phi}_g +
+                \sum_{g \ne g'}^G
+                {\Sigma_{g'\rightarrow g}^s} {\phi}_{g'} + \chi_g^p \sum_{g' = 1}^G (1 -
+                \beta) \nu {\Sigma_{g'}^f} {\phi}_{g'} + \chi_g^d \sum_i^I
+                \lambda_i {C_i} - {\Sigma_g^r} {\phi_g}
+ * \f]
+ * it's clearly the case that many terms are involved. Moltres, and MOOSE in general represent
+ * each term as a "kernel". This action adds all of the required kernels for this problem to the
+ * simulation. In addition, when using many flux variables, it adds the required variables to the
+ * problem as well.
+ */
 class NtAction : public AddVariableAction
 {
 public:

include/actions/PrecursorAction.h

@@ -3,6 +3,19 @@
 
 #include "AddVariableAction.h"
 
+/**
+ * This Action adds all required delayed neutron precursor variables and
+ * kernels to the problem. Since the delayed neutron precursors transport
+ * problem is pure advection, the problem is solved using discontinous Galerkin
+ * as documented in:
+ * <a href="http://epubs.siam.org/doi/book/10.1137/1.9780898717440">
+ * Discontinuous Galerkin Methods for Solving Elliptic and Parabolic
+ * Equations: Theory and Implementation
+ * </a>
+ * Note that the flow velocity must be constant when using the DGAdvection
+ * or DGTemperatureAdvection. In order to vary to flow through a user-defined
+ * function, use DGFunctionAdvection or DGFunctionTemperatureAdvection.
+ */
 class PrecursorAction : public AddVariableAction
 {
 public:

include/auxkernels/FissionHeatSourceAux.h

@@ -9,6 +9,15 @@ class FissionHeatSourceAux;
 template <>
 InputParameters validParams<FissionHeatSourceAux>();
 
+/**
+ * computes the heating term due to fissions.
+ * \f[
+ *   \dot{Q} = \sum_g \phi_g \Sigma_{g,f} \q_{fiss}
+ * \f]
+ * Where \f$ q_{fiss} \f$ is the average heat produced per fission.
+ * Note that in particular, this kernel is not meant for transients and instead is for
+ * specifying the power through the "power" parameter.
+ */
 class FissionHeatSourceAux : public AuxKernel
 {
 public:

include/auxkernels/FissionHeatSourceTransientAux.h

@@ -9,6 +9,13 @@ class FissionHeatSourceTransientAux;
 template <>
 InputParameters validParams<FissionHeatSourceTransientAux>();
 
+/**
+ * Computes heat source due to fission during a transient.
+ * This is the same as FissionHeatSourceAux, but with the exception
+ * that the power is not normalized to some user-defined value. The reactor
+ * will produce heat freely. You'll probably see thermal feedback since MSRs are
+ * nice like that.
+ */
 class FissionHeatSourceTransientAux : public AuxKernel
 {
 public:

include/auxkernels/MatDiffusionAux.h

@@ -10,6 +10,14 @@ class MatDiffusionAux;
 template <>
 InputParameters validParams<MatDiffusionAux>();
 
+/**
+ * Computes the Euclidean norm of the flux of some diffusing variable at
+ * any point in space. In other words, this computes:
+ * \f[
+ *   | D \nabla f |
+ * \f]
+ * Where D is the diffusion coefficient and f is some scalar variable in the simulation.
+ */
 class MatDiffusionAux : public AuxKernel
 {
 public:

include/auxkernels/ModeratorHeatSourceTransientAux.h

@@ -9,6 +9,18 @@ class ModeratorHeatSourceTransientAux;
 template <>
 InputParameters validParams<ModeratorHeatSourceTransientAux>();
 
+/**
+ * When a reactor runs, gamma rays are emitted in extraordinary quantity.
+ * These gammas tend to heat the graphite in thermal MSRs, as experienced at the MSRE,
+ * and make the graphite's steady temperature quite a bit hotter than then the salt.
+ * ORNL found that gamma heating in graphite is nearly uniform over the core since gammas have
+ * a long mean free path. In addition, the gamma heating is proportional to the average fission
+ * heat. This kernel computes local gamma heating as a function of average fission heat and a
+ * user-defined proportionality factor (usually between 2 and 10 percent).
+ *
+ * Gamma can define a form factor for the gamma heating. That is, gamma heating can be set to be
+ * cosinusoidal or Bessel.
+ */
 class ModeratorHeatSourceTransientAux : public AuxKernel
 {
 public:

include/dirackernels/DiracHX.h

@@ -10,6 +10,16 @@ class DiracHX;
 template <>
 InputParameters validParams<DiracHX>();
 
+/**
+ * Provides a Dirac kernel for heating or cooling. At first,
+ * this was used to model a heat exchanger in the reactor primary
+ * loop. It was found that this didn't exactly provide the expected
+ * amount of cooling, so InterfaceHX or InterfaceEffectivenessHX should
+ * be used instead.
+ *
+ * This could still be a useful kernel for easily providing some point heat/
+ * cooling sources.
+ */
 class DiracHX : public DiracKernel
 {
 public:

include/kernels/CoupledFissionEigenKernel.h

@@ -10,6 +10,12 @@ class CoupledFissionEigenKernel;
 template <>
 InputParameters validParams<CoupledFissionEigenKernel>();
 
+/**
+ * Computes the fission source normalized by eigenvalue. In other words:
+ * \f[
+ *   \frac{1}{k} \sum_g \nu \Sigma_{g,f} \phi_g
+ * \f]
+ */
 class CoupledFissionEigenKernel : public EigenKernel, public ScalarTransportBase
 {
 public:

include/kernels/CoupledFissionKernel.h

@@ -10,6 +10,10 @@ class CoupledFissionKernel;
 template <>
 InputParameters validParams<CoupledFissionKernel>();
 
+/**
+ * Computes fission source of neutrons without normalizing by
+ * \f$ 1/k \f$. Note that this kernel is meant for transients.
+ */
 class CoupledFissionKernel : public Kernel, public ScalarTransportBase
 {
 public:

include/kernels/INSBoussinesqBodyForce.h

@@ -9,6 +9,11 @@ class INSBoussinesqBodyForce;
 template <>
 InputParameters validParams<INSBoussinesqBodyForce>();
 
+/**
+ * Computes a body force that approximates natural buoyancy in
+ * problems where there aren't very large variations in density.
+ * See <a href="https://en.wikipedia.org/wiki/Boussinesq_approximation_(buoyancy)"> wikipedia </a>.
+ */
 class INSBoussinesqBodyForce : public Kernel
 {
 public: