From: Simon Sticko Date: Sat, 8 Jan 2022 20:41:51 +0000 (+0100) Subject: Remove occurances of /// in source/ X-Git-Tag: v9.4.0-rc1~644^2 X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6957fd834df708ade2b212ea3bf1f241e81495d4;p=dealii.git Remove occurances of /// in source/ To avoid them from showing up in the documentation. --- diff --git a/include/deal.II/numerics/point_value_history.h b/include/deal.II/numerics/point_value_history.h index abcc898e77..21801e2bab 100644 --- a/include/deal.II/numerics/point_value_history.h +++ b/include/deal.II/numerics/point_value_history.h @@ -61,6 +61,9 @@ namespace internal class PointGeometryData { public: + /** + * Only a constructor needed for this class (a struct really) + */ PointGeometryData( const Point & new_requested_location, const std::vector> & new_locations, diff --git a/source/base/data_out_base.cc b/source/base/data_out_base.cc index 6a8269c712..5b229d85a5 100644 --- a/source/base/data_out_base.cc +++ b/source/base/data_out_base.cc @@ -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 #include @@ -3348,7 +3348,7 @@ namespace DataOutBase unsigned int n_nodes; unsigned int n_cells; compute_sizes(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::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(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 << " \n"; out << " \n\n"; - ///////////////////////////////// + //------------------------------- // now for the cells out << " \n"; out << " \n"; - /////////////////////////////////////// + //------------------------------------- // data output. // now write the data vectors to @p{out} first make sure that all data is in diff --git a/source/base/function_lib.cc b/source/base/function_lib.cc index 2b94823f34..f0d7021059 100644 --- a/source/base/function_lib.cc +++ b/source/base/function_lib.cc @@ -121,7 +121,7 @@ namespace Functions } - ////////////////////////////////////////////////////////////////////// + //-------------------------------------------------------------------- template @@ -247,7 +247,7 @@ namespace Functions } - ////////////////////////////////////////////////////////////////////// + //-------------------------------------------------------------------- template @@ -419,7 +419,7 @@ namespace Functions } } - ////////////////////////////////////////////////////////////////////// + //-------------------------------------------------------------------- template CosineFunction::CosineFunction(const unsigned int n_components) @@ -709,7 +709,7 @@ namespace Functions } } - ////////////////////////////////////////////////////////////////////// + //-------------------------------------------------------------------- template CosineGradFunction::CosineGradFunction() @@ -1012,7 +1012,7 @@ namespace Functions } - ////////////////////////////////////////////////////////////////////// + //-------------------------------------------------------------------- template 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 double @@ -1637,7 +1637,7 @@ namespace Functions } } - ////////////////////////////////////////////////////////////////////// + //-------------------------------------------------------------------- double @@ -1797,7 +1797,7 @@ namespace Functions } } - ////////////////////////////////////////////////////////////////////// + //-------------------------------------------------------------------- template JumpFunction::JumpFunction(const Point &direction, diff --git a/source/base/function_lib_cutoff.cc b/source/base/function_lib_cutoff.cc index 4a32cd03cb..b6f0e1ee04 100644 --- a/source/base/function_lib_cutoff.cc +++ b/source/base/function_lib_cutoff.cc @@ -174,7 +174,7 @@ namespace Functions - ////////////////////////////////////////////////////////////////////// + //-------------------------------------------------------------------- namespace { // Integral of CutOffFunctionLinfty in dimension 1, 2, and 3 when the radius diff --git a/source/grid/grid_in.cc b/source/grid/grid_in.cc index 7488967372..43dbe4bb2f 100644 --- a/source/grid/grid_in.cc +++ b/source/grid/grid_in.cc @@ -154,7 +154,7 @@ GridIn::read_vtk(std::istream &in) } } - ///////////////////Declaring storage and mappings////////////////// + //-----------------Declaring storage and mappings------------------ std::vector> vertices; std::vector> cells; @@ -164,7 +164,7 @@ GridIn::read_vtk(std::istream &in) in >> keyword; - //////////////////Processing the POINTS section/////////////// + //----------------Processing the POINTS section--------------- if (keyword == "POINTS") { diff --git a/source/grid/tria.cc b/source/grid/tria.cc index 203a31d9d1..77845fcc54 100644 --- a/source/grid/tria.cc +++ b/source/grid/tria.cc @@ -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::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::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::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::cut_x: { - ////////////////////////////// + //---------------------------- // // RefinementCase::cut_x // @@ -8060,7 +8060,7 @@ namespace internal case RefinementCase::cut_y: { - ////////////////////////////// + //---------------------------- // // RefinementCase::cut_y // @@ -8286,7 +8286,7 @@ namespace internal case RefinementCase::cut_z: { - ////////////////////////////// + //---------------------------- // // RefinementCase::cut_z // @@ -8514,7 +8514,7 @@ namespace internal case RefinementCase::cut_xy: { - ////////////////////////////// + //---------------------------- // // RefinementCase::cut_xy // @@ -8948,7 +8948,7 @@ namespace internal case RefinementCase::cut_xz: { - ////////////////////////////// + //---------------------------- // // RefinementCase::cut_xz // @@ -9392,7 +9392,7 @@ namespace internal case RefinementCase::cut_yz: { - ////////////////////////////// + //---------------------------- // // RefinementCase::cut_yz // @@ -9825,7 +9825,7 @@ namespace internal case RefinementCase::cut_xyz: { - ////////////////////////////// + //---------------------------- // // RefinementCase::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::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::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::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::prepare_coarsening_and_refinement() } } - ////////////////////////////////////// + //------------------------------------ // STEP 3: // limit the level difference of neighboring cells at each // vertex. @@ -15599,7 +15599,7 @@ Triangulation::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::prepare_coarsening_and_refinement() cell, (smooth_grid & allow_anisotropic_smoothing) != 0); } - ///////////////////////////////// + //------------------------------- // STEP 5: // ensure patch level 1. // @@ -15769,7 +15769,7 @@ Triangulation::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::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::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 diff --git a/source/grid/tria_accessor.cc b/source/grid/tria_accessor.cc index 0afb2f5882..66281eedb6 100644 --- a/source/grid/tria_accessor.cc +++ b/source/grid/tria_accessor.cc @@ -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); diff --git a/source/numerics/point_value_history.cc b/source/numerics/point_value_history.cc index 4571d27ba7..b43e38edba 100644 --- a/source/numerics/point_value_history.cc +++ b/source/numerics/point_value_history.cc @@ -38,7 +38,6 @@ namespace internal { namespace PointValueHistoryImplementation { - /// Only a constructor needed for this class (a struct really) template PointGeometryData::PointGeometryData( const Point & new_requested_location,