]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Add documentation for enumerations. 3699/head
authorDavid Wells <wellsd2@rpi.edu>
Thu, 22 Dec 2016 18:28:08 +0000 (13:28 -0500)
committerDavid Wells <wellsd2@rpi.edu>
Fri, 23 Dec 2016 02:51:47 +0000 (21:51 -0500)
Individual values in an enumeration will not show up in doxygen unless
they have a documentation string, so add a little description for each
enumeration value.

23 files changed:
include/deal.II/base/exceptions.h
include/deal.II/base/geometry_info.h
include/deal.II/base/parameter_handler.h
include/deal.II/base/quadrature_lib.h
include/deal.II/base/table_handler.h
include/deal.II/base/timer.h
include/deal.II/fe/fe_base.h
include/deal.II/fe/fe_update_flags.h
include/deal.II/grid/grid_out.h
include/deal.II/grid/tria_accessor.h
include/deal.II/lac/arpack_solver.h
include/deal.II/lac/parpack_solver.h
include/deal.II/lac/sparse_vanka.h
include/deal.II/lac/trilinos_solver.h
include/deal.II/lac/vector.h
include/deal.II/matrix_free/fe_evaluation.h
include/deal.II/matrix_free/helper_functions.h
include/deal.II/matrix_free/matrix_free.h
include/deal.II/meshworker/loop.h
include/deal.II/numerics/data_out_stack.h
include/deal.II/numerics/histogram.h
include/deal.II/numerics/solution_transfer.h
include/deal.II/numerics/time_dependent.h

index ae3e10f9c2574e6fa29e36b3a6e284ab5a63b32d..4846a17ee7af449b3ac4412af178b3fd75812d9b 100644 (file)
@@ -224,26 +224,40 @@ namespace deal_II_exceptions
     /**
      * Conditionally abort the program.
      *
-     * Depending on whether disable_abort_on_exception was called, this
-     * function either aborts the program flow by printing the error message
-     * provided by @p exc and calling <tt>std::abort()</tt>, or throws @p exc
-     * instead (if @p nothrow is set to <tt>false</tt>).
+     * Depending on whether deal_II_exceptions::disable_abort_on_exception was
+     * called, this function either aborts the program flow by printing the
+     * error message provided by @p exc and calling <tt>std::abort()</tt>, or
+     * throws @p exc instead (if @p nothrow is set to <tt>false</tt>).
      *
-     * If the boolean @p nothrow is set to true and disable_abort_on_exception
-     * was called, the exception type is just printed to deallog and program
-     * flow continues. This is useful if throwing an exception is prohibited
+     * If the boolean @p nothrow is set to true and
+     * deal_II_exceptions::disable_abort_on_exception was called, the
+     * exception type is just printed to deallog and program flow
+     * continues. This is useful if throwing an exception is prohibited
      * (e.g. in a destructor with <tt>noexcept(true)</tt> or
      * <tt>throw()</tt>).
      */
     void abort (const ExceptionBase &exc, bool nothrow = false);
 
     /**
-     * An enum describing how to treat an exception in issue_error
+     * An enum describing how to treat an exception in issue_error.
      */
     enum ExceptionHandling
     {
+      /**
+       * Abort the program by calling <code>std::abort</code> unless
+       * deal_II_exceptions::disable_abort_on_exception has been called: in
+       * that case the program will throw an exception.
+       */
       abort_on_exception,
+      /**
+       * Throw the exception normally.
+       */
       throw_on_exception,
+      /**
+       * Call <code>std::abort</code> as long as
+       * deal_II_exceptions::disable_abort_on_exception has not been called:
+       * if it has, then just print a description of the exception to deallog.
+       */
       abort_nothrow_on_exception
     };
 
index 71f850db4553ea4a5277e7e1bc742d890d68147e..9c52e86764ae0aaec2237f033afeaa9f06797d7f 100644 (file)
@@ -52,9 +52,21 @@ public:
    */
   enum Object
   {
+    /**
+     * A vertex.
+     */
     vertex = 0,
+    /**
+     * A line.
+     */
     line   = 1,
+    /**
+     * A quadrilateral.
+     */
     quad   = 2,
+    /**
+     * A hexahedron.
+     */
     hex    = 3
   };
 
@@ -139,8 +151,14 @@ struct RefinementPossibilities
    */
   enum Possibilities
   {
-    no_refinement= 0,
+    /**
+     * Do not perform refinement.
+     */
+    no_refinement = 0,
 
+    /**
+     * Perform isotropic refinement.
+     */
     isotropic_refinement = static_cast<unsigned char>(-1)
   };
 };
@@ -196,9 +214,17 @@ struct RefinementPossibilities<1>
    */
   enum Possibilities
   {
-    no_refinement= 0,
+    /**
+     * Do not refine.
+     */
+    no_refinement = 0,
+    /**
+     * Perform a cut in the x-direction.
+     */
     cut_x        = 1,
-
+    /**
+     * Perform isotropic refinement.
+     */
     isotropic_refinement = cut_x
   };
 };
@@ -255,11 +281,26 @@ struct RefinementPossibilities<2>
    */
   enum Possibilities
   {
-    no_refinement= 0,
-    cut_x        = 1,
-    cut_y        = 2,
-    cut_xy       = cut_x | cut_y,
+    /**
+     * Do not refine.
+     */
+    no_refinement = 0,
+    /**
+     * Perform a cut in the x-direction.
+     */
+    cut_x         = 1,
+    /**
+     * Perform a cut in the y-direction.
+     */
+    cut_y         = 2,
+    /**
+     * Perform cuts in the x- and y-directions.
+     */
+    cut_xy        = cut_x | cut_y,
 
+    /**
+     * Perform isotropic refinement.
+     */
     isotropic_refinement = cut_xy
   };
 };
@@ -316,15 +357,42 @@ struct RefinementPossibilities<3>
    */
   enum Possibilities
   {
-    no_refinement= 0,
-    cut_x        = 1,
-    cut_y        = 2,
-    cut_xy       = cut_x | cut_y,
-    cut_z        = 4,
-    cut_xz       = cut_x | cut_z,
-    cut_yz       = cut_y | cut_z,
-    cut_xyz      = cut_x | cut_y | cut_z,
+    /**
+     * Do not refine.
+     */
+    no_refinement = 0,
+    /**
+     * Perform a cut in the x-direction.
+     */
+    cut_x         = 1,
+    /**
+     * Perform a cut in the y-direction.
+     */
+    cut_y         = 2,
+    /**
+     * Perform a cut in the x and y-directions.
+     */
+    cut_xy        = cut_x | cut_y,
+    /**
+     * Perform a cut in the z-direction.
+     */
+    cut_z         = 4,
+    /**
+     * Perform a cuts in the x- and y-directions.
+     */
+    cut_xz        = cut_x | cut_z,
+    /**
+     * Perform a cuts in the x- and y-directions.
+     */
+    cut_yz        = cut_y | cut_z,
+    /**
+     * Perform a cuts in the x-, y-, and z-directions.
+     */
+    cut_xyz       = cut_x | cut_y | cut_z,
 
+    /**
+     * Perform isotropic refinement.
+     */
     isotropic_refinement = cut_xyz
   };
 };
@@ -470,8 +538,14 @@ namespace internal
      */
     enum Possibilities
     {
+      /**
+       * Do not refine.
+       */
       case_none = 0,
 
+      /**
+       * Refine isotropically.
+       */
       case_isotropic = static_cast<unsigned char>(-1)
     };
   };
@@ -496,8 +570,14 @@ namespace internal
      */
     enum Possibilities
     {
+      /**
+       * Do not refine.
+       */
       case_none = 0,
 
+      /**
+       * Refine isotropically.
+       */
       case_isotropic = case_none
     };
   };
@@ -524,8 +604,14 @@ namespace internal
      */
     enum Possibilities
     {
+      /**
+       * Do not refine.
+       */
       case_none = 0,
 
+      /**
+       * Refine isotropically.
+       */
       case_isotropic = case_none
     };
   };
@@ -554,9 +640,17 @@ namespace internal
      */
     enum Possibilities
     {
+      /**
+       * Do not refine.
+       */
       case_none = 0,
+      /**
+       * Cut in the x-direction.
+       */
       case_x    = 1,
-
+      /**
+       * Refine isotropically.
+       */
       case_isotropic = case_x
     };
   };
index f395c5e463bc851f13936d9fe85b8a36c18caec3..1178195a181d197d11d1cf5f766ecedefee6bb88 100644 (file)
@@ -791,7 +791,17 @@ namespace Patterns
      * Files can be used for input or output. This can be specified in the
      * constructor by choosing the flag <tt>type</tt>.
      */
-    enum FileType {input = 0, output = 1};
+    enum FileType
+    {
+      /**
+       * Open for input.
+       */
+      input = 0,
+      /**
+       * Open for output.
+       */
+      output = 1
+    };
 
     /**
      * Constructor.  The type of the file can be specified by choosing the
@@ -2548,7 +2558,14 @@ private:
      */
     enum MultipleEntryType
     {
-      variant, array
+      /**
+       * A variant entry.
+       */
+      variant,
+      /**
+       * An array entry.
+       */
+      array
     };
 
     /**
index 67c3cf0b35fe48a22fee609dad0210934a25dfc3..d9c879223d4824911637757bfb73d88f27c64e1b 100644 (file)
@@ -583,7 +583,17 @@ public:
   /* EndPoint is used to specify which of the two endpoints of the unit interval
    * is used also as quadrature point
    */
-  enum EndPoint { left,right };
+  enum EndPoint
+  {
+    /**
+     * Left end point.
+     */
+    left,
+    /**
+     * Right end point.
+     */
+    right
+  };
   /// Generate a formula with <tt>n</tt> quadrature points
   QGaussRadauChebyshev(const unsigned int n,
                        EndPoint ep=QGaussRadauChebyshev::left);
index d5fed63aa162f2fb7c76ce034bc804aadc6bcf01..76cbee05d29fd856ba84cbc625a833da46542d6c 100644 (file)
@@ -322,9 +322,22 @@ public:
    */
   enum TextOutputFormat
   {
+    /**
+     * Print the table with headers.
+     */
     table_with_headers,
+    /**
+     * Print the table with separate lines for each column label.
+     */
     table_with_separate_column_description,
+    /**
+     * Like table_with_separate_column_description, but without aligning the
+     * column containing the column labels.
+     */
     simple_table_with_separate_column_description,
+    /**
+     * Print the table in org mode format.
+     */
     org_mode_table
   };
 
index 0692aabf6ee3202ce29827f1eb8e9b79221ff1d4..ac2c028b09e5c7d211aedd4f362b7a0c68c69f6c 100644 (file)
@@ -431,9 +431,21 @@ public:
    */
   enum OutputFrequency
   {
+    /**
+     * Generate output after every call.
+     */
     every_call,
+    /**
+     * Generate output in summary at the end.
+     */
     summary,
+    /**
+     * Generate output both after every call and in summary at the end.
+     */
     every_call_and_summary,
+    /**
+     * Never generate any output.
+     */
     never
   };
 
@@ -443,8 +455,17 @@ public:
    */
   enum OutputType
   {
+    /**
+     * Output CPU times.
+     */
     cpu_times,
+    /**
+     * Output wall clock times.
+     */
     wall_times,
+    /**
+     * Output both CPU and wall clock times.
+     */
     cpu_and_wall_times
   };
 
index 97dc0f283514d2cd243527759a98333a1c1e7d91..626fb3177c0a70070e54591c90e21b4c86b91a54 100644 (file)
@@ -94,10 +94,25 @@ namespace FiniteElementDomination
    */
   enum Domination
   {
+    /**
+     * The current element dominates.
+     */
     this_element_dominates,
+    /**
+     * The other element dominates.
+     */
     other_element_dominates,
+    /**
+     * Neither element dominates.
+     */
     neither_element_dominates,
+    /**
+     * Either element may dominate.
+     */
     either_element_can_dominate,
+    /**
+     * There are no requirements.
+     */
     no_requirements
   };
 
index 54772165818d9c32337c62584ca767bd569040d9..e094f8618e53189fa46abd8268d1117745d8e7cd 100644 (file)
@@ -355,9 +355,22 @@ namespace CellSimilarity
 {
   enum Similarity
   {
+    /**
+     * The cells differ by something besides a translation or inverted
+     * translations.
+     */
     none,
+    /**
+     * The cells differ by a translation.
+     */
     translation,
+    /**
+     * The cells differ by an inverted translation.
+     */
     inverted_translation,
+    /**
+     * The next cell is not valid.
+     */
     invalid_next_cell
   };
 }
index bb9c89dc32b1f25b5e7f0256988d80d57fc15eab..2cd4a58d815c071b4e7b5afcfc8c6bd973dea952 100644 (file)
@@ -285,7 +285,14 @@ namespace GridOutFlags
      */
     enum SizeType
     {
-      width, height
+      /**
+       * Scale with the width.
+       */
+      width,
+      /**
+       * Scale with the height.
+       */
+      height
     };
 
     /**
index 8bb37682bc45c21ab8e6ff39aa8d0ab9d2b3c0e7..5f2f0a9e63f85f074e82223fd6e8d2854ee48b9d 100644 (file)
@@ -1860,8 +1860,17 @@ public:
    */
   enum VertexKind
   {
+    /**
+     * Left vertex.
+     */
     left_vertex,
+    /**
+     * Interior vertex.
+     */
     interior_vertex,
+    /**
+     * Right vertex.
+     */
     right_vertex
   };
 
index 887e358d67d6a8fca3b051ef58c5d55d6f7e79a3..4fba4b6ec977a08408d6422e5473b1b3f945ff3a 100644 (file)
@@ -118,14 +118,44 @@ public:
    */
   enum WhichEigenvalues
   {
+    /**
+     * The algebraically largest eigenvalues.
+     */
     algebraically_largest,
+    /**
+     * The algebraically smallest eigenvalues.
+     */
     algebraically_smallest,
+    /**
+     * The eigenvalue with the largest magnitudes.
+     */
     largest_magnitude,
+    /**
+     * The eigenvalue with the smallest magnitudes.
+     */
     smallest_magnitude,
+    /**
+     * The eigenvalues with the largest real parts.
+     */
     largest_real_part,
+    /**
+     * The eigenvalues with the smallest real parts.
+     */
     smallest_real_part,
+    /**
+     * The eigenvalues with the largest imaginary parts.
+     */
     largest_imaginary_part,
+    /**
+     * The eigenvalues with the smallest imaginary parts.
+     */
     smallest_imaginary_part,
+    /**
+     * Compute half of the eigenvalues from the high end of the spectrum and
+     * the other half from the low end. If the number of requested
+     * eigenvectors is odd, then the extra eigenvector comes from the high end
+     * of the spectrum.
+     */
     both_ends
   };
 
index fe49ef86a3f22a1d46f75fd35c14599cc2055314..2280f686c82a4c5480da10a2be8934e7988b88ca 100644 (file)
@@ -160,14 +160,44 @@ public:
    */
   enum WhichEigenvalues
   {
+    /**
+     * The algebraically largest eigenvalues.
+     */
     algebraically_largest,
+    /**
+     * The algebraically smallest eigenvalues.
+     */
     algebraically_smallest,
+    /**
+     * The eigenvalue with the largest magnitudes.
+     */
     largest_magnitude,
+    /**
+     * The eigenvalue with the smallest magnitudes.
+     */
     smallest_magnitude,
+    /**
+     * The eigenvalues with the largest real parts.
+     */
     largest_real_part,
+    /**
+     * The eigenvalues with the smallest real parts.
+     */
     smallest_real_part,
+    /**
+     * The eigenvalues with the largest imaginary parts.
+     */
     largest_imaginary_part,
+    /**
+     * The eigenvalues with the smallest imaginary parts.
+     */
     smallest_imaginary_part,
+    /**
+     * Compute half of the eigenvalues from the high end of the spectrum and
+     * the other half from the low end. If the number of requested
+     * eigenvectors is odd, then the extra eigenvector comes from the high end
+     * of the spectrum.
+     */
     both_ends
   };
 
index 553bfec9a62e07d1ea559d85f24a4de29c0e2d30..0b4319b2c7857599dc1ef9455415b1b0f7c8a50b 100644 (file)
@@ -517,7 +517,14 @@ public:
    */
   enum BlockingStrategy
   {
-    index_intervals, adaptive
+    /**
+     * Block by index intervals.
+     */
+    index_intervals,
+    /**
+     * Block with an adaptive strategy.
+     */
+    adaptive
   };
 
   /**
index dc9902e608150852b7611025f7f80dcc5d204536..44798f1a98bd537bad70d461cad7b8c3b8331fde 100644 (file)
@@ -74,7 +74,29 @@ namespace TrilinosWrappers
      * one of the specialized derived classes when the solver should be set at
      * runtime. Currently enabled options are:
      */
-    enum SolverName {cg, cgs, gmres, bicgstab, tfqmr} solver_name;
+    enum SolverName
+    {
+      /**
+       * Use the conjugate gradient (CG) algorithm.
+       */
+      cg,
+      /**
+       * Use the conjugate gradient squared (CGS) algorithm.
+       */
+      cgs,
+      /**
+       * Use the generalized minimum residual (GMRES) algorithm.
+       */
+      gmres,
+      /**
+       * Use the biconjugate gradient stabilized (BICGStab) algorithm.
+       */
+      bicgstab,
+      /**
+       * Use the transpose-free quasi-minimal residual (TFQMR) method.
+       */
+      tfqmr
+    } solver_name;
 
     /**
      * Standardized data struct to pipe additional data to the solver.
index 8a141b455dad6f53f68f3cd654b4bf188ec897e8..c6af741f76b3914fa342397d4a788e0c7da845aa 100644 (file)
@@ -88,7 +88,21 @@ namespace parallel
  */
 struct VectorOperation
 {
-  enum values { unknown, insert, add };
+  enum values
+  {
+    /**
+     * The current operation is unknown.
+     */
+    unknown,
+    /**
+     * The current operation is an insertion.
+     */
+    insert,
+    /**
+     * The current operation is an addition.
+     */
+    add
+  };
 };
 
 
index cf88f73523a0f22706126bdd87343d13909b25af..ca1e3af0aeaf904ba3b5a7451dc2a76dfb8a3c94 100644 (file)
@@ -5013,8 +5013,22 @@ namespace internal
    */
   enum EvaluatorVariant
   {
+    /**
+     * Do not use anything more than the tensor product structure of the
+     * finite element.
+     */
     evaluate_general,
+    /**
+     * Perform evaluation by exploiting symmetry in the finite element: i.e.,
+     * skip some computations by utilizing the symmetry in the shape functions
+     * and quadrature points.
+     */
     evaluate_symmetric,
+    /**
+     * Use symmetry to apply the operator to even and odd parts of the input
+     * vector separately: see the documentation of the EvaluatorTensorProduct
+     * specialization for more information.
+     */
     evaluate_evenodd
   };
 
index f6aeffbae8ef6a095273602e11b80e244604c6da..7766dbbba14fa0529d8be3ace5b203aa48f21a4f 100644 (file)
@@ -135,7 +135,26 @@ namespace internal
     /**
      * Data type to identify cell type.
      */
-    enum CellType {cartesian=0, affine=1, general=2, undefined=3};
+    enum CellType
+    {
+      /**
+       * The cell is Cartesian.
+       */
+      cartesian = 0,
+      /**
+       * The cell may be described with an affine mapping.
+       */
+      affine    = 1,
+      /**
+       * There is no special information available for compressing the
+       * representation of the cell.
+       */
+      general   = 2,
+      /**
+       * The cell type is undefined.
+       */
+      undefined = 3
+    };
 
 
     /**
index d2e1e9c4a1f2015121c20129886291964a0afca8..b9515d756af6cf38df1cf428e278b2382bb6c5e8 100644 (file)
@@ -138,9 +138,30 @@ public:
   struct AdditionalData
   {
     /**
-     * Collects options for task parallelism.
+     * Collects options for task parallelism. See the documentation of the
+     * member variable MatrixFree::AdditionalData::tasks_parallel_scheme for a
+     * thorough description.
      */
-    enum TasksParallelScheme {none, partition_partition, partition_color, color};
+    enum TasksParallelScheme
+    {
+      /**
+       * Perform application in serial.
+       */
+      none,
+      /**
+       * Partition the cells into two levels and afterwards form chunks.
+       */
+      partition_partition,
+      /**
+       * Partition on the global level and color cells within the partitions.
+       */
+      partition_color,
+      /**
+       * Use the traditional coloring algorithm: this is like
+       * TasksParallelScheme::partition_color, but only uses one partition.
+       */
+      color
+    };
 
     /**
      * Constructor for AdditionalData.
@@ -879,7 +900,17 @@ private:
 
     std::vector<SmartPointer<const DoFHandler<dim> > >   dof_handler;
     std::vector<SmartPointer<const hp::DoFHandler<dim> > > hp_dof_handler;
-    enum ActiveDoFHandler { usual, hp } active_dof_handler;
+    enum ActiveDoFHandler
+    {
+      /**
+       * Use DoFHandler.
+       */
+      usual,
+      /**
+       * Use hp::DoFHandler.
+       */
+      hp
+    } active_dof_handler;
     unsigned int n_dof_handlers;
     unsigned int level;
   };
index 7f5a5df30fe09967f36488ef833af6723f23128f..f61db468b6302a6a0d8957cad8d9adcb4f42a149 100644 (file)
@@ -95,10 +95,24 @@ namespace MeshWorker
      */
     bool ghost_cells;
 
+    /**
+     * Enumeration describing when to do assembly on a face: see, e.g.,
+     * MeshWorker::LoopControl::faces_to_ghost for an example of how the value
+     * of this enumeration is interpreted in a particular circumstance.
+     */
     enum FaceOption
     {
+      /**
+       * Do not perform assembly on a face.
+       */
       never,
+      /**
+       * Perform assembly on one face.
+       */
       one,
+      /**
+       * Perform assembly on both faces.
+       */
       both
     };
 
index 4a1e071d066f5ce7e425d2459b57316fb441a99c..d3fe8e8fb8dece42c065d3f35fd96472aebe9436 100644 (file)
@@ -113,7 +113,17 @@ public:
    * Data type declaring the two types of vectors which are used in this
    * class.
    */
-  enum VectorType { cell_vector, dof_vector };
+  enum VectorType
+  {
+    /**
+     * The data describes one value for each cell.
+     */
+    cell_vector,
+    /**
+     * The data describes one value for each DoF.
+     */
+    dof_vector
+  };
 
   /**
    * Destructor. Only declared to make it @p virtual.
index fb8588633a7618cef114b531396c6c6ee2ea2a7b..344643e18b3edc2a948a28f2f06a653765494d34 100644 (file)
@@ -74,7 +74,14 @@ public:
    */
   enum IntervalSpacing
   {
-    linear, logarithmic
+    /**
+     * Space intervals linearly.
+     */
+    linear,
+    /**
+     * Space intervals logarithmically.
+     */
+    logarithmic
   };
 
 
index 524e164148c69cb034c643ebb637b0896aecec2a..ea494bad977d41389594de5bf380c6360e5d3f87 100644 (file)
@@ -433,7 +433,18 @@ private:
    */
   enum PreparationState
   {
-    none, pure_refinement, coarsening_and_refinement
+    /**
+     * The SolutionTransfer is not yet prepared.
+     */
+    none,
+    /**
+     * The SolutionTransfer is prepared for purely refinement.
+     */
+    pure_refinement,
+    /**
+     * The SolutionTransfer is prepared for coarsening and refinement.
+     */
+    coarsening_and_refinement
   };
 
   /**
index 660e2cede61d17c12bd332dad3a96964d0bb01e0..912cd19d7807d8ee485e0f13e89c1b3b88ef1a91 100644 (file)
@@ -408,7 +408,14 @@ public:
    */
   enum Direction
   {
-    forward, backward
+    /**
+     * Go in the forward direction.
+     */
+    forward,
+    /**
+     * Go in the backward direction.
+     */
+    backward
   };
 
   /**
@@ -643,8 +650,17 @@ public:
    */
   enum SolutionState
   {
+    /**
+     * Solve the primal problem next.
+     */
     primal_problem = 0x0,
+    /**
+     * Solve the dual problem next.
+     */
     dual_problem   = 0x1,
+    /**
+     * Perform postprocessing next.
+     */
     postprocess    = 0x2
   };
 
@@ -1272,6 +1288,9 @@ public:
    */
   enum SolutionState
   {
+    /**
+     * Perform grid refinement next.
+     */
     grid_refinement = 0x1000
   };
 

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.