]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Remove occurances of /// in source/ 13204/head
authorSimon Sticko <simon@sticko.se>
Sat, 8 Jan 2022 20:41:51 +0000 (21:41 +0100)
committerSimon Sticko <simon@sticko.se>
Sat, 8 Jan 2022 20:41:51 +0000 (21:41 +0100)
To avoid them from showing up in the documentation.

include/deal.II/numerics/point_value_history.h
source/base/data_out_base.cc
source/base/function_lib.cc
source/base/function_lib_cutoff.cc
source/grid/grid_in.cc
source/grid/tria.cc
source/grid/tria_accessor.cc
source/numerics/point_value_history.cc

index abcc898e7715adfce5b946e79485bb33f3f90b65..21801e2babd7be5732087791449f5031393f8e22 100644 (file)
@@ -61,6 +61,9 @@ namespace internal
     class PointGeometryData
     {
     public:
+      /**
+       * Only a constructor needed for this class (a struct really)
+       */
       PointGeometryData(
         const Point<dim> &                          new_requested_location,
         const std::vector<Point<dim>> &             new_locations,
index 6a8269c712a4732453d7742ed62374fae43e4f4a..5b229d85a5a8909d6adcc5485a0d841daa3ef3a9 100644 (file)
@@ -16,7 +16,7 @@
 
 // TODO: Do neighbors for dx and povray smooth triangles
 
-//////////////////////////////////////////////////////////////////////
+//--------------------------------------------------------------------
 // Remarks on the implementations
 //
 // Variable names: in most functions, variable names have been
@@ -29,7 +29,7 @@
 //
 // d1, d2, di Multiplicators for ii to find positions in the
 //    array of nodes.
-//////////////////////////////////////////////////////////////////////
+//--------------------------------------------------------------------
 
 #include <deal.II/base/data_out_base.h>
 #include <deal.II/base/memory_consumption.h>
@@ -3348,7 +3348,7 @@ namespace DataOutBase
     unsigned int n_nodes;
     unsigned int n_cells;
     compute_sizes<dim, spacedim>(patches, n_nodes, n_cells);
-    ///////////////////////
+    //---------------------
     // preamble
     if (flags.write_preamble)
       {
@@ -3374,7 +3374,7 @@ namespace DataOutBase
     write_cells(patches, ucd_out);
     out << '\n';
 
-    /////////////////////////////
+    //---------------------------
     // now write data
     if (n_data_sets != 0)
       {
@@ -3456,10 +3456,10 @@ namespace DataOutBase
         write_nodes(patches, dx_out);
       }
 
-    ///////////////////////////////
+    //-----------------------------
     // first write the coordinates of all vertices
 
-    /////////////////////////////////////////
+    //---------------------------------------
     // write cells
     out << "object \"cells\" class array type int rank 1 shape "
         << GeometryInfo<dim>::vertices_per_cell << " items " << n_cells;
@@ -3487,7 +3487,7 @@ namespace DataOutBase
     out << "\"" << '\n' << "attribute \"ref\" string \"positions\"" << '\n';
 
     // TODO:[GK] Patches must be of same size!
-    /////////////////////////////
+    //---------------------------
     // write neighbor information
     if (flags.write_neighbors)
       {
@@ -3620,7 +3620,7 @@ namespace DataOutBase
             out << '\n';
           }
       }
-    /////////////////////////////
+    //---------------------------
     // now write data
     if (n_data_sets != 0)
       {
@@ -4821,7 +4821,7 @@ namespace DataOutBase
                                   n_data_sets,
                                 patches[0].data.n_rows()));
 
-    ///////////////////////
+    //---------------------
     // preamble
     out << "gmvinput ascii" << '\n' << '\n';
 
@@ -4849,7 +4849,7 @@ namespace DataOutBase
     Threads::Task<> reorder_task =
       Threads::new_task(fun_ptr, patches, data_vectors);
 
-    ///////////////////////////////
+    //-----------------------------
     // first make up a list of used vertices along with their coordinates
     //
     // note that we have to print 3 dimensions
@@ -4869,12 +4869,12 @@ namespace DataOutBase
         out << '\n';
       }
 
-    /////////////////////////////////
+    //-------------------------------
     // now for the cells. note that vertices are counted from 1 onwards
     out << "cells " << n_cells << '\n';
     write_cells(patches, gmv_out);
 
-    ///////////////////////////////////////
+    //-------------------------------------
     // data output.
     out << "variable" << '\n';
 
@@ -4962,7 +4962,7 @@ namespace DataOutBase
     unsigned int n_cells;
     compute_sizes<dim, spacedim>(patches, n_nodes, n_cells);
 
-    ///////////
+    //---------
     // preamble
     {
       out
@@ -5030,7 +5030,7 @@ namespace DataOutBase
     Threads::Task<> reorder_task =
       Threads::new_task(fun_ptr, patches, data_vectors);
 
-    ///////////////////////////////
+    //-----------------------------
     // first make up a list of used vertices along with their coordinates
 
 
@@ -5042,7 +5042,7 @@ namespace DataOutBase
       }
 
 
-    ///////////////////////////////////////
+    //-------------------------------------
     // data output.
     //
     // now write the data vectors to @p{out} first make sure that all data is in
@@ -5269,7 +5269,7 @@ namespace DataOutBase
     Threads::Task<> reorder_task =
       Threads::new_task(fun_ptr, patches, data_vectors);
 
-    ///////////////////////////////
+    //-----------------------------
     // first make up a list of used vertices along with their coordinates
     for (unsigned int d = 1; d <= spacedim; ++d)
       {
@@ -5339,7 +5339,7 @@ namespace DataOutBase
       }
 
 
-    ///////////////////////////////////////
+    //-------------------------------------
     // data output.
     //
     reorder_task.join();
@@ -5353,7 +5353,7 @@ namespace DataOutBase
 
 
 
-    /////////////////////////////////
+    //-------------------------------
     // now for the cells. note that vertices are counted from 1 onwards
     unsigned int first_vertex_of_patch = 0;
     unsigned int elem                  = 0;
@@ -5508,7 +5508,7 @@ namespace DataOutBase
         AssertDimension(n_data_sets, patches[0].data.n_rows())
       }
 
-    ///////////////////////
+    //---------------------
     // preamble
     {
       out << "# vtk DataFile Version 3.0" << '\n'
@@ -5575,14 +5575,14 @@ namespace DataOutBase
     Threads::Task<> reorder_task =
       Threads::new_task(fun_ptr, patches, data_vectors);
 
-    ///////////////////////////////
+    //-----------------------------
     // first make up a list of used vertices along with their coordinates
     //
     // note that we have to print d=1..3 dimensions
     out << "POINTS " << n_nodes << " double" << '\n';
     write_nodes(patches, vtk_out);
     out << '\n';
-    /////////////////////////////////
+    //-------------------------------
     // now for the cells
     out << "CELLS " << n_cells << ' ' << n_points_and_n_cells << '\n';
     if (flags.write_higher_order_cells)
@@ -5606,7 +5606,7 @@ namespace DataOutBase
       }
 
     out << '\n';
-    ///////////////////////////////////////
+    //-------------------------------------
     // data output.
 
     // now write the data vectors to @p{out} first make sure that all data is in
@@ -5956,7 +5956,7 @@ namespace DataOutBase
     Threads::Task<> reorder_task =
       Threads::new_task(fun_ptr, patches, data_vectors);
 
-    ///////////////////////////////
+    //-----------------------------
     // first make up a list of used vertices along with their coordinates
     //
     // note that according to the standard, we have to print d=1..3 dimensions,
@@ -5969,7 +5969,7 @@ namespace DataOutBase
     write_nodes(patches, vtu_out);
     out << "    </DataArray>\n";
     out << "  </Points>\n\n";
-    /////////////////////////////////
+    //-------------------------------
     // now for the cells
     out << "  <Cells>\n";
     out << "    <DataArray type=\"Int32\" Name=\"connectivity\" format=\""
@@ -6028,7 +6028,7 @@ namespace DataOutBase
     out << "  </Cells>\n";
 
 
-    ///////////////////////////////////////
+    //-------------------------------------
     // data output.
 
     // now write the data vectors to @p{out} first make sure that all data is in
index 2b94823f34cb2ba812962e2026010ad7a798e4ed..f0d70210594abbede87988d8cb3bc30b2c387030 100644 (file)
@@ -121,7 +121,7 @@ namespace Functions
   }
 
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
 
 
   template <int dim>
@@ -247,7 +247,7 @@ namespace Functions
   }
 
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
 
 
   template <int dim>
@@ -419,7 +419,7 @@ namespace Functions
       }
   }
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
 
   template <int dim>
   CosineFunction<dim>::CosineFunction(const unsigned int n_components)
@@ -709,7 +709,7 @@ namespace Functions
       }
   }
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
 
   template <int dim>
   CosineGradFunction<dim>::CosineGradFunction()
@@ -1012,7 +1012,7 @@ namespace Functions
   }
 
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
 
   template <int dim>
   double
@@ -1166,7 +1166,7 @@ namespace Functions
       }
   }
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
 
 
   double
@@ -1340,7 +1340,7 @@ namespace Functions
       }
   }
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
 
   LSingularityGradFunction::LSingularityGradFunction()
     : Function<2>(2)
@@ -1467,7 +1467,7 @@ namespace Functions
     Assert(false, ExcNotImplemented());
   }
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
 
   template <int dim>
   double
@@ -1637,7 +1637,7 @@ namespace Functions
       }
   }
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
 
 
   double
@@ -1797,7 +1797,7 @@ namespace Functions
       }
   }
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
 
   template <int dim>
   JumpFunction<dim>::JumpFunction(const Point<dim> &direction,
index 4a32cd03cb8911ff5cb3462b12a76ad70b11ebd7..b6f0e1ee0453b701b0ae3a8edd32e0ae2decfe75 100644 (file)
@@ -174,7 +174,7 @@ namespace Functions
 
 
 
-  //////////////////////////////////////////////////////////////////////
+  //--------------------------------------------------------------------
   namespace
   {
     // Integral of CutOffFunctionLinfty in dimension 1, 2, and 3 when the radius
index 748896737206a3e87b8f8f96b829401290b80eba..43dbe4bb2f3f4b03651df12d59e5654b4487f1e9 100644 (file)
@@ -154,7 +154,7 @@ GridIn<dim, spacedim>::read_vtk(std::istream &in)
       }
   }
 
-  ///////////////////Declaring storage and mappings//////////////////
+  //-----------------Declaring storage and mappings------------------
 
   std::vector<Point<spacedim>> vertices;
   std::vector<CellData<dim>>   cells;
@@ -164,7 +164,7 @@ GridIn<dim, spacedim>::read_vtk(std::istream &in)
 
   in >> keyword;
 
-  //////////////////Processing the POINTS section///////////////
+  //----------------Processing the POINTS section---------------
 
   if (keyword == "POINTS")
     {
index 203a31d9d17ad2f88ae09d6eb9e7b6d8f268419a..77845fcc54dcbd28becfad6762581674bc803f68 100644 (file)
@@ -1838,7 +1838,7 @@ namespace internal
         // no cells at all?
         Assert(number_cache.n_levels > 0, ExcInternalError());
 
-        ///////////////////////////////////
+        //---------------------------------
         // update the number of lines on the different levels in the
         // cache
         number_cache.n_lines        = 0;
@@ -1930,7 +1930,7 @@ namespace internal
         using quad_iterator =
           typename Triangulation<dim, spacedim>::quad_iterator;
 
-        ///////////////////////////////////
+        //---------------------------------
         // update the number of quads on the different levels in the
         // cache
         number_cache.n_quads        = 0;
@@ -2037,7 +2037,7 @@ namespace internal
         using hex_iterator =
           typename Triangulation<dim, spacedim>::hex_iterator;
 
-        ///////////////////////////////////
+        //---------------------------------
         // update the number of hexes on the different levels in the
         // cache
         number_cache.n_hexes        = 0;
@@ -3034,7 +3034,7 @@ namespace internal
               --quad_cell_count[child->quad_index(f)];
           }
 
-        ///////////////////////////////////////
+        //-------------------------------------
         // delete interior quads and lines and the
         // interior vertex, depending on the
         // refinement case of the cell
@@ -5214,7 +5214,7 @@ namespace internal
             triangulation.vertices_used.resize(needed_vertices, false);
           }
 
-          ///////////////////////////////////////////
+          //-----------------------------------------
           // Before we start with the actual refinement, we do some
           // sanity checks if in debug mode. especially, we try to catch
           // the notorious problem with lines being twice refined,
@@ -6586,7 +6586,7 @@ namespace internal
           }
 
 
-          ///////////////////////////////////////////
+          //-----------------------------------------
           // Before we start with the actual refinement, we do some
           // sanity checks if in debug mode. especially, we try to catch
           // the notorious problem with lines being twice refined,
@@ -6608,7 +6608,7 @@ namespace internal
                          ExcInternalError());
 #endif
 
-        ///////////////////////////////////////////
+        //-----------------------------------------
         // Do refinement on every level
         //
         // To make life a bit easier, we first refine those lines and
@@ -6695,9 +6695,9 @@ namespace internal
         }
 
 
-        ///////////////////////////////////////
+        //-------------------------------------
         // now refine marked quads
-        ///////////////////////////////////////
+        //-------------------------------------
 
         // here we encounter several cases:
 
@@ -7595,10 +7595,10 @@ namespace internal
               }     // for all quads
           }         // looped two times over all quads, all quads refined now
 
-        ///////////////////////////////////
+        //---------------------------------
         // Now, finally, set up the new
         // cells
-        ///////////////////////////////////
+        //---------------------------------
 
         typename Triangulation<3, spacedim>::DistortedCellList
           cells_with_distorted_children;
@@ -7819,7 +7819,7 @@ namespace internal
                      {1, 0}}}; // RefinementCase<dim>::cut_y, face_flip=true,
                                // face_rotation=false and true
 
-                  ///////////////////////////////////////
+                  //-------------------------------------
                   //
                   // in the following we will do the same thing for
                   // each refinement case: create a new vertex (if
@@ -7838,7 +7838,7 @@ namespace internal
                     {
                       case RefinementCase<dim>::cut_x:
                         {
-                          //////////////////////////////
+                          //----------------------------
                           //
                           //     RefinementCase<dim>::cut_x
                           //
@@ -8060,7 +8060,7 @@ namespace internal
 
                       case RefinementCase<dim>::cut_y:
                         {
-                          //////////////////////////////
+                          //----------------------------
                           //
                           //     RefinementCase<dim>::cut_y
                           //
@@ -8286,7 +8286,7 @@ namespace internal
 
                       case RefinementCase<dim>::cut_z:
                         {
-                          //////////////////////////////
+                          //----------------------------
                           //
                           //     RefinementCase<dim>::cut_z
                           //
@@ -8514,7 +8514,7 @@ namespace internal
 
                       case RefinementCase<dim>::cut_xy:
                         {
-                          //////////////////////////////
+                          //----------------------------
                           //
                           //     RefinementCase<dim>::cut_xy
                           //
@@ -8948,7 +8948,7 @@ namespace internal
 
                       case RefinementCase<dim>::cut_xz:
                         {
-                          //////////////////////////////
+                          //----------------------------
                           //
                           //     RefinementCase<dim>::cut_xz
                           //
@@ -9392,7 +9392,7 @@ namespace internal
 
                       case RefinementCase<dim>::cut_yz:
                         {
-                          //////////////////////////////
+                          //----------------------------
                           //
                           //     RefinementCase<dim>::cut_yz
                           //
@@ -9825,7 +9825,7 @@ namespace internal
 
                       case RefinementCase<dim>::cut_xyz:
                         {
-                          //////////////////////////////
+                          //----------------------------
                           //
                           //     RefinementCase<dim>::cut_xyz
                           //     isotropic refinement
@@ -10349,7 +10349,7 @@ namespace internal
                           new_quads[11]->set_line_orientation(
                             3, line_orientation[13]);
 
-                          /////////////////////////////////
+                          //-------------------------------
                           // create the eight new hexes
                           //
                           // again first collect some data.  here, we need
@@ -15359,7 +15359,7 @@ Triangulation<dim, spacedim>::prepare_coarsening_and_refinement()
   // needs also take care that it won't tag cells for refinement for
   // which some neighbors are more refined or will be refined.
 
-  //////////////////////////////////////
+  //------------------------------------
   // STEP 0:
   //    Only if coarsest_level_1 or patch_level_1 is set: clear all
   //    coarsen flags on level 1 to avoid level 0 cells being created
@@ -15374,7 +15374,7 @@ Triangulation<dim, spacedim>::prepare_coarsening_and_refinement()
   bool mesh_changed_in_this_loop = false;
   do
     {
-      //////////////////////////////////////
+      //------------------------------------
       // STEP 1:
       //    do not coarsen a cell if 'most of the neighbors' will be
       //    refined after the step. This is to prevent the occurrence
@@ -15393,7 +15393,7 @@ Triangulation<dim, spacedim>::prepare_coarsening_and_refinement()
         }
 
 
-      //////////////////////////////////////
+      //------------------------------------
       // STEP 2:
       //    eliminate refined islands in the interior and at the
       //    boundary. since they don't do much harm besides increasing
@@ -15507,7 +15507,7 @@ Triangulation<dim, spacedim>::prepare_coarsening_and_refinement()
               }
         }
 
-      //////////////////////////////////////
+      //------------------------------------
       // STEP 3:
       //    limit the level difference of neighboring cells at each
       //    vertex.
@@ -15599,7 +15599,7 @@ Triangulation<dim, spacedim>::prepare_coarsening_and_refinement()
               }
         }
 
-      /////////////////////////////////////
+      //-----------------------------------
       // STEP 4:
       //    eliminate unrefined islands. this has higher priority
       //    since this diminishes the approximation properties not
@@ -15620,7 +15620,7 @@ Triangulation<dim, spacedim>::prepare_coarsening_and_refinement()
                 cell, (smooth_grid & allow_anisotropic_smoothing) != 0);
         }
 
-      /////////////////////////////////
+      //-------------------------------
       // STEP 5:
       //    ensure patch level 1.
       //
@@ -15769,7 +15769,7 @@ Triangulation<dim, spacedim>::prepare_coarsening_and_refinement()
             }
         }
 
-      //////////////////////////////////
+      //--------------------------------
       //
       //  at the boundary we could end up with cells with negative
       //  volume or at least with a part, that is negative, if the
@@ -15777,7 +15777,7 @@ Triangulation<dim, spacedim>::prepare_coarsening_and_refinement()
       //  that can happen
       this->policy->prevent_distorted_boundary_cells(*this);
 
-      /////////////////////////////////
+      //-------------------------------
       // STEP 6:
       //    take care of the requirement that no
       //    double refinement is done at each face
@@ -16232,14 +16232,14 @@ Triangulation<dim, spacedim>::prepare_coarsening_and_refinement()
               }
         }
 
-      //////////////////////////////////////
+      //------------------------------------
       // STEP 7:
       //    take care that no double refinement
       //    is done at each line in 3d or higher
       //    dimensions.
       this->policy->prepare_refinement_dim_dependent(*this);
 
-      //////////////////////////////////////
+      //------------------------------------
       // STEP 8:
       //    make sure that all children of each
       //    cell are either flagged for coarsening
index 0afb2f58823483bf21c53230393d02a03dd64278..66281eedb6868bbd27f6b50b09c185c8057c61ec 100644 (file)
@@ -1671,8 +1671,8 @@ double
 TriaAccessor<2, 2, 2>::extent_in_direction(const unsigned int axis) const
 {
   const unsigned int lines[2][2] = {
-    {2, 3},  /// Lines along x-axis, see GeometryInfo
-    {0, 1}}; /// Lines along y-axis
+    {2, 3},  //  Lines along x-axis, see GeometryInfo
+    {0, 1}}; //  Lines along y-axis
 
   AssertIndexRange(axis, 2);
 
@@ -1685,8 +1685,8 @@ double
 TriaAccessor<2, 2, 3>::extent_in_direction(const unsigned int axis) const
 {
   const unsigned int lines[2][2] = {
-    {2, 3},  /// Lines along x-axis, see GeometryInfo
-    {0, 1}}; /// Lines along y-axis
+    {2, 3},  //  Lines along x-axis, see GeometryInfo
+    {0, 1}}; //  Lines along y-axis
 
   AssertIndexRange(axis, 2);
 
@@ -1700,9 +1700,9 @@ double
 TriaAccessor<3, 3, 3>::extent_in_direction(const unsigned int axis) const
 {
   const unsigned int lines[3][4] = {
-    {2, 3, 6, 7},    /// Lines along x-axis, see GeometryInfo
-    {0, 1, 4, 5},    /// Lines along y-axis
-    {8, 9, 10, 11}}; /// Lines along z-axis
+    {2, 3, 6, 7},    // Lines along x-axis, see GeometryInfo
+    {0, 1, 4, 5},    // Lines along y-axis
+    {8, 9, 10, 11}}; // Lines along z-axis
 
   AssertIndexRange(axis, 3);
 
index 4571d27ba724a019fd99009af2679147560d252b..b43e38edbaa8ec80b0ef9867b36acac505ec8d58 100644 (file)
@@ -38,7 +38,6 @@ namespace internal
 {
   namespace PointValueHistoryImplementation
   {
-    /// Only a constructor needed for this class (a struct really)
     template <int dim>
     PointGeometryData<dim>::PointGeometryData(
       const Point<dim> &                          new_requested_location,

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.