]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Improve the situation somewhat but deal.II/coarsening_02_1d is still failing, albeit...
authorbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 7 Oct 2008 03:07:03 +0000 (03:07 +0000)
committerbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 7 Oct 2008 03:07:03 +0000 (03:07 +0000)
git-svn-id: https://svn.dealii.org/trunk@17122 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/source/grid/tria.cc

index 5acf31085c060262a2a41d24665d962e53569a66..ff72bd46bcbf12d9e7526b9c8ea6c9fe2a723405 100644 (file)
@@ -10452,16 +10452,19 @@ void Triangulation<dim>::fix_coarsen_flags ()
       active_cell_iterator cell = begin_active(),
                           endc = end();
       for (; cell!=endc; ++cell)
-       for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell;
-            ++vertex)
+       {
          if (cell->refine_flag_set())
-           vertex_level[cell->vertex_index(vertex)]
-             = std::max (vertex_level[cell->vertex_index(vertex)],
-                         cell->level()+1);
+           for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell;
+                ++vertex)
+             vertex_level[cell->vertex_index(vertex)]
+               = std::max (vertex_level[cell->vertex_index(vertex)],
+                           cell->level()+1);
          else if (!cell->coarsen_flag_set())
-           vertex_level[cell->vertex_index(vertex)]
-             = std::max (vertex_level[cell->vertex_index(vertex)],
-                         cell->level());
+           for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell;
+                ++vertex)
+             vertex_level[cell->vertex_index(vertex)]
+               = std::max (vertex_level[cell->vertex_index(vertex)],
+                           cell->level());
          else
            {
                                               // if coarsen flag is set then
@@ -10472,10 +10475,13 @@ void Triangulation<dim>::fix_coarsen_flags ()
                                               // removed again) and so we may
                                               // make an error here
              Assert (cell->coarsen_flag_set(), ExcInternalError());
-             vertex_level[cell->vertex_index(vertex)]
-               = std::max (vertex_level[cell->vertex_index(vertex)],
-                           cell->level()-1);
+             for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell;
+                  ++vertex)
+               vertex_level[cell->vertex_index(vertex)]
+                 = std::max (vertex_level[cell->vertex_index(vertex)],
+                             cell->level()-1);
            }
+       }
       
 
                                       // loop over all cells in reverse
@@ -10492,47 +10498,41 @@ void Triangulation<dim>::fix_coarsen_flags ()
                                       // adjacent to vertices that will
                                       // see refinement
       for (cell=last_active(); cell != endc; --cell)
-       {
-         if (cell->coarsen_flag_set() == true)
-           {
-             for (unsigned int vertex=0;
-                  vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
-               if (vertex_level[cell->vertex_index(vertex)] >=
-                   cell->level()+1)
-                 {
-                   cell->clear_coarsen_flag();
-                   break;
-                 }
-           }
-         else if (cell->refine_flag_set() == false)
-           {
-             for (unsigned int vertex=0;
-                  vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
-               if (vertex_level[cell->vertex_index(vertex)] >
-                   cell->level()+1)
-                 {
-                                                    // refine cell
-                                                    // and update
-                                                    // vertex levels
-                   cell->clear_coarsen_flag();
-                   cell->set_refine_flag();
-
-                   for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell;
-                        ++v)
-                     vertex_level[cell->vertex_index(v)]
-                       = std::max (vertex_level[cell->vertex_index(v)],
-                                   cell->level()+1);
-
-                                                    // now that we
-                                                    // fixed this
-                                                    // cell, we can
-                                                    // safely leave
-                                                    // this inner
-                                                    // loop.
-                   break;
-                 }
-           }
-       }  
+       if (cell->refine_flag_set() == false)
+         {
+           for (unsigned int vertex=0;
+                vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+             if (vertex_level[cell->vertex_index(vertex)] >=
+                 cell->level()+1)
+               {
+                                                  // remove coarsen flag...
+                 cell->clear_coarsen_flag();
+
+                                                  // ...and if necessary also
+                                                  // refine the current cell,
+                                                  // at the same time
+                                                  // updating the level
+                                                  // information about
+                                                  // vertices
+                 if (vertex_level[cell->vertex_index(vertex)] >
+                     cell->level()+1)
+                   {
+                     cell->set_refine_flag();
+                     
+                     for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell;
+                          ++v)
+                       vertex_level[cell->vertex_index(v)]
+                         = std::max (vertex_level[cell->vertex_index(v)],
+                                     cell->level()+1);
+                   }
+
+                                                  // continue and see whether
+                                                  // we may, for example, go
+                                                  // into the inner 'if'
+                                                  // above based on a
+                                                  // different vertex
+               }
+         }
     }
   
                                   // loop over all cells. Flag all
@@ -11062,33 +11062,37 @@ bool Triangulation<dim>::prepare_coarsening_and_refinement ()
          active_cell_iterator cell = begin_active(),
                               endc = end();
          for (; cell!=endc; ++cell)
-           for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell;
-                ++vertex)
+           {
              if (cell->refine_flag_set())
-               vertex_level[cell->vertex_index(vertex)]
-                 = std::max (vertex_level[cell->vertex_index(vertex)],
-                             cell->level()+1);
+               for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell;
+                    ++vertex)
+                 vertex_level[cell->vertex_index(vertex)]
+                   = std::max (vertex_level[cell->vertex_index(vertex)],
+                               cell->level()+1);
              else if (!cell->coarsen_flag_set())
-               vertex_level[cell->vertex_index(vertex)]
-                 = std::max (vertex_level[cell->vertex_index(vertex)],
-                             cell->level());
+               for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell;
+                    ++vertex)
+                 vertex_level[cell->vertex_index(vertex)]
+                   = std::max (vertex_level[cell->vertex_index(vertex)],
+                               cell->level());
              else
                {
-                                                  // if coarsen flag is set
-                                                  // then tentatively assume
-                                                  // that the cell will be
-                                                  // coarsened. this isn't
-                                                  // always true (the coarsen
-                                                  // flag could be removed
-                                                  // again) and so we may
-                                                  // make an error here. we
-                                                  // hope we catch these
-                                                  // cases further down
+                                                  // if coarsen flag is set then
+                                                  // tentatively assume that the
+                                                  // cell will be coarsened. this
+                                                  // isn't always true (the
+                                                  // coarsen flag could be
+                                                  // removed again) and so we may
+                                                  // make an error here
                  Assert (cell->coarsen_flag_set(), ExcInternalError());
-                 vertex_level[cell->vertex_index(vertex)]
-                   = std::max (vertex_level[cell->vertex_index(vertex)],
-                               cell->level()-1);
+                 for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell;
+                      ++vertex)
+                   vertex_level[cell->vertex_index(vertex)]
+                     = std::max (vertex_level[cell->vertex_index(vertex)],
+                                 cell->level()-1);
                }
+           }
+      
 
                                           // loop over all cells in reverse
                                           // order. do so because we can then
@@ -11104,47 +11108,41 @@ bool Triangulation<dim>::prepare_coarsening_and_refinement ()
                                           // adjacent to vertices that will
                                           // see refinement
          for (cell=last_active(); cell != endc; --cell)
-           {
-             if (cell->coarsen_flag_set() == true)
-               {
-                 for (unsigned int vertex=0;
-                      vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
-                   if (vertex_level[cell->vertex_index(vertex)] >=
-                       cell->level()+1)
-                     {
-                       cell->clear_coarsen_flag();
-                       break;
-                     }
-               }
-             else if (cell->refine_flag_set() == false)
-               {
-                 for (unsigned int vertex=0;
-                      vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
-                   if (vertex_level[cell->vertex_index(vertex)] >
-                       cell->level()+1)
-                     {
-                                                        // refine cell
-                                                        // and update
-                                                        // vertex levels
-                       cell->clear_coarsen_flag();
-                       cell->set_refine_flag();
-
-                       for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell;
-                            ++v)
-                         vertex_level[cell->vertex_index(v)]
-                           = std::max (vertex_level[cell->vertex_index(v)],
-                                       cell->level()+1);
-
-                                                        // now that we
-                                                        // fixed this
-                                                        // cell, we can
-                                                        // safely leave
-                                                        // this inner
-                                                        // loop.
-                       break;
-                     }
-               }
-           }  
+           if (cell->refine_flag_set() == false)
+             {
+               for (unsigned int vertex=0;
+                    vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+                 if (vertex_level[cell->vertex_index(vertex)] >=
+                     cell->level()+1)
+                   {
+                                                      // remove coarsen flag...
+                     cell->clear_coarsen_flag();
+
+                                                      // ...and if necessary also
+                                                      // refine the current cell,
+                                                      // at the same time
+                                                      // updating the level
+                                                      // information about
+                                                      // vertices
+                     if (vertex_level[cell->vertex_index(vertex)] >
+                         cell->level()+1)
+                       {
+                         cell->set_refine_flag();
+                     
+                         for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell;
+                              ++v)
+                           vertex_level[cell->vertex_index(v)]
+                             = std::max (vertex_level[cell->vertex_index(v)],
+                                         cell->level()+1);
+                       }
+
+                                                      // continue and see whether
+                                                      // we may, for example, go
+                                                      // into the inner 'if'
+                                                      // above based on a
+                                                      // different vertex
+                   }
+             }
        }
 
                                       /////////////////////////////////////

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.