From: guido Date: Thu, 13 Jul 2000 19:56:08 +0000 (+0000) Subject: Downstream numbering for DG X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=4f5e990afaa739a940f17f4e9ccbc4e6cc780bee;p=dealii-svn.git Downstream numbering for DG git-svn-id: https://svn.dealii.org/trunk@3158 0785d39b-7218-0410-832d-ea1e28bc413d --- diff --git a/deal.II/deal.II/include/numerics/dof_renumbering.h b/deal.II/deal.II/include/numerics/dof_renumbering.h index 6d3d61e495..e4ad5aa13a 100644 --- a/deal.II/deal.II/include/numerics/dof_renumbering.h +++ b/deal.II/deal.II/include/numerics/dof_renumbering.h @@ -165,7 +165,7 @@ * degrees of freedom. This renumbering may only exchange whole blocks * and must not destroy the block structure. * - * Given an ordered vector of cells, the function @p{cell_wise} + * Given an ordered vector of cells, the function @p{cell_wise_dg} * accomplishes this. Inside the cells, the previous ordering will be * preserved, so it may be useful to apply @component_wise} first. * @@ -278,12 +278,44 @@ class DoFRenumbering * freedom have to be associated * with the interior of the cell. */ - template< int dim> + template static void - cell_wise (DoFHandler &dof_handler, - const vector > &cell_order); + cell_wise_dg (DoFHandler &dof_handler, + const vector::cell_iterator> &cell_order); + /** + * Cell-wise downstream numbering + * with respect to a constant + * flow direction. + * + * The cells are sorted such that + * the centers of higher numbers + * are further downstream with + * respect to the constant vector + * @p{direction} than the centers + * of lower numbers. Even if this + * yields a downstream numbering + * with respect to the flux on + * the edges for fairly general + * grids, this might not be + * guaranteed for all meshes. + * + * This function produces a + * downstream ordering of the + * mesh cells and calls + * @ref{cell_wise_dg}. + * Therefore, it only works with + * Discontinuous Galerkin Finite + * Elements, i.e. all degrees of + * freedom have to be associated + * with the interior of the cell. + */ + template + static void + downstream_dg (DoFHandler &dof_handler, + const Point &direction); + /** * Sort those degrees of freedom * which are tagged with @p{true} @@ -299,8 +331,8 @@ class DoFRenumbering */ template static void - sort_selected_dofs_back (const vector &selected_dofs, - DoFHandler &dof_handler); + sort_selected_dofs_back (DoFHandler &dof_handler, + const vector &selected_dofs); /** * Exception diff --git a/deal.II/deal.II/source/dofs/dof_renumbering.cc b/deal.II/deal.II/source/dofs/dof_renumbering.cc index ae82208b61..bb9ae94807 100644 --- a/deal.II/deal.II/source/dofs/dof_renumbering.cc +++ b/deal.II/deal.II/source/dofs/dof_renumbering.cc @@ -501,8 +501,8 @@ void DoFRenumbering::component_wise (DoFHandler &dof_handler, template void -DoFRenumbering::sort_selected_dofs_back (const vector &selected_dofs, - DoFHandler &dof_handler) +DoFRenumbering::sort_selected_dofs_back (DoFHandler &dof_handler, + const vector &selected_dofs) { const unsigned int n_dofs = dof_handler.n_dofs(); Assert (selected_dofs.size() == n_dofs, @@ -538,8 +538,8 @@ DoFRenumbering::sort_selected_dofs_back (const vector &selected_dofs, template void -DoFRenumbering::cell_wise (DoFHandler& dof, - const vector >& cells) +DoFRenumbering::cell_wise_dg (DoFHandler& dof, + const vector::cell_iterator>& cells) { Assert(cells.size() == dof.get_tria().n_active_cells(), ExcDimensionMismatch(cells.size(), @@ -565,18 +565,74 @@ DoFRenumbering::cell_wise (DoFHandler& dof, unsigned int global_index = 0; - typename vector >::const_iterator cell; + typename vector::cell_iterator>::const_iterator cell; for(cell = cells.begin(); cell != cells.end(); ++cell) { - cell->get_dof_indices(cell_dofs); + (*cell)->get_dof_indices(cell_dofs); sort(cell_dofs.begin(), cell_dofs.end()); - + for (unsigned int i=0;i reverse(new_order.size()); + + for (unsigned int i=0;i +struct CompCells +{ + /** + * Flow direction. + */ + const Point& dir; + /** + * Constructor. + */ + CompCells (const Point& dir) : + dir(dir) + {} + /** + * Return true if c1 < c2. + */ + bool operator () (const typename DoFHandler::cell_iterator& c1, + const typename DoFHandler::cell_iterator&c2) const + { + Point diff = c2->center() - c1->center(); + double s = diff*dir; + return (s>0); + } +}; + + +template +void +DoFRenumbering::downstream_dg (DoFHandler& dof, + const Point& direction) +{ + vector::cell_iterator> + ordered_cells(dof.get_tria().n_active_cells()); + CompCells comparator(direction); + + typename DoFHandler::active_cell_iterator begin = dof.begin_active(); + typename DoFHandler::active_cell_iterator end = dof.end(); + + copy (begin, end, ordered_cells.begin()); + sort (ordered_cells.begin(), ordered_cells.end(), comparator); + + cell_wise_dg(dof, ordered_cells); } @@ -600,11 +656,13 @@ void DoFRenumbering::component_wise (DoFHandler&, template -void DoFRenumbering::cell_wise (DoFHandler&, - const vector >&); - +void DoFRenumbering::cell_wise_dg (DoFHandler&, + const vector::cell_iterator>&); +template +void DoFRenumbering::downstream_dg (DoFHandler&, + const Point&); template -void DoFRenumbering::sort_selected_dofs_back (const vector &, - DoFHandler &); +void DoFRenumbering::sort_selected_dofs_back (DoFHandler &, + const vector &);