From: Spencer Patty Date: Fri, 5 Feb 2016 04:13:42 +0000 (-0600) Subject: make various comment and naming changes based on discussion in pull request X-Git-Tag: v8.4.0-rc2~19^2~6 X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=46ce46c429bd7b3b151930864213442a1d47d8a0;p=dealii.git make various comment and naming changes based on discussion in pull request --- diff --git a/include/deal.II/grid/grid_tools.h b/include/deal.II/grid/grid_tools.h index 77dfe71e48..f51b4b9041 100644 --- a/include/deal.II/grid/grid_tools.h +++ b/include/deal.II/grid/grid_tools.h @@ -1092,26 +1092,33 @@ namespace GridTools * parallel:distributed::Triangulation are supported and handled * appropriately. * - * It is necessary that the finite element underlying the Container used has - * degrees of freedom on faces (2d or 3d) and lines (in 3d). This unfortunately - * precludes the FE_DGQ finite element. Likewise, the finite element - * must have nodal basis elements for this implementation to make sense. - * - * @tparam Container The Container could be a DoFHandler or hp::DoFHandler. - * @param[in] dof_handler The Container which could be built on a Triangulation - * or a parallel:distributed::Triangulation and should be using a nodal - * finite element with degrees of freedom defined on faces (2d or 3d) and - * lines (3d). - * @param[out] dof_to_support_patch_map A map from the global_dof_index of dofs on locally relevant cells - * to vectors containing Container::active_cell_iterators of + * It is necessary that the finite element underlying the MeshType used has + * degrees of freedom that are logically associated to a vertex, line, quad, + * or hex. This includes both nodal degrees of freedom and other modal types + * of dofs that are associated to an edge, etc. The result is the patch of + * cells representing the support of the basis element associated to the + * degree of freedom. For instance using an FE_Q finite element, we obtain + * the standard patch of cells touching the degree of freedom and then others + * that take care of possible hanging node constraints. Using a FE_DGQ finite + * element, the degrees of freedom are logically considered to be "interior" to + * the cells so the patch would be the cell on which the degree of freedom is + * located. + * + * @tparam MeshType The MeshType should be a DoFHandler or hp::DoFHandler. + * @param[in] dof_handler The MeshType which could be built on a Triangulation + * or a parallel::distributed::Triangulation and should be using a finite + * element that has degrees of freedom that are logically associated to a vertex, + * line, quad, or hex. + * @param[out] dof_to_support_patch_map A map from the global_dof_index of DoFs + * on locally relevant cells to vectors containing MeshType::active_cell_iterators of * cells in support of basis function at that degree of freedom. * * @author Spencer Patty, 2016 * */ - template - std::map< types::global_dof_index,std::vector > - get_dof_to_support_patch_map(Container &dof_handler); + template + std::map< types::global_dof_index,std::vector > + get_dof_to_support_patch_map(MeshType &dof_handler); /*@}*/ diff --git a/source/grid/grid_tools.cc b/source/grid/grid_tools.cc index 141882bcd9..6511c18b2e 100644 --- a/source/grid/grid_tools.cc +++ b/source/grid/grid_tools.cc @@ -3049,13 +3049,11 @@ next_cell: - template - std::map< types::global_dof_index,std::vector > - get_dof_to_support_patch_map(Container &dof_handler) + template + std::map< types::global_dof_index,std::vector > + get_dof_to_support_patch_map(MeshType &dof_handler) { - // TODO: Add Assert( fe is not dg) - // This is the map from global_dof_index to // a set of cells on patch. We first map into // a set because it is very likely that we @@ -3066,18 +3064,18 @@ next_cell: // constructed, we will copy to a map of vectors // since that is the prefered output for other // functions. - std::map< types::global_dof_index,std::set > dof_to_set_of_cells_map; + std::map< types::global_dof_index,std::set > dof_to_set_of_cells_map; - std::vector local_dof_index; - std::vector local_face_dof_index; - std::vector local_line_dof_index; + std::vector local_dof_indices; + std::vector local_face_dof_indices; + std::vector local_line_dof_indices; // in 3d, we need pointers from active lines to the // active parent lines, so we construct it as needed. - std::map lines_to_parent_lines_map; - if (Container::dimension == 3) + std::map lines_to_parent_lines_map; + if (MeshType::dimension == 3) { - typename Container::active_cell_iterator cell = dof_handler.begin_active(), + typename MeshType::active_cell_iterator cell = dof_handler.begin_active(), endc = dof_handler.end(); for (; cell!=endc; ++cell) { @@ -3087,7 +3085,7 @@ next_cell: // few and we don't have to use them. if (cell->is_artificial() == false) { - for (unsigned int l=0; l::lines_per_cell; ++l) + for (unsigned int l=0; l::lines_per_cell; ++l) if (cell->line(l)->has_children()) for (unsigned int c=0; cline(l)->n_children(); ++c) { @@ -3107,7 +3105,7 @@ next_cell: // which it is a part, mainly the ones that must // be added on account of adaptivity hanging node // constraints. - typename Container::active_cell_iterator cell = dof_handler.begin_active(), + typename MeshType::active_cell_iterator cell = dof_handler.begin_active(), endc = dof_handler.end(); for (; cell!=endc; ++cell) { @@ -3117,13 +3115,13 @@ next_cell: if (cell->is_artificial() == false) { const unsigned int n_dofs_per_cell = cell->get_fe().dofs_per_cell; - local_dof_index.resize(n_dofs_per_cell); + local_dof_indices.resize(n_dofs_per_cell); // Take care of adding cell pointer to each // dofs that exists on cell. - cell->get_dof_indices(local_dof_index); + cell->get_dof_indices(local_dof_indices); for (unsigned int i=0; i< n_dofs_per_cell; ++i ) - dof_to_set_of_cells_map[local_dof_index[i]].insert(cell); + dof_to_set_of_cells_map[local_dof_indices[i]].insert(cell); // In the case of the adjacent cell (over // faces or edges) being more refined, we @@ -3133,7 +3131,7 @@ next_cell: // face (or line). // Take care of dofs on neighbor faces - for (unsigned int f=0; f::faces_per_cell; ++f) + for (unsigned int f=0; f::faces_per_cell; ++f) { if (cell->face(f)->has_children()) { @@ -3154,11 +3152,11 @@ next_cell: Assert (cell->face(f)->child(c)->has_children() == false, ExcInternalError()); const unsigned int n_dofs_per_face = cell->get_fe().dofs_per_face; - local_face_dof_index.resize(n_dofs_per_face); + local_face_dof_indices.resize(n_dofs_per_face); - cell->face(f)->child(c)->get_dof_indices(local_face_dof_index); + cell->face(f)->child(c)->get_dof_indices(local_face_dof_indices); for (unsigned int i=0; i< n_dofs_per_face; ++i ) - dof_to_set_of_cells_map[local_face_dof_index[i]].insert(cell); + dof_to_set_of_cells_map[local_face_dof_indices[i]].insert(cell); } } else if ((cell->face(f)->at_boundary() == false) && (cell->neighbor_is_coarser(f))) @@ -3184,11 +3182,11 @@ next_cell: unsigned int subface = neighbor_face_no_subface_no.second; const unsigned int n_dofs_per_face = cell->get_fe().dofs_per_face; - local_face_dof_index.resize(n_dofs_per_face); + local_face_dof_indices.resize(n_dofs_per_face); - cell->neighbor(f)->face(face_no)->get_dof_indices(local_face_dof_index); + cell->neighbor(f)->face(face_no)->get_dof_indices(local_face_dof_indices); for (unsigned int i=0; i< n_dofs_per_face; ++i ) - dof_to_set_of_cells_map[local_face_dof_index[i]].insert(cell); + dof_to_set_of_cells_map[local_face_dof_indices[i]].insert(cell); // Add cell to all dofs of children of // parent face @@ -3197,12 +3195,12 @@ next_cell: if (c != subface) // don't repeat work on dofs of original cell { const unsigned int n_dofs_per_face = cell->get_fe().dofs_per_face; - local_face_dof_index.resize(n_dofs_per_face); + local_face_dof_indices.resize(n_dofs_per_face); Assert (cell->neighbor(f)->face(face_no)->child(c)->has_children() == false, ExcInternalError()); - cell->neighbor(f)->face(face_no)->child(c)->get_dof_indices(local_face_dof_index); + cell->neighbor(f)->face(face_no)->child(c)->get_dof_indices(local_face_dof_indices); for (unsigned int i=0; i::lines_per_cell; ++l) + for (unsigned int l=0; l::lines_per_cell; ++l) { if (cell->line(l)->has_children()) { @@ -3230,11 +3228,11 @@ next_cell: // on line not including the vertices of the line. const unsigned int n_dofs_per_line = 2*cell->get_fe().dofs_per_vertex + cell->get_fe().dofs_per_line; - local_line_dof_index.resize(n_dofs_per_line); + local_line_dof_indices.resize(n_dofs_per_line); - cell->line(l)->child(c)->get_dof_indices(local_line_dof_index); + cell->line(l)->child(c)->get_dof_indices(local_line_dof_indices); for (unsigned int i=0; iline(l)->user_flag_set() == true) { - typename Container::line_iterator parent_line = lines_to_parent_lines_map[cell->line(l)]; + typename MeshType::line_iterator parent_line = lines_to_parent_lines_map[cell->line(l)]; Assert (parent_line->has_children(), ExcInternalError() ); // dofs_per_line returns number of dofs // on line not including the vertices of the line. const unsigned int n_dofs_per_line = 2*cell->get_fe().dofs_per_vertex + cell->get_fe().dofs_per_line; - local_line_dof_index.resize(n_dofs_per_line); + local_line_dof_indices.resize(n_dofs_per_line); - parent_line->get_dof_indices(local_line_dof_index); + parent_line->get_dof_indices(local_line_dof_indices); for (unsigned int i=0; in_children(); ++c) { @@ -3262,11 +3260,11 @@ next_cell: const unsigned int n_dofs_per_line = 2*cell->get_fe().dofs_per_vertex + cell->get_fe().dofs_per_line; - local_line_dof_index.resize(n_dofs_per_line); + local_line_dof_indices.resize(n_dofs_per_line); - parent_line->child(c)->get_dof_indices(local_line_dof_index); + parent_line->child(c)->get_dof_indices(local_line_dof_indices); for (unsigned int i=0; iline(l)->clear_user_flag(); } } // for lines l - }// if Container::dimension == 3 + }// if MeshType::dimension == 3 }// if cell->is_locally_owned() }// for cells // Finally, we copy map of sets to // map of vectors using assign() - std::map< types::global_dof_index, std::vector > dof_to_cell_patches; + std::map< types::global_dof_index, std::vector > dof_to_cell_patches; - typename std::map >::iterator + typename std::map >::iterator it = dof_to_set_of_cells_map.begin(), it_end = dof_to_set_of_cells_map.end(); for ( ; it!=it_end; ++it)