// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
//
//---------------------------------------------------------------------------
-
-/*
- * Single out some functions which are needed by all dimensions, but
- * which are not template. They thus have the same name and when we
- * try to link with the libraries for different dimensions at the same
- * time, we get linker errors for functions defined more than once. By
- * putting these functions in a single file, the linker is allowed to
- * use it only once and throw away all other versions of this file in
- * the other libraries.
- */
-
-
#include <base/memory_consumption.h>
#include <grid/tria.h>
#include <grid/tria_levels.h>
+#include <grid/tria_faces.h>
#include <grid/tria_boundary.h>
+#include <grid/tria_accessor.h>
+#include <grid/tria_iterator.h>
+#include <base/geometry_info.h>
+#include <grid/grid_tools.h>
+#include <grid/magic_numbers.h>
+#include <fe/mapping_q1.h>
+#include <lac/vector.h>
+#include <algorithm>
#include <numeric>
+#include <map>
+#include <cmath>
+#include <functional>
-DEAL_II_NAMESPACE_OPEN
-
+#include <base/std_cxx1x/array.h>
+DEAL_II_NAMESPACE_OPEN
bool
SubCellData::check_consistency (const unsigned int dim) const
}
}
+// anonymous namespace for internal helper functions
+namespace
+{
+ // return whether the given cell is
+ // patch_level_1, i.e. determine
+ // whether either all or none of
+ // its children are further
+ // refined. this function can only
+ // be called for non-active cells.
+ template <int dim, int spacedim>
+ bool cell_is_patch_level_1 (const TriaIterator<dealii::CellAccessor<dim, spacedim> > &cell)
+ {
+ Assert (cell->active() == false, ExcInternalError());
+
+ unsigned int n_active_children = 0;
+ for (unsigned int i=0; i<cell->n_children(); ++i)
+ if (cell->child(i)->active())
+ ++n_active_children;
+
+ return (n_active_children == 0) || (n_active_children == cell->n_children());
+ }
+
+
+
+ // return, wheter a given @p cell will be
+ // coarsened, which is the case if all
+ // children are active and have their coarsen
+ // flag set. In case only part of the coarsen
+ // flags are set, remove them.
+ template <int dim, int spacedim>
+ bool cell_will_be_coarsened (const TriaIterator<dealii::CellAccessor<dim,spacedim> > &cell)
+ {
+ // only cells with children should be
+ // considered for coarsening
+
+ if (cell->has_children())
+ {
+ unsigned int children_to_coarsen=0;
+ const unsigned int n_children=cell->n_children();
+
+ for (unsigned int c=0; c<n_children; ++c)
+ if (cell->child(c)->active() &&
+ cell->child(c)->coarsen_flag_set())
+ ++children_to_coarsen;
+ if (children_to_coarsen==n_children)
+ return true;
+ else
+ for (unsigned int c=0; c<n_children; ++c)
+ if (cell->child(c)->active())
+ cell->child(c)->clear_coarsen_flag();
+ }
+ // no children, so no coarsening
+ // possible. however, no children also
+ // means that this cell will be in the same
+ // state as if it had children and was
+ // coarsened. So, what should we return -
+ // false or true?
+ // make sure we do not have to do this at
+ // all...
+ Assert(cell->has_children(), ExcInternalError());
+ // ... and then simply return false
+ return false;
+ }
+
+
+ // return, whether the face @p face_no of the
+ // given @p cell will be refined after the
+ // current refinement step, considering
+ // refine and coarsen flags and considering
+ // only those refinemnts that will be caused
+ // by the neighboring cell.
+
+ // this function is used on both active cells
+ // and cells with children. on cells with
+ // children it also of interest to know 'how'
+ // the face will be refined. thus there is an
+ // additional third argument @p
+ // expected_face_ref_case returning just
+ // that. be aware, that this vriable will
+ // only contain useful information if this
+ // function is called for an active cell.
+ //
+ // thus, this is an internal function, users
+ // should call one of the two alternatives
+ // following below.
+ template <int dim, int spacedim>
+ bool
+ face_will_be_refined_by_neighbor_internal(const TriaIterator<dealii::CellAccessor<dim,spacedim> > &cell,
+ const unsigned int face_no,
+ RefinementCase<dim-1> &expected_face_ref_case)
+ {
+ // first of all: set the default value for
+ // expected_face_ref_case, which is no
+ // refinement at all
+ expected_face_ref_case=RefinementCase<dim-1>::no_refinement;
+
+ const typename Triangulation<dim,spacedim>::cell_iterator neighbor=cell->neighbor(face_no);
+
+ // If we are at the boundary, there is no
+ // neighbor which could refine the face
+ if (neighbor.state()!=IteratorState::valid)
+ return false;
+
+ if (neighbor->has_children())
+ {
+ // if the neighbor is refined, it may be
+ // coarsened. if so, then it won't refine
+ // the face, no matter what else happens
+ if (cell_will_be_coarsened(neighbor))
+ return false;
+ else
+ // if the neighor is refined, then he
+ // is also refined at our current
+ // face. He will stay so without
+ // coarsening, so return true in that
+ // case.
+ {
+ expected_face_ref_case=cell->face(face_no)->refinement_case();
+ return true;
+ }
+ }
+
+ // now, the neighbor is not refined, but
+ // perhaps he will be
+ const RefinementCase<dim> nb_ref_flag=neighbor->refine_flag_set();
+ if (nb_ref_flag != RefinementCase<dim>::no_refinement)
+ {
+ // now we need to know, which of the
+ // neighbors faces points towards us
+ const unsigned int neighbor_neighbor=cell->neighbor_face_no(face_no);
+ // check, whether the cell will be
+ // refined in a way that refines our
+ // face
+ const RefinementCase<dim-1> face_ref_case=
+ GeometryInfo<dim>::face_refinement_case(nb_ref_flag,
+ neighbor_neighbor,
+ neighbor->face_orientation(neighbor_neighbor),
+ neighbor->face_flip(neighbor_neighbor),
+ neighbor->face_rotation(neighbor_neighbor));
+ if (face_ref_case != RefinementCase<dim-1>::no_refinement)
+ {
+ const typename Triangulation<dim,spacedim>::face_iterator neighbor_face=neighbor->face(neighbor_neighbor);
+ const int this_face_index=cell->face_index(face_no);
+
+ // there are still two basic
+ // possibilities here: the neighbor
+ // might be coarser or as coarse
+ // as we are
+ if (neighbor_face->index()==this_face_index)
+ // the neighbor is as coarse as
+ // we are and will be refined at
+ // the face of consideration, so
+ // return true
+ {
+ expected_face_ref_case = face_ref_case;
+ return true;
+ }
+ else
+ {
+
+ // the neighbor is coarser.
+ // this is the most complicated
+ // case. It might be, that the
+ // neighbor's face will be
+ // refined, but that we will
+ // not see this, as we are
+ // refined in a similar way.
+
+ // so, the neighbor's face must
+ // have children. check, if our
+ // cell's face is one of these
+ // (it could also be a
+ // grand_child)
+ for (unsigned int c=0; c<neighbor_face->n_children(); ++c)
+ if (neighbor_face->child_index(c)==this_face_index)
+ {
+ // if the flagged refine
+ // case of the face is a
+ // subset or the same as
+ // the current refine case,
+ // then the face, as seen
+ // from our cell, won't be
+ // refined by the neighbor
+ if ((neighbor_face->refinement_case() | face_ref_case)
+ == neighbor_face->refinement_case())
+ return false;
+ else
+ {
+ // if we are active, we
+ // must be an
+ // anisotropic child
+ // and the coming
+ // face_ref_case is
+ // isotropic. Thus,
+ // from our cell we
+ // will see exactly the
+ // opposite refine case
+ // that the face has
+ // now...
+ Assert(face_ref_case==RefinementCase<dim-1>::isotropic_refinement, ExcInternalError());
+ expected_face_ref_case = ~neighbor_face->refinement_case();
+ return true;
+ }
+ }
+
+ // so, obviously we were not
+ // one of the children, but a
+ // grandchild. This is only
+ // possible in 3d.
+ Assert(dim==3, ExcInternalError());
+ // In that case, however, no
+ // matter what the neighbor
+ // does, he won't be finer
+ // after the next refinement
+ // step.
+ return false;
+ }
+ }// if face will be refined
+ }// if neighbor is flagged for refinement
+
+ // no cases left, so the neighbor will not
+ // refine the face
+ return false;
+ }
+
+ // version of above function for both active
+ // and non-active cells
+ template <int dim, int spacedim>
+ bool
+ face_will_be_refined_by_neighbor(const TriaIterator<dealii::CellAccessor<dim, spacedim> > &cell,
+ const unsigned int face_no)
+ {
+ RefinementCase<dim-1> dummy = RefinementCase<dim-1>::no_refinement;
+ return face_will_be_refined_by_neighbor_internal(cell, face_no, dummy);
+ }
+
+ // version of above function for active cells
+ // only. Additionally returning the refine
+ // case (to come) of the face under
+ // consideration
+ template <int dim, int spacedim>
+ bool
+ face_will_be_refined_by_neighbor(const TriaActiveIterator<dealii::CellAccessor<dim,spacedim> > &cell,
+ const unsigned int face_no,
+ RefinementCase<dim-1> &expected_face_ref_case)
+ {
+ return face_will_be_refined_by_neighbor_internal(cell, face_no,
+ expected_face_ref_case);
+ }
+
+
+
+ template <int dim, int spacedim>
+ bool
+ satisfies_level1_at_vertex_rule (const Triangulation<dim,spacedim> &triangulation)
+ {
+ std::vector<unsigned int> min_adjacent_cell_level (triangulation.n_vertices(),
+ triangulation.n_levels());
+ std::vector<unsigned int> max_adjacent_cell_level (triangulation.n_vertices(),
+ 0);
+
+ for (typename Triangulation<dim,spacedim>::active_cell_iterator
+ cell = triangulation.begin_active();
+ cell != triangulation.end(); ++cell)
+ for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell; ++v)
+ {
+ min_adjacent_cell_level[cell->vertex_index(v)]
+ = std::min<unsigned int>
+ (min_adjacent_cell_level[cell->vertex_index(v)],
+ cell->level());
+ max_adjacent_cell_level[cell->vertex_index(v)]
+ = std::max<unsigned int> (min_adjacent_cell_level[cell->vertex_index(v)],
+ cell->level());
+ }
+
+ for (unsigned int k=0; k<triangulation.n_vertices(); ++k)
+ if (triangulation.vertex_used(k))
+ if (max_adjacent_cell_level[k] -
+ min_adjacent_cell_level[k] > 1)
+ return false;
+ return true;
+ }
+
+
+
+ /**
+ * Fill the vector @p line_cell_count
+ * needed by @p delete_children with the
+ * number of cells bounded by a given
+ * line.
+ */
+ template <int dim, int spacedim>
+ std::vector<unsigned int>
+ count_cells_bounded_by_line (const Triangulation<dim,spacedim> &triangulation)
+ {
+ if (dim >= 2)
+ {
+ std::vector<unsigned int> line_cell_count(triangulation.n_raw_lines(),0);
+ typename Triangulation<dim,spacedim>::cell_iterator
+ cell=triangulation.begin(),
+ endc=triangulation.end();
+ for (; cell!=endc; ++cell)
+ for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
+ ++line_cell_count[cell->line_index(l)];
+ return line_cell_count;
+ }
+ else
+ return std::vector<unsigned int>();
+ }
+
+
+
+
+ /**
+ * Fill the vector @p quad_cell_count
+ * needed by @p delete_children with the
+ * number of cells bounded by a given
+ * quad.
+ */
+ template <int dim, int spacedim>
+ std::vector<unsigned int>
+ count_cells_bounded_by_quad (const Triangulation<dim,spacedim> &triangulation)
+ {
+ if (dim >= 3)
+ {
+ std::vector<unsigned int> quad_cell_count (triangulation.n_raw_quads(),0);
+ typename Triangulation<dim,spacedim>::cell_iterator
+ cell=triangulation.begin(),
+ endc=triangulation.end();
+ for (; cell!=endc; ++cell)
+ for (unsigned int q=0; q<GeometryInfo<dim>::faces_per_cell; ++q)
+ ++quad_cell_count[cell->quad_index(q)];
+ return quad_cell_count;
+ }
+ else
+ return std::vector<unsigned int>();
+ }
+
+
+ /**
+ * For a given Triangulation, update the
+ * number cache for lines. For 1d, we have
+ * to deal with the fact that lines have
+ * levels, whereas for higher dimensions
+ * they do not.
+ *
+ * The second argument indicates
+ * for how many levels the
+ * Triangulation has objects,
+ * though the highest levels need
+ * not contain active cells if they
+ * have previously all been
+ * coarsened away.
+ */
+ template <int dim, int spacedim>
+ void compute_number_cache (const Triangulation<dim,spacedim> &triangulation,
+ const unsigned int level_objects,
+ internal::Triangulation::NumberCache<1> &number_cache)
+ {
+ typedef
+ typename Triangulation<dim,spacedim>::line_iterator line_iterator;
+ typedef
+ typename Triangulation<dim,spacedim>::active_line_iterator active_line_iterator;
+
+ number_cache.n_levels = 0;
+ if (level_objects > 0)
+ {
+ // check whether there are
+ // cells on the highest
+ // levels (there need not be,
+ // since they might all have
+ // been coarsened away)
+ typename Triangulation<dim,spacedim>::raw_cell_iterator
+ cell = triangulation.last_raw (level_objects-1),
+ endc = triangulation.end();
+ for (; cell!=endc; --cell)
+ if (cell->used())
+ {
+ // return level of most
+ // refined existing cell
+ // (+1 because of
+ // counting conventions)
+ number_cache.n_levels = cell->level()+1;
+ break;
+ }
+
+ // 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_level.resize (number_cache.n_levels);
+ number_cache.n_lines = 0;
+
+ number_cache.n_active_lines_level.resize (number_cache.n_levels);
+ number_cache.n_active_lines = 0;
+
+ // for 1d, lines have levels so take
+ // count the objects per level and
+ // globally
+ if (dim == 1)
+ {
+ for (unsigned int level=0; level<number_cache.n_levels; ++level)
+ {
+ // count lines on this level
+ number_cache.n_lines_level[level] = 0;
+
+ line_iterator line = triangulation.begin_line (level),
+ endc = (level == number_cache.n_levels-1 ?
+ line_iterator(triangulation.end_line()) :
+ triangulation.begin_line (level+1));
+ for (; line!=endc; ++line)
+ ++number_cache.n_lines_level[level];
+
+ // update total number of lines
+ number_cache.n_lines += number_cache.n_lines_level[level];
+ }
+
+ // do the update for the number of
+ // active lines as well
+ for (unsigned int level=0; level<number_cache.n_levels; ++level)
+ {
+ // count lines on this level
+ number_cache.n_active_lines_level[level] = 0;
+
+ active_line_iterator line = triangulation.begin_active_line (level),
+ endc = triangulation.end_active_line (level);
+ for (; line!=endc; ++line)
+ ++number_cache.n_active_lines_level[level];
+
+ // update total number of lines
+ number_cache.n_active_lines += number_cache.n_active_lines_level[level];
+ }
+ }
+ else
+ {
+ // for dim>1, there are no
+ // levels for lines
+ {
+ line_iterator line = triangulation.begin_line (),
+ endc = triangulation.end_line();
+ for (; line!=endc; ++line)
+ ++number_cache.n_lines;
+ }
+
+ {
+ active_line_iterator line = triangulation.begin_active_line (),
+ endc = triangulation.end_line();
+ for (; line!=endc; ++line)
+ ++number_cache.n_active_lines;
+ }
+ }
+ }
+
+ /**
+ * For a given Triangulation, update the
+ * number cache for quads. For 2d, we have
+ * to deal with the fact that quads have
+ * levels, whereas for higher dimensions
+ * they do not.
+ *
+ * The second argument indicates
+ * for how many levels the
+ * Triangulation has objects,
+ * though the highest levels need
+ * not contain active cells if they
+ * have previously all been
+ * coarsened away.
+ *
+ * At the beginning of the function, we call the
+ * respective function to update the number
+ * cache for lines.
+ */
+ template <int dim, int spacedim>
+ void compute_number_cache (const Triangulation<dim,spacedim> &triangulation,
+ const unsigned int level_objects,
+ internal::Triangulation::NumberCache<2> &number_cache)
+ {
+ // update lines and n_levels
+ compute_number_cache (triangulation,
+ level_objects,
+ static_cast<internal::Triangulation::NumberCache<1>&>
+ (number_cache));
+
+ typedef
+ typename Triangulation<dim,spacedim>::quad_iterator quad_iterator;
+ typedef
+ typename Triangulation<dim,spacedim>::active_quad_iterator active_quad_iterator;
+
+ ///////////////////////////////////
+ // update the number of quads
+ // on the different levels in
+ // the cache
+ number_cache.n_quads_level.resize (number_cache.n_levels);
+ number_cache.n_quads = 0;
+
+ number_cache.n_active_quads_level.resize (number_cache.n_levels);
+ number_cache.n_active_quads = 0;
+
+ // for 2d, quads have levels so take
+ // count the objects per level and
+ // globally
+ if (dim == 2)
+ {
+ for (unsigned int level=0; level<number_cache.n_levels; ++level)
+ {
+ // count quads on this level
+ number_cache.n_quads_level[level] = 0;
+
+ quad_iterator quad = triangulation.begin_quad (level),
+ endc = (level == number_cache.n_levels-1 ?
+ quad_iterator(triangulation.end_quad()) :
+ triangulation.begin_quad (level+1));
+ for (; quad!=endc; ++quad)
+ ++number_cache.n_quads_level[level];
+
+ // update total number of quads
+ number_cache.n_quads += number_cache.n_quads_level[level];
+ }
+
+ // do the update for the number of
+ // active quads as well
+ for (unsigned int level=0; level<number_cache.n_levels; ++level)
+ {
+ // count quads on this level
+ number_cache.n_active_quads_level[level] = 0;
+
+ active_quad_iterator quad = triangulation.begin_active_quad (level),
+ endc = triangulation.end_active_quad (level);
+ for (; quad!=endc; ++quad)
+ ++number_cache.n_active_quads_level[level];
+
+ // update total number of quads
+ number_cache.n_active_quads += number_cache.n_active_quads_level[level];
+ }
+ }
+ else
+ {
+ // for dim>2, there are no
+ // levels for quads
+ {
+ quad_iterator quad = triangulation.begin_quad (),
+ endc = triangulation.end_quad();
+ for (; quad!=endc; ++quad)
+ ++number_cache.n_quads;
+ }
+
+ {
+ active_quad_iterator quad = triangulation.begin_active_quad (),
+ endc = triangulation.end_quad();
+ for (; quad!=endc; ++quad)
+ ++number_cache.n_active_quads;
+ }
+ }
+ }
+
+ /**
+ * For a given Triangulation, update the
+ * number cache for hexes. For 3d, we have
+ * to deal with the fact that hexes have
+ * levels, whereas for higher dimensions
+ * they do not.
+ *
+ * The second argument indicates
+ * for how many levels the
+ * Triangulation has objects,
+ * though the highest levels need
+ * not contain active cells if they
+ * have previously all been
+ * coarsened away.
+ *
+ * At the end of the function, we call the
+ * respective function to update the number
+ * cache for quads, which will in turn call
+ * the respective function for lines.
+ */
+ template <int dim, int spacedim>
+ void compute_number_cache (const Triangulation<dim,spacedim> &triangulation,
+ const unsigned int level_objects,
+ internal::Triangulation::NumberCache<3> &number_cache)
+ {
+ // update quads, lines and n_levels
+ compute_number_cache (triangulation,
+ level_objects,
+ static_cast<internal::Triangulation::NumberCache<2>&>
+ (number_cache));
+
+ typedef
+ typename Triangulation<dim,spacedim>::hex_iterator hex_iterator;
+ typedef
+ typename Triangulation<dim,spacedim>::active_hex_iterator active_hex_iterator;
+
+ ///////////////////////////////////
+ // update the number of hexes
+ // on the different levels in
+ // the cache
+ number_cache.n_hexes_level.resize (number_cache.n_levels);
+ number_cache.n_hexes = 0;
+
+ number_cache.n_active_hexes_level.resize (number_cache.n_levels);
+ number_cache.n_active_hexes = 0;
+
+ // for 3d, hexes have levels so take
+ // count the objects per level and
+ // globally
+ if (dim == 3)
+ {
+ for (unsigned int level=0; level<number_cache.n_levels; ++level)
+ {
+ // count hexes on this level
+ number_cache.n_hexes_level[level] = 0;
+
+ hex_iterator hex = triangulation.begin_hex (level),
+ endc = (level == number_cache.n_levels-1 ?
+ hex_iterator(triangulation.end_hex()) :
+ triangulation.begin_hex (level+1));
+ for (; hex!=endc; ++hex)
+ ++number_cache.n_hexes_level[level];
+
+ // update total number of hexes
+ number_cache.n_hexes += number_cache.n_hexes_level[level];
+ }
+
+ // do the update for the number of
+ // active hexes as well
+ for (unsigned int level=0; level<number_cache.n_levels; ++level)
+ {
+ // count hexes on this level
+ number_cache.n_active_hexes_level[level] = 0;
+
+ active_hex_iterator hex = triangulation.begin_active_hex (level),
+ endc = triangulation.end_active_hex (level);
+ for (; hex!=endc; ++hex)
+ ++number_cache.n_active_hexes_level[level];
+
+ // update total number of hexes
+ number_cache.n_active_hexes += number_cache.n_active_hexes_level[level];
+ }
+ }
+ else
+ {
+ // for dim>3, there are no
+ // levels for hexs
+ {
+ hex_iterator hex = triangulation.begin_hex (),
+ endc = triangulation.end_hex();
+ for (; hex!=endc; ++hex)
+ ++number_cache.n_hexes;
+ }
+
+ {
+ active_hex_iterator hex = triangulation.begin_active_hex (),
+ endc = triangulation.end_hex();
+ for (; hex!=endc; ++hex)
+ ++number_cache.n_active_hexes;
+ }
+ }
+ }
+
+
+
+ /**
+ * A set of three functions that
+ * reorder the data given to
+ * create_triangulation_compatibility
+ * from the "classic" to the
+ * "current" format of vertex
+ * numbering of cells and
+ * faces. These functions do the
+ * reordering of their arguments
+ * in-place.
+ */
+ void
+ reorder_compatibility (const std::vector<CellData<1> > &,
+ const SubCellData &)
+ {
+ // nothing to do here: the format
+ // hasn't changed for 1d
+ }
+
+
+ void
+ reorder_compatibility (std::vector<CellData<2> > &cells,
+ const SubCellData &)
+ {
+ for (unsigned int cell=0; cell<cells.size(); ++cell)
+ std::swap(cells[cell].vertices[2],cells[cell].vertices[3]);
+ }
+
+
+ void
+ reorder_compatibility (std::vector<CellData<3> > &cells,
+ SubCellData &subcelldata)
+ {
+ unsigned int tmp[GeometryInfo<3>::vertices_per_cell];
+ for (unsigned int cell=0; cell<cells.size(); ++cell)
+ {
+ for (unsigned int i=0; i<GeometryInfo<3>::vertices_per_cell; ++i)
+ tmp[i] = cells[cell].vertices[i];
+ for (unsigned int i=0; i<GeometryInfo<3>::vertices_per_cell; ++i)
+ cells[cell].vertices[GeometryInfo<3>::ucd_to_deal[i]] = tmp[i];
+ }
+
+ // now points in boundary quads
+ std::vector<CellData<2> >::iterator boundary_quad
+ = subcelldata.boundary_quads.begin();
+ std::vector<CellData<2> >::iterator end_quad
+ = subcelldata.boundary_quads.end();
+ for (unsigned int quad_no=0; boundary_quad!=end_quad; ++boundary_quad, ++quad_no)
+ std::swap(boundary_quad->vertices[2], boundary_quad->vertices[3]);
+ }
+
+
+
+ /**
+ * Return the index of the vertex
+ * in the middle of this object,
+ * if it exists. In order to
+ * exist, the object needs to be
+ * refined - for 2D and 3D it
+ * needs to be refined
+ * isotropically or else the
+ * anisotropic children have to
+ * be refined again. If the
+ * middle vertex does not exist,
+ * return
+ * <tt>numbers::invalid_unsigned_int</tt>.
+ *
+ * This function should not really be
+ * used in application programs.
+ */
+ template <int dim, int spacedim>
+ unsigned int
+ middle_vertex_index(const typename Triangulation<dim,spacedim>::line_iterator &line)
+ {
+ if (line->has_children())
+ return line->child(0)->vertex_index(1);
+ return numbers::invalid_unsigned_int;
+ }
+
+
+ template <int dim, int spacedim>
+ unsigned int
+ middle_vertex_index(const typename Triangulation<dim,spacedim>::quad_iterator &quad)
+ {
+ switch (static_cast<unsigned char> (quad->refinement_case()))
+ {
+ case RefinementCase<2>::cut_x:
+ return middle_vertex_index<dim,spacedim>(quad->child(0)->line(1));
+ break;
+ case RefinementCase<2>::cut_y:
+ return middle_vertex_index<dim,spacedim>(quad->child(0)->line(3));
+ break;
+ case RefinementCase<2>::cut_xy:
+ return quad->child(0)->vertex_index(3);
+ break;
+ default:
+ break;
+ }
+ return numbers::invalid_unsigned_int;
+ }
+
+
+ template <int dim, int spacedim>
+ unsigned int
+ middle_vertex_index(const typename Triangulation<dim,spacedim>::hex_iterator &hex)
+ {
+ switch (static_cast<unsigned char> (hex->refinement_case()))
+ {
+ case RefinementCase<3>::cut_x:
+ return middle_vertex_index<dim,spacedim>(hex->child(0)->quad(1));
+ break;
+ case RefinementCase<3>::cut_y:
+ return middle_vertex_index<dim,spacedim>(hex->child(0)->quad(3));
+ break;
+ case RefinementCase<3>::cut_z:
+ return middle_vertex_index<dim,spacedim>(hex->child(0)->quad(5));
+ break;
+ case RefinementCase<3>::cut_xy:
+ return middle_vertex_index<dim,spacedim>(hex->child(0)->line(11));
+ break;
+ case RefinementCase<3>::cut_xz:
+ return middle_vertex_index<dim,spacedim>(hex->child(0)->line(5));
+ break;
+ case RefinementCase<3>::cut_yz:
+ return middle_vertex_index<dim,spacedim>(hex->child(0)->line(7));
+ break;
+ case RefinementCase<3>::cut_xyz:
+ return hex->child(0)->vertex_index(7);
+ break;
+ default:
+ break;
+ }
+ return numbers::invalid_unsigned_int;
+ }
+
+
+ /**
+ * Collect all coarse mesh cells
+ * with at least one vertex at
+ * which the determinant of the
+ * Jacobian is zero or
+ * negative. This is the function
+ * for the case dim==spacedim.
+ */
+ template <int dim>
+ typename Triangulation<dim,dim>::DistortedCellList
+ collect_distorted_coarse_cells (const Triangulation<dim,dim> &triangulation)
+ {
+ typename Triangulation<dim,dim>::DistortedCellList distorted_cells;
+ for (typename Triangulation<dim,dim>::cell_iterator
+ cell = triangulation.begin(0); cell != triangulation.end(0); ++cell)
+ {
+ Point<dim> vertices[GeometryInfo<dim>::vertices_per_cell];
+ for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_cell; ++i)
+ vertices[i] = cell->vertex(i);
+
+ Tensor<0,dim> determinants[GeometryInfo<dim>::vertices_per_cell];
+ GeometryInfo<dim>::alternating_form_at_vertices (vertices,
+ determinants);
+
+ for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_cell; ++i)
+ if (determinants[i] <= 1e-9 * std::pow (cell->diameter(),
+ 1.*dim))
+ {
+ distorted_cells.distorted_cells.push_back (cell);
+ break;
+ }
+ }
+
+ return distorted_cells;
+ }
+
+
+ /**
+ * Collect all coarse mesh cells
+ * with at least one vertex at
+ * which the determinant of the
+ * Jacobian is zero or
+ * negative. This is the function
+ * for the case dim!=spacedim,
+ * where we can not determine
+ * whether a cell is twisted as it
+ * may, for example, discretize a
+ * manifold with a twist.
+ */
+ template <int dim, int spacedim>
+ typename Triangulation<dim,spacedim>::DistortedCellList
+ collect_distorted_coarse_cells (const Triangulation<dim,spacedim> &)
+ {
+ return typename Triangulation<dim,spacedim>::DistortedCellList();
+ }
+
+
+
+ /**
+ * Return whether any of the
+ * children of the given cell is
+ * distorted or not. This is the
+ * function for dim==spacedim.
+ */
+ template <int dim>
+ bool
+ has_distorted_children (const typename Triangulation<dim,dim>::cell_iterator &cell,
+ internal::int2type<dim>,
+ internal::int2type<dim>)
+ {
+ Assert (cell->has_children(), ExcInternalError());
+
+ for (unsigned int c=0; c<cell->n_children(); ++c)
+ {
+ Point<dim> vertices[GeometryInfo<dim>::vertices_per_cell];
+ for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_cell; ++i)
+ vertices[i] = cell->child(c)->vertex(i);
+
+ Tensor<0,dim> determinants[GeometryInfo<dim>::vertices_per_cell];
+ GeometryInfo<dim>::alternating_form_at_vertices (vertices,
+ determinants);
+
+ for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_cell; ++i)
+ if (determinants[i] <= 1e-9 * std::pow (cell->child(c)->diameter(),
+ 1.*dim))
+ return true;
+ }
+
+ return false;
+ }
+
+
+ /**
+ * Function for dim!=spacedim. As
+ * for
+ * collect_distorted_coarse_cells,
+ * there is nothing that we can do
+ * in this case.
+ */
+ template <int dim, int spacedim>
+ bool
+ has_distorted_children (const typename Triangulation<dim,spacedim>::cell_iterator &,
+ internal::int2type<dim>,
+ internal::int2type<spacedim>)
+ {
+ return false;
+ }
+
+
+
+ /**
+ * For a given triangulation: set up the
+ * neighbor information on all cells.
+ */
+ template <int spacedim>
+ void
+ update_neighbors (Triangulation<1,spacedim> &/*triangulation*/)
+ {}
+
+
+ template <int dim, int spacedim>
+ void
+ update_neighbors (Triangulation<dim,spacedim> &triangulation)
+ {
+ // each face can be neighbored on two sides
+ // by cells. according to the face's
+ // intrinsic normal we define the left
+ // neighbor as the one for which the face
+ // normal points outward, and store that
+ // one first, with an offset of one we
+ // store the right neighbor for which the
+ // face normal points inward. This
+ // information depends on the type of cell
+ // and local number of face for the
+ // 'standard ordering and orientation' of
+ // faces and then on the face_orientation
+ // information for the real mesh. Set up a
+ // table to have fast access to those
+ // offsets (0 for left and 1 for
+ // right). Some of the values are invalid
+ // as they reference too large face
+ // numbers, but we just leave them at a
+ // zero value.
+ //
+ // Note, that in 2d for lines as faces the
+ // normal direction given in the
+ // GeometryInfo class is not consistent. We
+ // thus define here that the normal for a
+ // line points to the right if the line
+ // points upwards.
+ //
+ // first index: dimension (minus 2)
+ // second index: local face index
+ // third index: face_orientation (false and true)
+ static const unsigned int left_right_offset[2][6][2] =
+ {
+ // quadrilateral
+ {{0,1}, // face 0, face_orientation = false and true
+ {1,0}, // face 1, face_orientation = false and true
+ {1,0}, // face 2, face_orientation = false and true
+ {0,1}, // face 3, face_orientation = false and true
+ {0,0}, // face 4, invalid face
+ {0,0}},// face 5, invalid face
+ // hexahedron
+ {{0,1},
+ {1,0},
+ {0,1},
+ {1,0},
+ {0,1},
+ {1,0}}};
+
+ // now create a vector of the two active
+ // neighbors (left and right) for each face
+ // and fill it by looping over all cells. For
+ // cases with anisotropic refinement and more
+ // then one cell neighboring at a given side
+ // of the face we will automatically get the
+ // active one on the highest level as we loop
+ // over cells from lower levels first.
+ const typename Triangulation<dim,spacedim>::cell_iterator dummy;
+ std::vector<typename Triangulation<dim,spacedim>::cell_iterator>
+ adjacent_cells(2*triangulation.n_raw_faces(), dummy);
+
+ typename Triangulation<dim,spacedim>::cell_iterator
+ cell = triangulation.begin(),
+ endc = triangulation.end();
+ for (; cell != endc; ++cell)
+ for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+ {
+ const typename Triangulation<dim,spacedim>::face_iterator face=cell->face(f);
+ const unsigned int offset=left_right_offset[dim-2][f][cell->face_orientation(f)];
+ adjacent_cells[2*face->index() + offset] = cell;
+ // if this cell is not refined, but the
+ // face is, then we'll have to set our
+ // cell as neighbor for the cild faces
+ // as well. Fortunately the normal
+ // orientation of children will be just
+ // the same.
+ if (dim==2)
+ {
+ if (cell->active() && face->has_children())
+ {
+ adjacent_cells[2*face->child(0)->index() + offset] = cell;
+ adjacent_cells[2*face->child(1)->index() + offset] = cell;
+ }
+ }
+ else // -> dim == 3
+ {
+ // We need the same as in 2d
+ // here. Furthermore, if the face is
+ // refined with cut_x or cut_y then
+ // those children again in the other
+ // direction, and if this cell is
+ // refined isotropically (along the
+ // face) then the neighbor will
+ // (probably) be refined as cut_x or
+ // cut_y along the face. For those
+ // neighboring children cells, their
+ // neighbor will be the current,
+ // inactive cell, as our children are
+ // too fine to be neighbors. Catch that
+ // case by also acting on inactive
+ // cells with isotropic refinement
+ // along the face. If the situation
+ // described is not present, the data
+ // will be overwritten later on when we
+ // visit cells on finer levels, so no
+ // harm will be done.
+ if (face->has_children() &&
+ (cell->active() ||
+ GeometryInfo<dim>::face_refinement_case(cell->refinement_case(),f) == RefinementCase<dim-1>::isotropic_refinement))
+ {
+
+ for (unsigned int c=0; c<face->n_children(); ++c)
+ adjacent_cells[2*face->child(c)->index() + offset] = cell;
+ if (face->child(0)->has_children())
+ {
+ adjacent_cells[2*face->child(0)->child(0)->index() + offset] = cell;
+ adjacent_cells[2*face->child(0)->child(1)->index() + offset] = cell;
+ }
+ if (face->child(1)->has_children())
+ {
+ adjacent_cells[2*face->child(1)->child(0)->index() + offset] = cell;
+ adjacent_cells[2*face->child(1)->child(1)->index() + offset] = cell;
+ }
+ } // if cell active and face refined
+ } // else -> dim==3
+ } // for all faces of all cells
+
+ // now loop again over all cells and set the
+ // corresponding neighbor cell. Note, that we
+ // have to use the opposite of the
+ // left_right_offset in this case as we want
+ // the offset of the neighbor, not our own.
+ for (cell=triangulation.begin(); cell != endc; ++cell)
+ for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+ cell->set_neighbor(f,
+ adjacent_cells[2*cell->face(f)->index() + 1
+ - left_right_offset[dim-2][f][cell->face_orientation(f)]]);
+ }
+
+}// end of anonymous namespace
+
+
+namespace internal
+{
+ namespace Triangulation
+ {
+ // make sure that if in the following we
+ // write Triangulation<dim,spacedim>
+ // we mean the *class*
+ // dealii::Triangulation, not the
+ // enclosing namespace
+ // internal::Triangulation
+ using dealii::Triangulation;
+
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException0 (ExcCellShouldBeUnused);
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException0 (ExcTooFewVerticesAllocated);
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException0 (ExcUncaughtState);
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException2 (ExcGridsDoNotMatch,
+ int, int,
+ << "The present grid has " << arg1 << " active cells, "
+ << "but the one in the file had " << arg2);
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException1 (ExcGridHasInvalidCell,
+ int,
+ << "Something went wrong when making cell " << arg1
+ << ". Read the docs and the source code "
+ << "for more information.");
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException0 (ExcGridHasInvalidVertices);
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException1 (ExcInternalErrorOnCell,
+ int,
+ << "Something went wrong upon construction of cell "
+ << arg1);
+ /**
+ * A cell was entered which has
+ * negative measure. In most
+ * cases, this is due to a wrong
+ * order of the vertices of the
+ * cell.
+ *
+ * @ingroup Exceptions
+ */
+ DeclException1 (ExcCellHasNegativeMeasure,
+ int,
+ << "Cell " << arg1 << " has negative measure.");
+ /**
+ * A cell is created with a
+ * vertex number exceeding the
+ * vertex array.
+ *
+ * @ingroup Exceptions
+ */
+ DeclException3 (ExcInvalidVertexIndex,
+ int, int, int,
+ << "Error while creating cell " << arg1
+ << ": the vertex index " << arg2 << " must be between 0 and "
+ << arg3 << ".");
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException2 (ExcLineInexistant,
+ int, int,
+ << "When trying to give a boundary indicator to a line: "
+ << "the line with end vertices " << arg1 << " and "
+ << arg2 << " does not exist.");
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException4 (ExcQuadInexistant,
+ int, int, int, int,
+ << "When trying to give a boundary indicator to a quad: "
+ << "the quad with bounding lines " << arg1 << ", " << arg2
+ << ", " << arg3 << ", " << arg4 << " does not exist.");
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException0 (ExcInteriorLineCantBeBoundary);
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException0 (ExcInteriorQuadCantBeBoundary);
+ /**
+ * Exception
+ * @ingroup Exceptions
+ */
+ DeclException2 (ExcMultiplySetLineInfoOfLine,
+ int, int,
+ << "In SubCellData the line info of the line with vertex indices "
+ << arg1 << " and " << arg2 << " is multiply set.");
+
+
+/**
+ * A class into which we put many of the functions that implement
+ * functionality of the Triangulation class. The main reason for this
+ * class is as follows: the majority of the functions in Triangulation
+ * need to be implemented differently for dim==1, dim==2, and
+ * dim==3. However, their implementation is largly independent of the
+ * spacedim template parameter. So we would like to write things like
+ *
+ * template <int spacedim>
+ * void Triangulation<1,spacedim>::create_triangulation (...) {...}
+ *
+ * Unfortunately, C++ doesn't allow this: member functions of class
+ * templates have to be either not specialized at all, or fully
+ * specialized. No partial specialization is allowed. One possible
+ * solution would be to just duplicate the bodies of the functions and
+ * have equally implemented functions
+ *
+ * template <>
+ * void Triangulation<1,1>::create_triangulation (...) {...}
+ *
+ * template <>
+ * void Triangulation<1,2>::create_triangulation (...) {...}
+ *
+ * but that is clearly an unsatisfactory solution. Rather, what we do
+ * is introduce the current Implementation class in which we can write
+ * these functions as member templates over spacedim, i.e. we can have
+ *
+ * template <int dim_, int spacedim_>
+ * template <int spacedim>
+ * void Triangulation<dim_,spacedim_>::Implementation::
+ * create_triangulation (...,
+ * Triangulation<1,spacedim> &tria ) {...}
+ *
+ * The outer template parameters are here unused, only the inner
+ * ones are of real interest.
+ *
+ * One may ask why we put these functions into an class rather
+ * than an anonymous namespace, for example?
+ *
+ * First, these implementation functions need to be friends of the
+ * Triangulation class. It is simpler to make the entire class a friend
+ * rather than listing all members of an implementation namespace as
+ * friends of the Triangulation class (there is no such thing as a "friend
+ * namespace XXX" directive).
+ *
+ * Ideally, we would make this class a member class of the
+ * Triangulation<dim,spacedim> class, since then our implementation functions
+ * have immediate access to the typedefs and static functions of the
+ * surrounding Triangulation class. I.e., we do not have to write "typename
+ * Triangulation<dim,spacedim>::active_cell_iterator" but can write
+ * "active_cell_iterator" right away. This is, in fact, the way it was
+ * implemented first, but we ran into a bug in gcc4.0:
+ * @code
+ * class Triangulation {
+ * struct Implementation;
+ * friend class TriaAccessor;
+ * };
+ *
+ * class TriaAccessor {
+ * struct Implementation;
+ * friend class Triangulation;
+ * };
+ * @endcode
+ *
+ * Here, friendship (per C++ standard) is supposed to extend to all members of
+ * the befriended class, including its 'Implementation' member class. But gcc4.0
+ * gets this wrong: the members of Triangulation::Implementation are not friends
+ * of TriaAccessor and the other way around. Ideally, one would fix this by
+ * saying
+ * @code
+ * class Triangulation {
+ * struct Implementation;
+ * friend class TriaAccessor;
+ * friend class TriaAccessor::Implementation; // **
+ * };
+ *
+ * class TriaAccessor {
+ * struct Implementation;
+ * friend class Triangulation;
+ * friend class Triangulation::Implementation;
+ * };
+ * @endcode
+ * but that's not legal because in ** we don't know yet that TriaAccessor has
+ * a member class Implementation and so we can't make it a friend. The only
+ * way forward at this point was to make Implementation a class in the
+ * internal namespace so that we can forward declare it and make it a friend
+ * of the respective other outer class -- not quite what we wanted but the
+ * only way I could see to make it work...
+ */
+ struct Implementation
+ {
+ /**
+ * Create a triangulation from
+ * given data. This function does
+ * this work for 1-dimensional
+ * triangulations independently
+ * of the actual space dimension.
+ */
+ template <int spacedim>
+ static
+ void
+ create_triangulation (const std::vector<Point<spacedim> > &v,
+ const std::vector<CellData<1> > &cells,
+ const SubCellData &/*subcelldata*/,
+ Triangulation<1,spacedim> &triangulation)
+ {
+ // note: since no boundary
+ // information can be given in one
+ // dimension, the @p{subcelldata}
+ // field is ignored. (only used for
+ // error checking, which is a good
+ // idea in any case)
+ const unsigned int dim=1;
+
+ // copy vertices
+ triangulation.vertices = v;
+ triangulation.vertices_used = std::vector<bool> (v.size(), true);
+
+ // store the indices of the lines
+ // which are adjacent to a given
+ // vertex
+ std::vector<std::vector<int> > lines_at_vertex (v.size());
+
+ // reserve enough space
+ triangulation.levels.push_back (new internal::Triangulation::TriaLevel<dim>);
+ triangulation.levels[0]->reserve_space (cells.size(), dim);
+ triangulation.levels[0]->cells.reserve_space (0,cells.size());
+
+ // make up cells
+ typename Triangulation<dim,spacedim>::raw_line_iterator
+ next_free_line = triangulation.begin_raw_line ();
+ for (unsigned int cell=0; cell<cells.size(); ++cell)
+ {
+ while (next_free_line->used())
+ ++next_free_line;
+
+ next_free_line->set (internal::Triangulation
+ ::TriaObject<1> (cells[cell].vertices[0],
+ cells[cell].vertices[1]));
+ next_free_line->set_used_flag ();
+ next_free_line->set_material_id (cells[cell].material_id);
+ next_free_line->clear_user_data ();
+ next_free_line->set_subdomain_id (0);
+
+ // note that this cell is
+ // adjacent to these vertices
+ lines_at_vertex[cells[cell].vertices[0]].push_back (cell);
+ lines_at_vertex[cells[cell].vertices[1]].push_back (cell);
+ }
+
+
+ // some security tests
+ {
+ unsigned int boundary_nodes = 0;
+ for (unsigned int i=0; i<lines_at_vertex.size(); ++i)
+ switch (lines_at_vertex[i].size())
+ {
+ case 1:
+ // this vertex has only
+ // one adjacent line
+ ++boundary_nodes;
+ break;
+ case 2:
+ break;
+ default:
+ // a node must have one
+ // or two adjacent
+ // lines
+ AssertThrow (false, ExcInternalError());
+ }
+
+ // assert there are no more
+ // than two boundary
+ // nodes. note that if the
+ // space dimension is
+ // bigger than 1, then we
+ // can have fewer than 2
+ // nodes (for example a
+ // ring of cells -- no end
+ // points at all)
+ AssertThrow (((spacedim == 1) && (boundary_nodes == 2))
+ ||
+ (spacedim > 1),
+ ExcMessage("The Triangulation has too many end points"));
+ }
+
+
+
+ // update neighborship info
+ typename Triangulation<dim,spacedim>::active_line_iterator
+ line = triangulation.begin_active_line ();
+ // for all lines
+ for (; line!=triangulation.end(); ++line)
+ // for each of the two vertices
+ for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+ // if first cell adjacent to
+ // this vertex is the present
+ // one, then the neighbor is
+ // the second adjacent cell and
+ // vice versa
+ if (lines_at_vertex[line->vertex_index(vertex)][0] == line->index())
+ if (lines_at_vertex[line->vertex_index(vertex)].size() == 2)
+ {
+ const typename Triangulation<dim,spacedim>::cell_iterator
+ neighbor (&triangulation,
+ 0, // level
+ lines_at_vertex[line->vertex_index(vertex)][1]);
+ line->set_neighbor (vertex, neighbor);
+ }
+ else
+ // no second adjacent cell
+ // entered -> cell at
+ // boundary
+ line->set_neighbor (vertex, triangulation.end());
+ else
+ // present line is not first
+ // adjacent one -> first
+ // adjacent one is neighbor
+ {
+ const typename Triangulation<dim,spacedim>::cell_iterator
+ neighbor (&triangulation,
+ 0, // level
+ lines_at_vertex[line->vertex_index(vertex)][0]);
+ line->set_neighbor (vertex, neighbor);
+ }
+ }
+
+
+ /**
+ * Create a triangulation from
+ * given data. This function does
+ * this work for 2-dimensional
+ * triangulations independently
+ * of the actual space dimension.
+ */
+ template <int spacedim>
+ static
+ void
+ create_triangulation (const std::vector<Point<spacedim> > &v,
+ const std::vector<CellData<2> > &cells,
+ const SubCellData &subcelldata,
+ Triangulation<2,spacedim> &triangulation)
+ {
+ const unsigned int dim=2;
+
+ // copy vertices
+ triangulation.vertices = v;
+ triangulation.vertices_used = std::vector<bool> (v.size(), true);
+
+ // make up a list of the needed
+ // lines each line is a pair of
+ // vertices. The list is kept
+ // sorted and it is guaranteed that
+ // each line is inserted only once.
+ // While the key of such an entry
+ // is the pair of vertices, the
+ // thing it points to is an
+ // iterator pointing to the line
+ // object itself. In the first run,
+ // these iterators are all invalid
+ // ones, but they are filled
+ // afterwards
+ std::map<std::pair<int,int>,
+ typename Triangulation<dim,spacedim>::line_iterator> needed_lines;
+ for (unsigned int cell=0; cell<cells.size(); ++cell)
+ {
+ for (unsigned int vertex=0; vertex<4; ++vertex)
+ AssertThrow (cells[cell].vertices[vertex] < triangulation.vertices.size(),
+ ExcInvalidVertexIndex (cell, cells[cell].vertices[vertex],
+ triangulation.vertices.size()));
+
+ for (unsigned int line=0; line<GeometryInfo<dim>::faces_per_cell; ++line)
+ {
+ // given a line vertex number
+ // (0,1) on a specific line we
+ // get the cell vertex number
+ // (0-4) through the
+ // line_to_cell_vertices
+ // function
+ std::pair<int,int> line_vertices(
+ cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
+ cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)]);
+
+ // assert that the line was
+ // not already inserted in
+ // reverse order. This
+ // happens in spite of the
+ // vertex rotation above,
+ // if the sense of the cell
+ // was incorrect.
+ //
+ // Here is what usually
+ // happened when this
+ // exception is thrown:
+ // consider these two cells
+ // and the vertices
+ // 3---4---5
+ // | | |
+ // 0---1---2
+ // If in the input vector
+ // the two cells are given
+ // with vertices <0 1 4 3>
+ // and <4 1 2 5>, in the
+ // first cell the middle
+ // line would have
+ // direction 1->4, while in
+ // the second it would be
+ // 4->1. This will cause
+ // the exception.
+ AssertThrow (needed_lines.find(std::make_pair(line_vertices.second,
+ line_vertices.first))
+ ==
+ needed_lines.end(),
+ ExcGridHasInvalidCell(cell));
+
+ // insert line, with
+ // invalid iterator if line
+ // already exists, then
+ // nothing bad happens here
+ needed_lines[line_vertices] = triangulation.end_line();
+ }
+ }
+
+
+ // check that every vertex has at
+ // least two adjacent lines
+ {
+ std::vector<unsigned short int> vertex_touch_count (v.size(), 0);
+ typename std::map<std::pair<int,int>,
+ typename Triangulation<dim,spacedim>::line_iterator>::iterator i;
+ for (i=needed_lines.begin(); i!=needed_lines.end(); i++)
+ {
+ // touch the vertices of
+ // this line
+ ++vertex_touch_count[i->first.first];
+ ++vertex_touch_count[i->first.second];
+ }
+
+ // assert minimum touch count
+ // is at least two. if not so,
+ // then clean triangulation and
+ // exit with an exception
+ AssertThrow (* (std::min_element(vertex_touch_count.begin(),
+ vertex_touch_count.end())) >= 2,
+ ExcGridHasInvalidVertices());
+ }
+
+ // reserve enough space
+ triangulation.levels.push_back (new internal::Triangulation::TriaLevel<dim>);
+ triangulation.faces = new internal::Triangulation::TriaFaces<dim>;
+ triangulation.levels[0]->reserve_space (cells.size(), dim);
+ triangulation.faces->lines.reserve_space (0,needed_lines.size());
+ triangulation.levels[0]->cells.reserve_space (0,cells.size());
+
+ // make up lines
+ {
+ typename Triangulation<dim,spacedim>::raw_line_iterator
+ line = triangulation.begin_raw_line();
+ typename std::map<std::pair<int,int>,
+ typename Triangulation<dim,spacedim>::line_iterator>::iterator i;
+ for (i = needed_lines.begin();
+ line!=triangulation.end_line(); ++line, ++i)
+ {
+ line->set (internal::Triangulation::TriaObject<1>(i->first.first,
+ i->first.second));
+ line->set_used_flag ();
+ line->clear_user_flag ();
+ line->clear_user_data ();
+ i->second = line;
+ }
+ }
+
+
+ // store for each line index
+ // the adjacent cells
+ std::map<int,std::vector<typename Triangulation<dim,spacedim>::cell_iterator> >
+ adjacent_cells;
+
+ // finally make up cells
+ {
+ typename Triangulation<dim,spacedim>::raw_cell_iterator
+ cell = triangulation.begin_raw_quad();
+ for (unsigned int c=0; c<cells.size(); ++c, ++cell)
+ {
+ typename Triangulation<dim,spacedim>::line_iterator
+ lines[GeometryInfo<dim>::lines_per_cell];
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ lines[line]=needed_lines[std::make_pair(
+ cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
+ cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)])];
+
+ cell->set (internal::Triangulation::TriaObject<2> (lines[0]->index(),
+ lines[1]->index(),
+ lines[2]->index(),
+ lines[3]->index()));
+
+ cell->set_used_flag ();
+ cell->set_material_id (cells[c].material_id);
+ cell->clear_user_data ();
+ cell->set_subdomain_id (0);
+
+ // note that this cell is
+ // adjacent to the four
+ // lines
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ adjacent_cells[lines[line]->index()].push_back (cell);
+ }
+ }
+
+
+ for (typename Triangulation<dim,spacedim>::line_iterator
+ line=triangulation.begin_line();
+ line!=triangulation.end_line(); ++line)
+ {
+ const unsigned int n_adj_cells = adjacent_cells[line->index()].size();
+ // assert that every line has
+ // one or two adjacent cells
+ AssertThrow ((n_adj_cells >= 1) &&
+ (n_adj_cells <= 2),
+ ExcInternalError());
+
+ // if only one cell: line is at
+ // boundary -> give it the
+ // boundary indicator zero by
+ // default
+ if (n_adj_cells == 1)
+ line->set_boundary_indicator (0);
+ else
+ // interior line -> 255
+ line->set_boundary_indicator (255);
+ }
+
+ // set boundary indicators where
+ // given
+ std::vector<CellData<1> >::const_iterator boundary_line
+ = subcelldata.boundary_lines.begin();
+ std::vector<CellData<1> >::const_iterator end_boundary_line
+ = subcelldata.boundary_lines.end();
+ for (; boundary_line!=end_boundary_line; ++boundary_line)
+ {
+ typename Triangulation<dim,spacedim>::line_iterator line;
+ std::pair<int,int> line_vertices(std::make_pair(boundary_line->vertices[0],
+ boundary_line->vertices[1]));
+ if (needed_lines.find(line_vertices) != needed_lines.end())
+ // line found in this
+ // direction
+ line = needed_lines[line_vertices];
+ else
+ {
+ // look whether it exists
+ // in reverse direction
+ std::swap (line_vertices.first, line_vertices.second);
+ if (needed_lines.find(line_vertices) != needed_lines.end())
+ line = needed_lines[line_vertices];
+ else
+ // line does not exist
+ AssertThrow (false, ExcLineInexistant(line_vertices.first,
+ line_vertices.second));
+ }
+
+ // assert that we only set
+ // boundary info once
+ AssertThrow (! (line->boundary_indicator() != 0 &&
+ line->boundary_indicator() != 255),
+ ExcMultiplySetLineInfoOfLine(line_vertices.first,
+ line_vertices.second));
+
+ // Assert that only exterior lines
+ // are given a boundary indicator
+ AssertThrow (! (line->boundary_indicator() == 255),
+ ExcInteriorLineCantBeBoundary());
+
+ line->set_boundary_indicator (boundary_line->material_id);
+ }
+
+
+ // finally update neighborship info
+ for (typename Triangulation<dim,spacedim>::cell_iterator
+ cell=triangulation.begin(); cell!=triangulation.end(); ++cell)
+ for (unsigned int side=0; side<4; ++side)
+ if (adjacent_cells[cell->line(side)->index()][0] == cell)
+ // first adjacent cell is
+ // this one
+ {
+ if (adjacent_cells[cell->line(side)->index()].size() == 2)
+ // there is another
+ // adjacent cell
+ cell->set_neighbor (side,
+ adjacent_cells[cell->line(side)->index()][1]);
+ }
+ // first adjacent cell is not this
+ // one, -> it must be the neighbor
+ // we are looking for
+ else
+ cell->set_neighbor (side,
+ adjacent_cells[cell->line(side)->index()][0]);
+ }
+
+
+/**
+ * Invent an object which compares two internal::Triangulation::TriaObject<2>
+ * against each other. This comparison is needed in order to establish a map
+ * of TriaObject<2> to iterators in the Triangulation<3,3>::create_triangulation
+ * function.
+ *
+ * Since this comparison is not canonical, we do not include it into the
+ * general internal::Triangulation::TriaObject<2> class.
+ */
+ struct QuadComparator
+ {
+ inline bool operator () (const internal::Triangulation::TriaObject<2> &q1,
+ const internal::Triangulation::TriaObject<2> &q2) const
+ {
+ // here is room to
+ // optimize the repeated
+ // equality test of the
+ // previous lines; the
+ // compiler will probably
+ // take care of most of
+ // it anyway
+ if ((q1.face(0) < q2.face(0)) ||
+ ((q1.face(0) == q2.face(0)) &&
+ (q1.face(1) < q2.face(1))) ||
+ ((q1.face(0) == q2.face(0)) &&
+ (q1.face(1) == q2.face(1)) &&
+ (q1.face(2) < q2.face(2))) ||
+ ((q1.face(0) == q2.face(0)) &&
+ (q1.face(1) == q2.face(1)) &&
+ (q1.face(2) == q2.face(2)) &&
+ (q1.face(3) < q2.face(3))))
+ return true;
+ else
+ return false;
+ }
+ };
+
+
+
+ template <int spacedim>
+ static
+ void
+ create_triangulation (const std::vector<Point<spacedim> > &v,
+ const std::vector<CellData<3> > &cells,
+ const SubCellData &subcelldata,
+ Triangulation<3,spacedim> &triangulation)
+ {
+ const unsigned int dim=3;
+
+ // copy vertices
+ triangulation.vertices = v;
+ triangulation.vertices_used = std::vector<bool> (v.size(), true);
+
+ // check that all cells have
+ // positive volume. if not call the
+ // invert_all_cells_of_negative_grid
+ // and reorder_cells function of
+ // GridReordering before creating
+ // the triangulation
+ for (unsigned int cell_no=0; cell_no<cells.size(); ++cell_no)
+ AssertThrow (dealii::GridTools::cell_measure(triangulation.vertices,
+ cells[cell_no].vertices) >= 0,
+ ExcGridHasInvalidCell(cell_no));
+
+ ///////////////////////////////////////
+ // first set up some collections of data
+ //
+ // make up a list of the needed
+ // lines
+ //
+ // each line is a pair of
+ // vertices. The list is kept
+ // sorted and it is guaranteed that
+ // each line is inserted only once.
+ // While the key of such an entry
+ // is the pair of vertices, the
+ // thing it points to is an
+ // iterator pointing to the line
+ // object itself. In the first run,
+ // these iterators are all invalid
+ // ones, but they are filled
+ // afterwards same applies for the
+ // quads
+ typename std::map<std::pair<int,int>,
+ typename Triangulation<dim,spacedim>::line_iterator> needed_lines;
+ for (unsigned int cell=0; cell<cells.size(); ++cell)
+ {
+ // check whether vertex indices
+ // are valid ones
+ for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+ AssertThrow (cells[cell].vertices[vertex] < triangulation.vertices.size(),
+ ExcInvalidVertexIndex (cell, cells[cell].vertices[vertex],
+ triangulation.vertices.size()));
+
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ {
+ // given a line vertex number
+ // (0,1) on a specific line we
+ // get the cell vertex number
+ // (0-7) through the
+ // line_to_cell_vertices
+ // function
+ std::pair<int,int> line_vertices(
+ cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
+ cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)]);
+
+ // if that line was already inserted
+ // in reverse order do nothing, else
+ // insert the line
+ if ( (needed_lines.find(std::make_pair(line_vertices.second,
+ line_vertices.first))
+ ==
+ needed_lines.end()))
+ {
+ // insert line, with
+ // invalid iterator. if line
+ // already exists, then
+ // nothing bad happens here
+ needed_lines[line_vertices] = triangulation.end_line();
+ }
+ }
+ }
+
+
+ /////////////////////////////////
+ // now for some sanity-checks:
+ //
+ // check that every vertex has at
+ // least tree adjacent lines
+ {
+ std::vector<unsigned short int> vertex_touch_count (v.size(), 0);
+ typename std::map<std::pair<int,int>,
+ typename Triangulation<dim,spacedim>::line_iterator>::iterator i;
+ for (i=needed_lines.begin(); i!=needed_lines.end(); i++)
+ {
+ // touch the vertices of
+ // this line
+ ++vertex_touch_count[i->first.first];
+ ++vertex_touch_count[i->first.second];
+ }
+
+ // assert minimum touch count
+ // is at least three. if not so,
+ // then clean triangulation and
+ // exit with an exception
+ AssertThrow (* (std::min_element(vertex_touch_count.begin(),
+ vertex_touch_count.end())) >= 3,
+ ExcGridHasInvalidVertices());
+ }
+
+
+ ///////////////////////////////////
+ // actually set up data structures
+ // for the lines
+ // reserve enough space
+ triangulation.levels.push_back (new internal::Triangulation::TriaLevel<dim>);
+ triangulation.faces = new internal::Triangulation::TriaFaces<dim>;
+ triangulation.levels[0]->reserve_space (cells.size(), dim);
+ triangulation.faces->lines.reserve_space (0,needed_lines.size());
+
+ // make up lines
+ {
+ typename Triangulation<dim,spacedim>::raw_line_iterator
+ line = triangulation.begin_raw_line();
+ typename std::map<std::pair<int,int>,
+ typename Triangulation<dim,spacedim>::line_iterator>::iterator i;
+ for (i = needed_lines.begin(); line!=triangulation.end_line(); ++line, ++i)
+ {
+ line->set (internal::Triangulation::TriaObject<1>(i->first.first,
+ i->first.second));
+ line->set_used_flag ();
+ line->clear_user_flag ();
+ line->clear_user_data ();
+
+ // now set the iterator for
+ // this line
+ i->second = line;
+ }
+ }
+
+
+ ///////////////////////////////////////////
+ // make up the quads of this triangulation
+ //
+ // same thing: the iterators are
+ // set to the invalid value at
+ // first, we only collect the data
+ // now
+
+ // the bool array stores, wether the lines
+ // are in the standard orientation or not
+
+ // note that QuadComparator is a
+ // class declared and defined in
+ // this file
+ std::map<internal::Triangulation::TriaObject<2>,
+ std::pair<typename Triangulation<dim,spacedim>::quad_iterator,
+ std_cxx1x::array<bool,GeometryInfo<dim>::lines_per_face> >,
+ QuadComparator>
+ needed_quads;
+ for (unsigned int cell=0; cell<cells.size(); ++cell)
+ {
+ // the faces are quads which
+ // consist of four numbers
+ // denoting the index of the
+ // four lines bounding the
+ // quad. we can get this index
+ // by asking @p{needed_lines}
+ // for an iterator to this
+ // line, dereferencing it and
+ // thus return an iterator into
+ // the @p{lines} array of the
+ // triangulation, which is
+ // already set up. we can then
+ // ask this iterator for its
+ // index within the present
+ // level (the level is zero, of
+ // course)
+ //
+ // to make things easier, we
+ // don't create the lines
+ // (pairs of their vertex
+ // indices) in place, but
+ // before they are really
+ // needed.
+ std::pair<int,int> line_list[GeometryInfo<dim>::lines_per_cell],
+ inverse_line_list[GeometryInfo<dim>::lines_per_cell];
+ unsigned int face_line_list[GeometryInfo<dim>::lines_per_face];
+ std_cxx1x::array<bool,GeometryInfo<dim>::lines_per_face> orientation;
+
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ {
+ line_list[line]=std::pair<int,int> (
+ cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
+ cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)]);
+ inverse_line_list[line]=std::pair<int,int> (
+ cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)],
+ cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)]);
+ }
+
+ for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+ {
+ // set up a list of the lines to be
+ // used for this face. check the
+ // direction for each line
+ //
+ // given a face line number (0-3) on
+ // a specific face we get the cell
+ // line number (0-11) through the
+ // face_to_cell_lines function
+ for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_face; ++l)
+ if (needed_lines.find (inverse_line_list[GeometryInfo<dim>::
+ face_to_cell_lines(face,l)]) == needed_lines.end())
+ {
+ face_line_list[l]=needed_lines[line_list[GeometryInfo<dim>::
+ face_to_cell_lines(face,l)]]->index();
+ orientation[l]=true;
+ }
+ else
+ {
+ face_line_list[l]=needed_lines[inverse_line_list[GeometryInfo<dim>::
+ face_to_cell_lines(face,l)]]->index();
+ orientation[l]=false;
+ }
+
+
+ internal::Triangulation::TriaObject<2>
+ quad(face_line_list[0],
+ face_line_list[1],
+ face_line_list[2],
+ face_line_list[3]);
+
+ // insert quad, with
+ // invalid iterator
+ //
+ // if quad already exists,
+ // then nothing bad happens
+ // here, as this will then
+ // simply become an
+ // interior face of the
+ // triangulation. however,
+ // we will run into major
+ // trouble if the face was
+ // already inserted in the
+ // opposite
+ // direction. there are
+ // really only two
+ // orientations for a face
+ // to be in, since the edge
+ // directions are already
+ // set. thus, vertex 0 is
+ // the one from which two
+ // edges originate, and
+ // vertex 3 is the one to
+ // which they converge. we
+ // are then left with
+ // orientations 0-1-2-3 and
+ // 2-3-0-1 for the order of
+ // lines. the
+ // corresponding quad can
+ // be easily constructed by
+ // exchanging lines. we do
+ // so here, just to check
+ // that that flipped quad
+ // isn't already in the
+ // triangulation. if it is,
+ // then don't insert the
+ // new one and instead
+ // later set the
+ // face_orientation flag
+ const internal::Triangulation::TriaObject<2>
+ test_quad_1(quad.face(2), quad.face(3),
+ quad.face(0), quad.face(1)),//face_orientation=false, face_flip=false, face_rotation=false
+ test_quad_2(quad.face(0), quad.face(1),
+ quad.face(3), quad.face(2)),//face_orientation=false, face_flip=false, face_rotation=true
+ test_quad_3(quad.face(3), quad.face(2),
+ quad.face(1), quad.face(0)),//face_orientation=false, face_flip=true, face_rotation=false
+ test_quad_4(quad.face(1), quad.face(0),
+ quad.face(2), quad.face(3)),//face_orientation=false, face_flip=true, face_rotation=true
+ test_quad_5(quad.face(2), quad.face(3),
+ quad.face(1), quad.face(0)),//face_orientation=true, face_flip=false, face_rotation=true
+ test_quad_6(quad.face(1), quad.face(0),
+ quad.face(3), quad.face(2)),//face_orientation=true, face_flip=true, face_rotation=false
+ test_quad_7(quad.face(3), quad.face(2),
+ quad.face(0), quad.face(1));//face_orientation=true, face_flip=true, face_rotation=true
+ if (needed_quads.find (test_quad_1) == needed_quads.end() &&
+ needed_quads.find (test_quad_2) == needed_quads.end() &&
+ needed_quads.find (test_quad_3) == needed_quads.end() &&
+ needed_quads.find (test_quad_4) == needed_quads.end() &&
+ needed_quads.find (test_quad_5) == needed_quads.end() &&
+ needed_quads.find (test_quad_6) == needed_quads.end() &&
+ needed_quads.find (test_quad_7) == needed_quads.end())
+ needed_quads[quad] = std::make_pair(triangulation.end_quad(),orientation);
+ }
+ }
+
+
+ /////////////////////////////////
+ // enter the resulting quads into
+ // the arrays of the Triangulation
+ //
+ // first reserve enough space
+ triangulation.faces->quads.reserve_space (0,needed_quads.size());
+
+ {
+ typename Triangulation<dim,spacedim>::raw_quad_iterator
+ quad = triangulation.begin_raw_quad();
+ typename std::map<internal::Triangulation::TriaObject<2>,
+ std::pair<typename Triangulation<dim,spacedim>::quad_iterator,
+ std_cxx1x::array<bool,GeometryInfo<dim>::lines_per_face> >,
+ QuadComparator>
+ ::iterator q;
+ for (q = needed_quads.begin(); quad!=triangulation.end_quad(); ++quad, ++q)
+ {
+ quad->set (q->first);
+ quad->set_used_flag ();
+ quad->clear_user_flag ();
+ quad->clear_user_data ();
+ // set the line orientation
+ quad->set_line_orientation(0,q->second.second[0]);
+ quad->set_line_orientation(1,q->second.second[1]);
+ quad->set_line_orientation(2,q->second.second[2]);
+ quad->set_line_orientation(3,q->second.second[3]);
+
+
+ // now set the iterator for
+ // this quad
+ q->second.first = quad;
+ }
+ }
+
+ /////////////////////////////////
+ // finally create the cells
+ triangulation.levels[0]->cells.reserve_space (cells.size());
+
+ // store for each quad index the
+ // adjacent cells
+ std::map<int,std::vector<typename Triangulation<dim,spacedim>::cell_iterator> >
+ adjacent_cells;
+
+ // finally make up cells
+ {
+ typename Triangulation<dim,spacedim>::raw_cell_iterator
+ cell = triangulation.begin_raw_hex();
+ for (unsigned int c=0; c<cells.size(); ++c, ++cell)
+ {
+ // first find for each of
+ // the cells the quad
+ // iterator of the
+ // respective faces.
+ //
+ // to this end, set up the
+ // lines of this cell and
+ // find the quads that are
+ // bounded by these lines;
+ // these are then the faces
+ // of the present cell
+ std::pair<int,int> line_list[GeometryInfo<dim>::lines_per_cell],
+ inverse_line_list[GeometryInfo<dim>::lines_per_cell];
+ unsigned int face_line_list[4];
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ {
+ line_list[line]=std::make_pair(
+ cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
+ cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)]);
+ inverse_line_list[line]=std::pair<int,int> (
+ cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)],
+ cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)]);
+ }
+
+ // get the iterators
+ // corresponding to the
+ // faces. also store
+ // whether they are
+ // reversed or not
+ typename Triangulation<dim,spacedim>::quad_iterator
+ face_iterator[GeometryInfo<dim>::faces_per_cell];
+ bool face_orientation[GeometryInfo<dim>::faces_per_cell];
+ bool face_flip[GeometryInfo<dim>::faces_per_cell];
+ bool face_rotation[GeometryInfo<dim>::faces_per_cell];
+ for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+ {
+ for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_face; ++l)
+ if (needed_lines.find (inverse_line_list[GeometryInfo<dim>::
+ face_to_cell_lines(face,l)]) == needed_lines.end())
+ face_line_list[l]=needed_lines[line_list[GeometryInfo<dim>::
+ face_to_cell_lines(face,l)]]->index();
+ else
+ face_line_list[l]=needed_lines[inverse_line_list[GeometryInfo<dim>::
+ face_to_cell_lines(face,l)]]->index();
+
+ internal::Triangulation::TriaObject<2>
+ quad(face_line_list[0],
+ face_line_list[1],
+ face_line_list[2],
+ face_line_list[3]);
+
+ if (needed_quads.find (quad) != needed_quads.end())
+ {
+ // face is in standard
+ // orientation (and not
+ // flipped or rotated). this
+ // must be true for at least
+ // one of the two cells
+ // containing this face
+ // (i.e. for the cell which
+ // originally inserted the
+ // face)
+ face_iterator[face] = needed_quads[quad].first;
+ face_orientation[face] = true;
+ face_flip[face]=false;
+ face_rotation[face]=false;
+ }
+ else
+ {
+ // face must be available in
+ // reverse order
+ // then. construct all
+ // possibilities and check
+ // them one after the other
+ const internal::Triangulation::TriaObject<2>
+ test_quad_1(quad.face(2), quad.face(3),
+ quad.face(0), quad.face(1)),//face_orientation=false, face_flip=false, face_rotation=false
+ test_quad_2(quad.face(0), quad.face(1),
+ quad.face(3), quad.face(2)),//face_orientation=false, face_flip=false, face_rotation=true
+ test_quad_3(quad.face(3), quad.face(2),
+ quad.face(1), quad.face(0)),//face_orientation=false, face_flip=true, face_rotation=false
+ test_quad_4(quad.face(1), quad.face(0),
+ quad.face(2), quad.face(3)),//face_orientation=false, face_flip=true, face_rotation=true
+ test_quad_5(quad.face(2), quad.face(3),
+ quad.face(1), quad.face(0)),//face_orientation=true, face_flip=false, face_rotation=true
+ test_quad_6(quad.face(1), quad.face(0),
+ quad.face(3), quad.face(2)),//face_orientation=true, face_flip=true, face_rotation=false
+ test_quad_7(quad.face(3), quad.face(2),
+ quad.face(0), quad.face(1));//face_orientation=true, face_flip=true, face_rotation=true
+ if (needed_quads.find (test_quad_1) != needed_quads.end())
+ {
+ face_iterator[face] = needed_quads[test_quad_1].first;
+ face_orientation[face] = false;
+ face_flip[face]=false;
+ face_rotation[face]=false;
+ }
+ else if (needed_quads.find (test_quad_2) != needed_quads.end())
+ {
+ face_iterator[face] = needed_quads[test_quad_2].first;
+ face_orientation[face] = false;
+ face_flip[face]=false;
+ face_rotation[face]=true;
+ }
+ else if (needed_quads.find (test_quad_3) != needed_quads.end())
+ {
+ face_iterator[face] = needed_quads[test_quad_3].first;
+ face_orientation[face] = false;
+ face_flip[face]=true;
+ face_rotation[face]=false;
+ }
+ else if (needed_quads.find (test_quad_4) != needed_quads.end())
+ {
+ face_iterator[face] = needed_quads[test_quad_4].first;
+ face_orientation[face] = false;
+ face_flip[face]=true;
+ face_rotation[face]=true;
+ }
+ else if (needed_quads.find (test_quad_5) != needed_quads.end())
+ {
+ face_iterator[face] = needed_quads[test_quad_5].first;
+ face_orientation[face] = true;
+ face_flip[face]=false;
+ face_rotation[face]=true;
+ }
+ else if (needed_quads.find (test_quad_6) != needed_quads.end())
+ {
+ face_iterator[face] = needed_quads[test_quad_6].first;
+ face_orientation[face] = true;
+ face_flip[face]=true;
+ face_rotation[face]=false;
+ }
+ else if (needed_quads.find (test_quad_7) != needed_quads.end())
+ {
+ face_iterator[face] = needed_quads[test_quad_7].first;
+ face_orientation[face] = true;
+ face_flip[face]=true;
+ face_rotation[face]=true;
+ }
+
+ else
+ // we didn't find the
+ // face in any direction,
+ // so something went
+ // wrong above
+ Assert(false,ExcInternalError());
+
+ }
+ }// for all faces
+
+ // make the cell out of
+ // these iterators
+ cell->set (internal::Triangulation
+ ::TriaObject<3> (face_iterator[0]->index(),
+ face_iterator[1]->index(),
+ face_iterator[2]->index(),
+ face_iterator[3]->index(),
+ face_iterator[4]->index(),
+ face_iterator[5]->index()));
+
+ cell->set_used_flag ();
+ cell->set_material_id (cells[c].material_id);
+ cell->clear_user_flag ();
+ cell->clear_user_data ();
+ cell->set_subdomain_id (0);
+
+ // set orientation flag for
+ // each of the faces
+ for (unsigned int quad=0; quad<GeometryInfo<dim>::faces_per_cell; ++quad)
+ {
+ cell->set_face_orientation (quad, face_orientation[quad]);
+ cell->set_face_flip (quad, face_flip[quad]);
+ cell->set_face_rotation (quad, face_rotation[quad]);
+ }
+
+
+ // note that this cell is
+ // adjacent to the six
+ // quads
+ for (unsigned int quad=0; quad<GeometryInfo<dim>::faces_per_cell; ++quad)
+ adjacent_cells[face_iterator[quad]->index()].push_back (cell);
+
+#ifdef DEBUG
+ // make some checks on the
+ // lines and their
+ // ordering
+
+ // first map all cell lines
+ // to the two face lines
+ // which should
+ // coincide. all face lines
+ // are included with a cell
+ // line number (0-11)
+ // key. At the end all keys
+ // will be included twice
+ // (for each of the two
+ // coinciding lines once)
+ std::multimap<unsigned int, std::pair<unsigned int, unsigned int> >
+ cell_to_face_lines;
+ for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_face; ++line)
+ cell_to_face_lines.insert(
+ std::pair<unsigned int, std::pair<unsigned int, unsigned int> > (
+ GeometryInfo<dim>::face_to_cell_lines(face,line),
+ std::pair<unsigned int, unsigned int> (face,line)));
+ std::multimap<unsigned int, std::pair<unsigned int, unsigned int> >::const_iterator
+ map_iter=cell_to_face_lines.begin();
+
+ for (; map_iter!=cell_to_face_lines.end(); ++map_iter)
+ {
+ const unsigned int cell_line=map_iter->first;
+ const unsigned int face1=map_iter->second.first;
+ const unsigned int line1=map_iter->second.second;
+ ++map_iter;
+ Assert(map_iter!=cell_to_face_lines.end(), ExcInternalErrorOnCell(c));
+ Assert(map_iter->first==cell_line, ExcInternalErrorOnCell(c));
+ const unsigned int face2=map_iter->second.first;
+ const unsigned int line2=map_iter->second.second;
+
+ // check that the pair
+ // of lines really
+ // coincide. Take care
+ // about the face
+ // orientation;
+ Assert (face_iterator[face1]->line(GeometryInfo<dim>::standard_to_real_face_line(
+ line1,
+ face_orientation[face1],
+ face_flip[face1],
+ face_rotation[face1])) ==
+ face_iterator[face2]->line(GeometryInfo<dim>::standard_to_real_face_line(
+ line2,
+ face_orientation[face2],
+ face_flip[face2],
+ face_rotation[face2])),
+ ExcInternalErrorOnCell(c));
+ }
+#endif
+ }
+ }
+
+
+ /////////////////////////////////////////
+ // find those quads which are at the
+ // boundary and mark them appropriately
+ for (typename Triangulation<dim,spacedim>::quad_iterator
+ quad=triangulation.begin_quad(); quad!=triangulation.end_quad(); ++quad)
+ {
+ const unsigned int n_adj_cells = adjacent_cells[quad->index()].size();
+ // assert that every quad has
+ // one or two adjacent cells
+ AssertThrow ((n_adj_cells >= 1) &&
+ (n_adj_cells <= 2),
+ ExcInternalError());
+
+ // if only one cell: quad is at
+ // boundary -> give it the
+ // boundary indicator zero by
+ // default
+ if (n_adj_cells == 1)
+ quad->set_boundary_indicator (0);
+ else
+ // interior quad -> 255
+ quad->set_boundary_indicator (255);
+ }
+
+ /////////////////////////////////////////
+ // next find those lines which are at
+ // the boundary and mark all others as
+ // interior ones
+ //
+ // for this: first mark all lines
+ // as interior
+ for (typename Triangulation<dim,spacedim>::line_iterator
+ line=triangulation.begin_line(); line!=triangulation.end_line(); ++line)
+ line->set_boundary_indicator (255);
+ // next reset all lines bounding
+ // boundary quads as on the
+ // boundary also. note that since
+ // we are in 3d, there are cases
+ // where one or more lines of a
+ // quad that is not on the
+ // boundary, are actually boundary
+ // lines. they will not be marked
+ // when visiting this
+ // face. however, since we do not
+ // support dim-2 dimensional
+ // boundaries (i.e. internal lines
+ // constituting boundaries), every
+ // such line is also part of a face
+ // that is actually on the
+ // boundary, so sooner or later we
+ // get to mark that line for being
+ // on the boundary
+ for (typename Triangulation<dim,spacedim>::quad_iterator
+ quad=triangulation.begin_quad(); quad!=triangulation.end_quad(); ++quad)
+ if (quad->at_boundary())
+ for (unsigned int l=0; l<4; ++l)
+ quad->line(l)->set_boundary_indicator (0);
+
+ ///////////////////////////////////////
+ // now set boundary indicators
+ // where given
+ //
+ // first do so for lines
+ std::vector<CellData<1> >::const_iterator boundary_line
+ = subcelldata.boundary_lines.begin();
+ std::vector<CellData<1> >::const_iterator end_boundary_line
+ = subcelldata.boundary_lines.end();
+ for (; boundary_line!=end_boundary_line; ++boundary_line)
+ {
+ typename Triangulation<dim,spacedim>::line_iterator line;
+ std::pair <int, int> line_vertices(std::make_pair(boundary_line->vertices[0],
+ boundary_line->vertices[1]));
+ if (needed_lines.find(line_vertices) != needed_lines.end())
+ // line found in this
+ // direction
+ line = needed_lines[line_vertices];
+
+ else
+ {
+ // look wether it exists in
+ // reverse direction
+ std::swap (line_vertices.first, line_vertices.second);
+ if (needed_lines.find(line_vertices) != needed_lines.end())
+ line = needed_lines[line_vertices];
+ else
+ // line does not exist
+ AssertThrow (false, ExcLineInexistant(line_vertices.first,
+ line_vertices.second));
+ }
+ // Assert that only exterior
+ // lines are given a boundary
+ // indicator
+ AssertThrow (line->at_boundary(),
+ ExcInteriorLineCantBeBoundary());
+
+ // and make sure that we don't
+ // attempt to reset the
+ // boundary indicator to a
+ // different than the
+ // previously set value
+ if (line->boundary_indicator() != 0)
+ AssertThrow (line->boundary_indicator() == boundary_line->material_id,
+ ExcMessage ("Duplicate boundary lines are only allowed "
+ "if they carry the same boundary indicator."));
+
+ line->set_boundary_indicator (boundary_line->material_id);
+ }
+
+
+ // now go on with boundary faces
+ std::vector<CellData<2> >::const_iterator boundary_quad
+ = subcelldata.boundary_quads.begin();
+ std::vector<CellData<2> >::const_iterator end_boundary_quad
+ = subcelldata.boundary_quads.end();
+ for (; boundary_quad!=end_boundary_quad; ++boundary_quad)
+ {
+ typename Triangulation<dim,spacedim>::quad_iterator quad;
+ typename Triangulation<dim,spacedim>::line_iterator line[4];
+
+ // first find the lines that
+ // are made up of the given
+ // vertices, then build up a
+ // quad from these lines
+ // finally use the find
+ // function of the map template
+ // to find the quad
+ for (unsigned int i=0; i<4; ++i)
+ {
+ std::pair<int, int> line_vertices(
+ boundary_quad->vertices[GeometryInfo<dim-1>::line_to_cell_vertices(i,0)],
+ boundary_quad->vertices[GeometryInfo<dim-1>::line_to_cell_vertices(i,1)]);
+
+ // check whether line
+ // already exists
+ if (needed_lines.find(line_vertices) != needed_lines.end())
+ line[i] = needed_lines[line_vertices];
+ else
+ // look wether it exists
+ // in reverse direction
+ {
+ std::swap (line_vertices.first, line_vertices.second);
+ if (needed_lines.find(line_vertices) != needed_lines.end())
+ line[i] = needed_lines[line_vertices];
+ else
+ // line does
+ // not exist
+ AssertThrow (false, ExcLineInexistant(line_vertices.first,
+ line_vertices.second));
+ }
+ }
+
+
+ // Set up 2 quads that are
+ // built up from the lines for
+ // reasons of comparison to
+ // needed_quads. The second
+ // quad is the reversed version
+ // of the first quad in order
+ // find the quad regardless of
+ // its orientation. This is
+ // introduced for convenience
+ // and because boundary quad
+ // orientation does not carry
+ // any information.
+ internal::Triangulation::TriaObject<2>
+ quad_compare_1(line[0]->index(), line[1]->index(),
+ line[2]->index(), line[3]->index());
+ internal::Triangulation::TriaObject<2>
+ quad_compare_2(line[2]->index(), line[3]->index(),
+ line[0]->index(), line[1]->index());
+
+ // try to find the quad with
+ // lines situated as
+ // constructed above. if it
+ // could not be found, rotate
+ // the boundary lines 3 times
+ // until it is found or it does
+ // not exist.
+
+ // mapping from counterclock to
+ // lexicographic ordering of
+ // quad lines
+ static const unsigned int lex2cclock[4]={3,1,0,2};
+ // copy lines from
+ // lexicographic to
+ // counterclock ordering, as
+ // rotation is much simpler in
+ // counterclock ordering
+ typename Triangulation<dim,spacedim>::line_iterator
+ line_counterclock[4];
+ for (unsigned int i=0; i<4; ++i)
+ line_counterclock[lex2cclock[i]]=line[i];
+ unsigned int n_rotations=0;
+ bool not_found_quad_1;
+ while ( (not_found_quad_1=(needed_quads.find(quad_compare_1) == needed_quads.end())) &&
+ ( needed_quads.find(quad_compare_2) == needed_quads.end()) &&
+ (n_rotations<4))
+ {
+ // use the rotate defined
+ // in <algorithms>
+ rotate(line_counterclock, line_counterclock+1, line_counterclock+4);
+ // update the quads with
+ // rotated lines (i runs in
+ // lexicographic ordering)
+ for (unsigned int i=0; i<4; ++i)
+ {
+ quad_compare_1.set_face(i, line_counterclock[lex2cclock[i]]->index());
+ quad_compare_2.set_face((i+2)%4, line_counterclock[lex2cclock[i]]->index());
+ }
+
+ ++n_rotations;
+ }
+
+ AssertThrow (n_rotations!=4,
+ ExcQuadInexistant(line[0]->index(), line[1]->index(),
+ line[2]->index(), line[3]->index()));
+
+ if (not_found_quad_1)
+ quad = needed_quads[quad_compare_2].first;
+ else
+ quad = needed_quads[quad_compare_1].first;
+
+ // check whether this face is
+ // really an exterior one
+ AssertThrow (quad->at_boundary(),
+ ExcInteriorQuadCantBeBoundary());
+
+ // and make sure that we don't
+ // attempt to reset the
+ // boundary indicator to a
+ // different than the
+ // previously set value
+ if (quad->boundary_indicator() != 0)
+ AssertThrow (quad->boundary_indicator() == boundary_quad->material_id,
+ ExcMessage ("Duplicate boundary quads are only allowed "
+ "if they carry the same boundary indicator."));
+
+ quad->set_boundary_indicator (boundary_quad->material_id);
+ }
+
+
+ /////////////////////////////////////////
+ // finally update neighborship info
+ for (typename Triangulation<dim,spacedim>::cell_iterator
+ cell=triangulation.begin(); cell!=triangulation.end(); ++cell)
+ for (unsigned int face=0; face<6; ++face)
+ if (adjacent_cells[cell->quad(face)->index()][0] == cell)
+ // first adjacent cell is
+ // this one
+ {
+ if (adjacent_cells[cell->quad(face)->index()].size() == 2)
+ // there is another
+ // adjacent cell
+ cell->set_neighbor (face,
+ adjacent_cells[cell->quad(face)->index()][1]);
+ }
+ // first adjacent cell is not this
+ // one, -> it must be the neighbor
+ // we are looking for
+ else
+ cell->set_neighbor (face,
+ adjacent_cells[cell->quad(face)->index()][0]);
+ }
+
+
+ /**
+ * Distort a 1d triangulation in
+ * some random way.
+ */
+ template <int spacedim>
+ static
+ void
+ distort_random (const double factor,
+ const bool keep_boundary,
+ Triangulation<1,spacedim> &triangulation)
+ {
+ const unsigned int dim = 1;
+
+ // if spacedim>1 we need to
+ // make sure that we perturb
+ // points but keep them on
+ // the manifold
+ Assert (spacedim == 1,
+ ExcNotImplemented());
+
+ // this function is mostly
+ // equivalent to that for the
+ // general dimensional case the
+ // only difference being the
+ // correction for split faces which
+ // is not necessary in 1D
+
+ // find the smallest length of the
+ // lines adjacent to the
+ // vertex. take the initial value
+ // to be larger than anything that
+ // might be found: the diameter of
+ // the triangulation, here computed
+ // by adding up the diameters of
+ // the coarse grid cells.
+ double almost_infinite_length = 0;
+ for (typename Triangulation<dim,spacedim>::cell_iterator
+ cell=triangulation.begin(0); cell!=triangulation.end(0); ++cell)
+ almost_infinite_length += cell->diameter();
+
+ std::vector<double> minimal_length (triangulation.vertices.size(),
+ almost_infinite_length);
+ // also note if a vertex is at
+ // the boundary
+ std::vector<bool> at_boundary (triangulation.vertices.size(), false);
+
+ for (typename Triangulation<dim,spacedim>::active_line_iterator
+ line=triangulation.begin_active_line();
+ line != triangulation.end_line(); ++line)
+ {
+ if (keep_boundary && line->at_boundary())
+ {
+ at_boundary[line->vertex_index(0)] = true;
+ at_boundary[line->vertex_index(1)] = true;
+ }
+
+ minimal_length[line->vertex_index(0)]
+ = std::min(line->diameter(),
+ minimal_length[line->vertex_index(0)]);
+ minimal_length[line->vertex_index(1)]
+ = std::min(line->diameter(),
+ minimal_length[line->vertex_index(1)]);
+ }
+
+
+ const unsigned int n_vertices = triangulation.vertices.size();
+ Point<spacedim> shift_vector;
+
+ for (unsigned int vertex=0; vertex<n_vertices; ++vertex)
+ {
+ // ignore this vertex if we
+ // whall keep the boundary and
+ // this vertex *is* at the
+ // boundary
+ if (keep_boundary && at_boundary[vertex])
+ continue;
+
+ // first compute a random shift
+ // vector
+ for (unsigned int d=0; d<spacedim; ++d)
+ shift_vector(d) = std::rand()*1.0/RAND_MAX;
+
+ shift_vector *= factor * minimal_length[vertex] /
+ std::sqrt(shift_vector.square());
+
+ // finally move the vertex
+ triangulation.vertices[vertex] += shift_vector;
+ }
+ }
+
+
+ /**
+ * Distort a triangulation in
+ * some random way. This is the
+ * function taken for the case
+ * dim>1.
+ */
+ template <int dim, int spacedim>
+ static
+ void
+ distort_random (const double factor,
+ const bool keep_boundary,
+ Triangulation<dim,spacedim> &triangulation)
+ {
+//TODO:[?]Implement the random distortion in Triangulation for hanging nodes as well
+// Hanging nodes need to be reset to the correct mean value
+// at the end, which is simple for 2D but difficult for 3D. Maybe take
+// a look at how we get to the original location of the point in the
+// execute_refinement function and copy the relevant lines.
+
+ // this function is mostly
+ // equivalent to that for the
+ // general dimensional case the
+ // only difference being the
+ // correction for split faces which
+ // is not necessary in 1D
+ //
+ // if you change something here,
+ // don't forget to do so there as
+ // well
+
+ // find the smallest length of the
+ // lines adjacent to the
+ // vertex. take the initial value
+ // to be larger than anything that
+ // might be found: the diameter of
+ // the triangulation, here
+ // estimated by adding up the
+ // diameters of the coarse grid
+ // cells.
+ double almost_infinite_length = 0;
+ for (typename Triangulation<dim,spacedim>::cell_iterator
+ cell=triangulation.begin(0); cell!=triangulation.end(0); ++cell)
+ almost_infinite_length += cell->diameter();
+
+ std::vector<double> minimal_length (triangulation.vertices.size(),
+ almost_infinite_length);
+
+ // also note if a vertex is at the
+ // boundary
+ std::vector<bool> at_boundary (triangulation.vertices.size(), false);
+
+ for (typename Triangulation<dim,spacedim>::active_line_iterator
+ line=triangulation.begin_active_line();
+ line != triangulation.end_line(); ++line)
+ {
+ if (keep_boundary && line->at_boundary())
+ {
+ at_boundary[line->vertex_index(0)] = true;
+ at_boundary[line->vertex_index(1)] = true;
+ }
+
+ minimal_length[line->vertex_index(0)]
+ = std::min(line->diameter(),
+ minimal_length[line->vertex_index(0)]);
+ minimal_length[line->vertex_index(1)]
+ = std::min(line->diameter(),
+ minimal_length[line->vertex_index(1)]);
+ }
+
+
+ const unsigned int n_vertices = triangulation.vertices.size();
+ Point<spacedim> shift_vector;
+
+ for (unsigned int vertex=0; vertex<n_vertices; ++vertex)
+ {
+ // ignore this vertex if we
+ // whall keep the boundary and
+ // this vertex *is* at the
+ // boundary
+ if (keep_boundary && at_boundary[vertex])
+ continue;
+
+ // first compute a random shift
+ // vector
+ for (unsigned int d=0; d<spacedim; ++d)
+ shift_vector(d) = std::rand()*1.0/RAND_MAX;
+
+ shift_vector *= factor * minimal_length[vertex] /
+ std::sqrt(shift_vector.square());
+
+ // finally move the vertex
+ triangulation.vertices[vertex] += shift_vector;
+ }
+
+
+ // finally correct hanging nodes
+ // again. The following is not
+ // necessary for 1D
+ typename Triangulation<dim,spacedim>::active_cell_iterator
+ cell = triangulation.begin_active(),
+ endc = triangulation.end();
+ for (; cell!=endc; ++cell)
+ for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+ if (cell->face(face)->has_children() &&
+ !cell->face(face)->at_boundary())
+ // this lines has children,
+ // thus there are restricted
+ // nodes
+ {
+ // not implemented at
+ // present for dim=3 or
+ // higher
+ Assert (dim<=2, ExcNotImplemented());
+
+ // compute where the common
+ // point of the two child
+ // lines will lie and reset
+ // it to the correct value
+ triangulation.vertices[cell->face(face)->child(0)->vertex_index(1)]
+ = (cell->face(face)->vertex(0) +
+ cell->face(face)->vertex(1)) / 2;
+ }
+ }
+
+
+ /**
+ * Actually delete a cell, or rather all
+ * its children, which is the main step for
+ * the coarsening process. This is the
+ * dimension dependent part of @p
+ * execute_coarsening. The second argument
+ * is a vector which gives for each line
+ * index the number of cells containing
+ * this line. This information is needed to
+ * decide whether a refined line may be
+ * coarsened or not in 3D. In 1D and 2D
+ * this argument is not needed and thus
+ * ignored. The same applies for the last
+ * argument and quads instead of lines.
+ */
+ template <int spacedim>
+ static
+ void
+ delete_children (Triangulation<1,spacedim> &triangulation,
+ typename Triangulation<1,spacedim>::cell_iterator &cell,
+ std::vector<unsigned int> &,
+ std::vector<unsigned int> &)
+ {
+ const unsigned int dim = 1;
+
+ // first we need to reset the
+ // neighbor pointers of the
+ // neighbors of this cell's
+ // children to this cell. This is
+ // different for one dimension,
+ // since there neighbors can have a
+ // refinement level differing from
+ // that of this cell's children by
+ // more than one level.
+
+ Assert (!cell->child(0)->has_children() && !cell->child(1)->has_children(),
+ ExcInternalError());
+
+ // first do it for the cells to the
+ // left
+ if (cell->neighbor(0).state() == IteratorState::valid)
+ if (cell->neighbor(0)->has_children())
+ {
+ typename Triangulation<dim,spacedim>::cell_iterator
+ neighbor = cell->neighbor(0);
+ Assert (neighbor->level() == cell->level(), ExcInternalError());
+
+ // right child
+ neighbor = neighbor->child(1);
+ while (1)
+ {
+ Assert (neighbor->neighbor(1) == cell->child(0),
+ ExcInternalError());
+ neighbor->set_neighbor (1, cell);
+
+ // move on to further
+ // children on the
+ // boundary between this
+ // cell and its neighbor
+ if (neighbor->has_children())
+ neighbor = neighbor->child(1);
+ else
+ break;
+ }
+ }
+
+ // now do it for the cells to the
+ // left
+ if (cell->neighbor(1).state() == IteratorState::valid)
+ if (cell->neighbor(1)->has_children())
+ {
+ typename Triangulation<dim,spacedim>::cell_iterator
+ neighbor = cell->neighbor(1);
+ Assert (neighbor->level() == cell->level(), ExcInternalError());
+
+ // left child
+ neighbor = neighbor->child(0);
+ while (1)
+ {
+ Assert (neighbor->neighbor(0) == cell->child(1),
+ ExcInternalError());
+ neighbor->set_neighbor (0, cell);
+
+ // move on to further
+ // children on the
+ // boundary between this
+ // cell and its neighbor
+ if (neighbor->has_children())
+ neighbor = neighbor->child(0);
+ else
+ break;
+ }
+ }
+
+
+ // delete the vertex which will not
+ // be needed anymore. This vertex
+ // is the second of the first child
+ triangulation.vertices_used[cell->child(0)->vertex_index(1)] = false;
+
+ // invalidate children. clear user
+ // pointers, to avoid that they may
+ // appear at unwanted places later
+ // on...
+ for (unsigned int child=0; child<cell->n_children(); ++child)
+ {
+ cell->child(child)->clear_user_data();
+ cell->child(child)->clear_user_flag();
+ cell->child(child)->clear_used_flag();
+ }
+
+
+ // delete pointer to children
+ cell->clear_children ();
+ cell->clear_user_flag();
+ }
+
+
+
+ template <int spacedim>
+ static
+ void
+ delete_children (Triangulation<2,spacedim> &triangulation,
+ typename Triangulation<2,spacedim>::cell_iterator &cell,
+ std::vector<unsigned int> &line_cell_count,
+ std::vector<unsigned int> &)
+ {
+ const unsigned int dim=2;
+ const RefinementCase<dim> ref_case=cell->refinement_case();
+
+ Assert(line_cell_count.size()==triangulation.n_raw_lines(), ExcInternalError());
+
+ // vectors to hold all lines which
+ // may be deleted
+ std::vector<typename Triangulation<dim,spacedim>::line_iterator>
+ lines_to_delete(0);
+
+ lines_to_delete.reserve(4*2+4);
+
+ // now we decrease the counters for
+ // lines contained in the child
+ // cells
+ for (unsigned int c=0; c<cell->n_children(); ++c)
+ {
+ typename Triangulation<dim,spacedim>::cell_iterator
+ child=cell->child(c);
+ for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
+ --line_cell_count[child->line_index(l)];
+ }
+
+
+ // delete the vertex which will not
+ // be needed anymore. This vertex
+ // is the second of the second line
+ // of the first child, if the cell
+ // is refined with cut_xy, else there
+ // is no inner vertex.
+ // additionally delete unneeded inner
+ // lines
+ if (ref_case==RefinementCase<dim>::cut_xy)
+ {
+ triangulation.vertices_used[cell->child(0)->line(1)->vertex_index(1)] = false;
+
+ lines_to_delete.push_back(cell->child(0)->line(1));
+ lines_to_delete.push_back(cell->child(0)->line(3));
+ lines_to_delete.push_back(cell->child(3)->line(0));
+ lines_to_delete.push_back(cell->child(3)->line(2));
+ }
+ else
+ {
+ unsigned int inner_face_no=ref_case==RefinementCase<dim>::cut_x ? 1 : 3;
+
+ // the inner line will not be
+ // used any more
+ lines_to_delete.push_back(cell->child(0)->line(inner_face_no));
+ }
+
+ // invalidate children
+ for (unsigned int child=0; child<cell->n_children(); ++child)
+ {
+ cell->child(child)->clear_user_data();
+ cell->child(child)->clear_user_flag();
+ cell->child(child)->clear_used_flag();
+ }
+
+
+ // delete pointer to children
+ cell->clear_children ();
+ cell->clear_refinement_case();
+ cell->clear_user_flag();
+
+ // look at the refinement of outer
+ // lines. if nobody needs those
+ // anymore we can add them to the
+ // list of lines to be deleted.
+ for (unsigned int line_no=0; line_no<GeometryInfo<dim>::lines_per_cell; ++line_no)
+ {
+ typename Triangulation<dim,spacedim>::line_iterator
+ line=cell->line(line_no);
+
+ if (line->has_children())
+ {
+ // if one of the cell counters is
+ // zero, the other has to be as well
+
+ Assert((line_cell_count[line->child_index(0)] == 0 &&
+ line_cell_count[line->child_index(1)] == 0) ||
+ (line_cell_count[line->child_index(0)] > 0 &&
+ line_cell_count[line->child_index(1)] > 0),
+ ExcInternalError());
+
+ if (line_cell_count[line->child_index(0)]==0)
+ {
+ for (unsigned int c=0; c<2; ++c)
+ Assert (!line->child(c)->has_children(),
+ ExcInternalError());
+
+ // we may delete the line's
+ // children and the middle vertex
+ // as no cell references them
+ // anymore
+ triangulation.vertices_used[line->child(0)->vertex_index(1)] = false;
+
+ lines_to_delete.push_back(line->child(0));
+ lines_to_delete.push_back(line->child(1));
+
+ line->clear_children();
+ }
+ }
+ }
+
+ // finally, delete unneeded lines
+
+ // clear user pointers, to avoid that
+ // they may appear at unwanted places
+ // later on...
+ // same for user flags, then finally
+ // delete the lines
+ typename std::vector<typename Triangulation<dim,spacedim>::line_iterator>::iterator
+ line=lines_to_delete.begin(),
+ endline=lines_to_delete.end();
+ for (; line!=endline; ++line)
+ {
+ (*line)->clear_user_data();
+ (*line)->clear_user_flag();
+ (*line)->clear_used_flag();
+ }
+ }
+
+
+
+ template <int spacedim>
+ static
+ void
+ delete_children (Triangulation<3,spacedim> &triangulation,
+ typename Triangulation<3,spacedim>::cell_iterator &cell,
+ std::vector<unsigned int> &line_cell_count,
+ std::vector<unsigned int> &quad_cell_count)
+ {
+ const unsigned int dim=3;
+
+ Assert(line_cell_count.size()==triangulation.n_raw_lines(), ExcInternalError());
+ Assert(quad_cell_count.size()==triangulation.n_raw_quads(), ExcInternalError());
+
+ // first of all, we store the RefineCase of
+ // this cell
+ const RefinementCase<dim> ref_case=cell->refinement_case();
+ // vectors to hold all lines and quads which
+ // may be deleted
+ std::vector<typename Triangulation<dim,spacedim>::line_iterator>
+ lines_to_delete(0);
+ std::vector<typename Triangulation<dim,spacedim>::quad_iterator>
+ quads_to_delete(0);
+
+ lines_to_delete.reserve(12*2+6*4+6);
+ quads_to_delete.reserve(6*4+12);
+
+ // now we decrease the counters for lines and
+ // quads contained in the child cells
+ for (unsigned int c=0; c<cell->n_children(); ++c)
+ {
+ typename Triangulation<dim,spacedim>::cell_iterator
+ child=cell->child(c);
+ for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
+ --line_cell_count[child->line_index(l)];
+ for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+ --quad_cell_count[child->quad_index(f)];
+ }
+
+ ///////////////////////////////////////
+ // delete interior quads and lines and the
+ // interior vertex, depending on the
+ // refinement case of the cell
+ //
+ // for append quads and lines: only append
+ // them to the list of objects to be deleted
+
+ switch (ref_case)
+ {
+ case RefinementCase<dim>::cut_x:
+ quads_to_delete.push_back(cell->child(0)->face(1));
+ break;
+ case RefinementCase<dim>::cut_y:
+ quads_to_delete.push_back(cell->child(0)->face(3));
+ break;
+ case RefinementCase<dim>::cut_z:
+ quads_to_delete.push_back(cell->child(0)->face(5));
+ break;
+ case RefinementCase<dim>::cut_xy:
+ quads_to_delete.push_back(cell->child(0)->face(1));
+ quads_to_delete.push_back(cell->child(0)->face(3));
+ quads_to_delete.push_back(cell->child(3)->face(0));
+ quads_to_delete.push_back(cell->child(3)->face(2));
+
+ lines_to_delete.push_back(cell->child(0)->line(11));
+ break;
+ case RefinementCase<dim>::cut_xz:
+ quads_to_delete.push_back(cell->child(0)->face(1));
+ quads_to_delete.push_back(cell->child(0)->face(5));
+ quads_to_delete.push_back(cell->child(3)->face(0));
+ quads_to_delete.push_back(cell->child(3)->face(4));
+
+ lines_to_delete.push_back(cell->child(0)->line(5));
+ break;
+ case RefinementCase<dim>::cut_yz:
+ quads_to_delete.push_back(cell->child(0)->face(3));
+ quads_to_delete.push_back(cell->child(0)->face(5));
+ quads_to_delete.push_back(cell->child(3)->face(2));
+ quads_to_delete.push_back(cell->child(3)->face(4));
+
+ lines_to_delete.push_back(cell->child(0)->line(7));
+ break;
+ case RefinementCase<dim>::cut_xyz:
+ quads_to_delete.push_back(cell->child(0)->face(1));
+ quads_to_delete.push_back(cell->child(2)->face(1));
+ quads_to_delete.push_back(cell->child(4)->face(1));
+ quads_to_delete.push_back(cell->child(6)->face(1));
+
+ quads_to_delete.push_back(cell->child(0)->face(3));
+ quads_to_delete.push_back(cell->child(1)->face(3));
+ quads_to_delete.push_back(cell->child(4)->face(3));
+ quads_to_delete.push_back(cell->child(5)->face(3));
+
+ quads_to_delete.push_back(cell->child(0)->face(5));
+ quads_to_delete.push_back(cell->child(1)->face(5));
+ quads_to_delete.push_back(cell->child(2)->face(5));
+ quads_to_delete.push_back(cell->child(3)->face(5));
+
+ lines_to_delete.push_back(cell->child(0)->line(5));
+ lines_to_delete.push_back(cell->child(0)->line(7));
+ lines_to_delete.push_back(cell->child(0)->line(11));
+ lines_to_delete.push_back(cell->child(7)->line(0));
+ lines_to_delete.push_back(cell->child(7)->line(2));
+ lines_to_delete.push_back(cell->child(7)->line(8));
+ // delete the vertex which will not
+ // be needed anymore. This vertex
+ // is the vertex at the heart of
+ // this cell, which is the sixth of
+ // the first child
+ triangulation.vertices_used[cell->child(0)->vertex_index(7)] = false;
+ break;
+ default:
+ // only remaining case is
+ // no_refinement, thus an error
+ Assert(false, ExcInternalError());
+ break;
+ }
+
+
+ // invalidate children
+ for (unsigned int child=0; child<cell->n_children(); ++child)
+ {
+ cell->child(child)->clear_user_data();
+ cell->child(child)->clear_user_flag();
+
+ for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+ {
+ // set flags denoting deviations from
+ // standard orientation of faces back
+ // to initialization values
+ cell->child(child)->set_face_orientation (f, true);
+ cell->child(child)->set_face_flip(f,false);
+ cell->child(child)->set_face_rotation(f,false);
+ }
+
+ cell->child(child)->clear_used_flag();
+ }
+
+
+ // delete pointer to children
+ cell->clear_children ();
+ cell->clear_refinement_case ();
+ cell->clear_user_flag();
+
+ // so far we only looked at inner quads,
+ // lines and vertices. Now we have to
+ // consider outer ones as well. here, we have
+ // to check, whether there are other cells
+ // still needing these objects. oherwise we
+ // can delete them. first for quads (and
+ // their inner lines).
+
+ for (unsigned int quad_no=0; quad_no<GeometryInfo<dim>::faces_per_cell; ++quad_no)
+ {
+ typename Triangulation<dim,spacedim>::quad_iterator
+ quad=cell->face(quad_no);
+
+ Assert((GeometryInfo<dim>::face_refinement_case(ref_case,quad_no) && quad->has_children()) ||
+ GeometryInfo<dim>::face_refinement_case(ref_case,quad_no)==RefinementCase<dim-1>::no_refinement,
+ ExcInternalError());
+
+ switch (quad->refinement_case())
+ {
+ case RefinementCase<dim-1>::no_refinement:
+ // nothing to do as the quad
+ // is not refined
+ break;
+ case RefinementCase<dim-1>::cut_x:
+ case RefinementCase<dim-1>::cut_y:
+ {
+ // if one of the cell counters is
+ // zero, the other has to be as
+ // well
+ Assert((quad_cell_count[quad->child_index(0)] == 0 &&
+ quad_cell_count[quad->child_index(1)] == 0) ||
+ (quad_cell_count[quad->child_index(0)] > 0 &&
+ quad_cell_count[quad->child_index(1)] > 0),
+ ExcInternalError());
+ // it might be, that the quad is
+ // refined twice anisotropically,
+ // first check, whether we may
+ // delete possible grand_children
+ unsigned int deleted_grandchildren=0;
+ unsigned int number_of_child_refinements=0;
+
+ for (unsigned int c=0; c<2; ++c)
+ if (quad->child(c)->has_children())
+ {
+ ++number_of_child_refinements;
+ // if one of the cell counters is
+ // zero, the other has to be as
+ // well
+ Assert((quad_cell_count[quad->child(c)->child_index(0)] == 0 &&
+ quad_cell_count[quad->child(c)->child_index(1)] == 0) ||
+ (quad_cell_count[quad->child(c)->child_index(0)] > 0 &&
+ quad_cell_count[quad->child(c)->child_index(1)] > 0),
+ ExcInternalError());
+ if (quad_cell_count[quad->child(c)->child_index(0)]==0)
+ {
+ // Assert, that the two
+ // anisotropic
+ // refinements add up to
+ // isotropic refinement
+ Assert(quad->refinement_case()+quad->child(c)->refinement_case()==RefinementCase<dim>::cut_xy,
+ ExcInternalError());
+ // we may delete the
+ // quad's children and
+ // the inner line as no
+ // cell references them
+ // anymore
+ quads_to_delete.push_back(quad->child(c)->child(0));
+ quads_to_delete.push_back(quad->child(c)->child(1));
+ if (quad->child(c)->refinement_case()==RefinementCase<2>::cut_x)
+ lines_to_delete.push_back(quad->child(c)->child(0)->line(1));
+ else
+ lines_to_delete.push_back(quad->child(c)->child(0)->line(3));
+ quad->child(c)->clear_children();
+ quad->child(c)->clear_refinement_case();
+ ++deleted_grandchildren;
+ }
+ }
+ // if no grandchildren are left, we
+ // may as well delete the
+ // refinement of the inner line
+ // between our children and the
+ // corresponding vertex
+ if (number_of_child_refinements>0 &&
+ deleted_grandchildren==number_of_child_refinements)
+ {
+ typename Triangulation<dim,spacedim>::line_iterator
+ middle_line;
+ if (quad->refinement_case()==RefinementCase<2>::cut_x)
+ middle_line=quad->child(0)->line(1);
+ else
+ middle_line=quad->child(0)->line(3);
+
+ lines_to_delete.push_back(middle_line->child(0));
+ lines_to_delete.push_back(middle_line->child(1));
+ triangulation.vertices_used[middle_vertex_index<dim,spacedim>(middle_line)]
+ = false;
+ middle_line->clear_children();
+ }
+
+ // now consider the direct children
+ // of the given quad
+ if (quad_cell_count[quad->child_index(0)]==0)
+ {
+ // we may delete the quad's
+ // children and the inner line
+ // as no cell references them
+ // anymore
+ quads_to_delete.push_back(quad->child(0));
+ quads_to_delete.push_back(quad->child(1));
+ if (quad->refinement_case()==RefinementCase<2>::cut_x)
+ lines_to_delete.push_back(quad->child(0)->line(1));
+ else
+ lines_to_delete.push_back(quad->child(0)->line(3));
+
+ // if the counters just dropped
+ // to zero, otherwise the
+ // children would have been
+ // deleted earlier, then this
+ // cell's children must have
+ // contained the anisotropic
+ // quad children. thus, if
+ // those have again anisotropic
+ // children, which are in
+ // effect isotropic children of
+ // the original quad, those are
+ // still needed by a
+ // neighboring cell and we
+ // cannot delete them. instead,
+ // we have to reset this quad's
+ // refine case to isotropic and
+ // set the children
+ // accordingly.
+ if (quad->child(0)->has_children())
+ if (quad->refinement_case()==RefinementCase<2>::cut_x)
+ {
+ // now evereything is
+ // quite complicated. we
+ // have the children
+ // numbered according to
+ //
+ // *---*---*
+ // |n+1|m+1|
+ // *---*---*
+ // | n | m |
+ // *---*---*
+ //
+ // from the original
+ // anisotropic
+ // refinement. we have to
+ // reorder them as
+ //
+ // *---*---*
+ // | m |m+1|
+ // *---*---*
+ // | n |n+1|
+ // *---*---*
+ //
+ // for isotropic refinement.
+ //
+ // this is a bit ugly, of
+ // course: loop over all
+ // cells on all levels
+ // and look for faces n+1
+ // (switch_1) and m
+ // (switch_2).
+ const typename Triangulation<dim,spacedim>::quad_iterator
+ switch_1=quad->child(0)->child(1),
+ switch_2=quad->child(1)->child(0);
+
+ Assert(!switch_1->has_children(), ExcInternalError());
+ Assert(!switch_2->has_children(), ExcInternalError());
+
+ const int switch_1_index=switch_1->index();
+ const int switch_2_index=switch_2->index();
+ for (unsigned int l=0; l<triangulation.levels.size(); ++l)
+ for (unsigned int h=0; h<triangulation.levels[l]->cells.cells.size(); ++h)
+ for (unsigned int q=0; q<GeometryInfo<dim>::faces_per_cell; ++q)
+ {
+ const int index=triangulation.levels[l]->cells.cells[h].face(q);
+ if (index==switch_1_index)
+ triangulation.levels[l]->cells.cells[h].set_face(q,switch_2_index);
+ else if (index==switch_2_index)
+ triangulation.levels[l]->cells.cells[h].set_face(q,switch_1_index);
+ }
+ // now we have to copy
+ // all information of the
+ // two quads
+ const int switch_1_lines[4]=
+ {switch_1->line_index(0),
+ switch_1->line_index(1),
+ switch_1->line_index(2),
+ switch_1->line_index(3)};
+ const bool switch_1_line_orientations[4]=
+ {switch_1->line_orientation(0),
+ switch_1->line_orientation(1),
+ switch_1->line_orientation(2),
+ switch_1->line_orientation(3)};
+ const unsigned char switch_1_boundary_indicator=switch_1->boundary_indicator();
+ const unsigned int switch_1_user_index=switch_1->user_index();
+ const bool switch_1_user_flag=switch_1->user_flag_set();
+
+ switch_1->set(internal::Triangulation::TriaObject<2>(switch_2->line_index(0),
+ switch_2->line_index(1),
+ switch_2->line_index(2),
+ switch_2->line_index(3)));
+ switch_1->set_line_orientation(0, switch_2->line_orientation(0));
+ switch_1->set_line_orientation(1, switch_2->line_orientation(1));
+ switch_1->set_line_orientation(2, switch_2->line_orientation(2));
+ switch_1->set_line_orientation(3, switch_2->line_orientation(3));
+ switch_1->set_boundary_indicator(switch_2->boundary_indicator());
+ switch_1->set_user_index(switch_2->user_index());
+ if (switch_2->user_flag_set())
+ switch_1->set_user_flag();
+ else
+ switch_1->clear_user_flag();
+
+ switch_2->set(internal::Triangulation::TriaObject<2>(switch_1_lines[0],
+ switch_1_lines[1],
+ switch_1_lines[2],
+ switch_1_lines[3]));
+ switch_2->set_line_orientation(0, switch_1_line_orientations[0]);
+ switch_2->set_line_orientation(1, switch_1_line_orientations[1]);
+ switch_2->set_line_orientation(2, switch_1_line_orientations[2]);
+ switch_2->set_line_orientation(3, switch_1_line_orientations[3]);
+ switch_2->set_boundary_indicator(switch_1_boundary_indicator);
+ switch_2->set_user_index(switch_1_user_index);
+ if (switch_1_user_flag)
+ switch_2->set_user_flag();
+ else
+ switch_2->clear_user_flag();
+
+ const unsigned int child_0=quad->child(0)->child_index(0);
+ const unsigned int child_2=quad->child(1)->child_index(0);
+ quad->clear_children();
+ quad->clear_refinement_case();
+ quad->set_refinement_case(RefinementCase<2>::cut_xy);
+ quad->set_children(0,child_0);
+ quad->set_children(2,child_2);
+ std::swap(quad_cell_count[child_0+1],quad_cell_count[child_2]);
+ }
+ else
+ {
+ // the face was refined
+ // with cut_y, thus the
+ // children are already
+ // in correct order. we
+ // only have to set them
+ // correctly, deleting
+ // the indirection of two
+ // anisotropic refinement
+ // and going directly
+ // from the quad to
+ // isotropic children
+ const unsigned int child_0=quad->child(0)->child_index(0);
+ const unsigned int child_2=quad->child(1)->child_index(0);
+ quad->clear_children();
+ quad->clear_refinement_case();
+ quad->set_refinement_case(RefinementCase<2>::cut_xy);
+ quad->set_children(0,child_0);
+ quad->set_children(2,child_2);
+ }
+ else
+ {
+ quad->clear_children();
+ quad->clear_refinement_case();
+ }
+
+
+ }
+ break;
+ }
+ case RefinementCase<dim-1>::cut_xy:
+ {
+ // if one of the cell counters is
+ // zero, the others have to be as
+ // well
+
+ Assert((quad_cell_count[quad->child_index(0)] == 0 &&
+ quad_cell_count[quad->child_index(1)] == 0 &&
+ quad_cell_count[quad->child_index(2)] == 0 &&
+ quad_cell_count[quad->child_index(3)] == 0) ||
+ (quad_cell_count[quad->child_index(0)] > 0 &&
+ quad_cell_count[quad->child_index(1)] > 0 &&
+ quad_cell_count[quad->child_index(2)] > 0 &&
+ quad_cell_count[quad->child_index(3)] > 0),
+ ExcInternalError());
+
+ if (quad_cell_count[quad->child_index(0)]==0)
+ {
+ // we may delete the quad's
+ // children, the inner lines
+ // and the middle vertex as no
+ // cell references them anymore
+ lines_to_delete.push_back(quad->child(0)->line(1));
+ lines_to_delete.push_back(quad->child(3)->line(0));
+ lines_to_delete.push_back(quad->child(0)->line(3));
+ lines_to_delete.push_back(quad->child(3)->line(2));
+
+ for (unsigned int child=0; child<quad->n_children(); ++child)
+ quads_to_delete.push_back(quad->child(child));
+
+ triangulation.vertices_used[quad->child(0)->vertex_index(3)] = false;
+
+ quad->clear_children();
+ quad->clear_refinement_case();
+ }
+ }
+ break;
+
+ default:
+ Assert(false, ExcInternalError());
+ break;
+ }
+
+ }
+
+ // now we repeat a similar procedure
+ // for the outer lines of this cell.
+
+ // if in debug mode: check that each
+ // of the lines for which we consider
+ // deleting the children in fact has
+ // children (the bits/coarsening_3d
+ // test tripped over this initially)
+ for (unsigned int line_no=0; line_no<GeometryInfo<dim>::lines_per_cell; ++line_no)
+ {
+ typename Triangulation<dim,spacedim>::line_iterator
+ line=cell->line(line_no);
+
+ Assert((GeometryInfo<dim>::line_refinement_case(ref_case,line_no) && line->has_children()) ||
+ GeometryInfo<dim>::line_refinement_case(ref_case,line_no)==RefinementCase<1>::no_refinement,
+ ExcInternalError());
+
+ if (line->has_children())
+ {
+ // if one of the cell counters is
+ // zero, the other has to be as well
+
+ Assert((line_cell_count[line->child_index(0)] == 0 &&
+ line_cell_count[line->child_index(1)] == 0) ||
+ (line_cell_count[line->child_index(0)] > 0 &&
+ line_cell_count[line->child_index(1)] > 0),
+ ExcInternalError());
+
+ if (line_cell_count[line->child_index(0)]==0)
+ {
+ for (unsigned int c=0; c<2; ++c)
+ Assert (!line->child(c)->has_children(),
+ ExcInternalError());
+
+ // we may delete the line's
+ // children and the middle vertex
+ // as no cell references them
+ // anymore
+ triangulation.vertices_used[line->child(0)->vertex_index(1)] = false;
+
+ lines_to_delete.push_back(line->child(0));
+ lines_to_delete.push_back(line->child(1));
+
+ line->clear_children();
+ }
+ }
+ }
+
+ // finally, delete unneeded quads and lines
+
+ // clear user pointers, to avoid that
+ // they may appear at unwanted places
+ // later on...
+ // same for user flags, then finally
+ // delete the quads and lines
+ typename std::vector<typename Triangulation<dim,spacedim>::line_iterator>::iterator
+ line=lines_to_delete.begin(),
+ endline=lines_to_delete.end();
+ for (; line!=endline; ++line)
+ {
+ (*line)->clear_user_data();
+ (*line)->clear_user_flag();
+ (*line)->clear_used_flag();
+ }
+
+ typename std::vector<typename Triangulation<dim,spacedim>::quad_iterator>::iterator
+ quad=quads_to_delete.begin(),
+ endquad=quads_to_delete.end();
+ for (; quad!=endquad; ++quad)
+ {
+ (*quad)->clear_user_data();
+ (*quad)->clear_children();
+ (*quad)->clear_refinement_case();
+ (*quad)->clear_user_flag();
+ (*quad)->clear_used_flag();
+ }
+ }
+
+
+ /**
+ * Create the children of a 2d
+ * cell. The arguments indicate
+ * the next free spots in the
+ * vertices, lines, and cells
+ * arrays.
+ *
+ * The faces of the cell have to
+ * be refined already, whereas
+ * the inner lines in 2D will be
+ * created in this
+ * function. Therefore iterator
+ * pointers into the vectors of
+ * lines, quads and cells have to
+ * be passed, which point at (or
+ * "before") the reserved space.
+ */
+ template <int spacedim>
+ static
+ void
+ create_children (Triangulation<2,spacedim> &triangulation,
+ unsigned int &next_unused_vertex,
+ typename Triangulation<2,spacedim>::raw_line_iterator &next_unused_line,
+ typename Triangulation<2,spacedim>::raw_cell_iterator &next_unused_cell,
+ typename Triangulation<2,spacedim>::cell_iterator &cell)
+ {
+ const unsigned int dim=2;
+ // clear refinement flag
+ const RefinementCase<dim> ref_case=cell->refine_flag_set();
+ cell->clear_refine_flag ();
+
+/* For the refinement process: since we go the levels up from the lowest, there
+ are (unlike above) only two possibilities: a neighbor cell is on the same
+ level or one level up (in both cases, it may or may not be refined later on,
+ but we don't care here).
+
+ First:
+ Set up an array of the 3x3 vertices, which are distributed on the cell
+ (the array consists of indices into the @p{vertices} std::vector
+
+ 2--7--3
+ | | |
+ 4--8--5
+ | | |
+ 0--6--1
+
+ note: in case of cut_x or cut_y not all these vertices are needed for the new
+ cells
+
+ Second:
+ Set up an array of the new lines (the array consists of iterator pointers
+ into the lines arrays)
+
+ .-6-.-7-. The directions are: .->-.->-.
+ 1 9 3 ^ ^ ^
+ .-10.11-. .->-.->-.
+ 0 8 2 ^ ^ ^
+ .-4-.-5-. .->-.->-.
+
+ cut_x:
+ .-4-.-5-.
+ | | |
+ 0 6 1
+ | | |
+ .-2-.-3-.
+
+ cut_y:
+ .---5---.
+ 1 3
+ .---6---.
+ 0 2
+ .---4---.
+
+
+ Third:
+ Set up an array of neighbors:
+
+ 6 7
+ .--.--.
+ 1| | |3
+ .--.--.
+ 0| | |2
+ .--.--.
+ 4 5
+
+ We need this array for two reasons: first to get the lines which will
+ bound the four subcells (if the neighboring cell is refined, these
+ lines already exist), and second to update neighborship information.
+ Since if a neighbor is not refined, its neighborship record only
+ points to the present, unrefined, cell rather than the children we
+ are presently creating, we only need the neighborship information
+ if the neighbor cells are refined. In all other cases, we store
+ the unrefined neighbor address
+
+ We also need for every neighbor (if refined) which number among its
+ neighbors the present (unrefined) cell has, since that number is to
+ be replaced and because that also is the number of the subline which
+ will be the interface between that neighbor and the to be created cell.
+ We will store this number (between 0 and 3) in the field
+ @p{neighbors_neighbor}.
+
+ It would be sufficient to use the children of the common line to the
+ neighbor, if we only wanted to get the new sublines and the new vertex,
+ but because we need to update the neighborship information of the
+ two refined subcells of the neighbor, we need to search these anyway.
+
+ Convention:
+ The created children are numbered like this:
+
+ .--.--.
+ |2 . 3|
+ .--.--.
+ |0 | 1|
+ .--.--.
+*/
+
+ // collect the indices
+ // all vertices
+ // 2--7--3
+ // | | |
+ // 4--8--5
+ // | | |
+ // 0--6--1
+ int new_vertices[9];
+ for (unsigned int vertex_no=0; vertex_no<4; ++vertex_no)
+ new_vertices[vertex_no]=cell->vertex_index(vertex_no);
+ for (unsigned int line_no=0; line_no<4; ++line_no)
+ if (cell->line(line_no)->has_children())
+ new_vertices[4+line_no]=cell->line(line_no)->child(0)->vertex_index(1);
+
+ if (ref_case==RefinementCase<dim>::cut_xy)
+ {
+ // find the next
+ // unused vertex and
+ // set it
+ // appropriately
+ while (triangulation.vertices_used[next_unused_vertex] == true)
+ ++next_unused_vertex;
+ Assert (next_unused_vertex < triangulation.vertices.size(),
+ ExcTooFewVerticesAllocated());
+ triangulation.vertices_used[next_unused_vertex] = true;
+
+ new_vertices[8]=next_unused_vertex;
+
+ Point<spacedim> new_point;
+ if (dim == spacedim)
+ {
+ for (unsigned int i=0; i<8; ++i)
+ new_point += triangulation.vertices[new_vertices[i]];
+ new_point /= 8.0;
+ }
+ else
+ {
+ // new vertex is
+ // placed on the
+ // surface according
+ // to the information
+ // stored in the
+ // boundary class
+ new_point =
+ triangulation.boundary[cell->material_id()]
+ ->get_new_point_on_quad (cell);
+ }
+
+ triangulation.vertices[new_vertices[8]] = new_point;
+
+
+ // if the user_flag is set, i.e. if the
+ // cell is at the boundary, use a
+ // different calculation of the middle
+ // vertex here. this is of advantage, if
+ // the boundary is strongly curved and
+ // the cell has a high aspect ratio. this
+ // can happen for example, if it was
+ // refined anisotropically before.
+ if (cell->user_flag_set())
+ {
+ // first reset the user_flag
+ cell->clear_user_flag();
+ // the user flag indicates: at least
+ // one face is at the boundary. if it
+ // is only one, set the new middle
+ // vertex in a different way to avoid
+ // some mis-shaped elements if the
+ // new point on the boundary is not
+ // where we expect it, especially if
+ // it is to far inside the current
+ // cell
+ unsigned int bound_face=GeometryInfo<dim>::faces_per_cell;
+ for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+ if (cell->face(face)->at_boundary())
+ {
+ if (bound_face == GeometryInfo<dim>::faces_per_cell)
+ // no boundary face found so
+ // far, so set it now
+ bound_face=face;
+ else
+ // there is another boundary
+ // face, so reset bound_face to
+ // invalid value as a flag to
+ // do nothing in the following
+ bound_face=GeometryInfo<dim>::faces_per_cell+1;
+ }
+
+ if (bound_face<GeometryInfo<dim>::faces_per_cell)
+ // reset the cell's middle vertex
+ // to the middle of the straight
+ // connection between the new
+ // points on this face and on the
+ // opposite face
+ triangulation.vertices[new_vertices[8]]
+ = 0.5*(cell->face(bound_face)
+ ->child(0)->vertex(1)+
+ cell->face(GeometryInfo<dim>
+ ::opposite_face[bound_face])
+ ->child(0)->vertex(1));
+ }
+ }
+
+
+ // Now the lines:
+ typename Triangulation<dim,spacedim>::raw_line_iterator new_lines[12];
+ unsigned int lmin=8;
+ unsigned int lmax=12;
+ if (ref_case!=RefinementCase<dim>::cut_xy)
+ {
+ lmin=6;
+ lmax=7;
+ }
+
+ for (unsigned int l=lmin; l<lmax; ++l)
+ {
+ while (next_unused_line->used() == true)
+ ++next_unused_line;
+ new_lines[l] = next_unused_line;
+ ++next_unused_line;
+
+ Assert (new_lines[l]->used() == false,
+ ExcCellShouldBeUnused());
+ }
+
+ if (ref_case==RefinementCase<dim>::cut_xy)
+ {
+ // .-6-.-7-.
+ // 1 9 3
+ // .-10.11-.
+ // 0 8 2
+ // .-4-.-5-.
+
+ // lines 0-7 already
+ // exist, create only
+ // the four interior
+ // lines 8-11
+ unsigned int l=0;
+ for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell; ++face_no)
+ for (unsigned int c=0; c<2; ++c, ++l)
+ new_lines[l]=cell->line(face_no)->child(c);
+ Assert(l==8, ExcInternalError());
+
+ new_lines[8] ->set (internal::Triangulation::
+ TriaObject<1>(new_vertices[6], new_vertices[8]));
+ new_lines[9] ->set (internal::Triangulation::
+ TriaObject<1>(new_vertices[8], new_vertices[7]));
+ new_lines[10]->set (internal::Triangulation::
+ TriaObject<1>(new_vertices[4], new_vertices[8]));
+ new_lines[11]->set (internal::Triangulation::
+ TriaObject<1>(new_vertices[8], new_vertices[5]));
+ }
+ else if (ref_case==RefinementCase<dim>::cut_x)
+ {
+ // .-4-.-5-.
+ // | | |
+ // 0 6 1
+ // | | |
+ // .-2-.-3-.
+ new_lines[0]=cell->line(0);
+ new_lines[1]=cell->line(1);
+ new_lines[2]=cell->line(2)->child(0);
+ new_lines[3]=cell->line(2)->child(1);
+ new_lines[4]=cell->line(3)->child(0);
+ new_lines[5]=cell->line(3)->child(1);
+ new_lines[6]->set (internal::Triangulation::
+ TriaObject<1>(new_vertices[6], new_vertices[7]));
+ }
+ else
+ {
+ Assert(ref_case==RefinementCase<dim>::cut_y, ExcInternalError());
+ // .---5---.
+ // 1 3
+ // .---6---.
+ // 0 2
+ // .---4---.
+ new_lines[0]=cell->line(0)->child(0);
+ new_lines[1]=cell->line(0)->child(1);
+ new_lines[2]=cell->line(1)->child(0);
+ new_lines[3]=cell->line(1)->child(1);
+ new_lines[4]=cell->line(2);
+ new_lines[5]=cell->line(3);
+ new_lines[6]->set (internal::Triangulation::
+ TriaObject<1>(new_vertices[4], new_vertices[5]));
+ }
+
+ for (unsigned int l=lmin; l<lmax; ++l)
+ {
+ new_lines[l]->set_used_flag();
+ new_lines[l]->clear_user_flag();
+ new_lines[l]->clear_user_data();
+ new_lines[l]->clear_children();
+ // interior line
+ new_lines[l]->set_boundary_indicator(255);
+ }
+
+ // Now add the four (two)
+ // new cells!
+ typename Triangulation<dim,spacedim>::raw_cell_iterator
+ subcells[GeometryInfo<dim>::max_children_per_cell];
+ while (next_unused_cell->used() == true)
+ ++next_unused_cell;
+
+ const unsigned int n_children=
+ GeometryInfo<dim>::n_children(ref_case);
+ for (unsigned int i=0; i<n_children; ++i)
+ {
+ Assert (next_unused_cell->used() == false,
+ ExcCellShouldBeUnused());
+ subcells[i] = next_unused_cell;
+ ++next_unused_cell;
+ if (i%2==1 && i<n_children-1)
+ while (next_unused_cell->used() == true)
+ ++next_unused_cell;
+ }
+
+ if (ref_case==RefinementCase<dim>::cut_xy)
+ {
+ // children:
+ // .--.--.
+ // |2 . 3|
+ // .--.--.
+ // |0 | 1|
+ // .--.--.
+ // lines:
+ // .-6-.-7-.
+ // 1 9 3
+ // .-10.11-.
+ // 0 8 2
+ // .-4-.-5-.
+ subcells[0]->set (internal::Triangulation::
+ TriaObject<2>(new_lines[0]->index(),
+ new_lines[8]->index(),
+ new_lines[4]->index(),
+ new_lines[10]->index()));
+ subcells[1]->set (internal::Triangulation::
+ TriaObject<2>(new_lines[8]->index(),
+ new_lines[2]->index(),
+ new_lines[5]->index(),
+ new_lines[11]->index()));
+ subcells[2]->set (internal::Triangulation::
+ TriaObject<2>(new_lines[1]->index(),
+ new_lines[9]->index(),
+ new_lines[10]->index(),
+ new_lines[6]->index()));
+ subcells[3]->set (internal::Triangulation::
+ TriaObject<2>(new_lines[9]->index(),
+ new_lines[3]->index(),
+ new_lines[11]->index(),
+ new_lines[7]->index()));
+ }
+ else if (ref_case==RefinementCase<dim>::cut_x)
+ {
+ // children:
+ // .--.--.
+ // | . |
+ // .0 . 1.
+ // | | |
+ // .--.--.
+ // lines:
+ // .-4-.-5-.
+ // | | |
+ // 0 6 1
+ // | | |
+ // .-2-.-3-.
+ subcells[0]->set (internal::Triangulation::
+ TriaObject<2>(new_lines[0]->index(),
+ new_lines[6]->index(),
+ new_lines[2]->index(),
+ new_lines[4]->index()));
+ subcells[1]->set (internal::Triangulation::
+ TriaObject<2>(new_lines[6]->index(),
+ new_lines[1]->index(),
+ new_lines[3]->index(),
+ new_lines[5]->index()));
+ }
+ else
+ {
+ Assert(ref_case==RefinementCase<dim>::cut_y, ExcInternalError());
+ // children:
+ // .-----.
+ // | 1 |
+ // .-----.
+ // | 0 |
+ // .-----.
+ // lines:
+ // .---5---.
+ // 1 3
+ // .---6---.
+ // 0 2
+ // .---4---.
+ subcells[0]->set (internal::Triangulation::
+ TriaObject<2>(new_lines[0]->index(),
+ new_lines[2]->index(),
+ new_lines[4]->index(),
+ new_lines[6]->index()));
+ subcells[1]->set (internal::Triangulation::
+ TriaObject<2>(new_lines[1]->index(),
+ new_lines[3]->index(),
+ new_lines[6]->index(),
+ new_lines[5]->index()));
+ }
+
+
+ for (unsigned int i=0; i<n_children; ++i)
+ {
+ subcells[i]->set_used_flag();
+ subcells[i]->clear_refine_flag();
+ subcells[i]->clear_user_flag();
+ subcells[i]->clear_user_data();
+ subcells[i]->clear_children();
+ // inherit material
+ // properties
+ subcells[i]->set_material_id (cell->material_id());
+ subcells[i]->set_subdomain_id (cell->subdomain_id());
+
+ if (i%2==0)
+ subcells[i]->set_parent (cell->index ());
+ }
+
+
+
+ // set child index for
+ // even children children
+ // i=0,2 (0)
+ for (unsigned int i=0; i<n_children/2; ++i)
+ cell->set_children (2*i, subcells[2*i]->index());
+ // set the refine case
+ cell->set_refinement_case(ref_case);
+
+ // note that the
+ // refinement flag was
+ // already cleared at the
+ // beginning of this function
+ }
+
+
+
+ /**
+ * A function that performs the
+ * refinement of a triangulation in 1d.
+ */
+ template <int spacedim>
+ static
+ typename Triangulation<1,spacedim>::DistortedCellList
+ execute_refinement (Triangulation<1,spacedim> &triangulation,
+ const bool /*check_for_distorted_cells*/)
+ {
+ const unsigned int dim = 1;
+
+ // check whether a new level is
+ // needed we have to check for this
+ // on the highest level only (on
+ // this, all used cells are also
+ // active, so we only have to check
+ // for this)
+ {
+ typename Triangulation<dim,spacedim>::raw_cell_iterator
+ cell = triangulation.begin_active (triangulation.levels.size()-1),
+ endc = triangulation.end();
+ for (; cell != endc; ++cell)
+ if (cell->used())
+ if (cell->refine_flag_set())
+ {
+ triangulation.levels
+ .push_back (new internal::Triangulation::TriaLevel<dim>);
+ break;
+ }
+ }
+
+
+ // check how much space is needed
+ // on every level we need not check
+ // the highest level since either -
+ // on the highest level no cells
+ // are flagged for refinement -
+ // there are, but
+ // prepare_refinement added another
+ // empty level
+ unsigned int needed_vertices = 0;
+ for (int level=triangulation.levels.size()-2; level>=0; --level)
+ {
+ // count number of flagged
+ // cells on this level
+ unsigned int flagged_cells = 0;
+ typename Triangulation<dim,spacedim>::active_cell_iterator
+ acell = triangulation.begin_active(level),
+ aendc = triangulation.begin_active(level+1);
+ for (; acell!=aendc; ++acell)
+ if (acell->refine_flag_set())
+ ++flagged_cells;
+
+ // count number of used cells
+ // on the next higher level
+ const unsigned int used_cells
+ = std::count_if (triangulation.levels[level+1]->cells.used.begin(),
+ triangulation.levels[level+1]->cells.used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
+
+ // reserve space for the
+ // used_cells cells already
+ // existing on the next higher
+ // level as well as for the
+ // 2*flagged_cells that will be
+ // created on that level
+ triangulation.levels[level+1]
+ ->reserve_space(used_cells+
+ GeometryInfo<1>::max_children_per_cell *
+ flagged_cells,
+ 1);
+ // reserve space for
+ // 2*flagged_cells new lines on
+ // the next higher level
+ triangulation.levels[level+1]->cells
+ .reserve_space (GeometryInfo<1>::max_children_per_cell *
+ flagged_cells,
+ 0);
+
+ needed_vertices += flagged_cells;
+ }
+
+ // add to needed vertices how many
+ // vertices are already in use
+ needed_vertices += std::count_if (triangulation.vertices_used.begin(),
+ triangulation.vertices_used.end(),
+ std::bind2nd (std::equal_to<bool>(),
+ true));
+ // if we need more vertices: create
+ // them, if not: leave the array as
+ // is, since shrinking is not
+ // really possible because some of
+ // the vertices at the end may be
+ // in use
+ if (needed_vertices > triangulation.vertices.size())
+ {
+ triangulation.vertices.resize (needed_vertices,
+ Point<spacedim>());
+ triangulation.vertices_used.resize (needed_vertices, false);
+ }
+
+
+ // Do REFINEMENT
+ // on every level; exclude highest
+ // level as above
+
+ // index of next unused vertex
+ unsigned int next_unused_vertex = 0;
+
+ for (int level=triangulation.levels.size()-2; level>=0; --level)
+ {
+ typename Triangulation<dim,spacedim>::active_cell_iterator
+ cell = triangulation.begin_active(level),
+ endc = triangulation.begin_active(level+1);
+
+ typename Triangulation<dim,spacedim>::raw_cell_iterator
+ next_unused_cell = triangulation.begin_raw (level+1);
+
+ for (; (cell!=endc) && (cell->level()==level); ++cell)
+ if (cell->refine_flag_set())
+ {
+ // clear refinement flag
+ cell->clear_refine_flag ();
+
+ // search for next unused
+ // vertex
+ while (triangulation.vertices_used[next_unused_vertex] == true)
+ ++next_unused_vertex;
+ Assert (next_unused_vertex < triangulation.vertices.size(),
+ ExcTooFewVerticesAllocated());
+
+ // first insert new
+ // vertex. if dim==spacedim
+ // then simply use the
+ // midpoint; otherwise we
+ // have to ask the manifold
+ // object
+ if (dim == spacedim)
+ triangulation.vertices[next_unused_vertex] =
+ (cell->vertex(0) + cell->vertex(1)) / 2;
+ else
+ triangulation.vertices[next_unused_vertex] =
+ triangulation.boundary[cell->material_id()]
+ ->get_new_point_on_line(cell);
+ triangulation.vertices_used[next_unused_vertex] = true;
+
+ // search for next two
+ // unused cell (++ takes
+ // care of the end of the
+ // vector)
+ typename Triangulation<dim,spacedim>::raw_cell_iterator
+ first_child,
+ second_child;
+ while (next_unused_cell->used() == true)
+ ++next_unused_cell;
+ first_child = next_unused_cell;
+ first_child->set_used_flag ();
+ first_child->clear_user_data ();
+ ++next_unused_cell;
+ Assert (next_unused_cell->used() == false,
+ ExcCellShouldBeUnused());
+ second_child = next_unused_cell;
+ second_child->set_used_flag ();
+ second_child->clear_user_data ();
+
+ // insert first child
+ cell->set_children (0, first_child->index());
+ first_child->clear_children ();
+ first_child->set (internal::Triangulation
+ ::TriaObject<1> (cell->vertex_index(0),
+ next_unused_vertex));
+ first_child->set_material_id (cell->material_id());
+ first_child->set_subdomain_id (cell->subdomain_id());
+ first_child->set_parent (cell->index ());
+
+ // reset neighborship info (refer
+ // to
+ // internal::Triangulation::TriaLevel<0>
+ // for details)
+ first_child->set_neighbor (1, second_child);
+ if (cell->neighbor(0).state() != IteratorState::valid)
+ first_child->set_neighbor (0, cell->neighbor(0));
+ else
+ if (cell->neighbor(0)->active())
+ {
+ // since the
+ // neighbors level
+ // is always
+ // <=level, if the
+ // cell is active,
+ // then there are
+ // no cells to the
+ // left which may
+ // want to know
+ // about this new
+ // child cell.
+ Assert (cell->neighbor(0)->level() <= cell->level(),
+ ExcInternalError());
+ first_child->set_neighbor (0, cell->neighbor(0));
+ }
+ else
+ // left neighbor is
+ // refined
+ {
+ // set neighbor to
+ // cell on same
+ // level
+ first_child->set_neighbor (0, cell->neighbor(0)->child(1));
+
+ // reset neighbor
+ // info of all
+ // right descendant
+ // of the left
+ // neighbor of cell
+ typename Triangulation<dim,spacedim>::cell_iterator
+ left_neighbor = cell->neighbor(0);
+ while (left_neighbor->has_children())
+ {
+ left_neighbor = left_neighbor->child(1);
+ left_neighbor->set_neighbor (1, first_child);
+ }
+ }
+
+ // insert second child
+ second_child->clear_children ();
+ second_child->set (internal::Triangulation
+ ::TriaObject<1>(next_unused_vertex,
+ cell->vertex_index(1)));
+ second_child->set_neighbor (0, first_child);
+ second_child->set_material_id (cell->material_id());
+ second_child->set_subdomain_id (cell->subdomain_id());
+ if (cell->neighbor(1).state() != IteratorState::valid)
+ second_child->set_neighbor (1, cell->neighbor(1));
+ else
+ if (cell->neighbor(1)->active())
+ {
+ Assert (cell->neighbor(1)->level() <= cell->level(),
+ ExcInternalError());
+ second_child->set_neighbor (1, cell->neighbor(1));
+ }
+ else
+ // right neighbor is
+ // refined same as
+ // above
+ {
+ second_child->set_neighbor (1, cell->neighbor(1)->child(0));
+
+ typename Triangulation<dim,spacedim>::cell_iterator
+ right_neighbor = cell->neighbor(1);
+ while (right_neighbor->has_children())
+ {
+ right_neighbor = right_neighbor->child(0);
+ right_neighbor->set_neighbor (0, second_child);
+ }
+ }
+ }
+ }
+
+ // in 1d, we can not have
+ // distorted children
+ // unless the parent was
+ // already distorted
+ // (that is because we
+ // don't use boundary
+ // information for 1d
+ // triangulations). so
+ // return an empty list
+ return typename Triangulation<1,spacedim>::DistortedCellList();
+ }
+
+
+ /**
+ * A function that performs the
+ * refinement of a triangulation in 2d.
+ */
+ template <int spacedim>
+ static
+ typename Triangulation<2,spacedim>::DistortedCellList
+ execute_refinement (Triangulation<2,spacedim> &triangulation,
+ const bool check_for_distorted_cells)
+ {
+ const unsigned int dim = 2;
+
+ // check whether a new level is
+ // needed we have to check for this
+ // on the highest level only (on
+ // this, all used cells are also
+ // active, so we only have to check
+ // for this)
+ if (true)
+ {
+ typename Triangulation<dim,spacedim>::raw_cell_iterator
+ cell = triangulation.begin_active (triangulation.levels.size()-1),
+ endc = triangulation.end();
+ for (; cell != endc; ++cell)
+ if (cell->used())
+ if (cell->refine_flag_set())
+ {
+ triangulation.levels.push_back (new internal::Triangulation::TriaLevel<dim>);
+ break;
+ }
+ }
+
+
+ // first clear user flags and
+ // pointers of lines; we're going
+ // to use them to flag which lines
+ // need refinement
+ for (typename Triangulation<dim,spacedim>::line_iterator
+ line=triangulation.begin_line(); line!=triangulation.end_line(); ++line)
+ {
+ line->clear_user_flag();
+ line->clear_user_data();
+ }
+ // running over all cells and lines
+ // count the number
+ // n_single_lines of lines
+ // which can be stored as
+ // single lines, e.g. inner lines
+ unsigned int n_single_lines=0;
+ // New lines to be created:
+ // number lines which are
+ // stored in pairs (the
+ // children of lines must be
+ // stored in pairs)
+ unsigned int n_lines_in_pairs = 0;
+
+ // check how much space is needed
+ // on every level we need not check
+ // the highest level since either
+ // - on the highest level no cells
+ // are flagged for refinement
+ // - there are, but prepare_refinement
+ // added another empty level
+ unsigned int needed_vertices = 0;
+ for (int level=triangulation.levels.size()-2; level>=0; --level)
+ {
+ // count number of flagged
+ // cells on this level and
+ // compute how many new
+ // vertices and new lines will
+ // be needed
+ unsigned int needed_cells = 0;
+
+ typename Triangulation<dim,spacedim>::active_cell_iterator
+ cell = triangulation.begin_active(level),
+ endc = triangulation.begin_active(level+1);
+ for (; cell!=endc; ++cell)
+ if (cell->refine_flag_set())
+ {
+ if (cell->refine_flag_set()==RefinementCase<dim>::cut_xy)
+ {
+ needed_cells += 4;
+
+ // new vertex at
+ // center of cell is
+ // needed in any case
+ ++needed_vertices;
+ // the four inner
+ // lines can be
+ // stored as singles
+ n_single_lines += 4;
+ }
+ else // cut_x || cut_y
+ {
+ // set the flag showing that
+ // anisotropic refinement is
+ // used for at least one cell
+ triangulation.anisotropic_refinement = true;
+
+ needed_cells += 2;
+ // no vertex at center
+
+ // the inner line can
+ // be stored as
+ // single
+ n_single_lines += 1;
+
+ }
+
+ // mark all faces
+ // (lines) for
+ // refinement;
+ // checking locally
+ // whether the
+ // neighbor would
+ // also like to
+ // refine them is
+ // rather difficult
+ // for lines so we
+ // only flag them and
+ // after visiting all
+ // cells, we decide
+ // which lines need
+ // refinement;
+ for (unsigned int line_no=0; line_no<GeometryInfo<dim>::faces_per_cell;
+ ++line_no)
+ {
+ if (GeometryInfo<dim>::face_refinement_case(
+ cell->refine_flag_set(), line_no)==RefinementCase<1>::cut_x)
+ {
+ typename Triangulation<dim,spacedim>::line_iterator
+ line = cell->line(line_no);
+ if (line->has_children() == false)
+ {
+ line->set_user_flag ();
+//TODO[WB]: we overwrite the user_index here because we later on need to find
+// out which boundary object we have to ask to refine this line. find a better
+// way to do that
+ if (spacedim > dim)
+ line->set_user_index(cell->material_id());
+ }
+ }
+ }
+ }
+
+
+ // count number of used cells
+ // on the next higher level
+ const unsigned int used_cells
+ = std::count_if (triangulation.levels[level+1]->cells.used.begin(),
+ triangulation.levels[level+1]->cells.used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
+
+
+ // reserve space for the
+ // used_cells cells already
+ // existing on the next higher
+ // level as well as for the
+ // needed_cells that will be
+ // created on that level
+ triangulation.levels[level+1]->reserve_space (used_cells+needed_cells, 2);
+
+ // reserve space for
+ // needed_cells
+ // new quads on the next higher
+ // level
+ triangulation.levels[level+1]->cells.
+ reserve_space (needed_cells,0);
+ }
+
+ // now count the lines which
+ // were flagged for refinement
+ for (typename Triangulation<dim,spacedim>::line_iterator
+ line=triangulation.begin_line(); line!=triangulation.end_line(); ++line)
+ if (line->user_flag_set())
+ {
+ Assert (line->has_children() == false, ExcInternalError());
+ n_lines_in_pairs += 2;
+ needed_vertices += 1;
+ }
+ // reserve space for
+ // n_lines_in_pairs new lines.
+ // note, that we can't reserve space
+ // for the single lines here as well,
+ // as all the space reserved for lines
+ // in pairs would be counted as unused
+ // and we would end up with too little
+ // space to store all lines. memory
+ // reservation for n_single_lines can
+ // only be done AFTER we refined the lines
+ // of the current cells
+ triangulation.faces->lines.
+ reserve_space (n_lines_in_pairs, 0);
+
+ // add to needed vertices how many
+ // vertices are already in use
+ needed_vertices += std::count_if (triangulation.vertices_used.begin(), triangulation.vertices_used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
+ // if we need more vertices: create
+ // them, if not: leave the array as
+ // is, since shrinking is not
+ // really possible because some of
+ // the vertices at the end may be
+ // in use
+ if (needed_vertices > triangulation.vertices.size())
+ {
+ triangulation.vertices.resize (needed_vertices, Point<spacedim>());
+ triangulation.vertices_used.resize (needed_vertices, false);
+ }
+
+
+ // Do REFINEMENT
+ // on every level; exclude highest
+ // level as above
+
+ // index of next unused vertex
+ unsigned int next_unused_vertex = 0;
+
+ // first the refinement of lines.
+ // children are stored pairwise
+ if (true)
+ {
+ // only active objects can be
+ // refined further
+ typename Triangulation<dim,spacedim>::active_line_iterator
+ line = triangulation.begin_active_line(),
+ endl = triangulation.end_line();
+ typename Triangulation<dim,spacedim>::raw_line_iterator
+ next_unused_line = triangulation.begin_raw_line ();
+
+ for (; line!=endl; ++line)
+ if (line->user_flag_set())
+ {
+ // this line needs to be
+ // refined
+
+ // find the next unused
+ // vertex and set it
+ // appropriately
+ while (triangulation.vertices_used[next_unused_vertex] == true)
+ ++next_unused_vertex;
+ Assert (next_unused_vertex < triangulation.vertices.size(),
+ ExcTooFewVerticesAllocated());
+ triangulation.vertices_used[next_unused_vertex] = true;
+
+ if (spacedim == dim)
+ {
+ // for the case of a domain
+ // in an equal-dimensional
+ // space we only have to
+ // treat boundary lines
+ // differently; for interior
+ // lines we can compute the
+ // midpoint as the mean of
+ // the two vertices:
+ if (line->at_boundary())
+ triangulation.vertices[next_unused_vertex]
+ = triangulation.boundary[line->boundary_indicator()]
+ ->get_new_point_on_line (line);
+ else
+ triangulation.vertices[next_unused_vertex]
+ = (line->vertex(0) + line->vertex(1)) / 2;
+ }
+ else
+ // however, if spacedim>dim, we
+ // always have to ask the
+ // boundary object for its
+ // answer
+ triangulation.vertices[next_unused_vertex]
+ = triangulation.boundary[line->user_index()]->get_new_point_on_line (line);
+
+ // now that we created
+ // the right point, make
+ // up the two child
+ // lines. To this end,
+ // find a pair of unused
+ // lines
+ bool pair_found=false;
+ for (; next_unused_line!=endl; ++next_unused_line)
+ if (!next_unused_line->used() &&
+ !(++next_unused_line)->used())
+ {
+ // go back to the
+ // first of the two
+ // unused lines
+ --next_unused_line;
+ pair_found=true;
+ break;
+ }
+ Assert (pair_found, ExcInternalError());
+
+ // there are now two
+ // consecutive unused
+ // lines, such that the
+ // children of a line
+ // will be consecutive.
+ // then set the child
+ // pointer of the present
+ // line
+ line->set_children (0, next_unused_line->index());
+
+ // set the two new lines
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ children[2] = { next_unused_line,
+ ++next_unused_line };
+ // some tests; if any of
+ // the iterators should
+ // be invalid, then
+ // already dereferencing
+ // will fail
+ Assert (children[0]->used() == false, ExcCellShouldBeUnused());
+ Assert (children[1]->used() == false, ExcCellShouldBeUnused());
+
+ children[0]->set (internal::Triangulation
+ ::TriaObject<1>(line->vertex_index(0),
+ next_unused_vertex));
+ children[1]->set (internal::Triangulation
+ ::TriaObject<1>(next_unused_vertex,
+ line->vertex_index(1)));
+
+ children[0]->set_used_flag();
+ children[1]->set_used_flag();
+ children[0]->clear_children();
+ children[1]->clear_children();
+ children[0]->clear_user_data();
+ children[1]->clear_user_data();
+ children[0]->clear_user_flag();
+ children[1]->clear_user_flag();
+
+ children[0]->set_boundary_indicator (line->boundary_indicator());
+ children[1]->set_boundary_indicator (line->boundary_indicator());
+
+ // finally clear flag
+ // indicating the need
+ // for refinement
+ line->clear_user_flag ();
+ }
+ }
+
+
+ // Now set up the new cells
+
+ // reserve space for inner
+ // lines (can be stored as
+ // single lines)
+ triangulation.faces->lines.
+ reserve_space (0,n_single_lines);
+
+ typename Triangulation<2,spacedim>::DistortedCellList
+ cells_with_distorted_children;
+
+ // reset next_unused_line, as
+ // now also single empty places
+ // in the vector can be used
+ typename Triangulation<dim,spacedim>::raw_line_iterator
+ next_unused_line = triangulation.begin_raw_line ();
+
+ for (int level=0; level<static_cast<int>(triangulation.levels.size())-1; ++level)
+ {
+
+ // Remember: as we don't operate
+ // on the finest level, begin_*(level+1)
+ // is allowed
+ typename Triangulation<dim,spacedim>::active_cell_iterator
+ cell = triangulation.begin_active(level),
+ endc = triangulation.begin_active(level+1);
+
+ typename Triangulation<dim,spacedim>::raw_cell_iterator
+ next_unused_cell = triangulation.begin_raw (level+1);
+
+ for (; cell!=endc; ++cell)
+ if (cell->refine_flag_set())
+ {
+ // set the user flag to
+ // indicate, that at least one
+ // line is at the boundary
+
+ // TODO[Tobias Leicht] find a
+ // better place to set this flag,
+ // so that we do not need so much
+ // time to check each cell here
+ if (cell->at_boundary())
+ cell->set_user_flag();
+
+ // actually set up the children and
+ // update neighbor information
+ create_children (triangulation,
+ next_unused_vertex,
+ next_unused_line,
+ next_unused_cell,
+ cell);
+
+ if ((check_for_distorted_cells == true)
+ &&
+ has_distorted_children (cell,
+ internal::int2type<dim>(),
+ internal::int2type<spacedim>()))
+ cells_with_distorted_children.distorted_cells.push_back (cell);
+ }
+ }
+
+ return cells_with_distorted_children;
+ }
+
+
+ /**
+ * A function that performs the
+ * refinement of a triangulation in 3d.
+ */
+ template <int spacedim>
+ static
+ typename Triangulation<3,spacedim>::DistortedCellList
+ execute_refinement (Triangulation<3,spacedim> &triangulation,
+ const bool check_for_distorted_cells)
+ {
+ const unsigned int dim = 3;
+
+ // this function probably
+ // also works for spacedim>3
+ // but it isn't tested. it
+ // will probably be necessary
+ // to pull new vertices onto
+ // the manifold just as we do
+ // for the other functions
+ // above.
+ Assert (spacedim == 3, ExcNotImplemented());
+
+ // check whether a new level is
+ // needed we have to check for this
+ // on the highest level only (on
+ // this, all used cells are also
+ // active, so we only have to check
+ // for this)
+ if (true)
+ {
+ typename Triangulation<dim,spacedim>::raw_cell_iterator
+ cell = triangulation.begin_active (triangulation.levels.size()-1),
+ endc = triangulation.end();
+ for (; cell != endc; ++cell)
+ if (cell->used())
+ if (cell->refine_flag_set())
+ {
+ triangulation.levels.push_back (new internal::Triangulation::TriaLevel<dim>);
+ break;
+ }
+ }
+
+
+ // first clear user flags for quads
+ // and lines; we're going to use them
+ // to flag which lines and quads
+ // need refinement
+ triangulation.faces->quads.clear_user_data();
+
+ for (typename Triangulation<dim,spacedim>::line_iterator
+ line=triangulation.begin_line(); line!=triangulation.end_line(); ++line)
+ line->clear_user_flag();
+ for (typename Triangulation<dim,spacedim>::quad_iterator
+ quad=triangulation.begin_quad(); quad!=triangulation.end_quad(); ++quad)
+ quad->clear_user_flag();
+
+ // create an array of face refine cases. User
+ // indices of faces will be set to values
+ // corresponding with indices in this array.
+ const RefinementCase<dim-1> face_refinement_cases[4]=
+ {RefinementCase<dim-1>::no_refinement,
+ RefinementCase<dim-1>::cut_x,
+ RefinementCase<dim-1>::cut_y,
+ RefinementCase<dim-1>::cut_xy};
+
+ // check how much space is needed
+ // on every level
+ // we need not check the highest
+ // level since either
+ // - on the highest level no cells
+ // are flagged for refinement
+ // - there are, but prepare_refinement
+ // added another empty level which
+ // then is the highest level
+
+ // variables to hold the number of newly to
+ // be created vertices, lines and quads. as
+ // these are stored globally, declare them
+ // outside the loop over al levels. we need
+ // lines and quads in pairs for refinement of
+ // old ones and lines and quads, that can be
+ // stored as single ones, as they are newly
+ // created in the inside of an existing cell
+ unsigned int needed_vertices = 0;
+ unsigned int needed_lines_single = 0;
+ unsigned int needed_quads_single = 0;
+ unsigned int needed_lines_pair = 0;
+ unsigned int needed_quads_pair = 0;
+ for (int level=triangulation.levels.size()-2; level>=0; --level)
+ {
+ // count number of flagged
+ // cells on this level and
+ // compute how many new
+ // vertices and new lines will
+ // be needed
+ unsigned int new_cells = 0;
+
+ typename Triangulation<dim,spacedim>::active_cell_iterator
+ acell = triangulation.begin_active(level),
+ aendc = triangulation.begin_active(level+1);
+ for (; acell!=aendc; ++acell)
+ if (acell->refine_flag_set())
+ {
+ RefinementCase<dim> ref_case=acell->refine_flag_set();
+
+ // now for interior vertices, lines
+ // and quads, which are needed in
+ // any case
+ if (ref_case==RefinementCase<dim>::cut_x ||
+ ref_case==RefinementCase<dim>::cut_y ||
+ ref_case==RefinementCase<dim>::cut_z)
+ {
+ ++needed_quads_single;
+ new_cells+=2;
+ triangulation.anisotropic_refinement=true;
+ }
+ else if (ref_case==RefinementCase<dim>::cut_xy ||
+ ref_case==RefinementCase<dim>::cut_xz ||
+ ref_case==RefinementCase<dim>::cut_yz)
+ {
+ ++needed_lines_single;
+ needed_quads_single += 4;
+ new_cells+=4;
+ triangulation.anisotropic_refinement=true;
+ }
+ else if (ref_case==RefinementCase<dim>::cut_xyz)
+ {
+ ++needed_vertices;
+ needed_lines_single += 6;
+ needed_quads_single += 12;
+ new_cells+=8;
+ }
+ else
+ {
+ // we should never get here
+ Assert(false, ExcInternalError());
+ }
+
+ // mark all faces for refinement;
+ // checking locally
+ // if and how the neighbor
+ // would like to
+ // refine these is
+ // difficult so
+ // we only flag them and
+ // after visiting all
+ // cells, we decide which
+ // faces need which refinement;
+ for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell;
+ ++face)
+ {
+ typename Triangulation<dim,spacedim>::face_iterator
+ aface = acell->face(face);
+ // get the RefineCase this
+ // faces has for the given
+ // RefineCase of the cell
+ RefinementCase<dim-1> face_ref_case=
+ GeometryInfo<dim>::face_refinement_case(ref_case,
+ face,
+ acell->face_orientation(face),
+ acell->face_flip(face),
+ acell->face_rotation(face));
+ // only do something, if this
+ // face has to be refined
+ if (face_ref_case)
+ {
+ if (face_ref_case==RefinementCase<dim-1>::isotropic_refinement)
+ {
+ if (aface->number_of_children()<4)
+ // we use user_flags to
+ // denote needed isotropic
+ // refinement
+ aface->set_user_flag();
+ }
+ else if (aface->refinement_case()!=face_ref_case)
+ // we use user_indices
+ // to denote needed
+ // anisotropic
+ // refinement. note, that
+ // we can have at most
+ // one anisotropic
+ // refinement case for
+ // this face, as
+ // otherwise
+ // prepare_refinement()
+ // would have changed one
+ // of the cells to yield
+ // isotropic refinement
+ // at this
+ // face. therefore we set
+ // the user_index
+ // uniquely
+ {
+ Assert(aface->refinement_case()==RefinementCase<dim-1>::isotropic_refinement ||
+ aface->refinement_case()==RefinementCase<dim-1>::no_refinement,
+ ExcInternalError());
+ aface->set_user_index(face_ref_case);
+ }
+ }
+ }// for all faces
+
+ // flag all lines, that have to be
+ // refined
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ if (GeometryInfo<dim>::line_refinement_case(ref_case,line) &&
+ !acell->line(line)->has_children())
+ acell->line(line)->set_user_flag();
+
+ }// if refine_flag set and for all cells on this level
+
+
+ // count number of used cells on
+ // the next higher level
+ const unsigned int used_cells
+ = std::count_if (triangulation.levels[level+1]->cells.used.begin(),
+ triangulation.levels[level+1]->cells.used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
+
+
+ // reserve space for the
+ // used_cells cells already
+ // existing on the next higher
+ // level as well as for the
+ // 8*flagged_cells that will be
+ // created on that level
+ triangulation.levels[level+1]->reserve_space (used_cells+new_cells, 3);
+ // reserve space for
+ // 8*flagged_cells
+ // new hexes on the next higher
+ // level
+ triangulation.levels[level+1]->cells.reserve_space (new_cells);
+ }// for all levels
+ // now count the quads and
+ // lines which were flagged for
+ // refinement
+ for (typename Triangulation<dim,spacedim>::quad_iterator
+ quad=triangulation.begin_quad(); quad!=triangulation.end_quad(); ++quad)
+ {
+ if (quad->user_flag_set())
+ {
+ // isotropic refinement: 1 interior
+ // vertex, 4 quads and 4 interior
+ // lines. we store the interior lines
+ // in pairs in case the face is
+ // already or will be refined
+ // anisotropically
+ needed_quads_pair += 4;
+ needed_lines_pair += 4;
+ needed_vertices += 1;
+ }
+ if (quad->user_index())
+ {
+ // anisotropic refinement: 1 interior
+ // line and two quads
+ needed_quads_pair += 2;
+ needed_lines_single += 1;
+ // there is a kind of complicated
+ // situation here which requires our
+ // attention. if the quad is refined
+ // isotropcally, two of the interior
+ // lines will get a new mother line -
+ // the interior line of our
+ // anisotropically refined quad. if
+ // those two lines are not
+ // consecutive, we cannot do so and
+ // have to replace them by two lines
+ // that are consecutive. we try to
+ // avoid that situation, but it may
+ // happen nevertheless throug
+ // repeated refinement and
+ // coarsening. thus we have to check
+ // here, as we will need some
+ // additional space to store those
+ // new lines in case we need them...
+ if (quad->has_children())
+ {
+ Assert(quad->refinement_case()==RefinementCase<dim-1>::isotropic_refinement, ExcInternalError());
+ if ((face_refinement_cases[quad->user_index()]==RefinementCase<dim-1>::cut_x
+ && (quad->child(0)->line_index(1)+1!=quad->child(2)->line_index(1))) ||
+ (face_refinement_cases[quad->user_index()]==RefinementCase<dim-1>::cut_y
+ && (quad->child(0)->line_index(3)+1!=quad->child(1)->line_index(3))))
+ needed_lines_pair +=2;
+ }
+ }
+ }
+
+ for (typename Triangulation<dim,spacedim>::line_iterator
+ line=triangulation.begin_line(); line!=triangulation.end_line(); ++line)
+ if (line->user_flag_set())
+ {
+ needed_lines_pair += 2;
+ needed_vertices += 1;
+ }
+
+ // reserve space for
+ // needed_lines new lines
+ // stored in pairs
+ triangulation.faces->lines.
+ reserve_space (needed_lines_pair,needed_lines_single);
+ // reserve space for
+ // needed_quads new quads
+ // stored in pairs
+ triangulation.faces->quads.
+ reserve_space (needed_quads_pair,needed_quads_single);
+
+
+ // add to needed vertices how many
+ // vertices are already in use
+ needed_vertices += std::count_if (triangulation.vertices_used.begin(), triangulation.vertices_used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
+ // if we need more vertices: create
+ // them, if not: leave the array as
+ // is, since shrinking is not
+ // really possible because some of
+ // the vertices at the end may be
+ // in use
+ if (needed_vertices > triangulation.vertices.size())
+ {
+ triangulation.vertices.resize (needed_vertices, Point<spacedim>());
+ 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,
+ // i.e. there are cells adjacent at
+ // one line ("around the edge", but
+ // not at a face), with two cells
+ // differing by more than one
+ // refinement level
+ //
+ // this check is very simple to
+ // implement here, since we have
+ // all lines flagged if they shall
+ // be refined
+#ifdef DEBUG
+ for (typename Triangulation<dim,spacedim>::active_cell_iterator
+ cell=triangulation.begin_active(); cell!=triangulation.end(); ++cell)
+ if (!cell->refine_flag_set())
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ if (cell->line(line)->has_children())
+ for (unsigned int c=0; c<2; ++c)
+ Assert (cell->line(line)->child(c)->user_flag_set() == false,
+ ExcInternalError());
+#endif
+
+ ///////////////////////////////////////////
+ // Do refinement on every level
+ //
+ // To make life a bit easier, we
+ // first refine those lines and
+ // quads that were flagged for
+ // refinement and then compose the
+ // newly to be created cells.
+ //
+ // index of next unused vertex
+ unsigned int next_unused_vertex = 0;
+
+ // first for lines
+ if (true)
+ {
+ // only active objects can be
+ // refined further
+ typename Triangulation<dim,spacedim>::active_line_iterator
+ line = triangulation.begin_active_line(),
+ endl = triangulation.end_line();
+ typename Triangulation<dim,spacedim>::raw_line_iterator
+ next_unused_line = triangulation.begin_raw_line ();
+
+ for (; line!=endl; ++line)
+ if (line->user_flag_set())
+ {
+ // this line needs to be
+ // refined
+
+ // find the next unused
+ // vertex and set it
+ // appropriately
+ while (triangulation.vertices_used[next_unused_vertex] == true)
+ ++next_unused_vertex;
+ Assert (next_unused_vertex < triangulation.vertices.size(),
+ ExcTooFewVerticesAllocated());
+ triangulation.vertices_used[next_unused_vertex] = true;
+
+ if (line->at_boundary())
+ triangulation.vertices[next_unused_vertex]
+ = triangulation.boundary[line->boundary_indicator()]->get_new_point_on_line (line);
+ else
+ triangulation.vertices[next_unused_vertex]
+ = (line->vertex(0) + line->vertex(1)) / 2;
+
+ // now that we created
+ // the right point, make
+ // up the two child lines
+ // (++ takes care of the
+ // end of the vector)
+ next_unused_line=triangulation.faces->lines.next_free_pair_line(triangulation);
+ Assert(next_unused_line.state() == IteratorState::valid,
+ ExcInternalError());
+
+ // now we found
+ // two consecutive unused
+ // lines, such that the
+ // children of a line
+ // will be consecutive.
+ // then set the child
+ // pointer of the present
+ // line
+ line->set_children (0, next_unused_line->index());
+
+ // set the two new lines
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ children[2] = { next_unused_line,
+ ++next_unused_line };
+
+ // some tests; if any of
+ // the iterators should
+ // be invalid, then
+ // already dereferencing
+ // will fail
+ Assert (children[0]->used() == false, ExcCellShouldBeUnused());
+ Assert (children[1]->used() == false, ExcCellShouldBeUnused());
+
+ children[0]->set (internal::Triangulation
+ ::TriaObject<1>(line->vertex_index(0),
+ next_unused_vertex));
+ children[1]->set (internal::Triangulation
+ ::TriaObject<1>(next_unused_vertex,
+ line->vertex_index(1)));
+
+ children[0]->set_used_flag();
+ children[1]->set_used_flag();
+ children[0]->clear_children();
+ children[1]->clear_children();
+ children[0]->clear_user_data();
+ children[1]->clear_user_data();
+ children[0]->clear_user_flag();
+ children[1]->clear_user_flag();
+
+ children[0]->set_boundary_indicator (line->boundary_indicator());
+ children[1]->set_boundary_indicator (line->boundary_indicator());
+
+ // finally clear flag
+ // indicating the need
+ // for refinement
+ line->clear_user_flag ();
+ }
+ }
+
+
+ ///////////////////////////////////////
+ // now refine marked quads
+ ///////////////////////////////////////
+
+ // here we encounter several cases:
+
+ // a) the quad is unrefined and shall be
+ // refined isotropically
+
+ // b) the quad is unrefined and shall be
+ // refined anisotropically
+
+ // c) the quad is unrefined and shall be
+ // refined both anisotropically and
+ // isotropically (this is reduced to case b)
+ // and then case b) for the children again)
+
+ // d) the quad is refined anisotropically and
+ // shall be refined isotropically (this is
+ // reduced to case b) for the anisotropic
+ // children)
+
+ // e) the quad is refined isotropically and
+ // shall be refined anisotropically (this is
+ // transformed to case c), however we might
+ // have to renumber/rename children...)
+
+ // we need a loop in cases c) and d), as the
+ // anisotropic children migt have a lower
+ // index than the mother quad
+ for (unsigned int loop=0; loop<2; ++loop)
+ {
+ // usually, only active objects can be
+ // refined further. however, in cases d)
+ // and e) that is not true, so we have to
+ // use 'normal' iterators here
+ typename Triangulation<dim,spacedim>::quad_iterator
+ quad = triangulation.begin_quad(),
+ endq = triangulation.end_quad();
+ typename Triangulation<dim,spacedim>::raw_line_iterator
+ next_unused_line = triangulation.begin_raw_line ();
+ typename Triangulation<dim,spacedim>::raw_quad_iterator
+ next_unused_quad = triangulation.begin_raw_quad ();
+
+ for (; quad!=endq; ++quad)
+ {
+ if (quad->user_index())
+ {
+ RefinementCase<dim-1> aniso_quad_ref_case=face_refinement_cases[quad->user_index()];
+ // there is one unlikely event
+ // here, where we already have
+ // refind the face: if the face
+ // was refined anisotropically
+ // and we want to refine it
+ // isotropically, both children
+ // are flagged for anisotropic
+ // refinement. however, if those
+ // children were already flagged
+ // for anisotropic refinement,
+ // they might already be
+ // processed and refined.
+ if (aniso_quad_ref_case == quad->refinement_case())
+ continue;
+
+ Assert(quad->refinement_case()==RefinementCase<dim-1>::cut_xy ||
+ quad->refinement_case()==RefinementCase<dim-1>::no_refinement,
+ ExcInternalError());
+
+ // this quad needs to be refined
+ // anisotropically
+ Assert(quad->user_index() == RefinementCase<dim-1>::cut_x ||
+ quad->user_index() == RefinementCase<dim-1>::cut_y,
+ ExcInternalError());
+
+ // make the new line interior to
+ // the quad
+ typename Triangulation<dim,spacedim>::raw_line_iterator new_line;
+
+ new_line=triangulation.faces->lines.next_free_single_line(triangulation);
+ Assert (new_line->used() == false,
+ ExcCellShouldBeUnused());
+
+ // first collect the
+ // indices of the vertices:
+ // *--1--*
+ // | | |
+ // | | | cut_x
+ // | | |
+ // *--0--*
+ //
+ // *-----*
+ // | |
+ // 0-----1 cut_y
+ // | |
+ // *-----*
+ unsigned int vertex_indices[2];
+ if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
+ {
+ vertex_indices[0]=quad->line(2)->child(0)->vertex_index(1);
+ vertex_indices[1]=quad->line(3)->child(0)->vertex_index(1);
+ }
+ else
+ {
+ vertex_indices[0]=quad->line(0)->child(0)->vertex_index(1);
+ vertex_indices[1]=quad->line(1)->child(0)->vertex_index(1);
+ }
+
+ new_line->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[0], vertex_indices[1]));
+ new_line->set_used_flag();
+ new_line->clear_user_flag();
+ new_line->clear_user_data();
+ new_line->clear_children();
+ new_line->set_boundary_indicator(quad->boundary_indicator());
+
+ // child 0 and 1 of a line are
+ // switched if the line
+ // orientation is false. set up a
+ // miniature table, indicating
+ // which child to take for line
+ // orientations false and
+ // true. first index: child index
+ // in standard orientation,
+ // second index: line orientation
+ const unsigned int index[2][2]=
+ {{1,0}, // child 0, line_orientation=false and true
+ {0,1}}; // child 1, line_orientation=false and true
+
+ // find some space (consecutive)
+ // for the two newly to be
+ // created quads.
+ typename Triangulation<dim,spacedim>::raw_quad_iterator new_quads[2];
+
+ next_unused_quad=triangulation.faces->quads.next_free_pair_quad(triangulation);
+ new_quads[0] = next_unused_quad;
+ Assert (new_quads[0]->used() == false, ExcCellShouldBeUnused());
+
+ ++next_unused_quad;
+ new_quads[1] = next_unused_quad;
+ Assert (new_quads[1]->used() == false, ExcCellShouldBeUnused());
+
+
+ if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
+ {
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(quad->line_index(0),
+ new_line->index(),
+ quad->line(2)->child(index[0][quad->line_orientation(2)])->index(),
+ quad->line(3)->child(index[0][quad->line_orientation(3)])->index()));
+ new_quads[1]->set (internal::Triangulation
+ ::TriaObject<2>(new_line->index(),
+ quad->line_index(1),
+ quad->line(2)->child(index[1][quad->line_orientation(2)])->index(),
+ quad->line(3)->child(index[1][quad->line_orientation(3)])->index()));
+ }
+ else
+ {
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(quad->line(0)->child(index[0][quad->line_orientation(0)])->index(),
+ quad->line(1)->child(index[0][quad->line_orientation(1)])->index(),
+ quad->line_index(2),
+ new_line->index()));
+ new_quads[1]->set (internal::Triangulation
+ ::TriaObject<2>(quad->line(0)->child(index[1][quad->line_orientation(0)])->index(),
+ quad->line(1)->child(index[1][quad->line_orientation(1)])->index(),
+ new_line->index(),
+ quad->line_index(3)));
+ }
+
+ for (unsigned int i=0; i<2; ++i)
+ {
+ new_quads[i]->set_used_flag();
+ new_quads[i]->clear_user_flag();
+ new_quads[i]->clear_user_data();
+ new_quads[i]->clear_children();
+ new_quads[i]->set_boundary_indicator (quad->boundary_indicator());
+ // set all line orientations to
+ // true, change this after the
+ // loop, as we have to consider
+ // different lines for each
+ // child
+ for (unsigned int j=0; j<GeometryInfo<dim>::lines_per_face; ++j)
+ new_quads[i]->set_line_orientation(j,true);
+ }
+ // now set the line orientation of
+ // children of outer lines
+ // correctly, the lines in the
+ // interior of the refined quad are
+ // automatically oriented
+ // conforming to the standard
+ new_quads[0]->set_line_orientation(0,quad->line_orientation(0));
+ new_quads[0]->set_line_orientation(2,quad->line_orientation(2));
+ new_quads[1]->set_line_orientation(1,quad->line_orientation(1));
+ new_quads[1]->set_line_orientation(3,quad->line_orientation(3));
+ if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
+ {
+ new_quads[0]->set_line_orientation(3,quad->line_orientation(3));
+ new_quads[1]->set_line_orientation(2,quad->line_orientation(2));
+ }
+ else
+ {
+ new_quads[0]->set_line_orientation(1,quad->line_orientation(1));
+ new_quads[1]->set_line_orientation(0,quad->line_orientation(0));
+ }
+
+ // test, whether this face is
+ // refined isotropically
+ // already. if so, set the
+ // correct children pointers.
+ if (quad->refinement_case()==RefinementCase<dim-1>::cut_xy)
+ {
+ // we will put a new
+ // refinemnt level of
+ // anisotropic refinement
+ // between the unrefined and
+ // isotropically refined quad
+ // ending up with the same
+ // fine quads but introducing
+ // anisotropically refined
+ // ones as children of the
+ // unrefined quad and mother
+ // cells of the original fine
+ // ones.
+
+ // this process includes the
+ // creation of a new middle
+ // line which we will assign
+ // as the mother line of two
+ // of the existing inner
+ // lines. If those inner
+ // lines are not consecutive
+ // in memory, we won't find
+ // them later on, so we have
+ // to create new ones instead
+ // and replace all occurances
+ // of the old ones with those
+ // new ones. As this is kind
+ // of ugly, we hope we don't
+ // have to do it often...
+ typename Triangulation<dim,spacedim>::line_iterator old_child[2];
+ if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
+ {
+ old_child[0]=quad->child(0)->line(1);
+ old_child[1]=quad->child(2)->line(1);
+ }
+ else
+ {
+ Assert(aniso_quad_ref_case==RefinementCase<dim-1>::cut_y, ExcInternalError());
+
+ old_child[0]=quad->child(0)->line(3);
+ old_child[1]=quad->child(1)->line(3);
+ }
+
+ if (old_child[0]->index()+1 != old_child[1]->index())
+ {
+ // this is exactly the
+ // ugly case we taked
+ // about. so, no
+ // coimplaining, lets get
+ // two new lines and copy
+ // all info
+ typename Triangulation<dim,spacedim>::raw_line_iterator new_child[2];
+
+ new_child[0]=new_child[1]=triangulation.faces->lines.next_free_pair_line(triangulation);
+ ++new_child[1];
+
+ new_child[0]->set_used_flag();
+ new_child[1]->set_used_flag();
+
+ const int old_index_0=old_child[0]->index(),
+ old_index_1=old_child[1]->index(),
+ new_index_0=new_child[0]->index(),
+ new_index_1=new_child[1]->index();
+
+ // loop over all quads
+ // and replace the old
+ // lines
+ for (unsigned int q=0; q<triangulation.faces->quads.cells.size(); ++q)
+ for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_face; ++l)
+ {
+ const int index=triangulation.faces->quads.cells[q].face(l);
+ if (index==old_index_0)
+ triangulation.faces->quads.cells[q].set_face(l,new_index_0);
+ else if (index==old_index_1)
+ triangulation.faces->quads.cells[q].set_face(l,new_index_1);
+ }
+ // now we have to copy
+ // all information of the
+ // two lines
+ for (unsigned int i=0; i<2; ++i)
+ {
+ Assert(!old_child[i]->has_children(), ExcInternalError());
+
+ new_child[i]->set(internal::Triangulation::TriaObject<1>(old_child[i]->vertex_index(0),
+ old_child[i]->vertex_index(1)));
+ new_child[i]->set_boundary_indicator(old_child[i]->boundary_indicator());
+ new_child[i]->set_user_index(old_child[i]->user_index());
+ if (old_child[i]->user_flag_set())
+ new_child[i]->set_user_flag();
+ else
+ new_child[i]->clear_user_flag();
+
+ new_child[i]->clear_children();
+
+ old_child[i]->clear_user_flag();
+ old_child[i]->clear_user_index();
+ old_child[i]->clear_used_flag();
+ }
+ }
+ // now that we cared
+ // about the lines, go on
+ // with the quads
+ // themselves, where we
+ // might encounter
+ // similar situations...
+ if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
+ {
+ new_line->set_children(0, quad->child(0)->line_index(1));
+ Assert(new_line->child(1)==quad->child(2)->line(1),
+ ExcInternalError());
+ // now evereything is
+ // quite complicated. we
+ // have the children
+ // numbered according to
+ //
+ // *---*---*
+ // |n+2|n+3|
+ // *---*---*
+ // | n |n+1|
+ // *---*---*
+ //
+ // from the original
+ // isotropic
+ // refinement. we have to
+ // reorder them as
+ //
+ // *---*---*
+ // |n+1|n+3|
+ // *---*---*
+ // | n |n+2|
+ // *---*---*
+ //
+ // such that n and n+1
+ // are consecutive
+ // children of m and n+2
+ // and n+3 are
+ // consecutive children
+ // of m+1, where m and
+ // m+1 are given as in
+ //
+ // *---*---*
+ // | | |
+ // | m |m+1|
+ // | | |
+ // *---*---*
+ //
+ // this is a bit ugly, of
+ // course: loop over all
+ // cells on all levels
+ // and look for faces n+1
+ // (switch_1) and n+2
+ // (switch_2).
+ const typename Triangulation<dim,spacedim>::quad_iterator
+ switch_1=quad->child(1),
+ switch_2=quad->child(2);
+ const int switch_1_index=switch_1->index();
+ const int switch_2_index=switch_2->index();
+ for (unsigned int l=0; l<triangulation.levels.size(); ++l)
+ for (unsigned int h=0; h<triangulation.levels[l]->cells.cells.size(); ++h)
+ for (unsigned int q=0; q<GeometryInfo<dim>::faces_per_cell; ++q)
+ {
+ const int index=triangulation.levels[l]->cells.cells[h].face(q);
+ if (index==switch_1_index)
+ triangulation.levels[l]->cells.cells[h].set_face(q,switch_2_index);
+ else if (index==switch_2_index)
+ triangulation.levels[l]->cells.cells[h].set_face(q,switch_1_index);
+ }
+ // now we have to copy
+ // all information of the
+ // two quads
+ const int switch_1_lines[4]=
+ {switch_1->line_index(0),
+ switch_1->line_index(1),
+ switch_1->line_index(2),
+ switch_1->line_index(3)};
+ const bool switch_1_line_orientations[4]=
+ {switch_1->line_orientation(0),
+ switch_1->line_orientation(1),
+ switch_1->line_orientation(2),
+ switch_1->line_orientation(3)};
+ const unsigned char switch_1_boundary_indicator=switch_1->boundary_indicator();
+ const unsigned int switch_1_user_index=switch_1->user_index();
+ const bool switch_1_user_flag=switch_1->user_flag_set();
+ const RefinementCase<dim-1> switch_1_refinement_case=switch_1->refinement_case();
+ const int switch_1_first_child_pair=(switch_1_refinement_case ? switch_1->child_index(0) : -1);
+ const int switch_1_second_child_pair=(switch_1_refinement_case==RefinementCase<dim-1>::cut_xy ? switch_1->child_index(2) : -1);
+
+ switch_1->set(internal::Triangulation::TriaObject<2>(switch_2->line_index(0),
+ switch_2->line_index(1),
+ switch_2->line_index(2),
+ switch_2->line_index(3)));
+ switch_1->set_line_orientation(0, switch_2->line_orientation(0));
+ switch_1->set_line_orientation(1, switch_2->line_orientation(1));
+ switch_1->set_line_orientation(2, switch_2->line_orientation(2));
+ switch_1->set_line_orientation(3, switch_2->line_orientation(3));
+ switch_1->set_boundary_indicator(switch_2->boundary_indicator());
+ switch_1->set_user_index(switch_2->user_index());
+ if (switch_2->user_flag_set())
+ switch_1->set_user_flag();
+ else
+ switch_1->clear_user_flag();
+ switch_1->clear_refinement_case();
+ switch_1->set_refinement_case(switch_2->refinement_case());
+ switch_1->clear_children();
+ if (switch_2->refinement_case())
+ switch_1->set_children(0, switch_2->child_index(0));
+ if (switch_2->refinement_case()==RefinementCase<dim-1>::cut_xy)
+ switch_1->set_children(2, switch_2->child_index(2));
+
+ switch_2->set(internal::Triangulation::TriaObject<2>(switch_1_lines[0],
+ switch_1_lines[1],
+ switch_1_lines[2],
+ switch_1_lines[3]));
+ switch_2->set_line_orientation(0, switch_1_line_orientations[0]);
+ switch_2->set_line_orientation(1, switch_1_line_orientations[1]);
+ switch_2->set_line_orientation(2, switch_1_line_orientations[2]);
+ switch_2->set_line_orientation(3, switch_1_line_orientations[3]);
+ switch_2->set_boundary_indicator(switch_1_boundary_indicator);
+ switch_2->set_user_index(switch_1_user_index);
+ if (switch_1_user_flag)
+ switch_2->set_user_flag();
+ else
+ switch_2->clear_user_flag();
+ switch_2->clear_refinement_case();
+ switch_2->set_refinement_case(switch_1_refinement_case);
+ switch_2->clear_children();
+ switch_2->set_children(0, switch_1_first_child_pair);
+ switch_2->set_children(2, switch_1_second_child_pair);
+
+ new_quads[0]->set_refinement_case(RefinementCase<2>::cut_y);
+ new_quads[0]->set_children(0, quad->child_index(0));
+ new_quads[1]->set_refinement_case(RefinementCase<2>::cut_y);
+ new_quads[1]->set_children(0, quad->child_index(2));
+ }
+ else
+ {
+ new_quads[0]->set_refinement_case(RefinementCase<2>::cut_x);
+ new_quads[0]->set_children(0, quad->child_index(0));
+ new_quads[1]->set_refinement_case(RefinementCase<2>::cut_x);
+ new_quads[1]->set_children(0, quad->child_index(2));
+ new_line->set_children(0, quad->child(0)->line_index(3));
+ Assert(new_line->child(1)==quad->child(1)->line(3),
+ ExcInternalError());
+ }
+ quad->clear_children();
+ }
+
+ // note these quads as children
+ // to the present one
+ quad->set_children (0, new_quads[0]->index());
+
+ quad->set_refinement_case(aniso_quad_ref_case);
+
+ // finally clear flag
+ // indicating the need
+ // for refinement
+ quad->clear_user_data ();
+ } // if (anisotropic refinement)
+
+ if (quad->user_flag_set())
+ {
+ // this quad needs to be
+ // refined isotropically
+
+ // first of all: we only get here
+ // in the first run of the loop
+ Assert(loop==0,ExcInternalError());
+
+ // find the next unused
+ // vertex. we'll need this in any
+ // case
+ while (triangulation.vertices_used[next_unused_vertex] == true)
+ ++next_unused_vertex;
+ Assert (next_unused_vertex < triangulation.vertices.size(),
+ ExcTooFewVerticesAllocated());
+
+ // now: if the quad is refined
+ // anisotropically already, set
+ // the anisotropic refinement
+ // flag for both
+ // children. Additionally, we
+ // have to refine the inner line,
+ // as it is an outer line of the
+ // two (anisotropic) children
+ const RefinementCase<dim-1> quad_ref_case=quad->refinement_case();
+
+ if (quad_ref_case==RefinementCase<dim-1>::cut_x ||
+ quad_ref_case==RefinementCase<dim-1>::cut_y)
+ {
+ // set the 'opposite' refine case for children
+ quad->child(0)->set_user_index(RefinementCase<dim-1>::cut_xy-quad_ref_case);
+ quad->child(1)->set_user_index(RefinementCase<dim-1>::cut_xy-quad_ref_case);
+ // refine the inner line
+ typename Triangulation<dim,spacedim>::line_iterator middle_line;
+ if (quad_ref_case==RefinementCase<dim-1>::cut_x)
+ middle_line=quad->child(0)->line(1);
+ else
+ middle_line=quad->child(0)->line(3);
+
+ // if the face has been
+ // refined anisotropically in
+ // the last refinement step
+ // it might be, that it is
+ // flagged already and that
+ // the middle line is thus
+ // refined already. if not
+ // create children.
+ if (!middle_line->has_children())
+ {
+ // set the middle vertex
+ // appropriately. double
+ // refinement of quads can only
+ // happen in the interior of
+ // the domain, so we need not
+ // care about boundary quads
+ // here
+ triangulation.vertices[next_unused_vertex]
+ = (middle_line->vertex(0) + middle_line->vertex(1)) / 2;
+ triangulation.vertices_used[next_unused_vertex] = true;
+
+ // now search a slot for the two
+ // child lines
+ next_unused_line=triangulation.faces->lines.next_free_pair_line(triangulation);
+
+ // set the child
+ // pointer of the present
+ // line
+ middle_line->set_children (0, next_unused_line->index());
+
+ // set the two new lines
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ children[2] = { next_unused_line,
+ ++next_unused_line };
+
+ // some tests; if any of
+ // the iterators should
+ // be invalid, then
+ // already dereferencing
+ // will fail
+ Assert (children[0]->used() == false, ExcCellShouldBeUnused());
+ Assert (children[1]->used() == false, ExcCellShouldBeUnused());
+
+ children[0]->set (internal::Triangulation::
+ TriaObject<1>(middle_line->vertex_index(0),
+ next_unused_vertex));
+ children[1]->set (internal::Triangulation::
+ TriaObject<1>(next_unused_vertex,
+ middle_line->vertex_index(1)));
+
+ children[0]->set_used_flag();
+ children[1]->set_used_flag();
+ children[0]->clear_children();
+ children[1]->clear_children();
+ children[0]->clear_user_data();
+ children[1]->clear_user_data();
+ children[0]->clear_user_flag();
+ children[1]->clear_user_flag();
+
+ children[0]->set_boundary_indicator (middle_line->boundary_indicator());
+ children[1]->set_boundary_indicator (middle_line->boundary_indicator());
+ }
+ // now remove the flag from the
+ // quad and go to the next
+ // quad, the actual refinement
+ // of the quad takes place
+ // later on in this pass of the
+ // loop or in the next one
+ quad->clear_user_flag();
+ continue;
+ } // if (several refinement cases)
+
+ // if we got here, we have an
+ // unrefined quad and have to do
+ // the usual work like in an purely
+ // isotropic refinement
+ Assert(quad_ref_case==RefinementCase<dim-1>::no_refinement, ExcInternalError());
+
+ // set the middle vertex
+ // appropriately
+ if (quad->at_boundary())
+ triangulation.vertices[next_unused_vertex]
+ = triangulation.boundary[quad->boundary_indicator()]->get_new_point_on_quad (quad);
+ else
+ // it might be that the
+ // quad itself is not
+ // at the boundary, but
+ // that one of its lines
+ // actually is. in this
+ // case, the newly
+ // created vertices at
+ // the centers of the
+ // lines are not
+ // necessarily the mean
+ // values of the
+ // adjacent vertices,
+ // so do not compute
+ // the new vertex as
+ // the mean value of
+ // the 4 vertices of
+ // the face, but rather
+ // as a weighted mean
+ // value of the 8
+ // vertices which we
+ // already have (the
+ // four old ones, and
+ // the four ones
+ // inserted as middle
+ // points for the four
+ // lines). summing up
+ // some more points is
+ // generally cheaper
+ // than first asking
+ // whether one of the
+ // lines is at the
+ // boundary
+ //
+ // note that the exact
+ // weights are chosen
+ // such as to minimize
+ // the distortion of
+ // the four new quads
+ // from the optimal
+ // shape; their
+ // derivation and
+ // values is copied
+ // over from the
+ // @p{MappingQ::set_laplace_on_vector}
+ // function
+ triangulation.vertices[next_unused_vertex]
+ = (quad->vertex(0) + quad->vertex(1) +
+ quad->vertex(2) + quad->vertex(3) +
+ 3*(quad->line(0)->child(0)->vertex(1) +
+ quad->line(1)->child(0)->vertex(1) +
+ quad->line(2)->child(0)->vertex(1) +
+ quad->line(3)->child(0)->vertex(1)) ) / 16;
+
+ triangulation.vertices_used[next_unused_vertex] = true;
+
+ // now that we created
+ // the right point, make
+ // up the four lines
+ // interior to the quad
+ // (++ takes care of the
+ // end of the vector)
+ typename Triangulation<dim,spacedim>::raw_line_iterator new_lines[4];
+
+ for (unsigned int i=0; i<4; ++i)
+ {
+ if (i%2==0)
+ // search a free pair of
+ // lines for 0. and 2. line,
+ // so that two of them end up
+ // together, which is
+ // necessary if later on we
+ // want to refine the quad
+ // anisotropically and the
+ // two lines end up as
+ // children of new line
+ next_unused_line=triangulation.faces->lines.next_free_pair_line(triangulation);
+
+ new_lines[i] = next_unused_line;
+ ++next_unused_line;
+
+ Assert (new_lines[i]->used() == false,
+ ExcCellShouldBeUnused());
+ }
+
+ // set the data of the
+ // four lines.
+ // first collect the
+ // indices of the five
+ // vertices:
+ // *--3--*
+ // | | |
+ // 0--4--1
+ // | | |
+ // *--2--*
+ // the lines are numbered
+ // as follows:
+ // *--*--*
+ // | 1 |
+ // *2-*-3*
+ // | 0 |
+ // *--*--*
+
+ const unsigned int vertex_indices[5]
+ = { quad->line(0)->child(0)->vertex_index(1),
+ quad->line(1)->child(0)->vertex_index(1),
+ quad->line(2)->child(0)->vertex_index(1),
+ quad->line(3)->child(0)->vertex_index(1),
+ next_unused_vertex
+ };
+
+ new_lines[0]->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[2], vertex_indices[4]));
+ new_lines[1]->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[4], vertex_indices[3]));
+ new_lines[2]->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[0], vertex_indices[4]));
+ new_lines[3]->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[4], vertex_indices[1]));
+
+ for (unsigned int i=0; i<4; ++i)
+ {
+ new_lines[i]->set_used_flag();
+ new_lines[i]->clear_user_flag();
+ new_lines[i]->clear_user_data();
+ new_lines[i]->clear_children();
+ new_lines[i]->set_boundary_indicator(quad->boundary_indicator());
+ }
+
+ // now for the
+ // quads. again, first
+ // collect some data
+ // about the indices of
+ // the lines, with the
+ // following numbering:
+ // .-6-.-7-.
+ // 1 9 3
+ // .-10.11-.
+ // 0 8 2
+ // .-4-.-5-.
+
+ // child 0 and 1 of a line are
+ // switched if the line orientation
+ // is false. set up a miniature
+ // table, indicating which child to
+ // take for line orientations false
+ // and true. first index: child
+ // index in standard orientation,
+ // second index: line orientation
+ const unsigned int index[2][2]=
+ {{1,0}, // child 0, line_orientation=false and true
+ {0,1}}; // child 1, line_orientation=false and true
+
+ const unsigned int line_indices[12]
+ = { quad->line(0)->child(index[0][quad->line_orientation(0)])->index(),
+ quad->line(0)->child(index[1][quad->line_orientation(0)])->index(),
+ quad->line(1)->child(index[0][quad->line_orientation(1)])->index(),
+ quad->line(1)->child(index[1][quad->line_orientation(1)])->index(),
+ quad->line(2)->child(index[0][quad->line_orientation(2)])->index(),
+ quad->line(2)->child(index[1][quad->line_orientation(2)])->index(),
+ quad->line(3)->child(index[0][quad->line_orientation(3)])->index(),
+ quad->line(3)->child(index[1][quad->line_orientation(3)])->index(),
+ new_lines[0]->index(),
+ new_lines[1]->index(),
+ new_lines[2]->index(),
+ new_lines[3]->index()
+ };
+
+ // find some space (consecutive)
+ // for the first two newly to be
+ // created quads.
+ typename Triangulation<dim,spacedim>::raw_quad_iterator new_quads[4];
+
+ next_unused_quad=triangulation.faces->quads.next_free_pair_quad(triangulation);
+
+ new_quads[0] = next_unused_quad;
+ Assert (new_quads[0]->used() == false, ExcCellShouldBeUnused());
+
+ ++next_unused_quad;
+ new_quads[1] = next_unused_quad;
+ Assert (new_quads[1]->used() == false, ExcCellShouldBeUnused());
+
+ next_unused_quad=triangulation.faces->quads.next_free_pair_quad(triangulation);
+ new_quads[2] = next_unused_quad;
+ Assert (new_quads[2]->used() == false, ExcCellShouldBeUnused());
+
+ ++next_unused_quad;
+ new_quads[3] = next_unused_quad;
+ Assert (new_quads[3]->used() == false, ExcCellShouldBeUnused());
+
+ // note these quads as
+ // children to the
+ // present one
+ quad->set_children (0, new_quads[0]->index());
+ quad->set_children (2, new_quads[2]->index());
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[0],
+ line_indices[8],
+ line_indices[4],
+ line_indices[10]));
+
+ quad->set_refinement_case(RefinementCase<2>::cut_xy);
+
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[0],
+ line_indices[8],
+ line_indices[4],
+ line_indices[10]));
+ new_quads[1]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[8],
+ line_indices[2],
+ line_indices[5],
+ line_indices[11]));
+ new_quads[2]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[1],
+ line_indices[9],
+ line_indices[10],
+ line_indices[6]));
+ new_quads[3]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[9],
+ line_indices[3],
+ line_indices[11],
+ line_indices[7]));
+ for (unsigned int i=0; i<4; ++i)
+ {
+ new_quads[i]->set_used_flag();
+ new_quads[i]->clear_user_flag();
+ new_quads[i]->clear_user_data();
+ new_quads[i]->clear_children();
+ new_quads[i]->set_boundary_indicator (quad->boundary_indicator());
+ // set all line orientations to
+ // true, change this after the
+ // loop, as we have to consider
+ // different lines for each
+ // child
+ for (unsigned int j=0; j<GeometryInfo<dim>::lines_per_face; ++j)
+ new_quads[i]->set_line_orientation(j,true);
+ }
+ // now set the line orientation of
+ // children of outer lines
+ // correctly, the lines in the
+ // interior of the refined quad are
+ // automatically oriented
+ // conforming to the standard
+ new_quads[0]->set_line_orientation(0,quad->line_orientation(0));
+ new_quads[0]->set_line_orientation(2,quad->line_orientation(2));
+ new_quads[1]->set_line_orientation(1,quad->line_orientation(1));
+ new_quads[1]->set_line_orientation(2,quad->line_orientation(2));
+ new_quads[2]->set_line_orientation(0,quad->line_orientation(0));
+ new_quads[2]->set_line_orientation(3,quad->line_orientation(3));
+ new_quads[3]->set_line_orientation(1,quad->line_orientation(1));
+ new_quads[3]->set_line_orientation(3,quad->line_orientation(3));
+
+ // finally clear flag
+ // indicating the need
+ // for refinement
+ quad->clear_user_flag ();
+ } // if (isotropic refinement)
+ } // 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;
+
+ for (unsigned int level=0; level!=triangulation.levels.size()-1; ++level)
+ {
+ // only active objects can be
+ // refined further; remember
+ // that we won't operate on the
+ // finest level, so
+ // triangulation.begin_*(level+1) is allowed
+ typename Triangulation<dim,spacedim>::active_hex_iterator
+ hex = triangulation.begin_active_hex(level),
+ endh = triangulation.begin_active_hex(level+1);
+ typename Triangulation<dim,spacedim>::raw_hex_iterator
+ next_unused_hex = triangulation.begin_raw_hex (level+1);
+
+ for (; hex!=endh; ++hex)
+ if (hex->refine_flag_set())
+ {
+ // this hex needs to be
+ // refined
+
+ // clear flag indicating
+ // the need for
+ // refinement. do it here
+ // already, since we
+ // can't do it anymore
+ // once the cell has
+ // children
+ const RefinementCase<dim> ref_case=hex->refine_flag_set();
+ hex->clear_refine_flag ();
+ hex->set_refinement_case(ref_case);
+
+ // depending on the refine case we
+ // might have to create additional
+ // vertices, lines and quads
+ // interior of the hex before the
+ // actual children can be set up.
+
+ // in a first step: reserve the
+ // needed space for lines, quads
+ // and hexes and initialize them
+ // correctly
+
+ unsigned int n_new_lines=0;
+ unsigned int n_new_quads=0;
+ unsigned int n_new_hexes=0;
+ switch (ref_case)
+ {
+ case RefinementCase<dim>::cut_x:
+ case RefinementCase<dim>::cut_y:
+ case RefinementCase<dim>::cut_z:
+ n_new_lines=0;
+ n_new_quads=1;
+ n_new_hexes=2;
+ break;
+ case RefinementCase<dim>::cut_xy:
+ case RefinementCase<dim>::cut_xz:
+ case RefinementCase<dim>::cut_yz:
+ n_new_lines=1;
+ n_new_quads=4;
+ n_new_hexes=4;
+ break;
+ case RefinementCase<dim>::cut_xyz:
+ n_new_lines=6;
+ n_new_quads=12;
+ n_new_hexes=8;
+ break;
+ default:
+ Assert(false, ExcInternalError());
+ break;
+ }
+
+ // find some space for the newly to
+ // be created interior lines and
+ // initialize them.
+ std::vector<typename Triangulation<dim,spacedim>::raw_line_iterator>
+ new_lines(n_new_lines);
+ for (unsigned int i=0; i<n_new_lines; ++i)
+ {
+ new_lines[i] = triangulation.faces->lines.next_free_single_line(triangulation);
+
+ Assert (new_lines[i]->used() == false,
+ ExcCellShouldBeUnused());
+ new_lines[i]->set_used_flag();
+ new_lines[i]->clear_user_flag();
+ new_lines[i]->clear_user_data();
+ new_lines[i]->clear_children();
+ // interior line
+ new_lines[i]->set_boundary_indicator(255);
+ }
+
+ // find some space for the newly to
+ // be created interior quads and
+ // initialize them.
+ std::vector<typename Triangulation<dim,spacedim>::raw_quad_iterator>
+ new_quads(n_new_quads);
+ for (unsigned int i=0; i<n_new_quads; ++i)
+ {
+ new_quads[i] = triangulation.faces->quads.next_free_single_quad(triangulation);
+
+ Assert (new_quads[i]->used() == false,
+ ExcCellShouldBeUnused());
+ new_quads[i]->set_used_flag();
+ new_quads[i]->clear_user_flag();
+ new_quads[i]->clear_user_data();
+ new_quads[i]->clear_children();
+ // interior quad
+ new_quads[i]->set_boundary_indicator (255);
+ // set all line orientation
+ // flags to true by default,
+ // change this afterwards, if
+ // necessary
+ for (unsigned int j=0; j<GeometryInfo<dim>::lines_per_face; ++j)
+ new_quads[i]->set_line_orientation(j,true);
+ }
+
+ // find some space for the newly to
+ // be created hexes and initialize
+ // them.
+ std::vector<typename Triangulation<dim,spacedim>::raw_hex_iterator>
+ new_hexes(n_new_hexes);
+ for (unsigned int i=0; i<n_new_hexes; ++i)
+ {
+ if (i%2==0)
+ next_unused_hex=triangulation.levels[level+1]->cells.next_free_hex(triangulation,level+1);
+
+ else
+ ++next_unused_hex;
+
+ new_hexes[i]=next_unused_hex;
+
+ Assert (new_hexes[i]->used() == false,
+ ExcCellShouldBeUnused());
+ new_hexes[i]->set_used_flag();
+ new_hexes[i]->clear_user_flag();
+ new_hexes[i]->clear_user_data();
+ new_hexes[i]->clear_children();
+ // inherit material
+ // properties
+ new_hexes[i]->set_material_id (hex->material_id());
+ new_hexes[i]->set_subdomain_id (hex->subdomain_id());
+
+ if (i%2)
+ new_hexes[i]->set_parent (hex->index ());
+ // set the face_orientation
+ // flag to true for all faces
+ // initially, as this is the
+ // default value which is true
+ // for all faces interior to
+ // the hex. later on go the
+ // other way round and reset
+ // faces that are at the
+ // boundary of the mother cube
+ //
+ // the same is true for the
+ // face_flip and face_rotation
+ // flags. however, the latter
+ // two are set to false by
+ // default as this is the
+ // standard value
+ for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+ {
+ new_hexes[i]->set_face_orientation(f, true);
+ new_hexes[i]->set_face_flip(f, false);
+ new_hexes[i]->set_face_rotation(f, false);
+ }
+ }
+ // note these hexes as
+ // children to the
+ // present cell
+ for (unsigned int i=0; i<n_new_hexes/2; ++i)
+ hex->set_children (2*i, new_hexes[2*i]->index());
+
+ // we have to take into account
+ // whether the different faces are
+ // oriented correctly or in the
+ // opposite direction, so store
+ // that up front
+
+ // face_orientation
+ const bool f_or[6]
+ = { hex->face_orientation (0),
+ hex->face_orientation (1),
+ hex->face_orientation (2),
+ hex->face_orientation (3),
+ hex->face_orientation (4),
+ hex->face_orientation (5) };
+
+ // face_flip
+ const bool f_fl[6]
+ = { hex->face_flip (0),
+ hex->face_flip (1),
+ hex->face_flip (2),
+ hex->face_flip (3),
+ hex->face_flip (4),
+ hex->face_flip (5) };
+
+ // face_rotation
+ const bool f_ro[6]
+ = { hex->face_rotation (0),
+ hex->face_rotation (1),
+ hex->face_rotation (2),
+ hex->face_rotation (3),
+ hex->face_rotation (4),
+ hex->face_rotation (5) };
+
+ // some commonly used fields which
+ // have varying size
+ const unsigned int *vertex_indices=0;
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ *lines=0;
+ const unsigned int *line_indices=0;
+ const bool *line_orientation=0;
+ const unsigned int *quad_indices=0;
+
+ // little helper table, indicating,
+ // whether the child with index 0
+ // or with index 1 can be found at
+ // the standard origin of an
+ // anisotropically refined quads in
+ // real orientation
+ // index 1: (RefineCase - 1)
+ // index 2: face_flip
+
+ // index 3: face rotation
+ // note: face orientation has no influence
+ const unsigned int child_at_origin[2][2][2]=
+ { { { 0, 0 }, // RefinementCase<dim>::cut_x, face_flip=false, face_rotation=false and true
+ { 1, 1 }}, // RefinementCase<dim>::cut_x, face_flip=true, face_rotation=false and true
+ { { 0, 1 }, // RefinementCase<dim>::cut_y, face_flip=false, face_rotation=false and true
+ { 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
+ // needed), create new interior
+ // lines (if needed), create new
+ // interior quads and afterwards
+ // build the children hexes out of
+ // these and the existing subfaces
+ // of the outer quads (which have
+ // been created above). However,
+ // even if the steps are quite
+ // similar, the actual work
+ // strongly depends on the actual
+ // refinement case. therefore, we
+ // use seperate blocks of code for
+ // each of these cases, which
+ // hopefully increases the
+ // readability to some extend.
+
+ switch (ref_case)
+ {
+ case RefinementCase<dim>::cut_x:
+ {
+ //////////////////////////////
+ //
+ // RefinementCase<dim>::cut_x
+ //
+ // the refined cube will look
+ // like this:
+ //
+ // *----*----*
+ // / / /|
+ // / / / |
+ // / / / |
+ // *----*----* |
+ // | | | |
+ // | | | *
+ // | | | /
+ // | | | /
+ // | | |/
+ // *----*----*
+ //
+ // again, first
+ // collect some data
+ // about the indices of
+ // the lines, with the
+ // following numbering:
+
+ // face 2: front plane
+ // (note: x,y exchanged)
+ // *---*---*
+ // | | |
+ // | 0 |
+ // | | |
+ // *---*---*
+ // m0
+ // face 3: back plane
+ // (note: x,y exchanged)
+ // m1
+ // *---*---*
+ // | | |
+ // | 1 |
+ // | | |
+ // *---*---*
+ // face 4: bottom plane
+ // *---*---*
+ // / / /
+ // / 2 /
+ // / / /
+ // *---*---*
+ // m0
+ // face 5: top plane
+ // m1
+ // *---*---*
+ // / / /
+ // / 3 /
+ // / / /
+ // *---*---*
+
+ // set up a list of line iterators
+ // first. from this, construct
+ // lists of line_indices and
+ // line orientations later on
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ lines_x[4]
+ = {
+ hex->face(2)->child(0)
+ ->line((hex->face(2)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
+ hex->face(3)->child(0)
+ ->line((hex->face(3)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
+ hex->face(4)->child(0)
+ ->line((hex->face(4)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
+ hex->face(5)->child(0)
+ ->line((hex->face(5)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3) //3
+ };
+
+ lines=&lines_x[0];
+
+ unsigned int line_indices_x[4];
+
+ for (unsigned int i=0; i<4; ++i)
+ line_indices_x[i]=lines[i]->index();
+ line_indices=&line_indices_x[0];
+
+ // the orientation of lines for the
+ // inner quads is quite tricky. as
+ // these lines are newly created
+ // ones and thus have no parents,
+ // they cannot inherit this
+ // property. set up an array and
+ // fill it with the respective
+ // values
+ bool line_orientation_x[4];
+
+ // the middle vertice marked
+ // as m0 above is the start
+ // vertex for lines 0 and 2
+ // in standard orientation,
+ // whereas m1 is the end
+ // vertex of lines 1 and 3 in
+ // standard orientation
+ const unsigned int middle_vertices[2]=
+ {
+ hex->line(2)->child(0)->vertex_index(1),
+ hex->line(7)->child(0)->vertex_index(1)
+ };
+
+ for (unsigned int i=0; i<4; ++i)
+ if (lines[i]->vertex_index(i%2)==middle_vertices[i%2])
+ line_orientation_x[i]=true;
+ else
+ {
+ // it must be the other
+ // way round then
+ Assert(lines[i]->vertex_index((i+1)%2)==middle_vertices[i%2],
+ ExcInternalError());
+ line_orientation_x[i]=false;
+ }
+
+ line_orientation=&line_orientation_x[0];
+
+ // set up the new quad, line
+ // numbering is as indicated
+ // above
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[0],
+ line_indices[1],
+ line_indices[2],
+ line_indices[3]));
+
+ new_quads[0]->set_line_orientation(0,line_orientation[0]);
+ new_quads[0]->set_line_orientation(1,line_orientation[1]);
+ new_quads[0]->set_line_orientation(2,line_orientation[2]);
+ new_quads[0]->set_line_orientation(3,line_orientation[3]);
+
+ // the quads are
+ // numbered as follows:
+ //
+ // planes in the interior
+ // of the old hex:
+ // *
+ // /|
+ // / | x
+ // / | *-------* *---------*
+ // * | | | / /
+ // | 0 | | | / /
+ // | * | | / /
+ // | / *-------*y *---------*x
+ // | /
+ // |/
+ // *
+ //
+ // children of the faces
+ // of the old hex
+ // *---*---* *---*---*
+ // /| | | / / /|
+ // / | | | / 9 / 10/ |
+ // / | 5 | 6 | / / / |
+ // * | | | *---*---* |
+ // | 1 *---*---* | | | 2 *
+ // | / / / | | | /
+ // | / 7 / 8 / | 3 | 4 | /
+ // |/ / / | | |/
+ // *---*---* *---*---*
+ //
+ // note that we have to
+ // take care of the
+ // orientation of
+ // faces.
+ const unsigned int quad_indices_x[11]
+ = {
+ new_quads[0]->index(), //0
+
+ hex->face(0)->index(), //1
+
+ hex->face(1)->index(), //2
+
+ hex->face(2)->child_index( child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]), //3
+ hex->face(2)->child_index(1-child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]),
+
+ hex->face(3)->child_index( child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]), //5
+ hex->face(3)->child_index(1-child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]),
+
+ hex->face(4)->child_index( child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]), //7
+ hex->face(4)->child_index(1-child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]),
+
+ hex->face(5)->child_index( child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]]), //9
+ hex->face(5)->child_index(1-child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]])
+
+ };
+ quad_indices=&quad_indices_x[0];
+
+ new_hexes[0]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[1],
+ quad_indices[0],
+ quad_indices[3],
+ quad_indices[5],
+ quad_indices[7],
+ quad_indices[9]));
+ new_hexes[1]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[0],
+ quad_indices[2],
+ quad_indices[4],
+ quad_indices[6],
+ quad_indices[8],
+ quad_indices[10]));
+ break;
+ }
+ case RefinementCase<dim>::cut_y:
+ {
+ //////////////////////////////
+ //
+ // RefinementCase<dim>::cut_y
+ //
+ // the refined cube will look
+ // like this:
+ //
+ // *---------*
+ // / /|
+ // *---------* |
+ // / /| |
+ // *---------* | |
+ // | | | |
+ // | | | *
+ // | | |/
+ // | | *
+ // | |/
+ // *---------*
+ //
+ // again, first
+ // collect some data
+ // about the indices of
+ // the lines, with the
+ // following numbering:
+
+ // face 0: left plane
+ // *
+ // /|
+ // * |
+ // /| |
+ // * | |
+ // | 0 |
+ // | | *
+ // | |/
+ // | *m0
+ // |/
+ // *
+ // face 1: right plane
+ // *
+ // /|
+ // m1* |
+ // /| |
+ // * | |
+ // | 1 |
+ // | | *
+ // | |/
+ // | *
+ // |/
+ // *
+ // face 4: bottom plane
+ // *-------*
+ // / /
+ // m0*---2---*
+ // / /
+ // *-------*
+ // face 5: top plane
+ // *-------*
+ // / /
+ // *---3---*m1
+ // / /
+ // *-------*
+
+ // set up a list of line iterators
+ // first. from this, construct
+ // lists of line_indices and
+ // line orientations later on
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ lines_y[4]
+ = {
+ hex->face(0)->child(0)
+ ->line((hex->face(0)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
+ hex->face(1)->child(0)
+ ->line((hex->face(1)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
+ hex->face(4)->child(0)
+ ->line((hex->face(4)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
+ hex->face(5)->child(0)
+ ->line((hex->face(5)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3) //3
+ };
+
+ lines=&lines_y[0];
+
+ unsigned int line_indices_y[4];
+
+ for (unsigned int i=0; i<4; ++i)
+ line_indices_y[i]=lines[i]->index();
+ line_indices=&line_indices_y[0];
+
+ // the orientation of lines for the
+ // inner quads is quite tricky. as
+ // these lines are newly created
+ // ones and thus have no parents,
+ // they cannot inherit this
+ // property. set up an array and
+ // fill it with the respective
+ // values
+ bool line_orientation_y[4];
+
+ // the middle vertice marked
+ // as m0 above is the start
+ // vertex for lines 0 and 2
+ // in standard orientation,
+ // whereas m1 is the end
+ // vertex of lines 1 and 3 in
+ // standard orientation
+ const unsigned int middle_vertices[2]=
+ {
+ hex->line(0)->child(0)->vertex_index(1),
+ hex->line(5)->child(0)->vertex_index(1)
+ };
+
+ for (unsigned int i=0; i<4; ++i)
+ if (lines[i]->vertex_index(i%2)==middle_vertices[i%2])
+ line_orientation_y[i]=true;
+ else
+ {
+ // it must be the other way round then
+ Assert(lines[i]->vertex_index((i+1)%2)==middle_vertices[i%2],
+ ExcInternalError());
+ line_orientation_y[i]=false;
+ }
+
+ line_orientation=&line_orientation_y[0];
+
+ // set up the new quad, line
+ // numbering is as indicated
+ // above
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[2],
+ line_indices[3],
+ line_indices[0],
+ line_indices[1]));
+
+ new_quads[0]->set_line_orientation(0,line_orientation[2]);
+ new_quads[0]->set_line_orientation(1,line_orientation[3]);
+ new_quads[0]->set_line_orientation(2,line_orientation[0]);
+ new_quads[0]->set_line_orientation(3,line_orientation[1]);
+
+ // the quads are
+ // numbered as follows:
+ //
+ // planes in the interior
+ // of the old hex:
+ // *
+ // /|
+ // / | x
+ // / | *-------* *---------*
+ // * | | | / /
+ // | | | 0 | / /
+ // | * | | / /
+ // | / *-------*y *---------*x
+ // | /
+ // |/
+ // *
+ //
+ // children of the faces
+ // of the old hex
+ // *-------* *-------*
+ // /| | / 10 /|
+ // * | | *-------* |
+ // /| | 6 | / 9 /| |
+ // * |2| | *-------* |4|
+ // | | *-------* | | | *
+ // |1|/ 8 / | |3|/
+ // | *-------* | 5 | *
+ // |/ 7 / | |/
+ // *-------* *-------*
+ //
+ // note that we have to
+ // take care of the
+ // orientation of
+ // faces.
+ const unsigned int quad_indices_y[11]
+ = {
+ new_quads[0]->index(), //0
+
+ hex->face(0)->child_index( child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]), //1
+ hex->face(0)->child_index(1-child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]),
+
+ hex->face(1)->child_index( child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]), //3
+ hex->face(1)->child_index(1-child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]),
+
+ hex->face(2)->index(), //5
+
+ hex->face(3)->index(), //6
+
+ hex->face(4)->child_index( child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]), //7
+ hex->face(4)->child_index(1-child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]),
+
+ hex->face(5)->child_index( child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]]), //9
+ hex->face(5)->child_index(1-child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]])
+
+ };
+ quad_indices=&quad_indices_y[0];
+
+ new_hexes[0]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[1],
+ quad_indices[3],
+ quad_indices[5],
+ quad_indices[0],
+ quad_indices[7],
+ quad_indices[9]));
+ new_hexes[1]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[2],
+ quad_indices[4],
+ quad_indices[0],
+ quad_indices[6],
+ quad_indices[8],
+ quad_indices[10]));
+ break;
+ }
+ case RefinementCase<dim>::cut_z:
+ {
+ //////////////////////////////
+ //
+ // RefinementCase<dim>::cut_z
+ //
+ // the refined cube will look
+ // like this:
+ //
+ // *---------*
+ // / /|
+ // / / |
+ // / / *
+ // *---------* /|
+ // | | / |
+ // | |/ *
+ // *---------* /
+ // | | /
+ // | |/
+ // *---------*
+ //
+ // again, first
+ // collect some data
+ // about the indices of
+ // the lines, with the
+ // following numbering:
+
+ // face 0: left plane
+ // *
+ // /|
+ // / |
+ // / *
+ // * /|
+ // | 0 |
+ // |/ *
+ // m0* /
+ // | /
+ // |/
+ // *
+ // face 1: right plane
+ // *
+ // /|
+ // / |
+ // / *m1
+ // * /|
+ // | 1 |
+ // |/ *
+ // * /
+ // | /
+ // |/
+ // *
+ // face 2: front plane
+ // (note: x,y exchanged)
+ // *-------*
+ // | |
+ // m0*---2---*
+ // | |
+ // *-------*
+ // face 3: back plane
+ // (note: x,y exchanged)
+ // *-------*
+ // | |
+ // *---3---*m1
+ // | |
+ // *-------*
+
+ // set up a list of line iterators
+ // first. from this, construct
+ // lists of line_indices and
+ // line orientations later on
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ lines_z[4]
+ = {
+ hex->face(0)->child(0)
+ ->line((hex->face(0)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
+ hex->face(1)->child(0)
+ ->line((hex->face(1)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
+ hex->face(2)->child(0)
+ ->line((hex->face(2)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
+ hex->face(3)->child(0)
+ ->line((hex->face(3)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3) //3
+ };
+
+ lines=&lines_z[0];
+
+ unsigned int line_indices_z[4];
+
+ for (unsigned int i=0; i<4; ++i)
+ line_indices_z[i]=lines[i]->index();
+ line_indices=&line_indices_z[0];
+
+ // the orientation of lines for the
+ // inner quads is quite tricky. as
+ // these lines are newly created
+ // ones and thus have no parents,
+ // they cannot inherit this
+ // property. set up an array and
+ // fill it with the respective
+ // values
+ bool line_orientation_z[4];
+
+ // the middle vertex marked
+ // as m0 above is the start
+ // vertex for lines 0 and 2
+ // in standard orientation,
+ // whereas m1 is the end
+ // vertex of lines 1 and 3 in
+ // standard orientation
+ const unsigned int middle_vertices[2]=
+ {
+ middle_vertex_index<dim,spacedim>(hex->line(8)),
+ middle_vertex_index<dim,spacedim>(hex->line(11))
+ };
+
+ for (unsigned int i=0; i<4; ++i)
+ if (lines[i]->vertex_index(i%2)==middle_vertices[i%2])
+ line_orientation_z[i]=true;
+ else
+ {
+ // it must be the other way round then
+ Assert(lines[i]->vertex_index((i+1)%2)==middle_vertices[i%2],
+ ExcInternalError());
+ line_orientation_z[i]=false;
+ }
+
+ line_orientation=&line_orientation_z[0];
+
+ // set up the new quad, line
+ // numbering is as indicated
+ // above
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[0],
+ line_indices[1],
+ line_indices[2],
+ line_indices[3]));
+
+ new_quads[0]->set_line_orientation(0,line_orientation[0]);
+ new_quads[0]->set_line_orientation(1,line_orientation[1]);
+ new_quads[0]->set_line_orientation(2,line_orientation[2]);
+ new_quads[0]->set_line_orientation(3,line_orientation[3]);
+
+ // the quads are
+ // numbered as follows:
+ //
+ // planes in the interior
+ // of the old hex:
+ // *
+ // /|
+ // / | x
+ // / | *-------* *---------*
+ // * | | | / /
+ // | | | | / 0 /
+ // | * | | / /
+ // | / *-------*y *---------*x
+ // | /
+ // |/
+ // *
+ //
+ // children of the faces
+ // of the old hex
+ // *---*---* *-------*
+ // /| 8 | / /|
+ // / | | / 10 / |
+ // / *-------* / / *
+ // * 2/| | *-------* 4/|
+ // | / | 7 | | 6 | / |
+ // |/1 *-------* | |/3 *
+ // * / / *-------* /
+ // | / 9 / | | /
+ // |/ / | 5 |/
+ // *-------* *---*---*
+ //
+ // note that we have to
+ // take care of the
+ // orientation of
+ // faces.
+ const unsigned int quad_indices_z[11]
+ = {
+ new_quads[0]->index(), //0
+
+ hex->face(0)->child_index( child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]), //1
+ hex->face(0)->child_index(1-child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]),
+
+ hex->face(1)->child_index( child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]), //3
+ hex->face(1)->child_index(1-child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]),
+
+ hex->face(2)->child_index( child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]), //5
+ hex->face(2)->child_index(1-child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]),
+
+ hex->face(3)->child_index( child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]), //7
+ hex->face(3)->child_index(1-child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]),
+
+ hex->face(4)->index(), //9
+
+ hex->face(5)->index() //10
+ };
+ quad_indices=&quad_indices_z[0];
+
+ new_hexes[0]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[1],
+ quad_indices[3],
+ quad_indices[5],
+ quad_indices[7],
+ quad_indices[9],
+ quad_indices[0]));
+ new_hexes[1]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[2],
+ quad_indices[4],
+ quad_indices[6],
+ quad_indices[8],
+ quad_indices[0],
+ quad_indices[10]));
+ break;
+ }
+ case RefinementCase<dim>::cut_xy:
+ {
+ //////////////////////////////
+ //
+ // RefinementCase<dim>::cut_xy
+ //
+ // the refined cube will look
+ // like this:
+ //
+ // *----*----*
+ // / / /|
+ // *----*----* |
+ // / / /| |
+ // *----*----* | |
+ // | | | | |
+ // | | | | *
+ // | | | |/
+ // | | | *
+ // | | |/
+ // *----*----*
+ //
+
+ // first, create the new
+ // internal line
+ new_lines[0]->set (internal::Triangulation::
+ TriaObject<1>(middle_vertex_index<dim,spacedim>(hex->face(4)),
+ middle_vertex_index<dim,spacedim>(hex->face(5))));
+
+ // again, first
+ // collect some data
+ // about the indices of
+ // the lines, with the
+ // following numbering:
+
+ // face 0: left plane
+ // *
+ // /|
+ // * |
+ // /| |
+ // * | |
+ // | 0 |
+ // | | *
+ // | |/
+ // | *
+ // |/
+ // *
+ // face 1: right plane
+ // *
+ // /|
+ // * |
+ // /| |
+ // * | |
+ // | 1 |
+ // | | *
+ // | |/
+ // | *
+ // |/
+ // *
+ // face 2: front plane
+ // (note: x,y exchanged)
+ // *---*---*
+ // | | |
+ // | 2 |
+ // | | |
+ // *-------*
+ // face 3: back plane
+ // (note: x,y exchanged)
+ // *---*---*
+ // | | |
+ // | 3 |
+ // | | |
+ // *---*---*
+ // face 4: bottom plane
+ // *---*---*
+ // / 5 /
+ // *-6-*-7-*
+ // / 4 /
+ // *---*---*
+ // face 5: top plane
+ // *---*---*
+ // / 9 /
+ // *10-*-11*
+ // / 8 /
+ // *---*---*
+ // middle planes
+ // *-------* *---*---*
+ // / / | | |
+ // / / | 12 |
+ // / / | | |
+ // *-------* *---*---*
+
+ // set up a list of line iterators
+ // first. from this, construct
+ // lists of line_indices and
+ // line orientations later on
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ lines_xy[13]
+ = {
+ hex->face(0)->child(0)
+ ->line((hex->face(0)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
+ hex->face(1)->child(0)
+ ->line((hex->face(1)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
+ hex->face(2)->child(0)
+ ->line((hex->face(2)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
+ hex->face(3)->child(0)
+ ->line((hex->face(3)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //3
+
+ hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[4],f_fl[4],f_ro[4])), //4
+ hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[4],f_fl[4],f_ro[4])), //5
+ hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[4],f_fl[4],f_ro[4])), //6
+ hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[4],f_fl[4],f_ro[4])), //7
+
+ hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[5],f_fl[5],f_ro[5])), //8
+ hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[5],f_fl[5],f_ro[5])), //9
+ hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[5],f_fl[5],f_ro[5])), //10
+ hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[5],f_fl[5],f_ro[5])), //11
+
+ new_lines[0] //12
+ };
+
+ lines=&lines_xy[0];
+
+ unsigned int line_indices_xy[13];
+
+ for (unsigned int i=0; i<13; ++i)
+ line_indices_xy[i]=lines[i]->index();
+ line_indices=&line_indices_xy[0];
+
+ // the orientation of lines for the
+ // inner quads is quite tricky. as
+ // these lines are newly created
+ // ones and thus have no parents,
+ // they cannot inherit this
+ // property. set up an array and
+ // fill it with the respective
+ // values
+ bool line_orientation_xy[13];
+
+ // the middle vertices of the
+ // lines of our bottom face
+ const unsigned int middle_vertices[4]=
+ {
+ hex->line(0)->child(0)->vertex_index(1),
+ hex->line(1)->child(0)->vertex_index(1),
+ hex->line(2)->child(0)->vertex_index(1),
+ hex->line(3)->child(0)->vertex_index(1),
+ };
+
+ // note: for lines 0 to 3 the
+ // orientation of the line
+ // is 'true', if vertex 0 is
+ // on the bottom face
+ for (unsigned int i=0; i<4; ++i)
+ if (lines[i]->vertex_index(0)==middle_vertices[i])
+ line_orientation_xy[i]=true;
+ else
+ {
+ // it must be the other way round then
+ Assert(lines[i]->vertex_index(1)==middle_vertices[i],
+ ExcInternalError());
+ line_orientation_xy[i]=false;
+ }
+
+ // note: for lines 4 to 11
+ // (inner lines of the outer quads)
+ // the following holds: the second
+ // vertex of the even lines in
+ // standard orientation is the
+ // vertex in the middle of the
+ // quad, whereas for odd lines the
+ // first vertex is the same middle
+ // vertex.
+ for (unsigned int i=4; i<12; ++i)
+ if (lines[i]->vertex_index((i+1)%2) ==
+ middle_vertex_index<dim,spacedim>(hex->face(3+i/4)))
+ line_orientation_xy[i]=true;
+ else
+ {
+ // it must be the other way
+ // round then
+ Assert(lines[i]->vertex_index(i%2) ==
+ (middle_vertex_index<dim,spacedim>(hex->face(3+i/4))),
+ ExcInternalError());
+ line_orientation_xy[i]=false;
+ }
+ // for the last line the line
+ // orientation is always true,
+ // since it was just constructed
+ // that way
+
+ line_orientation_xy[12]=true;
+ line_orientation=&line_orientation_xy[0];
+
+ // set up the 4 quads,
+ // numbered as follows
+ // (left quad numbering,
+ // right line numbering
+ // extracted from above)
+ //
+ // * *
+ // /| 9|
+ // * | * |
+ // y/| | 8| 3
+ // * |1| * | |
+ // | | |x | 12|
+ // |0| * | | *
+ // | |/ 2 |5
+ // | * | *
+ // |/ |4
+ // * *
+ //
+ // x
+ // *---*---* *10-*-11*
+ // | | | | | |
+ // | 2 | 3 | 0 12 1
+ // | | | | | |
+ // *---*---*y *-6-*-7-*
+
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[2],
+ line_indices[12],
+ line_indices[4],
+ line_indices[8]));
+ new_quads[1]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[12],
+ line_indices[3],
+ line_indices[5],
+ line_indices[9]));
+ new_quads[2]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[6],
+ line_indices[10],
+ line_indices[0],
+ line_indices[12]));
+ new_quads[3]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[7],
+ line_indices[11],
+ line_indices[12],
+ line_indices[1]));
+
+ new_quads[0]->set_line_orientation(0,line_orientation[2]);
+ new_quads[0]->set_line_orientation(2,line_orientation[4]);
+ new_quads[0]->set_line_orientation(3,line_orientation[8]);
+
+ new_quads[1]->set_line_orientation(1,line_orientation[3]);
+ new_quads[1]->set_line_orientation(2,line_orientation[5]);
+ new_quads[1]->set_line_orientation(3,line_orientation[9]);
+
+ new_quads[2]->set_line_orientation(0,line_orientation[6]);
+ new_quads[2]->set_line_orientation(1,line_orientation[10]);
+ new_quads[2]->set_line_orientation(2,line_orientation[0]);
+
+ new_quads[3]->set_line_orientation(0,line_orientation[7]);
+ new_quads[3]->set_line_orientation(1,line_orientation[11]);
+ new_quads[3]->set_line_orientation(3,line_orientation[1]);
+
+ // the quads are
+ // numbered as follows:
+ //
+ // planes in the interior
+ // of the old hex:
+ // *
+ // /|
+ // * | x
+ // /| | *---*---* *---------*
+ // * |1| | | | / /
+ // | | | | 2 | 3 | / /
+ // |0| * | | | / /
+ // | |/ *---*---*y *---------*x
+ // | *
+ // |/
+ // *
+ //
+ // children of the faces
+ // of the old hex
+ // *---*---* *---*---*
+ // /| | | /18 / 19/|
+ // * |10 | 11| /---/---* |
+ // /| | | | /16 / 17/| |
+ // * |5| | | *---*---* |7|
+ // | | *---*---* | | | | *
+ // |4|/14 / 15/ | | |6|/
+ // | *---/---/ | 8 | 9 | *
+ // |/12 / 13/ | | |/
+ // *---*---* *---*---*
+ //
+ // note that we have to
+ // take care of the
+ // orientation of
+ // faces.
+ const unsigned int quad_indices_xy[20]
+ = {
+ new_quads[0]->index(), //0
+ new_quads[1]->index(),
+ new_quads[2]->index(),
+ new_quads[3]->index(),
+
+ hex->face(0)->child_index( child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]), //4
+ hex->face(0)->child_index(1-child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]),
+
+ hex->face(1)->child_index( child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]), //6
+ hex->face(1)->child_index(1-child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]),
+
+ hex->face(2)->child_index( child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]), //8
+ hex->face(2)->child_index(1-child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]),
+
+ hex->face(3)->child_index( child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]), //10
+ hex->face(3)->child_index(1-child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]),
+
+ hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4])), //12
+ hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[4],f_fl[4],f_ro[4])),
+ hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[4],f_fl[4],f_ro[4])),
+ hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4])),
+
+ hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5])), //16
+ hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[5],f_fl[5],f_ro[5])),
+ hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[5],f_fl[5],f_ro[5])),
+ hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
+ };
+ quad_indices=&quad_indices_xy[0];
+
+ new_hexes[0]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[4],
+ quad_indices[0],
+ quad_indices[8],
+ quad_indices[2],
+ quad_indices[12],
+ quad_indices[16]));
+ new_hexes[1]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[0],
+ quad_indices[6],
+ quad_indices[9],
+ quad_indices[3],
+ quad_indices[13],
+ quad_indices[17]));
+ new_hexes[2]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[5],
+ quad_indices[1],
+ quad_indices[2],
+ quad_indices[10],
+ quad_indices[14],
+ quad_indices[18]));
+ new_hexes[3]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[1],
+ quad_indices[7],
+ quad_indices[3],
+ quad_indices[11],
+ quad_indices[15],
+ quad_indices[19]));
+ break;
+ }
+ case RefinementCase<dim>::cut_xz:
+ {
+ //////////////////////////////
+ //
+ // RefinementCase<dim>::cut_xz
+ //
+ // the refined cube will look
+ // like this:
+ //
+ // *----*----*
+ // / / /|
+ // / / / |
+ // / / / *
+ // *----*----* /|
+ // | | | / |
+ // | | |/ *
+ // *----*----* /
+ // | | | /
+ // | | |/
+ // *----*----*
+ //
+
+ // first, create the new
+ // internal line
+ new_lines[0]->set (internal::Triangulation::
+ TriaObject<1>(middle_vertex_index<dim,spacedim>(hex->face(2)),
+ middle_vertex_index<dim,spacedim>(hex->face(3))));
+
+ // again, first
+ // collect some data
+ // about the indices of
+ // the lines, with the
+ // following numbering:
+
+ // face 0: left plane
+ // *
+ // /|
+ // / |
+ // / *
+ // * /|
+ // | 0 |
+ // |/ *
+ // * /
+ // | /
+ // |/
+ // *
+ // face 1: right plane
+ // *
+ // /|
+ // / |
+ // / *
+ // * /|
+ // | 1 |
+ // |/ *
+ // * /
+ // | /
+ // |/
+ // *
+ // face 2: front plane
+ // (note: x,y exchanged)
+ // *---*---*
+ // | 5 |
+ // *-6-*-7-*
+ // | 4 |
+ // *---*---*
+ // face 3: back plane
+ // (note: x,y exchanged)
+ // *---*---*
+ // | 9 |
+ // *10-*-11*
+ // | 8 |
+ // *---*---*
+ // face 4: bottom plane
+ // *---*---*
+ // / / /
+ // / 2 /
+ // / / /
+ // *---*---*
+ // face 5: top plane
+ // *---*---*
+ // / / /
+ // / 3 /
+ // / / /
+ // *---*---*
+ // middle planes
+ // *---*---* *-------*
+ // / / / | |
+ // / 12 / | |
+ // / / / | |
+ // *---*---* *-------*
+
+ // set up a list of line iterators
+ // first. from this, construct
+ // lists of line_indices and
+ // line orientations later on
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ lines_xz[13]
+ = {
+ hex->face(0)->child(0)
+ ->line((hex->face(0)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
+ hex->face(1)->child(0)
+ ->line((hex->face(1)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
+ hex->face(4)->child(0)
+ ->line((hex->face(4)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
+ hex->face(5)->child(0)
+ ->line((hex->face(5)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //3
+
+ hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[2],f_fl[2],f_ro[2])), //4
+ hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[2],f_fl[2],f_ro[2])), //5
+ hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[2],f_fl[2],f_ro[2])), //6
+ hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[2],f_fl[2],f_ro[2])), //7
+
+ hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[3],f_fl[3],f_ro[3])), //8
+ hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[3],f_fl[3],f_ro[3])), //9
+ hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[3],f_fl[3],f_ro[3])), //10
+ hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[3],f_fl[3],f_ro[3])), //11
+
+ new_lines[0] //12
+ };
+
+ lines=&lines_xz[0];
+
+ unsigned int line_indices_xz[13];
+
+ for (unsigned int i=0; i<13; ++i)
+ line_indices_xz[i]=lines[i]->index();
+ line_indices=&line_indices_xz[0];
+
+ // the orientation of lines for the
+ // inner quads is quite tricky. as
+ // these lines are newly created
+ // ones and thus have no parents,
+ // they cannot inherit this
+ // property. set up an array and
+ // fill it with the respective
+ // values
+ bool line_orientation_xz[13];
+
+ // the middle vertices of the
+ // lines of our front face
+ const unsigned int middle_vertices[4]=
+ {
+ hex->line(8)->child(0)->vertex_index(1),
+ hex->line(9)->child(0)->vertex_index(1),
+ hex->line(2)->child(0)->vertex_index(1),
+ hex->line(6)->child(0)->vertex_index(1),
+ };
+
+ // note: for lines 0 to 3 the
+ // orientation of the line
+ // is 'true', if vertex 0 is
+ // on the front
+ for (unsigned int i=0; i<4; ++i)
+ if (lines[i]->vertex_index(0)==middle_vertices[i])
+ line_orientation_xz[i]=true;
+ else
+ {
+ // it must be the other way round then
+ Assert(lines[i]->vertex_index(1)==middle_vertices[i],
+ ExcInternalError());
+ line_orientation_xz[i]=false;
+ }
+
+ // note: for lines 4 to 11
+ // (inner lines of the outer quads)
+ // the following holds: the second
+ // vertex of the even lines in
+ // standard orientation is the
+ // vertex in the middle of the
+ // quad, whereas for odd lines the
+ // first vertex is the same middle
+ // vertex.
+ for (unsigned int i=4; i<12; ++i)
+ if (lines[i]->vertex_index((i+1)%2) ==
+ middle_vertex_index<dim,spacedim>(hex->face(1+i/4)))
+ line_orientation_xz[i]=true;
+ else
+ {
+ // it must be the other way
+ // round then
+ Assert(lines[i]->vertex_index(i%2) ==
+ (middle_vertex_index<dim,spacedim>(hex->face(1+i/4))),
+ ExcInternalError());
+ line_orientation_xz[i]=false;
+ }
+ // for the last line the line
+ // orientation is always true,
+ // since it was just constructed
+ // that way
+
+ line_orientation_xz[12]=true;
+ line_orientation=&line_orientation_xz[0];
+
+ // set up the 4 quads,
+ // numbered as follows
+ // (left quad numbering,
+ // right line numbering
+ // extracted from above),
+ // the drawings denote
+ // middle planes
+ //
+ // * *
+ // /| /|
+ // / | 3 9
+ // y/ * / *
+ // * 3/| * /|
+ // | / |x 5 12|8
+ // |/ * |/ *
+ // * 2/ * /
+ // | / 4 2
+ // |/ |/
+ // * *
+ //
+ // y
+ // *----*----* *-10-*-11-*
+ // / / / / / /
+ // / 0 / 1 / 0 12 1
+ // / / / / / /
+ // *----*----*x *--6-*--7-*
+
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[0],
+ line_indices[12],
+ line_indices[6],
+ line_indices[10]));
+ new_quads[1]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[12],
+ line_indices[1],
+ line_indices[7],
+ line_indices[11]));
+ new_quads[2]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[4],
+ line_indices[8],
+ line_indices[2],
+ line_indices[12]));
+ new_quads[3]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[5],
+ line_indices[9],
+ line_indices[12],
+ line_indices[3]));
+
+ new_quads[0]->set_line_orientation(0,line_orientation[0]);
+ new_quads[0]->set_line_orientation(2,line_orientation[6]);
+ new_quads[0]->set_line_orientation(3,line_orientation[10]);
+
+ new_quads[1]->set_line_orientation(1,line_orientation[1]);
+ new_quads[1]->set_line_orientation(2,line_orientation[7]);
+ new_quads[1]->set_line_orientation(3,line_orientation[11]);
+
+ new_quads[2]->set_line_orientation(0,line_orientation[4]);
+ new_quads[2]->set_line_orientation(1,line_orientation[8]);
+ new_quads[2]->set_line_orientation(2,line_orientation[2]);
+
+ new_quads[3]->set_line_orientation(0,line_orientation[5]);
+ new_quads[3]->set_line_orientation(1,line_orientation[9]);
+ new_quads[3]->set_line_orientation(3,line_orientation[3]);
+
+ // the quads are
+ // numbered as follows:
+ //
+ // planes in the interior
+ // of the old hex:
+ // *
+ // /|
+ // / | x
+ // /3 * *-------* *----*----*
+ // * /| | | / / /
+ // | / | | | / 0 / 1 /
+ // |/ * | | / / /
+ // * 2/ *-------*y *----*----*x
+ // | /
+ // |/
+ // *
+ //
+ // children of the faces
+ // of the old hex
+ // *---*---* *---*---*
+ // /|13 | 15| / / /|
+ // / | | | /18 / 19/ |
+ // / *---*---* / / / *
+ // * 5/| | | *---*---* 7/|
+ // | / |12 | 14| | 9 | 11| / |
+ // |/4 *---*---* | | |/6 *
+ // * / / / *---*---* /
+ // | /16 / 17/ | | | /
+ // |/ / / | 8 | 10|/
+ // *---*---* *---*---*
+ //
+ // note that we have to
+ // take care of the
+ // orientation of
+ // faces.
+ const unsigned int quad_indices_xz[20]
+ = {
+ new_quads[0]->index(), //0
+ new_quads[1]->index(),
+ new_quads[2]->index(),
+ new_quads[3]->index(),
+
+ hex->face(0)->child_index( child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]), //4
+ hex->face(0)->child_index(1-child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]),
+
+ hex->face(1)->child_index( child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]), //6
+ hex->face(1)->child_index(1-child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]),
+
+ hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2])), //8
+ hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[2],f_fl[2],f_ro[2])),
+ hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[2],f_fl[2],f_ro[2])),
+ hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2])),
+
+ hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3])), //12
+ hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[3],f_fl[3],f_ro[3])),
+ hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[3],f_fl[3],f_ro[3])),
+ hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3])),
+
+ hex->face(4)->child_index( child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]), //16
+ hex->face(4)->child_index(1-child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]),
+
+ hex->face(5)->child_index( child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]]), //18
+ hex->face(5)->child_index(1-child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]])
+ };
+ quad_indices=&quad_indices_xz[0];
+
+ // due to the exchange of x
+ // and y for the front and
+ // back face, we order the
+ // children according to
+ //
+ // *---*---*
+ // | 1 | 3 |
+ // *---*---*
+ // | 0 | 2 |
+ // *---*---*
+ new_hexes[0]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[4],
+ quad_indices[2],
+ quad_indices[8],
+ quad_indices[12],
+ quad_indices[16],
+ quad_indices[0]));
+ new_hexes[1]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[5],
+ quad_indices[3],
+ quad_indices[9],
+ quad_indices[13],
+ quad_indices[0],
+ quad_indices[18]));
+ new_hexes[2]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[2],
+ quad_indices[6],
+ quad_indices[10],
+ quad_indices[14],
+ quad_indices[17],
+ quad_indices[1]));
+ new_hexes[3]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[3],
+ quad_indices[7],
+ quad_indices[11],
+ quad_indices[15],
+ quad_indices[1],
+ quad_indices[19]));
+ break;
+ }
+ case RefinementCase<dim>::cut_yz:
+ {
+ //////////////////////////////
+ //
+ // RefinementCase<dim>::cut_yz
+ //
+ // the refined cube will look
+ // like this:
+ //
+ // *---------*
+ // / /|
+ // *---------* |
+ // / /| |
+ // *---------* |/|
+ // | | * |
+ // | |/| *
+ // *---------* |/
+ // | | *
+ // | |/
+ // *---------*
+ //
+
+ // first, create the new
+ // internal line
+ new_lines[0]->set (internal::Triangulation::
+ TriaObject<1>(middle_vertex_index<dim,spacedim>(hex->face(0)),
+ middle_vertex_index<dim,spacedim>(hex->face(1))));
+
+ // again, first
+ // collect some data
+ // about the indices of
+ // the lines, with the
+ // following numbering:
+ // (note that face 0 and
+ // 1 each are shown twice
+ // for better
+ // readability)
+
+ // face 0: left plane
+ // * *
+ // /| /|
+ // * | * |
+ // /| * /| *
+ // * 5/| * |7|
+ // | * | | * |
+ // |/| * |6| *
+ // * 4/ * |/
+ // | * | *
+ // |/ |/
+ // * *
+ // face 1: right plane
+ // * *
+ // /| /|
+ // * | * |
+ // /| * /| *
+ // * 9/| * |11
+ // | * | | * |
+ // |/| * |10 *
+ // * 8/ * |/
+ // | * | *
+ // |/ |/
+ // * *
+ // face 2: front plane
+ // (note: x,y exchanged)
+ // *-------*
+ // | |
+ // *---0---*
+ // | |
+ // *-------*
+ // face 3: back plane
+ // (note: x,y exchanged)
+ // *-------*
+ // | |
+ // *---1---*
+ // | |
+ // *-------*
+ // face 4: bottom plane
+ // *-------*
+ // / /
+ // *---2---*
+ // / /
+ // *-------*
+ // face 5: top plane
+ // *-------*
+ // / /
+ // *---3---*
+ // / /
+ // *-------*
+ // middle planes
+ // *-------* *-------*
+ // / / | |
+ // *---12--* | |
+ // / / | |
+ // *-------* *-------*
+
+ // set up a list of line iterators
+ // first. from this, construct
+ // lists of line_indices and
+ // line orientations later on
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ lines_yz[13]
+ = {
+ hex->face(2)->child(0)
+ ->line((hex->face(2)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
+ hex->face(3)->child(0)
+ ->line((hex->face(3)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
+ hex->face(4)->child(0)
+ ->line((hex->face(4)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
+ hex->face(5)->child(0)
+ ->line((hex->face(5)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //3
+
+ hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[0],f_fl[0],f_ro[0])), //4
+ hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[0],f_fl[0],f_ro[0])), //5
+ hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[0],f_fl[0],f_ro[0])), //6
+ hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[0],f_fl[0],f_ro[0])), //7
+
+ hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[1],f_fl[1],f_ro[1])), //8
+ hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[1],f_fl[1],f_ro[1])), //9
+ hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[1],f_fl[1],f_ro[1])), //10
+ hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[1],f_fl[1],f_ro[1])), //11
+
+ new_lines[0] //12
+ };
+
+ lines=&lines_yz[0];
+
+ unsigned int line_indices_yz[13];
+
+ for (unsigned int i=0; i<13; ++i)
+ line_indices_yz[i]=lines[i]->index();
+ line_indices=&line_indices_yz[0];
+
+ // the orientation of lines for the
+ // inner quads is quite tricky. as
+ // these lines are newly created
+ // ones and thus have no parents,
+ // they cannot inherit this
+ // property. set up an array and
+ // fill it with the respective
+ // values
+ bool line_orientation_yz[13];
+
+ // the middle vertices of the
+ // lines of our front face
+ const unsigned int middle_vertices[4]=
+ {
+ hex->line(8)->child(0)->vertex_index(1),
+ hex->line(10)->child(0)->vertex_index(1),
+ hex->line(0)->child(0)->vertex_index(1),
+ hex->line(4)->child(0)->vertex_index(1),
+ };
+
+ // note: for lines 0 to 3 the
+ // orientation of the line
+ // is 'true', if vertex 0 is
+ // on the front
+ for (unsigned int i=0; i<4; ++i)
+ if (lines[i]->vertex_index(0)==middle_vertices[i])
+ line_orientation_yz[i]=true;
+ else
+ {
+ // it must be the other way round then
+ Assert(lines[i]->vertex_index(1)==middle_vertices[i],
+ ExcInternalError());
+ line_orientation_yz[i]=false;
+ }
+
+ // note: for lines 4 to 11
+ // (inner lines of the outer quads)
+ // the following holds: the second
+ // vertex of the even lines in
+ // standard orientation is the
+ // vertex in the middle of the
+ // quad, whereas for odd lines the
+ // first vertex is the same middle
+ // vertex.
+ for (unsigned int i=4; i<12; ++i)
+ if (lines[i]->vertex_index((i+1)%2) ==
+ middle_vertex_index<dim,spacedim>(hex->face(i/4-1)))
+ line_orientation_yz[i]=true;
+ else
+ {
+ // it must be the other way
+ // round then
+ Assert(lines[i]->vertex_index(i%2) ==
+ (middle_vertex_index<dim,spacedim>(hex->face(i/4-1))),
+ ExcInternalError());
+ line_orientation_yz[i]=false;
+ }
+ // for the last line the line
+ // orientation is always true,
+ // since it was just constructed
+ // that way
+
+ line_orientation_yz[12]=true;
+ line_orientation=&line_orientation_yz[0];
+
+ // set up the 4 quads,
+ // numbered as follows (left
+ // quad numbering, right line
+ // numbering extracted from
+ // above)
+ //
+ // x
+ // *-------* *---3---*
+ // | 3 | 5 9
+ // *-------* *---12--*
+ // | 2 | 4 8
+ // *-------*y *---2---*
+ //
+ // y
+ // *---------* *----1----*
+ // / 1 / 7 11
+ // *---------* *----12---*
+ // / 0 / 6 10
+ // *---------*x *----0----*
+
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[6],
+ line_indices[10],
+ line_indices[0],
+ line_indices[12]));
+ new_quads[1]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[7],
+ line_indices[11],
+ line_indices[12],
+ line_indices[1]));
+ new_quads[2]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[2],
+ line_indices[12],
+ line_indices[4],
+ line_indices[8]));
+ new_quads[3]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[12],
+ line_indices[3],
+ line_indices[5],
+ line_indices[9]));
+
+ new_quads[0]->set_line_orientation(0,line_orientation[6]);
+ new_quads[0]->set_line_orientation(1,line_orientation[10]);
+ new_quads[0]->set_line_orientation(2,line_orientation[0]);
+
+ new_quads[1]->set_line_orientation(0,line_orientation[7]);
+ new_quads[1]->set_line_orientation(1,line_orientation[11]);
+ new_quads[1]->set_line_orientation(3,line_orientation[1]);
+
+ new_quads[2]->set_line_orientation(0,line_orientation[2]);
+ new_quads[2]->set_line_orientation(2,line_orientation[4]);
+ new_quads[2]->set_line_orientation(3,line_orientation[8]);
+
+ new_quads[3]->set_line_orientation(1,line_orientation[3]);
+ new_quads[3]->set_line_orientation(2,line_orientation[5]);
+ new_quads[3]->set_line_orientation(3,line_orientation[9]);
+
+ // the quads are
+ // numbered as follows:
+ //
+ // planes in the interior
+ // of the old hex:
+ // *
+ // /|
+ // / | x
+ // / | *-------* *---------*
+ // * | | 3 | / 1 /
+ // | | *-------* *---------*
+ // | * | 2 | / 0 /
+ // | / *-------*y *---------*x
+ // | /
+ // |/
+ // *
+ //
+ // children of the faces
+ // of the old hex
+ // *-------* *-------*
+ // /| | / 19 /|
+ // * | 15 | *-------* |
+ // /|7*-------* / 18 /|11
+ // * |/| | *-------* |/|
+ // |6* | 14 | | 10* |
+ // |/|5*-------* | 13 |/|9*
+ // * |/ 17 / *-------* |/
+ // |4*-------* | |8*
+ // |/ 16 / | 12 |/
+ // *-------* *-------*
+ //
+ // note that we have to
+ // take care of the
+ // orientation of
+ // faces.
+ const unsigned int quad_indices_yz[20]
+ = {
+ new_quads[0]->index(), //0
+ new_quads[1]->index(),
+ new_quads[2]->index(),
+ new_quads[3]->index(),
+
+ hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0])), //4
+ hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[0],f_fl[0],f_ro[0])),
+ hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[0],f_fl[0],f_ro[0])),
+ hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0])),
+
+ hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1])), //8
+ hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[1],f_fl[1],f_ro[1])),
+ hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[1],f_fl[1],f_ro[1])),
+ hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1])),
+
+ hex->face(2)->child_index( child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]), //12
+ hex->face(2)->child_index(1-child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]),
+
+ hex->face(3)->child_index( child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]), //14
+ hex->face(3)->child_index(1-child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]),
+
+ hex->face(4)->child_index( child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]), //16
+ hex->face(4)->child_index(1-child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]),
+
+ hex->face(5)->child_index( child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]]), //18
+ hex->face(5)->child_index(1-child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]])
+ };
+ quad_indices=&quad_indices_yz[0];
+
+ new_hexes[0]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[4],
+ quad_indices[8],
+ quad_indices[12],
+ quad_indices[2],
+ quad_indices[16],
+ quad_indices[0]));
+ new_hexes[1]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[5],
+ quad_indices[9],
+ quad_indices[2],
+ quad_indices[14],
+ quad_indices[17],
+ quad_indices[1]));
+ new_hexes[2]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[6],
+ quad_indices[10],
+ quad_indices[13],
+ quad_indices[3],
+ quad_indices[0],
+ quad_indices[18]));
+ new_hexes[3]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[7],
+ quad_indices[11],
+ quad_indices[3],
+ quad_indices[15],
+ quad_indices[1],
+ quad_indices[19]));
+ break;
+ }
+ case RefinementCase<dim>::cut_xyz:
+ {
+ //////////////////////////////
+ //
+ // RefinementCase<dim>::cut_xyz
+ // isotropic refinement
+ //
+ // the refined cube will look
+ // like this:
+ //
+ // *----*----*
+ // / / /|
+ // *----*----* |
+ // / / /| *
+ // *----*----* |/|
+ // | | | * |
+ // | | |/| *
+ // *----*----* |/
+ // | | | *
+ // | | |/
+ // *----*----*
+ //
+
+ // find the next unused
+ // vertex and set it
+ // appropriately
+ while (triangulation.vertices_used[next_unused_vertex] == true)
+ ++next_unused_vertex;
+ Assert (next_unused_vertex < triangulation.vertices.size(),
+ ExcTooFewVerticesAllocated());
+ triangulation.vertices_used[next_unused_vertex] = true;
+
+ // the new vertex is
+ // definitely in the
+ // interior, so we need not
+ // worry about the boundary.
+ // let it be the average of
+ // the 26 vertices
+ // surrounding it. weight
+ // these vertices in the same
+ // way as they are weighted
+ // in the
+ // @p{MappingQ::set_laplace_on_hex_vector}
+ // function, and like the new
+ // vertex at the center of
+ // the quad is weighted (see
+ // above)
+ triangulation.vertices[next_unused_vertex] = Point<dim>();
+ // first add corners of hex
+ for (unsigned int vertex=0;
+ vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+ triangulation.vertices[next_unused_vertex] += hex->vertex(vertex) / 128;
+ // now add center of lines
+ for (unsigned int line=0;
+ line<GeometryInfo<dim>::lines_per_cell; ++line)
+ triangulation.vertices[next_unused_vertex] += hex->line(line)->child(0)->vertex(1) *
+ 7./192.;
+ // finally add centers of
+ // faces. note that vertex 3
+ // of child 0 is an invariant
+ // with respect to the face
+ // orientation, flip and
+ // rotation
+ for (unsigned int face=0;
+ face<GeometryInfo<dim>::faces_per_cell; ++face)
+ triangulation.vertices[next_unused_vertex] += hex->face(face)->isotropic_child(0)->vertex(3) *
+ 1./12.;
+
+ // set the data of the
+ // six lines. first
+ // collect the indices of
+ // the seven vertices
+ // (consider the two
+ // planes to be crossed
+ // to form the planes
+ // cutting the hex in two
+ // vertically and
+ // horizontally)
+ // *--3--* *--5--*
+ // / / / | | |
+ // 0--6--1 0--6--1
+ // / / / | | |
+ // *--2--* *--4--*
+ // the lines are numbered
+ // as follows:
+ // *--*--* *--*--*
+ // / 1 / | 5 |
+ // *2-*-3* *2-*-3*
+ // / 0 / | 4 |
+ // *--*--* *--*--*
+ //
+ const unsigned int vertex_indices_xyz[7]
+ = { middle_vertex_index<dim,spacedim>(hex->face(0)),
+ middle_vertex_index<dim,spacedim>(hex->face(1)),
+ middle_vertex_index<dim,spacedim>(hex->face(2)),
+ middle_vertex_index<dim,spacedim>(hex->face(3)),
+ middle_vertex_index<dim,spacedim>(hex->face(4)),
+ middle_vertex_index<dim,spacedim>(hex->face(5)),
+ next_unused_vertex
+ };
+ vertex_indices=&vertex_indices_xyz[0];
+
+ new_lines[0]->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[2], vertex_indices[6]));
+ new_lines[1]->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[6], vertex_indices[3]));
+ new_lines[2]->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[0], vertex_indices[6]));
+ new_lines[3]->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[6], vertex_indices[1]));
+ new_lines[4]->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[4], vertex_indices[6]));
+ new_lines[5]->set (internal::Triangulation::
+ TriaObject<1>(vertex_indices[6], vertex_indices[5]));
+
+ // again, first
+ // collect some data
+ // about the indices of
+ // the lines, with the
+ // following numbering:
+ // (note that face 0 and
+ // 1 each are shown twice
+ // for better
+ // readability)
+
+ // face 0: left plane
+ // * *
+ // /| /|
+ // * | * |
+ // /| * /| *
+ // * 1/| * |3|
+ // | * | | * |
+ // |/| * |2| *
+ // * 0/ * |/
+ // | * | *
+ // |/ |/
+ // * *
+ // face 1: right plane
+ // * *
+ // /| /|
+ // * | * |
+ // /| * /| *
+ // * 5/| * |7|
+ // | * | | * |
+ // |/| * |6| *
+ // * 4/ * |/
+ // | * | *
+ // |/ |/
+ // * *
+ // face 2: front plane
+ // (note: x,y exchanged)
+ // *---*---*
+ // | 11 |
+ // *-8-*-9-*
+ // | 10 |
+ // *---*---*
+ // face 3: back plane
+ // (note: x,y exchanged)
+ // *---*---*
+ // | 15 |
+ // *12-*-13*
+ // | 14 |
+ // *---*---*
+ // face 4: bottom plane
+ // *---*---*
+ // / 17 /
+ // *18-*-19*
+ // / 16 /
+ // *---*---*
+ // face 5: top plane
+ // *---*---*
+ // / 21 /
+ // *22-*-23*
+ // / 20 /
+ // *---*---*
+ // middle planes
+ // *---*---* *---*---*
+ // / 25 / | 29 |
+ // *26-*-27* *26-*-27*
+ // / 24 / | 28 |
+ // *---*---* *---*---*
+
+ // set up a list of line iterators
+ // first. from this, construct
+ // lists of line_indices and
+ // line orientations later on
+ const typename Triangulation<dim,spacedim>::raw_line_iterator
+ lines_xyz[30]
+ = {
+ hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[0],f_fl[0],f_ro[0])), //0
+ hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[0],f_fl[0],f_ro[0])), //1
+ hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[0],f_fl[0],f_ro[0])), //2
+ hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[0],f_fl[0],f_ro[0])), //3
+
+ hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[1],f_fl[1],f_ro[1])), //4
+ hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[1],f_fl[1],f_ro[1])), //5
+ hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[1],f_fl[1],f_ro[1])), //6
+ hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[1],f_fl[1],f_ro[1])), //7
+
+ hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[2],f_fl[2],f_ro[2])), //8
+ hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[2],f_fl[2],f_ro[2])), //9
+ hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[2],f_fl[2],f_ro[2])), //10
+ hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[2],f_fl[2],f_ro[2])), //11
+
+ hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[3],f_fl[3],f_ro[3])), //12
+ hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[3],f_fl[3],f_ro[3])), //13
+ hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[3],f_fl[3],f_ro[3])), //14
+ hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[3],f_fl[3],f_ro[3])), //15
+
+ hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[4],f_fl[4],f_ro[4])), //16
+ hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[4],f_fl[4],f_ro[4])), //17
+ hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[4],f_fl[4],f_ro[4])), //18
+ hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[4],f_fl[4],f_ro[4])), //19
+
+ hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[5],f_fl[5],f_ro[5])), //20
+ hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[5],f_fl[5],f_ro[5])), //21
+ hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[5],f_fl[5],f_ro[5])), //22
+ hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
+ ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[5],f_fl[5],f_ro[5])), //23
+
+ new_lines[0], //24
+ new_lines[1], //25
+ new_lines[2], //26
+ new_lines[3], //27
+ new_lines[4], //28
+ new_lines[5] //29
+ };
+
+ lines=&lines_xyz[0];
+
+ unsigned int line_indices_xyz[30];
+ for (unsigned int i=0; i<30; ++i)
+ line_indices_xyz[i]=lines[i]->index();
+ line_indices=&line_indices_xyz[0];
+
+ // the orientation of lines for the
+ // inner quads is quite tricky. as
+ // these lines are newly created
+ // ones and thus have no parents,
+ // they cannot inherit this
+ // property. set up an array and
+ // fill it with the respective
+ // values
+ bool line_orientation_xyz[30];
+
+ // note: for the first 24 lines
+ // (inner lines of the outer quads)
+ // the following holds: the second
+ // vertex of the even lines in
+ // standard orientation is the
+ // vertex in the middle of the
+ // quad, whereas for odd lines the
+ // first vertex is the same middle
+ // vertex.
+ for (unsigned int i=0; i<24; ++i)
+ if (lines[i]->vertex_index((i+1)%2)==vertex_indices[i/4])
+ line_orientation_xyz[i]=true;
+ else
+ {
+ // it must be the other way
+ // round then
+ Assert(lines[i]->vertex_index(i%2)==vertex_indices[i/4],
+ ExcInternalError());
+ line_orientation_xyz[i]=false;
+ }
+ // for the last 6 lines the line
+ // orientation is always true,
+ // since they were just constructed
+ // that way
+ for (unsigned int i=24; i<30; ++i)
+ line_orientation_xyz[i]=true;
+ line_orientation=&line_orientation_xyz[0];
+
+ // set up the 12 quads,
+ // numbered as follows
+ // (left quad numbering,
+ // right line numbering
+ // extracted from above)
+ //
+ // * *
+ // /| 21|
+ // * | * 15
+ // y/|3* 20| *
+ // * |/| * |/|
+ // |2* |x 11 * 14
+ // |/|1* |/| *
+ // * |/ * |17
+ // |0* 10 *
+ // |/ |16
+ // * *
+ //
+ // x
+ // *---*---* *22-*-23*
+ // | 5 | 7 | 1 29 5
+ // *---*---* *26-*-27*
+ // | 4 | 6 | 0 28 4
+ // *---*---*y *18-*-19*
+ //
+ // y
+ // *----*----* *-12-*-13-*
+ // / 10 / 11 / 3 25 7
+ // *----*----* *-26-*-27-*
+ // / 8 / 9 / 2 24 6
+ // *----*----*x *--8-*--9-*
+
+ new_quads[0]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[10],
+ line_indices[28],
+ line_indices[16],
+ line_indices[24]));
+ new_quads[1]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[28],
+ line_indices[14],
+ line_indices[17],
+ line_indices[25]));
+ new_quads[2]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[11],
+ line_indices[29],
+ line_indices[24],
+ line_indices[20]));
+ new_quads[3]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[29],
+ line_indices[15],
+ line_indices[25],
+ line_indices[21]));
+ new_quads[4]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[18],
+ line_indices[26],
+ line_indices[0],
+ line_indices[28]));
+ new_quads[5]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[26],
+ line_indices[22],
+ line_indices[1],
+ line_indices[29]));
+ new_quads[6]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[19],
+ line_indices[27],
+ line_indices[28],
+ line_indices[4]));
+ new_quads[7]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[27],
+ line_indices[23],
+ line_indices[29],
+ line_indices[5]));
+ new_quads[8]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[2],
+ line_indices[24],
+ line_indices[8],
+ line_indices[26]));
+ new_quads[9]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[24],
+ line_indices[6],
+ line_indices[9],
+ line_indices[27]));
+ new_quads[10]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[3],
+ line_indices[25],
+ line_indices[26],
+ line_indices[12]));
+ new_quads[11]->set (internal::Triangulation
+ ::TriaObject<2>(line_indices[25],
+ line_indices[7],
+ line_indices[27],
+ line_indices[13]));
+
+ // now reset the line_orientation
+ // flags of outer lines as they
+ // cannot be set in a loop (at
+ // least not easily)
+ new_quads[0]->set_line_orientation(0,line_orientation[10]);
+ new_quads[0]->set_line_orientation(2,line_orientation[16]);
+
+ new_quads[1]->set_line_orientation(1,line_orientation[14]);
+ new_quads[1]->set_line_orientation(2,line_orientation[17]);
+
+ new_quads[2]->set_line_orientation(0,line_orientation[11]);
+ new_quads[2]->set_line_orientation(3,line_orientation[20]);
+
+ new_quads[3]->set_line_orientation(1,line_orientation[15]);
+ new_quads[3]->set_line_orientation(3,line_orientation[21]);
+
+ new_quads[4]->set_line_orientation(0,line_orientation[18]);
+ new_quads[4]->set_line_orientation(2,line_orientation[0]);
+
+ new_quads[5]->set_line_orientation(1,line_orientation[22]);
+ new_quads[5]->set_line_orientation(2,line_orientation[1]);
+
+ new_quads[6]->set_line_orientation(0,line_orientation[19]);
+ new_quads[6]->set_line_orientation(3,line_orientation[4]);
+
+ new_quads[7]->set_line_orientation(1,line_orientation[23]);
+ new_quads[7]->set_line_orientation(3,line_orientation[5]);
+
+ new_quads[8]->set_line_orientation(0,line_orientation[2]);
+ new_quads[8]->set_line_orientation(2,line_orientation[8]);
+
+ new_quads[9]->set_line_orientation(1,line_orientation[6]);
+ new_quads[9]->set_line_orientation(2,line_orientation[9]);
+
+ new_quads[10]->set_line_orientation(0,line_orientation[3]);
+ new_quads[10]->set_line_orientation(3,line_orientation[12]);
+
+ new_quads[11]->set_line_orientation(1,line_orientation[7]);
+ new_quads[11]->set_line_orientation(3,line_orientation[13]);
+
+ /////////////////////////////////
+ // create the eight new hexes
+ //
+ // again first collect
+ // some data. here, we
+ // need the indices of a
+ // whole lotta
+ // quads.
+
+ // the quads are
+ // numbered as follows:
+ //
+ // planes in the interior
+ // of the old hex:
+ // *
+ // /|
+ // * |
+ // /|3* *---*---* *----*----*
+ // * |/| | 5 | 7 | / 10 / 11 /
+ // |2* | *---*---* *----*----*
+ // |/|1* | 4 | 6 | / 8 / 9 /
+ // * |/ *---*---*y *----*----*x
+ // |0*
+ // |/
+ // *
+ //
+ // children of the faces
+ // of the old hex
+ // *-------* *-------*
+ // /|25 27| /34 35/|
+ // 15| | / /19
+ // / | | /32 33/ |
+ // * |24 26| *-------*18 |
+ // 1413*-------* |21 23| 17*
+ // | /30 31/ | | /
+ // 12/ / | |16
+ // |/28 29/ |20 22|/
+ // *-------* *-------*
+ //
+ // note that we have to
+ // take care of the
+ // orientation of
+ // faces.
+ const unsigned int quad_indices_xyz[36]
+ = {
+ new_quads[0]->index(), //0
+ new_quads[1]->index(),
+ new_quads[2]->index(),
+ new_quads[3]->index(),
+ new_quads[4]->index(),
+ new_quads[5]->index(),
+ new_quads[6]->index(),
+ new_quads[7]->index(),
+ new_quads[8]->index(),
+ new_quads[9]->index(),
+ new_quads[10]->index(),
+ new_quads[11]->index(), //11
+
+ hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0])), //12
+ hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[0],f_fl[0],f_ro[0])),
+ hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[0],f_fl[0],f_ro[0])),
+ hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0])),
+
+ hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1])), //16
+ hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[1],f_fl[1],f_ro[1])),
+ hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[1],f_fl[1],f_ro[1])),
+ hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1])),
+
+ hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2])), //20
+ hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[2],f_fl[2],f_ro[2])),
+ hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[2],f_fl[2],f_ro[2])),
+ hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2])),
+
+ hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3])), //24
+ hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[3],f_fl[3],f_ro[3])),
+ hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[3],f_fl[3],f_ro[3])),
+ hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3])),
+
+ hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4])), //28
+ hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[4],f_fl[4],f_ro[4])),
+ hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[4],f_fl[4],f_ro[4])),
+ hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4])),
+
+ hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5])), //32
+ hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[5],f_fl[5],f_ro[5])),
+ hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[5],f_fl[5],f_ro[5])),
+ hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
+ };
+ quad_indices=&quad_indices_xyz[0];
+
+ // bottom children
+ new_hexes[0]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[12],
+ quad_indices[0],
+ quad_indices[20],
+ quad_indices[4],
+ quad_indices[28],
+ quad_indices[8]));
+ new_hexes[1]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[0],
+ quad_indices[16],
+ quad_indices[22],
+ quad_indices[6],
+ quad_indices[29],
+ quad_indices[9]));
+ new_hexes[2]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[13],
+ quad_indices[1],
+ quad_indices[4],
+ quad_indices[24],
+ quad_indices[30],
+ quad_indices[10]));
+ new_hexes[3]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[1],
+ quad_indices[17],
+ quad_indices[6],
+ quad_indices[26],
+ quad_indices[31],
+ quad_indices[11]));
+
+ // top children
+ new_hexes[4]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[14],
+ quad_indices[2],
+ quad_indices[21],
+ quad_indices[5],
+ quad_indices[8],
+ quad_indices[32]));
+ new_hexes[5]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[2],
+ quad_indices[18],
+ quad_indices[23],
+ quad_indices[7],
+ quad_indices[9],
+ quad_indices[33]));
+ new_hexes[6]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[15],
+ quad_indices[3],
+ quad_indices[5],
+ quad_indices[25],
+ quad_indices[10],
+ quad_indices[34]));
+ new_hexes[7]->set (internal::Triangulation
+ ::TriaObject<3>(quad_indices[3],
+ quad_indices[19],
+ quad_indices[7],
+ quad_indices[27],
+ quad_indices[11],
+ quad_indices[35]));
+ break;
+ }
+ default:
+ // all refinement cases
+ // have been treated,
+ // there only remains
+ // RefinementCase<dim>::no_refinement
+ // as untreated
+ // enumeration
+ // value. However, in
+ // that case we should
+ // have aborted much
+ // earlier. thus we
+ // should never get here
+ Assert(false, ExcInternalError());
+ break;
+ }//switch (ref_case)
+
+ // and set face orientation
+ // flags. note that new faces in
+ // the interior of the mother cell
+ // always have a correctly oriented
+ // face, but the ones on the outer
+ // faces will inherit this flag
+ //
+ // the flag have been set to true
+ // for all faces initially, now go
+ // the other way round and reset
+ // faces that are at the boundary
+ // of the mother cube
+ //
+ // the same is true for the
+ // face_flip and face_rotation
+ // flags. however, the latter two
+ // are set to false by default as
+ // this is the standard value
+
+ // loop over all faces and all
+ // (relevant) subfaces of that in
+ // order to set the correct values
+ // for face_orientation, face_flip
+ // and face_rotation, which are
+ // inherited from the corresponding
+ // face of the mother cube
+ for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+ for (unsigned int s=0;
+ s<std::max(GeometryInfo<dim-1>::n_children(GeometryInfo<dim>::face_refinement_case(ref_case,f)),
+ 1U);
+ ++s)
+ {
+ const unsigned int current_child
+ =GeometryInfo<dim>::child_cell_on_face(ref_case,
+ f,
+ s,
+ f_or[f],
+ f_fl[f],
+ f_ro[f],
+ GeometryInfo<dim>::face_refinement_case(ref_case,
+ f,
+ f_or[f],
+ f_fl[f],
+ f_ro[f]));
+ new_hexes[current_child]->set_face_orientation (f, f_or[f]);
+ new_hexes[current_child]->set_face_flip (f, f_fl[f]);
+ new_hexes[current_child]->set_face_rotation (f, f_ro[f]);
+ }
+
+ // now see if
+ // we have
+ // created
+ // cells that
+ // are
+ // distorted
+ // and if so
+ // add them to
+ // our list
+ if ((check_for_distorted_cells == true)
+ &&
+ has_distorted_children (hex,
+ internal::int2type<dim>(),
+ internal::int2type<spacedim>()))
+ cells_with_distorted_children.distorted_cells.push_back (hex);
+
+ // note that the
+ // refinement flag was
+ // already cleared at the
+ // beginning of this loop
+ }
+ }
+
+ // clear user data on quads. we used some of
+ // this data to indicate anisotropic
+ // refinemnt cases on faces. all data should
+ // be cleared by now, but the information
+ // whether we used indices or pointers is
+ // still present. reset it now to enable the
+ // user to use whichever he likes later on.
+ triangulation.faces->quads.clear_user_data();
+
+ // return the list with distorted children
+ return cells_with_distorted_children;
+ }
+
+
+ /**
+ * At the boundary of the domain, the new
+ * point on the face may be far inside the
+ * current cell, if the boundary has a
+ * strong curvature. If we allow anisotropic
+ * refinement here, the resulting cell may
+ * be strongly distorted. To prevent this,
+ * this function flags such cells for
+ * isotropic refinement. It is called
+ * automatically from
+ * prepare_coarsening_and_refinement().
+ *
+ * This function does nothing in
+ * 1d (therefore the
+ * specialization).
+ */
+ template <int spacedim>
+ static
+ void
+ prevent_distorted_boundary_cells (const Triangulation<1,spacedim> &);
+
+ template <int dim, int spacedim>
+ static
+ void
+ prevent_distorted_boundary_cells (Triangulation<dim,spacedim> &triangulation)
+ {
+ for (typename Triangulation<dim,spacedim>::cell_iterator
+ cell=triangulation.begin(); cell!=triangulation.end(); ++cell)
+ if (cell->at_boundary() &&
+ cell->refine_flag_set() &&
+ cell->refine_flag_set()!=RefinementCase<dim>::isotropic_refinement)
+ {
+ // The cell is at the boundary
+ // and it is flagged for
+ // anisotropic
+ // refinement. Therefore, we have
+ // a closer look
+ const RefinementCase<dim> ref_case=cell->refine_flag_set();
+ for (unsigned int face_no=0;
+ face_no<GeometryInfo<dim>::faces_per_cell;
+ ++face_no)
+ if (cell->face(face_no)->at_boundary())
+ {
+ // this is the critical
+ // face at the boundary.
+ if (GeometryInfo<dim>::face_refinement_case(ref_case,face_no)
+ !=RefinementCase<dim-1>::isotropic_refinement)
+ {
+ // up to now, we do not
+ // want to refine this
+ // cell along the face
+ // under consideration
+ // here.
+ const typename Triangulation<dim,spacedim>::face_iterator
+ face = cell->face(face_no);
+ // the new point on the
+ // boundary would be
+ // this one.
+ const Point<spacedim> new_bound
+ = triangulation.boundary[face->boundary_indicator()]
+ ->get_new_point_on_face (face);
+ // to check it,
+ // transform to the
+ // unit cell with
+ // Q1Mapping
+ const Point<dim> new_unit
+ = StaticMappingQ1<dim,spacedim>::mapping.
+ transform_real_to_unit_cell(cell,
+ new_bound);
+
+ // Now, we have to
+ // calculate the
+ // distance from the
+ // face in the unit
+ // cell.
+
+ // take the correct
+ // coordinate direction (0
+ // for faces 0 and 1, 1 for
+ // faces 2 and 3, 2 for faces
+ // 4 and 5) and substract the
+ // correct boundary value of
+ // the face (0 for faces 0,
+ // 2, and 4; 1 for faces 1, 3
+ // and 5)
+ const double dist = std::fabs(new_unit[face_no/2] - face_no%2);
+ // compare this with
+ // the empirical value
+ // allowed. if it is
+ // too big, flag the
+ // face for isotropic
+ // refinement
+ const double allowed=0.25;
+
+ if (dist>allowed)
+ cell->flag_for_face_refinement(face_no);
+ }//if flagged for anistropic refinement
+ }//if (cell->face(face)->at_boundary())
+ }//for all cells
+ }
+
+
+ /**
+ * Some dimension dependent stuff for
+ * mesh smoothing.
+ *
+ * At present, this function does nothing
+ * in 1d and 2D, but makes sure no two
+ * cells with a level difference greater
+ * than one share one line in 3D. This
+ * is a requirement needed for the
+ * interpolation of hanging nodes, since
+ * otherwise to steps of interpolation
+ * would be necessary. This would make
+ * the processes implemented in the
+ * @p ConstraintMatrix class much more
+ * complex, since these two steps of
+ * interpolation do not commute.
+ */
+ template <int dim, int spacedim>
+ static
+ void
+ prepare_refinement_dim_dependent (const Triangulation<dim,spacedim> &)
+ {
+ Assert (dim < 3,
+ ExcMessage ("Wrong function called -- there should "
+ "be a specialization."));
+ }
+
+
+ template <int spacedim>
+ static
+ void
+ prepare_refinement_dim_dependent (Triangulation<3,spacedim> &triangulation)
+ {
+ const unsigned int dim = 3;
+
+ // first clear flags on lines,
+ // since we need them to determine
+ // which lines will be refined
+ triangulation.clear_user_flags_line();
+
+ // also clear flags on hexes, since we need
+ // them to mark those cells which are to be
+ // coarsened
+ triangulation.clear_user_flags_hex();
+
+ // variable to store whether the
+ // mesh was changed in the present
+ // loop and in the whole process
+ bool mesh_changed = false;
+
+ do
+ {
+ mesh_changed = false;
+
+ // for this following, we need to know
+ // which cells are going to be
+ // coarsened, if we had to make a
+ // decision. the following function
+ // sets these flags:
+ triangulation.fix_coarsen_flags ();
+
+
+ // flag those lines that are refined and
+ // will not be coarsened and those that
+ // will be refined
+ for (typename Triangulation<dim,spacedim>::cell_iterator
+ cell=triangulation.begin(); cell!=triangulation.end(); ++cell)
+ if (cell->refine_flag_set())
+ {
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ if (GeometryInfo<dim>::line_refinement_case(cell->refine_flag_set(), line)
+ ==RefinementCase<1>::cut_x)
+ // flag a line, that will be
+ // refined
+ cell->line(line)->set_user_flag();
+ }
+ else if(cell->has_children() && !cell->child(0)->coarsen_flag_set())
+ {
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ if (GeometryInfo<dim>::line_refinement_case(cell->refinement_case(), line)
+ ==RefinementCase<1>::cut_x)
+ // flag a line, that is refined
+ // and will stay so
+ cell->line(line)->set_user_flag();
+ }
+ else if(cell->has_children() && cell->child(0)->coarsen_flag_set())
+ cell->set_user_flag();
+
+
+ // now check whether there are
+ // cells with lines that are
+ // more than once refined or
+ // that will be more than once
+ // refined. The first thing
+ // should never be the case, in
+ // the second case we flag the
+ // cell for refinement
+ for (typename Triangulation<dim,spacedim>::active_cell_iterator
+ cell=triangulation.last_active(); cell!=triangulation.end(); --cell)
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ {
+ if (cell->line(line)->has_children())
+ {
+ // if this line is
+ // refined, its
+ // children should
+ // not have further
+ // children
+ //
+ // however, if any of
+ // the children is
+ // flagged for
+ // further
+ // refinement, we
+ // need to refine
+ // this cell also (at
+ // least, if the cell
+ // is not already
+ // flagged)
+ bool offending_line_found = false;
+
+ for (unsigned int c=0; c<2; ++c)
+ {
+ Assert (cell->line(line)->child(c)->has_children() == false,
+ ExcInternalError());
+
+ if (cell->line(line)->child(c)->user_flag_set () &&
+ (GeometryInfo<dim>::line_refinement_case(cell->refine_flag_set(),
+ line)
+ ==RefinementCase<1>::no_refinement))
+ {
+ // tag this
+ // cell for
+ // refinement
+ cell->clear_coarsen_flag ();
+ // if anisotropic
+ // coarsening is
+ // allowed: extend the
+ // refine_flag in the
+ // needed direction,
+ // else set refine_flag
+ // (isotropic)
+ if (triangulation.smooth_grid &
+ Triangulation<dim,spacedim>::allow_anisotropic_smoothing)
+ cell->flag_for_line_refinement(line);
+ else
+ cell->set_refine_flag();
+
+ for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
+ if (GeometryInfo<dim>::line_refinement_case(cell->refine_flag_set(), line)
+ ==RefinementCase<1>::cut_x)
+ // flag a line,
+ // that will be
+ // refined
+ cell->line(l)->set_user_flag();
+ // note that
+ // we have
+ // changed
+ // the grid
+ offending_line_found = true;
+
+ // it may save us several
+ // loop iterations if we
+ // flag all lines of
+ // this cell now (and not
+ // at the outset of the
+ // next iteration) for
+ // refinement
+ for (unsigned int line=0;
+ line<GeometryInfo<dim>::lines_per_cell; ++line)
+ if (!cell->line(line)->has_children() &&
+ (GeometryInfo<dim>::line_refinement_case(cell->refine_flag_set(),
+ line)
+ !=RefinementCase<1>::no_refinement))
+ cell->line(line)->set_user_flag();
+
+ break;
+ }
+ }
+
+ if (offending_line_found)
+ {
+ mesh_changed = true;
+ break;
+ }
+ }
+ }
+
+
+ // there is another thing here:
+ // if any of the lines will be
+ // refined, then we may not
+ // coarsen the present cell
+ // similarly, if any of the lines
+ // *is* already refined, we may
+ // not coarsen the current
+ // cell. however, there's a
+ // catch: if the line is refined,
+ // but the cell behind it is
+ // going to be coarsened, then
+ // the situation changes. if we
+ // forget this second condition,
+ // the refine_and_coarsen_3d test
+ // will start to fail. note that
+ // to know which cells are going
+ // to be coarsened, the call for
+ // fix_coarsen_flags above is
+ // necessary
+ for (typename Triangulation<dim,spacedim>::cell_iterator
+ cell=triangulation.last(); cell!=triangulation.end(); --cell)
+ {
+ if (cell->user_flag_set())
+ for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+ if (cell->line(line)->has_children() &&
+ (cell->line(line)->child(0)->user_flag_set() ||
+ cell->line(line)->child(1)->user_flag_set()))
+ {
+ for (unsigned int c=0; c<cell->n_children(); ++c)
+ cell->child(c)->clear_coarsen_flag ();
+ cell->clear_user_flag();
+ for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
+ if (GeometryInfo<dim>::line_refinement_case(cell->refinement_case(), l)
+ ==RefinementCase<1>::cut_x)
+ // flag a line, that is refined
+ // and will stay so
+ cell->line(l)->set_user_flag();
+ mesh_changed = true;
+ break;
+ }
+ }
+ }
+ while (mesh_changed == true);
+ }
+
+
+
+ /**
+ * Helper function for
+ * @p fix_coarsen_flags. Return wether
+ * coarsening of this cell is allowed.
+ * Coarsening can be forbidden if the
+ * neighboring cells are or will be
+ * refined twice along the common face.
+ */
+ template <int dim, int spacedim>
+ static
+ bool
+ coarsening_allowed (const typename Triangulation<dim,spacedim>::cell_iterator& cell)
+ {
+ // in 1d, coarsening is
+ // always allowed since we
+ // don't enforce the 2:1
+ // constraint there
+ if (dim == 1)
+ return true;
+
+ const RefinementCase<dim> ref_case = cell->refinement_case();
+ for (unsigned int n=0; n<GeometryInfo<dim>::faces_per_cell; ++n)
+ {
+ // if the cell is not refined
+ // along that face, coarsening
+ // will not change anything, so
+ // do nothing. the same applies,
+ // if the face is at the boandary
+ const RefinementCase<dim-1> face_ref_case =
+ GeometryInfo<dim>::face_refinement_case(cell->refinement_case(), n);
+
+ const unsigned int n_subfaces
+ = GeometryInfo<dim-1>::n_children(face_ref_case);
+
+ if (n_subfaces == 0 || cell->at_boundary(n))
+ continue;
+ for (unsigned int c=0; c<n_subfaces; ++c)
+ {
+ const typename Triangulation<dim,spacedim>::cell_iterator
+ child = cell->child(GeometryInfo<dim>::
+ child_cell_on_face(ref_case,
+ n,c));
+
+ const typename Triangulation<dim,spacedim>::cell_iterator
+ child_neighbor = child->neighbor(n);
+ if (!child->neighbor_is_coarser(n))
+ // in 2d, if the child's neighbor
+ // is coarser, then it has no
+ // children. however, in 3d it
+ // might be otherwise. consider
+ // for example, that our face
+ // might be refined with cut_x,
+ // but the neighbor is refined
+ // with cut_xy at that face. then
+ // the neighbor pointers of the
+ // children of our cell will point
+ // to the common neighbor cell,
+ // not to its children. what we
+ // really want to know in the
+ // following is, wether the
+ // neighbor cell is refined twice
+ // with reference to our cell.
+ // that only has to be asked, if
+ // the child's neighbor is not a
+ // coarser one.
+ if ((child_neighbor->has_children() &&
+ !child_neighbor->user_flag_set())||
+ // neighbor has children, which
+ // are further refined along
+ // the face, otherwise
+ // something went wrong in the
+ // contruction of neighbor
+ // pointers. then only allow
+ // coarsening if this neighbor
+ // will be coarsened as well
+ // (user_pointer is set). the
+ // same applies, if the
+ // neighbors children are not
+ // refined but will be after
+ // refinement
+ child_neighbor->refine_flag_set())
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+ }
+}
+
+
+template <int dim, int spacedim>
+const StraightBoundary<dim,spacedim>
+Triangulation<dim, spacedim>::straight_boundary = StraightBoundary<dim,spacedim>();
+
+
+
+template <int dim, int spacedim>
+const unsigned int
+Triangulation<dim, spacedim>::dimension;
+
+
+
+template <int dim, int spacedim>
+Triangulation<dim, spacedim>::
+Triangulation (const MeshSmoothing smooth_grid,
+ const bool check_for_distorted_cells)
+ :
+ smooth_grid(smooth_grid),
+ faces(NULL),
+ anisotropic_refinement(false),
+ check_for_distorted_cells(check_for_distorted_cells)
+{
+ // set default boundary for all
+ // possible components
+ for (unsigned int i=0;i<255;++i)
+ boundary[i] = &straight_boundary;
+}
+
+
+template <int dim, int spacedim>
+Triangulation<dim, spacedim>::
+Triangulation (const Triangulation<dim, spacedim> &)
+ // do not set any subscriptors;
+ // anyway, calling this constructor
+ // is an error!
+ :
+ Subscriptor(),
+ check_for_distorted_cells(check_for_distorted_cells)
+{
+ Assert (false, ExcInternalError());
+}
+
+
+
+template <int dim, int spacedim>
+Triangulation<dim, spacedim>::~Triangulation ()
+{
+ for (unsigned int i=0; i<levels.size(); ++i)
+ delete levels[i];
+ levels.clear ();
+ delete faces;
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::clear ()
+{
+ clear_despite_subscriptions();
+}
+
+
+
+template <int dim, int spacedim>
+void
+Triangulation<dim, spacedim>::set_mesh_smoothing(const MeshSmoothing mesh_smoothing)
+{
+ Assert (n_levels() == 0, ExcTriangulationNotEmpty ());
+ smooth_grid=mesh_smoothing;
+}
+
+
+
+template <int dim, int spacedim>
+void
+Triangulation<dim, spacedim>::set_boundary (const unsigned int number,
+ const Boundary<dim, spacedim>& boundary_object)
+{
+ Assert(number<255, ExcIndexRange(number,0,255));
+
+ boundary[number] = &boundary_object;
+}
+
+
+
+template <int dim, int spacedim>
+void
+Triangulation<dim, spacedim>::set_boundary (const unsigned int number)
+{
+ set_boundary (number, straight_boundary);
+}
+
+
+
+template <int dim, int spacedim>
+const Boundary<dim, spacedim> &
+Triangulation<dim, spacedim>::get_boundary (const unsigned int number) const
+{
+ Assert(number<255, ExcIndexRange(number,0,255));
+
+ return *(boundary[number]);
+}
+
+
+template <int dim, int spacedim>
+std::vector<unsigned char>
+Triangulation<dim, spacedim>::get_boundary_indicators () const
+{
+ // in 1d, the situation is simpler:
+ if (dim == 1)
+ return std::vector<unsigned char> (0);;
+
+ std::vector<bool> bi_exists(255, false);
+ active_cell_iterator cell=begin_active();
+ for (; cell!=end(); ++cell)
+ for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+ if (cell->at_boundary(face))
+ bi_exists[cell->face(face)->boundary_indicator()]=true;
+
+ const unsigned int n_bi=
+ std::count(bi_exists.begin(), bi_exists.end(), true);
+
+ std::vector<unsigned char> boundary_indicators(n_bi);
+ unsigned int bi_counter=0;
+ for (unsigned int i=0; i<bi_exists.size(); ++i)
+ if (bi_exists[i]==true)
+ boundary_indicators[bi_counter++]=i;
+
+ return boundary_indicators;
+}
+
+
+
+/*-----------------------------------------------------------------*/
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::copy_triangulation (const Triangulation<dim, spacedim> &old_tria)
+{
+ Assert (vertices.size() == 0, ExcTriangulationNotEmpty());
+ Assert (levels.size () == 0, ExcTriangulationNotEmpty());
+ Assert (faces == NULL, ExcTriangulationNotEmpty());
+
+ Assert (old_tria.levels.size() != 0, ExcInternalError());
+ Assert (old_tria.vertices.size() != 0, ExcInternalError());
+ Assert (dim == 1 || old_tria.faces != NULL, ExcInternalError());
+
+
+ // copy normal elements
+ vertices = old_tria.vertices;
+ vertices_used = old_tria.vertices_used;
+ anisotropic_refinement = old_tria.anisotropic_refinement;
+ smooth_grid = old_tria.smooth_grid;
+
+ faces = new internal::Triangulation::TriaFaces<dim>(*old_tria.faces);
+
+ for (unsigned i=0;i<255;++i)
+ boundary[i] = old_tria.boundary[i];
+
+ levels.reserve (old_tria.levels.size());
+ for (unsigned int level=0; level<old_tria.levels.size(); ++level)
+ levels.push_back (new internal::Triangulation::TriaLevel<dim>(*old_tria.levels[level]));
+
+ number_cache = old_tria.number_cache;
+
+ // inform RefinementListeners of old_tria of
+ // the copy operation
+ typename std::list<RefinementListener *>::iterator ref_listener =
+ old_tria.refinement_listeners.begin (),
+ end_listener = old_tria.refinement_listeners.end ();
+ for (; ref_listener != end_listener; ++ref_listener)
+ (*ref_listener)->copy_notification (old_tria, *this);
+
+ // note that we need not copy the
+ // subscriptor!
+}
+
+
+
+template <int dim, int spacedim>
+void
+Triangulation<dim,spacedim>::
+create_triangulation_compatibility (const std::vector<Point<spacedim> > &v,
+ const std::vector<CellData<dim> > &cells,
+ const SubCellData &subcelldata)
+{
+ std::vector<CellData<dim> > reordered_cells (cells);
+ SubCellData reordered_subcelldata (subcelldata);
+
+ // in-place reordering of data
+ reorder_compatibility (reordered_cells, reordered_subcelldata);
+
+ // now create triangulation from
+ // reordered data
+ create_triangulation(v, reordered_cells, reordered_subcelldata);
+}
+
+
+template <int dim, int spacedim>
+void
+Triangulation<dim,spacedim>::
+create_triangulation (const std::vector<Point<spacedim> > &v,
+ const std::vector<CellData<dim> > &cells,
+ const SubCellData &subcelldata)
+{
+ Assert (vertices.size() == 0, ExcTriangulationNotEmpty());
+ Assert (levels.size() == 0, ExcTriangulationNotEmpty());
+ Assert (faces == NULL, ExcTriangulationNotEmpty());
+ // check that no forbidden arrays
+ // are used
+ Assert (subcelldata.check_consistency(dim), ExcInternalError());
+
+ // try to create a triangulation;
+ // if this fails, we still want to
+ // throw an exception but if we
+ // just do so we'll get into
+ // trouble because sometimes other
+ // objects are already attached to
+ // it:
+ try
+ {
+ internal::Triangulation::Implementation::create_triangulation (v, cells, subcelldata, *this);
+ }
+ catch (...)
+ {
+ clear_despite_subscriptions();
+ throw;
+ }
+
+ compute_number_cache (*this, levels.size(), number_cache);
+
+ // now verify that there are indeed
+ // no distorted cells. as per the
+ // documentation of this class, we
+ // first collect all distorted
+ // cells and then throw an
+ // exception if there are any
+ if (check_for_distorted_cells == true)
+ {
+ DistortedCellList distorted_cells = collect_distorted_coarse_cells (*this);
+ // throw the array (and fill the
+ // various location fields) if
+ // there are distorted
+ // cells. otherwise, just fall off
+ // the end of the function
+ AssertThrow (distorted_cells.distorted_cells.size() == 0,
+ distorted_cells);
+ }
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::distort_random (const double factor,
+ const bool keep_boundary)
+{
+ internal::Triangulation::Implementation::distort_random (factor, keep_boundary, *this);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::set_all_refine_flags ()
+{
+ active_cell_iterator cell = begin_active(),
+ endc = end();
+
+ for (; cell != endc; ++cell)
+ {
+ cell->clear_coarsen_flag();
+ cell->set_refine_flag ();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::refine_global (const unsigned int times)
+{
+ for (unsigned int i=0; i<times; ++i)
+ {
+ set_all_refine_flags();
+ execute_coarsening_and_refinement ();
+ }
+}
+
+
+
+/*-------------------- refine/coarsen flags -------------------------*/
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_refine_flags (std::vector<bool> &v) const
+{
+ v.resize (dim*n_active_cells(), false);
+ std::vector<bool>::iterator i = v.begin();
+ active_cell_iterator cell = begin_active(),
+ endc = end();
+ for (; cell!=endc; ++cell)
+ for (unsigned int j=0; j<dim; ++j,++i)
+ if (cell->refine_flag_set() & (1<<j) )
+ *i = true;
+
+ Assert (i == v.end(), ExcInternalError());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_refine_flags (std::ostream &out) const
+{
+ std::vector<bool> v;
+ save_refine_flags (v);
+ write_bool_vector (mn_tria_refine_flags_begin, v, mn_tria_refine_flags_end,
+ out);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_refine_flags (std::istream &in)
+{
+ std::vector<bool> v;
+ read_bool_vector (mn_tria_refine_flags_begin, v, mn_tria_refine_flags_end,
+ in);
+ load_refine_flags (v);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_refine_flags (const std::vector<bool> &v)
+{
+ AssertThrow (v.size() == dim*n_active_cells(), ExcGridReadError());
+
+ active_cell_iterator cell = begin_active(),
+ endc = end();
+ std::vector<bool>::const_iterator i = v.begin();
+ for (; cell!=endc; ++cell)
+ {
+ unsigned int ref_case=0;
+
+ for(unsigned int j=0; j<dim; ++j, ++i)
+ if (*i == true)
+ ref_case+=1<<j;
+ Assert(ref_case<RefinementCase<dim>::isotropic_refinement+1,
+ ExcGridReadError());
+ if (ref_case>0)
+ cell->set_refine_flag(RefinementCase<dim>(ref_case));
+ else
+ cell->clear_refine_flag();
+ }
+
+ Assert (i == v.end(), ExcInternalError());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_coarsen_flags (std::vector<bool> &v) const
+{
+ v.resize (n_active_cells(), false);
+ std::vector<bool>::iterator i = v.begin();
+ active_cell_iterator cell = begin_active(),
+ endc = end();
+ for (; cell!=endc; ++cell, ++i)
+ *i = cell->coarsen_flag_set();
+
+ Assert (i == v.end(), ExcInternalError());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_coarsen_flags (std::ostream &out) const
+{
+ std::vector<bool> v;
+ save_coarsen_flags (v);
+ write_bool_vector (mn_tria_coarsen_flags_begin, v, mn_tria_coarsen_flags_end,
+ out);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_coarsen_flags (std::istream &in)
+{
+ std::vector<bool> v;
+ read_bool_vector (mn_tria_coarsen_flags_begin, v, mn_tria_coarsen_flags_end,
+ in);
+ load_coarsen_flags (v);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_coarsen_flags (const std::vector<bool> &v)
+{
+ Assert (v.size() == n_active_cells(), ExcGridReadError());
+
+ active_cell_iterator cell = begin_active(),
+ endc = end();
+ std::vector<bool>::const_iterator i = v.begin();
+ for (; cell!=endc; ++cell, ++i)
+ if (*i == true)
+ cell->set_coarsen_flag();
+ else
+ cell->clear_coarsen_flag();
+
+ Assert (i == v.end(), ExcInternalError());
+}
+
+
+template <int dim, int spacedim>
+bool Triangulation<dim,spacedim>::get_anisotropic_refinement_flag() const
+{
+ return anisotropic_refinement;
+}
+
+
+
+/*-------------------- user data/flags -------------------------*/
+
+
+namespace
+{
+ // clear user data of cells
+ template <int dim>
+ void clear_user_data (std::vector<internal::Triangulation::TriaLevel<dim>*> &levels)
+ {
+ for (unsigned int level=0;level<levels.size();++level)
+ levels[level]->cells.clear_user_data();
+ }
+
+
+ // clear user data of faces
+ void clear_user_data (internal::Triangulation::TriaFaces<1> *)
+ {
+ // nothing to do in 1d
+ }
+
+
+ void clear_user_data (internal::Triangulation::TriaFaces<2> *faces)
+ {
+ faces->lines.clear_user_data();
+ }
+
+
+ void clear_user_data (internal::Triangulation::TriaFaces<3> *faces)
+ {
+ faces->lines.clear_user_data();
+ faces->quads.clear_user_data();
+ }
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim,spacedim>::clear_user_data ()
+{
+ // let functions in anonymous namespace do their work
+ dealii::clear_user_data (levels);
+ dealii::clear_user_data (faces);
+}
+
+
+
+namespace
+{
+ void clear_user_flags_line (std::vector<internal::Triangulation::TriaLevel<1>*> &levels,
+ internal::Triangulation::TriaFaces<1> *)
+ {
+ for (unsigned int level=0; level<levels.size(); ++level)
+ levels[level]->cells.clear_user_flags();
+ }
+
+ template <int dim>
+ void clear_user_flags_line (std::vector<internal::Triangulation::TriaLevel<dim>*> &,
+ internal::Triangulation::TriaFaces<dim> *faces)
+ {
+ faces->lines.clear_user_flags();
+ }
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim,spacedim>::clear_user_flags_line ()
+{
+ dealii::clear_user_flags_line (levels, faces);
+}
+
+
+
+namespace
+{
+ void clear_user_flags_quad (std::vector<internal::Triangulation::TriaLevel<1>*> &,
+ internal::Triangulation::TriaFaces<1> *)
+ {
+ // nothing to do in 1d
+ }
+
+ void clear_user_flags_quad (std::vector<internal::Triangulation::TriaLevel<2>*> &levels,
+ internal::Triangulation::TriaFaces<2> *)
+ {
+ for (unsigned int level=0; level<levels.size(); ++level)
+ levels[level]->cells.clear_user_flags();
+ }
+
+ template <int dim>
+ void clear_user_flags_quad (std::vector<internal::Triangulation::TriaLevel<dim>*> &,
+ internal::Triangulation::TriaFaces<dim> *faces)
+ {
+ faces->quads.clear_user_flags();
+ }
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim,spacedim>::clear_user_flags_quad ()
+{
+ dealii::clear_user_flags_quad (levels, faces);
+}
+
+
+
+namespace
+{
+ void clear_user_flags_hex (std::vector<internal::Triangulation::TriaLevel<1>*> &,
+ internal::Triangulation::TriaFaces<1> *)
+ {
+ // nothing to do in 1d
+ }
+
+
+ void clear_user_flags_hex (std::vector<internal::Triangulation::TriaLevel<2>*> &,
+ internal::Triangulation::TriaFaces<2> *)
+ {
+ // nothing to do in 2d
+ }
+
+ void clear_user_flags_hex (std::vector<internal::Triangulation::TriaLevel<3>*> &levels,
+ internal::Triangulation::TriaFaces<3> *)
+ {
+ for (unsigned int level=0; level<levels.size(); ++level)
+ levels[level]->cells.clear_user_flags();
+ }
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim,spacedim>::clear_user_flags_hex ()
+{
+ dealii::clear_user_flags_hex (levels, faces);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim,spacedim>::clear_user_flags ()
+{
+ clear_user_flags_line ();
+ clear_user_flags_quad ();
+ clear_user_flags_hex ();
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim,spacedim>::clear_user_pointers ()
+{
+ clear_user_data();
+}
+
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_flags (std::ostream &out) const
+{
+ save_user_flags_line (out);
+
+ if (dim>=2)
+ save_user_flags_quad (out);
+
+ if (dim>=3)
+ save_user_flags_hex (out);
+
+ if (dim >= 4)
+ Assert (false, ExcNotImplemented());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_flags (std::vector<bool> &v) const
+{
+ // clear vector and append
+ // all the stuff later on
+ v.clear ();
+
+ std::vector<bool> tmp;
+
+ save_user_flags_line (tmp);
+ v.insert (v.end(), tmp.begin(), tmp.end());
+
+ if (dim >= 2)
+ {
+ save_user_flags_quad (tmp);
+ v.insert (v.end(), tmp.begin(), tmp.end());
+ }
+
+ if (dim >= 3)
+ {
+ save_user_flags_hex (tmp);
+ v.insert (v.end(), tmp.begin(), tmp.end());
+ }
+
+ if (dim >= 4)
+ Assert (false, ExcNotImplemented());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_flags (std::istream &in)
+{
+ load_user_flags_line (in);
+
+ if (dim>=2)
+ load_user_flags_quad (in);
+
+ if (dim>=3)
+ load_user_flags_hex (in);
+
+ if (dim >= 4)
+ Assert (false, ExcNotImplemented());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_flags (const std::vector<bool> &v)
+{
+ Assert (v.size() == n_lines()+n_quads()+n_hexs(), ExcInternalError());
+ std::vector<bool> tmp;
+
+ // first extract the flags
+ // belonging to lines
+ tmp.insert (tmp.end(),
+ v.begin(), v.begin()+n_lines());
+ // and set the lines
+ load_user_flags_line (tmp);
+
+ if (dim >= 2)
+ {
+ tmp.clear ();
+ tmp.insert (tmp.end(),
+ v.begin()+n_lines(), v.begin()+n_lines()+n_quads());
+ load_user_flags_quad (tmp);
+ }
+
+ if (dim >= 3)
+ {
+ tmp.clear();
+ tmp.insert (tmp.end(),
+ v.begin()+n_lines()+n_quads(), v.begin()+n_lines()+n_quads()+n_hexs());
+ load_user_flags_hex (tmp);
+ }
+
+ if (dim >= 4)
+ Assert (false, ExcNotImplemented());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_flags_line (std::vector<bool> &v) const
+{
+ v.resize (n_lines(), false);
+ std::vector<bool>::iterator i = v.begin();
+ line_iterator line = begin_line(),
+ endl = end_line();
+ for (; line!=endl; ++line, ++i)
+ *i = line->user_flag_set();
+
+ Assert (i == v.end(), ExcInternalError());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_flags_line (std::ostream &out) const
+{
+ std::vector<bool> v;
+ save_user_flags_line (v);
+ write_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
+ out);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_flags_line (std::istream &in)
+{
+ std::vector<bool> v;
+ read_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
+ in);
+ load_user_flags_line (v);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_flags_line (const std::vector<bool> &v)
+{
+ Assert (v.size() == n_lines(), ExcGridReadError());
+
+ line_iterator line = begin_line(),
+ endl = end_line();
+ std::vector<bool>::const_iterator i = v.begin();
+ for (; line!=endl; ++line, ++i)
+ if (*i == true)
+ line->set_user_flag();
+ else
+ line->clear_user_flag();
+
+ Assert (i == v.end(), ExcInternalError());
+}
+
+
+namespace
+{
+ template <typename Iterator>
+ bool get_user_flag (const Iterator &i)
+ {
+ return i->user_flag_set();
+ }
+
+
+
+ template <int structdim, int dim, int spacedim>
+ bool get_user_flag (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &)
+ {
+ Assert (false, ExcInternalError());
+ return false;
+ }
+
+
+
+ template <typename Iterator>
+ void set_user_flag (const Iterator &i)
+ {
+ i->set_user_flag();
+ }
+
+
+
+ template <int structdim, int dim, int spacedim>
+ void set_user_flag (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &)
+ {
+ Assert (false, ExcInternalError());
+ }
+
+
+
+ template <typename Iterator>
+ void clear_user_flag (const Iterator &i)
+ {
+ i->clear_user_flag();
+ }
+
+
+
+ template <int structdim, int dim, int spacedim>
+ void clear_user_flag (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &)
+ {
+ Assert (false, ExcInternalError());
+ }
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_flags_quad (std::vector<bool> &v) const
+{
+ v.resize (n_quads(), false);
+
+ if (dim >= 2)
+ {
+ std::vector<bool>::iterator i = v.begin();
+ quad_iterator quad = begin_quad(),
+ endq = end_quad();
+ for (; quad!=endq; ++quad, ++i)
+ *i = get_user_flag (quad);
+
+ Assert (i == v.end(), ExcInternalError());
+ }
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_flags_quad (std::ostream &out) const
+{
+ std::vector<bool> v;
+ save_user_flags_quad (v);
+ write_bool_vector (mn_tria_quad_user_flags_begin, v, mn_tria_quad_user_flags_end,
+ out);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_flags_quad (std::istream &in)
+{
+ std::vector<bool> v;
+ read_bool_vector (mn_tria_quad_user_flags_begin, v, mn_tria_quad_user_flags_end,
+ in);
+ load_user_flags_quad (v);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_flags_quad (const std::vector<bool> &v)
+{
+ Assert (v.size() == n_quads(), ExcGridReadError());
+
+ if (dim >= 2)
+ {
+ quad_iterator quad = begin_quad(),
+ endq = end_quad();
+ std::vector<bool>::const_iterator i = v.begin();
+ for (; quad!=endq; ++quad, ++i)
+ if (*i == true)
+ set_user_flag(quad);
+ else
+ clear_user_flag(quad);
+
+ Assert (i == v.end(), ExcInternalError());
+ }
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_flags_hex (std::vector<bool> &v) const
+{
+ v.resize (n_hexs(), false);
+
+ if (dim >= 3)
+ {
+ std::vector<bool>::iterator i = v.begin();
+ hex_iterator hex = begin_hex(),
+ endh = end_hex();
+ for (; hex!=endh; ++hex, ++i)
+ *i = get_user_flag (hex);
+
+ Assert (i == v.end(), ExcInternalError());
+ }
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_flags_hex (std::ostream &out) const
+{
+ std::vector<bool> v;
+ save_user_flags_hex (v);
+ write_bool_vector (mn_tria_hex_user_flags_begin, v, mn_tria_hex_user_flags_end,
+ out);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_flags_hex (std::istream &in)
+{
+ std::vector<bool> v;
+ read_bool_vector (mn_tria_hex_user_flags_begin, v, mn_tria_hex_user_flags_end,
+ in);
+ load_user_flags_hex (v);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_flags_hex (const std::vector<bool> &v)
+{
+ Assert (v.size() == n_hexs(), ExcGridReadError());
+
+ if (dim >= 3)
+ {
+ hex_iterator hex = begin_hex(),
+ endh = end_hex();
+ std::vector<bool>::const_iterator i = v.begin();
+ for (; hex!=endh; ++hex, ++i)
+ if (*i == true)
+ set_user_flag(hex);
+ else
+ clear_user_flag(hex);
+
+ Assert (i == v.end(), ExcInternalError());
+ }
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_indices (std::vector<unsigned int> &v) const
+{
+ // clear vector and append all the
+ // stuff later on
+ v.clear ();
+
+ std::vector<unsigned int> tmp;
+
+ save_user_indices_line (tmp);
+ v.insert (v.end(), tmp.begin(), tmp.end());
+
+ if (dim >= 2)
+ {
+ save_user_indices_quad (tmp);
+ v.insert (v.end(), tmp.begin(), tmp.end());
+ }
+
+ if (dim >= 3)
+ {
+ save_user_indices_hex (tmp);
+ v.insert (v.end(), tmp.begin(), tmp.end());
+ }
+
+ if (dim >= 4)
+ Assert (false, ExcNotImplemented());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_indices (const std::vector<unsigned int> &v)
+{
+ Assert (v.size() == n_lines()+n_quads()+n_hexs(), ExcInternalError());
+ std::vector<unsigned int> tmp;
+
+ // first extract the indices
+ // belonging to lines
+ tmp.insert (tmp.end(),
+ v.begin(), v.begin()+n_lines());
+ // and set the lines
+ load_user_indices_line (tmp);
+
+ if (dim >= 2)
+ {
+ tmp.clear ();
+ tmp.insert (tmp.end(),
+ v.begin()+n_lines(), v.begin()+n_lines()+n_quads());
+ load_user_indices_quad (tmp);
+ }
+
+ if (dim >= 3)
+ {
+ tmp.clear ();
+ tmp.insert (tmp.end(),
+ v.begin()+n_lines()+n_quads(), v.begin()+n_lines()+n_quads()+n_hexs());
+ load_user_indices_hex (tmp);
+ }
+
+ if (dim >= 4)
+ Assert (false, ExcNotImplemented());
+}
+
+
+
+namespace
+{
+ template <typename Iterator>
+ unsigned int get_user_index (const Iterator &i)
+ {
+ return i->user_index();
+ }
+
+
+
+ template <int structdim, int dim, int spacedim>
+ unsigned int get_user_index (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &)
+ {
+ Assert (false, ExcInternalError());
+ return numbers::invalid_unsigned_int;
+ }
+
+
+
+ template <typename Iterator>
+ void set_user_index (const Iterator &i,
+ const unsigned int x)
+ {
+ i->set_user_index(x);
+ }
+
+
+
+ template <int structdim, int dim, int spacedim>
+ void set_user_index (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &,
+ const unsigned int)
+ {
+ Assert (false, ExcInternalError());
+ }
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_indices_line (std::vector<unsigned int> &v) const
+{
+ v.resize (n_lines(), 0);
+ std::vector<unsigned int>::iterator i = v.begin();
+ line_iterator line = begin_line(),
+ endl = end_line();
+ for (; line!=endl; ++line, ++i)
+ *i = line->user_index();
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_indices_line (const std::vector<unsigned int> &v)
+{
+ Assert (v.size() == n_lines(), ExcGridReadError());
+
+ line_iterator line = begin_line(),
+ endl = end_line();
+ std::vector<unsigned int>::const_iterator i = v.begin();
+ for (; line!=endl; ++line, ++i)
+ line->set_user_index(*i);
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_indices_quad (std::vector<unsigned int> &v) const
+{
+ v.resize (n_quads(), 0);
+
+ if (dim >= 2)
+ {
+ std::vector<unsigned int>::iterator i = v.begin();
+ quad_iterator quad = begin_quad(),
+ endq = end_quad();
+ for (; quad!=endq; ++quad, ++i)
+ *i = get_user_index(quad);
+ }
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_indices_quad (const std::vector<unsigned int> &v)
+{
+ Assert (v.size() == n_quads(), ExcGridReadError());
+
+ if (dim >= 2)
+ {
+ quad_iterator quad = begin_quad(),
+ endq = end_quad();
+ std::vector<unsigned int>::const_iterator i = v.begin();
+ for (; quad!=endq; ++quad, ++i)
+ set_user_index(quad, *i);
+ }
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_indices_hex (std::vector<unsigned int> &v) const
+{
+ v.resize (n_hexs(), 0);
+
+ if (dim >= 3)
+ {
+ std::vector<unsigned int>::iterator i = v.begin();
+ hex_iterator hex = begin_hex(),
+ endh = end_hex();
+ for (; hex!=endh; ++hex, ++i)
+ *i = get_user_index(hex);
+ }
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_indices_hex (const std::vector<unsigned int> &v)
+{
+ Assert (v.size() == n_hexs(), ExcGridReadError());
+
+ if (dim >= 3)
+ {
+ hex_iterator hex = begin_hex(),
+ endh = end_hex();
+ std::vector<unsigned int>::const_iterator i = v.begin();
+ for (; hex!=endh; ++hex, ++i)
+ set_user_index(hex, *i);
+ }
+}
+
+
+
+//---------------- user pointers ----------------------------------------//
+
+
+namespace
+{
+ template <typename Iterator>
+ void * get_user_pointer (const Iterator &i)
+ {
+ return i->user_pointer();
+ }
+
+
+
+ template <int structdim, int dim, int spacedim>
+ void * get_user_pointer (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &)
+ {
+ Assert (false, ExcInternalError());
+ return 0;
+ }
+
+
+
+ template <typename Iterator>
+ void set_user_pointer (const Iterator &i,
+ void * x)
+ {
+ i->set_user_pointer(x);
+ }
+
+
+
+ template <int structdim, int dim, int spacedim>
+ void set_user_pointer (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &,
+ void *)
+ {
+ Assert (false, ExcInternalError());
+ }
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_pointers (std::vector<void *> &v) const
+{
+ // clear vector and append all the
+ // stuff later on
+ v.clear ();
+
+ std::vector<void *> tmp;
+
+ save_user_pointers_line (tmp);
+ v.insert (v.end(), tmp.begin(), tmp.end());
+
+ if (dim >= 2)
+ {
+ save_user_pointers_quad (tmp);
+ v.insert (v.end(), tmp.begin(), tmp.end());
+ }
+
+ if (dim >= 3)
+ {
+ save_user_pointers_hex (tmp);
+ v.insert (v.end(), tmp.begin(), tmp.end());
+ }
+
+ if (dim >= 4)
+ Assert (false, ExcNotImplemented());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_pointers (const std::vector<void *> &v)
+{
+ Assert (v.size() == n_lines()+n_quads()+n_hexs(), ExcInternalError());
+ std::vector<void *> tmp;
+
+ // first extract the pointers
+ // belonging to lines
+ tmp.insert (tmp.end(),
+ v.begin(), v.begin()+n_lines());
+ // and set the lines
+ load_user_pointers_line (tmp);
+
+ if (dim >= 2)
+ {
+ tmp.clear ();
+ tmp.insert (tmp.end(),
+ v.begin()+n_lines(), v.begin()+n_lines()+n_quads());
+ load_user_pointers_quad (tmp);
+ }
+
+ if (dim >= 3)
+ {
+ tmp.clear ();
+ tmp.insert (tmp.end(),
+ v.begin()+n_lines()+n_quads(), v.begin()+n_lines()+n_quads()+n_hexs());
+ load_user_pointers_hex (tmp);
+ }
+
+ if (dim >= 4)
+ Assert (false, ExcNotImplemented());
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_pointers_line (std::vector<void *> &v) const
+{
+ v.resize (n_lines(), 0);
+ std::vector<void *>::iterator i = v.begin();
+ line_iterator line = begin_line(),
+ endl = end_line();
+ for (; line!=endl; ++line, ++i)
+ *i = line->user_pointer();
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_pointers_line (const std::vector<void *> &v)
+{
+ Assert (v.size() == n_lines(), ExcGridReadError());
+
+ line_iterator line = begin_line(),
+ endl = end_line();
+ std::vector<void *>::const_iterator i = v.begin();
+ for (; line!=endl; ++line, ++i)
+ line->set_user_pointer(*i);
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_pointers_quad (std::vector<void *> &v) const
+{
+ v.resize (n_quads(), 0);
+
+ if (dim >= 2)
+ {
+ std::vector<void *>::iterator i = v.begin();
+ quad_iterator quad = begin_quad(),
+ endq = end_quad();
+ for (; quad!=endq; ++quad, ++i)
+ *i = get_user_pointer(quad);
+ }
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_pointers_quad (const std::vector<void *> &v)
+{
+ Assert (v.size() == n_quads(), ExcGridReadError());
+
+ if (dim >= 2)
+ {
+ quad_iterator quad = begin_quad(),
+ endq = end_quad();
+ std::vector<void *>::const_iterator i = v.begin();
+ for (; quad!=endq; ++quad, ++i)
+ set_user_pointer(quad, *i);
+ }
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::save_user_pointers_hex (std::vector<void *> &v) const
+{
+ v.resize (n_hexs(), 0);
+
+ if (dim >= 3)
+ {
+ std::vector<void *>::iterator i = v.begin();
+ hex_iterator hex = begin_hex(),
+ endh = end_hex();
+ for (; hex!=endh; ++hex, ++i)
+ *i = get_user_pointer(hex);
+ }
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::load_user_pointers_hex (const std::vector<void *> &v)
+{
+ Assert (v.size() == n_hexs(), ExcGridReadError());
+
+ if (dim >= 3)
+ {
+ hex_iterator hex = begin_hex(),
+ endh = end_hex();
+ std::vector<void *>::const_iterator i = v.begin();
+ for (; hex!=endh; ++hex, ++i)
+ set_user_pointer(hex, *i);
+ }
+}
+
+
+
+/*------------------------ Cell iterator functions ------------------------*/
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_cell_iterator
+Triangulation<dim,spacedim>::begin_raw (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ return begin_raw_line (level);
+ case 2:
+ return begin_raw_quad (level);
+ case 3:
+ return begin_raw_hex (level);
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_cell_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::cell_iterator
+Triangulation<dim,spacedim>::begin (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ return begin_line (level);
+ case 2:
+ return begin_quad (level);
+ case 3:
+ return begin_hex (level);
+ default:
+ Assert (false, ExcImpossibleInDim(dim));
+ return cell_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::active_cell_iterator
+Triangulation<dim,spacedim>::begin_active (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ return begin_active_line (level);
+ case 2:
+ return begin_active_quad (level);
+ case 3:
+ return begin_active_hex (level);
+ default:
+ Assert (false, ExcNotImplemented());
+ return active_cell_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_cell_iterator
+Triangulation<dim,spacedim>::last_raw () const
+{
+ switch (dim)
+ {
+ case 1:
+ return last_raw_line ();
+ case 2:
+ return last_raw_quad ();
+ case 3:
+ return last_raw_hex ();
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_cell_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_cell_iterator
+Triangulation<dim,spacedim>::last_raw (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ return last_raw_line (level);
+ case 2:
+ return last_raw_quad (level);
+ case 3:
+ return last_raw_hex (level);
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_cell_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::cell_iterator
+Triangulation<dim,spacedim>::last () const
+{
+ switch (dim)
+ {
+ case 1:
+ return last_line ();
+ case 2:
+ return last_quad ();
+ case 3:
+ return last_hex ();
+ default:
+ Assert (false, ExcNotImplemented());
+ return cell_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::cell_iterator
+Triangulation<dim,spacedim>::last (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ return last_line (level);
+ case 2:
+ return last_quad (level);
+ case 3:
+ return last_hex (level);
+ default:
+ Assert (false, ExcNotImplemented());
+ return cell_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::active_cell_iterator
+Triangulation<dim,spacedim>::last_active () const
+{
+ switch (dim)
+ {
+ case 1:
+ return last_active_line ();
+ case 2:
+ return last_active_quad ();
+ case 3:
+ return last_active_hex ();
+ default:
+ Assert (false, ExcNotImplemented());
+ return active_cell_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::active_cell_iterator
+Triangulation<dim,spacedim>::last_active (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ return last_active_line (level);
+ case 2:
+ return last_active_quad (level);
+ case 3:
+ return last_active_hex (level);
+ default:
+ Assert (false, ExcNotImplemented());
+ return active_cell_iterator();
+ }
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_cell_iterator
+Triangulation<dim,spacedim>::end () const
+{
+ switch (dim)
+ {
+ case 1:
+ return end_line();
+ case 2:
+ return end_quad();
+ case 3:
+ return end_hex();
+ default:
+ Assert (false, ExcImpossibleInDim(dim));
+ return raw_cell_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_cell_iterator
+Triangulation<dim, spacedim>::end_raw (const unsigned int level) const
+{
+ return (level == levels.size()-1 ?
+ end() :
+ begin_raw (level+1));
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::cell_iterator
+Triangulation<dim, spacedim>::end (const unsigned int level) const
+{
+ return (level == levels.size()-1 ?
+ cell_iterator(end()) :
+ begin (level+1));
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_cell_iterator
+Triangulation<dim, spacedim>::end_active (const unsigned int level) const
+{
+ return (level == levels.size()-1 ?
+ active_cell_iterator(end()) :
+ begin_active (level+1));
+}
+
+
+/*------------------------ Face iterator functions ------------------------*/
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_face_iterator
+Triangulation<dim,spacedim>::begin_raw_face () const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (false, ExcImpossibleInDim(1));
+ return raw_face_iterator();
+ case 2:
+ return begin_raw_line ();
+ case 3:
+ return begin_raw_quad ();
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_face_iterator ();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::face_iterator
+Triangulation<dim,spacedim>::begin_face () const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (false, ExcImpossibleInDim(1));
+ return raw_face_iterator();
+ case 2:
+ return begin_line ();
+ case 3:
+ return begin_quad ();
+ default:
+ Assert (false, ExcNotImplemented());
+ return face_iterator ();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::active_face_iterator
+Triangulation<dim,spacedim>::begin_active_face () const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (false, ExcImpossibleInDim(1));
+ return raw_face_iterator();
+ case 2:
+ return begin_active_line ();
+ case 3:
+ return begin_active_quad ();
+ default:
+ Assert (false, ExcNotImplemented());
+ return active_face_iterator ();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_face_iterator
+Triangulation<dim, spacedim>::end_raw_face () const
+{
+ return end_face();
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_face_iterator
+Triangulation<dim,spacedim>::end_face () const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (false, ExcImpossibleInDim(1));
+ return raw_face_iterator();
+ case 2:
+ return end_line ();
+ case 3:
+ return end_quad ();
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_face_iterator ();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_face_iterator
+Triangulation<dim, spacedim>::end_active_face () const
+{
+ return active_face_iterator(end_face());
+}
+
+
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_face_iterator
+Triangulation<dim,spacedim>::last_raw_face () const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (false, ExcImpossibleInDim(1));
+ return raw_face_iterator();
+ case 2:
+ return last_raw_line ();
+ case 3:
+ return last_raw_quad ();
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_face_iterator ();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::face_iterator
+Triangulation<dim,spacedim>::last_face () const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (false, ExcImpossibleInDim(1));
+ return raw_face_iterator();
+ case 2:
+ return last_line ();
+ case 3:
+ return last_quad ();
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_face_iterator ();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::active_face_iterator
+Triangulation<dim,spacedim>::last_active_face () const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (false, ExcImpossibleInDim(1));
+ return raw_face_iterator();
+ case 2:
+ return last_active_line ();
+ case 3:
+ return last_active_quad ();
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_face_iterator ();
+ }
+}
+
+
+/*------------------------ Line iterator functions ------------------------*/
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_line_iterator
+Triangulation<dim, spacedim>::begin_raw_line (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (level<levels.size(), ExcInvalidLevel(level));
+
+ if (levels[level]->cells.cells.size() == 0)
+ return end_line ();
+
+ return raw_line_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
+ level,
+ 0);
+
+ default:
+ Assert (level == 0, ExcFacesHaveNoLevel());
+ return raw_line_iterator (const_cast<Triangulation<dim, spacedim>*>(this),
+ 0,
+ 0);
+ }
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::line_iterator
+Triangulation<dim, spacedim>::begin_line (const unsigned int level) const
+{
+ // level is checked in begin_raw
+ raw_line_iterator ri = begin_raw_line (level);
+ if (ri.state() != IteratorState::valid)
+ return ri;
+ while (ri->used() == false)
+ if ((++ri).state() != IteratorState::valid)
+ return ri;
+ return ri;
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_line_iterator
+Triangulation<dim, spacedim>::begin_active_line (const unsigned int level) const
+{
+ // level is checked in begin_raw
+ line_iterator i = begin_line (level);
+ if (i.state() != IteratorState::valid)
+ return i;
+ while (i->has_children())
+ if ((++i).state() != IteratorState::valid)
+ return i;
+ return i;
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_line_iterator
+Triangulation<dim, spacedim>::end_line () const
+{
+ return raw_line_iterator (const_cast<Triangulation<dim, spacedim>*>(this),
+ -1,
+ -1);
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_line_iterator
+Triangulation<dim, spacedim>::last_raw_line (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (level<levels.size(), ExcInvalidLevel(level));
+ Assert (levels[level]->cells.cells.size() != 0,
+ ExcEmptyLevel (level));
+
+ return raw_line_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
+ level,
+ levels[level]->cells.cells.size()-1);
+
+ default:
+ Assert (level == 0, ExcFacesHaveNoLevel());
+ return raw_line_iterator (const_cast<Triangulation<dim, spacedim>*>(this),
+ 0,
+ n_raw_lines()-1);
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_line_iterator
+Triangulation<dim, spacedim>::last_raw_line () const
+{
+ if (dim == 1)
+ return last_raw_line (levels.size()-1);
+ else
+ return last_raw_line (0);
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::line_iterator
+Triangulation<dim, spacedim>::last_line (const unsigned int level) const
+{
+ // level is checked in last_raw
+ raw_line_iterator ri = last_raw_line(level);
+ if (ri->used()==true)
+ return ri;
+ while ((--ri).state() == IteratorState::valid)
+ if (ri->used()==true)
+ return ri;
+ return ri;
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::line_iterator
+Triangulation<dim, spacedim>::last_line () const
+{
+ if (dim == 1)
+ return last_line (levels.size()-1);
+ else
+ return last_line (0);
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_line_iterator
+Triangulation<dim, spacedim>::last_active_line (const unsigned int level) const
+{
+ // level is checked in last_raw
+ line_iterator i = last_line(level);
+ if (i->has_children()==false)
+ return i;
+ while ((--i).state() == IteratorState::valid)
+ if (i->has_children()==false)
+ return i;
+ return i;
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_line_iterator
+Triangulation<dim, spacedim>::last_active_line () const
+{
+ if (dim == 1)
+ return last_active_line (levels.size()-1);
+ else
+ return last_active_line (0);
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_line_iterator
+Triangulation<dim, spacedim>::end_raw_line (const unsigned int level) const
+{
+ Assert (dim == 1 || level == 0, ExcFacesHaveNoLevel());
+ if (dim == 1)
+ return (level == levels.size()-1 ?
+ end_line() :
+ begin_raw_line (level+1));
+ else
+ return end_line();
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::line_iterator
+Triangulation<dim, spacedim>::end_line (const unsigned int level) const
+{
+ Assert (dim == 1 || level == 0, ExcFacesHaveNoLevel());
+ if (dim == 1)
+ return (level == levels.size()-1 ?
+ line_iterator(end_line()) :
+ begin_line (level+1));
+ else
+ return line_iterator(end_line());
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_line_iterator
+Triangulation<dim, spacedim>::end_active_line (const unsigned int level) const
+{
+ Assert (dim == 1 || level == 0, ExcFacesHaveNoLevel());
+ if (dim == 1)
+ return (level == levels.size()-1 ?
+ active_line_iterator(end_line()) :
+ begin_active_line (level+1));
+ else
+ return active_line_iterator(end_line());
+}
+
+
+
+/*------------------------ Quad iterator functions ------------------------*/
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_quad_iterator
+Triangulation<dim,spacedim>::begin_raw_quad (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (false, ExcImpossibleInDim(1));
+ return raw_hex_iterator();
+ case 2:
+ {
+ Assert (level<levels.size(), ExcInvalidLevel(level));
+
+ if (levels[level]->cells.cells.size() == 0)
+ return end_quad();
+
+ return raw_quad_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
+ level,
+ 0);
+ }
+
+ case 3:
+ {
+ Assert (level == 0, ExcFacesHaveNoLevel());
+
+ return raw_quad_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
+ 0,
+ 0);
+ }
+
+
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_hex_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::quad_iterator
+Triangulation<dim,spacedim>::begin_quad (const unsigned int level) const
+{
+ // level is checked in begin_raw
+ raw_quad_iterator ri = begin_raw_quad (level);
+ if (ri.state() != IteratorState::valid)
+ return ri;
+ while (ri->used() == false)
+ if ((++ri).state() != IteratorState::valid)
+ return ri;
+ return ri;
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::active_quad_iterator
+Triangulation<dim,spacedim>::begin_active_quad (const unsigned int level) const
+{
+ // level is checked in begin_raw
+ quad_iterator i = begin_quad (level);
+ if (i.state() != IteratorState::valid)
+ return i;
+ while (i->has_children())
+ if ((++i).state() != IteratorState::valid)
+ return i;
+ return i;
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_quad_iterator
+Triangulation<dim, spacedim>::end_raw_quad (const unsigned int level) const
+{
+ Assert (dim == 2 || level == 0, ExcFacesHaveNoLevel());
+ if (dim == 2)
+ return (level == levels.size()-1 ?
+ end_quad() :
+ begin_raw_quad (level+1));
+ else
+ return end_quad();
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::quad_iterator
+Triangulation<dim, spacedim>::end_quad (const unsigned int level) const
+{
+ Assert (dim == 2 || level == 0, ExcFacesHaveNoLevel());
+ if (dim == 2)
+ return (level == levels.size()-1 ?
+ quad_iterator(end_quad()) :
+ begin_quad (level+1));
+ else
+ return quad_iterator(end_quad());
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_quad_iterator
+Triangulation<dim, spacedim>::end_active_quad (const unsigned int level) const
+{
+ Assert(dim == 2 || level == 0, ExcFacesHaveNoLevel());
+ if (dim == 2)
+ return (level == levels.size()-1 ?
+ active_quad_iterator(end_quad()) :
+ begin_active_quad (level+1));
+ else
+ return active_quad_iterator(end_quad());
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_quad_iterator
+Triangulation<dim,spacedim>::end_quad () const
+{
+ return raw_quad_iterator (const_cast<Triangulation<dim, spacedim>*>(this),
+ -1,
+ -1);
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_quad_iterator
+Triangulation<dim,spacedim>::last_raw_quad (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ Assert (false, ExcImpossibleInDim(1));
+ return raw_quad_iterator();
+ case 2:
+ Assert (level<levels.size(),
+ ExcInvalidLevel(level));
+ Assert (levels[level]->cells.cells.size() != 0,
+ ExcEmptyLevel (level));
+ return raw_quad_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
+ level,
+ levels[level]->cells.cells.size()-1);
+ case 3:
+ Assert (level == 0, ExcFacesHaveNoLevel());
+ return raw_quad_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
+ 0,
+ n_raw_quads()-1);
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_quad_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_quad_iterator
+Triangulation<dim,spacedim>::last_raw_quad () const
+{
+ if (dim == 2)
+ return last_raw_quad (levels.size()-1);
+ else
+ return last_raw_quad (0);
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::quad_iterator
+Triangulation<dim,spacedim>::last_quad (const unsigned int level) const
+{
+ // level is checked in last_raw
+ raw_quad_iterator ri = last_raw_quad(level);
+ if (ri->used()==true)
+ return ri;
+ while ((--ri).state() == IteratorState::valid)
+ if (ri->used()==true)
+ return ri;
+ return ri;
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::quad_iterator
+Triangulation<dim,spacedim>::last_quad () const
+{
+ if (dim == 2)
+ return last_quad (levels.size()-1);
+ else
+ return last_quad (0);
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::active_quad_iterator
+Triangulation<dim,spacedim>::last_active_quad (const unsigned int level) const
+{
+ // level is checked in last_raw
+ quad_iterator i = last_quad(level);
+ if (i->has_children()==false)
+ return i;
+ while ((--i).state() == IteratorState::valid)
+ if (i->has_children()==false)
+ return i;
+ return i;
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::active_quad_iterator
+Triangulation<dim,spacedim>::last_active_quad () const
+{
+ if (dim == 2)
+ return last_active_quad (levels.size()-1);
+ else
+ return last_active_quad (0);
+}
+
+
+/*------------------------ Hex iterator functions ------------------------*/
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::raw_hex_iterator
+Triangulation<dim,spacedim>::begin_raw_hex (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ case 2:
+ Assert (false, ExcImpossibleInDim(1));
+ return raw_hex_iterator();
+ case 3:
+ {
+ Assert (level<levels.size(), ExcInvalidLevel(level));
+
+ if (levels[level]->cells.cells.size() == 0)
+ return end_hex();
+
+ return raw_hex_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
+ level,
+ 0);
+ }
+
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_hex_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::hex_iterator
+Triangulation<dim,spacedim>::begin_hex (const unsigned int level) const
+{
+ // level is checked in begin_raw
+ raw_hex_iterator ri = begin_raw_hex (level);
+ if (ri.state() != IteratorState::valid)
+ return ri;
+ while (ri->used() == false)
+ if ((++ri).state() != IteratorState::valid)
+ return ri;
+ return ri;
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_hex_iterator
+Triangulation<dim, spacedim>::begin_active_hex (const unsigned int level) const
+{
+ // level is checked in begin_raw
+ hex_iterator i = begin_hex (level);
+ if (i.state() != IteratorState::valid)
+ return i;
+ while (i->has_children())
+ if ((++i).state() != IteratorState::valid)
+ return i;
+ return i;
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_hex_iterator
+Triangulation<dim, spacedim>::end_raw_hex (const unsigned int level) const
+{
+ return (level == levels.size()-1 ?
+ end_hex() :
+ begin_raw_hex (level+1));
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::hex_iterator
+Triangulation<dim, spacedim>::end_hex (const unsigned int level) const
+{
+ return (level == levels.size()-1 ?
+ hex_iterator(end_hex()) :
+ begin_hex (level+1));
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_hex_iterator
+Triangulation<dim, spacedim>::end_active_hex (const unsigned int level) const
+{
+ return (level == levels.size()-1 ?
+ active_hex_iterator(end_hex()) :
+ begin_active_hex (level+1));
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_hex_iterator
+Triangulation<dim, spacedim>::end_hex () const
+{
+ return raw_hex_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
+ -1,
+ -1);
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_hex_iterator
+Triangulation<dim, spacedim>::last_raw_hex (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ case 2:
+ Assert (false, ExcImpossibleInDim(dim));
+ return raw_hex_iterator();
+
+ case 3:
+ Assert (level<levels.size(),
+ ExcInvalidLevel(level));
+ Assert (levels[level]->cells.cells.size() != 0,
+ ExcEmptyLevel (level));
+
+ return raw_hex_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
+ level,
+ levels[level]->cells.cells.size()-1);
+ default:
+ Assert (false, ExcNotImplemented());
+ return raw_hex_iterator();
+ }
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::raw_hex_iterator
+Triangulation<dim, spacedim>::last_raw_hex () const
+{
+ return last_raw_hex (levels.size()-1);
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::hex_iterator
+Triangulation<dim, spacedim>::last_hex (const unsigned int level) const
+{
+ // level is checked in last_raw
+ raw_hex_iterator ri = last_raw_hex(level);
+ if (ri->used()==true)
+ return ri;
+ while ((--ri).state() == IteratorState::valid)
+ if (ri->used()==true)
+ return ri;
+ return ri;
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::hex_iterator
+Triangulation<dim, spacedim>::last_hex () const
+{
+ return last_hex (levels.size()-1);
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_hex_iterator
+Triangulation<dim, spacedim>::last_active_hex (const unsigned int level) const
+{
+ // level is checked in last_raw
+ hex_iterator i = last_hex(level);
+ if (i->has_children()==false)
+ return i;
+ while ((--i).state() == IteratorState::valid)
+ if (i->has_children()==false)
+ return i;
+ return i;
+}
+
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim, spacedim>::active_hex_iterator
+Triangulation<dim, spacedim>::last_active_hex () const
+{
+ return last_active_hex (levels.size()-1);
+}
+
+
+
+// -------------------------------- number of cells etc ---------------
+
+
+namespace internal
+{
+ namespace Triangulation
+ {
+ inline
+ unsigned int
+ n_cells (const internal::Triangulation::NumberCache<1> &c)
+ {
+ return c.n_lines;
+ }
+
+
+ inline
+ unsigned int
+ n_active_cells (const internal::Triangulation::NumberCache<1> &c)
+ {
+ return c.n_active_lines;
+ }
+
+
+ inline
+ unsigned int
+ n_cells (const internal::Triangulation::NumberCache<2> &c)
+ {
+ return c.n_quads;
+ }
+
+
+ inline
+ unsigned int
+ n_active_cells (const internal::Triangulation::NumberCache<2> &c)
+ {
+ return c.n_active_quads;
+ }
+
+
+ inline
+ unsigned int
+ n_cells (const internal::Triangulation::NumberCache<3> &c)
+ {
+ return c.n_hexes;
+ }
+
+
+ inline
+ unsigned int
+ n_active_cells (const internal::Triangulation::NumberCache<3> &c)
+ {
+ return c.n_active_hexes;
+ }
+ }
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_cells () const
+{
+ return internal::Triangulation::n_cells (number_cache);
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_active_cells () const
+{
+ return internal::Triangulation::n_active_cells (number_cache);
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_faces () const
+{
+ switch (dim)
+ {
+ case 1:
+ return 0;
+ case 2:
+ return n_lines();
+ case 3:
+ return n_quads();
+ default:
+ Assert (false, ExcNotImplemented());
+ }
+ return 0;
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_raw_faces () const
+{
+ switch (dim)
+ {
+ case 2:
+ return n_raw_lines();
+ case 3:
+ return n_raw_quads();
+ default:
+ Assert (false, ExcNotImplemented());
+ }
+ return 0;
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_active_faces () const
+{
+ switch (dim)
+ {
+ case 1:
+ return 0;
+ case 2:
+ return n_active_lines();
+ case 3:
+ return n_active_quads();
+ default:
+ Assert (false, ExcNotImplemented());
+ }
+ return 0;
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_raw_cells (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ return n_raw_lines(level);
+ case 2:
+ return n_raw_quads(level);
+ case 3:
+ return n_raw_hexs(level);
+ default:
+ Assert (false, ExcNotImplemented());
+ }
+ return 0;
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_cells (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ return n_lines(level);
+ case 2:
+ return n_quads(level);
+ case 3:
+ return n_hexs(level);
+ default:
+ Assert (false, ExcNotImplemented());
+ }
+ return 0;
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_active_cells (const unsigned int level) const
+{
+ switch (dim)
+ {
+ case 1:
+ return n_active_lines(level);
+ case 2:
+ return n_active_quads(level);
+ case 3:
+ return n_active_hexs(level);
+ default:
+ Assert (false, ExcNotImplemented());
+ }
+ return 0;
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_lines () const
+{
+ return number_cache.n_lines;
+}
+
+
+
+template <>
+unsigned int Triangulation<1,1>::n_raw_lines (const unsigned int level) const
+{
+ Assert(level < n_levels(), ExcIndexRange(level,0,n_levels()));
+ return levels[level]->cells.cells.size();
+}
+
+
+template <>
+unsigned int Triangulation<1,1>::n_raw_lines () const
+{
+ Assert(false, ExcNotImplemented());
+ return 0;
+}
+
+
+
+template <>
+unsigned int Triangulation<1,2>::n_raw_lines (const unsigned int level) const
+{
+ Assert(level < n_levels(), ExcIndexRange(level,0,n_levels()));
+ return levels[level]->cells.cells.size();
+}
+
+
+template <>
+unsigned int Triangulation<1,2>::n_raw_lines () const
+{
+ Assert(false, ExcNotImplemented());
+ return 0;
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_raw_lines (const unsigned int) const
+{
+ Assert(false, ExcFacesHaveNoLevel());
+ return 0;
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_raw_lines () const
+{
+ return faces->lines.cells.size();
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_lines (const unsigned int level) const
+{
+ Assert (level < number_cache.n_lines_level.size(),
+ ExcIndexRange (level, 0, number_cache.n_lines_level.size()));
+ Assert (dim == 1, ExcFacesHaveNoLevel());
+ return number_cache.n_lines_level[level];
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_active_lines () const
+{
+ return number_cache.n_active_lines;
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_active_lines (const unsigned int level) const
+{
+ Assert (level < number_cache.n_lines_level.size(),
+ ExcIndexRange (level, 0, number_cache.n_lines_level.size()));
+ Assert (dim == 1, ExcFacesHaveNoLevel());
+
+ return number_cache.n_active_lines_level[level];
+}
+
+
+template <>
+unsigned int Triangulation<1,1>::n_quads () const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,1>::n_quads (const unsigned int) const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,1>::n_raw_quads (const unsigned int) const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,1>::n_raw_hexs (const unsigned int) const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,1>::n_active_quads (const unsigned int) const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,1>::n_active_quads () const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,2>::n_quads () const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,2>::n_quads (const unsigned int) const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,2>::n_raw_quads (const unsigned int) const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,2>::n_raw_hexs (const unsigned int) const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,2>::n_active_quads (const unsigned int) const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<1,2>::n_active_quads () const
+{
+ return 0;
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_quads () const
+{
+ return number_cache.n_quads;
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_quads (const unsigned int level) const
+{
+ Assert (dim == 2, ExcFacesHaveNoLevel());
+ Assert (level < number_cache.n_quads_level.size(),
+ ExcIndexRange (level, 0, number_cache.n_quads_level.size()));
+ return number_cache.n_quads_level[level];
+}
+
+
+
+template <>
+unsigned int Triangulation<2,2>::n_raw_quads (const unsigned int level) const
+{
+ Assert(level < n_levels(), ExcIndexRange(level,0,n_levels()));
+ return levels[level]->cells.cells.size();
+}
+
+
+
+template <>
+unsigned int Triangulation<2,3>::n_raw_quads (const unsigned int level) const
+{
+ Assert(level < n_levels(), ExcIndexRange(level,0,n_levels()));
+ return levels[level]->cells.cells.size();
+}
+
+
+template <>
+unsigned int Triangulation<3,3>::n_raw_quads (const unsigned int) const
+{
+ Assert(false, ExcFacesHaveNoLevel());
+ return 0;
+}
+
+
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_raw_quads () const
+{
+ Assert (false, ExcNotImplemented());
+ return 0;
+}
+
+
+
+template <>
+unsigned int Triangulation<3,3>::n_raw_quads () const
+{
+ return faces->quads.cells.size();
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_active_quads () const
+{
+ return number_cache.n_active_quads;
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_active_quads (const unsigned int level) const
+{
+ Assert (level < number_cache.n_quads_level.size(),
+ ExcIndexRange (level, 0, number_cache.n_quads_level.size()));
+ Assert (dim == 2, ExcFacesHaveNoLevel());
+
+ return number_cache.n_active_quads_level[level];
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_hexs () const
+{
+ return 0;
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_hexs (const unsigned int) const
+{
+ return 0;
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_raw_hexs (const unsigned int) const
+{
+ return 0;
+}
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_active_hexs () const
+{
+ return 0;
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::n_active_hexs (const unsigned int) const
+{
+ return 0;
+}
+
+
+template <>
+unsigned int Triangulation<3,3>::n_hexs () const
+{
+ return number_cache.n_hexes;
+}
+
+
+
+template <>
+unsigned int Triangulation<3,3>::n_hexs (const unsigned int level) const
+{
+ Assert (level < number_cache.n_hexes_level.size(),
+ ExcIndexRange (level, 0, number_cache.n_hexes_level.size()));
+
+ return number_cache.n_hexes_level[level];
+}
+
+
+
+template <>
+unsigned int Triangulation<3,3>::n_raw_hexs (const unsigned int level) const
+{
+ Assert(level < n_levels(), ExcIndexRange(level,0,n_levels()));
+ return levels[level]->cells.cells.size();
+}
+
+
+template <>
+unsigned int Triangulation<3,3>::n_active_hexs () const
+{
+ return number_cache.n_active_hexes;
+}
+
+
+
+template <>
+unsigned int Triangulation<3,3>::n_active_hexs (const unsigned int level) const
+{
+ Assert (level < number_cache.n_hexes_level.size(),
+ ExcIndexRange (level, 0, number_cache.n_hexes_level.size()));
+
+ return number_cache.n_active_hexes_level[level];
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int
+Triangulation<dim, spacedim>::n_used_vertices () const
+{
+ return std::count_if (vertices_used.begin(), vertices_used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
+}
+
+
+
+template <int dim, int spacedim>
+const std::vector<bool> &
+Triangulation<dim, spacedim>::get_used_vertices () const
+{
+ return vertices_used;
+}
+
+
+
+
+template <>
+unsigned int Triangulation<1,1>::max_adjacent_cells () const
+{
+ return 2;
+}
+
+
+
+template <>
+unsigned int Triangulation<1,2>::max_adjacent_cells () const
+{
+ return 2;
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int Triangulation<dim, spacedim>::max_adjacent_cells () const
+{
+ cell_iterator cell = begin(0),
+ endc = (n_levels() > 1 ? begin(1) : cell_iterator(end()));
+ // store the largest index of the
+ // vertices used on level 0
+ unsigned int max_vertex_index = 0;
+ for (; cell!=endc; ++cell)
+ for (unsigned vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+ if (cell->vertex_index(vertex) > max_vertex_index)
+ max_vertex_index = cell->vertex_index(vertex);
+
+ // store the number of times a cell
+ // touches a vertex. An unsigned
+ // int should suffice, even for
+ // larger dimensions
+ std::vector<unsigned short int> usage_count (max_vertex_index+1, 0);
+ // touch a vertex's usage count
+ // everytime we find an adjacent
+ // element
+ for (cell=begin(); cell!=endc; ++cell)
+ for (unsigned vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+ ++usage_count[cell->vertex_index(vertex)];
+
+ return std::max (GeometryInfo<dim>::vertices_per_cell,
+ static_cast<unsigned int>(*std::max_element (usage_count.begin(),
+ usage_count.end())));
+}
+
+
+
+template <int dim, int spacedim>
+void
+Triangulation<dim, spacedim>::execute_coarsening_and_refinement ()
+{
+ prepare_coarsening_and_refinement ();
+
+ // verify a case with which we have had
+ // some difficulty in the past (see the
+ // deal.II/coarsening_* tests)
+ if (smooth_grid & limit_level_difference_at_vertices)
+ Assert (satisfies_level1_at_vertex_rule (*this) == true,
+ ExcInternalError());
+
+ // Inform RefinementListeners
+ // about beginning of refinement.
+ typename std::list<RefinementListener *>::iterator ref_listener =
+ refinement_listeners.begin (),
+ end_listener = refinement_listeners.end ();
+ for (; ref_listener != end_listener; ++ref_listener)
+ (*ref_listener)->pre_refinement_notification (*this);
+
+ execute_coarsening();
+
+ const DistortedCellList
+ cells_with_distorted_children = execute_refinement();
+
+ // verify a case with which we have had
+ // some difficulty in the past (see the
+ // deal.II/coarsening_* tests)
+ if (smooth_grid & limit_level_difference_at_vertices)
+ Assert (satisfies_level1_at_vertex_rule (*this) == true,
+ ExcInternalError());
+
+ // finally build up neighbor connectivity
+ // information
+ update_neighbors(*this);
+
+ // Inform RefinementListeners
+ // about end of refinement.
+ for (ref_listener = refinement_listeners.begin ();
+ ref_listener != end_listener; ++ref_listener)
+ (*ref_listener)->post_refinement_notification (*this);
+
+ AssertThrow (cells_with_distorted_children.distorted_cells.size() == 0,
+ cells_with_distorted_children);
+}
+
+
+template<int dim, int spacedim>
+void
+Triangulation<dim, spacedim>::clear_despite_subscriptions()
+{
+ // This is the former function
+ // clear without the assertion in
+ // the beginning.
+ for (unsigned int i=0; i<levels.size(); ++i)
+ delete levels[i];
+ levels.clear ();
+
+ delete faces;
+ faces = NULL;
+
+ vertices.clear ();
+ vertices_used.clear ();
+
+ for (unsigned int i=0; i<255; ++i)
+ boundary[i] = &straight_boundary;
+
+ number_cache = internal::Triangulation::NumberCache<dim>();
+}
+
+
+template <int dim, int spacedim>
+typename Triangulation<dim,spacedim>::DistortedCellList
+Triangulation<dim,spacedim>::execute_refinement ()
+{
+ const DistortedCellList
+ cells_with_distorted_children
+ =
+ internal::Triangulation::Implementation::
+ execute_refinement (*this,check_for_distorted_cells);
+
+
+
+ // re-compute number of lines
+ compute_number_cache (*this, levels.size(), number_cache);
+
+#ifdef DEBUG
+ for (unsigned int level=0; level<levels.size(); ++level)
+ levels[level]->cells.monitor_memory (dim);
+
+ // check whether really all
+ // refinement flags are reset (also
+ // of previously non-active cells
+ // which we may not have
+ // touched. If the refinement flag
+ // of a non-active cell is set,
+ // something went wrong since the
+ // cell-accessors should have
+ // caught this)
+ cell_iterator cell = begin(),
+ endc = end();
+ while (cell != endc)
+ Assert (!(cell++)->refine_flag_set(), ExcInternalError ());
+#endif
+
+ return cells_with_distorted_children;
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::execute_coarsening ()
+{
+ // create a vector counting for each line how
+ // many cells contain this line. in 3D, this
+ // is used later on to decide which lines can
+ // be deleted after coarsening a cell. in
+ // other dimensions it will be ignored
+ std::vector<unsigned int> line_cell_count = count_cells_bounded_by_line (*this);
+ std::vector<unsigned int> quad_cell_count = count_cells_bounded_by_quad (*this);
+
+ // loop over all cells. Flag all
+ // cells of which all children are
+ // flagged for
+ // coarsening and delete the childrens'
+ // flags. In effect, only those
+ // cells are flagged of which originally
+ // all children were flagged and for which
+ // all children are on the same refinement
+ // level. For flagging, the user flags are
+ // used, to avoid confusion and because
+ // non-active cells can't be flagged for
+ // coarsening. Note that because of the
+ // effects of @p{fix_coarsen_flags}, of a
+ // cell either all or no children must
+ // be flagged for coarsening, so it is
+ // ok to only check the first child
+ clear_user_flags ();
+
+ cell_iterator cell = begin(),
+ endc = end();
+ for (; cell!=endc; ++cell)
+ if (!cell->active())
+ if (cell->child(0)->coarsen_flag_set())
+ {
+ cell->set_user_flag();
+ for (unsigned int child=0; child<cell->n_children(); ++child)
+ {
+ Assert (cell->child(child)->coarsen_flag_set(),
+ ExcInternalError());
+ cell->child(child)->clear_coarsen_flag();
+ }
+ }
+
+
+ // now do the actual coarsening
+ // step. Since the loop goes over
+ // used cells we only need not
+ // worry about deleting some cells
+ // since the ++operator will then
+ // just hop over them if we should
+ // hit one. Do the loop in the
+ // reverse way since we may only
+ // delete some cells if their
+ // neighbors have already been
+ // deleted (if the latter are on a
+ // higher level for example)
+ //
+ // if there is only one level,
+ // there can not be anything to do
+ if (levels.size() >= 2)
+ for (cell = last(levels.size()-2); cell!=endc; --cell)
+ if (cell->user_flag_set())
+ // use a separate function,
+ // since this is dimension
+ // specific
+ internal::Triangulation::Implementation::delete_children (*this, cell,
+ line_cell_count, quad_cell_count);
+
+ // re-compute number of lines and
+ // quads
+ compute_number_cache (*this, levels.size(), number_cache);
+
+ // in principle no user flags
+ // should be
+ // set any more at this point
+#if DEBUG
+ for (cell=begin(); cell!=endc; ++cell)
+ Assert (cell->user_flag_set() == false, ExcInternalError());
+#endif
+}
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::fix_coarsen_flags ()
+{
+ // copy a piece of code from
+ // prepare_coarsening_and_refinement that
+ // ensures that the level difference at
+ // vertices is limited if so desired. we
+ // need this code here since at least in 1d
+ // we don't call the dimension-independent
+ // version of
+ // prepare_coarsening_and_refinement
+ // function. in 2d and 3d, having this hunk
+ // here makes our lives a bit easier as
+ // well as it takes care of these cases
+ // earlier than it would otherwise happen.
+ //
+ // the main difference to the code
+ // in p_c_and_r is that here we
+ // absolutely have to make sure
+ // that we get things right,
+ // i.e. that in particular we set
+ // flags right if
+ // limit_level_difference_at_vertices
+ // is set. to do so we iterate
+ // until the flags don't change any
+ // more
+ std::vector<bool> previous_coarsen_flags (n_active_cells());
+ save_coarsen_flags (previous_coarsen_flags);
+
+ std::vector<int> vertex_level (vertices.size(), 0);
+
+ bool continue_iterating = true;
+
+ do
+ {
+ if (smooth_grid & limit_level_difference_at_vertices)
+ {
+ Assert(!anisotropic_refinement,
+ ExcMessage("In case of anisotropic refinement the "
+ "limit_level_difference_at_vertices flag for "
+ "mesh smoothing must not be set!"));
+
+ // store highest level one
+ // of the cells adjacent to
+ // a vertex belongs to
+ std::fill (vertex_level.begin(), vertex_level.end(), 0);
+ active_cell_iterator cell = begin_active(),
+ endc = end();
+ for (; cell!=endc; ++cell)
+ {
+ if (cell->refine_flag_set())
+ 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())
+ 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 try to
+ // correct this by
+ // iterating over the
+ // entire process until
+ // we are converged
+ Assert (cell->coarsen_flag_set(), ExcInternalError());
+ 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
+ // update the vertex levels on the
+ // adjacent vertices and maybe
+ // already flag additional cells in
+ // this loop
+ //
+ // note that not only may we have
+ // to add additional refinement
+ // flags, but we will also have to
+ // remove coarsening flags on cells
+ // adjacent to vertices that will
+ // see refinement
+ for (cell=last_active(); cell != endc; --cell)
+ 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
+ // cells of which all children are
+ // flagged for coarsening and
+ // delete the childrens'
+ // flags. Also delete all flags of
+ // cells for which not all children
+ // of a cell are flagged. In
+ // effect, only those cells are
+ // flagged of which originally all
+ // children were flagged and for
+ // which all children are on the
+ // same refinement level. For
+ // flagging, the user flags are
+ // used, to avoid confusion and
+ // because non-active cells can't
+ // be flagged for coarsening
+ //
+ // In effect, all coarsen flags are
+ // turned into user flags of the
+ // mother cell if coarsening is
+ // possible or deleted
+ // otherwise.
+ clear_user_flags ();
+ // Coarsen flags of
+ // cells with no mother cell,
+ // i.e. on the coarsest level are
+ // deleted explicitly.
+ active_cell_iterator acell = begin_active(0),
+ end_ac = end_active(0);
+ for (; acell!=end_ac; ++acell)
+ acell->clear_coarsen_flag();
+
+ cell_iterator cell = begin(),
+ endc = end();
+ for (; cell!=endc; ++cell)
+ {
+ // nothing to do if we are
+ // already on the finest level
+ if (cell->active())
+ continue;
+
+ const unsigned int n_children=cell->n_children();
+ unsigned int flagged_children=0;
+ for (unsigned int child=0; child<n_children; ++child)
+ if (cell->child(child)->active() &&
+ cell->child(child)->coarsen_flag_set())
+ {
+ ++flagged_children;
+ // clear flag since we
+ // don't need it anymore
+ cell->child(child)->clear_coarsen_flag();
+ }
+
+ // flag this cell for
+ // coarsening if all children
+ // were flagged
+ if (flagged_children == n_children)
+ cell->set_user_flag();
+ }
+
+ // in principle no coarsen flags
+ // should be set any more at this
+ // point
+#if DEBUG
+ for (cell=begin(); cell!=endc; ++cell)
+ Assert (cell->coarsen_flag_set() == false, ExcInternalError());
+#endif
+
+ // now loop over all cells which have the
+ // user flag set. their children were
+ // flagged for coarsening. set the coarsen
+ // flag again if we are sure that none of
+ // the neighbors of these children are
+ // refined, or will be refined, since then
+ // we would get a two-level jump in
+ // refinement. on the other hand, if one of
+ // the children's neighbors has their user
+ // flag set, then we know that its children
+ // will go away by coarsening, and we will
+ // be ok.
+ //
+ // note on the other hand that we do allow
+ // level-2 jumps in refinement between
+ // neighbors in 1d, so this whole procedure
+ // is only necessary if we are not in 1d
+ //
+ // since we remove some coarsening/user
+ // flags in the process, we have to work
+ // from the finest level to the coarsest
+ // one, since we occasionally inspect user
+ // flags of cells on finer levels and need
+ // to be sure that these flags are final
+ for (cell=last(); cell!=endc; --cell)
+ if (cell->user_flag_set())
+ // if allowed: flag the
+ // children for coarsening
+ if (internal::Triangulation::Implementation::template coarsening_allowed<dim,spacedim>(cell))
+ for (unsigned int c=0; c<cell->n_children(); ++c)
+ {
+ Assert (cell->child(c)->refine_flag_set()==false,
+ ExcInternalError());
+
+ cell->child(c)->set_coarsen_flag();
+ }
+
+ // clear all user flags again, now that we
+ // don't need them any more
+ clear_user_flags ();
+
+
+ // now see if anything has
+ // changed in the last
+ // iteration of this function
+ std::vector<bool> current_coarsen_flags (n_active_cells());
+ save_coarsen_flags (current_coarsen_flags);
+
+ continue_iterating = (current_coarsen_flags != previous_coarsen_flags);
+ previous_coarsen_flags = current_coarsen_flags;
+ }
+ while (continue_iterating == true);
+}
+
+
+
+template <>
+bool Triangulation<1,1>::prepare_coarsening_and_refinement ()
+{
+ // save the flags to determine
+ // whether something was changed in
+ // the course of this function
+ std::vector<bool> flags_before;
+ save_coarsen_flags (flags_before);
+
+ // do nothing in 1d, except setting
+ // the coarsening flags correctly
+ fix_coarsen_flags ();
+
+ std::vector<bool> flags_after;
+ save_coarsen_flags (flags_after);
+
+ return (flags_before != flags_after);
+}
+
+
+template <>
+bool Triangulation<1,2>::prepare_coarsening_and_refinement ()
+{
+ // save the flags to determine
+ // whether something was changed in
+ // the course of this function
+ std::vector<bool> flags_before;
+ save_coarsen_flags (flags_before);
+
+ // do nothing in 1d, except setting
+ // the coarsening flags correctly
+ fix_coarsen_flags ();
+
+ std::vector<bool> flags_after;
+ save_coarsen_flags (flags_after);
+
+ return (flags_before != flags_after);
+}
+
+
+
+namespace
+{
+
+ // check if the given @param cell marked
+ // for coarsening would produce an
+ // unrefined island. To break up long
+ // chains of these cells we recursively
+ // check our neighbors in case we change
+ // this cell. This reduces the number of
+ // outer iterations dramatically.
+ template <int dim, int spacedim>
+ void
+ possibly_do_not_produce_unrefined_islands(
+ const typename Triangulation<dim,spacedim>::cell_iterator &cell)
+ {
+ Assert (cell->has_children(), ExcInternalError());
+
+ unsigned int n_neighbors=0;
+ // count all neighbors
+ // that will be refined
+ // along the face of our
+ // cell after the next
+ // step
+ unsigned int count=0;
+ for (unsigned int n=0; n<GeometryInfo<dim>::faces_per_cell; ++n)
+ {
+ const typename Triangulation<dim,spacedim>::cell_iterator neighbor = cell->neighbor(n);
+ if (neighbor.state() == IteratorState::valid)
+ {
+ ++n_neighbors;
+ if (face_will_be_refined_by_neighbor(cell,n))
+ ++count;
+ }
+ }
+ // clear coarsen flags if
+ // either all existing
+ // neighbors will be
+ // refined or all but one
+ // will be and the cell
+ // is in the interior of
+ // the domain
+ if (count==n_neighbors ||
+ (count>=n_neighbors-1 &&
+ n_neighbors == GeometryInfo<dim>::faces_per_cell) )
+ {
+ for (unsigned int c=0; c<cell->n_children(); ++c)
+ cell->child(c)->clear_coarsen_flag();
+
+ for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+ if (!cell->at_boundary(face)
+ &&
+ ( !cell->neighbor(face)->active() )
+ && (cell_will_be_coarsened(cell->neighbor(face))) )
+ possibly_do_not_produce_unrefined_islands<dim,spacedim>( cell->neighbor(face) );
+ }
+ }
+
+
+ // see if the current cell needs to
+ // be refined to avoid unrefined
+ // islands.
+ //
+ // there are sometimes chains of
+ // cells that induce refinement of
+ // each other. to avoid running the
+ // loop in
+ // prepare_coarsening_and_refinement
+ // over and over again for each one
+ // of them, at least for the
+ // isotropic refinement case we
+ // seek to flag neighboring
+ // elements as well as
+ // necessary. this takes care of
+ // (slightly pathological) cases
+ // like deal.II/mesh_smoothing_03
+ template <int dim, int spacedim>
+ void
+ possibly_refine_unrefined_island
+ (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
+ const bool allow_anisotropic_smoothing)
+ {
+ Assert (cell->has_children() == false, ExcInternalError());
+ Assert (cell->refine_flag_set() == false, ExcInternalError());
+
+
+ // now we provide two
+ // algorithms. the first one is
+ // the standard one, coming from
+ // the time, where only isotropic
+ // refinement was possible. it
+ // simply counts the neighbors
+ // that are or will be refined
+ // and compares to the number of
+ // other ones. the second one
+ // does this check independently
+ // for each direction: if all
+ // neighbors in one direction
+ // (normally two, at the boundary
+ // only one) are refined, the
+ // current cell is flagged to be
+ // refined in an according
+ // direction.
+
+ if (allow_anisotropic_smoothing == false)
+ {
+ // use first algorithm
+ unsigned int refined_neighbors = 0,
+ unrefined_neighbors = 0;
+ for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+ if (!cell->at_boundary(face))
+ {
+ if (face_will_be_refined_by_neighbor(cell,face))
+ ++refined_neighbors;
+ else
+ ++unrefined_neighbors;
+ }
+
+ if (unrefined_neighbors < refined_neighbors)
+ {
+ cell->clear_coarsen_flag();
+ cell->set_refine_flag ();
+
+ // ok, so now we have
+ // flagged this cell. if
+ // we know that there
+ // were any unrefined
+ // neighbors at all, see
+ // if any of those will
+ // have to be refined as
+ // well
+ if (unrefined_neighbors > 0)
+ for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+ if (!cell->at_boundary(face)
+ &&
+ (face_will_be_refined_by_neighbor(cell,face) == false)
+ &&
+ (cell->neighbor(face)->has_children() == false)
+ &&
+ (cell->neighbor(face)->refine_flag_set() == false))
+ possibly_refine_unrefined_island<dim,spacedim>
+ (cell->neighbor(face),
+ allow_anisotropic_smoothing);
+ }
+ }
+ else
+ {
+ // variable to store the cell
+ // refine case needed to
+ // fulfill all smoothing
+ // requirements
+ RefinementCase<dim> smoothing_cell_refinement_case
+ = RefinementCase<dim>::no_refinement;
+
+ // use second algorithm, do
+ // the check individually for
+ // each direction
+ for (unsigned int face_pair=0;
+ face_pair<GeometryInfo<dim>::faces_per_cell/2; ++face_pair)
+ {
+ // variable to store the
+ // cell refine case
+ // needed to refine at
+ // the current face pair
+ // in the same way as the
+ // neighbors do...
+ RefinementCase<dim> directional_cell_refinement_case
+ = RefinementCase<dim>::isotropic_refinement;
+
+ for (unsigned int face_index=0; face_index<2; ++face_index)
+ {
+ unsigned int face=2*face_pair+face_index;
+ // variable to store
+ // the refine case
+ // (to come) of the
+ // face under
+ // consideration
+ RefinementCase<dim-1> expected_face_ref_case
+ = RefinementCase<dim-1>::no_refinement;
+
+ if (cell->neighbor(face).state() == IteratorState::valid)
+ face_will_be_refined_by_neighbor<dim,spacedim>(cell,face,expected_face_ref_case);
+ // now extract which
+ // refine case would
+ // be necessary to
+ // achive the same
+ // face
+ // refinement. set
+ // the intersection
+ // with other
+ // requirements for
+ // the same
+ // direction.
+
+ // note: using the
+ // intersection is
+ // not an obvious
+ // decision, we could
+ // also argue that it
+ // is more natural to
+ // use the
+ // union. however,
+ // intersection is
+ // the less
+ // aggressive tactic
+ // and favours a
+ // smaller number of
+ // refined cells over
+ // an intensive
+ // smoothing. this
+ // way we try not to
+ // loose too much of
+ // the effort we put
+ // in anisotropic
+ // refinement
+ // indicators due to
+ // overly aggressive
+ // smoothing...
+ directional_cell_refinement_case
+ = (directional_cell_refinement_case &
+ GeometryInfo<dim>::min_cell_refinement_case_for_face_refinement(
+ expected_face_ref_case,
+ face,
+ cell->face_orientation(face),
+ cell->face_flip(face),
+ cell->face_rotation(face)));
+ }//for both face indices
+ // if both requirements
+ // sum up to something
+ // useful, add this to
+ // the refine case for
+ // smoothing. note: if
+ // directional_cell_refinement_case
+ // is isotropic still,
+ // then something went
+ // wrong...
+ Assert(directional_cell_refinement_case <
+ RefinementCase<dim>::isotropic_refinement,
+ ExcInternalError());
+ smoothing_cell_refinement_case = smoothing_cell_refinement_case |
+ directional_cell_refinement_case;
+ }//for all face_pairs
+ // no we collected
+ // contributions from all
+ // directions. combine the
+ // new flags with the
+ // existing refine case, but
+ // only if smoothing is
+ // required
+ if (smoothing_cell_refinement_case)
+ {
+ cell->clear_coarsen_flag();
+ cell->set_refine_flag(cell->refine_flag_set() |
+ smoothing_cell_refinement_case);
+ }
+ }
+ }
+}
+
+
+template <int dim, int spacedim>
+bool Triangulation<dim,spacedim>::prepare_coarsening_and_refinement ()
+{
+ // save the flags to determine
+ // whether something was changed in
+ // the course of this function
+ std::vector<bool> flags_before[2];
+ save_coarsen_flags (flags_before[0]);
+ save_refine_flags (flags_before[1]);
+
+ // save the flags at the outset of
+ // each loop. we do so in order to
+ // find out whether something was
+ // changed in the present loop, in
+ // which case we would have to
+ // re-run the loop. the other
+ // possibility to find this out
+ // would be to set a flag
+ // @p{something_changed} to true
+ // each time we change something.
+ // however, sometimes one change in
+ // one of the parts of the loop is
+ // undone by another one, so we
+ // might end up in an endless
+ // loop. we could be tempted to
+ // break this loop at an arbitrary
+ // number of runs, but that would
+ // not be a clean solution, since
+ // we would either have to
+ // 1/ break the loop too early, in which
+ // case the promise that a second
+ // call to this function immediately
+ // after the first one does not
+ // change anything, would be broken,
+ // or
+ // 2/ we do as many loops as there are
+ // levels. we know that information
+ // is transported over one level
+ // in each run of the loop, so this
+ // is enough. Unfortunately, each
+ // loop is rather expensive, so
+ // we chose the way presented here
+ std::vector<bool> flags_before_loop[2] = {flags_before[0],
+ flags_before[1]};
+
+ // now for what is done in each
+ // loop: we have to fulfill several
+ // tasks at the same time, namely
+ // several mesh smoothing
+ // algorithms and mesh
+ // regularisation, by which we mean
+ // that the next mesh fulfills
+ // several requirements such as no
+ // double refinement at each face
+ // or line, etc.
+ //
+ // since doing these things at once
+ // seems almost impossible (in the
+ // first year of this library, they
+ // were done in two functions, one
+ // for refinement and one for
+ // coarsening, and most things
+ // within these were done at once,
+ // so the code was rather
+ // impossible to join into this,
+ // only, function), we do them one
+ // after each other. the order in
+ // which we do them is such that
+ // the important tasks, namely
+ // regularisation, are done last
+ // and the least important things
+ // are done the first. the
+ // following order is chosen:
+ //
+ // 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 by coarsening.
+ // As coarsen flags will never be added,
+ // this can be done once and for all
+ // before the actual loop starts.
+ // 1/ do not coarsen a cell if
+ // 'most of the neighbors' will be
+ // refined after the step. This is
+ // to prevent occurence of
+ // unrefined islands.
+ // 2/ eliminate refined islands in the
+ // interior and at the boundary. since
+ // they don't do much harm besides
+ // increasing the number of degrees
+ // of freedom, doing this has a
+ // rather low priority.
+ // 3/ limit the level difference of
+ // neighboring cells at each vertex.
+ // 4/ eliminate unrefined islands. this
+ // has higher priority since this
+ // diminishes the approximation
+ // properties not only of the unrefined
+ // island, but also of the surrounding
+ // patch.
+ // 5/ ensure patch level 1. Then the
+ // triangulation consists of patches,
+ // i.e. of cells that are
+ // refined once. It follows that if at
+ // least one of the children of a cell
+ // is or will be refined than all children
+ // need to be refined. This step
+ // only sets refinement flags and does
+ // not set coarsening flags.
+ // If the patch_level_1 flag is set, then
+ // eliminate_unrefined_islands,
+ // eliminate_refined_inner_islands and
+ // eliminate_refined_boundary_islands will
+ // be fulfilled automatically and do not
+ // need to be enforced separately.
+ // 6/ take care of the requirement that no
+ // double refinement is done at each face
+ // 7/ take care that no double refinement
+ // is done at each line in 3d or higher
+ // dimensions.
+ // 8/ make sure that all children of each
+ // cell are either flagged for coarsening
+ // or none of the children is
+ //
+ // For some of these steps, it is
+ // known that they
+ // interact. Namely, it is not
+ // possible to guarantee that after
+ // step 6 another step 5 would have
+ // no effect; the same holds for
+ // the opposite order and also when
+ // taking into account step
+ // 7. however, it is important to
+ // guarantee that step five or six
+ // do not undo something that step
+ // 5 did, and step 7 not something
+ // of step 6, otherwise the
+ // requirements will not be
+ // satisfied even if the loop
+ // terminates. this is accomplished
+ // by the fact that steps 5 and 6
+ // only *add* refinement flags and
+ // delete coarsening flags
+ // (therefore, step 6 can't undo
+ // something that step 4 already
+ // did), and step 7 only deletes
+ // coarsening flags, never adds
+ // some. step 7 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 by coarsening.
+ if (((smooth_grid & coarsest_level_1) ||
+ (smooth_grid & patch_level_1)) && n_levels()>=2)
+ {
+ active_cell_iterator
+ cell=begin_active(1),
+ endc=end_active(1);
+
+ for (; cell!=endc; ++cell)
+ cell->clear_coarsen_flag();
+ }
+
+ 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
+ // occurence of unrefined islands.
+ // If patch_level_1 is set, this will
+ // be automatically fulfilled.
+ if (smooth_grid & do_not_produce_unrefined_islands &&
+ !(smooth_grid & patch_level_1))
+ {
+ cell_iterator cell;
+ const cell_iterator endc = end();
+
+ for (cell=begin(); cell!=endc; ++cell)
+ {
+ // only do something if this
+ // cell will be coarsened
+ if (!cell->active() && cell_will_be_coarsened(cell))
+ possibly_do_not_produce_unrefined_islands<dim,spacedim>(cell);
+ }
+ }
+
+
+ //////////////////////////////////////
+ // STEP 2:
+ // eliminate refined islands in the
+ // interior and at the boundary. since
+ // they don't do much harm besides
+ // increasing the number of degrees of
+ // freedom, doing this has a rather low
+ // priority.
+ // If patch_level_1 is set, this will
+ // be automatically fulfilled.
+ //
+ // there is one corner case
+ // to consider: if this is a
+ // distributed
+ // triangulation, there may
+ // be refined islands on the
+ // boundary of which we own
+ // only part (e.g. a single
+ // cell in the corner of a
+ // domain). the rest of the
+ // island is ghost cells and
+ // it *looks* like the area
+ // around it (artificial
+ // cells) are coarser but
+ // this is only because they
+ // may actually be equally
+ // fine on other
+ // processors. it's hard to
+ // detect this case but we
+ // can do the following:
+ // only set coarsen flags to
+ // remove this refined
+ // island if all cells we
+ // want to set flags on are
+ // locally owned
+ if (smooth_grid & (eliminate_refined_inner_islands |
+ eliminate_refined_boundary_islands) &&
+ !(smooth_grid & patch_level_1))
+ {
+ cell_iterator cell;
+ const cell_iterator endc = end();
+
+ for (cell=begin(); cell!=endc; ++cell)
+ if (!cell->active() ||
+ (cell->active() &&
+ cell->refine_flag_set() &&
+ !cell->is_ghost() &&
+ !cell->is_artificial()))
+ {
+ // check whether all
+ // children are
+ // active, i.e. not
+ // refined
+ // themselves. This
+ // is a precondition
+ // that the children
+ // may be coarsened
+ // away. If the cell
+ // is only flagged
+ // for refinement,
+ // then all future
+ // children will be
+ // active
+ bool all_children_active = true;
+ if (!cell->active())
+ for (unsigned int c=0; c<cell->n_children(); ++c)
+ if (!cell->child(c)->active() ||
+ cell->child(c)->is_ghost() ||
+ cell->child(c)->is_artificial())
+ {
+ all_children_active = false;
+ break;
+ }
+
+ if (all_children_active)
+ {
+ // count number
+ // of refined and
+ // unrefined
+ // neighbors of
+ // cell.
+ // neighbors on
+ // lower levels
+ // are counted as
+ // unrefined
+ // since they can
+ // only get to
+ // the same level
+ // as this cell
+ // by the next
+ // refinement
+ // cycle
+ unsigned int unrefined_neighbors = 0,
+ total_neighbors = 0;
+
+ for (unsigned int n=0; n<GeometryInfo<dim>::faces_per_cell; ++n)
+ {
+ const cell_iterator neighbor = cell->neighbor(n);
+ if (neighbor.state() == IteratorState::valid)
+ {
+ ++total_neighbors;
+
+ if (!face_will_be_refined_by_neighbor(cell,n))
+ ++unrefined_neighbors;
+ }
+
+ }
+
+ // if all
+ // neighbors
+ // unrefined:
+ // mark this cell
+ // for coarsening
+ // or don't
+ // refine if
+ // marked for
+ // that
+ //
+ // also do the
+ // distinction
+ // between the
+ // two versions
+ // of the
+ // eliminate_refined_*_islands
+ // flag
+ //
+ // the last check
+ // is whether
+ // there are any
+ // neighbors at
+ // all. if not
+ // so, then we
+ // are (e.g.) on
+ // the coarsest
+ // grid with one
+ // cell, for
+ // which, of
+ // course, we do
+ // not remove the
+ // refine flag.
+ if ((unrefined_neighbors == total_neighbors)
+ &&
+ (((unrefined_neighbors==GeometryInfo<dim>::faces_per_cell) &&
+ (smooth_grid & eliminate_refined_inner_islands)) ||
+ ((unrefined_neighbors<GeometryInfo<dim>::faces_per_cell) &&
+ (smooth_grid & eliminate_refined_boundary_islands)) )
+ &&
+ (total_neighbors != 0))
+ {
+ if (!cell->active())
+ for (unsigned int c=0; c<cell->n_children(); ++c)
+ {
+ cell->child(c)->clear_refine_flag ();
+ cell->child(c)->set_coarsen_flag ();
+ }
+ else
+ cell->clear_refine_flag();
+ }
+ }
+ }
+ }
+
+ //////////////////////////////////////
+ // STEP 3:
+ // limit the level difference of
+ // neighboring cells at each vertex.
+ //
+ // in case of anisotropic refinement
+ // this does not make sense. as soon
+ // as one cell is anisotropically
+ // refined, an Assertion is
+ // thrown. therefore we can ignore
+ // this problem later on
+ if (smooth_grid & limit_level_difference_at_vertices)
+ {
+ Assert(!anisotropic_refinement,
+ ExcMessage("In case of anisotropic refinement the "
+ "limit_level_difference_at_vertices flag for "
+ "mesh smoothing must not be set!"));
+
+ // store highest level one
+ // of the cells adjacent to
+ // a vertex belongs to
+ std::vector<int> vertex_level (vertices.size(), 0);
+ active_cell_iterator cell = begin_active(),
+ endc = end();
+ for (; cell!=endc; ++cell)
+ {
+ if (cell->refine_flag_set())
+ 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())
+ 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
+ Assert (cell->coarsen_flag_set(), ExcInternalError());
+ 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
+ // update the vertex levels on the
+ // adjacent vertices and maybe
+ // already flag additional cells in
+ // this loop
+ //
+ // note that not only may we have
+ // to add additional refinement
+ // flags, but we will also have to
+ // remove coarsening flags on cells
+ // adjacent to vertices that will
+ // see refinement
+ for (cell=last_active(); cell != endc; --cell)
+ 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
+ }
+ }
+ }
+
+ /////////////////////////////////////
+ // STEP 4:
+ // eliminate unrefined
+ // islands. this has higher
+ // priority since this
+ // diminishes the
+ // approximation properties
+ // not only of the unrefined
+ // island, but also of the
+ // surrounding patch.
+ //
+ // do the loop from finest
+ // to coarsest cells since
+ // we may trigger a cascade
+ // by marking cells for
+ // refinement which may
+ // trigger more cells
+ // further down below
+ if (smooth_grid & eliminate_unrefined_islands)
+ {
+ active_cell_iterator cell=last_active(),
+ endc=end();
+
+ for (; cell != endc; --cell)
+ // only do something if
+ // cell is not already
+ // flagged for
+ // (isotropic) refinement
+ if (cell->refine_flag_set() != RefinementCase<dim>::isotropic_refinement)
+ possibly_refine_unrefined_island<dim,spacedim>
+ (cell,
+ (smooth_grid & allow_anisotropic_smoothing) != 0);
+ }
+
+ /////////////////////////////////
+ // STEP 5:
+ // ensure patch level 1.
+ //
+ // Introduce some terminology:
+ // - a cell that is refined
+ // once is a patch of
+ // level 1 simply called patch.
+ // - a cell that is globally
+ // refined twice is called
+ // a patch of level 2.
+ // - patch level n says that
+ // the triangulation consists
+ // of patches of level n.
+ // This makes sense only
+ // if the grid is already at
+ // least n times globally
+ // refined.
+ //
+ // E.g. from patch level 1
+ // follows: if at least one
+ // of the children of a cell
+ // is or will be refined
+ // than enforce all
+ // children to be
+ // refined.
+
+ // This step 4 only
+ // sets refinement flags and
+ // does not set coarsening
+ // flags.
+ if (smooth_grid & patch_level_1)
+ {
+ // An important assumption
+ // (A) is that before
+ // calling this function
+ // the grid was already of
+ // patch level 1.
+
+ // loop over all cells
+ // whose children are all
+ // active. (By assumption
+ // (A) either all or none
+ // of the children are
+ // active). If the refine
+ // flag of at least one of
+ // the children is set then
+ // set_refine_flag and
+ // clear_coarsen_flag of
+ // all children.
+ for (cell_iterator cell = begin(); cell != end(); ++cell)
+ if (!cell->active())
+ {
+ // ensure the
+ // invariant. we can
+ // then check whether
+ // all of its
+ // children are
+ // further refined or
+ // not by simply
+ // looking at the
+ // first child
+ Assert (cell_is_patch_level_1(cell),
+ ExcInternalError());
+ if (cell->child(0)->has_children() == true)
+ continue;
+
+ // cell is found to
+ // be a patch.
+ // combine the refine
+ // cases of all
+ // children
+ RefinementCase<dim> combined_ref_case = RefinementCase<dim>::no_refinement;
+ for (unsigned int i=0; i<cell->n_children(); ++i)
+ combined_ref_case = combined_ref_case |
+ cell->child(i)->refine_flag_set();
+ if (combined_ref_case != RefinementCase<dim>::no_refinement)
+ for (unsigned int i=0; i<cell->n_children(); ++i)
+ {
+ cell_iterator child = cell->child(i);
+
+ child->clear_coarsen_flag();
+ child->set_refine_flag(combined_ref_case);
+ }
+ }
+
+ // The code above dealt
+ // with the case where we
+ // may get a
+ // non-patch_level_1 mesh
+ // from refinement. Now
+ // also deal with the case
+ // where we could get such
+ // a mesh by coarsening.
+ // Coarsen the children
+ // (and remove the
+ // grandchildren) only if
+ // all cell->grandchild(i)
+ // ->coarsen_flag_set()
+ // are set.
+ //
+ // for a case where this is
+ // a bit tricky, take a
+ // look at the
+ // mesh_smoothing_0[12]
+ // testcases
+ for (cell_iterator cell = begin(); cell != end(); ++cell)
+ {
+ // check if this cell
+ // has active
+ // grandchildren. note
+ // that we know that it
+ // is patch_level_1,
+ // i.e. if one of its
+ // children is active
+ // then so are all, and
+ // it isn't going to
+ // have any
+ // grandchildren at
+ // all:
+ if (cell->active()
+ ||
+ cell->child(0)->active())
+ continue;
+
+ // cell is not active,
+ // and so are none of
+ // its children. check
+ // the
+ // grandchildren. note
+ // that the children
+ // are also
+ // patch_level_1, and
+ // so we only ever need
+ // to check their first
+ // child
+ const unsigned int n_children=cell->n_children();
+ bool has_active_grandchildren = false;
+
+ for (unsigned int i=0; i<n_children; ++i)
+ if (cell->child(i)->child(0)->active())
+ {
+ has_active_grandchildren = true;
+ break;
+ }
+
+ if (has_active_grandchildren == false)
+ continue;
+
+
+ // ok, there are active
+ // grandchildren. see
+ // if either all or
+ // none of them are
+ // flagged for
+ // coarsening
+ unsigned int n_grandchildren=0;
+ // count all coarsen
+ // flags of the
+ // grandchildren.
+ unsigned int n_coarsen_flags=0;
+ // cell is not a
+ // patch (of level 1)
+ // as it has a
+ // grandchild. Is
+ // cell a patch of
+ // level 2??
+ // Therefore: find
+ // out whether all
+ // cell->child(i) are
+ // patches
+ for (unsigned int c=0; c<n_children; ++c)
+ {
+ // get at the
+ // child. by
+ // assumption
+ // (A), and the
+ // check by which
+ // we got here,
+ // the child is
+ // not active
+ cell_iterator child=cell->child(c);
+
+ const unsigned int nn_children=child->n_children();
+ n_grandchildren += nn_children;
+
+ // if child is
+ // found to be a
+ // patch of
+ // active cells
+ // itself, then
+ // add up how
+ // many of its
+ // children are
+ // supposed to be
+ // coarsened
+ if (child->child(0)->active())
+ for (unsigned int cc=0; cc<nn_children; ++cc)
+ if (child->child(cc)->coarsen_flag_set())
+ ++n_coarsen_flags;
+ }
+
+ // if not all
+ // grandchildren are
+ // supposed to be
+ // coarsened
+ // (e.g. because some
+ // simply don't have
+ // the flag set, or
+ // because they are not
+ // active and therefore
+ // cannot carry the
+ // flag), then remove
+ // the coarsen flag
+ // from all of the
+ // active
+ // grandchildren. note
+ // that there may be
+ // coarsen flags on the
+ // grandgrandchildren
+ // -- we don't clear
+ // them here, but we'll
+ // get to them in later
+ // iterations if
+ // necessary
+ //
+ // there is nothing
+ // we have to do if
+ // no coarsen flags
+ // have been set at
+ // all
+ if ((n_coarsen_flags != n_grandchildren)
+ &&
+ (n_coarsen_flags > 0))
+ for (unsigned int c=0; c<n_children; ++c)
+ {
+ const cell_iterator child = cell->child(c);
+ if (child->child(0)->active())
+ for (unsigned int cc=0; cc<child->n_children(); ++cc)
+ child->child(cc)->clear_coarsen_flag();
+ }
+ }
+ }
+
+ //////////////////////////////////
+ //
+ // at the boundary we could end up with
+ // cells with negative volume or at
+ // least with a part, that is negative,
+ // if the cell is refined
+ // anisotropically. we have to check,
+ // whether that can happen
+ internal::Triangulation::Implementation::prevent_distorted_boundary_cells(*this);
+
+ /////////////////////////////////
+ // STEP 6:
+ // take care of the requirement that no
+ // double refinement is done at each face
+ //
+ // in case of anisotropic refinement
+ // it is only likely, but not sure,
+ // that the cells, which are more
+ // refined along a certain face common
+ // to two cells are on a higher
+ // level. therefore we cannot be sure,
+ // that the requirement of no double
+ // refinement is fulfilled after a
+ // single pass of the following
+ // actions. We could just wait for the
+ // next global loop. when this
+ // function terminates, the
+ // requirement will be
+ // fullfilled. However, it might be
+ // faster to insert an inner loop
+ // here.
+ bool changed = true;
+ while (changed)
+ {
+ changed=false;
+ active_cell_iterator cell=last_active(),
+ endc=end();
+
+ for (; cell != endc; --cell)
+ if (cell->refine_flag_set())
+ {
+ // loop over neighbors of cell
+ for (unsigned int i=0; i<GeometryInfo<dim>::faces_per_cell; ++i)
+ {
+ // only do something if the
+ // face is not at the boundary
+ // and if the face will be
+ // refined with the RefineCase
+ // currently flagged for
+ if (cell->neighbor(i).state() == IteratorState::valid &&
+ (GeometryInfo<dim>::face_refinement_case(cell->refine_flag_set(),
+ i)
+ != RefinementCase<dim-1>::no_refinement))
+ {
+ // 1) if the neighbor has
+ // children: nothing to
+ // worry about.
+ // 2) if the neighbor is
+ // active and a coarser
+ // one, ensure, that its
+ // refine_flag is set
+ // 3) if the neighbor is
+ // active and as
+ // refined along the face
+ // as our current cell,
+ // make sure, that no
+ // coarsen_flag is set. if
+ // we remove the coarsen
+ // flag of our neighbor,
+ // fix_coarsen_flags() makes
+ // sure, that the mother
+ // cell will not be
+ // coarsened
+ if (cell->neighbor(i)->active())
+ {
+ if (cell->neighbor_is_coarser(i))
+ {
+ if (cell->neighbor(i)->coarsen_flag_set())
+ cell->neighbor(i)->clear_coarsen_flag();
+ // we'll set the
+ // refine flag
+ // for this
+ // neighbor
+ // below. we
+ // note, that we
+ // have changed
+ // something by
+ // setting the
+ // changed flag
+ // to true. We do
+ // not need to do
+ // so, if we just
+ // removed the
+ // coarsen flag,
+ // as the changed
+ // flag only
+ // indicates the
+ // need to re-run
+ // the inner
+ // loop. however,
+ // we only loop
+ // over cells
+ // flagged for
+ // refinement
+ // here, so
+ // nothing to
+ // worry about if
+ // we remove
+ // coarsen flags
+
+ if (dim==2)
+ {
+ if (smooth_grid & allow_anisotropic_smoothing)
+ changed=cell->neighbor(i)->flag_for_face_refinement(cell->neighbor_of_coarser_neighbor(i).first,
+ RefinementCase<dim-1>::cut_x);
+ else
+ {
+ if (!cell->neighbor(i)->refine_flag_set())
+ changed=true;
+ cell->neighbor(i)->set_refine_flag();
+ }
+ }
+ else //i.e. if (dim==3)
+ {
+// ugly situations might arise here, consider the following situation, which
+// shows neighboring cells at the common face, where the upper right element is
+// coarser at the given face. Now the upper child element of the lower left
+// wants to refine according to cut_z, such that there is a 'horizontal'
+// refinement of the face marked with #####
+//
+// / /
+// / /
+// *---------------*
+// | |
+// | |
+// | |
+// | |
+// | |
+// | | /
+// | |/
+// *---------------*
+//
+//
+// *---------------*
+// /| /|
+// / | ##### / |
+// | |
+// *---------------*
+// /| /|
+// / | / |
+// | |
+// *---------------*
+// / /
+// / /
+//
+// this introduces too many hanging nodes and the neighboring (coarser) cell
+// (upper right) has to be refined. If it is only refined according to cut_z,
+// then everything is ok:
+//
+// / /
+// / /
+// *---------------*
+// | |
+// | | /
+// | |/
+// *---------------*
+// | |
+// | | /
+// | |/
+// *---------------*
+//
+//
+// *---------------*
+// /| /|
+// / *---------------*
+// /| /|
+// *---------------*
+// /| /|
+// / | / |
+// | |
+// *---------------*
+// / /
+// / /
+//
+// if however the cell wants to refine itself in an other way, or if we disallow
+// anisotropic smoothing, then simply refining the neighbor isotropically is not
+// going to work, since this introduces a refinement of face ##### with both
+// cut_x and cut_y, which is not possible:
+//
+// / / /
+// / / /
+// *-------*-------*
+// | | |
+// | | | /
+// | | |/
+// *-------*-------*
+// | | |
+// | | | /
+// | | |/
+// *-------*-------*
+//
+//
+// *---------------*
+// /| /|
+// / *---------------*
+// /| /|
+// *---------------*
+// /| /|
+// / | / |
+// | |
+// *---------------*
+// / /
+// / /
+//
+// thus, in this case we also need to refine our current cell in the new
+// direction:
+//
+// / / /
+// / / /
+// *-------*-------*
+// | | |
+// | | | /
+// | | |/
+// *-------*-------*
+// | | |
+// | | | /
+// | | |/
+// *-------*-------*
+//
+//
+// *-------*-------*
+// /| /| /|
+// / *-------*-------*
+// /| /| /|
+// *-------*-------*
+// /| / /|
+// / | / |
+// | |
+// *---------------*
+// / /
+// / /
+
+ std::pair<unsigned int, unsigned int> nb_indices
+ =cell->neighbor_of_coarser_neighbor(i);
+ unsigned int refined_along_x=0,
+ refined_along_y=0,
+ to_be_refined_along_x=0,
+ to_be_refined_along_y=0;
+
+ const int this_face_index=cell->face_index(i);
+
+// step 1: detect, along which axis the face is currently refined
+ if ((this_face_index
+ == cell->neighbor(i)->face(nb_indices.first)->child_index(0)) ||
+ (this_face_index
+ == cell->neighbor(i)->face(nb_indices.first)->child_index(1)))
+ {
+ // this
+ // might
+ // be an
+ // anisotropic
+ // child. get
+ // the
+ // face
+ // refine
+ // case
+ // of the
+ // neighbors
+ // face
+ // and
+ // count
+ // refinements
+ // in x
+ // and y
+ // direction.
+ RefinementCase<dim-1> frc=cell->neighbor(i)->face(nb_indices.first)->refinement_case();
+ if (frc & RefinementCase<dim>::cut_x)
+ ++refined_along_x;
+ if (frc & RefinementCase<dim>::cut_y)
+ ++refined_along_y;
+ }
+ else
+ // this has
+ // to be an
+ // isotropic
+ // child
+ {
+ ++refined_along_x;
+ ++refined_along_y;
+ }
+// step 2: detect, along which axis the face has to be refined given the current
+// refine flag
+ RefinementCase<dim-1> flagged_frc=
+ GeometryInfo<dim>::face_refinement_case(cell->refine_flag_set(),
+ i,
+ cell->face_orientation(i),
+ cell->face_flip(i),
+ cell->face_rotation(i));
+ if (flagged_frc & RefinementCase<dim>::cut_x)
+ ++to_be_refined_along_x;
+ if (flagged_frc & RefinementCase<dim>::cut_y)
+ ++to_be_refined_along_y;
+
+// step 3: set the refine flag of the (coarser and active) neighbor.
+ if ((smooth_grid & allow_anisotropic_smoothing) ||
+ cell->neighbor(i)->refine_flag_set())
+ {
+ if (refined_along_x + to_be_refined_along_x > 1)
+ changed |= cell->neighbor(i)->flag_for_face_refinement(nb_indices.first,
+ RefinementCase<dim-1>::cut_axis(0));
+ if (refined_along_y + to_be_refined_along_y > 1)
+ changed |= cell->neighbor(i)->flag_for_face_refinement(nb_indices.first,
+ RefinementCase<dim-1>::cut_axis(1));
+ }
+ else
+ {
+ if (cell->neighbor(i)->refine_flag_set()!=RefinementCase<dim>::isotropic_refinement)
+ changed=true;
+ cell->neighbor(i)->set_refine_flag();
+ }
+
+// step 4: if necessary (see above) add to the refine flag of the current cell
+ cell_iterator nb=cell->neighbor(i);
+ RefinementCase<dim-1> nb_frc
+ = GeometryInfo<dim>::face_refinement_case(nb->refine_flag_set(),
+ nb_indices.first,
+ nb->face_orientation(nb_indices.first),
+ nb->face_flip(nb_indices.first),
+ nb->face_rotation(nb_indices.first));
+ if ((nb_frc & RefinementCase<dim>::cut_x) &&
+ !(refined_along_x || to_be_refined_along_x))
+ changed |= cell->flag_for_face_refinement(i,RefinementCase<dim-1>::cut_axis(0));
+ if ((nb_frc & RefinementCase<dim>::cut_y) &&
+ !(refined_along_y || to_be_refined_along_y))
+ changed |= cell->flag_for_face_refinement(i,RefinementCase<dim-1>::cut_axis(1));
+ }
+ }// if neighbor is coarser
+ else // -> now the neighbor is not coarser
+ {
+ cell->neighbor(i)->clear_coarsen_flag();
+ const unsigned int nb_nb=cell->neighbor_of_neighbor(i);
+ const cell_iterator neighbor=cell->neighbor(i);
+ RefinementCase<dim-1> face_ref_case=
+ GeometryInfo<dim>::face_refinement_case(neighbor->refine_flag_set(),
+ nb_nb,
+ neighbor->face_orientation(nb_nb),
+ neighbor->face_flip(nb_nb),
+ neighbor->face_rotation(nb_nb));
+ RefinementCase<dim-1> needed_face_ref_case
+ =GeometryInfo<dim>::face_refinement_case(cell->refine_flag_set(),
+ i,
+ cell->face_orientation(i),
+ cell->face_flip(i),
+ cell->face_rotation(i));
+ // if the
+ // neighbor wants
+ // to refine the
+ // face with
+ // cut_x and we
+ // want cut_y or
+ // vice versa, we
+ // have to refine
+ // isotropically
+ // at the given
+ // face
+ if ((face_ref_case==RefinementCase<dim>::cut_x && needed_face_ref_case==RefinementCase<dim>::cut_y) ||
+ (face_ref_case==RefinementCase<dim>::cut_y && needed_face_ref_case==RefinementCase<dim>::cut_x))
+ {
+ changed=cell->flag_for_face_refinement(i, face_ref_case);
+ neighbor->flag_for_face_refinement(nb_nb, needed_face_ref_case);
+ }
+ }
+ }
+ else //-> the neighbor is not active
+ {
+ RefinementCase<dim-1> face_ref_case = cell->face(i)->refinement_case(),
+ needed_face_ref_case = GeometryInfo<dim>::face_refinement_case(cell->refine_flag_set(),
+ i,
+ cell->face_orientation(i),
+ cell->face_flip(i),
+ cell->face_rotation(i));
+ // if the face is
+ // refined with cut_x
+ // and we want cut_y
+ // or vice versa, we
+ // have to refine
+ // isotropically at
+ // the given face
+ if ((face_ref_case==RefinementCase<dim>::cut_x && needed_face_ref_case==RefinementCase<dim>::cut_y) ||
+ (face_ref_case==RefinementCase<dim>::cut_y && needed_face_ref_case==RefinementCase<dim>::cut_x))
+ changed=cell->flag_for_face_refinement(i, face_ref_case);
+ }
+ }
+ }
+ }
+ }
+
+ //////////////////////////////////////
+ // STEP 7:
+ // take care that no double refinement
+ // is done at each line in 3d or higher
+ // dimensions.
+ internal::Triangulation::Implementation::prepare_refinement_dim_dependent (*this);
+
+ //////////////////////////////////////
+ // STEP 8:
+ // make sure that all children of each
+ // cell are either flagged for coarsening
+ // or none of the children is
+ fix_coarsen_flags ();
+ // get the refinement and coarsening
+ // flags
+ std::vector<bool> flags_after_loop[2];
+ save_coarsen_flags (flags_after_loop[0]);
+ save_refine_flags (flags_after_loop[1]);
+
+ // find out whether something was
+ // changed in this loop
+ mesh_changed_in_this_loop
+ = ((flags_before_loop[0] != flags_after_loop[0]) ||
+ (flags_before_loop[1] != flags_after_loop[1]));
+
+ // set the flags for the next loop
+ // already
+ flags_before_loop[0].swap(flags_after_loop[0]);
+ flags_before_loop[1].swap(flags_after_loop[1]);
+ }
+ while (mesh_changed_in_this_loop);
+
+
+ // find out whether something was really
+ // changed in this function. Note that
+ // @p{flags_before_loop} represents the
+ // state after the last loop, i.e.
+ // the present state
+ return ((flags_before[0] != flags_before_loop[0]) ||
+ (flags_before[1] != flags_before_loop[1]));
+}
+
+
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::write_bool_vector (const unsigned int magic_number1,
+ const std::vector<bool> &v,
+ const unsigned int magic_number2,
+ std::ostream &out)
+{
+ const unsigned int N = v.size();
+ unsigned char *flags = new unsigned char[N/8+1];
+ for (unsigned int i=0; i<N/8+1; ++i) flags[i]=0;
+
+ for (unsigned int position=0; position<N; ++position)
+ flags[position/8] |= (v[position] ? (1<<(position%8)) : 0);
+
+ AssertThrow (out, ExcIO());
+
+ // format:
+ // 0. magic number
+ // 1. number of flags
+ // 2. the flags
+ // 3. magic number
+ out << magic_number1 << ' ' << N << std::endl;
+ for (unsigned int i=0; i<N/8+1; ++i)
+ out << static_cast<unsigned int>(flags[i]) << ' ';
+
+ out << std::endl << magic_number2 << std::endl;
+
+ delete[] flags;
+
+ AssertThrow (out, ExcIO());
+}
+
+
+template <int dim, int spacedim>
+void Triangulation<dim, spacedim>::read_bool_vector (const unsigned int magic_number1,
+ std::vector<bool> &v,
+ const unsigned int magic_number2,
+ std::istream &in)
+{
+ AssertThrow (in, ExcIO());
+
+ unsigned int magic_number;
+ in >> magic_number;
+ AssertThrow (magic_number==magic_number1, ExcGridReadError());
+
+ unsigned int N;
+ in >> N;
+ v.resize (N);
+
+ unsigned char *flags = new unsigned char[N/8+1];
+ unsigned short int tmp;
+ for (unsigned int i=0; i<N/8+1; ++i)
+ {
+ in >> tmp;
+ flags[i] = tmp;
+ }
+
+ for (unsigned int position=0; position!=N; ++position)
+ v[position] = (flags[position/8] & (1<<(position%8)));
+
+ in >> magic_number;
+ AssertThrow (magic_number==magic_number2, ExcGridReadError());
+
+ delete[] flags;
+
+ AssertThrow (in, ExcIO());
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int
+Triangulation<dim, spacedim>::memory_consumption () const
+{
+ unsigned int mem = 0;
+ mem += MemoryConsumption::memory_consumption(levels);
+ for (unsigned int i=0; i<levels.size(); ++i)
+ mem += MemoryConsumption::memory_consumption (*levels[i]);
+ mem += MemoryConsumption::memory_consumption (vertices);
+ mem += MemoryConsumption::memory_consumption (vertices_used);
+ mem += sizeof(boundary);
+ mem += sizeof(smooth_grid);
+ mem += MemoryConsumption::memory_consumption (number_cache);
+ mem += sizeof (faces);
+ mem += MemoryConsumption::memory_consumption (*faces);
+
+ return mem;
+}
+
+
+
+
+template<int dim, int spacedim>
+Triangulation<dim, spacedim>::RefinementListener::~RefinementListener ()
+{}
+
+
+
+template<int dim, int spacedim>
+Triangulation<dim, spacedim>::DistortedCellList::~DistortedCellList () throw ()
+{
+ // don't do anything here. the compiler
+ // will automatically convert any
+ // exceptions created by the destructors of
+ // the member variables into abort() in
+ // order to satisfy the throw()
+ // specification
+}
+
+
+
+
+template<int dim, int spacedim>
+void Triangulation<dim, spacedim>::
+RefinementListener::pre_refinement_notification (const Triangulation<dim, spacedim> &)
+{}
+
+
+
+template<int dim, int spacedim>
+void Triangulation<dim, spacedim>::
+RefinementListener::post_refinement_notification (const Triangulation<dim, spacedim> &)
+{}
+
+
+
+template<int dim, int spacedim>
+void Triangulation<dim, spacedim>::
+RefinementListener::copy_notification (const Triangulation<dim, spacedim> &,
+ const Triangulation<dim, spacedim> &)
+{}
+
+
+
+template<int dim, int spacedim>
+void
+Triangulation<dim, spacedim>::add_refinement_listener (RefinementListener &listener) const
+{
+ refinement_listeners.push_back (&listener);
+}
+
+
+
+template<int dim, int spacedim>
+void
+Triangulation<dim, spacedim>::remove_refinement_listener (RefinementListener &listener) const
+{
+ typename std::list<RefinementListener *>::iterator p =
+ std::find (refinement_listeners.begin (),
+ refinement_listeners.end (),
+ &listener);
+ Assert (p != refinement_listeners.end (), ExcInternalError ());
+ refinement_listeners.erase (p);
+}
+
+
+
+// explicit instantiations
+#include "tria.inst"
+
+// this is a hack: we need to instantiate this one function because
+// TriaAccessor<1,1,3> uses it. We could instead instantiate
+// Triangulation<1,3>, but that requires a lot more specializations of
+// functions that currently only exist for <1,1> and <1,2>
+template
+const Boundary<1,3> &
+Triangulation<1,3>::get_boundary (const unsigned int number) const;
+
DEAL_II_NAMESPACE_CLOSE
+++ /dev/null
-//---------------------------------------------------------------------------
-// $Id$
-// Version: $Name$
-//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 by the deal.II authors
-//
-// This file is subject to QPL and may not be distributed
-// without copyright and license information. Please refer
-// to the file deal.II/doc/license.html for the text and
-// further information on this license.
-//
-//---------------------------------------------------------------------------
-
-#include <base/memory_consumption.h>
-#include <grid/tria.h>
-#include <grid/tria_levels.h>
-#include <grid/tria_faces.h>
-#include <grid/tria_boundary.h>
-#include <grid/tria_accessor.h>
-#include <grid/tria_iterator.h>
-#include <base/geometry_info.h>
-#include <grid/grid_tools.h>
-#include <grid/magic_numbers.h>
-#include <fe/mapping_q1.h>
-#include <lac/vector.h>
-
-#include <algorithm>
-#include <numeric>
-#include <map>
-#include <cmath>
-#include <functional>
-
-#include <base/std_cxx1x/array.h>
-
-DEAL_II_NAMESPACE_OPEN
-
-// anonymous namespace for internal helper functions
-namespace
-{
- // return whether the given cell is
- // patch_level_1, i.e. determine
- // whether either all or none of
- // its children are further
- // refined. this function can only
- // be called for non-active cells.
- template <int dim, int spacedim>
- bool cell_is_patch_level_1 (const TriaIterator<dealii::CellAccessor<dim, spacedim> > &cell)
- {
- Assert (cell->active() == false, ExcInternalError());
-
- unsigned int n_active_children = 0;
- for (unsigned int i=0; i<cell->n_children(); ++i)
- if (cell->child(i)->active())
- ++n_active_children;
-
- return (n_active_children == 0) || (n_active_children == cell->n_children());
- }
-
-
-
- // return, wheter a given @p cell will be
- // coarsened, which is the case if all
- // children are active and have their coarsen
- // flag set. In case only part of the coarsen
- // flags are set, remove them.
- template <int dim, int spacedim>
- bool cell_will_be_coarsened (const TriaIterator<dealii::CellAccessor<dim,spacedim> > &cell)
- {
- // only cells with children should be
- // considered for coarsening
-
- if (cell->has_children())
- {
- unsigned int children_to_coarsen=0;
- const unsigned int n_children=cell->n_children();
-
- for (unsigned int c=0; c<n_children; ++c)
- if (cell->child(c)->active() &&
- cell->child(c)->coarsen_flag_set())
- ++children_to_coarsen;
- if (children_to_coarsen==n_children)
- return true;
- else
- for (unsigned int c=0; c<n_children; ++c)
- if (cell->child(c)->active())
- cell->child(c)->clear_coarsen_flag();
- }
- // no children, so no coarsening
- // possible. however, no children also
- // means that this cell will be in the same
- // state as if it had children and was
- // coarsened. So, what should we return -
- // false or true?
- // make sure we do not have to do this at
- // all...
- Assert(cell->has_children(), ExcInternalError());
- // ... and then simply return false
- return false;
- }
-
-
- // return, whether the face @p face_no of the
- // given @p cell will be refined after the
- // current refinement step, considering
- // refine and coarsen flags and considering
- // only those refinemnts that will be caused
- // by the neighboring cell.
-
- // this function is used on both active cells
- // and cells with children. on cells with
- // children it also of interest to know 'how'
- // the face will be refined. thus there is an
- // additional third argument @p
- // expected_face_ref_case returning just
- // that. be aware, that this vriable will
- // only contain useful information if this
- // function is called for an active cell.
- //
- // thus, this is an internal function, users
- // should call one of the two alternatives
- // following below.
- template <int dim, int spacedim>
- bool
- face_will_be_refined_by_neighbor_internal(const TriaIterator<dealii::CellAccessor<dim,spacedim> > &cell,
- const unsigned int face_no,
- RefinementCase<dim-1> &expected_face_ref_case)
- {
- // first of all: set the default value for
- // expected_face_ref_case, which is no
- // refinement at all
- expected_face_ref_case=RefinementCase<dim-1>::no_refinement;
-
- const typename Triangulation<dim,spacedim>::cell_iterator neighbor=cell->neighbor(face_no);
-
- // If we are at the boundary, there is no
- // neighbor which could refine the face
- if (neighbor.state()!=IteratorState::valid)
- return false;
-
- if (neighbor->has_children())
- {
- // if the neighbor is refined, it may be
- // coarsened. if so, then it won't refine
- // the face, no matter what else happens
- if (cell_will_be_coarsened(neighbor))
- return false;
- else
- // if the neighor is refined, then he
- // is also refined at our current
- // face. He will stay so without
- // coarsening, so return true in that
- // case.
- {
- expected_face_ref_case=cell->face(face_no)->refinement_case();
- return true;
- }
- }
-
- // now, the neighbor is not refined, but
- // perhaps he will be
- const RefinementCase<dim> nb_ref_flag=neighbor->refine_flag_set();
- if (nb_ref_flag != RefinementCase<dim>::no_refinement)
- {
- // now we need to know, which of the
- // neighbors faces points towards us
- const unsigned int neighbor_neighbor=cell->neighbor_face_no(face_no);
- // check, whether the cell will be
- // refined in a way that refines our
- // face
- const RefinementCase<dim-1> face_ref_case=
- GeometryInfo<dim>::face_refinement_case(nb_ref_flag,
- neighbor_neighbor,
- neighbor->face_orientation(neighbor_neighbor),
- neighbor->face_flip(neighbor_neighbor),
- neighbor->face_rotation(neighbor_neighbor));
- if (face_ref_case != RefinementCase<dim-1>::no_refinement)
- {
- const typename Triangulation<dim,spacedim>::face_iterator neighbor_face=neighbor->face(neighbor_neighbor);
- const int this_face_index=cell->face_index(face_no);
-
- // there are still two basic
- // possibilities here: the neighbor
- // might be coarser or as coarse
- // as we are
- if (neighbor_face->index()==this_face_index)
- // the neighbor is as coarse as
- // we are and will be refined at
- // the face of consideration, so
- // return true
- {
- expected_face_ref_case = face_ref_case;
- return true;
- }
- else
- {
-
- // the neighbor is coarser.
- // this is the most complicated
- // case. It might be, that the
- // neighbor's face will be
- // refined, but that we will
- // not see this, as we are
- // refined in a similar way.
-
- // so, the neighbor's face must
- // have children. check, if our
- // cell's face is one of these
- // (it could also be a
- // grand_child)
- for (unsigned int c=0; c<neighbor_face->n_children(); ++c)
- if (neighbor_face->child_index(c)==this_face_index)
- {
- // if the flagged refine
- // case of the face is a
- // subset or the same as
- // the current refine case,
- // then the face, as seen
- // from our cell, won't be
- // refined by the neighbor
- if ((neighbor_face->refinement_case() | face_ref_case)
- == neighbor_face->refinement_case())
- return false;
- else
- {
- // if we are active, we
- // must be an
- // anisotropic child
- // and the coming
- // face_ref_case is
- // isotropic. Thus,
- // from our cell we
- // will see exactly the
- // opposite refine case
- // that the face has
- // now...
- Assert(face_ref_case==RefinementCase<dim-1>::isotropic_refinement, ExcInternalError());
- expected_face_ref_case = ~neighbor_face->refinement_case();
- return true;
- }
- }
-
- // so, obviously we were not
- // one of the children, but a
- // grandchild. This is only
- // possible in 3d.
- Assert(dim==3, ExcInternalError());
- // In that case, however, no
- // matter what the neighbor
- // does, he won't be finer
- // after the next refinement
- // step.
- return false;
- }
- }// if face will be refined
- }// if neighbor is flagged for refinement
-
- // no cases left, so the neighbor will not
- // refine the face
- return false;
- }
-
- // version of above function for both active
- // and non-active cells
- template <int dim, int spacedim>
- bool
- face_will_be_refined_by_neighbor(const TriaIterator<dealii::CellAccessor<dim, spacedim> > &cell,
- const unsigned int face_no)
- {
- RefinementCase<dim-1> dummy = RefinementCase<dim-1>::no_refinement;
- return face_will_be_refined_by_neighbor_internal(cell, face_no, dummy);
- }
-
- // version of above function for active cells
- // only. Additionally returning the refine
- // case (to come) of the face under
- // consideration
- template <int dim, int spacedim>
- bool
- face_will_be_refined_by_neighbor(const TriaActiveIterator<dealii::CellAccessor<dim,spacedim> > &cell,
- const unsigned int face_no,
- RefinementCase<dim-1> &expected_face_ref_case)
- {
- return face_will_be_refined_by_neighbor_internal(cell, face_no,
- expected_face_ref_case);
- }
-
-
-
- template <int dim, int spacedim>
- bool
- satisfies_level1_at_vertex_rule (const Triangulation<dim,spacedim> &triangulation)
- {
- std::vector<unsigned int> min_adjacent_cell_level (triangulation.n_vertices(),
- triangulation.n_levels());
- std::vector<unsigned int> max_adjacent_cell_level (triangulation.n_vertices(),
- 0);
-
- for (typename Triangulation<dim,spacedim>::active_cell_iterator
- cell = triangulation.begin_active();
- cell != triangulation.end(); ++cell)
- for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell; ++v)
- {
- min_adjacent_cell_level[cell->vertex_index(v)]
- = std::min<unsigned int>
- (min_adjacent_cell_level[cell->vertex_index(v)],
- cell->level());
- max_adjacent_cell_level[cell->vertex_index(v)]
- = std::max<unsigned int> (min_adjacent_cell_level[cell->vertex_index(v)],
- cell->level());
- }
-
- for (unsigned int k=0; k<triangulation.n_vertices(); ++k)
- if (triangulation.vertex_used(k))
- if (max_adjacent_cell_level[k] -
- min_adjacent_cell_level[k] > 1)
- return false;
- return true;
- }
-
-
-
- /**
- * Fill the vector @p line_cell_count
- * needed by @p delete_children with the
- * number of cells bounded by a given
- * line.
- */
- template <int dim, int spacedim>
- std::vector<unsigned int>
- count_cells_bounded_by_line (const Triangulation<dim,spacedim> &triangulation)
- {
- if (dim >= 2)
- {
- std::vector<unsigned int> line_cell_count(triangulation.n_raw_lines(),0);
- typename Triangulation<dim,spacedim>::cell_iterator
- cell=triangulation.begin(),
- endc=triangulation.end();
- for (; cell!=endc; ++cell)
- for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
- ++line_cell_count[cell->line_index(l)];
- return line_cell_count;
- }
- else
- return std::vector<unsigned int>();
- }
-
-
-
-
- /**
- * Fill the vector @p quad_cell_count
- * needed by @p delete_children with the
- * number of cells bounded by a given
- * quad.
- */
- template <int dim, int spacedim>
- std::vector<unsigned int>
- count_cells_bounded_by_quad (const Triangulation<dim,spacedim> &triangulation)
- {
- if (dim >= 3)
- {
- std::vector<unsigned int> quad_cell_count (triangulation.n_raw_quads(),0);
- typename Triangulation<dim,spacedim>::cell_iterator
- cell=triangulation.begin(),
- endc=triangulation.end();
- for (; cell!=endc; ++cell)
- for (unsigned int q=0; q<GeometryInfo<dim>::faces_per_cell; ++q)
- ++quad_cell_count[cell->quad_index(q)];
- return quad_cell_count;
- }
- else
- return std::vector<unsigned int>();
- }
-
-
- /**
- * For a given Triangulation, update the
- * number cache for lines. For 1d, we have
- * to deal with the fact that lines have
- * levels, whereas for higher dimensions
- * they do not.
- *
- * The second argument indicates
- * for how many levels the
- * Triangulation has objects,
- * though the highest levels need
- * not contain active cells if they
- * have previously all been
- * coarsened away.
- */
- template <int dim, int spacedim>
- void compute_number_cache (const Triangulation<dim,spacedim> &triangulation,
- const unsigned int level_objects,
- internal::Triangulation::NumberCache<1> &number_cache)
- {
- typedef
- typename Triangulation<dim,spacedim>::line_iterator line_iterator;
- typedef
- typename Triangulation<dim,spacedim>::active_line_iterator active_line_iterator;
-
- number_cache.n_levels = 0;
- if (level_objects > 0)
- {
- // check whether there are
- // cells on the highest
- // levels (there need not be,
- // since they might all have
- // been coarsened away)
- typename Triangulation<dim,spacedim>::raw_cell_iterator
- cell = triangulation.last_raw (level_objects-1),
- endc = triangulation.end();
- for (; cell!=endc; --cell)
- if (cell->used())
- {
- // return level of most
- // refined existing cell
- // (+1 because of
- // counting conventions)
- number_cache.n_levels = cell->level()+1;
- break;
- }
-
- // 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_level.resize (number_cache.n_levels);
- number_cache.n_lines = 0;
-
- number_cache.n_active_lines_level.resize (number_cache.n_levels);
- number_cache.n_active_lines = 0;
-
- // for 1d, lines have levels so take
- // count the objects per level and
- // globally
- if (dim == 1)
- {
- for (unsigned int level=0; level<number_cache.n_levels; ++level)
- {
- // count lines on this level
- number_cache.n_lines_level[level] = 0;
-
- line_iterator line = triangulation.begin_line (level),
- endc = (level == number_cache.n_levels-1 ?
- line_iterator(triangulation.end_line()) :
- triangulation.begin_line (level+1));
- for (; line!=endc; ++line)
- ++number_cache.n_lines_level[level];
-
- // update total number of lines
- number_cache.n_lines += number_cache.n_lines_level[level];
- }
-
- // do the update for the number of
- // active lines as well
- for (unsigned int level=0; level<number_cache.n_levels; ++level)
- {
- // count lines on this level
- number_cache.n_active_lines_level[level] = 0;
-
- active_line_iterator line = triangulation.begin_active_line (level),
- endc = triangulation.end_active_line (level);
- for (; line!=endc; ++line)
- ++number_cache.n_active_lines_level[level];
-
- // update total number of lines
- number_cache.n_active_lines += number_cache.n_active_lines_level[level];
- }
- }
- else
- {
- // for dim>1, there are no
- // levels for lines
- {
- line_iterator line = triangulation.begin_line (),
- endc = triangulation.end_line();
- for (; line!=endc; ++line)
- ++number_cache.n_lines;
- }
-
- {
- active_line_iterator line = triangulation.begin_active_line (),
- endc = triangulation.end_line();
- for (; line!=endc; ++line)
- ++number_cache.n_active_lines;
- }
- }
- }
-
- /**
- * For a given Triangulation, update the
- * number cache for quads. For 2d, we have
- * to deal with the fact that quads have
- * levels, whereas for higher dimensions
- * they do not.
- *
- * The second argument indicates
- * for how many levels the
- * Triangulation has objects,
- * though the highest levels need
- * not contain active cells if they
- * have previously all been
- * coarsened away.
- *
- * At the beginning of the function, we call the
- * respective function to update the number
- * cache for lines.
- */
- template <int dim, int spacedim>
- void compute_number_cache (const Triangulation<dim,spacedim> &triangulation,
- const unsigned int level_objects,
- internal::Triangulation::NumberCache<2> &number_cache)
- {
- // update lines and n_levels
- compute_number_cache (triangulation,
- level_objects,
- static_cast<internal::Triangulation::NumberCache<1>&>
- (number_cache));
-
- typedef
- typename Triangulation<dim,spacedim>::quad_iterator quad_iterator;
- typedef
- typename Triangulation<dim,spacedim>::active_quad_iterator active_quad_iterator;
-
- ///////////////////////////////////
- // update the number of quads
- // on the different levels in
- // the cache
- number_cache.n_quads_level.resize (number_cache.n_levels);
- number_cache.n_quads = 0;
-
- number_cache.n_active_quads_level.resize (number_cache.n_levels);
- number_cache.n_active_quads = 0;
-
- // for 2d, quads have levels so take
- // count the objects per level and
- // globally
- if (dim == 2)
- {
- for (unsigned int level=0; level<number_cache.n_levels; ++level)
- {
- // count quads on this level
- number_cache.n_quads_level[level] = 0;
-
- quad_iterator quad = triangulation.begin_quad (level),
- endc = (level == number_cache.n_levels-1 ?
- quad_iterator(triangulation.end_quad()) :
- triangulation.begin_quad (level+1));
- for (; quad!=endc; ++quad)
- ++number_cache.n_quads_level[level];
-
- // update total number of quads
- number_cache.n_quads += number_cache.n_quads_level[level];
- }
-
- // do the update for the number of
- // active quads as well
- for (unsigned int level=0; level<number_cache.n_levels; ++level)
- {
- // count quads on this level
- number_cache.n_active_quads_level[level] = 0;
-
- active_quad_iterator quad = triangulation.begin_active_quad (level),
- endc = triangulation.end_active_quad (level);
- for (; quad!=endc; ++quad)
- ++number_cache.n_active_quads_level[level];
-
- // update total number of quads
- number_cache.n_active_quads += number_cache.n_active_quads_level[level];
- }
- }
- else
- {
- // for dim>2, there are no
- // levels for quads
- {
- quad_iterator quad = triangulation.begin_quad (),
- endc = triangulation.end_quad();
- for (; quad!=endc; ++quad)
- ++number_cache.n_quads;
- }
-
- {
- active_quad_iterator quad = triangulation.begin_active_quad (),
- endc = triangulation.end_quad();
- for (; quad!=endc; ++quad)
- ++number_cache.n_active_quads;
- }
- }
- }
-
- /**
- * For a given Triangulation, update the
- * number cache for hexes. For 3d, we have
- * to deal with the fact that hexes have
- * levels, whereas for higher dimensions
- * they do not.
- *
- * The second argument indicates
- * for how many levels the
- * Triangulation has objects,
- * though the highest levels need
- * not contain active cells if they
- * have previously all been
- * coarsened away.
- *
- * At the end of the function, we call the
- * respective function to update the number
- * cache for quads, which will in turn call
- * the respective function for lines.
- */
- template <int dim, int spacedim>
- void compute_number_cache (const Triangulation<dim,spacedim> &triangulation,
- const unsigned int level_objects,
- internal::Triangulation::NumberCache<3> &number_cache)
- {
- // update quads, lines and n_levels
- compute_number_cache (triangulation,
- level_objects,
- static_cast<internal::Triangulation::NumberCache<2>&>
- (number_cache));
-
- typedef
- typename Triangulation<dim,spacedim>::hex_iterator hex_iterator;
- typedef
- typename Triangulation<dim,spacedim>::active_hex_iterator active_hex_iterator;
-
- ///////////////////////////////////
- // update the number of hexes
- // on the different levels in
- // the cache
- number_cache.n_hexes_level.resize (number_cache.n_levels);
- number_cache.n_hexes = 0;
-
- number_cache.n_active_hexes_level.resize (number_cache.n_levels);
- number_cache.n_active_hexes = 0;
-
- // for 3d, hexes have levels so take
- // count the objects per level and
- // globally
- if (dim == 3)
- {
- for (unsigned int level=0; level<number_cache.n_levels; ++level)
- {
- // count hexes on this level
- number_cache.n_hexes_level[level] = 0;
-
- hex_iterator hex = triangulation.begin_hex (level),
- endc = (level == number_cache.n_levels-1 ?
- hex_iterator(triangulation.end_hex()) :
- triangulation.begin_hex (level+1));
- for (; hex!=endc; ++hex)
- ++number_cache.n_hexes_level[level];
-
- // update total number of hexes
- number_cache.n_hexes += number_cache.n_hexes_level[level];
- }
-
- // do the update for the number of
- // active hexes as well
- for (unsigned int level=0; level<number_cache.n_levels; ++level)
- {
- // count hexes on this level
- number_cache.n_active_hexes_level[level] = 0;
-
- active_hex_iterator hex = triangulation.begin_active_hex (level),
- endc = triangulation.end_active_hex (level);
- for (; hex!=endc; ++hex)
- ++number_cache.n_active_hexes_level[level];
-
- // update total number of hexes
- number_cache.n_active_hexes += number_cache.n_active_hexes_level[level];
- }
- }
- else
- {
- // for dim>3, there are no
- // levels for hexs
- {
- hex_iterator hex = triangulation.begin_hex (),
- endc = triangulation.end_hex();
- for (; hex!=endc; ++hex)
- ++number_cache.n_hexes;
- }
-
- {
- active_hex_iterator hex = triangulation.begin_active_hex (),
- endc = triangulation.end_hex();
- for (; hex!=endc; ++hex)
- ++number_cache.n_active_hexes;
- }
- }
- }
-
-
-
- /**
- * A set of three functions that
- * reorder the data given to
- * create_triangulation_compatibility
- * from the "classic" to the
- * "current" format of vertex
- * numbering of cells and
- * faces. These functions do the
- * reordering of their arguments
- * in-place.
- */
- void
- reorder_compatibility (const std::vector<CellData<1> > &,
- const SubCellData &)
- {
- // nothing to do here: the format
- // hasn't changed for 1d
- }
-
-
- void
- reorder_compatibility (std::vector<CellData<2> > &cells,
- const SubCellData &)
- {
- for (unsigned int cell=0; cell<cells.size(); ++cell)
- std::swap(cells[cell].vertices[2],cells[cell].vertices[3]);
- }
-
-
- void
- reorder_compatibility (std::vector<CellData<3> > &cells,
- SubCellData &subcelldata)
- {
- unsigned int tmp[GeometryInfo<3>::vertices_per_cell];
- for (unsigned int cell=0; cell<cells.size(); ++cell)
- {
- for (unsigned int i=0; i<GeometryInfo<3>::vertices_per_cell; ++i)
- tmp[i] = cells[cell].vertices[i];
- for (unsigned int i=0; i<GeometryInfo<3>::vertices_per_cell; ++i)
- cells[cell].vertices[GeometryInfo<3>::ucd_to_deal[i]] = tmp[i];
- }
-
- // now points in boundary quads
- std::vector<CellData<2> >::iterator boundary_quad
- = subcelldata.boundary_quads.begin();
- std::vector<CellData<2> >::iterator end_quad
- = subcelldata.boundary_quads.end();
- for (unsigned int quad_no=0; boundary_quad!=end_quad; ++boundary_quad, ++quad_no)
- std::swap(boundary_quad->vertices[2], boundary_quad->vertices[3]);
- }
-
-
-
- /**
- * Return the index of the vertex
- * in the middle of this object,
- * if it exists. In order to
- * exist, the object needs to be
- * refined - for 2D and 3D it
- * needs to be refined
- * isotropically or else the
- * anisotropic children have to
- * be refined again. If the
- * middle vertex does not exist,
- * return
- * <tt>numbers::invalid_unsigned_int</tt>.
- *
- * This function should not really be
- * used in application programs.
- */
- template <int dim, int spacedim>
- unsigned int
- middle_vertex_index(const typename Triangulation<dim,spacedim>::line_iterator &line)
- {
- if (line->has_children())
- return line->child(0)->vertex_index(1);
- return numbers::invalid_unsigned_int;
- }
-
-
- template <int dim, int spacedim>
- unsigned int
- middle_vertex_index(const typename Triangulation<dim,spacedim>::quad_iterator &quad)
- {
- switch (static_cast<unsigned char> (quad->refinement_case()))
- {
- case RefinementCase<2>::cut_x:
- return middle_vertex_index<dim,spacedim>(quad->child(0)->line(1));
- break;
- case RefinementCase<2>::cut_y:
- return middle_vertex_index<dim,spacedim>(quad->child(0)->line(3));
- break;
- case RefinementCase<2>::cut_xy:
- return quad->child(0)->vertex_index(3);
- break;
- default:
- break;
- }
- return numbers::invalid_unsigned_int;
- }
-
-
- template <int dim, int spacedim>
- unsigned int
- middle_vertex_index(const typename Triangulation<dim,spacedim>::hex_iterator &hex)
- {
- switch (static_cast<unsigned char> (hex->refinement_case()))
- {
- case RefinementCase<3>::cut_x:
- return middle_vertex_index<dim,spacedim>(hex->child(0)->quad(1));
- break;
- case RefinementCase<3>::cut_y:
- return middle_vertex_index<dim,spacedim>(hex->child(0)->quad(3));
- break;
- case RefinementCase<3>::cut_z:
- return middle_vertex_index<dim,spacedim>(hex->child(0)->quad(5));
- break;
- case RefinementCase<3>::cut_xy:
- return middle_vertex_index<dim,spacedim>(hex->child(0)->line(11));
- break;
- case RefinementCase<3>::cut_xz:
- return middle_vertex_index<dim,spacedim>(hex->child(0)->line(5));
- break;
- case RefinementCase<3>::cut_yz:
- return middle_vertex_index<dim,spacedim>(hex->child(0)->line(7));
- break;
- case RefinementCase<3>::cut_xyz:
- return hex->child(0)->vertex_index(7);
- break;
- default:
- break;
- }
- return numbers::invalid_unsigned_int;
- }
-
-
- /**
- * Collect all coarse mesh cells
- * with at least one vertex at
- * which the determinant of the
- * Jacobian is zero or
- * negative. This is the function
- * for the case dim==spacedim.
- */
- template <int dim>
- typename Triangulation<dim,dim>::DistortedCellList
- collect_distorted_coarse_cells (const Triangulation<dim,dim> &triangulation)
- {
- typename Triangulation<dim,dim>::DistortedCellList distorted_cells;
- for (typename Triangulation<dim,dim>::cell_iterator
- cell = triangulation.begin(0); cell != triangulation.end(0); ++cell)
- {
- Point<dim> vertices[GeometryInfo<dim>::vertices_per_cell];
- for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_cell; ++i)
- vertices[i] = cell->vertex(i);
-
- Tensor<0,dim> determinants[GeometryInfo<dim>::vertices_per_cell];
- GeometryInfo<dim>::alternating_form_at_vertices (vertices,
- determinants);
-
- for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_cell; ++i)
- if (determinants[i] <= 1e-9 * std::pow (cell->diameter(),
- 1.*dim))
- {
- distorted_cells.distorted_cells.push_back (cell);
- break;
- }
- }
-
- return distorted_cells;
- }
-
-
- /**
- * Collect all coarse mesh cells
- * with at least one vertex at
- * which the determinant of the
- * Jacobian is zero or
- * negative. This is the function
- * for the case dim!=spacedim,
- * where we can not determine
- * whether a cell is twisted as it
- * may, for example, discretize a
- * manifold with a twist.
- */
- template <int dim, int spacedim>
- typename Triangulation<dim,spacedim>::DistortedCellList
- collect_distorted_coarse_cells (const Triangulation<dim,spacedim> &)
- {
- return typename Triangulation<dim,spacedim>::DistortedCellList();
- }
-
-
-
- /**
- * Return whether any of the
- * children of the given cell is
- * distorted or not. This is the
- * function for dim==spacedim.
- */
- template <int dim>
- bool
- has_distorted_children (const typename Triangulation<dim,dim>::cell_iterator &cell,
- internal::int2type<dim>,
- internal::int2type<dim>)
- {
- Assert (cell->has_children(), ExcInternalError());
-
- for (unsigned int c=0; c<cell->n_children(); ++c)
- {
- Point<dim> vertices[GeometryInfo<dim>::vertices_per_cell];
- for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_cell; ++i)
- vertices[i] = cell->child(c)->vertex(i);
-
- Tensor<0,dim> determinants[GeometryInfo<dim>::vertices_per_cell];
- GeometryInfo<dim>::alternating_form_at_vertices (vertices,
- determinants);
-
- for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_cell; ++i)
- if (determinants[i] <= 1e-9 * std::pow (cell->child(c)->diameter(),
- 1.*dim))
- return true;
- }
-
- return false;
- }
-
-
- /**
- * Function for dim!=spacedim. As
- * for
- * collect_distorted_coarse_cells,
- * there is nothing that we can do
- * in this case.
- */
- template <int dim, int spacedim>
- bool
- has_distorted_children (const typename Triangulation<dim,spacedim>::cell_iterator &,
- internal::int2type<dim>,
- internal::int2type<spacedim>)
- {
- return false;
- }
-
-
-
- /**
- * For a given triangulation: set up the
- * neighbor information on all cells.
- */
- template <int dim, int spacedim>
- void
- update_neighbors (Triangulation<dim,spacedim> &triangulation)
- {
- // each face can be neighbored on two sides
- // by cells. according to the face's
- // intrinsic normal we define the left
- // neighbor as the one for which the face
- // normal points outward, and store that
- // one first, with an offset of one we
- // store the right neighbor for which the
- // face normal points inward. This
- // information depends on the type of cell
- // and local number of face for the
- // 'standard ordering and orientation' of
- // faces and then on the face_orientation
- // information for the real mesh. Set up a
- // table to have fast access to those
- // offsets (0 for left and 1 for
- // right). Some of the values are invalid
- // as they reference too large face
- // numbers, but we just leave them at a
- // zero value.
- //
- // Note, that in 2d for lines as faces the
- // normal direction given in the
- // GeometryInfo class is not consistent. We
- // thus define here that the normal for a
- // line points to the right if the line
- // points upwards.
- //
- // first index: dimension (minus 2)
- // second index: local face index
- // third index: face_orientation (false and true)
- static const unsigned int left_right_offset[2][6][2] =
- {
- // quadrilateral
- {{0,1}, // face 0, face_orientation = false and true
- {1,0}, // face 1, face_orientation = false and true
- {1,0}, // face 2, face_orientation = false and true
- {0,1}, // face 3, face_orientation = false and true
- {0,0}, // face 4, invalid face
- {0,0}},// face 5, invalid face
- // hexahedron
- {{0,1},
- {1,0},
- {0,1},
- {1,0},
- {0,1},
- {1,0}}};
-
- // now create a vector of the two active
- // neighbors (left and right) for each face
- // and fill it by looping over all cells. For
- // cases with anisotropic refinement and more
- // then one cell neighboring at a given side
- // of the face we will automatically get the
- // active one on the highest level as we loop
- // over cells from lower levels first.
- const typename Triangulation<dim,spacedim>::cell_iterator dummy;
- std::vector<typename Triangulation<dim,spacedim>::cell_iterator>
- adjacent_cells(2*triangulation.n_raw_faces(), dummy);
-
- typename Triangulation<dim,spacedim>::cell_iterator
- cell = triangulation.begin(),
- endc = triangulation.end();
- for (; cell != endc; ++cell)
- for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
- {
- const typename Triangulation<dim,spacedim>::face_iterator face=cell->face(f);
- const unsigned int offset=left_right_offset[dim-2][f][cell->face_orientation(f)];
- adjacent_cells[2*face->index() + offset] = cell;
- // if this cell is not refined, but the
- // face is, then we'll have to set our
- // cell as neighbor for the cild faces
- // as well. Fortunately the normal
- // orientation of children will be just
- // the same.
- if (dim==2)
- {
- if (cell->active() && face->has_children())
- {
- adjacent_cells[2*face->child(0)->index() + offset] = cell;
- adjacent_cells[2*face->child(1)->index() + offset] = cell;
- }
- }
- else // -> dim == 3
- {
- // We need the same as in 2d
- // here. Furthermore, if the face is
- // refined with cut_x or cut_y then
- // those children again in the other
- // direction, and if this cell is
- // refined isotropically (along the
- // face) then the neighbor will
- // (probably) be refined as cut_x or
- // cut_y along the face. For those
- // neighboring children cells, their
- // neighbor will be the current,
- // inactive cell, as our children are
- // too fine to be neighbors. Catch that
- // case by also acting on inactive
- // cells with isotropic refinement
- // along the face. If the situation
- // described is not present, the data
- // will be overwritten later on when we
- // visit cells on finer levels, so no
- // harm will be done.
- if (face->has_children() &&
- (cell->active() ||
- GeometryInfo<dim>::face_refinement_case(cell->refinement_case(),f) == RefinementCase<dim-1>::isotropic_refinement))
- {
-
- for (unsigned int c=0; c<face->n_children(); ++c)
- adjacent_cells[2*face->child(c)->index() + offset] = cell;
- if (face->child(0)->has_children())
- {
- adjacent_cells[2*face->child(0)->child(0)->index() + offset] = cell;
- adjacent_cells[2*face->child(0)->child(1)->index() + offset] = cell;
- }
- if (face->child(1)->has_children())
- {
- adjacent_cells[2*face->child(1)->child(0)->index() + offset] = cell;
- adjacent_cells[2*face->child(1)->child(1)->index() + offset] = cell;
- }
- } // if cell active and face refined
- } // else -> dim==3
- } // for all faces of all cells
-
- // now loop again over all cells and set the
- // corresponding neighbor cell. Note, that we
- // have to use the opposite of the
- // left_right_offset in this case as we want
- // the offset of the neighbor, not our own.
- for (cell=triangulation.begin(); cell != endc; ++cell)
- for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
- cell->set_neighbor(f,
- adjacent_cells[2*cell->face(f)->index() + 1
- - left_right_offset[dim-2][f][cell->face_orientation(f)]]);
- }
-
-}// end of anonymous namespace
-
-
-namespace internal
-{
- namespace Triangulation
- {
- // make sure that if in the following we
- // write Triangulation<dim,spacedim>
- // we mean the *class*
- // dealii::Triangulation, not the
- // enclosing namespace
- // internal::Triangulation
- using dealii::Triangulation;
-
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException0 (ExcCellShouldBeUnused);
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException0 (ExcTooFewVerticesAllocated);
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException0 (ExcUncaughtState);
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException2 (ExcGridsDoNotMatch,
- int, int,
- << "The present grid has " << arg1 << " active cells, "
- << "but the one in the file had " << arg2);
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException1 (ExcGridHasInvalidCell,
- int,
- << "Something went wrong when making cell " << arg1
- << ". Read the docs and the source code "
- << "for more information.");
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException0 (ExcGridHasInvalidVertices);
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException1 (ExcInternalErrorOnCell,
- int,
- << "Something went wrong upon construction of cell "
- << arg1);
- /**
- * A cell was entered which has
- * negative measure. In most
- * cases, this is due to a wrong
- * order of the vertices of the
- * cell.
- *
- * @ingroup Exceptions
- */
- DeclException1 (ExcCellHasNegativeMeasure,
- int,
- << "Cell " << arg1 << " has negative measure.");
- /**
- * A cell is created with a
- * vertex number exceeding the
- * vertex array.
- *
- * @ingroup Exceptions
- */
- DeclException3 (ExcInvalidVertexIndex,
- int, int, int,
- << "Error while creating cell " << arg1
- << ": the vertex index " << arg2 << " must be between 0 and "
- << arg3 << ".");
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException2 (ExcLineInexistant,
- int, int,
- << "When trying to give a boundary indicator to a line: "
- << "the line with end vertices " << arg1 << " and "
- << arg2 << " does not exist.");
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException4 (ExcQuadInexistant,
- int, int, int, int,
- << "When trying to give a boundary indicator to a quad: "
- << "the quad with bounding lines " << arg1 << ", " << arg2
- << ", " << arg3 << ", " << arg4 << " does not exist.");
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException0 (ExcInteriorLineCantBeBoundary);
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException0 (ExcInteriorQuadCantBeBoundary);
- /**
- * Exception
- * @ingroup Exceptions
- */
- DeclException2 (ExcMultiplySetLineInfoOfLine,
- int, int,
- << "In SubCellData the line info of the line with vertex indices "
- << arg1 << " and " << arg2 << " is multiply set.");
-
-
-/**
- * A class into which we put many of the functions that implement
- * functionality of the Triangulation class. The main reason for this
- * class is as follows: the majority of the functions in Triangulation
- * need to be implemented differently for dim==1, dim==2, and
- * dim==3. However, their implementation is largly independent of the
- * spacedim template parameter. So we would like to write things like
- *
- * template <int spacedim>
- * void Triangulation<1,spacedim>::create_triangulation (...) {...}
- *
- * Unfortunately, C++ doesn't allow this: member functions of class
- * templates have to be either not specialized at all, or fully
- * specialized. No partial specialization is allowed. One possible
- * solution would be to just duplicate the bodies of the functions and
- * have equally implemented functions
- *
- * template <>
- * void Triangulation<1,1>::create_triangulation (...) {...}
- *
- * template <>
- * void Triangulation<1,2>::create_triangulation (...) {...}
- *
- * but that is clearly an unsatisfactory solution. Rather, what we do
- * is introduce the current Implementation class in which we can write
- * these functions as member templates over spacedim, i.e. we can have
- *
- * template <int dim_, int spacedim_>
- * template <int spacedim>
- * void Triangulation<dim_,spacedim_>::Implementation::
- * create_triangulation (...,
- * Triangulation<1,spacedim> &tria ) {...}
- *
- * The outer template parameters are here unused, only the inner
- * ones are of real interest.
- *
- * One may ask why we put these functions into an class rather
- * than an anonymous namespace, for example?
- *
- * First, these implementation functions need to be friends of the
- * Triangulation class. It is simpler to make the entire class a friend
- * rather than listing all members of an implementation namespace as
- * friends of the Triangulation class (there is no such thing as a "friend
- * namespace XXX" directive).
- *
- * Ideally, we would make this class a member class of the
- * Triangulation<dim,spacedim> class, since then our implementation functions
- * have immediate access to the typedefs and static functions of the
- * surrounding Triangulation class. I.e., we do not have to write "typename
- * Triangulation<dim,spacedim>::active_cell_iterator" but can write
- * "active_cell_iterator" right away. This is, in fact, the way it was
- * implemented first, but we ran into a bug in gcc4.0:
- * @code
- * class Triangulation {
- * struct Implementation;
- * friend class TriaAccessor;
- * };
- *
- * class TriaAccessor {
- * struct Implementation;
- * friend class Triangulation;
- * };
- * @endcode
- *
- * Here, friendship (per C++ standard) is supposed to extend to all members of
- * the befriended class, including its 'Implementation' member class. But gcc4.0
- * gets this wrong: the members of Triangulation::Implementation are not friends
- * of TriaAccessor and the other way around. Ideally, one would fix this by
- * saying
- * @code
- * class Triangulation {
- * struct Implementation;
- * friend class TriaAccessor;
- * friend class TriaAccessor::Implementation; // **
- * };
- *
- * class TriaAccessor {
- * struct Implementation;
- * friend class Triangulation;
- * friend class Triangulation::Implementation;
- * };
- * @endcode
- * but that's not legal because in ** we don't know yet that TriaAccessor has
- * a member class Implementation and so we can't make it a friend. The only
- * way forward at this point was to make Implementation a class in the
- * internal namespace so that we can forward declare it and make it a friend
- * of the respective other outer class -- not quite what we wanted but the
- * only way I could see to make it work...
- */
- struct Implementation
- {
- /**
- * Create a triangulation from
- * given data. This function does
- * this work for 1-dimensional
- * triangulations independently
- * of the actual space dimension.
- */
- template <int spacedim>
- static
- void
- create_triangulation (const std::vector<Point<spacedim> > &v,
- const std::vector<CellData<1> > &cells,
- const SubCellData &/*subcelldata*/,
- Triangulation<1,spacedim> &triangulation)
- {
- // note: since no boundary
- // information can be given in one
- // dimension, the @p{subcelldata}
- // field is ignored. (only used for
- // error checking, which is a good
- // idea in any case)
- const unsigned int dim=1;
-
- // copy vertices
- triangulation.vertices = v;
- triangulation.vertices_used = std::vector<bool> (v.size(), true);
-
- // store the indices of the lines
- // which are adjacent to a given
- // vertex
- std::vector<std::vector<int> > lines_at_vertex (v.size());
-
- // reserve enough space
- triangulation.levels.push_back (new internal::Triangulation::TriaLevel<dim>);
- triangulation.levels[0]->reserve_space (cells.size(), dim);
- triangulation.levels[0]->cells.reserve_space (0,cells.size());
-
- // make up cells
- typename Triangulation<dim,spacedim>::raw_line_iterator
- next_free_line = triangulation.begin_raw_line ();
- for (unsigned int cell=0; cell<cells.size(); ++cell)
- {
- while (next_free_line->used())
- ++next_free_line;
-
- next_free_line->set (internal::Triangulation
- ::TriaObject<1> (cells[cell].vertices[0],
- cells[cell].vertices[1]));
- next_free_line->set_used_flag ();
- next_free_line->set_material_id (cells[cell].material_id);
- next_free_line->clear_user_data ();
- next_free_line->set_subdomain_id (0);
-
- // note that this cell is
- // adjacent to these vertices
- lines_at_vertex[cells[cell].vertices[0]].push_back (cell);
- lines_at_vertex[cells[cell].vertices[1]].push_back (cell);
- }
-
-
- // some security tests
- {
- unsigned int boundary_nodes = 0;
- for (unsigned int i=0; i<lines_at_vertex.size(); ++i)
- switch (lines_at_vertex[i].size())
- {
- case 1:
- // this vertex has only
- // one adjacent line
- ++boundary_nodes;
- break;
- case 2:
- break;
- default:
- // a node must have one
- // or two adjacent
- // lines
- AssertThrow (false, ExcInternalError());
- }
-
- // assert there are no more
- // than two boundary
- // nodes. note that if the
- // space dimension is
- // bigger than 1, then we
- // can have fewer than 2
- // nodes (for example a
- // ring of cells -- no end
- // points at all)
- AssertThrow (((spacedim == 1) && (boundary_nodes == 2))
- ||
- (spacedim > 1),
- ExcMessage("The Triangulation has too many end points"));
- }
-
-
-
- // update neighborship info
- typename Triangulation<dim,spacedim>::active_line_iterator
- line = triangulation.begin_active_line ();
- // for all lines
- for (; line!=triangulation.end(); ++line)
- // for each of the two vertices
- for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
- // if first cell adjacent to
- // this vertex is the present
- // one, then the neighbor is
- // the second adjacent cell and
- // vice versa
- if (lines_at_vertex[line->vertex_index(vertex)][0] == line->index())
- if (lines_at_vertex[line->vertex_index(vertex)].size() == 2)
- {
- const typename Triangulation<dim,spacedim>::cell_iterator
- neighbor (&triangulation,
- 0, // level
- lines_at_vertex[line->vertex_index(vertex)][1]);
- line->set_neighbor (vertex, neighbor);
- }
- else
- // no second adjacent cell
- // entered -> cell at
- // boundary
- line->set_neighbor (vertex, triangulation.end());
- else
- // present line is not first
- // adjacent one -> first
- // adjacent one is neighbor
- {
- const typename Triangulation<dim,spacedim>::cell_iterator
- neighbor (&triangulation,
- 0, // level
- lines_at_vertex[line->vertex_index(vertex)][0]);
- line->set_neighbor (vertex, neighbor);
- }
- }
-
-
- /**
- * Create a triangulation from
- * given data. This function does
- * this work for 2-dimensional
- * triangulations independently
- * of the actual space dimension.
- */
- template <int spacedim>
- static
- void
- create_triangulation (const std::vector<Point<spacedim> > &v,
- const std::vector<CellData<2> > &cells,
- const SubCellData &subcelldata,
- Triangulation<2,spacedim> &triangulation)
- {
- const unsigned int dim=2;
-
- // copy vertices
- triangulation.vertices = v;
- triangulation.vertices_used = std::vector<bool> (v.size(), true);
-
- // make up a list of the needed
- // lines each line is a pair of
- // vertices. The list is kept
- // sorted and it is guaranteed that
- // each line is inserted only once.
- // While the key of such an entry
- // is the pair of vertices, the
- // thing it points to is an
- // iterator pointing to the line
- // object itself. In the first run,
- // these iterators are all invalid
- // ones, but they are filled
- // afterwards
- std::map<std::pair<int,int>,
- typename Triangulation<dim,spacedim>::line_iterator> needed_lines;
- for (unsigned int cell=0; cell<cells.size(); ++cell)
- {
- for (unsigned int vertex=0; vertex<4; ++vertex)
- AssertThrow (cells[cell].vertices[vertex] < triangulation.vertices.size(),
- ExcInvalidVertexIndex (cell, cells[cell].vertices[vertex],
- triangulation.vertices.size()));
-
- for (unsigned int line=0; line<GeometryInfo<dim>::faces_per_cell; ++line)
- {
- // given a line vertex number
- // (0,1) on a specific line we
- // get the cell vertex number
- // (0-4) through the
- // line_to_cell_vertices
- // function
- std::pair<int,int> line_vertices(
- cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
- cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)]);
-
- // assert that the line was
- // not already inserted in
- // reverse order. This
- // happens in spite of the
- // vertex rotation above,
- // if the sense of the cell
- // was incorrect.
- //
- // Here is what usually
- // happened when this
- // exception is thrown:
- // consider these two cells
- // and the vertices
- // 3---4---5
- // | | |
- // 0---1---2
- // If in the input vector
- // the two cells are given
- // with vertices <0 1 4 3>
- // and <4 1 2 5>, in the
- // first cell the middle
- // line would have
- // direction 1->4, while in
- // the second it would be
- // 4->1. This will cause
- // the exception.
- AssertThrow (needed_lines.find(std::make_pair(line_vertices.second,
- line_vertices.first))
- ==
- needed_lines.end(),
- ExcGridHasInvalidCell(cell));
-
- // insert line, with
- // invalid iterator if line
- // already exists, then
- // nothing bad happens here
- needed_lines[line_vertices] = triangulation.end_line();
- }
- }
-
-
- // check that every vertex has at
- // least two adjacent lines
- {
- std::vector<unsigned short int> vertex_touch_count (v.size(), 0);
- typename std::map<std::pair<int,int>,
- typename Triangulation<dim,spacedim>::line_iterator>::iterator i;
- for (i=needed_lines.begin(); i!=needed_lines.end(); i++)
- {
- // touch the vertices of
- // this line
- ++vertex_touch_count[i->first.first];
- ++vertex_touch_count[i->first.second];
- }
-
- // assert minimum touch count
- // is at least two. if not so,
- // then clean triangulation and
- // exit with an exception
- AssertThrow (* (std::min_element(vertex_touch_count.begin(),
- vertex_touch_count.end())) >= 2,
- ExcGridHasInvalidVertices());
- }
-
- // reserve enough space
- triangulation.levels.push_back (new internal::Triangulation::TriaLevel<dim>);
- triangulation.faces = new internal::Triangulation::TriaFaces<dim>;
- triangulation.levels[0]->reserve_space (cells.size(), dim);
- triangulation.faces->lines.reserve_space (0,needed_lines.size());
- triangulation.levels[0]->cells.reserve_space (0,cells.size());
-
- // make up lines
- {
- typename Triangulation<dim,spacedim>::raw_line_iterator
- line = triangulation.begin_raw_line();
- typename std::map<std::pair<int,int>,
- typename Triangulation<dim,spacedim>::line_iterator>::iterator i;
- for (i = needed_lines.begin();
- line!=triangulation.end_line(); ++line, ++i)
- {
- line->set (internal::Triangulation::TriaObject<1>(i->first.first,
- i->first.second));
- line->set_used_flag ();
- line->clear_user_flag ();
- line->clear_user_data ();
- i->second = line;
- }
- }
-
-
- // store for each line index
- // the adjacent cells
- std::map<int,std::vector<typename Triangulation<dim,spacedim>::cell_iterator> >
- adjacent_cells;
-
- // finally make up cells
- {
- typename Triangulation<dim,spacedim>::raw_cell_iterator
- cell = triangulation.begin_raw_quad();
- for (unsigned int c=0; c<cells.size(); ++c, ++cell)
- {
- typename Triangulation<dim,spacedim>::line_iterator
- lines[GeometryInfo<dim>::lines_per_cell];
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- lines[line]=needed_lines[std::make_pair(
- cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
- cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)])];
-
- cell->set (internal::Triangulation::TriaObject<2> (lines[0]->index(),
- lines[1]->index(),
- lines[2]->index(),
- lines[3]->index()));
-
- cell->set_used_flag ();
- cell->set_material_id (cells[c].material_id);
- cell->clear_user_data ();
- cell->set_subdomain_id (0);
-
- // note that this cell is
- // adjacent to the four
- // lines
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- adjacent_cells[lines[line]->index()].push_back (cell);
- }
- }
-
-
- for (typename Triangulation<dim,spacedim>::line_iterator
- line=triangulation.begin_line();
- line!=triangulation.end_line(); ++line)
- {
- const unsigned int n_adj_cells = adjacent_cells[line->index()].size();
- // assert that every line has
- // one or two adjacent cells
- AssertThrow ((n_adj_cells >= 1) &&
- (n_adj_cells <= 2),
- ExcInternalError());
-
- // if only one cell: line is at
- // boundary -> give it the
- // boundary indicator zero by
- // default
- if (n_adj_cells == 1)
- line->set_boundary_indicator (0);
- else
- // interior line -> 255
- line->set_boundary_indicator (255);
- }
-
- // set boundary indicators where
- // given
- std::vector<CellData<1> >::const_iterator boundary_line
- = subcelldata.boundary_lines.begin();
- std::vector<CellData<1> >::const_iterator end_boundary_line
- = subcelldata.boundary_lines.end();
- for (; boundary_line!=end_boundary_line; ++boundary_line)
- {
- typename Triangulation<dim,spacedim>::line_iterator line;
- std::pair<int,int> line_vertices(std::make_pair(boundary_line->vertices[0],
- boundary_line->vertices[1]));
- if (needed_lines.find(line_vertices) != needed_lines.end())
- // line found in this
- // direction
- line = needed_lines[line_vertices];
- else
- {
- // look whether it exists
- // in reverse direction
- std::swap (line_vertices.first, line_vertices.second);
- if (needed_lines.find(line_vertices) != needed_lines.end())
- line = needed_lines[line_vertices];
- else
- // line does not exist
- AssertThrow (false, ExcLineInexistant(line_vertices.first,
- line_vertices.second));
- }
-
- // assert that we only set
- // boundary info once
- AssertThrow (! (line->boundary_indicator() != 0 &&
- line->boundary_indicator() != 255),
- ExcMultiplySetLineInfoOfLine(line_vertices.first,
- line_vertices.second));
-
- // Assert that only exterior lines
- // are given a boundary indicator
- AssertThrow (! (line->boundary_indicator() == 255),
- ExcInteriorLineCantBeBoundary());
-
- line->set_boundary_indicator (boundary_line->material_id);
- }
-
-
- // finally update neighborship info
- for (typename Triangulation<dim,spacedim>::cell_iterator
- cell=triangulation.begin(); cell!=triangulation.end(); ++cell)
- for (unsigned int side=0; side<4; ++side)
- if (adjacent_cells[cell->line(side)->index()][0] == cell)
- // first adjacent cell is
- // this one
- {
- if (adjacent_cells[cell->line(side)->index()].size() == 2)
- // there is another
- // adjacent cell
- cell->set_neighbor (side,
- adjacent_cells[cell->line(side)->index()][1]);
- }
- // first adjacent cell is not this
- // one, -> it must be the neighbor
- // we are looking for
- else
- cell->set_neighbor (side,
- adjacent_cells[cell->line(side)->index()][0]);
- }
-
-
-/**
- * Invent an object which compares two internal::Triangulation::TriaObject<2>
- * against each other. This comparison is needed in order to establish a map
- * of TriaObject<2> to iterators in the Triangulation<3,3>::create_triangulation
- * function.
- *
- * Since this comparison is not canonical, we do not include it into the
- * general internal::Triangulation::TriaObject<2> class.
- */
- struct QuadComparator
- {
- inline bool operator () (const internal::Triangulation::TriaObject<2> &q1,
- const internal::Triangulation::TriaObject<2> &q2) const
- {
- // here is room to
- // optimize the repeated
- // equality test of the
- // previous lines; the
- // compiler will probably
- // take care of most of
- // it anyway
- if ((q1.face(0) < q2.face(0)) ||
- ((q1.face(0) == q2.face(0)) &&
- (q1.face(1) < q2.face(1))) ||
- ((q1.face(0) == q2.face(0)) &&
- (q1.face(1) == q2.face(1)) &&
- (q1.face(2) < q2.face(2))) ||
- ((q1.face(0) == q2.face(0)) &&
- (q1.face(1) == q2.face(1)) &&
- (q1.face(2) == q2.face(2)) &&
- (q1.face(3) < q2.face(3))))
- return true;
- else
- return false;
- }
- };
-
-
-
- template <int spacedim>
- static
- void
- create_triangulation (const std::vector<Point<spacedim> > &v,
- const std::vector<CellData<3> > &cells,
- const SubCellData &subcelldata,
- Triangulation<3,spacedim> &triangulation)
- {
- const unsigned int dim=3;
-
- // copy vertices
- triangulation.vertices = v;
- triangulation.vertices_used = std::vector<bool> (v.size(), true);
-
- // check that all cells have
- // positive volume. if not call the
- // invert_all_cells_of_negative_grid
- // and reorder_cells function of
- // GridReordering before creating
- // the triangulation
- for (unsigned int cell_no=0; cell_no<cells.size(); ++cell_no)
- AssertThrow (dealii::GridTools::cell_measure(triangulation.vertices,
- cells[cell_no].vertices) >= 0,
- ExcGridHasInvalidCell(cell_no));
-
- ///////////////////////////////////////
- // first set up some collections of data
- //
- // make up a list of the needed
- // lines
- //
- // each line is a pair of
- // vertices. The list is kept
- // sorted and it is guaranteed that
- // each line is inserted only once.
- // While the key of such an entry
- // is the pair of vertices, the
- // thing it points to is an
- // iterator pointing to the line
- // object itself. In the first run,
- // these iterators are all invalid
- // ones, but they are filled
- // afterwards same applies for the
- // quads
- typename std::map<std::pair<int,int>,
- typename Triangulation<dim,spacedim>::line_iterator> needed_lines;
- for (unsigned int cell=0; cell<cells.size(); ++cell)
- {
- // check whether vertex indices
- // are valid ones
- for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
- AssertThrow (cells[cell].vertices[vertex] < triangulation.vertices.size(),
- ExcInvalidVertexIndex (cell, cells[cell].vertices[vertex],
- triangulation.vertices.size()));
-
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- {
- // given a line vertex number
- // (0,1) on a specific line we
- // get the cell vertex number
- // (0-7) through the
- // line_to_cell_vertices
- // function
- std::pair<int,int> line_vertices(
- cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
- cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)]);
-
- // if that line was already inserted
- // in reverse order do nothing, else
- // insert the line
- if ( (needed_lines.find(std::make_pair(line_vertices.second,
- line_vertices.first))
- ==
- needed_lines.end()))
- {
- // insert line, with
- // invalid iterator. if line
- // already exists, then
- // nothing bad happens here
- needed_lines[line_vertices] = triangulation.end_line();
- }
- }
- }
-
-
- /////////////////////////////////
- // now for some sanity-checks:
- //
- // check that every vertex has at
- // least tree adjacent lines
- {
- std::vector<unsigned short int> vertex_touch_count (v.size(), 0);
- typename std::map<std::pair<int,int>,
- typename Triangulation<dim,spacedim>::line_iterator>::iterator i;
- for (i=needed_lines.begin(); i!=needed_lines.end(); i++)
- {
- // touch the vertices of
- // this line
- ++vertex_touch_count[i->first.first];
- ++vertex_touch_count[i->first.second];
- }
-
- // assert minimum touch count
- // is at least three. if not so,
- // then clean triangulation and
- // exit with an exception
- AssertThrow (* (std::min_element(vertex_touch_count.begin(),
- vertex_touch_count.end())) >= 3,
- ExcGridHasInvalidVertices());
- }
-
-
- ///////////////////////////////////
- // actually set up data structures
- // for the lines
- // reserve enough space
- triangulation.levels.push_back (new internal::Triangulation::TriaLevel<dim>);
- triangulation.faces = new internal::Triangulation::TriaFaces<dim>;
- triangulation.levels[0]->reserve_space (cells.size(), dim);
- triangulation.faces->lines.reserve_space (0,needed_lines.size());
-
- // make up lines
- {
- typename Triangulation<dim,spacedim>::raw_line_iterator
- line = triangulation.begin_raw_line();
- typename std::map<std::pair<int,int>,
- typename Triangulation<dim,spacedim>::line_iterator>::iterator i;
- for (i = needed_lines.begin(); line!=triangulation.end_line(); ++line, ++i)
- {
- line->set (internal::Triangulation::TriaObject<1>(i->first.first,
- i->first.second));
- line->set_used_flag ();
- line->clear_user_flag ();
- line->clear_user_data ();
-
- // now set the iterator for
- // this line
- i->second = line;
- }
- }
-
-
- ///////////////////////////////////////////
- // make up the quads of this triangulation
- //
- // same thing: the iterators are
- // set to the invalid value at
- // first, we only collect the data
- // now
-
- // the bool array stores, wether the lines
- // are in the standard orientation or not
-
- // note that QuadComparator is a
- // class declared and defined in
- // this file
- std::map<internal::Triangulation::TriaObject<2>,
- std::pair<typename Triangulation<dim,spacedim>::quad_iterator,
- std_cxx1x::array<bool,GeometryInfo<dim>::lines_per_face> >,
- QuadComparator>
- needed_quads;
- for (unsigned int cell=0; cell<cells.size(); ++cell)
- {
- // the faces are quads which
- // consist of four numbers
- // denoting the index of the
- // four lines bounding the
- // quad. we can get this index
- // by asking @p{needed_lines}
- // for an iterator to this
- // line, dereferencing it and
- // thus return an iterator into
- // the @p{lines} array of the
- // triangulation, which is
- // already set up. we can then
- // ask this iterator for its
- // index within the present
- // level (the level is zero, of
- // course)
- //
- // to make things easier, we
- // don't create the lines
- // (pairs of their vertex
- // indices) in place, but
- // before they are really
- // needed.
- std::pair<int,int> line_list[GeometryInfo<dim>::lines_per_cell],
- inverse_line_list[GeometryInfo<dim>::lines_per_cell];
- unsigned int face_line_list[GeometryInfo<dim>::lines_per_face];
- std_cxx1x::array<bool,GeometryInfo<dim>::lines_per_face> orientation;
-
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- {
- line_list[line]=std::pair<int,int> (
- cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
- cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)]);
- inverse_line_list[line]=std::pair<int,int> (
- cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)],
- cells[cell].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)]);
- }
-
- for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- {
- // set up a list of the lines to be
- // used for this face. check the
- // direction for each line
- //
- // given a face line number (0-3) on
- // a specific face we get the cell
- // line number (0-11) through the
- // face_to_cell_lines function
- for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_face; ++l)
- if (needed_lines.find (inverse_line_list[GeometryInfo<dim>::
- face_to_cell_lines(face,l)]) == needed_lines.end())
- {
- face_line_list[l]=needed_lines[line_list[GeometryInfo<dim>::
- face_to_cell_lines(face,l)]]->index();
- orientation[l]=true;
- }
- else
- {
- face_line_list[l]=needed_lines[inverse_line_list[GeometryInfo<dim>::
- face_to_cell_lines(face,l)]]->index();
- orientation[l]=false;
- }
-
-
- internal::Triangulation::TriaObject<2>
- quad(face_line_list[0],
- face_line_list[1],
- face_line_list[2],
- face_line_list[3]);
-
- // insert quad, with
- // invalid iterator
- //
- // if quad already exists,
- // then nothing bad happens
- // here, as this will then
- // simply become an
- // interior face of the
- // triangulation. however,
- // we will run into major
- // trouble if the face was
- // already inserted in the
- // opposite
- // direction. there are
- // really only two
- // orientations for a face
- // to be in, since the edge
- // directions are already
- // set. thus, vertex 0 is
- // the one from which two
- // edges originate, and
- // vertex 3 is the one to
- // which they converge. we
- // are then left with
- // orientations 0-1-2-3 and
- // 2-3-0-1 for the order of
- // lines. the
- // corresponding quad can
- // be easily constructed by
- // exchanging lines. we do
- // so here, just to check
- // that that flipped quad
- // isn't already in the
- // triangulation. if it is,
- // then don't insert the
- // new one and instead
- // later set the
- // face_orientation flag
- const internal::Triangulation::TriaObject<2>
- test_quad_1(quad.face(2), quad.face(3),
- quad.face(0), quad.face(1)),//face_orientation=false, face_flip=false, face_rotation=false
- test_quad_2(quad.face(0), quad.face(1),
- quad.face(3), quad.face(2)),//face_orientation=false, face_flip=false, face_rotation=true
- test_quad_3(quad.face(3), quad.face(2),
- quad.face(1), quad.face(0)),//face_orientation=false, face_flip=true, face_rotation=false
- test_quad_4(quad.face(1), quad.face(0),
- quad.face(2), quad.face(3)),//face_orientation=false, face_flip=true, face_rotation=true
- test_quad_5(quad.face(2), quad.face(3),
- quad.face(1), quad.face(0)),//face_orientation=true, face_flip=false, face_rotation=true
- test_quad_6(quad.face(1), quad.face(0),
- quad.face(3), quad.face(2)),//face_orientation=true, face_flip=true, face_rotation=false
- test_quad_7(quad.face(3), quad.face(2),
- quad.face(0), quad.face(1));//face_orientation=true, face_flip=true, face_rotation=true
- if (needed_quads.find (test_quad_1) == needed_quads.end() &&
- needed_quads.find (test_quad_2) == needed_quads.end() &&
- needed_quads.find (test_quad_3) == needed_quads.end() &&
- needed_quads.find (test_quad_4) == needed_quads.end() &&
- needed_quads.find (test_quad_5) == needed_quads.end() &&
- needed_quads.find (test_quad_6) == needed_quads.end() &&
- needed_quads.find (test_quad_7) == needed_quads.end())
- needed_quads[quad] = std::make_pair(triangulation.end_quad(),orientation);
- }
- }
-
-
- /////////////////////////////////
- // enter the resulting quads into
- // the arrays of the Triangulation
- //
- // first reserve enough space
- triangulation.faces->quads.reserve_space (0,needed_quads.size());
-
- {
- typename Triangulation<dim,spacedim>::raw_quad_iterator
- quad = triangulation.begin_raw_quad();
- typename std::map<internal::Triangulation::TriaObject<2>,
- std::pair<typename Triangulation<dim,spacedim>::quad_iterator,
- std_cxx1x::array<bool,GeometryInfo<dim>::lines_per_face> >,
- QuadComparator>
- ::iterator q;
- for (q = needed_quads.begin(); quad!=triangulation.end_quad(); ++quad, ++q)
- {
- quad->set (q->first);
- quad->set_used_flag ();
- quad->clear_user_flag ();
- quad->clear_user_data ();
- // set the line orientation
- quad->set_line_orientation(0,q->second.second[0]);
- quad->set_line_orientation(1,q->second.second[1]);
- quad->set_line_orientation(2,q->second.second[2]);
- quad->set_line_orientation(3,q->second.second[3]);
-
-
- // now set the iterator for
- // this quad
- q->second.first = quad;
- }
- }
-
- /////////////////////////////////
- // finally create the cells
- triangulation.levels[0]->cells.reserve_space (cells.size());
-
- // store for each quad index the
- // adjacent cells
- std::map<int,std::vector<typename Triangulation<dim,spacedim>::cell_iterator> >
- adjacent_cells;
-
- // finally make up cells
- {
- typename Triangulation<dim,spacedim>::raw_cell_iterator
- cell = triangulation.begin_raw_hex();
- for (unsigned int c=0; c<cells.size(); ++c, ++cell)
- {
- // first find for each of
- // the cells the quad
- // iterator of the
- // respective faces.
- //
- // to this end, set up the
- // lines of this cell and
- // find the quads that are
- // bounded by these lines;
- // these are then the faces
- // of the present cell
- std::pair<int,int> line_list[GeometryInfo<dim>::lines_per_cell],
- inverse_line_list[GeometryInfo<dim>::lines_per_cell];
- unsigned int face_line_list[4];
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- {
- line_list[line]=std::make_pair(
- cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
- cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)]);
- inverse_line_list[line]=std::pair<int,int> (
- cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)],
- cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)]);
- }
-
- // get the iterators
- // corresponding to the
- // faces. also store
- // whether they are
- // reversed or not
- typename Triangulation<dim,spacedim>::quad_iterator
- face_iterator[GeometryInfo<dim>::faces_per_cell];
- bool face_orientation[GeometryInfo<dim>::faces_per_cell];
- bool face_flip[GeometryInfo<dim>::faces_per_cell];
- bool face_rotation[GeometryInfo<dim>::faces_per_cell];
- for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- {
- for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_face; ++l)
- if (needed_lines.find (inverse_line_list[GeometryInfo<dim>::
- face_to_cell_lines(face,l)]) == needed_lines.end())
- face_line_list[l]=needed_lines[line_list[GeometryInfo<dim>::
- face_to_cell_lines(face,l)]]->index();
- else
- face_line_list[l]=needed_lines[inverse_line_list[GeometryInfo<dim>::
- face_to_cell_lines(face,l)]]->index();
-
- internal::Triangulation::TriaObject<2>
- quad(face_line_list[0],
- face_line_list[1],
- face_line_list[2],
- face_line_list[3]);
-
- if (needed_quads.find (quad) != needed_quads.end())
- {
- // face is in standard
- // orientation (and not
- // flipped or rotated). this
- // must be true for at least
- // one of the two cells
- // containing this face
- // (i.e. for the cell which
- // originally inserted the
- // face)
- face_iterator[face] = needed_quads[quad].first;
- face_orientation[face] = true;
- face_flip[face]=false;
- face_rotation[face]=false;
- }
- else
- {
- // face must be available in
- // reverse order
- // then. construct all
- // possibilities and check
- // them one after the other
- const internal::Triangulation::TriaObject<2>
- test_quad_1(quad.face(2), quad.face(3),
- quad.face(0), quad.face(1)),//face_orientation=false, face_flip=false, face_rotation=false
- test_quad_2(quad.face(0), quad.face(1),
- quad.face(3), quad.face(2)),//face_orientation=false, face_flip=false, face_rotation=true
- test_quad_3(quad.face(3), quad.face(2),
- quad.face(1), quad.face(0)),//face_orientation=false, face_flip=true, face_rotation=false
- test_quad_4(quad.face(1), quad.face(0),
- quad.face(2), quad.face(3)),//face_orientation=false, face_flip=true, face_rotation=true
- test_quad_5(quad.face(2), quad.face(3),
- quad.face(1), quad.face(0)),//face_orientation=true, face_flip=false, face_rotation=true
- test_quad_6(quad.face(1), quad.face(0),
- quad.face(3), quad.face(2)),//face_orientation=true, face_flip=true, face_rotation=false
- test_quad_7(quad.face(3), quad.face(2),
- quad.face(0), quad.face(1));//face_orientation=true, face_flip=true, face_rotation=true
- if (needed_quads.find (test_quad_1) != needed_quads.end())
- {
- face_iterator[face] = needed_quads[test_quad_1].first;
- face_orientation[face] = false;
- face_flip[face]=false;
- face_rotation[face]=false;
- }
- else if (needed_quads.find (test_quad_2) != needed_quads.end())
- {
- face_iterator[face] = needed_quads[test_quad_2].first;
- face_orientation[face] = false;
- face_flip[face]=false;
- face_rotation[face]=true;
- }
- else if (needed_quads.find (test_quad_3) != needed_quads.end())
- {
- face_iterator[face] = needed_quads[test_quad_3].first;
- face_orientation[face] = false;
- face_flip[face]=true;
- face_rotation[face]=false;
- }
- else if (needed_quads.find (test_quad_4) != needed_quads.end())
- {
- face_iterator[face] = needed_quads[test_quad_4].first;
- face_orientation[face] = false;
- face_flip[face]=true;
- face_rotation[face]=true;
- }
- else if (needed_quads.find (test_quad_5) != needed_quads.end())
- {
- face_iterator[face] = needed_quads[test_quad_5].first;
- face_orientation[face] = true;
- face_flip[face]=false;
- face_rotation[face]=true;
- }
- else if (needed_quads.find (test_quad_6) != needed_quads.end())
- {
- face_iterator[face] = needed_quads[test_quad_6].first;
- face_orientation[face] = true;
- face_flip[face]=true;
- face_rotation[face]=false;
- }
- else if (needed_quads.find (test_quad_7) != needed_quads.end())
- {
- face_iterator[face] = needed_quads[test_quad_7].first;
- face_orientation[face] = true;
- face_flip[face]=true;
- face_rotation[face]=true;
- }
-
- else
- // we didn't find the
- // face in any direction,
- // so something went
- // wrong above
- Assert(false,ExcInternalError());
-
- }
- }// for all faces
-
- // make the cell out of
- // these iterators
- cell->set (internal::Triangulation
- ::TriaObject<3> (face_iterator[0]->index(),
- face_iterator[1]->index(),
- face_iterator[2]->index(),
- face_iterator[3]->index(),
- face_iterator[4]->index(),
- face_iterator[5]->index()));
-
- cell->set_used_flag ();
- cell->set_material_id (cells[c].material_id);
- cell->clear_user_flag ();
- cell->clear_user_data ();
- cell->set_subdomain_id (0);
-
- // set orientation flag for
- // each of the faces
- for (unsigned int quad=0; quad<GeometryInfo<dim>::faces_per_cell; ++quad)
- {
- cell->set_face_orientation (quad, face_orientation[quad]);
- cell->set_face_flip (quad, face_flip[quad]);
- cell->set_face_rotation (quad, face_rotation[quad]);
- }
-
-
- // note that this cell is
- // adjacent to the six
- // quads
- for (unsigned int quad=0; quad<GeometryInfo<dim>::faces_per_cell; ++quad)
- adjacent_cells[face_iterator[quad]->index()].push_back (cell);
-
-#ifdef DEBUG
- // make some checks on the
- // lines and their
- // ordering
-
- // first map all cell lines
- // to the two face lines
- // which should
- // coincide. all face lines
- // are included with a cell
- // line number (0-11)
- // key. At the end all keys
- // will be included twice
- // (for each of the two
- // coinciding lines once)
- std::multimap<unsigned int, std::pair<unsigned int, unsigned int> >
- cell_to_face_lines;
- for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_face; ++line)
- cell_to_face_lines.insert(
- std::pair<unsigned int, std::pair<unsigned int, unsigned int> > (
- GeometryInfo<dim>::face_to_cell_lines(face,line),
- std::pair<unsigned int, unsigned int> (face,line)));
- std::multimap<unsigned int, std::pair<unsigned int, unsigned int> >::const_iterator
- map_iter=cell_to_face_lines.begin();
-
- for (; map_iter!=cell_to_face_lines.end(); ++map_iter)
- {
- const unsigned int cell_line=map_iter->first;
- const unsigned int face1=map_iter->second.first;
- const unsigned int line1=map_iter->second.second;
- ++map_iter;
- Assert(map_iter!=cell_to_face_lines.end(), ExcInternalErrorOnCell(c));
- Assert(map_iter->first==cell_line, ExcInternalErrorOnCell(c));
- const unsigned int face2=map_iter->second.first;
- const unsigned int line2=map_iter->second.second;
-
- // check that the pair
- // of lines really
- // coincide. Take care
- // about the face
- // orientation;
- Assert (face_iterator[face1]->line(GeometryInfo<dim>::standard_to_real_face_line(
- line1,
- face_orientation[face1],
- face_flip[face1],
- face_rotation[face1])) ==
- face_iterator[face2]->line(GeometryInfo<dim>::standard_to_real_face_line(
- line2,
- face_orientation[face2],
- face_flip[face2],
- face_rotation[face2])),
- ExcInternalErrorOnCell(c));
- }
-#endif
- }
- }
-
-
- /////////////////////////////////////////
- // find those quads which are at the
- // boundary and mark them appropriately
- for (typename Triangulation<dim,spacedim>::quad_iterator
- quad=triangulation.begin_quad(); quad!=triangulation.end_quad(); ++quad)
- {
- const unsigned int n_adj_cells = adjacent_cells[quad->index()].size();
- // assert that every quad has
- // one or two adjacent cells
- AssertThrow ((n_adj_cells >= 1) &&
- (n_adj_cells <= 2),
- ExcInternalError());
-
- // if only one cell: quad is at
- // boundary -> give it the
- // boundary indicator zero by
- // default
- if (n_adj_cells == 1)
- quad->set_boundary_indicator (0);
- else
- // interior quad -> 255
- quad->set_boundary_indicator (255);
- }
-
- /////////////////////////////////////////
- // next find those lines which are at
- // the boundary and mark all others as
- // interior ones
- //
- // for this: first mark all lines
- // as interior
- for (typename Triangulation<dim,spacedim>::line_iterator
- line=triangulation.begin_line(); line!=triangulation.end_line(); ++line)
- line->set_boundary_indicator (255);
- // next reset all lines bounding
- // boundary quads as on the
- // boundary also. note that since
- // we are in 3d, there are cases
- // where one or more lines of a
- // quad that is not on the
- // boundary, are actually boundary
- // lines. they will not be marked
- // when visiting this
- // face. however, since we do not
- // support dim-2 dimensional
- // boundaries (i.e. internal lines
- // constituting boundaries), every
- // such line is also part of a face
- // that is actually on the
- // boundary, so sooner or later we
- // get to mark that line for being
- // on the boundary
- for (typename Triangulation<dim,spacedim>::quad_iterator
- quad=triangulation.begin_quad(); quad!=triangulation.end_quad(); ++quad)
- if (quad->at_boundary())
- for (unsigned int l=0; l<4; ++l)
- quad->line(l)->set_boundary_indicator (0);
-
- ///////////////////////////////////////
- // now set boundary indicators
- // where given
- //
- // first do so for lines
- std::vector<CellData<1> >::const_iterator boundary_line
- = subcelldata.boundary_lines.begin();
- std::vector<CellData<1> >::const_iterator end_boundary_line
- = subcelldata.boundary_lines.end();
- for (; boundary_line!=end_boundary_line; ++boundary_line)
- {
- typename Triangulation<dim,spacedim>::line_iterator line;
- std::pair <int, int> line_vertices(std::make_pair(boundary_line->vertices[0],
- boundary_line->vertices[1]));
- if (needed_lines.find(line_vertices) != needed_lines.end())
- // line found in this
- // direction
- line = needed_lines[line_vertices];
-
- else
- {
- // look wether it exists in
- // reverse direction
- std::swap (line_vertices.first, line_vertices.second);
- if (needed_lines.find(line_vertices) != needed_lines.end())
- line = needed_lines[line_vertices];
- else
- // line does not exist
- AssertThrow (false, ExcLineInexistant(line_vertices.first,
- line_vertices.second));
- }
- // Assert that only exterior
- // lines are given a boundary
- // indicator
- AssertThrow (line->at_boundary(),
- ExcInteriorLineCantBeBoundary());
-
- // and make sure that we don't
- // attempt to reset the
- // boundary indicator to a
- // different than the
- // previously set value
- if (line->boundary_indicator() != 0)
- AssertThrow (line->boundary_indicator() == boundary_line->material_id,
- ExcMessage ("Duplicate boundary lines are only allowed "
- "if they carry the same boundary indicator."));
-
- line->set_boundary_indicator (boundary_line->material_id);
- }
-
-
- // now go on with boundary faces
- std::vector<CellData<2> >::const_iterator boundary_quad
- = subcelldata.boundary_quads.begin();
- std::vector<CellData<2> >::const_iterator end_boundary_quad
- = subcelldata.boundary_quads.end();
- for (; boundary_quad!=end_boundary_quad; ++boundary_quad)
- {
- typename Triangulation<dim,spacedim>::quad_iterator quad;
- typename Triangulation<dim,spacedim>::line_iterator line[4];
-
- // first find the lines that
- // are made up of the given
- // vertices, then build up a
- // quad from these lines
- // finally use the find
- // function of the map template
- // to find the quad
- for (unsigned int i=0; i<4; ++i)
- {
- std::pair<int, int> line_vertices(
- boundary_quad->vertices[GeometryInfo<dim-1>::line_to_cell_vertices(i,0)],
- boundary_quad->vertices[GeometryInfo<dim-1>::line_to_cell_vertices(i,1)]);
-
- // check whether line
- // already exists
- if (needed_lines.find(line_vertices) != needed_lines.end())
- line[i] = needed_lines[line_vertices];
- else
- // look wether it exists
- // in reverse direction
- {
- std::swap (line_vertices.first, line_vertices.second);
- if (needed_lines.find(line_vertices) != needed_lines.end())
- line[i] = needed_lines[line_vertices];
- else
- // line does
- // not exist
- AssertThrow (false, ExcLineInexistant(line_vertices.first,
- line_vertices.second));
- }
- }
-
-
- // Set up 2 quads that are
- // built up from the lines for
- // reasons of comparison to
- // needed_quads. The second
- // quad is the reversed version
- // of the first quad in order
- // find the quad regardless of
- // its orientation. This is
- // introduced for convenience
- // and because boundary quad
- // orientation does not carry
- // any information.
- internal::Triangulation::TriaObject<2>
- quad_compare_1(line[0]->index(), line[1]->index(),
- line[2]->index(), line[3]->index());
- internal::Triangulation::TriaObject<2>
- quad_compare_2(line[2]->index(), line[3]->index(),
- line[0]->index(), line[1]->index());
-
- // try to find the quad with
- // lines situated as
- // constructed above. if it
- // could not be found, rotate
- // the boundary lines 3 times
- // until it is found or it does
- // not exist.
-
- // mapping from counterclock to
- // lexicographic ordering of
- // quad lines
- static const unsigned int lex2cclock[4]={3,1,0,2};
- // copy lines from
- // lexicographic to
- // counterclock ordering, as
- // rotation is much simpler in
- // counterclock ordering
- typename Triangulation<dim,spacedim>::line_iterator
- line_counterclock[4];
- for (unsigned int i=0; i<4; ++i)
- line_counterclock[lex2cclock[i]]=line[i];
- unsigned int n_rotations=0;
- bool not_found_quad_1;
- while ( (not_found_quad_1=(needed_quads.find(quad_compare_1) == needed_quads.end())) &&
- ( needed_quads.find(quad_compare_2) == needed_quads.end()) &&
- (n_rotations<4))
- {
- // use the rotate defined
- // in <algorithms>
- rotate(line_counterclock, line_counterclock+1, line_counterclock+4);
- // update the quads with
- // rotated lines (i runs in
- // lexicographic ordering)
- for (unsigned int i=0; i<4; ++i)
- {
- quad_compare_1.set_face(i, line_counterclock[lex2cclock[i]]->index());
- quad_compare_2.set_face((i+2)%4, line_counterclock[lex2cclock[i]]->index());
- }
-
- ++n_rotations;
- }
-
- AssertThrow (n_rotations!=4,
- ExcQuadInexistant(line[0]->index(), line[1]->index(),
- line[2]->index(), line[3]->index()));
-
- if (not_found_quad_1)
- quad = needed_quads[quad_compare_2].first;
- else
- quad = needed_quads[quad_compare_1].first;
-
- // check whether this face is
- // really an exterior one
- AssertThrow (quad->at_boundary(),
- ExcInteriorQuadCantBeBoundary());
-
- // and make sure that we don't
- // attempt to reset the
- // boundary indicator to a
- // different than the
- // previously set value
- if (quad->boundary_indicator() != 0)
- AssertThrow (quad->boundary_indicator() == boundary_quad->material_id,
- ExcMessage ("Duplicate boundary quads are only allowed "
- "if they carry the same boundary indicator."));
-
- quad->set_boundary_indicator (boundary_quad->material_id);
- }
-
-
- /////////////////////////////////////////
- // finally update neighborship info
- for (typename Triangulation<dim,spacedim>::cell_iterator
- cell=triangulation.begin(); cell!=triangulation.end(); ++cell)
- for (unsigned int face=0; face<6; ++face)
- if (adjacent_cells[cell->quad(face)->index()][0] == cell)
- // first adjacent cell is
- // this one
- {
- if (adjacent_cells[cell->quad(face)->index()].size() == 2)
- // there is another
- // adjacent cell
- cell->set_neighbor (face,
- adjacent_cells[cell->quad(face)->index()][1]);
- }
- // first adjacent cell is not this
- // one, -> it must be the neighbor
- // we are looking for
- else
- cell->set_neighbor (face,
- adjacent_cells[cell->quad(face)->index()][0]);
- }
-
-
- /**
- * Distort a 1d triangulation in
- * some random way.
- */
- template <int spacedim>
- static
- void
- distort_random (const double factor,
- const bool keep_boundary,
- Triangulation<1,spacedim> &triangulation)
- {
- const unsigned int dim = 1;
-
- // if spacedim>1 we need to
- // make sure that we perturb
- // points but keep them on
- // the manifold
- Assert (spacedim == 1,
- ExcNotImplemented());
-
- // this function is mostly
- // equivalent to that for the
- // general dimensional case the
- // only difference being the
- // correction for split faces which
- // is not necessary in 1D
-
- // find the smallest length of the
- // lines adjacent to the
- // vertex. take the initial value
- // to be larger than anything that
- // might be found: the diameter of
- // the triangulation, here computed
- // by adding up the diameters of
- // the coarse grid cells.
- double almost_infinite_length = 0;
- for (typename Triangulation<dim,spacedim>::cell_iterator
- cell=triangulation.begin(0); cell!=triangulation.end(0); ++cell)
- almost_infinite_length += cell->diameter();
-
- std::vector<double> minimal_length (triangulation.vertices.size(),
- almost_infinite_length);
- // also note if a vertex is at
- // the boundary
- std::vector<bool> at_boundary (triangulation.vertices.size(), false);
-
- for (typename Triangulation<dim,spacedim>::active_line_iterator
- line=triangulation.begin_active_line();
- line != triangulation.end_line(); ++line)
- {
- if (keep_boundary && line->at_boundary())
- {
- at_boundary[line->vertex_index(0)] = true;
- at_boundary[line->vertex_index(1)] = true;
- }
-
- minimal_length[line->vertex_index(0)]
- = std::min(line->diameter(),
- minimal_length[line->vertex_index(0)]);
- minimal_length[line->vertex_index(1)]
- = std::min(line->diameter(),
- minimal_length[line->vertex_index(1)]);
- }
-
-
- const unsigned int n_vertices = triangulation.vertices.size();
- Point<spacedim> shift_vector;
-
- for (unsigned int vertex=0; vertex<n_vertices; ++vertex)
- {
- // ignore this vertex if we
- // whall keep the boundary and
- // this vertex *is* at the
- // boundary
- if (keep_boundary && at_boundary[vertex])
- continue;
-
- // first compute a random shift
- // vector
- for (unsigned int d=0; d<spacedim; ++d)
- shift_vector(d) = std::rand()*1.0/RAND_MAX;
-
- shift_vector *= factor * minimal_length[vertex] /
- std::sqrt(shift_vector.square());
-
- // finally move the vertex
- triangulation.vertices[vertex] += shift_vector;
- }
- }
-
-
- /**
- * Distort a triangulation in
- * some random way. This is the
- * function taken for the case
- * dim>1.
- */
- template <int dim, int spacedim>
- static
- void
- distort_random (const double factor,
- const bool keep_boundary,
- Triangulation<dim,spacedim> &triangulation)
- {
-//TODO:[?]Implement the random distortion in Triangulation for hanging nodes as well
-// Hanging nodes need to be reset to the correct mean value
-// at the end, which is simple for 2D but difficult for 3D. Maybe take
-// a look at how we get to the original location of the point in the
-// execute_refinement function and copy the relevant lines.
-
- // this function is mostly
- // equivalent to that for the
- // general dimensional case the
- // only difference being the
- // correction for split faces which
- // is not necessary in 1D
- //
- // if you change something here,
- // don't forget to do so there as
- // well
-
- // find the smallest length of the
- // lines adjacent to the
- // vertex. take the initial value
- // to be larger than anything that
- // might be found: the diameter of
- // the triangulation, here
- // estimated by adding up the
- // diameters of the coarse grid
- // cells.
- double almost_infinite_length = 0;
- for (typename Triangulation<dim,spacedim>::cell_iterator
- cell=triangulation.begin(0); cell!=triangulation.end(0); ++cell)
- almost_infinite_length += cell->diameter();
-
- std::vector<double> minimal_length (triangulation.vertices.size(),
- almost_infinite_length);
-
- // also note if a vertex is at the
- // boundary
- std::vector<bool> at_boundary (triangulation.vertices.size(), false);
-
- for (typename Triangulation<dim,spacedim>::active_line_iterator
- line=triangulation.begin_active_line();
- line != triangulation.end_line(); ++line)
- {
- if (keep_boundary && line->at_boundary())
- {
- at_boundary[line->vertex_index(0)] = true;
- at_boundary[line->vertex_index(1)] = true;
- }
-
- minimal_length[line->vertex_index(0)]
- = std::min(line->diameter(),
- minimal_length[line->vertex_index(0)]);
- minimal_length[line->vertex_index(1)]
- = std::min(line->diameter(),
- minimal_length[line->vertex_index(1)]);
- }
-
-
- const unsigned int n_vertices = triangulation.vertices.size();
- Point<spacedim> shift_vector;
-
- for (unsigned int vertex=0; vertex<n_vertices; ++vertex)
- {
- // ignore this vertex if we
- // whall keep the boundary and
- // this vertex *is* at the
- // boundary
- if (keep_boundary && at_boundary[vertex])
- continue;
-
- // first compute a random shift
- // vector
- for (unsigned int d=0; d<spacedim; ++d)
- shift_vector(d) = std::rand()*1.0/RAND_MAX;
-
- shift_vector *= factor * minimal_length[vertex] /
- std::sqrt(shift_vector.square());
-
- // finally move the vertex
- triangulation.vertices[vertex] += shift_vector;
- }
-
-
- // finally correct hanging nodes
- // again. The following is not
- // necessary for 1D
- typename Triangulation<dim,spacedim>::active_cell_iterator
- cell = triangulation.begin_active(),
- endc = triangulation.end();
- for (; cell!=endc; ++cell)
- for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->face(face)->has_children() &&
- !cell->face(face)->at_boundary())
- // this lines has children,
- // thus there are restricted
- // nodes
- {
- // not implemented at
- // present for dim=3 or
- // higher
- Assert (dim<=2, ExcNotImplemented());
-
- // compute where the common
- // point of the two child
- // lines will lie and reset
- // it to the correct value
- triangulation.vertices[cell->face(face)->child(0)->vertex_index(1)]
- = (cell->face(face)->vertex(0) +
- cell->face(face)->vertex(1)) / 2;
- }
- }
-
-
- /**
- * Actually delete a cell, or rather all
- * its children, which is the main step for
- * the coarsening process. This is the
- * dimension dependent part of @p
- * execute_coarsening. The second argument
- * is a vector which gives for each line
- * index the number of cells containing
- * this line. This information is needed to
- * decide whether a refined line may be
- * coarsened or not in 3D. In 1D and 2D
- * this argument is not needed and thus
- * ignored. The same applies for the last
- * argument and quads instead of lines.
- */
- template <int spacedim>
- static
- void
- delete_children (Triangulation<1,spacedim> &triangulation,
- typename Triangulation<1,spacedim>::cell_iterator &cell,
- std::vector<unsigned int> &,
- std::vector<unsigned int> &)
- {
- const unsigned int dim = 1;
-
- // first we need to reset the
- // neighbor pointers of the
- // neighbors of this cell's
- // children to this cell. This is
- // different for one dimension,
- // since there neighbors can have a
- // refinement level differing from
- // that of this cell's children by
- // more than one level.
-
- Assert (!cell->child(0)->has_children() && !cell->child(1)->has_children(),
- ExcInternalError());
-
- // first do it for the cells to the
- // left
- if (cell->neighbor(0).state() == IteratorState::valid)
- if (cell->neighbor(0)->has_children())
- {
- typename Triangulation<dim,spacedim>::cell_iterator
- neighbor = cell->neighbor(0);
- Assert (neighbor->level() == cell->level(), ExcInternalError());
-
- // right child
- neighbor = neighbor->child(1);
- while (1)
- {
- Assert (neighbor->neighbor(1) == cell->child(0),
- ExcInternalError());
- neighbor->set_neighbor (1, cell);
-
- // move on to further
- // children on the
- // boundary between this
- // cell and its neighbor
- if (neighbor->has_children())
- neighbor = neighbor->child(1);
- else
- break;
- }
- }
-
- // now do it for the cells to the
- // left
- if (cell->neighbor(1).state() == IteratorState::valid)
- if (cell->neighbor(1)->has_children())
- {
- typename Triangulation<dim,spacedim>::cell_iterator
- neighbor = cell->neighbor(1);
- Assert (neighbor->level() == cell->level(), ExcInternalError());
-
- // left child
- neighbor = neighbor->child(0);
- while (1)
- {
- Assert (neighbor->neighbor(0) == cell->child(1),
- ExcInternalError());
- neighbor->set_neighbor (0, cell);
-
- // move on to further
- // children on the
- // boundary between this
- // cell and its neighbor
- if (neighbor->has_children())
- neighbor = neighbor->child(0);
- else
- break;
- }
- }
-
-
- // delete the vertex which will not
- // be needed anymore. This vertex
- // is the second of the first child
- triangulation.vertices_used[cell->child(0)->vertex_index(1)] = false;
-
- // invalidate children. clear user
- // pointers, to avoid that they may
- // appear at unwanted places later
- // on...
- for (unsigned int child=0; child<cell->n_children(); ++child)
- {
- cell->child(child)->clear_user_data();
- cell->child(child)->clear_user_flag();
- cell->child(child)->clear_used_flag();
- }
-
-
- // delete pointer to children
- cell->clear_children ();
- cell->clear_user_flag();
- }
-
-
-
- template <int spacedim>
- static
- void
- delete_children (Triangulation<2,spacedim> &triangulation,
- typename Triangulation<2,spacedim>::cell_iterator &cell,
- std::vector<unsigned int> &line_cell_count,
- std::vector<unsigned int> &)
- {
- const unsigned int dim=2;
- const RefinementCase<dim> ref_case=cell->refinement_case();
-
- Assert(line_cell_count.size()==triangulation.n_raw_lines(), ExcInternalError());
-
- // vectors to hold all lines which
- // may be deleted
- std::vector<typename Triangulation<dim,spacedim>::line_iterator>
- lines_to_delete(0);
-
- lines_to_delete.reserve(4*2+4);
-
- // now we decrease the counters for
- // lines contained in the child
- // cells
- for (unsigned int c=0; c<cell->n_children(); ++c)
- {
- typename Triangulation<dim,spacedim>::cell_iterator
- child=cell->child(c);
- for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
- --line_cell_count[child->line_index(l)];
- }
-
-
- // delete the vertex which will not
- // be needed anymore. This vertex
- // is the second of the second line
- // of the first child, if the cell
- // is refined with cut_xy, else there
- // is no inner vertex.
- // additionally delete unneeded inner
- // lines
- if (ref_case==RefinementCase<dim>::cut_xy)
- {
- triangulation.vertices_used[cell->child(0)->line(1)->vertex_index(1)] = false;
-
- lines_to_delete.push_back(cell->child(0)->line(1));
- lines_to_delete.push_back(cell->child(0)->line(3));
- lines_to_delete.push_back(cell->child(3)->line(0));
- lines_to_delete.push_back(cell->child(3)->line(2));
- }
- else
- {
- unsigned int inner_face_no=ref_case==RefinementCase<dim>::cut_x ? 1 : 3;
-
- // the inner line will not be
- // used any more
- lines_to_delete.push_back(cell->child(0)->line(inner_face_no));
- }
-
- // invalidate children
- for (unsigned int child=0; child<cell->n_children(); ++child)
- {
- cell->child(child)->clear_user_data();
- cell->child(child)->clear_user_flag();
- cell->child(child)->clear_used_flag();
- }
-
-
- // delete pointer to children
- cell->clear_children ();
- cell->clear_refinement_case();
- cell->clear_user_flag();
-
- // look at the refinement of outer
- // lines. if nobody needs those
- // anymore we can add them to the
- // list of lines to be deleted.
- for (unsigned int line_no=0; line_no<GeometryInfo<dim>::lines_per_cell; ++line_no)
- {
- typename Triangulation<dim,spacedim>::line_iterator
- line=cell->line(line_no);
-
- if (line->has_children())
- {
- // if one of the cell counters is
- // zero, the other has to be as well
-
- Assert((line_cell_count[line->child_index(0)] == 0 &&
- line_cell_count[line->child_index(1)] == 0) ||
- (line_cell_count[line->child_index(0)] > 0 &&
- line_cell_count[line->child_index(1)] > 0),
- ExcInternalError());
-
- if (line_cell_count[line->child_index(0)]==0)
- {
- for (unsigned int c=0; c<2; ++c)
- Assert (!line->child(c)->has_children(),
- ExcInternalError());
-
- // we may delete the line's
- // children and the middle vertex
- // as no cell references them
- // anymore
- triangulation.vertices_used[line->child(0)->vertex_index(1)] = false;
-
- lines_to_delete.push_back(line->child(0));
- lines_to_delete.push_back(line->child(1));
-
- line->clear_children();
- }
- }
- }
-
- // finally, delete unneeded lines
-
- // clear user pointers, to avoid that
- // they may appear at unwanted places
- // later on...
- // same for user flags, then finally
- // delete the lines
- typename std::vector<typename Triangulation<dim,spacedim>::line_iterator>::iterator
- line=lines_to_delete.begin(),
- endline=lines_to_delete.end();
- for (; line!=endline; ++line)
- {
- (*line)->clear_user_data();
- (*line)->clear_user_flag();
- (*line)->clear_used_flag();
- }
- }
-
-
-
- template <int spacedim>
- static
- void
- delete_children (Triangulation<3,spacedim> &triangulation,
- typename Triangulation<3,spacedim>::cell_iterator &cell,
- std::vector<unsigned int> &line_cell_count,
- std::vector<unsigned int> &quad_cell_count)
- {
- const unsigned int dim=3;
-
- Assert(line_cell_count.size()==triangulation.n_raw_lines(), ExcInternalError());
- Assert(quad_cell_count.size()==triangulation.n_raw_quads(), ExcInternalError());
-
- // first of all, we store the RefineCase of
- // this cell
- const RefinementCase<dim> ref_case=cell->refinement_case();
- // vectors to hold all lines and quads which
- // may be deleted
- std::vector<typename Triangulation<dim,spacedim>::line_iterator>
- lines_to_delete(0);
- std::vector<typename Triangulation<dim,spacedim>::quad_iterator>
- quads_to_delete(0);
-
- lines_to_delete.reserve(12*2+6*4+6);
- quads_to_delete.reserve(6*4+12);
-
- // now we decrease the counters for lines and
- // quads contained in the child cells
- for (unsigned int c=0; c<cell->n_children(); ++c)
- {
- typename Triangulation<dim,spacedim>::cell_iterator
- child=cell->child(c);
- for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
- --line_cell_count[child->line_index(l)];
- for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
- --quad_cell_count[child->quad_index(f)];
- }
-
- ///////////////////////////////////////
- // delete interior quads and lines and the
- // interior vertex, depending on the
- // refinement case of the cell
- //
- // for append quads and lines: only append
- // them to the list of objects to be deleted
-
- switch (ref_case)
- {
- case RefinementCase<dim>::cut_x:
- quads_to_delete.push_back(cell->child(0)->face(1));
- break;
- case RefinementCase<dim>::cut_y:
- quads_to_delete.push_back(cell->child(0)->face(3));
- break;
- case RefinementCase<dim>::cut_z:
- quads_to_delete.push_back(cell->child(0)->face(5));
- break;
- case RefinementCase<dim>::cut_xy:
- quads_to_delete.push_back(cell->child(0)->face(1));
- quads_to_delete.push_back(cell->child(0)->face(3));
- quads_to_delete.push_back(cell->child(3)->face(0));
- quads_to_delete.push_back(cell->child(3)->face(2));
-
- lines_to_delete.push_back(cell->child(0)->line(11));
- break;
- case RefinementCase<dim>::cut_xz:
- quads_to_delete.push_back(cell->child(0)->face(1));
- quads_to_delete.push_back(cell->child(0)->face(5));
- quads_to_delete.push_back(cell->child(3)->face(0));
- quads_to_delete.push_back(cell->child(3)->face(4));
-
- lines_to_delete.push_back(cell->child(0)->line(5));
- break;
- case RefinementCase<dim>::cut_yz:
- quads_to_delete.push_back(cell->child(0)->face(3));
- quads_to_delete.push_back(cell->child(0)->face(5));
- quads_to_delete.push_back(cell->child(3)->face(2));
- quads_to_delete.push_back(cell->child(3)->face(4));
-
- lines_to_delete.push_back(cell->child(0)->line(7));
- break;
- case RefinementCase<dim>::cut_xyz:
- quads_to_delete.push_back(cell->child(0)->face(1));
- quads_to_delete.push_back(cell->child(2)->face(1));
- quads_to_delete.push_back(cell->child(4)->face(1));
- quads_to_delete.push_back(cell->child(6)->face(1));
-
- quads_to_delete.push_back(cell->child(0)->face(3));
- quads_to_delete.push_back(cell->child(1)->face(3));
- quads_to_delete.push_back(cell->child(4)->face(3));
- quads_to_delete.push_back(cell->child(5)->face(3));
-
- quads_to_delete.push_back(cell->child(0)->face(5));
- quads_to_delete.push_back(cell->child(1)->face(5));
- quads_to_delete.push_back(cell->child(2)->face(5));
- quads_to_delete.push_back(cell->child(3)->face(5));
-
- lines_to_delete.push_back(cell->child(0)->line(5));
- lines_to_delete.push_back(cell->child(0)->line(7));
- lines_to_delete.push_back(cell->child(0)->line(11));
- lines_to_delete.push_back(cell->child(7)->line(0));
- lines_to_delete.push_back(cell->child(7)->line(2));
- lines_to_delete.push_back(cell->child(7)->line(8));
- // delete the vertex which will not
- // be needed anymore. This vertex
- // is the vertex at the heart of
- // this cell, which is the sixth of
- // the first child
- triangulation.vertices_used[cell->child(0)->vertex_index(7)] = false;
- break;
- default:
- // only remaining case is
- // no_refinement, thus an error
- Assert(false, ExcInternalError());
- break;
- }
-
-
- // invalidate children
- for (unsigned int child=0; child<cell->n_children(); ++child)
- {
- cell->child(child)->clear_user_data();
- cell->child(child)->clear_user_flag();
-
- for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
- {
- // set flags denoting deviations from
- // standard orientation of faces back
- // to initialization values
- cell->child(child)->set_face_orientation (f, true);
- cell->child(child)->set_face_flip(f,false);
- cell->child(child)->set_face_rotation(f,false);
- }
-
- cell->child(child)->clear_used_flag();
- }
-
-
- // delete pointer to children
- cell->clear_children ();
- cell->clear_refinement_case ();
- cell->clear_user_flag();
-
- // so far we only looked at inner quads,
- // lines and vertices. Now we have to
- // consider outer ones as well. here, we have
- // to check, whether there are other cells
- // still needing these objects. oherwise we
- // can delete them. first for quads (and
- // their inner lines).
-
- for (unsigned int quad_no=0; quad_no<GeometryInfo<dim>::faces_per_cell; ++quad_no)
- {
- typename Triangulation<dim,spacedim>::quad_iterator
- quad=cell->face(quad_no);
-
- Assert((GeometryInfo<dim>::face_refinement_case(ref_case,quad_no) && quad->has_children()) ||
- GeometryInfo<dim>::face_refinement_case(ref_case,quad_no)==RefinementCase<dim-1>::no_refinement,
- ExcInternalError());
-
- switch (quad->refinement_case())
- {
- case RefinementCase<dim-1>::no_refinement:
- // nothing to do as the quad
- // is not refined
- break;
- case RefinementCase<dim-1>::cut_x:
- case RefinementCase<dim-1>::cut_y:
- {
- // if one of the cell counters is
- // zero, the other has to be as
- // well
- Assert((quad_cell_count[quad->child_index(0)] == 0 &&
- quad_cell_count[quad->child_index(1)] == 0) ||
- (quad_cell_count[quad->child_index(0)] > 0 &&
- quad_cell_count[quad->child_index(1)] > 0),
- ExcInternalError());
- // it might be, that the quad is
- // refined twice anisotropically,
- // first check, whether we may
- // delete possible grand_children
- unsigned int deleted_grandchildren=0;
- unsigned int number_of_child_refinements=0;
-
- for (unsigned int c=0; c<2; ++c)
- if (quad->child(c)->has_children())
- {
- ++number_of_child_refinements;
- // if one of the cell counters is
- // zero, the other has to be as
- // well
- Assert((quad_cell_count[quad->child(c)->child_index(0)] == 0 &&
- quad_cell_count[quad->child(c)->child_index(1)] == 0) ||
- (quad_cell_count[quad->child(c)->child_index(0)] > 0 &&
- quad_cell_count[quad->child(c)->child_index(1)] > 0),
- ExcInternalError());
- if (quad_cell_count[quad->child(c)->child_index(0)]==0)
- {
- // Assert, that the two
- // anisotropic
- // refinements add up to
- // isotropic refinement
- Assert(quad->refinement_case()+quad->child(c)->refinement_case()==RefinementCase<dim>::cut_xy,
- ExcInternalError());
- // we may delete the
- // quad's children and
- // the inner line as no
- // cell references them
- // anymore
- quads_to_delete.push_back(quad->child(c)->child(0));
- quads_to_delete.push_back(quad->child(c)->child(1));
- if (quad->child(c)->refinement_case()==RefinementCase<2>::cut_x)
- lines_to_delete.push_back(quad->child(c)->child(0)->line(1));
- else
- lines_to_delete.push_back(quad->child(c)->child(0)->line(3));
- quad->child(c)->clear_children();
- quad->child(c)->clear_refinement_case();
- ++deleted_grandchildren;
- }
- }
- // if no grandchildren are left, we
- // may as well delete the
- // refinement of the inner line
- // between our children and the
- // corresponding vertex
- if (number_of_child_refinements>0 &&
- deleted_grandchildren==number_of_child_refinements)
- {
- typename Triangulation<dim,spacedim>::line_iterator
- middle_line;
- if (quad->refinement_case()==RefinementCase<2>::cut_x)
- middle_line=quad->child(0)->line(1);
- else
- middle_line=quad->child(0)->line(3);
-
- lines_to_delete.push_back(middle_line->child(0));
- lines_to_delete.push_back(middle_line->child(1));
- triangulation.vertices_used[middle_vertex_index<dim,spacedim>(middle_line)]
- = false;
- middle_line->clear_children();
- }
-
- // now consider the direct children
- // of the given quad
- if (quad_cell_count[quad->child_index(0)]==0)
- {
- // we may delete the quad's
- // children and the inner line
- // as no cell references them
- // anymore
- quads_to_delete.push_back(quad->child(0));
- quads_to_delete.push_back(quad->child(1));
- if (quad->refinement_case()==RefinementCase<2>::cut_x)
- lines_to_delete.push_back(quad->child(0)->line(1));
- else
- lines_to_delete.push_back(quad->child(0)->line(3));
-
- // if the counters just dropped
- // to zero, otherwise the
- // children would have been
- // deleted earlier, then this
- // cell's children must have
- // contained the anisotropic
- // quad children. thus, if
- // those have again anisotropic
- // children, which are in
- // effect isotropic children of
- // the original quad, those are
- // still needed by a
- // neighboring cell and we
- // cannot delete them. instead,
- // we have to reset this quad's
- // refine case to isotropic and
- // set the children
- // accordingly.
- if (quad->child(0)->has_children())
- if (quad->refinement_case()==RefinementCase<2>::cut_x)
- {
- // now evereything is
- // quite complicated. we
- // have the children
- // numbered according to
- //
- // *---*---*
- // |n+1|m+1|
- // *---*---*
- // | n | m |
- // *---*---*
- //
- // from the original
- // anisotropic
- // refinement. we have to
- // reorder them as
- //
- // *---*---*
- // | m |m+1|
- // *---*---*
- // | n |n+1|
- // *---*---*
- //
- // for isotropic refinement.
- //
- // this is a bit ugly, of
- // course: loop over all
- // cells on all levels
- // and look for faces n+1
- // (switch_1) and m
- // (switch_2).
- const typename Triangulation<dim,spacedim>::quad_iterator
- switch_1=quad->child(0)->child(1),
- switch_2=quad->child(1)->child(0);
-
- Assert(!switch_1->has_children(), ExcInternalError());
- Assert(!switch_2->has_children(), ExcInternalError());
-
- const int switch_1_index=switch_1->index();
- const int switch_2_index=switch_2->index();
- for (unsigned int l=0; l<triangulation.levels.size(); ++l)
- for (unsigned int h=0; h<triangulation.levels[l]->cells.cells.size(); ++h)
- for (unsigned int q=0; q<GeometryInfo<dim>::faces_per_cell; ++q)
- {
- const int index=triangulation.levels[l]->cells.cells[h].face(q);
- if (index==switch_1_index)
- triangulation.levels[l]->cells.cells[h].set_face(q,switch_2_index);
- else if (index==switch_2_index)
- triangulation.levels[l]->cells.cells[h].set_face(q,switch_1_index);
- }
- // now we have to copy
- // all information of the
- // two quads
- const int switch_1_lines[4]=
- {switch_1->line_index(0),
- switch_1->line_index(1),
- switch_1->line_index(2),
- switch_1->line_index(3)};
- const bool switch_1_line_orientations[4]=
- {switch_1->line_orientation(0),
- switch_1->line_orientation(1),
- switch_1->line_orientation(2),
- switch_1->line_orientation(3)};
- const unsigned char switch_1_boundary_indicator=switch_1->boundary_indicator();
- const unsigned int switch_1_user_index=switch_1->user_index();
- const bool switch_1_user_flag=switch_1->user_flag_set();
-
- switch_1->set(internal::Triangulation::TriaObject<2>(switch_2->line_index(0),
- switch_2->line_index(1),
- switch_2->line_index(2),
- switch_2->line_index(3)));
- switch_1->set_line_orientation(0, switch_2->line_orientation(0));
- switch_1->set_line_orientation(1, switch_2->line_orientation(1));
- switch_1->set_line_orientation(2, switch_2->line_orientation(2));
- switch_1->set_line_orientation(3, switch_2->line_orientation(3));
- switch_1->set_boundary_indicator(switch_2->boundary_indicator());
- switch_1->set_user_index(switch_2->user_index());
- if (switch_2->user_flag_set())
- switch_1->set_user_flag();
- else
- switch_1->clear_user_flag();
-
- switch_2->set(internal::Triangulation::TriaObject<2>(switch_1_lines[0],
- switch_1_lines[1],
- switch_1_lines[2],
- switch_1_lines[3]));
- switch_2->set_line_orientation(0, switch_1_line_orientations[0]);
- switch_2->set_line_orientation(1, switch_1_line_orientations[1]);
- switch_2->set_line_orientation(2, switch_1_line_orientations[2]);
- switch_2->set_line_orientation(3, switch_1_line_orientations[3]);
- switch_2->set_boundary_indicator(switch_1_boundary_indicator);
- switch_2->set_user_index(switch_1_user_index);
- if (switch_1_user_flag)
- switch_2->set_user_flag();
- else
- switch_2->clear_user_flag();
-
- const unsigned int child_0=quad->child(0)->child_index(0);
- const unsigned int child_2=quad->child(1)->child_index(0);
- quad->clear_children();
- quad->clear_refinement_case();
- quad->set_refinement_case(RefinementCase<2>::cut_xy);
- quad->set_children(0,child_0);
- quad->set_children(2,child_2);
- std::swap(quad_cell_count[child_0+1],quad_cell_count[child_2]);
- }
- else
- {
- // the face was refined
- // with cut_y, thus the
- // children are already
- // in correct order. we
- // only have to set them
- // correctly, deleting
- // the indirection of two
- // anisotropic refinement
- // and going directly
- // from the quad to
- // isotropic children
- const unsigned int child_0=quad->child(0)->child_index(0);
- const unsigned int child_2=quad->child(1)->child_index(0);
- quad->clear_children();
- quad->clear_refinement_case();
- quad->set_refinement_case(RefinementCase<2>::cut_xy);
- quad->set_children(0,child_0);
- quad->set_children(2,child_2);
- }
- else
- {
- quad->clear_children();
- quad->clear_refinement_case();
- }
-
-
- }
- break;
- }
- case RefinementCase<dim-1>::cut_xy:
- {
- // if one of the cell counters is
- // zero, the others have to be as
- // well
-
- Assert((quad_cell_count[quad->child_index(0)] == 0 &&
- quad_cell_count[quad->child_index(1)] == 0 &&
- quad_cell_count[quad->child_index(2)] == 0 &&
- quad_cell_count[quad->child_index(3)] == 0) ||
- (quad_cell_count[quad->child_index(0)] > 0 &&
- quad_cell_count[quad->child_index(1)] > 0 &&
- quad_cell_count[quad->child_index(2)] > 0 &&
- quad_cell_count[quad->child_index(3)] > 0),
- ExcInternalError());
-
- if (quad_cell_count[quad->child_index(0)]==0)
- {
- // we may delete the quad's
- // children, the inner lines
- // and the middle vertex as no
- // cell references them anymore
- lines_to_delete.push_back(quad->child(0)->line(1));
- lines_to_delete.push_back(quad->child(3)->line(0));
- lines_to_delete.push_back(quad->child(0)->line(3));
- lines_to_delete.push_back(quad->child(3)->line(2));
-
- for (unsigned int child=0; child<quad->n_children(); ++child)
- quads_to_delete.push_back(quad->child(child));
-
- triangulation.vertices_used[quad->child(0)->vertex_index(3)] = false;
-
- quad->clear_children();
- quad->clear_refinement_case();
- }
- }
- break;
-
- default:
- Assert(false, ExcInternalError());
- break;
- }
-
- }
-
- // now we repeat a similar procedure
- // for the outer lines of this cell.
-
- // if in debug mode: check that each
- // of the lines for which we consider
- // deleting the children in fact has
- // children (the bits/coarsening_3d
- // test tripped over this initially)
- for (unsigned int line_no=0; line_no<GeometryInfo<dim>::lines_per_cell; ++line_no)
- {
- typename Triangulation<dim,spacedim>::line_iterator
- line=cell->line(line_no);
-
- Assert((GeometryInfo<dim>::line_refinement_case(ref_case,line_no) && line->has_children()) ||
- GeometryInfo<dim>::line_refinement_case(ref_case,line_no)==RefinementCase<1>::no_refinement,
- ExcInternalError());
-
- if (line->has_children())
- {
- // if one of the cell counters is
- // zero, the other has to be as well
-
- Assert((line_cell_count[line->child_index(0)] == 0 &&
- line_cell_count[line->child_index(1)] == 0) ||
- (line_cell_count[line->child_index(0)] > 0 &&
- line_cell_count[line->child_index(1)] > 0),
- ExcInternalError());
-
- if (line_cell_count[line->child_index(0)]==0)
- {
- for (unsigned int c=0; c<2; ++c)
- Assert (!line->child(c)->has_children(),
- ExcInternalError());
-
- // we may delete the line's
- // children and the middle vertex
- // as no cell references them
- // anymore
- triangulation.vertices_used[line->child(0)->vertex_index(1)] = false;
-
- lines_to_delete.push_back(line->child(0));
- lines_to_delete.push_back(line->child(1));
-
- line->clear_children();
- }
- }
- }
-
- // finally, delete unneeded quads and lines
-
- // clear user pointers, to avoid that
- // they may appear at unwanted places
- // later on...
- // same for user flags, then finally
- // delete the quads and lines
- typename std::vector<typename Triangulation<dim,spacedim>::line_iterator>::iterator
- line=lines_to_delete.begin(),
- endline=lines_to_delete.end();
- for (; line!=endline; ++line)
- {
- (*line)->clear_user_data();
- (*line)->clear_user_flag();
- (*line)->clear_used_flag();
- }
-
- typename std::vector<typename Triangulation<dim,spacedim>::quad_iterator>::iterator
- quad=quads_to_delete.begin(),
- endquad=quads_to_delete.end();
- for (; quad!=endquad; ++quad)
- {
- (*quad)->clear_user_data();
- (*quad)->clear_children();
- (*quad)->clear_refinement_case();
- (*quad)->clear_user_flag();
- (*quad)->clear_used_flag();
- }
- }
-
-
- /**
- * Create the children of a 2d
- * cell. The arguments indicate
- * the next free spots in the
- * vertices, lines, and cells
- * arrays.
- *
- * The faces of the cell have to
- * be refined already, whereas
- * the inner lines in 2D will be
- * created in this
- * function. Therefore iterator
- * pointers into the vectors of
- * lines, quads and cells have to
- * be passed, which point at (or
- * "before") the reserved space.
- */
- template <int spacedim>
- static
- void
- create_children (Triangulation<2,spacedim> &triangulation,
- unsigned int &next_unused_vertex,
- typename Triangulation<2,spacedim>::raw_line_iterator &next_unused_line,
- typename Triangulation<2,spacedim>::raw_cell_iterator &next_unused_cell,
- typename Triangulation<2,spacedim>::cell_iterator &cell)
- {
- const unsigned int dim=2;
- // clear refinement flag
- const RefinementCase<dim> ref_case=cell->refine_flag_set();
- cell->clear_refine_flag ();
-
-/* For the refinement process: since we go the levels up from the lowest, there
- are (unlike above) only two possibilities: a neighbor cell is on the same
- level or one level up (in both cases, it may or may not be refined later on,
- but we don't care here).
-
- First:
- Set up an array of the 3x3 vertices, which are distributed on the cell
- (the array consists of indices into the @p{vertices} std::vector
-
- 2--7--3
- | | |
- 4--8--5
- | | |
- 0--6--1
-
- note: in case of cut_x or cut_y not all these vertices are needed for the new
- cells
-
- Second:
- Set up an array of the new lines (the array consists of iterator pointers
- into the lines arrays)
-
- .-6-.-7-. The directions are: .->-.->-.
- 1 9 3 ^ ^ ^
- .-10.11-. .->-.->-.
- 0 8 2 ^ ^ ^
- .-4-.-5-. .->-.->-.
-
- cut_x:
- .-4-.-5-.
- | | |
- 0 6 1
- | | |
- .-2-.-3-.
-
- cut_y:
- .---5---.
- 1 3
- .---6---.
- 0 2
- .---4---.
-
-
- Third:
- Set up an array of neighbors:
-
- 6 7
- .--.--.
- 1| | |3
- .--.--.
- 0| | |2
- .--.--.
- 4 5
-
- We need this array for two reasons: first to get the lines which will
- bound the four subcells (if the neighboring cell is refined, these
- lines already exist), and second to update neighborship information.
- Since if a neighbor is not refined, its neighborship record only
- points to the present, unrefined, cell rather than the children we
- are presently creating, we only need the neighborship information
- if the neighbor cells are refined. In all other cases, we store
- the unrefined neighbor address
-
- We also need for every neighbor (if refined) which number among its
- neighbors the present (unrefined) cell has, since that number is to
- be replaced and because that also is the number of the subline which
- will be the interface between that neighbor and the to be created cell.
- We will store this number (between 0 and 3) in the field
- @p{neighbors_neighbor}.
-
- It would be sufficient to use the children of the common line to the
- neighbor, if we only wanted to get the new sublines and the new vertex,
- but because we need to update the neighborship information of the
- two refined subcells of the neighbor, we need to search these anyway.
-
- Convention:
- The created children are numbered like this:
-
- .--.--.
- |2 . 3|
- .--.--.
- |0 | 1|
- .--.--.
-*/
-
- // collect the indices
- // all vertices
- // 2--7--3
- // | | |
- // 4--8--5
- // | | |
- // 0--6--1
- int new_vertices[9];
- for (unsigned int vertex_no=0; vertex_no<4; ++vertex_no)
- new_vertices[vertex_no]=cell->vertex_index(vertex_no);
- for (unsigned int line_no=0; line_no<4; ++line_no)
- if (cell->line(line_no)->has_children())
- new_vertices[4+line_no]=cell->line(line_no)->child(0)->vertex_index(1);
-
- if (ref_case==RefinementCase<dim>::cut_xy)
- {
- // find the next
- // unused vertex and
- // set it
- // appropriately
- while (triangulation.vertices_used[next_unused_vertex] == true)
- ++next_unused_vertex;
- Assert (next_unused_vertex < triangulation.vertices.size(),
- ExcTooFewVerticesAllocated());
- triangulation.vertices_used[next_unused_vertex] = true;
-
- new_vertices[8]=next_unused_vertex;
-
- Point<spacedim> new_point;
- if (dim == spacedim)
- {
- for (unsigned int i=0; i<8; ++i)
- new_point += triangulation.vertices[new_vertices[i]];
- new_point /= 8.0;
- }
- else
- {
- // new vertex is
- // placed on the
- // surface according
- // to the information
- // stored in the
- // boundary class
- new_point =
- triangulation.boundary[cell->material_id()]
- ->get_new_point_on_quad (cell);
- }
-
- triangulation.vertices[new_vertices[8]] = new_point;
-
-
- // if the user_flag is set, i.e. if the
- // cell is at the boundary, use a
- // different calculation of the middle
- // vertex here. this is of advantage, if
- // the boundary is strongly curved and
- // the cell has a high aspect ratio. this
- // can happen for example, if it was
- // refined anisotropically before.
- if (cell->user_flag_set())
- {
- // first reset the user_flag
- cell->clear_user_flag();
- // the user flag indicates: at least
- // one face is at the boundary. if it
- // is only one, set the new middle
- // vertex in a different way to avoid
- // some mis-shaped elements if the
- // new point on the boundary is not
- // where we expect it, especially if
- // it is to far inside the current
- // cell
- unsigned int bound_face=GeometryInfo<dim>::faces_per_cell;
- for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->face(face)->at_boundary())
- {
- if (bound_face == GeometryInfo<dim>::faces_per_cell)
- // no boundary face found so
- // far, so set it now
- bound_face=face;
- else
- // there is another boundary
- // face, so reset bound_face to
- // invalid value as a flag to
- // do nothing in the following
- bound_face=GeometryInfo<dim>::faces_per_cell+1;
- }
-
- if (bound_face<GeometryInfo<dim>::faces_per_cell)
- // reset the cell's middle vertex
- // to the middle of the straight
- // connection between the new
- // points on this face and on the
- // opposite face
- triangulation.vertices[new_vertices[8]]
- = 0.5*(cell->face(bound_face)
- ->child(0)->vertex(1)+
- cell->face(GeometryInfo<dim>
- ::opposite_face[bound_face])
- ->child(0)->vertex(1));
- }
- }
-
-
- // Now the lines:
- typename Triangulation<dim,spacedim>::raw_line_iterator new_lines[12];
- unsigned int lmin=8;
- unsigned int lmax=12;
- if (ref_case!=RefinementCase<dim>::cut_xy)
- {
- lmin=6;
- lmax=7;
- }
-
- for (unsigned int l=lmin; l<lmax; ++l)
- {
- while (next_unused_line->used() == true)
- ++next_unused_line;
- new_lines[l] = next_unused_line;
- ++next_unused_line;
-
- Assert (new_lines[l]->used() == false,
- ExcCellShouldBeUnused());
- }
-
- if (ref_case==RefinementCase<dim>::cut_xy)
- {
- // .-6-.-7-.
- // 1 9 3
- // .-10.11-.
- // 0 8 2
- // .-4-.-5-.
-
- // lines 0-7 already
- // exist, create only
- // the four interior
- // lines 8-11
- unsigned int l=0;
- for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell; ++face_no)
- for (unsigned int c=0; c<2; ++c, ++l)
- new_lines[l]=cell->line(face_no)->child(c);
- Assert(l==8, ExcInternalError());
-
- new_lines[8] ->set (internal::Triangulation::
- TriaObject<1>(new_vertices[6], new_vertices[8]));
- new_lines[9] ->set (internal::Triangulation::
- TriaObject<1>(new_vertices[8], new_vertices[7]));
- new_lines[10]->set (internal::Triangulation::
- TriaObject<1>(new_vertices[4], new_vertices[8]));
- new_lines[11]->set (internal::Triangulation::
- TriaObject<1>(new_vertices[8], new_vertices[5]));
- }
- else if (ref_case==RefinementCase<dim>::cut_x)
- {
- // .-4-.-5-.
- // | | |
- // 0 6 1
- // | | |
- // .-2-.-3-.
- new_lines[0]=cell->line(0);
- new_lines[1]=cell->line(1);
- new_lines[2]=cell->line(2)->child(0);
- new_lines[3]=cell->line(2)->child(1);
- new_lines[4]=cell->line(3)->child(0);
- new_lines[5]=cell->line(3)->child(1);
- new_lines[6]->set (internal::Triangulation::
- TriaObject<1>(new_vertices[6], new_vertices[7]));
- }
- else
- {
- Assert(ref_case==RefinementCase<dim>::cut_y, ExcInternalError());
- // .---5---.
- // 1 3
- // .---6---.
- // 0 2
- // .---4---.
- new_lines[0]=cell->line(0)->child(0);
- new_lines[1]=cell->line(0)->child(1);
- new_lines[2]=cell->line(1)->child(0);
- new_lines[3]=cell->line(1)->child(1);
- new_lines[4]=cell->line(2);
- new_lines[5]=cell->line(3);
- new_lines[6]->set (internal::Triangulation::
- TriaObject<1>(new_vertices[4], new_vertices[5]));
- }
-
- for (unsigned int l=lmin; l<lmax; ++l)
- {
- new_lines[l]->set_used_flag();
- new_lines[l]->clear_user_flag();
- new_lines[l]->clear_user_data();
- new_lines[l]->clear_children();
- // interior line
- new_lines[l]->set_boundary_indicator(255);
- }
-
- // Now add the four (two)
- // new cells!
- typename Triangulation<dim,spacedim>::raw_cell_iterator
- subcells[GeometryInfo<dim>::max_children_per_cell];
- while (next_unused_cell->used() == true)
- ++next_unused_cell;
-
- const unsigned int n_children=
- GeometryInfo<dim>::n_children(ref_case);
- for (unsigned int i=0; i<n_children; ++i)
- {
- Assert (next_unused_cell->used() == false,
- ExcCellShouldBeUnused());
- subcells[i] = next_unused_cell;
- ++next_unused_cell;
- if (i%2==1 && i<n_children-1)
- while (next_unused_cell->used() == true)
- ++next_unused_cell;
- }
-
- if (ref_case==RefinementCase<dim>::cut_xy)
- {
- // children:
- // .--.--.
- // |2 . 3|
- // .--.--.
- // |0 | 1|
- // .--.--.
- // lines:
- // .-6-.-7-.
- // 1 9 3
- // .-10.11-.
- // 0 8 2
- // .-4-.-5-.
- subcells[0]->set (internal::Triangulation::
- TriaObject<2>(new_lines[0]->index(),
- new_lines[8]->index(),
- new_lines[4]->index(),
- new_lines[10]->index()));
- subcells[1]->set (internal::Triangulation::
- TriaObject<2>(new_lines[8]->index(),
- new_lines[2]->index(),
- new_lines[5]->index(),
- new_lines[11]->index()));
- subcells[2]->set (internal::Triangulation::
- TriaObject<2>(new_lines[1]->index(),
- new_lines[9]->index(),
- new_lines[10]->index(),
- new_lines[6]->index()));
- subcells[3]->set (internal::Triangulation::
- TriaObject<2>(new_lines[9]->index(),
- new_lines[3]->index(),
- new_lines[11]->index(),
- new_lines[7]->index()));
- }
- else if (ref_case==RefinementCase<dim>::cut_x)
- {
- // children:
- // .--.--.
- // | . |
- // .0 . 1.
- // | | |
- // .--.--.
- // lines:
- // .-4-.-5-.
- // | | |
- // 0 6 1
- // | | |
- // .-2-.-3-.
- subcells[0]->set (internal::Triangulation::
- TriaObject<2>(new_lines[0]->index(),
- new_lines[6]->index(),
- new_lines[2]->index(),
- new_lines[4]->index()));
- subcells[1]->set (internal::Triangulation::
- TriaObject<2>(new_lines[6]->index(),
- new_lines[1]->index(),
- new_lines[3]->index(),
- new_lines[5]->index()));
- }
- else
- {
- Assert(ref_case==RefinementCase<dim>::cut_y, ExcInternalError());
- // children:
- // .-----.
- // | 1 |
- // .-----.
- // | 0 |
- // .-----.
- // lines:
- // .---5---.
- // 1 3
- // .---6---.
- // 0 2
- // .---4---.
- subcells[0]->set (internal::Triangulation::
- TriaObject<2>(new_lines[0]->index(),
- new_lines[2]->index(),
- new_lines[4]->index(),
- new_lines[6]->index()));
- subcells[1]->set (internal::Triangulation::
- TriaObject<2>(new_lines[1]->index(),
- new_lines[3]->index(),
- new_lines[6]->index(),
- new_lines[5]->index()));
- }
-
-
- for (unsigned int i=0; i<n_children; ++i)
- {
- subcells[i]->set_used_flag();
- subcells[i]->clear_refine_flag();
- subcells[i]->clear_user_flag();
- subcells[i]->clear_user_data();
- subcells[i]->clear_children();
- // inherit material
- // properties
- subcells[i]->set_material_id (cell->material_id());
- subcells[i]->set_subdomain_id (cell->subdomain_id());
-
- if (i%2==0)
- subcells[i]->set_parent (cell->index ());
- }
-
-
-
- // set child index for
- // even children children
- // i=0,2 (0)
- for (unsigned int i=0; i<n_children/2; ++i)
- cell->set_children (2*i, subcells[2*i]->index());
- // set the refine case
- cell->set_refinement_case(ref_case);
-
- // note that the
- // refinement flag was
- // already cleared at the
- // beginning of this function
- }
-
-
-
- /**
- * A function that performs the
- * refinement of a triangulation in 1d.
- */
- template <int spacedim>
- static
- typename Triangulation<1,spacedim>::DistortedCellList
- execute_refinement (Triangulation<1,spacedim> &triangulation,
- const bool /*check_for_distorted_cells*/)
- {
- const unsigned int dim = 1;
-
- // check whether a new level is
- // needed we have to check for this
- // on the highest level only (on
- // this, all used cells are also
- // active, so we only have to check
- // for this)
- {
- typename Triangulation<dim,spacedim>::raw_cell_iterator
- cell = triangulation.begin_active (triangulation.levels.size()-1),
- endc = triangulation.end();
- for (; cell != endc; ++cell)
- if (cell->used())
- if (cell->refine_flag_set())
- {
- triangulation.levels
- .push_back (new internal::Triangulation::TriaLevel<dim>);
- break;
- }
- }
-
-
- // check how much space is needed
- // on every level we need not check
- // the highest level since either -
- // on the highest level no cells
- // are flagged for refinement -
- // there are, but
- // prepare_refinement added another
- // empty level
- unsigned int needed_vertices = 0;
- for (int level=triangulation.levels.size()-2; level>=0; --level)
- {
- // count number of flagged
- // cells on this level
- unsigned int flagged_cells = 0;
- typename Triangulation<dim,spacedim>::active_cell_iterator
- acell = triangulation.begin_active(level),
- aendc = triangulation.begin_active(level+1);
- for (; acell!=aendc; ++acell)
- if (acell->refine_flag_set())
- ++flagged_cells;
-
- // count number of used cells
- // on the next higher level
- const unsigned int used_cells
- = std::count_if (triangulation.levels[level+1]->cells.used.begin(),
- triangulation.levels[level+1]->cells.used.end(),
- std::bind2nd (std::equal_to<bool>(), true));
-
- // reserve space for the
- // used_cells cells already
- // existing on the next higher
- // level as well as for the
- // 2*flagged_cells that will be
- // created on that level
- triangulation.levels[level+1]
- ->reserve_space(used_cells+
- GeometryInfo<1>::max_children_per_cell *
- flagged_cells,
- 1);
- // reserve space for
- // 2*flagged_cells new lines on
- // the next higher level
- triangulation.levels[level+1]->cells
- .reserve_space (GeometryInfo<1>::max_children_per_cell *
- flagged_cells,
- 0);
-
- needed_vertices += flagged_cells;
- }
-
- // add to needed vertices how many
- // vertices are already in use
- needed_vertices += std::count_if (triangulation.vertices_used.begin(),
- triangulation.vertices_used.end(),
- std::bind2nd (std::equal_to<bool>(),
- true));
- // if we need more vertices: create
- // them, if not: leave the array as
- // is, since shrinking is not
- // really possible because some of
- // the vertices at the end may be
- // in use
- if (needed_vertices > triangulation.vertices.size())
- {
- triangulation.vertices.resize (needed_vertices,
- Point<spacedim>());
- triangulation.vertices_used.resize (needed_vertices, false);
- }
-
-
- // Do REFINEMENT
- // on every level; exclude highest
- // level as above
-
- // index of next unused vertex
- unsigned int next_unused_vertex = 0;
-
- for (int level=triangulation.levels.size()-2; level>=0; --level)
- {
- typename Triangulation<dim,spacedim>::active_cell_iterator
- cell = triangulation.begin_active(level),
- endc = triangulation.begin_active(level+1);
-
- typename Triangulation<dim,spacedim>::raw_cell_iterator
- next_unused_cell = triangulation.begin_raw (level+1);
-
- for (; (cell!=endc) && (cell->level()==level); ++cell)
- if (cell->refine_flag_set())
- {
- // clear refinement flag
- cell->clear_refine_flag ();
-
- // search for next unused
- // vertex
- while (triangulation.vertices_used[next_unused_vertex] == true)
- ++next_unused_vertex;
- Assert (next_unused_vertex < triangulation.vertices.size(),
- ExcTooFewVerticesAllocated());
-
- // first insert new
- // vertex. if dim==spacedim
- // then simply use the
- // midpoint; otherwise we
- // have to ask the manifold
- // object
- if (dim == spacedim)
- triangulation.vertices[next_unused_vertex] =
- (cell->vertex(0) + cell->vertex(1)) / 2;
- else
- triangulation.vertices[next_unused_vertex] =
- triangulation.boundary[cell->material_id()]
- ->get_new_point_on_line(cell);
- triangulation.vertices_used[next_unused_vertex] = true;
-
- // search for next two
- // unused cell (++ takes
- // care of the end of the
- // vector)
- typename Triangulation<dim,spacedim>::raw_cell_iterator
- first_child,
- second_child;
- while (next_unused_cell->used() == true)
- ++next_unused_cell;
- first_child = next_unused_cell;
- first_child->set_used_flag ();
- first_child->clear_user_data ();
- ++next_unused_cell;
- Assert (next_unused_cell->used() == false,
- ExcCellShouldBeUnused());
- second_child = next_unused_cell;
- second_child->set_used_flag ();
- second_child->clear_user_data ();
-
- // insert first child
- cell->set_children (0, first_child->index());
- first_child->clear_children ();
- first_child->set (internal::Triangulation
- ::TriaObject<1> (cell->vertex_index(0),
- next_unused_vertex));
- first_child->set_material_id (cell->material_id());
- first_child->set_subdomain_id (cell->subdomain_id());
- first_child->set_parent (cell->index ());
-
- // reset neighborship info (refer
- // to
- // internal::Triangulation::TriaLevel<0>
- // for details)
- first_child->set_neighbor (1, second_child);
- if (cell->neighbor(0).state() != IteratorState::valid)
- first_child->set_neighbor (0, cell->neighbor(0));
- else
- if (cell->neighbor(0)->active())
- {
- // since the
- // neighbors level
- // is always
- // <=level, if the
- // cell is active,
- // then there are
- // no cells to the
- // left which may
- // want to know
- // about this new
- // child cell.
- Assert (cell->neighbor(0)->level() <= cell->level(),
- ExcInternalError());
- first_child->set_neighbor (0, cell->neighbor(0));
- }
- else
- // left neighbor is
- // refined
- {
- // set neighbor to
- // cell on same
- // level
- first_child->set_neighbor (0, cell->neighbor(0)->child(1));
-
- // reset neighbor
- // info of all
- // right descendant
- // of the left
- // neighbor of cell
- typename Triangulation<dim,spacedim>::cell_iterator
- left_neighbor = cell->neighbor(0);
- while (left_neighbor->has_children())
- {
- left_neighbor = left_neighbor->child(1);
- left_neighbor->set_neighbor (1, first_child);
- }
- }
-
- // insert second child
- second_child->clear_children ();
- second_child->set (internal::Triangulation
- ::TriaObject<1>(next_unused_vertex,
- cell->vertex_index(1)));
- second_child->set_neighbor (0, first_child);
- second_child->set_material_id (cell->material_id());
- second_child->set_subdomain_id (cell->subdomain_id());
- if (cell->neighbor(1).state() != IteratorState::valid)
- second_child->set_neighbor (1, cell->neighbor(1));
- else
- if (cell->neighbor(1)->active())
- {
- Assert (cell->neighbor(1)->level() <= cell->level(),
- ExcInternalError());
- second_child->set_neighbor (1, cell->neighbor(1));
- }
- else
- // right neighbor is
- // refined same as
- // above
- {
- second_child->set_neighbor (1, cell->neighbor(1)->child(0));
-
- typename Triangulation<dim,spacedim>::cell_iterator
- right_neighbor = cell->neighbor(1);
- while (right_neighbor->has_children())
- {
- right_neighbor = right_neighbor->child(0);
- right_neighbor->set_neighbor (0, second_child);
- }
- }
- }
- }
-
- // in 1d, we can not have
- // distorted children
- // unless the parent was
- // already distorted
- // (that is because we
- // don't use boundary
- // information for 1d
- // triangulations). so
- // return an empty list
- return typename Triangulation<1,spacedim>::DistortedCellList();
- }
-
-
- /**
- * A function that performs the
- * refinement of a triangulation in 2d.
- */
- template <int spacedim>
- static
- typename Triangulation<2,spacedim>::DistortedCellList
- execute_refinement (Triangulation<2,spacedim> &triangulation,
- const bool check_for_distorted_cells)
- {
- const unsigned int dim = 2;
-
- // check whether a new level is
- // needed we have to check for this
- // on the highest level only (on
- // this, all used cells are also
- // active, so we only have to check
- // for this)
- if (true)
- {
- typename Triangulation<dim,spacedim>::raw_cell_iterator
- cell = triangulation.begin_active (triangulation.levels.size()-1),
- endc = triangulation.end();
- for (; cell != endc; ++cell)
- if (cell->used())
- if (cell->refine_flag_set())
- {
- triangulation.levels.push_back (new internal::Triangulation::TriaLevel<dim>);
- break;
- }
- }
-
-
- // first clear user flags and
- // pointers of lines; we're going
- // to use them to flag which lines
- // need refinement
- for (typename Triangulation<dim,spacedim>::line_iterator
- line=triangulation.begin_line(); line!=triangulation.end_line(); ++line)
- {
- line->clear_user_flag();
- line->clear_user_data();
- }
- // running over all cells and lines
- // count the number
- // n_single_lines of lines
- // which can be stored as
- // single lines, e.g. inner lines
- unsigned int n_single_lines=0;
- // New lines to be created:
- // number lines which are
- // stored in pairs (the
- // children of lines must be
- // stored in pairs)
- unsigned int n_lines_in_pairs = 0;
-
- // check how much space is needed
- // on every level we need not check
- // the highest level since either
- // - on the highest level no cells
- // are flagged for refinement
- // - there are, but prepare_refinement
- // added another empty level
- unsigned int needed_vertices = 0;
- for (int level=triangulation.levels.size()-2; level>=0; --level)
- {
- // count number of flagged
- // cells on this level and
- // compute how many new
- // vertices and new lines will
- // be needed
- unsigned int needed_cells = 0;
-
- typename Triangulation<dim,spacedim>::active_cell_iterator
- cell = triangulation.begin_active(level),
- endc = triangulation.begin_active(level+1);
- for (; cell!=endc; ++cell)
- if (cell->refine_flag_set())
- {
- if (cell->refine_flag_set()==RefinementCase<dim>::cut_xy)
- {
- needed_cells += 4;
-
- // new vertex at
- // center of cell is
- // needed in any case
- ++needed_vertices;
- // the four inner
- // lines can be
- // stored as singles
- n_single_lines += 4;
- }
- else // cut_x || cut_y
- {
- // set the flag showing that
- // anisotropic refinement is
- // used for at least one cell
- triangulation.anisotropic_refinement = true;
-
- needed_cells += 2;
- // no vertex at center
-
- // the inner line can
- // be stored as
- // single
- n_single_lines += 1;
-
- }
-
- // mark all faces
- // (lines) for
- // refinement;
- // checking locally
- // whether the
- // neighbor would
- // also like to
- // refine them is
- // rather difficult
- // for lines so we
- // only flag them and
- // after visiting all
- // cells, we decide
- // which lines need
- // refinement;
- for (unsigned int line_no=0; line_no<GeometryInfo<dim>::faces_per_cell;
- ++line_no)
- {
- if (GeometryInfo<dim>::face_refinement_case(
- cell->refine_flag_set(), line_no)==RefinementCase<1>::cut_x)
- {
- typename Triangulation<dim,spacedim>::line_iterator
- line = cell->line(line_no);
- if (line->has_children() == false)
- {
- line->set_user_flag ();
-//TODO[WB]: we overwrite the user_index here because we later on need to find
-// out which boundary object we have to ask to refine this line. find a better
-// way to do that
- if (spacedim > dim)
- line->set_user_index(cell->material_id());
- }
- }
- }
- }
-
-
- // count number of used cells
- // on the next higher level
- const unsigned int used_cells
- = std::count_if (triangulation.levels[level+1]->cells.used.begin(),
- triangulation.levels[level+1]->cells.used.end(),
- std::bind2nd (std::equal_to<bool>(), true));
-
-
- // reserve space for the
- // used_cells cells already
- // existing on the next higher
- // level as well as for the
- // needed_cells that will be
- // created on that level
- triangulation.levels[level+1]->reserve_space (used_cells+needed_cells, 2);
-
- // reserve space for
- // needed_cells
- // new quads on the next higher
- // level
- triangulation.levels[level+1]->cells.
- reserve_space (needed_cells,0);
- }
-
- // now count the lines which
- // were flagged for refinement
- for (typename Triangulation<dim,spacedim>::line_iterator
- line=triangulation.begin_line(); line!=triangulation.end_line(); ++line)
- if (line->user_flag_set())
- {
- Assert (line->has_children() == false, ExcInternalError());
- n_lines_in_pairs += 2;
- needed_vertices += 1;
- }
- // reserve space for
- // n_lines_in_pairs new lines.
- // note, that we can't reserve space
- // for the single lines here as well,
- // as all the space reserved for lines
- // in pairs would be counted as unused
- // and we would end up with too little
- // space to store all lines. memory
- // reservation for n_single_lines can
- // only be done AFTER we refined the lines
- // of the current cells
- triangulation.faces->lines.
- reserve_space (n_lines_in_pairs, 0);
-
- // add to needed vertices how many
- // vertices are already in use
- needed_vertices += std::count_if (triangulation.vertices_used.begin(), triangulation.vertices_used.end(),
- std::bind2nd (std::equal_to<bool>(), true));
- // if we need more vertices: create
- // them, if not: leave the array as
- // is, since shrinking is not
- // really possible because some of
- // the vertices at the end may be
- // in use
- if (needed_vertices > triangulation.vertices.size())
- {
- triangulation.vertices.resize (needed_vertices, Point<spacedim>());
- triangulation.vertices_used.resize (needed_vertices, false);
- }
-
-
- // Do REFINEMENT
- // on every level; exclude highest
- // level as above
-
- // index of next unused vertex
- unsigned int next_unused_vertex = 0;
-
- // first the refinement of lines.
- // children are stored pairwise
- if (true)
- {
- // only active objects can be
- // refined further
- typename Triangulation<dim,spacedim>::active_line_iterator
- line = triangulation.begin_active_line(),
- endl = triangulation.end_line();
- typename Triangulation<dim,spacedim>::raw_line_iterator
- next_unused_line = triangulation.begin_raw_line ();
-
- for (; line!=endl; ++line)
- if (line->user_flag_set())
- {
- // this line needs to be
- // refined
-
- // find the next unused
- // vertex and set it
- // appropriately
- while (triangulation.vertices_used[next_unused_vertex] == true)
- ++next_unused_vertex;
- Assert (next_unused_vertex < triangulation.vertices.size(),
- ExcTooFewVerticesAllocated());
- triangulation.vertices_used[next_unused_vertex] = true;
-
- if (spacedim == dim)
- {
- // for the case of a domain
- // in an equal-dimensional
- // space we only have to
- // treat boundary lines
- // differently; for interior
- // lines we can compute the
- // midpoint as the mean of
- // the two vertices:
- if (line->at_boundary())
- triangulation.vertices[next_unused_vertex]
- = triangulation.boundary[line->boundary_indicator()]
- ->get_new_point_on_line (line);
- else
- triangulation.vertices[next_unused_vertex]
- = (line->vertex(0) + line->vertex(1)) / 2;
- }
- else
- // however, if spacedim>dim, we
- // always have to ask the
- // boundary object for its
- // answer
- triangulation.vertices[next_unused_vertex]
- = triangulation.boundary[line->user_index()]->get_new_point_on_line (line);
-
- // now that we created
- // the right point, make
- // up the two child
- // lines. To this end,
- // find a pair of unused
- // lines
- bool pair_found=false;
- for (; next_unused_line!=endl; ++next_unused_line)
- if (!next_unused_line->used() &&
- !(++next_unused_line)->used())
- {
- // go back to the
- // first of the two
- // unused lines
- --next_unused_line;
- pair_found=true;
- break;
- }
- Assert (pair_found, ExcInternalError());
-
- // there are now two
- // consecutive unused
- // lines, such that the
- // children of a line
- // will be consecutive.
- // then set the child
- // pointer of the present
- // line
- line->set_children (0, next_unused_line->index());
-
- // set the two new lines
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- children[2] = { next_unused_line,
- ++next_unused_line };
- // some tests; if any of
- // the iterators should
- // be invalid, then
- // already dereferencing
- // will fail
- Assert (children[0]->used() == false, ExcCellShouldBeUnused());
- Assert (children[1]->used() == false, ExcCellShouldBeUnused());
-
- children[0]->set (internal::Triangulation
- ::TriaObject<1>(line->vertex_index(0),
- next_unused_vertex));
- children[1]->set (internal::Triangulation
- ::TriaObject<1>(next_unused_vertex,
- line->vertex_index(1)));
-
- children[0]->set_used_flag();
- children[1]->set_used_flag();
- children[0]->clear_children();
- children[1]->clear_children();
- children[0]->clear_user_data();
- children[1]->clear_user_data();
- children[0]->clear_user_flag();
- children[1]->clear_user_flag();
-
- children[0]->set_boundary_indicator (line->boundary_indicator());
- children[1]->set_boundary_indicator (line->boundary_indicator());
-
- // finally clear flag
- // indicating the need
- // for refinement
- line->clear_user_flag ();
- }
- }
-
-
- // Now set up the new cells
-
- // reserve space for inner
- // lines (can be stored as
- // single lines)
- triangulation.faces->lines.
- reserve_space (0,n_single_lines);
-
- typename Triangulation<2,spacedim>::DistortedCellList
- cells_with_distorted_children;
-
- // reset next_unused_line, as
- // now also single empty places
- // in the vector can be used
- typename Triangulation<dim,spacedim>::raw_line_iterator
- next_unused_line = triangulation.begin_raw_line ();
-
- for (int level=0; level<static_cast<int>(triangulation.levels.size())-1; ++level)
- {
-
- // Remember: as we don't operate
- // on the finest level, begin_*(level+1)
- // is allowed
- typename Triangulation<dim,spacedim>::active_cell_iterator
- cell = triangulation.begin_active(level),
- endc = triangulation.begin_active(level+1);
-
- typename Triangulation<dim,spacedim>::raw_cell_iterator
- next_unused_cell = triangulation.begin_raw (level+1);
-
- for (; cell!=endc; ++cell)
- if (cell->refine_flag_set())
- {
- // set the user flag to
- // indicate, that at least one
- // line is at the boundary
-
- // TODO[Tobias Leicht] find a
- // better place to set this flag,
- // so that we do not need so much
- // time to check each cell here
- if (cell->at_boundary())
- cell->set_user_flag();
-
- // actually set up the children and
- // update neighbor information
- create_children (triangulation,
- next_unused_vertex,
- next_unused_line,
- next_unused_cell,
- cell);
-
- if ((check_for_distorted_cells == true)
- &&
- has_distorted_children (cell,
- internal::int2type<dim>(),
- internal::int2type<spacedim>()))
- cells_with_distorted_children.distorted_cells.push_back (cell);
- }
- }
-
- return cells_with_distorted_children;
- }
-
-
- /**
- * A function that performs the
- * refinement of a triangulation in 3d.
- */
- template <int spacedim>
- static
- typename Triangulation<3,spacedim>::DistortedCellList
- execute_refinement (Triangulation<3,spacedim> &triangulation,
- const bool check_for_distorted_cells)
- {
- const unsigned int dim = 3;
-
- // this function probably
- // also works for spacedim>3
- // but it isn't tested. it
- // will probably be necessary
- // to pull new vertices onto
- // the manifold just as we do
- // for the other functions
- // above.
- Assert (spacedim == 3, ExcNotImplemented());
-
- // check whether a new level is
- // needed we have to check for this
- // on the highest level only (on
- // this, all used cells are also
- // active, so we only have to check
- // for this)
- if (true)
- {
- typename Triangulation<dim,spacedim>::raw_cell_iterator
- cell = triangulation.begin_active (triangulation.levels.size()-1),
- endc = triangulation.end();
- for (; cell != endc; ++cell)
- if (cell->used())
- if (cell->refine_flag_set())
- {
- triangulation.levels.push_back (new internal::Triangulation::TriaLevel<dim>);
- break;
- }
- }
-
-
- // first clear user flags for quads
- // and lines; we're going to use them
- // to flag which lines and quads
- // need refinement
- triangulation.faces->quads.clear_user_data();
-
- for (typename Triangulation<dim,spacedim>::line_iterator
- line=triangulation.begin_line(); line!=triangulation.end_line(); ++line)
- line->clear_user_flag();
- for (typename Triangulation<dim,spacedim>::quad_iterator
- quad=triangulation.begin_quad(); quad!=triangulation.end_quad(); ++quad)
- quad->clear_user_flag();
-
- // create an array of face refine cases. User
- // indices of faces will be set to values
- // corresponding with indices in this array.
- const RefinementCase<dim-1> face_refinement_cases[4]=
- {RefinementCase<dim-1>::no_refinement,
- RefinementCase<dim-1>::cut_x,
- RefinementCase<dim-1>::cut_y,
- RefinementCase<dim-1>::cut_xy};
-
- // check how much space is needed
- // on every level
- // we need not check the highest
- // level since either
- // - on the highest level no cells
- // are flagged for refinement
- // - there are, but prepare_refinement
- // added another empty level which
- // then is the highest level
-
- // variables to hold the number of newly to
- // be created vertices, lines and quads. as
- // these are stored globally, declare them
- // outside the loop over al levels. we need
- // lines and quads in pairs for refinement of
- // old ones and lines and quads, that can be
- // stored as single ones, as they are newly
- // created in the inside of an existing cell
- unsigned int needed_vertices = 0;
- unsigned int needed_lines_single = 0;
- unsigned int needed_quads_single = 0;
- unsigned int needed_lines_pair = 0;
- unsigned int needed_quads_pair = 0;
- for (int level=triangulation.levels.size()-2; level>=0; --level)
- {
- // count number of flagged
- // cells on this level and
- // compute how many new
- // vertices and new lines will
- // be needed
- unsigned int new_cells = 0;
-
- typename Triangulation<dim,spacedim>::active_cell_iterator
- acell = triangulation.begin_active(level),
- aendc = triangulation.begin_active(level+1);
- for (; acell!=aendc; ++acell)
- if (acell->refine_flag_set())
- {
- RefinementCase<dim> ref_case=acell->refine_flag_set();
-
- // now for interior vertices, lines
- // and quads, which are needed in
- // any case
- if (ref_case==RefinementCase<dim>::cut_x ||
- ref_case==RefinementCase<dim>::cut_y ||
- ref_case==RefinementCase<dim>::cut_z)
- {
- ++needed_quads_single;
- new_cells+=2;
- triangulation.anisotropic_refinement=true;
- }
- else if (ref_case==RefinementCase<dim>::cut_xy ||
- ref_case==RefinementCase<dim>::cut_xz ||
- ref_case==RefinementCase<dim>::cut_yz)
- {
- ++needed_lines_single;
- needed_quads_single += 4;
- new_cells+=4;
- triangulation.anisotropic_refinement=true;
- }
- else if (ref_case==RefinementCase<dim>::cut_xyz)
- {
- ++needed_vertices;
- needed_lines_single += 6;
- needed_quads_single += 12;
- new_cells+=8;
- }
- else
- {
- // we should never get here
- Assert(false, ExcInternalError());
- }
-
- // mark all faces for refinement;
- // checking locally
- // if and how the neighbor
- // would like to
- // refine these is
- // difficult so
- // we only flag them and
- // after visiting all
- // cells, we decide which
- // faces need which refinement;
- for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell;
- ++face)
- {
- typename Triangulation<dim,spacedim>::face_iterator
- aface = acell->face(face);
- // get the RefineCase this
- // faces has for the given
- // RefineCase of the cell
- RefinementCase<dim-1> face_ref_case=
- GeometryInfo<dim>::face_refinement_case(ref_case,
- face,
- acell->face_orientation(face),
- acell->face_flip(face),
- acell->face_rotation(face));
- // only do something, if this
- // face has to be refined
- if (face_ref_case)
- {
- if (face_ref_case==RefinementCase<dim-1>::isotropic_refinement)
- {
- if (aface->number_of_children()<4)
- // we use user_flags to
- // denote needed isotropic
- // refinement
- aface->set_user_flag();
- }
- else if (aface->refinement_case()!=face_ref_case)
- // we use user_indices
- // to denote needed
- // anisotropic
- // refinement. note, that
- // we can have at most
- // one anisotropic
- // refinement case for
- // this face, as
- // otherwise
- // prepare_refinement()
- // would have changed one
- // of the cells to yield
- // isotropic refinement
- // at this
- // face. therefore we set
- // the user_index
- // uniquely
- {
- Assert(aface->refinement_case()==RefinementCase<dim-1>::isotropic_refinement ||
- aface->refinement_case()==RefinementCase<dim-1>::no_refinement,
- ExcInternalError());
- aface->set_user_index(face_ref_case);
- }
- }
- }// for all faces
-
- // flag all lines, that have to be
- // refined
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- if (GeometryInfo<dim>::line_refinement_case(ref_case,line) &&
- !acell->line(line)->has_children())
- acell->line(line)->set_user_flag();
-
- }// if refine_flag set and for all cells on this level
-
-
- // count number of used cells on
- // the next higher level
- const unsigned int used_cells
- = std::count_if (triangulation.levels[level+1]->cells.used.begin(),
- triangulation.levels[level+1]->cells.used.end(),
- std::bind2nd (std::equal_to<bool>(), true));
-
-
- // reserve space for the
- // used_cells cells already
- // existing on the next higher
- // level as well as for the
- // 8*flagged_cells that will be
- // created on that level
- triangulation.levels[level+1]->reserve_space (used_cells+new_cells, 3);
- // reserve space for
- // 8*flagged_cells
- // new hexes on the next higher
- // level
- triangulation.levels[level+1]->cells.reserve_space (new_cells);
- }// for all levels
- // now count the quads and
- // lines which were flagged for
- // refinement
- for (typename Triangulation<dim,spacedim>::quad_iterator
- quad=triangulation.begin_quad(); quad!=triangulation.end_quad(); ++quad)
- {
- if (quad->user_flag_set())
- {
- // isotropic refinement: 1 interior
- // vertex, 4 quads and 4 interior
- // lines. we store the interior lines
- // in pairs in case the face is
- // already or will be refined
- // anisotropically
- needed_quads_pair += 4;
- needed_lines_pair += 4;
- needed_vertices += 1;
- }
- if (quad->user_index())
- {
- // anisotropic refinement: 1 interior
- // line and two quads
- needed_quads_pair += 2;
- needed_lines_single += 1;
- // there is a kind of complicated
- // situation here which requires our
- // attention. if the quad is refined
- // isotropcally, two of the interior
- // lines will get a new mother line -
- // the interior line of our
- // anisotropically refined quad. if
- // those two lines are not
- // consecutive, we cannot do so and
- // have to replace them by two lines
- // that are consecutive. we try to
- // avoid that situation, but it may
- // happen nevertheless throug
- // repeated refinement and
- // coarsening. thus we have to check
- // here, as we will need some
- // additional space to store those
- // new lines in case we need them...
- if (quad->has_children())
- {
- Assert(quad->refinement_case()==RefinementCase<dim-1>::isotropic_refinement, ExcInternalError());
- if ((face_refinement_cases[quad->user_index()]==RefinementCase<dim-1>::cut_x
- && (quad->child(0)->line_index(1)+1!=quad->child(2)->line_index(1))) ||
- (face_refinement_cases[quad->user_index()]==RefinementCase<dim-1>::cut_y
- && (quad->child(0)->line_index(3)+1!=quad->child(1)->line_index(3))))
- needed_lines_pair +=2;
- }
- }
- }
-
- for (typename Triangulation<dim,spacedim>::line_iterator
- line=triangulation.begin_line(); line!=triangulation.end_line(); ++line)
- if (line->user_flag_set())
- {
- needed_lines_pair += 2;
- needed_vertices += 1;
- }
-
- // reserve space for
- // needed_lines new lines
- // stored in pairs
- triangulation.faces->lines.
- reserve_space (needed_lines_pair,needed_lines_single);
- // reserve space for
- // needed_quads new quads
- // stored in pairs
- triangulation.faces->quads.
- reserve_space (needed_quads_pair,needed_quads_single);
-
-
- // add to needed vertices how many
- // vertices are already in use
- needed_vertices += std::count_if (triangulation.vertices_used.begin(), triangulation.vertices_used.end(),
- std::bind2nd (std::equal_to<bool>(), true));
- // if we need more vertices: create
- // them, if not: leave the array as
- // is, since shrinking is not
- // really possible because some of
- // the vertices at the end may be
- // in use
- if (needed_vertices > triangulation.vertices.size())
- {
- triangulation.vertices.resize (needed_vertices, Point<spacedim>());
- 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,
- // i.e. there are cells adjacent at
- // one line ("around the edge", but
- // not at a face), with two cells
- // differing by more than one
- // refinement level
- //
- // this check is very simple to
- // implement here, since we have
- // all lines flagged if they shall
- // be refined
-#ifdef DEBUG
- for (typename Triangulation<dim,spacedim>::active_cell_iterator
- cell=triangulation.begin_active(); cell!=triangulation.end(); ++cell)
- if (!cell->refine_flag_set())
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- if (cell->line(line)->has_children())
- for (unsigned int c=0; c<2; ++c)
- Assert (cell->line(line)->child(c)->user_flag_set() == false,
- ExcInternalError());
-#endif
-
- ///////////////////////////////////////////
- // Do refinement on every level
- //
- // To make life a bit easier, we
- // first refine those lines and
- // quads that were flagged for
- // refinement and then compose the
- // newly to be created cells.
- //
- // index of next unused vertex
- unsigned int next_unused_vertex = 0;
-
- // first for lines
- if (true)
- {
- // only active objects can be
- // refined further
- typename Triangulation<dim,spacedim>::active_line_iterator
- line = triangulation.begin_active_line(),
- endl = triangulation.end_line();
- typename Triangulation<dim,spacedim>::raw_line_iterator
- next_unused_line = triangulation.begin_raw_line ();
-
- for (; line!=endl; ++line)
- if (line->user_flag_set())
- {
- // this line needs to be
- // refined
-
- // find the next unused
- // vertex and set it
- // appropriately
- while (triangulation.vertices_used[next_unused_vertex] == true)
- ++next_unused_vertex;
- Assert (next_unused_vertex < triangulation.vertices.size(),
- ExcTooFewVerticesAllocated());
- triangulation.vertices_used[next_unused_vertex] = true;
-
- if (line->at_boundary())
- triangulation.vertices[next_unused_vertex]
- = triangulation.boundary[line->boundary_indicator()]->get_new_point_on_line (line);
- else
- triangulation.vertices[next_unused_vertex]
- = (line->vertex(0) + line->vertex(1)) / 2;
-
- // now that we created
- // the right point, make
- // up the two child lines
- // (++ takes care of the
- // end of the vector)
- next_unused_line=triangulation.faces->lines.next_free_pair_line(triangulation);
- Assert(next_unused_line.state() == IteratorState::valid,
- ExcInternalError());
-
- // now we found
- // two consecutive unused
- // lines, such that the
- // children of a line
- // will be consecutive.
- // then set the child
- // pointer of the present
- // line
- line->set_children (0, next_unused_line->index());
-
- // set the two new lines
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- children[2] = { next_unused_line,
- ++next_unused_line };
-
- // some tests; if any of
- // the iterators should
- // be invalid, then
- // already dereferencing
- // will fail
- Assert (children[0]->used() == false, ExcCellShouldBeUnused());
- Assert (children[1]->used() == false, ExcCellShouldBeUnused());
-
- children[0]->set (internal::Triangulation
- ::TriaObject<1>(line->vertex_index(0),
- next_unused_vertex));
- children[1]->set (internal::Triangulation
- ::TriaObject<1>(next_unused_vertex,
- line->vertex_index(1)));
-
- children[0]->set_used_flag();
- children[1]->set_used_flag();
- children[0]->clear_children();
- children[1]->clear_children();
- children[0]->clear_user_data();
- children[1]->clear_user_data();
- children[0]->clear_user_flag();
- children[1]->clear_user_flag();
-
- children[0]->set_boundary_indicator (line->boundary_indicator());
- children[1]->set_boundary_indicator (line->boundary_indicator());
-
- // finally clear flag
- // indicating the need
- // for refinement
- line->clear_user_flag ();
- }
- }
-
-
- ///////////////////////////////////////
- // now refine marked quads
- ///////////////////////////////////////
-
- // here we encounter several cases:
-
- // a) the quad is unrefined and shall be
- // refined isotropically
-
- // b) the quad is unrefined and shall be
- // refined anisotropically
-
- // c) the quad is unrefined and shall be
- // refined both anisotropically and
- // isotropically (this is reduced to case b)
- // and then case b) for the children again)
-
- // d) the quad is refined anisotropically and
- // shall be refined isotropically (this is
- // reduced to case b) for the anisotropic
- // children)
-
- // e) the quad is refined isotropically and
- // shall be refined anisotropically (this is
- // transformed to case c), however we might
- // have to renumber/rename children...)
-
- // we need a loop in cases c) and d), as the
- // anisotropic children migt have a lower
- // index than the mother quad
- for (unsigned int loop=0; loop<2; ++loop)
- {
- // usually, only active objects can be
- // refined further. however, in cases d)
- // and e) that is not true, so we have to
- // use 'normal' iterators here
- typename Triangulation<dim,spacedim>::quad_iterator
- quad = triangulation.begin_quad(),
- endq = triangulation.end_quad();
- typename Triangulation<dim,spacedim>::raw_line_iterator
- next_unused_line = triangulation.begin_raw_line ();
- typename Triangulation<dim,spacedim>::raw_quad_iterator
- next_unused_quad = triangulation.begin_raw_quad ();
-
- for (; quad!=endq; ++quad)
- {
- if (quad->user_index())
- {
- RefinementCase<dim-1> aniso_quad_ref_case=face_refinement_cases[quad->user_index()];
- // there is one unlikely event
- // here, where we already have
- // refind the face: if the face
- // was refined anisotropically
- // and we want to refine it
- // isotropically, both children
- // are flagged for anisotropic
- // refinement. however, if those
- // children were already flagged
- // for anisotropic refinement,
- // they might already be
- // processed and refined.
- if (aniso_quad_ref_case == quad->refinement_case())
- continue;
-
- Assert(quad->refinement_case()==RefinementCase<dim-1>::cut_xy ||
- quad->refinement_case()==RefinementCase<dim-1>::no_refinement,
- ExcInternalError());
-
- // this quad needs to be refined
- // anisotropically
- Assert(quad->user_index() == RefinementCase<dim-1>::cut_x ||
- quad->user_index() == RefinementCase<dim-1>::cut_y,
- ExcInternalError());
-
- // make the new line interior to
- // the quad
- typename Triangulation<dim,spacedim>::raw_line_iterator new_line;
-
- new_line=triangulation.faces->lines.next_free_single_line(triangulation);
- Assert (new_line->used() == false,
- ExcCellShouldBeUnused());
-
- // first collect the
- // indices of the vertices:
- // *--1--*
- // | | |
- // | | | cut_x
- // | | |
- // *--0--*
- //
- // *-----*
- // | |
- // 0-----1 cut_y
- // | |
- // *-----*
- unsigned int vertex_indices[2];
- if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
- {
- vertex_indices[0]=quad->line(2)->child(0)->vertex_index(1);
- vertex_indices[1]=quad->line(3)->child(0)->vertex_index(1);
- }
- else
- {
- vertex_indices[0]=quad->line(0)->child(0)->vertex_index(1);
- vertex_indices[1]=quad->line(1)->child(0)->vertex_index(1);
- }
-
- new_line->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[0], vertex_indices[1]));
- new_line->set_used_flag();
- new_line->clear_user_flag();
- new_line->clear_user_data();
- new_line->clear_children();
- new_line->set_boundary_indicator(quad->boundary_indicator());
-
- // child 0 and 1 of a line are
- // switched if the line
- // orientation is false. set up a
- // miniature table, indicating
- // which child to take for line
- // orientations false and
- // true. first index: child index
- // in standard orientation,
- // second index: line orientation
- const unsigned int index[2][2]=
- {{1,0}, // child 0, line_orientation=false and true
- {0,1}}; // child 1, line_orientation=false and true
-
- // find some space (consecutive)
- // for the two newly to be
- // created quads.
- typename Triangulation<dim,spacedim>::raw_quad_iterator new_quads[2];
-
- next_unused_quad=triangulation.faces->quads.next_free_pair_quad(triangulation);
- new_quads[0] = next_unused_quad;
- Assert (new_quads[0]->used() == false, ExcCellShouldBeUnused());
-
- ++next_unused_quad;
- new_quads[1] = next_unused_quad;
- Assert (new_quads[1]->used() == false, ExcCellShouldBeUnused());
-
-
- if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
- {
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(quad->line_index(0),
- new_line->index(),
- quad->line(2)->child(index[0][quad->line_orientation(2)])->index(),
- quad->line(3)->child(index[0][quad->line_orientation(3)])->index()));
- new_quads[1]->set (internal::Triangulation
- ::TriaObject<2>(new_line->index(),
- quad->line_index(1),
- quad->line(2)->child(index[1][quad->line_orientation(2)])->index(),
- quad->line(3)->child(index[1][quad->line_orientation(3)])->index()));
- }
- else
- {
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(quad->line(0)->child(index[0][quad->line_orientation(0)])->index(),
- quad->line(1)->child(index[0][quad->line_orientation(1)])->index(),
- quad->line_index(2),
- new_line->index()));
- new_quads[1]->set (internal::Triangulation
- ::TriaObject<2>(quad->line(0)->child(index[1][quad->line_orientation(0)])->index(),
- quad->line(1)->child(index[1][quad->line_orientation(1)])->index(),
- new_line->index(),
- quad->line_index(3)));
- }
-
- for (unsigned int i=0; i<2; ++i)
- {
- new_quads[i]->set_used_flag();
- new_quads[i]->clear_user_flag();
- new_quads[i]->clear_user_data();
- new_quads[i]->clear_children();
- new_quads[i]->set_boundary_indicator (quad->boundary_indicator());
- // set all line orientations to
- // true, change this after the
- // loop, as we have to consider
- // different lines for each
- // child
- for (unsigned int j=0; j<GeometryInfo<dim>::lines_per_face; ++j)
- new_quads[i]->set_line_orientation(j,true);
- }
- // now set the line orientation of
- // children of outer lines
- // correctly, the lines in the
- // interior of the refined quad are
- // automatically oriented
- // conforming to the standard
- new_quads[0]->set_line_orientation(0,quad->line_orientation(0));
- new_quads[0]->set_line_orientation(2,quad->line_orientation(2));
- new_quads[1]->set_line_orientation(1,quad->line_orientation(1));
- new_quads[1]->set_line_orientation(3,quad->line_orientation(3));
- if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
- {
- new_quads[0]->set_line_orientation(3,quad->line_orientation(3));
- new_quads[1]->set_line_orientation(2,quad->line_orientation(2));
- }
- else
- {
- new_quads[0]->set_line_orientation(1,quad->line_orientation(1));
- new_quads[1]->set_line_orientation(0,quad->line_orientation(0));
- }
-
- // test, whether this face is
- // refined isotropically
- // already. if so, set the
- // correct children pointers.
- if (quad->refinement_case()==RefinementCase<dim-1>::cut_xy)
- {
- // we will put a new
- // refinemnt level of
- // anisotropic refinement
- // between the unrefined and
- // isotropically refined quad
- // ending up with the same
- // fine quads but introducing
- // anisotropically refined
- // ones as children of the
- // unrefined quad and mother
- // cells of the original fine
- // ones.
-
- // this process includes the
- // creation of a new middle
- // line which we will assign
- // as the mother line of two
- // of the existing inner
- // lines. If those inner
- // lines are not consecutive
- // in memory, we won't find
- // them later on, so we have
- // to create new ones instead
- // and replace all occurances
- // of the old ones with those
- // new ones. As this is kind
- // of ugly, we hope we don't
- // have to do it often...
- typename Triangulation<dim,spacedim>::line_iterator old_child[2];
- if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
- {
- old_child[0]=quad->child(0)->line(1);
- old_child[1]=quad->child(2)->line(1);
- }
- else
- {
- Assert(aniso_quad_ref_case==RefinementCase<dim-1>::cut_y, ExcInternalError());
-
- old_child[0]=quad->child(0)->line(3);
- old_child[1]=quad->child(1)->line(3);
- }
-
- if (old_child[0]->index()+1 != old_child[1]->index())
- {
- // this is exactly the
- // ugly case we taked
- // about. so, no
- // coimplaining, lets get
- // two new lines and copy
- // all info
- typename Triangulation<dim,spacedim>::raw_line_iterator new_child[2];
-
- new_child[0]=new_child[1]=triangulation.faces->lines.next_free_pair_line(triangulation);
- ++new_child[1];
-
- new_child[0]->set_used_flag();
- new_child[1]->set_used_flag();
-
- const int old_index_0=old_child[0]->index(),
- old_index_1=old_child[1]->index(),
- new_index_0=new_child[0]->index(),
- new_index_1=new_child[1]->index();
-
- // loop over all quads
- // and replace the old
- // lines
- for (unsigned int q=0; q<triangulation.faces->quads.cells.size(); ++q)
- for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_face; ++l)
- {
- const int index=triangulation.faces->quads.cells[q].face(l);
- if (index==old_index_0)
- triangulation.faces->quads.cells[q].set_face(l,new_index_0);
- else if (index==old_index_1)
- triangulation.faces->quads.cells[q].set_face(l,new_index_1);
- }
- // now we have to copy
- // all information of the
- // two lines
- for (unsigned int i=0; i<2; ++i)
- {
- Assert(!old_child[i]->has_children(), ExcInternalError());
-
- new_child[i]->set(internal::Triangulation::TriaObject<1>(old_child[i]->vertex_index(0),
- old_child[i]->vertex_index(1)));
- new_child[i]->set_boundary_indicator(old_child[i]->boundary_indicator());
- new_child[i]->set_user_index(old_child[i]->user_index());
- if (old_child[i]->user_flag_set())
- new_child[i]->set_user_flag();
- else
- new_child[i]->clear_user_flag();
-
- new_child[i]->clear_children();
-
- old_child[i]->clear_user_flag();
- old_child[i]->clear_user_index();
- old_child[i]->clear_used_flag();
- }
- }
- // now that we cared
- // about the lines, go on
- // with the quads
- // themselves, where we
- // might encounter
- // similar situations...
- if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
- {
- new_line->set_children(0, quad->child(0)->line_index(1));
- Assert(new_line->child(1)==quad->child(2)->line(1),
- ExcInternalError());
- // now evereything is
- // quite complicated. we
- // have the children
- // numbered according to
- //
- // *---*---*
- // |n+2|n+3|
- // *---*---*
- // | n |n+1|
- // *---*---*
- //
- // from the original
- // isotropic
- // refinement. we have to
- // reorder them as
- //
- // *---*---*
- // |n+1|n+3|
- // *---*---*
- // | n |n+2|
- // *---*---*
- //
- // such that n and n+1
- // are consecutive
- // children of m and n+2
- // and n+3 are
- // consecutive children
- // of m+1, where m and
- // m+1 are given as in
- //
- // *---*---*
- // | | |
- // | m |m+1|
- // | | |
- // *---*---*
- //
- // this is a bit ugly, of
- // course: loop over all
- // cells on all levels
- // and look for faces n+1
- // (switch_1) and n+2
- // (switch_2).
- const typename Triangulation<dim,spacedim>::quad_iterator
- switch_1=quad->child(1),
- switch_2=quad->child(2);
- const int switch_1_index=switch_1->index();
- const int switch_2_index=switch_2->index();
- for (unsigned int l=0; l<triangulation.levels.size(); ++l)
- for (unsigned int h=0; h<triangulation.levels[l]->cells.cells.size(); ++h)
- for (unsigned int q=0; q<GeometryInfo<dim>::faces_per_cell; ++q)
- {
- const int index=triangulation.levels[l]->cells.cells[h].face(q);
- if (index==switch_1_index)
- triangulation.levels[l]->cells.cells[h].set_face(q,switch_2_index);
- else if (index==switch_2_index)
- triangulation.levels[l]->cells.cells[h].set_face(q,switch_1_index);
- }
- // now we have to copy
- // all information of the
- // two quads
- const int switch_1_lines[4]=
- {switch_1->line_index(0),
- switch_1->line_index(1),
- switch_1->line_index(2),
- switch_1->line_index(3)};
- const bool switch_1_line_orientations[4]=
- {switch_1->line_orientation(0),
- switch_1->line_orientation(1),
- switch_1->line_orientation(2),
- switch_1->line_orientation(3)};
- const unsigned char switch_1_boundary_indicator=switch_1->boundary_indicator();
- const unsigned int switch_1_user_index=switch_1->user_index();
- const bool switch_1_user_flag=switch_1->user_flag_set();
- const RefinementCase<dim-1> switch_1_refinement_case=switch_1->refinement_case();
- const int switch_1_first_child_pair=(switch_1_refinement_case ? switch_1->child_index(0) : -1);
- const int switch_1_second_child_pair=(switch_1_refinement_case==RefinementCase<dim-1>::cut_xy ? switch_1->child_index(2) : -1);
-
- switch_1->set(internal::Triangulation::TriaObject<2>(switch_2->line_index(0),
- switch_2->line_index(1),
- switch_2->line_index(2),
- switch_2->line_index(3)));
- switch_1->set_line_orientation(0, switch_2->line_orientation(0));
- switch_1->set_line_orientation(1, switch_2->line_orientation(1));
- switch_1->set_line_orientation(2, switch_2->line_orientation(2));
- switch_1->set_line_orientation(3, switch_2->line_orientation(3));
- switch_1->set_boundary_indicator(switch_2->boundary_indicator());
- switch_1->set_user_index(switch_2->user_index());
- if (switch_2->user_flag_set())
- switch_1->set_user_flag();
- else
- switch_1->clear_user_flag();
- switch_1->clear_refinement_case();
- switch_1->set_refinement_case(switch_2->refinement_case());
- switch_1->clear_children();
- if (switch_2->refinement_case())
- switch_1->set_children(0, switch_2->child_index(0));
- if (switch_2->refinement_case()==RefinementCase<dim-1>::cut_xy)
- switch_1->set_children(2, switch_2->child_index(2));
-
- switch_2->set(internal::Triangulation::TriaObject<2>(switch_1_lines[0],
- switch_1_lines[1],
- switch_1_lines[2],
- switch_1_lines[3]));
- switch_2->set_line_orientation(0, switch_1_line_orientations[0]);
- switch_2->set_line_orientation(1, switch_1_line_orientations[1]);
- switch_2->set_line_orientation(2, switch_1_line_orientations[2]);
- switch_2->set_line_orientation(3, switch_1_line_orientations[3]);
- switch_2->set_boundary_indicator(switch_1_boundary_indicator);
- switch_2->set_user_index(switch_1_user_index);
- if (switch_1_user_flag)
- switch_2->set_user_flag();
- else
- switch_2->clear_user_flag();
- switch_2->clear_refinement_case();
- switch_2->set_refinement_case(switch_1_refinement_case);
- switch_2->clear_children();
- switch_2->set_children(0, switch_1_first_child_pair);
- switch_2->set_children(2, switch_1_second_child_pair);
-
- new_quads[0]->set_refinement_case(RefinementCase<2>::cut_y);
- new_quads[0]->set_children(0, quad->child_index(0));
- new_quads[1]->set_refinement_case(RefinementCase<2>::cut_y);
- new_quads[1]->set_children(0, quad->child_index(2));
- }
- else
- {
- new_quads[0]->set_refinement_case(RefinementCase<2>::cut_x);
- new_quads[0]->set_children(0, quad->child_index(0));
- new_quads[1]->set_refinement_case(RefinementCase<2>::cut_x);
- new_quads[1]->set_children(0, quad->child_index(2));
- new_line->set_children(0, quad->child(0)->line_index(3));
- Assert(new_line->child(1)==quad->child(1)->line(3),
- ExcInternalError());
- }
- quad->clear_children();
- }
-
- // note these quads as children
- // to the present one
- quad->set_children (0, new_quads[0]->index());
-
- quad->set_refinement_case(aniso_quad_ref_case);
-
- // finally clear flag
- // indicating the need
- // for refinement
- quad->clear_user_data ();
- } // if (anisotropic refinement)
-
- if (quad->user_flag_set())
- {
- // this quad needs to be
- // refined isotropically
-
- // first of all: we only get here
- // in the first run of the loop
- Assert(loop==0,ExcInternalError());
-
- // find the next unused
- // vertex. we'll need this in any
- // case
- while (triangulation.vertices_used[next_unused_vertex] == true)
- ++next_unused_vertex;
- Assert (next_unused_vertex < triangulation.vertices.size(),
- ExcTooFewVerticesAllocated());
-
- // now: if the quad is refined
- // anisotropically already, set
- // the anisotropic refinement
- // flag for both
- // children. Additionally, we
- // have to refine the inner line,
- // as it is an outer line of the
- // two (anisotropic) children
- const RefinementCase<dim-1> quad_ref_case=quad->refinement_case();
-
- if (quad_ref_case==RefinementCase<dim-1>::cut_x ||
- quad_ref_case==RefinementCase<dim-1>::cut_y)
- {
- // set the 'opposite' refine case for children
- quad->child(0)->set_user_index(RefinementCase<dim-1>::cut_xy-quad_ref_case);
- quad->child(1)->set_user_index(RefinementCase<dim-1>::cut_xy-quad_ref_case);
- // refine the inner line
- typename Triangulation<dim,spacedim>::line_iterator middle_line;
- if (quad_ref_case==RefinementCase<dim-1>::cut_x)
- middle_line=quad->child(0)->line(1);
- else
- middle_line=quad->child(0)->line(3);
-
- // if the face has been
- // refined anisotropically in
- // the last refinement step
- // it might be, that it is
- // flagged already and that
- // the middle line is thus
- // refined already. if not
- // create children.
- if (!middle_line->has_children())
- {
- // set the middle vertex
- // appropriately. double
- // refinement of quads can only
- // happen in the interior of
- // the domain, so we need not
- // care about boundary quads
- // here
- triangulation.vertices[next_unused_vertex]
- = (middle_line->vertex(0) + middle_line->vertex(1)) / 2;
- triangulation.vertices_used[next_unused_vertex] = true;
-
- // now search a slot for the two
- // child lines
- next_unused_line=triangulation.faces->lines.next_free_pair_line(triangulation);
-
- // set the child
- // pointer of the present
- // line
- middle_line->set_children (0, next_unused_line->index());
-
- // set the two new lines
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- children[2] = { next_unused_line,
- ++next_unused_line };
-
- // some tests; if any of
- // the iterators should
- // be invalid, then
- // already dereferencing
- // will fail
- Assert (children[0]->used() == false, ExcCellShouldBeUnused());
- Assert (children[1]->used() == false, ExcCellShouldBeUnused());
-
- children[0]->set (internal::Triangulation::
- TriaObject<1>(middle_line->vertex_index(0),
- next_unused_vertex));
- children[1]->set (internal::Triangulation::
- TriaObject<1>(next_unused_vertex,
- middle_line->vertex_index(1)));
-
- children[0]->set_used_flag();
- children[1]->set_used_flag();
- children[0]->clear_children();
- children[1]->clear_children();
- children[0]->clear_user_data();
- children[1]->clear_user_data();
- children[0]->clear_user_flag();
- children[1]->clear_user_flag();
-
- children[0]->set_boundary_indicator (middle_line->boundary_indicator());
- children[1]->set_boundary_indicator (middle_line->boundary_indicator());
- }
- // now remove the flag from the
- // quad and go to the next
- // quad, the actual refinement
- // of the quad takes place
- // later on in this pass of the
- // loop or in the next one
- quad->clear_user_flag();
- continue;
- } // if (several refinement cases)
-
- // if we got here, we have an
- // unrefined quad and have to do
- // the usual work like in an purely
- // isotropic refinement
- Assert(quad_ref_case==RefinementCase<dim-1>::no_refinement, ExcInternalError());
-
- // set the middle vertex
- // appropriately
- if (quad->at_boundary())
- triangulation.vertices[next_unused_vertex]
- = triangulation.boundary[quad->boundary_indicator()]->get_new_point_on_quad (quad);
- else
- // it might be that the
- // quad itself is not
- // at the boundary, but
- // that one of its lines
- // actually is. in this
- // case, the newly
- // created vertices at
- // the centers of the
- // lines are not
- // necessarily the mean
- // values of the
- // adjacent vertices,
- // so do not compute
- // the new vertex as
- // the mean value of
- // the 4 vertices of
- // the face, but rather
- // as a weighted mean
- // value of the 8
- // vertices which we
- // already have (the
- // four old ones, and
- // the four ones
- // inserted as middle
- // points for the four
- // lines). summing up
- // some more points is
- // generally cheaper
- // than first asking
- // whether one of the
- // lines is at the
- // boundary
- //
- // note that the exact
- // weights are chosen
- // such as to minimize
- // the distortion of
- // the four new quads
- // from the optimal
- // shape; their
- // derivation and
- // values is copied
- // over from the
- // @p{MappingQ::set_laplace_on_vector}
- // function
- triangulation.vertices[next_unused_vertex]
- = (quad->vertex(0) + quad->vertex(1) +
- quad->vertex(2) + quad->vertex(3) +
- 3*(quad->line(0)->child(0)->vertex(1) +
- quad->line(1)->child(0)->vertex(1) +
- quad->line(2)->child(0)->vertex(1) +
- quad->line(3)->child(0)->vertex(1)) ) / 16;
-
- triangulation.vertices_used[next_unused_vertex] = true;
-
- // now that we created
- // the right point, make
- // up the four lines
- // interior to the quad
- // (++ takes care of the
- // end of the vector)
- typename Triangulation<dim,spacedim>::raw_line_iterator new_lines[4];
-
- for (unsigned int i=0; i<4; ++i)
- {
- if (i%2==0)
- // search a free pair of
- // lines for 0. and 2. line,
- // so that two of them end up
- // together, which is
- // necessary if later on we
- // want to refine the quad
- // anisotropically and the
- // two lines end up as
- // children of new line
- next_unused_line=triangulation.faces->lines.next_free_pair_line(triangulation);
-
- new_lines[i] = next_unused_line;
- ++next_unused_line;
-
- Assert (new_lines[i]->used() == false,
- ExcCellShouldBeUnused());
- }
-
- // set the data of the
- // four lines.
- // first collect the
- // indices of the five
- // vertices:
- // *--3--*
- // | | |
- // 0--4--1
- // | | |
- // *--2--*
- // the lines are numbered
- // as follows:
- // *--*--*
- // | 1 |
- // *2-*-3*
- // | 0 |
- // *--*--*
-
- const unsigned int vertex_indices[5]
- = { quad->line(0)->child(0)->vertex_index(1),
- quad->line(1)->child(0)->vertex_index(1),
- quad->line(2)->child(0)->vertex_index(1),
- quad->line(3)->child(0)->vertex_index(1),
- next_unused_vertex
- };
-
- new_lines[0]->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[2], vertex_indices[4]));
- new_lines[1]->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[4], vertex_indices[3]));
- new_lines[2]->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[0], vertex_indices[4]));
- new_lines[3]->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[4], vertex_indices[1]));
-
- for (unsigned int i=0; i<4; ++i)
- {
- new_lines[i]->set_used_flag();
- new_lines[i]->clear_user_flag();
- new_lines[i]->clear_user_data();
- new_lines[i]->clear_children();
- new_lines[i]->set_boundary_indicator(quad->boundary_indicator());
- }
-
- // now for the
- // quads. again, first
- // collect some data
- // about the indices of
- // the lines, with the
- // following numbering:
- // .-6-.-7-.
- // 1 9 3
- // .-10.11-.
- // 0 8 2
- // .-4-.-5-.
-
- // child 0 and 1 of a line are
- // switched if the line orientation
- // is false. set up a miniature
- // table, indicating which child to
- // take for line orientations false
- // and true. first index: child
- // index in standard orientation,
- // second index: line orientation
- const unsigned int index[2][2]=
- {{1,0}, // child 0, line_orientation=false and true
- {0,1}}; // child 1, line_orientation=false and true
-
- const unsigned int line_indices[12]
- = { quad->line(0)->child(index[0][quad->line_orientation(0)])->index(),
- quad->line(0)->child(index[1][quad->line_orientation(0)])->index(),
- quad->line(1)->child(index[0][quad->line_orientation(1)])->index(),
- quad->line(1)->child(index[1][quad->line_orientation(1)])->index(),
- quad->line(2)->child(index[0][quad->line_orientation(2)])->index(),
- quad->line(2)->child(index[1][quad->line_orientation(2)])->index(),
- quad->line(3)->child(index[0][quad->line_orientation(3)])->index(),
- quad->line(3)->child(index[1][quad->line_orientation(3)])->index(),
- new_lines[0]->index(),
- new_lines[1]->index(),
- new_lines[2]->index(),
- new_lines[3]->index()
- };
-
- // find some space (consecutive)
- // for the first two newly to be
- // created quads.
- typename Triangulation<dim,spacedim>::raw_quad_iterator new_quads[4];
-
- next_unused_quad=triangulation.faces->quads.next_free_pair_quad(triangulation);
-
- new_quads[0] = next_unused_quad;
- Assert (new_quads[0]->used() == false, ExcCellShouldBeUnused());
-
- ++next_unused_quad;
- new_quads[1] = next_unused_quad;
- Assert (new_quads[1]->used() == false, ExcCellShouldBeUnused());
-
- next_unused_quad=triangulation.faces->quads.next_free_pair_quad(triangulation);
- new_quads[2] = next_unused_quad;
- Assert (new_quads[2]->used() == false, ExcCellShouldBeUnused());
-
- ++next_unused_quad;
- new_quads[3] = next_unused_quad;
- Assert (new_quads[3]->used() == false, ExcCellShouldBeUnused());
-
- // note these quads as
- // children to the
- // present one
- quad->set_children (0, new_quads[0]->index());
- quad->set_children (2, new_quads[2]->index());
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[0],
- line_indices[8],
- line_indices[4],
- line_indices[10]));
-
- quad->set_refinement_case(RefinementCase<2>::cut_xy);
-
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[0],
- line_indices[8],
- line_indices[4],
- line_indices[10]));
- new_quads[1]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[8],
- line_indices[2],
- line_indices[5],
- line_indices[11]));
- new_quads[2]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[1],
- line_indices[9],
- line_indices[10],
- line_indices[6]));
- new_quads[3]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[9],
- line_indices[3],
- line_indices[11],
- line_indices[7]));
- for (unsigned int i=0; i<4; ++i)
- {
- new_quads[i]->set_used_flag();
- new_quads[i]->clear_user_flag();
- new_quads[i]->clear_user_data();
- new_quads[i]->clear_children();
- new_quads[i]->set_boundary_indicator (quad->boundary_indicator());
- // set all line orientations to
- // true, change this after the
- // loop, as we have to consider
- // different lines for each
- // child
- for (unsigned int j=0; j<GeometryInfo<dim>::lines_per_face; ++j)
- new_quads[i]->set_line_orientation(j,true);
- }
- // now set the line orientation of
- // children of outer lines
- // correctly, the lines in the
- // interior of the refined quad are
- // automatically oriented
- // conforming to the standard
- new_quads[0]->set_line_orientation(0,quad->line_orientation(0));
- new_quads[0]->set_line_orientation(2,quad->line_orientation(2));
- new_quads[1]->set_line_orientation(1,quad->line_orientation(1));
- new_quads[1]->set_line_orientation(2,quad->line_orientation(2));
- new_quads[2]->set_line_orientation(0,quad->line_orientation(0));
- new_quads[2]->set_line_orientation(3,quad->line_orientation(3));
- new_quads[3]->set_line_orientation(1,quad->line_orientation(1));
- new_quads[3]->set_line_orientation(3,quad->line_orientation(3));
-
- // finally clear flag
- // indicating the need
- // for refinement
- quad->clear_user_flag ();
- } // if (isotropic refinement)
- } // 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;
-
- for (unsigned int level=0; level!=triangulation.levels.size()-1; ++level)
- {
- // only active objects can be
- // refined further; remember
- // that we won't operate on the
- // finest level, so
- // triangulation.begin_*(level+1) is allowed
- typename Triangulation<dim,spacedim>::active_hex_iterator
- hex = triangulation.begin_active_hex(level),
- endh = triangulation.begin_active_hex(level+1);
- typename Triangulation<dim,spacedim>::raw_hex_iterator
- next_unused_hex = triangulation.begin_raw_hex (level+1);
-
- for (; hex!=endh; ++hex)
- if (hex->refine_flag_set())
- {
- // this hex needs to be
- // refined
-
- // clear flag indicating
- // the need for
- // refinement. do it here
- // already, since we
- // can't do it anymore
- // once the cell has
- // children
- const RefinementCase<dim> ref_case=hex->refine_flag_set();
- hex->clear_refine_flag ();
- hex->set_refinement_case(ref_case);
-
- // depending on the refine case we
- // might have to create additional
- // vertices, lines and quads
- // interior of the hex before the
- // actual children can be set up.
-
- // in a first step: reserve the
- // needed space for lines, quads
- // and hexes and initialize them
- // correctly
-
- unsigned int n_new_lines=0;
- unsigned int n_new_quads=0;
- unsigned int n_new_hexes=0;
- switch (ref_case)
- {
- case RefinementCase<dim>::cut_x:
- case RefinementCase<dim>::cut_y:
- case RefinementCase<dim>::cut_z:
- n_new_lines=0;
- n_new_quads=1;
- n_new_hexes=2;
- break;
- case RefinementCase<dim>::cut_xy:
- case RefinementCase<dim>::cut_xz:
- case RefinementCase<dim>::cut_yz:
- n_new_lines=1;
- n_new_quads=4;
- n_new_hexes=4;
- break;
- case RefinementCase<dim>::cut_xyz:
- n_new_lines=6;
- n_new_quads=12;
- n_new_hexes=8;
- break;
- default:
- Assert(false, ExcInternalError());
- break;
- }
-
- // find some space for the newly to
- // be created interior lines and
- // initialize them.
- std::vector<typename Triangulation<dim,spacedim>::raw_line_iterator>
- new_lines(n_new_lines);
- for (unsigned int i=0; i<n_new_lines; ++i)
- {
- new_lines[i] = triangulation.faces->lines.next_free_single_line(triangulation);
-
- Assert (new_lines[i]->used() == false,
- ExcCellShouldBeUnused());
- new_lines[i]->set_used_flag();
- new_lines[i]->clear_user_flag();
- new_lines[i]->clear_user_data();
- new_lines[i]->clear_children();
- // interior line
- new_lines[i]->set_boundary_indicator(255);
- }
-
- // find some space for the newly to
- // be created interior quads and
- // initialize them.
- std::vector<typename Triangulation<dim,spacedim>::raw_quad_iterator>
- new_quads(n_new_quads);
- for (unsigned int i=0; i<n_new_quads; ++i)
- {
- new_quads[i] = triangulation.faces->quads.next_free_single_quad(triangulation);
-
- Assert (new_quads[i]->used() == false,
- ExcCellShouldBeUnused());
- new_quads[i]->set_used_flag();
- new_quads[i]->clear_user_flag();
- new_quads[i]->clear_user_data();
- new_quads[i]->clear_children();
- // interior quad
- new_quads[i]->set_boundary_indicator (255);
- // set all line orientation
- // flags to true by default,
- // change this afterwards, if
- // necessary
- for (unsigned int j=0; j<GeometryInfo<dim>::lines_per_face; ++j)
- new_quads[i]->set_line_orientation(j,true);
- }
-
- // find some space for the newly to
- // be created hexes and initialize
- // them.
- std::vector<typename Triangulation<dim,spacedim>::raw_hex_iterator>
- new_hexes(n_new_hexes);
- for (unsigned int i=0; i<n_new_hexes; ++i)
- {
- if (i%2==0)
- next_unused_hex=triangulation.levels[level+1]->cells.next_free_hex(triangulation,level+1);
-
- else
- ++next_unused_hex;
-
- new_hexes[i]=next_unused_hex;
-
- Assert (new_hexes[i]->used() == false,
- ExcCellShouldBeUnused());
- new_hexes[i]->set_used_flag();
- new_hexes[i]->clear_user_flag();
- new_hexes[i]->clear_user_data();
- new_hexes[i]->clear_children();
- // inherit material
- // properties
- new_hexes[i]->set_material_id (hex->material_id());
- new_hexes[i]->set_subdomain_id (hex->subdomain_id());
-
- if (i%2)
- new_hexes[i]->set_parent (hex->index ());
- // set the face_orientation
- // flag to true for all faces
- // initially, as this is the
- // default value which is true
- // for all faces interior to
- // the hex. later on go the
- // other way round and reset
- // faces that are at the
- // boundary of the mother cube
- //
- // the same is true for the
- // face_flip and face_rotation
- // flags. however, the latter
- // two are set to false by
- // default as this is the
- // standard value
- for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
- {
- new_hexes[i]->set_face_orientation(f, true);
- new_hexes[i]->set_face_flip(f, false);
- new_hexes[i]->set_face_rotation(f, false);
- }
- }
- // note these hexes as
- // children to the
- // present cell
- for (unsigned int i=0; i<n_new_hexes/2; ++i)
- hex->set_children (2*i, new_hexes[2*i]->index());
-
- // we have to take into account
- // whether the different faces are
- // oriented correctly or in the
- // opposite direction, so store
- // that up front
-
- // face_orientation
- const bool f_or[6]
- = { hex->face_orientation (0),
- hex->face_orientation (1),
- hex->face_orientation (2),
- hex->face_orientation (3),
- hex->face_orientation (4),
- hex->face_orientation (5) };
-
- // face_flip
- const bool f_fl[6]
- = { hex->face_flip (0),
- hex->face_flip (1),
- hex->face_flip (2),
- hex->face_flip (3),
- hex->face_flip (4),
- hex->face_flip (5) };
-
- // face_rotation
- const bool f_ro[6]
- = { hex->face_rotation (0),
- hex->face_rotation (1),
- hex->face_rotation (2),
- hex->face_rotation (3),
- hex->face_rotation (4),
- hex->face_rotation (5) };
-
- // some commonly used fields which
- // have varying size
- const unsigned int *vertex_indices=0;
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- *lines=0;
- const unsigned int *line_indices=0;
- const bool *line_orientation=0;
- const unsigned int *quad_indices=0;
-
- // little helper table, indicating,
- // whether the child with index 0
- // or with index 1 can be found at
- // the standard origin of an
- // anisotropically refined quads in
- // real orientation
- // index 1: (RefineCase - 1)
- // index 2: face_flip
-
- // index 3: face rotation
- // note: face orientation has no influence
- const unsigned int child_at_origin[2][2][2]=
- { { { 0, 0 }, // RefinementCase<dim>::cut_x, face_flip=false, face_rotation=false and true
- { 1, 1 }}, // RefinementCase<dim>::cut_x, face_flip=true, face_rotation=false and true
- { { 0, 1 }, // RefinementCase<dim>::cut_y, face_flip=false, face_rotation=false and true
- { 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
- // needed), create new interior
- // lines (if needed), create new
- // interior quads and afterwards
- // build the children hexes out of
- // these and the existing subfaces
- // of the outer quads (which have
- // been created above). However,
- // even if the steps are quite
- // similar, the actual work
- // strongly depends on the actual
- // refinement case. therefore, we
- // use seperate blocks of code for
- // each of these cases, which
- // hopefully increases the
- // readability to some extend.
-
- switch (ref_case)
- {
- case RefinementCase<dim>::cut_x:
- {
- //////////////////////////////
- //
- // RefinementCase<dim>::cut_x
- //
- // the refined cube will look
- // like this:
- //
- // *----*----*
- // / / /|
- // / / / |
- // / / / |
- // *----*----* |
- // | | | |
- // | | | *
- // | | | /
- // | | | /
- // | | |/
- // *----*----*
- //
- // again, first
- // collect some data
- // about the indices of
- // the lines, with the
- // following numbering:
-
- // face 2: front plane
- // (note: x,y exchanged)
- // *---*---*
- // | | |
- // | 0 |
- // | | |
- // *---*---*
- // m0
- // face 3: back plane
- // (note: x,y exchanged)
- // m1
- // *---*---*
- // | | |
- // | 1 |
- // | | |
- // *---*---*
- // face 4: bottom plane
- // *---*---*
- // / / /
- // / 2 /
- // / / /
- // *---*---*
- // m0
- // face 5: top plane
- // m1
- // *---*---*
- // / / /
- // / 3 /
- // / / /
- // *---*---*
-
- // set up a list of line iterators
- // first. from this, construct
- // lists of line_indices and
- // line orientations later on
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- lines_x[4]
- = {
- hex->face(2)->child(0)
- ->line((hex->face(2)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
- hex->face(3)->child(0)
- ->line((hex->face(3)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
- hex->face(4)->child(0)
- ->line((hex->face(4)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
- hex->face(5)->child(0)
- ->line((hex->face(5)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3) //3
- };
-
- lines=&lines_x[0];
-
- unsigned int line_indices_x[4];
-
- for (unsigned int i=0; i<4; ++i)
- line_indices_x[i]=lines[i]->index();
- line_indices=&line_indices_x[0];
-
- // the orientation of lines for the
- // inner quads is quite tricky. as
- // these lines are newly created
- // ones and thus have no parents,
- // they cannot inherit this
- // property. set up an array and
- // fill it with the respective
- // values
- bool line_orientation_x[4];
-
- // the middle vertice marked
- // as m0 above is the start
- // vertex for lines 0 and 2
- // in standard orientation,
- // whereas m1 is the end
- // vertex of lines 1 and 3 in
- // standard orientation
- const unsigned int middle_vertices[2]=
- {
- hex->line(2)->child(0)->vertex_index(1),
- hex->line(7)->child(0)->vertex_index(1)
- };
-
- for (unsigned int i=0; i<4; ++i)
- if (lines[i]->vertex_index(i%2)==middle_vertices[i%2])
- line_orientation_x[i]=true;
- else
- {
- // it must be the other
- // way round then
- Assert(lines[i]->vertex_index((i+1)%2)==middle_vertices[i%2],
- ExcInternalError());
- line_orientation_x[i]=false;
- }
-
- line_orientation=&line_orientation_x[0];
-
- // set up the new quad, line
- // numbering is as indicated
- // above
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[0],
- line_indices[1],
- line_indices[2],
- line_indices[3]));
-
- new_quads[0]->set_line_orientation(0,line_orientation[0]);
- new_quads[0]->set_line_orientation(1,line_orientation[1]);
- new_quads[0]->set_line_orientation(2,line_orientation[2]);
- new_quads[0]->set_line_orientation(3,line_orientation[3]);
-
- // the quads are
- // numbered as follows:
- //
- // planes in the interior
- // of the old hex:
- // *
- // /|
- // / | x
- // / | *-------* *---------*
- // * | | | / /
- // | 0 | | | / /
- // | * | | / /
- // | / *-------*y *---------*x
- // | /
- // |/
- // *
- //
- // children of the faces
- // of the old hex
- // *---*---* *---*---*
- // /| | | / / /|
- // / | | | / 9 / 10/ |
- // / | 5 | 6 | / / / |
- // * | | | *---*---* |
- // | 1 *---*---* | | | 2 *
- // | / / / | | | /
- // | / 7 / 8 / | 3 | 4 | /
- // |/ / / | | |/
- // *---*---* *---*---*
- //
- // note that we have to
- // take care of the
- // orientation of
- // faces.
- const unsigned int quad_indices_x[11]
- = {
- new_quads[0]->index(), //0
-
- hex->face(0)->index(), //1
-
- hex->face(1)->index(), //2
-
- hex->face(2)->child_index( child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]), //3
- hex->face(2)->child_index(1-child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]),
-
- hex->face(3)->child_index( child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]), //5
- hex->face(3)->child_index(1-child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]),
-
- hex->face(4)->child_index( child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]), //7
- hex->face(4)->child_index(1-child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]),
-
- hex->face(5)->child_index( child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]]), //9
- hex->face(5)->child_index(1-child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]])
-
- };
- quad_indices=&quad_indices_x[0];
-
- new_hexes[0]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[1],
- quad_indices[0],
- quad_indices[3],
- quad_indices[5],
- quad_indices[7],
- quad_indices[9]));
- new_hexes[1]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[0],
- quad_indices[2],
- quad_indices[4],
- quad_indices[6],
- quad_indices[8],
- quad_indices[10]));
- break;
- }
- case RefinementCase<dim>::cut_y:
- {
- //////////////////////////////
- //
- // RefinementCase<dim>::cut_y
- //
- // the refined cube will look
- // like this:
- //
- // *---------*
- // / /|
- // *---------* |
- // / /| |
- // *---------* | |
- // | | | |
- // | | | *
- // | | |/
- // | | *
- // | |/
- // *---------*
- //
- // again, first
- // collect some data
- // about the indices of
- // the lines, with the
- // following numbering:
-
- // face 0: left plane
- // *
- // /|
- // * |
- // /| |
- // * | |
- // | 0 |
- // | | *
- // | |/
- // | *m0
- // |/
- // *
- // face 1: right plane
- // *
- // /|
- // m1* |
- // /| |
- // * | |
- // | 1 |
- // | | *
- // | |/
- // | *
- // |/
- // *
- // face 4: bottom plane
- // *-------*
- // / /
- // m0*---2---*
- // / /
- // *-------*
- // face 5: top plane
- // *-------*
- // / /
- // *---3---*m1
- // / /
- // *-------*
-
- // set up a list of line iterators
- // first. from this, construct
- // lists of line_indices and
- // line orientations later on
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- lines_y[4]
- = {
- hex->face(0)->child(0)
- ->line((hex->face(0)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
- hex->face(1)->child(0)
- ->line((hex->face(1)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
- hex->face(4)->child(0)
- ->line((hex->face(4)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
- hex->face(5)->child(0)
- ->line((hex->face(5)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3) //3
- };
-
- lines=&lines_y[0];
-
- unsigned int line_indices_y[4];
-
- for (unsigned int i=0; i<4; ++i)
- line_indices_y[i]=lines[i]->index();
- line_indices=&line_indices_y[0];
-
- // the orientation of lines for the
- // inner quads is quite tricky. as
- // these lines are newly created
- // ones and thus have no parents,
- // they cannot inherit this
- // property. set up an array and
- // fill it with the respective
- // values
- bool line_orientation_y[4];
-
- // the middle vertice marked
- // as m0 above is the start
- // vertex for lines 0 and 2
- // in standard orientation,
- // whereas m1 is the end
- // vertex of lines 1 and 3 in
- // standard orientation
- const unsigned int middle_vertices[2]=
- {
- hex->line(0)->child(0)->vertex_index(1),
- hex->line(5)->child(0)->vertex_index(1)
- };
-
- for (unsigned int i=0; i<4; ++i)
- if (lines[i]->vertex_index(i%2)==middle_vertices[i%2])
- line_orientation_y[i]=true;
- else
- {
- // it must be the other way round then
- Assert(lines[i]->vertex_index((i+1)%2)==middle_vertices[i%2],
- ExcInternalError());
- line_orientation_y[i]=false;
- }
-
- line_orientation=&line_orientation_y[0];
-
- // set up the new quad, line
- // numbering is as indicated
- // above
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[2],
- line_indices[3],
- line_indices[0],
- line_indices[1]));
-
- new_quads[0]->set_line_orientation(0,line_orientation[2]);
- new_quads[0]->set_line_orientation(1,line_orientation[3]);
- new_quads[0]->set_line_orientation(2,line_orientation[0]);
- new_quads[0]->set_line_orientation(3,line_orientation[1]);
-
- // the quads are
- // numbered as follows:
- //
- // planes in the interior
- // of the old hex:
- // *
- // /|
- // / | x
- // / | *-------* *---------*
- // * | | | / /
- // | | | 0 | / /
- // | * | | / /
- // | / *-------*y *---------*x
- // | /
- // |/
- // *
- //
- // children of the faces
- // of the old hex
- // *-------* *-------*
- // /| | / 10 /|
- // * | | *-------* |
- // /| | 6 | / 9 /| |
- // * |2| | *-------* |4|
- // | | *-------* | | | *
- // |1|/ 8 / | |3|/
- // | *-------* | 5 | *
- // |/ 7 / | |/
- // *-------* *-------*
- //
- // note that we have to
- // take care of the
- // orientation of
- // faces.
- const unsigned int quad_indices_y[11]
- = {
- new_quads[0]->index(), //0
-
- hex->face(0)->child_index( child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]), //1
- hex->face(0)->child_index(1-child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]),
-
- hex->face(1)->child_index( child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]), //3
- hex->face(1)->child_index(1-child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]),
-
- hex->face(2)->index(), //5
-
- hex->face(3)->index(), //6
-
- hex->face(4)->child_index( child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]), //7
- hex->face(4)->child_index(1-child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]),
-
- hex->face(5)->child_index( child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]]), //9
- hex->face(5)->child_index(1-child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]])
-
- };
- quad_indices=&quad_indices_y[0];
-
- new_hexes[0]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[1],
- quad_indices[3],
- quad_indices[5],
- quad_indices[0],
- quad_indices[7],
- quad_indices[9]));
- new_hexes[1]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[2],
- quad_indices[4],
- quad_indices[0],
- quad_indices[6],
- quad_indices[8],
- quad_indices[10]));
- break;
- }
- case RefinementCase<dim>::cut_z:
- {
- //////////////////////////////
- //
- // RefinementCase<dim>::cut_z
- //
- // the refined cube will look
- // like this:
- //
- // *---------*
- // / /|
- // / / |
- // / / *
- // *---------* /|
- // | | / |
- // | |/ *
- // *---------* /
- // | | /
- // | |/
- // *---------*
- //
- // again, first
- // collect some data
- // about the indices of
- // the lines, with the
- // following numbering:
-
- // face 0: left plane
- // *
- // /|
- // / |
- // / *
- // * /|
- // | 0 |
- // |/ *
- // m0* /
- // | /
- // |/
- // *
- // face 1: right plane
- // *
- // /|
- // / |
- // / *m1
- // * /|
- // | 1 |
- // |/ *
- // * /
- // | /
- // |/
- // *
- // face 2: front plane
- // (note: x,y exchanged)
- // *-------*
- // | |
- // m0*---2---*
- // | |
- // *-------*
- // face 3: back plane
- // (note: x,y exchanged)
- // *-------*
- // | |
- // *---3---*m1
- // | |
- // *-------*
-
- // set up a list of line iterators
- // first. from this, construct
- // lists of line_indices and
- // line orientations later on
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- lines_z[4]
- = {
- hex->face(0)->child(0)
- ->line((hex->face(0)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
- hex->face(1)->child(0)
- ->line((hex->face(1)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
- hex->face(2)->child(0)
- ->line((hex->face(2)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
- hex->face(3)->child(0)
- ->line((hex->face(3)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3) //3
- };
-
- lines=&lines_z[0];
-
- unsigned int line_indices_z[4];
-
- for (unsigned int i=0; i<4; ++i)
- line_indices_z[i]=lines[i]->index();
- line_indices=&line_indices_z[0];
-
- // the orientation of lines for the
- // inner quads is quite tricky. as
- // these lines are newly created
- // ones and thus have no parents,
- // they cannot inherit this
- // property. set up an array and
- // fill it with the respective
- // values
- bool line_orientation_z[4];
-
- // the middle vertex marked
- // as m0 above is the start
- // vertex for lines 0 and 2
- // in standard orientation,
- // whereas m1 is the end
- // vertex of lines 1 and 3 in
- // standard orientation
- const unsigned int middle_vertices[2]=
- {
- middle_vertex_index<dim,spacedim>(hex->line(8)),
- middle_vertex_index<dim,spacedim>(hex->line(11))
- };
-
- for (unsigned int i=0; i<4; ++i)
- if (lines[i]->vertex_index(i%2)==middle_vertices[i%2])
- line_orientation_z[i]=true;
- else
- {
- // it must be the other way round then
- Assert(lines[i]->vertex_index((i+1)%2)==middle_vertices[i%2],
- ExcInternalError());
- line_orientation_z[i]=false;
- }
-
- line_orientation=&line_orientation_z[0];
-
- // set up the new quad, line
- // numbering is as indicated
- // above
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[0],
- line_indices[1],
- line_indices[2],
- line_indices[3]));
-
- new_quads[0]->set_line_orientation(0,line_orientation[0]);
- new_quads[0]->set_line_orientation(1,line_orientation[1]);
- new_quads[0]->set_line_orientation(2,line_orientation[2]);
- new_quads[0]->set_line_orientation(3,line_orientation[3]);
-
- // the quads are
- // numbered as follows:
- //
- // planes in the interior
- // of the old hex:
- // *
- // /|
- // / | x
- // / | *-------* *---------*
- // * | | | / /
- // | | | | / 0 /
- // | * | | / /
- // | / *-------*y *---------*x
- // | /
- // |/
- // *
- //
- // children of the faces
- // of the old hex
- // *---*---* *-------*
- // /| 8 | / /|
- // / | | / 10 / |
- // / *-------* / / *
- // * 2/| | *-------* 4/|
- // | / | 7 | | 6 | / |
- // |/1 *-------* | |/3 *
- // * / / *-------* /
- // | / 9 / | | /
- // |/ / | 5 |/
- // *-------* *---*---*
- //
- // note that we have to
- // take care of the
- // orientation of
- // faces.
- const unsigned int quad_indices_z[11]
- = {
- new_quads[0]->index(), //0
-
- hex->face(0)->child_index( child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]), //1
- hex->face(0)->child_index(1-child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]),
-
- hex->face(1)->child_index( child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]), //3
- hex->face(1)->child_index(1-child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]),
-
- hex->face(2)->child_index( child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]), //5
- hex->face(2)->child_index(1-child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]),
-
- hex->face(3)->child_index( child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]), //7
- hex->face(3)->child_index(1-child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]),
-
- hex->face(4)->index(), //9
-
- hex->face(5)->index() //10
- };
- quad_indices=&quad_indices_z[0];
-
- new_hexes[0]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[1],
- quad_indices[3],
- quad_indices[5],
- quad_indices[7],
- quad_indices[9],
- quad_indices[0]));
- new_hexes[1]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[2],
- quad_indices[4],
- quad_indices[6],
- quad_indices[8],
- quad_indices[0],
- quad_indices[10]));
- break;
- }
- case RefinementCase<dim>::cut_xy:
- {
- //////////////////////////////
- //
- // RefinementCase<dim>::cut_xy
- //
- // the refined cube will look
- // like this:
- //
- // *----*----*
- // / / /|
- // *----*----* |
- // / / /| |
- // *----*----* | |
- // | | | | |
- // | | | | *
- // | | | |/
- // | | | *
- // | | |/
- // *----*----*
- //
-
- // first, create the new
- // internal line
- new_lines[0]->set (internal::Triangulation::
- TriaObject<1>(middle_vertex_index<dim,spacedim>(hex->face(4)),
- middle_vertex_index<dim,spacedim>(hex->face(5))));
-
- // again, first
- // collect some data
- // about the indices of
- // the lines, with the
- // following numbering:
-
- // face 0: left plane
- // *
- // /|
- // * |
- // /| |
- // * | |
- // | 0 |
- // | | *
- // | |/
- // | *
- // |/
- // *
- // face 1: right plane
- // *
- // /|
- // * |
- // /| |
- // * | |
- // | 1 |
- // | | *
- // | |/
- // | *
- // |/
- // *
- // face 2: front plane
- // (note: x,y exchanged)
- // *---*---*
- // | | |
- // | 2 |
- // | | |
- // *-------*
- // face 3: back plane
- // (note: x,y exchanged)
- // *---*---*
- // | | |
- // | 3 |
- // | | |
- // *---*---*
- // face 4: bottom plane
- // *---*---*
- // / 5 /
- // *-6-*-7-*
- // / 4 /
- // *---*---*
- // face 5: top plane
- // *---*---*
- // / 9 /
- // *10-*-11*
- // / 8 /
- // *---*---*
- // middle planes
- // *-------* *---*---*
- // / / | | |
- // / / | 12 |
- // / / | | |
- // *-------* *---*---*
-
- // set up a list of line iterators
- // first. from this, construct
- // lists of line_indices and
- // line orientations later on
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- lines_xy[13]
- = {
- hex->face(0)->child(0)
- ->line((hex->face(0)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
- hex->face(1)->child(0)
- ->line((hex->face(1)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
- hex->face(2)->child(0)
- ->line((hex->face(2)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
- hex->face(3)->child(0)
- ->line((hex->face(3)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //3
-
- hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[4],f_fl[4],f_ro[4])), //4
- hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[4],f_fl[4],f_ro[4])), //5
- hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[4],f_fl[4],f_ro[4])), //6
- hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[4],f_fl[4],f_ro[4])), //7
-
- hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[5],f_fl[5],f_ro[5])), //8
- hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[5],f_fl[5],f_ro[5])), //9
- hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[5],f_fl[5],f_ro[5])), //10
- hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[5],f_fl[5],f_ro[5])), //11
-
- new_lines[0] //12
- };
-
- lines=&lines_xy[0];
-
- unsigned int line_indices_xy[13];
-
- for (unsigned int i=0; i<13; ++i)
- line_indices_xy[i]=lines[i]->index();
- line_indices=&line_indices_xy[0];
-
- // the orientation of lines for the
- // inner quads is quite tricky. as
- // these lines are newly created
- // ones and thus have no parents,
- // they cannot inherit this
- // property. set up an array and
- // fill it with the respective
- // values
- bool line_orientation_xy[13];
-
- // the middle vertices of the
- // lines of our bottom face
- const unsigned int middle_vertices[4]=
- {
- hex->line(0)->child(0)->vertex_index(1),
- hex->line(1)->child(0)->vertex_index(1),
- hex->line(2)->child(0)->vertex_index(1),
- hex->line(3)->child(0)->vertex_index(1),
- };
-
- // note: for lines 0 to 3 the
- // orientation of the line
- // is 'true', if vertex 0 is
- // on the bottom face
- for (unsigned int i=0; i<4; ++i)
- if (lines[i]->vertex_index(0)==middle_vertices[i])
- line_orientation_xy[i]=true;
- else
- {
- // it must be the other way round then
- Assert(lines[i]->vertex_index(1)==middle_vertices[i],
- ExcInternalError());
- line_orientation_xy[i]=false;
- }
-
- // note: for lines 4 to 11
- // (inner lines of the outer quads)
- // the following holds: the second
- // vertex of the even lines in
- // standard orientation is the
- // vertex in the middle of the
- // quad, whereas for odd lines the
- // first vertex is the same middle
- // vertex.
- for (unsigned int i=4; i<12; ++i)
- if (lines[i]->vertex_index((i+1)%2) ==
- middle_vertex_index<dim,spacedim>(hex->face(3+i/4)))
- line_orientation_xy[i]=true;
- else
- {
- // it must be the other way
- // round then
- Assert(lines[i]->vertex_index(i%2) ==
- (middle_vertex_index<dim,spacedim>(hex->face(3+i/4))),
- ExcInternalError());
- line_orientation_xy[i]=false;
- }
- // for the last line the line
- // orientation is always true,
- // since it was just constructed
- // that way
-
- line_orientation_xy[12]=true;
- line_orientation=&line_orientation_xy[0];
-
- // set up the 4 quads,
- // numbered as follows
- // (left quad numbering,
- // right line numbering
- // extracted from above)
- //
- // * *
- // /| 9|
- // * | * |
- // y/| | 8| 3
- // * |1| * | |
- // | | |x | 12|
- // |0| * | | *
- // | |/ 2 |5
- // | * | *
- // |/ |4
- // * *
- //
- // x
- // *---*---* *10-*-11*
- // | | | | | |
- // | 2 | 3 | 0 12 1
- // | | | | | |
- // *---*---*y *-6-*-7-*
-
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[2],
- line_indices[12],
- line_indices[4],
- line_indices[8]));
- new_quads[1]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[12],
- line_indices[3],
- line_indices[5],
- line_indices[9]));
- new_quads[2]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[6],
- line_indices[10],
- line_indices[0],
- line_indices[12]));
- new_quads[3]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[7],
- line_indices[11],
- line_indices[12],
- line_indices[1]));
-
- new_quads[0]->set_line_orientation(0,line_orientation[2]);
- new_quads[0]->set_line_orientation(2,line_orientation[4]);
- new_quads[0]->set_line_orientation(3,line_orientation[8]);
-
- new_quads[1]->set_line_orientation(1,line_orientation[3]);
- new_quads[1]->set_line_orientation(2,line_orientation[5]);
- new_quads[1]->set_line_orientation(3,line_orientation[9]);
-
- new_quads[2]->set_line_orientation(0,line_orientation[6]);
- new_quads[2]->set_line_orientation(1,line_orientation[10]);
- new_quads[2]->set_line_orientation(2,line_orientation[0]);
-
- new_quads[3]->set_line_orientation(0,line_orientation[7]);
- new_quads[3]->set_line_orientation(1,line_orientation[11]);
- new_quads[3]->set_line_orientation(3,line_orientation[1]);
-
- // the quads are
- // numbered as follows:
- //
- // planes in the interior
- // of the old hex:
- // *
- // /|
- // * | x
- // /| | *---*---* *---------*
- // * |1| | | | / /
- // | | | | 2 | 3 | / /
- // |0| * | | | / /
- // | |/ *---*---*y *---------*x
- // | *
- // |/
- // *
- //
- // children of the faces
- // of the old hex
- // *---*---* *---*---*
- // /| | | /18 / 19/|
- // * |10 | 11| /---/---* |
- // /| | | | /16 / 17/| |
- // * |5| | | *---*---* |7|
- // | | *---*---* | | | | *
- // |4|/14 / 15/ | | |6|/
- // | *---/---/ | 8 | 9 | *
- // |/12 / 13/ | | |/
- // *---*---* *---*---*
- //
- // note that we have to
- // take care of the
- // orientation of
- // faces.
- const unsigned int quad_indices_xy[20]
- = {
- new_quads[0]->index(), //0
- new_quads[1]->index(),
- new_quads[2]->index(),
- new_quads[3]->index(),
-
- hex->face(0)->child_index( child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]), //4
- hex->face(0)->child_index(1-child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]),
-
- hex->face(1)->child_index( child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]), //6
- hex->face(1)->child_index(1-child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]),
-
- hex->face(2)->child_index( child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]), //8
- hex->face(2)->child_index(1-child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]),
-
- hex->face(3)->child_index( child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]), //10
- hex->face(3)->child_index(1-child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]),
-
- hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4])), //12
- hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[4],f_fl[4],f_ro[4])),
- hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[4],f_fl[4],f_ro[4])),
- hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4])),
-
- hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5])), //16
- hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[5],f_fl[5],f_ro[5])),
- hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[5],f_fl[5],f_ro[5])),
- hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
- };
- quad_indices=&quad_indices_xy[0];
-
- new_hexes[0]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[4],
- quad_indices[0],
- quad_indices[8],
- quad_indices[2],
- quad_indices[12],
- quad_indices[16]));
- new_hexes[1]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[0],
- quad_indices[6],
- quad_indices[9],
- quad_indices[3],
- quad_indices[13],
- quad_indices[17]));
- new_hexes[2]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[5],
- quad_indices[1],
- quad_indices[2],
- quad_indices[10],
- quad_indices[14],
- quad_indices[18]));
- new_hexes[3]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[1],
- quad_indices[7],
- quad_indices[3],
- quad_indices[11],
- quad_indices[15],
- quad_indices[19]));
- break;
- }
- case RefinementCase<dim>::cut_xz:
- {
- //////////////////////////////
- //
- // RefinementCase<dim>::cut_xz
- //
- // the refined cube will look
- // like this:
- //
- // *----*----*
- // / / /|
- // / / / |
- // / / / *
- // *----*----* /|
- // | | | / |
- // | | |/ *
- // *----*----* /
- // | | | /
- // | | |/
- // *----*----*
- //
-
- // first, create the new
- // internal line
- new_lines[0]->set (internal::Triangulation::
- TriaObject<1>(middle_vertex_index<dim,spacedim>(hex->face(2)),
- middle_vertex_index<dim,spacedim>(hex->face(3))));
-
- // again, first
- // collect some data
- // about the indices of
- // the lines, with the
- // following numbering:
-
- // face 0: left plane
- // *
- // /|
- // / |
- // / *
- // * /|
- // | 0 |
- // |/ *
- // * /
- // | /
- // |/
- // *
- // face 1: right plane
- // *
- // /|
- // / |
- // / *
- // * /|
- // | 1 |
- // |/ *
- // * /
- // | /
- // |/
- // *
- // face 2: front plane
- // (note: x,y exchanged)
- // *---*---*
- // | 5 |
- // *-6-*-7-*
- // | 4 |
- // *---*---*
- // face 3: back plane
- // (note: x,y exchanged)
- // *---*---*
- // | 9 |
- // *10-*-11*
- // | 8 |
- // *---*---*
- // face 4: bottom plane
- // *---*---*
- // / / /
- // / 2 /
- // / / /
- // *---*---*
- // face 5: top plane
- // *---*---*
- // / / /
- // / 3 /
- // / / /
- // *---*---*
- // middle planes
- // *---*---* *-------*
- // / / / | |
- // / 12 / | |
- // / / / | |
- // *---*---* *-------*
-
- // set up a list of line iterators
- // first. from this, construct
- // lists of line_indices and
- // line orientations later on
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- lines_xz[13]
- = {
- hex->face(0)->child(0)
- ->line((hex->face(0)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
- hex->face(1)->child(0)
- ->line((hex->face(1)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
- hex->face(4)->child(0)
- ->line((hex->face(4)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
- hex->face(5)->child(0)
- ->line((hex->face(5)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //3
-
- hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[2],f_fl[2],f_ro[2])), //4
- hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[2],f_fl[2],f_ro[2])), //5
- hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[2],f_fl[2],f_ro[2])), //6
- hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[2],f_fl[2],f_ro[2])), //7
-
- hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[3],f_fl[3],f_ro[3])), //8
- hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[3],f_fl[3],f_ro[3])), //9
- hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[3],f_fl[3],f_ro[3])), //10
- hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[3],f_fl[3],f_ro[3])), //11
-
- new_lines[0] //12
- };
-
- lines=&lines_xz[0];
-
- unsigned int line_indices_xz[13];
-
- for (unsigned int i=0; i<13; ++i)
- line_indices_xz[i]=lines[i]->index();
- line_indices=&line_indices_xz[0];
-
- // the orientation of lines for the
- // inner quads is quite tricky. as
- // these lines are newly created
- // ones and thus have no parents,
- // they cannot inherit this
- // property. set up an array and
- // fill it with the respective
- // values
- bool line_orientation_xz[13];
-
- // the middle vertices of the
- // lines of our front face
- const unsigned int middle_vertices[4]=
- {
- hex->line(8)->child(0)->vertex_index(1),
- hex->line(9)->child(0)->vertex_index(1),
- hex->line(2)->child(0)->vertex_index(1),
- hex->line(6)->child(0)->vertex_index(1),
- };
-
- // note: for lines 0 to 3 the
- // orientation of the line
- // is 'true', if vertex 0 is
- // on the front
- for (unsigned int i=0; i<4; ++i)
- if (lines[i]->vertex_index(0)==middle_vertices[i])
- line_orientation_xz[i]=true;
- else
- {
- // it must be the other way round then
- Assert(lines[i]->vertex_index(1)==middle_vertices[i],
- ExcInternalError());
- line_orientation_xz[i]=false;
- }
-
- // note: for lines 4 to 11
- // (inner lines of the outer quads)
- // the following holds: the second
- // vertex of the even lines in
- // standard orientation is the
- // vertex in the middle of the
- // quad, whereas for odd lines the
- // first vertex is the same middle
- // vertex.
- for (unsigned int i=4; i<12; ++i)
- if (lines[i]->vertex_index((i+1)%2) ==
- middle_vertex_index<dim,spacedim>(hex->face(1+i/4)))
- line_orientation_xz[i]=true;
- else
- {
- // it must be the other way
- // round then
- Assert(lines[i]->vertex_index(i%2) ==
- (middle_vertex_index<dim,spacedim>(hex->face(1+i/4))),
- ExcInternalError());
- line_orientation_xz[i]=false;
- }
- // for the last line the line
- // orientation is always true,
- // since it was just constructed
- // that way
-
- line_orientation_xz[12]=true;
- line_orientation=&line_orientation_xz[0];
-
- // set up the 4 quads,
- // numbered as follows
- // (left quad numbering,
- // right line numbering
- // extracted from above),
- // the drawings denote
- // middle planes
- //
- // * *
- // /| /|
- // / | 3 9
- // y/ * / *
- // * 3/| * /|
- // | / |x 5 12|8
- // |/ * |/ *
- // * 2/ * /
- // | / 4 2
- // |/ |/
- // * *
- //
- // y
- // *----*----* *-10-*-11-*
- // / / / / / /
- // / 0 / 1 / 0 12 1
- // / / / / / /
- // *----*----*x *--6-*--7-*
-
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[0],
- line_indices[12],
- line_indices[6],
- line_indices[10]));
- new_quads[1]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[12],
- line_indices[1],
- line_indices[7],
- line_indices[11]));
- new_quads[2]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[4],
- line_indices[8],
- line_indices[2],
- line_indices[12]));
- new_quads[3]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[5],
- line_indices[9],
- line_indices[12],
- line_indices[3]));
-
- new_quads[0]->set_line_orientation(0,line_orientation[0]);
- new_quads[0]->set_line_orientation(2,line_orientation[6]);
- new_quads[0]->set_line_orientation(3,line_orientation[10]);
-
- new_quads[1]->set_line_orientation(1,line_orientation[1]);
- new_quads[1]->set_line_orientation(2,line_orientation[7]);
- new_quads[1]->set_line_orientation(3,line_orientation[11]);
-
- new_quads[2]->set_line_orientation(0,line_orientation[4]);
- new_quads[2]->set_line_orientation(1,line_orientation[8]);
- new_quads[2]->set_line_orientation(2,line_orientation[2]);
-
- new_quads[3]->set_line_orientation(0,line_orientation[5]);
- new_quads[3]->set_line_orientation(1,line_orientation[9]);
- new_quads[3]->set_line_orientation(3,line_orientation[3]);
-
- // the quads are
- // numbered as follows:
- //
- // planes in the interior
- // of the old hex:
- // *
- // /|
- // / | x
- // /3 * *-------* *----*----*
- // * /| | | / / /
- // | / | | | / 0 / 1 /
- // |/ * | | / / /
- // * 2/ *-------*y *----*----*x
- // | /
- // |/
- // *
- //
- // children of the faces
- // of the old hex
- // *---*---* *---*---*
- // /|13 | 15| / / /|
- // / | | | /18 / 19/ |
- // / *---*---* / / / *
- // * 5/| | | *---*---* 7/|
- // | / |12 | 14| | 9 | 11| / |
- // |/4 *---*---* | | |/6 *
- // * / / / *---*---* /
- // | /16 / 17/ | | | /
- // |/ / / | 8 | 10|/
- // *---*---* *---*---*
- //
- // note that we have to
- // take care of the
- // orientation of
- // faces.
- const unsigned int quad_indices_xz[20]
- = {
- new_quads[0]->index(), //0
- new_quads[1]->index(),
- new_quads[2]->index(),
- new_quads[3]->index(),
-
- hex->face(0)->child_index( child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]), //4
- hex->face(0)->child_index(1-child_at_origin[hex->face(0)->refinement_case()-1][f_fl[0]][f_ro[0]]),
-
- hex->face(1)->child_index( child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]), //6
- hex->face(1)->child_index(1-child_at_origin[hex->face(1)->refinement_case()-1][f_fl[1]][f_ro[1]]),
-
- hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2])), //8
- hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[2],f_fl[2],f_ro[2])),
- hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[2],f_fl[2],f_ro[2])),
- hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2])),
-
- hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3])), //12
- hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[3],f_fl[3],f_ro[3])),
- hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[3],f_fl[3],f_ro[3])),
- hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3])),
-
- hex->face(4)->child_index( child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]), //16
- hex->face(4)->child_index(1-child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]),
-
- hex->face(5)->child_index( child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]]), //18
- hex->face(5)->child_index(1-child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]])
- };
- quad_indices=&quad_indices_xz[0];
-
- // due to the exchange of x
- // and y for the front and
- // back face, we order the
- // children according to
- //
- // *---*---*
- // | 1 | 3 |
- // *---*---*
- // | 0 | 2 |
- // *---*---*
- new_hexes[0]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[4],
- quad_indices[2],
- quad_indices[8],
- quad_indices[12],
- quad_indices[16],
- quad_indices[0]));
- new_hexes[1]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[5],
- quad_indices[3],
- quad_indices[9],
- quad_indices[13],
- quad_indices[0],
- quad_indices[18]));
- new_hexes[2]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[2],
- quad_indices[6],
- quad_indices[10],
- quad_indices[14],
- quad_indices[17],
- quad_indices[1]));
- new_hexes[3]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[3],
- quad_indices[7],
- quad_indices[11],
- quad_indices[15],
- quad_indices[1],
- quad_indices[19]));
- break;
- }
- case RefinementCase<dim>::cut_yz:
- {
- //////////////////////////////
- //
- // RefinementCase<dim>::cut_yz
- //
- // the refined cube will look
- // like this:
- //
- // *---------*
- // / /|
- // *---------* |
- // / /| |
- // *---------* |/|
- // | | * |
- // | |/| *
- // *---------* |/
- // | | *
- // | |/
- // *---------*
- //
-
- // first, create the new
- // internal line
- new_lines[0]->set (internal::Triangulation::
- TriaObject<1>(middle_vertex_index<dim,spacedim>(hex->face(0)),
- middle_vertex_index<dim,spacedim>(hex->face(1))));
-
- // again, first
- // collect some data
- // about the indices of
- // the lines, with the
- // following numbering:
- // (note that face 0 and
- // 1 each are shown twice
- // for better
- // readability)
-
- // face 0: left plane
- // * *
- // /| /|
- // * | * |
- // /| * /| *
- // * 5/| * |7|
- // | * | | * |
- // |/| * |6| *
- // * 4/ * |/
- // | * | *
- // |/ |/
- // * *
- // face 1: right plane
- // * *
- // /| /|
- // * | * |
- // /| * /| *
- // * 9/| * |11
- // | * | | * |
- // |/| * |10 *
- // * 8/ * |/
- // | * | *
- // |/ |/
- // * *
- // face 2: front plane
- // (note: x,y exchanged)
- // *-------*
- // | |
- // *---0---*
- // | |
- // *-------*
- // face 3: back plane
- // (note: x,y exchanged)
- // *-------*
- // | |
- // *---1---*
- // | |
- // *-------*
- // face 4: bottom plane
- // *-------*
- // / /
- // *---2---*
- // / /
- // *-------*
- // face 5: top plane
- // *-------*
- // / /
- // *---3---*
- // / /
- // *-------*
- // middle planes
- // *-------* *-------*
- // / / | |
- // *---12--* | |
- // / / | |
- // *-------* *-------*
-
- // set up a list of line iterators
- // first. from this, construct
- // lists of line_indices and
- // line orientations later on
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- lines_yz[13]
- = {
- hex->face(2)->child(0)
- ->line((hex->face(2)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //0
- hex->face(3)->child(0)
- ->line((hex->face(3)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //1
- hex->face(4)->child(0)
- ->line((hex->face(4)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //2
- hex->face(5)->child(0)
- ->line((hex->face(5)->refinement_case() == RefinementCase<2>::cut_x) ? 1 : 3), //3
-
- hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[0],f_fl[0],f_ro[0])), //4
- hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[0],f_fl[0],f_ro[0])), //5
- hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[0],f_fl[0],f_ro[0])), //6
- hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[0],f_fl[0],f_ro[0])), //7
-
- hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[1],f_fl[1],f_ro[1])), //8
- hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[1],f_fl[1],f_ro[1])), //9
- hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[1],f_fl[1],f_ro[1])), //10
- hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[1],f_fl[1],f_ro[1])), //11
-
- new_lines[0] //12
- };
-
- lines=&lines_yz[0];
-
- unsigned int line_indices_yz[13];
-
- for (unsigned int i=0; i<13; ++i)
- line_indices_yz[i]=lines[i]->index();
- line_indices=&line_indices_yz[0];
-
- // the orientation of lines for the
- // inner quads is quite tricky. as
- // these lines are newly created
- // ones and thus have no parents,
- // they cannot inherit this
- // property. set up an array and
- // fill it with the respective
- // values
- bool line_orientation_yz[13];
-
- // the middle vertices of the
- // lines of our front face
- const unsigned int middle_vertices[4]=
- {
- hex->line(8)->child(0)->vertex_index(1),
- hex->line(10)->child(0)->vertex_index(1),
- hex->line(0)->child(0)->vertex_index(1),
- hex->line(4)->child(0)->vertex_index(1),
- };
-
- // note: for lines 0 to 3 the
- // orientation of the line
- // is 'true', if vertex 0 is
- // on the front
- for (unsigned int i=0; i<4; ++i)
- if (lines[i]->vertex_index(0)==middle_vertices[i])
- line_orientation_yz[i]=true;
- else
- {
- // it must be the other way round then
- Assert(lines[i]->vertex_index(1)==middle_vertices[i],
- ExcInternalError());
- line_orientation_yz[i]=false;
- }
-
- // note: for lines 4 to 11
- // (inner lines of the outer quads)
- // the following holds: the second
- // vertex of the even lines in
- // standard orientation is the
- // vertex in the middle of the
- // quad, whereas for odd lines the
- // first vertex is the same middle
- // vertex.
- for (unsigned int i=4; i<12; ++i)
- if (lines[i]->vertex_index((i+1)%2) ==
- middle_vertex_index<dim,spacedim>(hex->face(i/4-1)))
- line_orientation_yz[i]=true;
- else
- {
- // it must be the other way
- // round then
- Assert(lines[i]->vertex_index(i%2) ==
- (middle_vertex_index<dim,spacedim>(hex->face(i/4-1))),
- ExcInternalError());
- line_orientation_yz[i]=false;
- }
- // for the last line the line
- // orientation is always true,
- // since it was just constructed
- // that way
-
- line_orientation_yz[12]=true;
- line_orientation=&line_orientation_yz[0];
-
- // set up the 4 quads,
- // numbered as follows (left
- // quad numbering, right line
- // numbering extracted from
- // above)
- //
- // x
- // *-------* *---3---*
- // | 3 | 5 9
- // *-------* *---12--*
- // | 2 | 4 8
- // *-------*y *---2---*
- //
- // y
- // *---------* *----1----*
- // / 1 / 7 11
- // *---------* *----12---*
- // / 0 / 6 10
- // *---------*x *----0----*
-
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[6],
- line_indices[10],
- line_indices[0],
- line_indices[12]));
- new_quads[1]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[7],
- line_indices[11],
- line_indices[12],
- line_indices[1]));
- new_quads[2]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[2],
- line_indices[12],
- line_indices[4],
- line_indices[8]));
- new_quads[3]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[12],
- line_indices[3],
- line_indices[5],
- line_indices[9]));
-
- new_quads[0]->set_line_orientation(0,line_orientation[6]);
- new_quads[0]->set_line_orientation(1,line_orientation[10]);
- new_quads[0]->set_line_orientation(2,line_orientation[0]);
-
- new_quads[1]->set_line_orientation(0,line_orientation[7]);
- new_quads[1]->set_line_orientation(1,line_orientation[11]);
- new_quads[1]->set_line_orientation(3,line_orientation[1]);
-
- new_quads[2]->set_line_orientation(0,line_orientation[2]);
- new_quads[2]->set_line_orientation(2,line_orientation[4]);
- new_quads[2]->set_line_orientation(3,line_orientation[8]);
-
- new_quads[3]->set_line_orientation(1,line_orientation[3]);
- new_quads[3]->set_line_orientation(2,line_orientation[5]);
- new_quads[3]->set_line_orientation(3,line_orientation[9]);
-
- // the quads are
- // numbered as follows:
- //
- // planes in the interior
- // of the old hex:
- // *
- // /|
- // / | x
- // / | *-------* *---------*
- // * | | 3 | / 1 /
- // | | *-------* *---------*
- // | * | 2 | / 0 /
- // | / *-------*y *---------*x
- // | /
- // |/
- // *
- //
- // children of the faces
- // of the old hex
- // *-------* *-------*
- // /| | / 19 /|
- // * | 15 | *-------* |
- // /|7*-------* / 18 /|11
- // * |/| | *-------* |/|
- // |6* | 14 | | 10* |
- // |/|5*-------* | 13 |/|9*
- // * |/ 17 / *-------* |/
- // |4*-------* | |8*
- // |/ 16 / | 12 |/
- // *-------* *-------*
- //
- // note that we have to
- // take care of the
- // orientation of
- // faces.
- const unsigned int quad_indices_yz[20]
- = {
- new_quads[0]->index(), //0
- new_quads[1]->index(),
- new_quads[2]->index(),
- new_quads[3]->index(),
-
- hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0])), //4
- hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[0],f_fl[0],f_ro[0])),
- hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[0],f_fl[0],f_ro[0])),
- hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0])),
-
- hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1])), //8
- hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[1],f_fl[1],f_ro[1])),
- hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[1],f_fl[1],f_ro[1])),
- hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1])),
-
- hex->face(2)->child_index( child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]), //12
- hex->face(2)->child_index(1-child_at_origin[hex->face(2)->refinement_case()-1][f_fl[2]][f_ro[2]]),
-
- hex->face(3)->child_index( child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]), //14
- hex->face(3)->child_index(1-child_at_origin[hex->face(3)->refinement_case()-1][f_fl[3]][f_ro[3]]),
-
- hex->face(4)->child_index( child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]), //16
- hex->face(4)->child_index(1-child_at_origin[hex->face(4)->refinement_case()-1][f_fl[4]][f_ro[4]]),
-
- hex->face(5)->child_index( child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]]), //18
- hex->face(5)->child_index(1-child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]])
- };
- quad_indices=&quad_indices_yz[0];
-
- new_hexes[0]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[4],
- quad_indices[8],
- quad_indices[12],
- quad_indices[2],
- quad_indices[16],
- quad_indices[0]));
- new_hexes[1]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[5],
- quad_indices[9],
- quad_indices[2],
- quad_indices[14],
- quad_indices[17],
- quad_indices[1]));
- new_hexes[2]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[6],
- quad_indices[10],
- quad_indices[13],
- quad_indices[3],
- quad_indices[0],
- quad_indices[18]));
- new_hexes[3]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[7],
- quad_indices[11],
- quad_indices[3],
- quad_indices[15],
- quad_indices[1],
- quad_indices[19]));
- break;
- }
- case RefinementCase<dim>::cut_xyz:
- {
- //////////////////////////////
- //
- // RefinementCase<dim>::cut_xyz
- // isotropic refinement
- //
- // the refined cube will look
- // like this:
- //
- // *----*----*
- // / / /|
- // *----*----* |
- // / / /| *
- // *----*----* |/|
- // | | | * |
- // | | |/| *
- // *----*----* |/
- // | | | *
- // | | |/
- // *----*----*
- //
-
- // find the next unused
- // vertex and set it
- // appropriately
- while (triangulation.vertices_used[next_unused_vertex] == true)
- ++next_unused_vertex;
- Assert (next_unused_vertex < triangulation.vertices.size(),
- ExcTooFewVerticesAllocated());
- triangulation.vertices_used[next_unused_vertex] = true;
-
- // the new vertex is
- // definitely in the
- // interior, so we need not
- // worry about the boundary.
- // let it be the average of
- // the 26 vertices
- // surrounding it. weight
- // these vertices in the same
- // way as they are weighted
- // in the
- // @p{MappingQ::set_laplace_on_hex_vector}
- // function, and like the new
- // vertex at the center of
- // the quad is weighted (see
- // above)
- triangulation.vertices[next_unused_vertex] = Point<dim>();
- // first add corners of hex
- for (unsigned int vertex=0;
- vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
- triangulation.vertices[next_unused_vertex] += hex->vertex(vertex) / 128;
- // now add center of lines
- for (unsigned int line=0;
- line<GeometryInfo<dim>::lines_per_cell; ++line)
- triangulation.vertices[next_unused_vertex] += hex->line(line)->child(0)->vertex(1) *
- 7./192.;
- // finally add centers of
- // faces. note that vertex 3
- // of child 0 is an invariant
- // with respect to the face
- // orientation, flip and
- // rotation
- for (unsigned int face=0;
- face<GeometryInfo<dim>::faces_per_cell; ++face)
- triangulation.vertices[next_unused_vertex] += hex->face(face)->isotropic_child(0)->vertex(3) *
- 1./12.;
-
- // set the data of the
- // six lines. first
- // collect the indices of
- // the seven vertices
- // (consider the two
- // planes to be crossed
- // to form the planes
- // cutting the hex in two
- // vertically and
- // horizontally)
- // *--3--* *--5--*
- // / / / | | |
- // 0--6--1 0--6--1
- // / / / | | |
- // *--2--* *--4--*
- // the lines are numbered
- // as follows:
- // *--*--* *--*--*
- // / 1 / | 5 |
- // *2-*-3* *2-*-3*
- // / 0 / | 4 |
- // *--*--* *--*--*
- //
- const unsigned int vertex_indices_xyz[7]
- = { middle_vertex_index<dim,spacedim>(hex->face(0)),
- middle_vertex_index<dim,spacedim>(hex->face(1)),
- middle_vertex_index<dim,spacedim>(hex->face(2)),
- middle_vertex_index<dim,spacedim>(hex->face(3)),
- middle_vertex_index<dim,spacedim>(hex->face(4)),
- middle_vertex_index<dim,spacedim>(hex->face(5)),
- next_unused_vertex
- };
- vertex_indices=&vertex_indices_xyz[0];
-
- new_lines[0]->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[2], vertex_indices[6]));
- new_lines[1]->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[6], vertex_indices[3]));
- new_lines[2]->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[0], vertex_indices[6]));
- new_lines[3]->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[6], vertex_indices[1]));
- new_lines[4]->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[4], vertex_indices[6]));
- new_lines[5]->set (internal::Triangulation::
- TriaObject<1>(vertex_indices[6], vertex_indices[5]));
-
- // again, first
- // collect some data
- // about the indices of
- // the lines, with the
- // following numbering:
- // (note that face 0 and
- // 1 each are shown twice
- // for better
- // readability)
-
- // face 0: left plane
- // * *
- // /| /|
- // * | * |
- // /| * /| *
- // * 1/| * |3|
- // | * | | * |
- // |/| * |2| *
- // * 0/ * |/
- // | * | *
- // |/ |/
- // * *
- // face 1: right plane
- // * *
- // /| /|
- // * | * |
- // /| * /| *
- // * 5/| * |7|
- // | * | | * |
- // |/| * |6| *
- // * 4/ * |/
- // | * | *
- // |/ |/
- // * *
- // face 2: front plane
- // (note: x,y exchanged)
- // *---*---*
- // | 11 |
- // *-8-*-9-*
- // | 10 |
- // *---*---*
- // face 3: back plane
- // (note: x,y exchanged)
- // *---*---*
- // | 15 |
- // *12-*-13*
- // | 14 |
- // *---*---*
- // face 4: bottom plane
- // *---*---*
- // / 17 /
- // *18-*-19*
- // / 16 /
- // *---*---*
- // face 5: top plane
- // *---*---*
- // / 21 /
- // *22-*-23*
- // / 20 /
- // *---*---*
- // middle planes
- // *---*---* *---*---*
- // / 25 / | 29 |
- // *26-*-27* *26-*-27*
- // / 24 / | 28 |
- // *---*---* *---*---*
-
- // set up a list of line iterators
- // first. from this, construct
- // lists of line_indices and
- // line orientations later on
- const typename Triangulation<dim,spacedim>::raw_line_iterator
- lines_xyz[30]
- = {
- hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[0],f_fl[0],f_ro[0])), //0
- hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[0],f_fl[0],f_ro[0])), //1
- hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[0],f_fl[0],f_ro[0])), //2
- hex->face(0)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[0],f_fl[0],f_ro[0])), //3
-
- hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[1],f_fl[1],f_ro[1])), //4
- hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[1],f_fl[1],f_ro[1])), //5
- hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[1],f_fl[1],f_ro[1])), //6
- hex->face(1)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[1],f_fl[1],f_ro[1])), //7
-
- hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[2],f_fl[2],f_ro[2])), //8
- hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[2],f_fl[2],f_ro[2])), //9
- hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[2],f_fl[2],f_ro[2])), //10
- hex->face(2)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[2],f_fl[2],f_ro[2])), //11
-
- hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[3],f_fl[3],f_ro[3])), //12
- hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[3],f_fl[3],f_ro[3])), //13
- hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[3],f_fl[3],f_ro[3])), //14
- hex->face(3)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[3],f_fl[3],f_ro[3])), //15
-
- hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[4],f_fl[4],f_ro[4])), //16
- hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[4],f_fl[4],f_ro[4])), //17
- hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[4],f_fl[4],f_ro[4])), //18
- hex->face(4)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[4],f_fl[4],f_ro[4])), //19
-
- hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(1,f_or[5],f_fl[5],f_ro[5])), //20
- hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(0,f_or[5],f_fl[5],f_ro[5])), //21
- hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(3,f_or[5],f_fl[5],f_ro[5])), //22
- hex->face(5)->isotropic_child(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
- ->line(GeometryInfo<dim>::standard_to_real_face_line(2,f_or[5],f_fl[5],f_ro[5])), //23
-
- new_lines[0], //24
- new_lines[1], //25
- new_lines[2], //26
- new_lines[3], //27
- new_lines[4], //28
- new_lines[5] //29
- };
-
- lines=&lines_xyz[0];
-
- unsigned int line_indices_xyz[30];
- for (unsigned int i=0; i<30; ++i)
- line_indices_xyz[i]=lines[i]->index();
- line_indices=&line_indices_xyz[0];
-
- // the orientation of lines for the
- // inner quads is quite tricky. as
- // these lines are newly created
- // ones and thus have no parents,
- // they cannot inherit this
- // property. set up an array and
- // fill it with the respective
- // values
- bool line_orientation_xyz[30];
-
- // note: for the first 24 lines
- // (inner lines of the outer quads)
- // the following holds: the second
- // vertex of the even lines in
- // standard orientation is the
- // vertex in the middle of the
- // quad, whereas for odd lines the
- // first vertex is the same middle
- // vertex.
- for (unsigned int i=0; i<24; ++i)
- if (lines[i]->vertex_index((i+1)%2)==vertex_indices[i/4])
- line_orientation_xyz[i]=true;
- else
- {
- // it must be the other way
- // round then
- Assert(lines[i]->vertex_index(i%2)==vertex_indices[i/4],
- ExcInternalError());
- line_orientation_xyz[i]=false;
- }
- // for the last 6 lines the line
- // orientation is always true,
- // since they were just constructed
- // that way
- for (unsigned int i=24; i<30; ++i)
- line_orientation_xyz[i]=true;
- line_orientation=&line_orientation_xyz[0];
-
- // set up the 12 quads,
- // numbered as follows
- // (left quad numbering,
- // right line numbering
- // extracted from above)
- //
- // * *
- // /| 21|
- // * | * 15
- // y/|3* 20| *
- // * |/| * |/|
- // |2* |x 11 * 14
- // |/|1* |/| *
- // * |/ * |17
- // |0* 10 *
- // |/ |16
- // * *
- //
- // x
- // *---*---* *22-*-23*
- // | 5 | 7 | 1 29 5
- // *---*---* *26-*-27*
- // | 4 | 6 | 0 28 4
- // *---*---*y *18-*-19*
- //
- // y
- // *----*----* *-12-*-13-*
- // / 10 / 11 / 3 25 7
- // *----*----* *-26-*-27-*
- // / 8 / 9 / 2 24 6
- // *----*----*x *--8-*--9-*
-
- new_quads[0]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[10],
- line_indices[28],
- line_indices[16],
- line_indices[24]));
- new_quads[1]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[28],
- line_indices[14],
- line_indices[17],
- line_indices[25]));
- new_quads[2]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[11],
- line_indices[29],
- line_indices[24],
- line_indices[20]));
- new_quads[3]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[29],
- line_indices[15],
- line_indices[25],
- line_indices[21]));
- new_quads[4]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[18],
- line_indices[26],
- line_indices[0],
- line_indices[28]));
- new_quads[5]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[26],
- line_indices[22],
- line_indices[1],
- line_indices[29]));
- new_quads[6]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[19],
- line_indices[27],
- line_indices[28],
- line_indices[4]));
- new_quads[7]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[27],
- line_indices[23],
- line_indices[29],
- line_indices[5]));
- new_quads[8]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[2],
- line_indices[24],
- line_indices[8],
- line_indices[26]));
- new_quads[9]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[24],
- line_indices[6],
- line_indices[9],
- line_indices[27]));
- new_quads[10]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[3],
- line_indices[25],
- line_indices[26],
- line_indices[12]));
- new_quads[11]->set (internal::Triangulation
- ::TriaObject<2>(line_indices[25],
- line_indices[7],
- line_indices[27],
- line_indices[13]));
-
- // now reset the line_orientation
- // flags of outer lines as they
- // cannot be set in a loop (at
- // least not easily)
- new_quads[0]->set_line_orientation(0,line_orientation[10]);
- new_quads[0]->set_line_orientation(2,line_orientation[16]);
-
- new_quads[1]->set_line_orientation(1,line_orientation[14]);
- new_quads[1]->set_line_orientation(2,line_orientation[17]);
-
- new_quads[2]->set_line_orientation(0,line_orientation[11]);
- new_quads[2]->set_line_orientation(3,line_orientation[20]);
-
- new_quads[3]->set_line_orientation(1,line_orientation[15]);
- new_quads[3]->set_line_orientation(3,line_orientation[21]);
-
- new_quads[4]->set_line_orientation(0,line_orientation[18]);
- new_quads[4]->set_line_orientation(2,line_orientation[0]);
-
- new_quads[5]->set_line_orientation(1,line_orientation[22]);
- new_quads[5]->set_line_orientation(2,line_orientation[1]);
-
- new_quads[6]->set_line_orientation(0,line_orientation[19]);
- new_quads[6]->set_line_orientation(3,line_orientation[4]);
-
- new_quads[7]->set_line_orientation(1,line_orientation[23]);
- new_quads[7]->set_line_orientation(3,line_orientation[5]);
-
- new_quads[8]->set_line_orientation(0,line_orientation[2]);
- new_quads[8]->set_line_orientation(2,line_orientation[8]);
-
- new_quads[9]->set_line_orientation(1,line_orientation[6]);
- new_quads[9]->set_line_orientation(2,line_orientation[9]);
-
- new_quads[10]->set_line_orientation(0,line_orientation[3]);
- new_quads[10]->set_line_orientation(3,line_orientation[12]);
-
- new_quads[11]->set_line_orientation(1,line_orientation[7]);
- new_quads[11]->set_line_orientation(3,line_orientation[13]);
-
- /////////////////////////////////
- // create the eight new hexes
- //
- // again first collect
- // some data. here, we
- // need the indices of a
- // whole lotta
- // quads.
-
- // the quads are
- // numbered as follows:
- //
- // planes in the interior
- // of the old hex:
- // *
- // /|
- // * |
- // /|3* *---*---* *----*----*
- // * |/| | 5 | 7 | / 10 / 11 /
- // |2* | *---*---* *----*----*
- // |/|1* | 4 | 6 | / 8 / 9 /
- // * |/ *---*---*y *----*----*x
- // |0*
- // |/
- // *
- //
- // children of the faces
- // of the old hex
- // *-------* *-------*
- // /|25 27| /34 35/|
- // 15| | / /19
- // / | | /32 33/ |
- // * |24 26| *-------*18 |
- // 1413*-------* |21 23| 17*
- // | /30 31/ | | /
- // 12/ / | |16
- // |/28 29/ |20 22|/
- // *-------* *-------*
- //
- // note that we have to
- // take care of the
- // orientation of
- // faces.
- const unsigned int quad_indices_xyz[36]
- = {
- new_quads[0]->index(), //0
- new_quads[1]->index(),
- new_quads[2]->index(),
- new_quads[3]->index(),
- new_quads[4]->index(),
- new_quads[5]->index(),
- new_quads[6]->index(),
- new_quads[7]->index(),
- new_quads[8]->index(),
- new_quads[9]->index(),
- new_quads[10]->index(),
- new_quads[11]->index(), //11
-
- hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[0],f_fl[0],f_ro[0])), //12
- hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[0],f_fl[0],f_ro[0])),
- hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[0],f_fl[0],f_ro[0])),
- hex->face(0)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[0],f_fl[0],f_ro[0])),
-
- hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[1],f_fl[1],f_ro[1])), //16
- hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[1],f_fl[1],f_ro[1])),
- hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[1],f_fl[1],f_ro[1])),
- hex->face(1)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[1],f_fl[1],f_ro[1])),
-
- hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[2],f_fl[2],f_ro[2])), //20
- hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[2],f_fl[2],f_ro[2])),
- hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[2],f_fl[2],f_ro[2])),
- hex->face(2)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[2],f_fl[2],f_ro[2])),
-
- hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[3],f_fl[3],f_ro[3])), //24
- hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[3],f_fl[3],f_ro[3])),
- hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[3],f_fl[3],f_ro[3])),
- hex->face(3)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[3],f_fl[3],f_ro[3])),
-
- hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[4],f_fl[4],f_ro[4])), //28
- hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[4],f_fl[4],f_ro[4])),
- hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[4],f_fl[4],f_ro[4])),
- hex->face(4)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[4],f_fl[4],f_ro[4])),
-
- hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(0,f_or[5],f_fl[5],f_ro[5])), //32
- hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(1,f_or[5],f_fl[5],f_ro[5])),
- hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(2,f_or[5],f_fl[5],f_ro[5])),
- hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
- };
- quad_indices=&quad_indices_xyz[0];
-
- // bottom children
- new_hexes[0]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[12],
- quad_indices[0],
- quad_indices[20],
- quad_indices[4],
- quad_indices[28],
- quad_indices[8]));
- new_hexes[1]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[0],
- quad_indices[16],
- quad_indices[22],
- quad_indices[6],
- quad_indices[29],
- quad_indices[9]));
- new_hexes[2]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[13],
- quad_indices[1],
- quad_indices[4],
- quad_indices[24],
- quad_indices[30],
- quad_indices[10]));
- new_hexes[3]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[1],
- quad_indices[17],
- quad_indices[6],
- quad_indices[26],
- quad_indices[31],
- quad_indices[11]));
-
- // top children
- new_hexes[4]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[14],
- quad_indices[2],
- quad_indices[21],
- quad_indices[5],
- quad_indices[8],
- quad_indices[32]));
- new_hexes[5]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[2],
- quad_indices[18],
- quad_indices[23],
- quad_indices[7],
- quad_indices[9],
- quad_indices[33]));
- new_hexes[6]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[15],
- quad_indices[3],
- quad_indices[5],
- quad_indices[25],
- quad_indices[10],
- quad_indices[34]));
- new_hexes[7]->set (internal::Triangulation
- ::TriaObject<3>(quad_indices[3],
- quad_indices[19],
- quad_indices[7],
- quad_indices[27],
- quad_indices[11],
- quad_indices[35]));
- break;
- }
- default:
- // all refinement cases
- // have been treated,
- // there only remains
- // RefinementCase<dim>::no_refinement
- // as untreated
- // enumeration
- // value. However, in
- // that case we should
- // have aborted much
- // earlier. thus we
- // should never get here
- Assert(false, ExcInternalError());
- break;
- }//switch (ref_case)
-
- // and set face orientation
- // flags. note that new faces in
- // the interior of the mother cell
- // always have a correctly oriented
- // face, but the ones on the outer
- // faces will inherit this flag
- //
- // the flag have been set to true
- // for all faces initially, now go
- // the other way round and reset
- // faces that are at the boundary
- // of the mother cube
- //
- // the same is true for the
- // face_flip and face_rotation
- // flags. however, the latter two
- // are set to false by default as
- // this is the standard value
-
- // loop over all faces and all
- // (relevant) subfaces of that in
- // order to set the correct values
- // for face_orientation, face_flip
- // and face_rotation, which are
- // inherited from the corresponding
- // face of the mother cube
- for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
- for (unsigned int s=0;
- s<std::max(GeometryInfo<dim-1>::n_children(GeometryInfo<dim>::face_refinement_case(ref_case,f)),
- 1U);
- ++s)
- {
- const unsigned int current_child
- =GeometryInfo<dim>::child_cell_on_face(ref_case,
- f,
- s,
- f_or[f],
- f_fl[f],
- f_ro[f],
- GeometryInfo<dim>::face_refinement_case(ref_case,
- f,
- f_or[f],
- f_fl[f],
- f_ro[f]));
- new_hexes[current_child]->set_face_orientation (f, f_or[f]);
- new_hexes[current_child]->set_face_flip (f, f_fl[f]);
- new_hexes[current_child]->set_face_rotation (f, f_ro[f]);
- }
-
- // now see if
- // we have
- // created
- // cells that
- // are
- // distorted
- // and if so
- // add them to
- // our list
- if ((check_for_distorted_cells == true)
- &&
- has_distorted_children (hex,
- internal::int2type<dim>(),
- internal::int2type<spacedim>()))
- cells_with_distorted_children.distorted_cells.push_back (hex);
-
- // note that the
- // refinement flag was
- // already cleared at the
- // beginning of this loop
- }
- }
-
- // clear user data on quads. we used some of
- // this data to indicate anisotropic
- // refinemnt cases on faces. all data should
- // be cleared by now, but the information
- // whether we used indices or pointers is
- // still present. reset it now to enable the
- // user to use whichever he likes later on.
- triangulation.faces->quads.clear_user_data();
-
- // return the list with distorted children
- return cells_with_distorted_children;
- }
-
-
- /**
- * At the boundary of the domain, the new
- * point on the face may be far inside the
- * current cell, if the boundary has a
- * strong curvature. If we allow anisotropic
- * refinement here, the resulting cell may
- * be strongly distorted. To prevent this,
- * this function flags such cells for
- * isotropic refinement. It is called
- * automatically from
- * prepare_coarsening_and_refinement().
- *
- * This function does nothing in
- * 1d (therefore the
- * specialization).
- */
- template <int spacedim>
- static
- void
- prevent_distorted_boundary_cells (const Triangulation<1,spacedim> &);
-
- template <int dim, int spacedim>
- static
- void
- prevent_distorted_boundary_cells (Triangulation<dim,spacedim> &triangulation)
- {
- for (typename Triangulation<dim,spacedim>::cell_iterator
- cell=triangulation.begin(); cell!=triangulation.end(); ++cell)
- if (cell->at_boundary() &&
- cell->refine_flag_set() &&
- cell->refine_flag_set()!=RefinementCase<dim>::isotropic_refinement)
- {
- // The cell is at the boundary
- // and it is flagged for
- // anisotropic
- // refinement. Therefore, we have
- // a closer look
- const RefinementCase<dim> ref_case=cell->refine_flag_set();
- for (unsigned int face_no=0;
- face_no<GeometryInfo<dim>::faces_per_cell;
- ++face_no)
- if (cell->face(face_no)->at_boundary())
- {
- // this is the critical
- // face at the boundary.
- if (GeometryInfo<dim>::face_refinement_case(ref_case,face_no)
- !=RefinementCase<dim-1>::isotropic_refinement)
- {
- // up to now, we do not
- // want to refine this
- // cell along the face
- // under consideration
- // here.
- const typename Triangulation<dim,spacedim>::face_iterator
- face = cell->face(face_no);
- // the new point on the
- // boundary would be
- // this one.
- const Point<spacedim> new_bound
- = triangulation.boundary[face->boundary_indicator()]
- ->get_new_point_on_face (face);
- // to check it,
- // transform to the
- // unit cell with
- // Q1Mapping
- const Point<dim> new_unit
- = StaticMappingQ1<dim,spacedim>::mapping.
- transform_real_to_unit_cell(cell,
- new_bound);
-
- // Now, we have to
- // calculate the
- // distance from the
- // face in the unit
- // cell.
-
- // take the correct
- // coordinate direction (0
- // for faces 0 and 1, 1 for
- // faces 2 and 3, 2 for faces
- // 4 and 5) and substract the
- // correct boundary value of
- // the face (0 for faces 0,
- // 2, and 4; 1 for faces 1, 3
- // and 5)
- const double dist = std::fabs(new_unit[face_no/2] - face_no%2);
- // compare this with
- // the empirical value
- // allowed. if it is
- // too big, flag the
- // face for isotropic
- // refinement
- const double allowed=0.25;
-
- if (dist>allowed)
- cell->flag_for_face_refinement(face_no);
- }//if flagged for anistropic refinement
- }//if (cell->face(face)->at_boundary())
- }//for all cells
- }
-
-
- /**
- * Some dimension dependent stuff for
- * mesh smoothing.
- *
- * At present, this function does nothing
- * in 1d and 2D, but makes sure no two
- * cells with a level difference greater
- * than one share one line in 3D. This
- * is a requirement needed for the
- * interpolation of hanging nodes, since
- * otherwise to steps of interpolation
- * would be necessary. This would make
- * the processes implemented in the
- * @p ConstraintMatrix class much more
- * complex, since these two steps of
- * interpolation do not commute.
- */
- template <int dim, int spacedim>
- static
- void
- prepare_refinement_dim_dependent (const Triangulation<dim,spacedim> &)
- {
- Assert (dim < 3,
- ExcMessage ("Wrong function called -- there should "
- "be a specialization."));
- }
-
-
- template <int spacedim>
- static
- void
- prepare_refinement_dim_dependent (Triangulation<3,spacedim> &triangulation)
- {
- const unsigned int dim = 3;
-
- // first clear flags on lines,
- // since we need them to determine
- // which lines will be refined
- triangulation.clear_user_flags_line();
-
- // also clear flags on hexes, since we need
- // them to mark those cells which are to be
- // coarsened
- triangulation.clear_user_flags_hex();
-
- // variable to store whether the
- // mesh was changed in the present
- // loop and in the whole process
- bool mesh_changed = false;
-
- do
- {
- mesh_changed = false;
-
- // for this following, we need to know
- // which cells are going to be
- // coarsened, if we had to make a
- // decision. the following function
- // sets these flags:
- triangulation.fix_coarsen_flags ();
-
-
- // flag those lines that are refined and
- // will not be coarsened and those that
- // will be refined
- for (typename Triangulation<dim,spacedim>::cell_iterator
- cell=triangulation.begin(); cell!=triangulation.end(); ++cell)
- if (cell->refine_flag_set())
- {
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- if (GeometryInfo<dim>::line_refinement_case(cell->refine_flag_set(), line)
- ==RefinementCase<1>::cut_x)
- // flag a line, that will be
- // refined
- cell->line(line)->set_user_flag();
- }
- else if(cell->has_children() && !cell->child(0)->coarsen_flag_set())
- {
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- if (GeometryInfo<dim>::line_refinement_case(cell->refinement_case(), line)
- ==RefinementCase<1>::cut_x)
- // flag a line, that is refined
- // and will stay so
- cell->line(line)->set_user_flag();
- }
- else if(cell->has_children() && cell->child(0)->coarsen_flag_set())
- cell->set_user_flag();
-
-
- // now check whether there are
- // cells with lines that are
- // more than once refined or
- // that will be more than once
- // refined. The first thing
- // should never be the case, in
- // the second case we flag the
- // cell for refinement
- for (typename Triangulation<dim,spacedim>::active_cell_iterator
- cell=triangulation.last_active(); cell!=triangulation.end(); --cell)
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- {
- if (cell->line(line)->has_children())
- {
- // if this line is
- // refined, its
- // children should
- // not have further
- // children
- //
- // however, if any of
- // the children is
- // flagged for
- // further
- // refinement, we
- // need to refine
- // this cell also (at
- // least, if the cell
- // is not already
- // flagged)
- bool offending_line_found = false;
-
- for (unsigned int c=0; c<2; ++c)
- {
- Assert (cell->line(line)->child(c)->has_children() == false,
- ExcInternalError());
-
- if (cell->line(line)->child(c)->user_flag_set () &&
- (GeometryInfo<dim>::line_refinement_case(cell->refine_flag_set(),
- line)
- ==RefinementCase<1>::no_refinement))
- {
- // tag this
- // cell for
- // refinement
- cell->clear_coarsen_flag ();
- // if anisotropic
- // coarsening is
- // allowed: extend the
- // refine_flag in the
- // needed direction,
- // else set refine_flag
- // (isotropic)
- if (triangulation.smooth_grid &
- Triangulation<dim,spacedim>::allow_anisotropic_smoothing)
- cell->flag_for_line_refinement(line);
- else
- cell->set_refine_flag();
-
- for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
- if (GeometryInfo<dim>::line_refinement_case(cell->refine_flag_set(), line)
- ==RefinementCase<1>::cut_x)
- // flag a line,
- // that will be
- // refined
- cell->line(l)->set_user_flag();
- // note that
- // we have
- // changed
- // the grid
- offending_line_found = true;
-
- // it may save us several
- // loop iterations if we
- // flag all lines of
- // this cell now (and not
- // at the outset of the
- // next iteration) for
- // refinement
- for (unsigned int line=0;
- line<GeometryInfo<dim>::lines_per_cell; ++line)
- if (!cell->line(line)->has_children() &&
- (GeometryInfo<dim>::line_refinement_case(cell->refine_flag_set(),
- line)
- !=RefinementCase<1>::no_refinement))
- cell->line(line)->set_user_flag();
-
- break;
- }
- }
-
- if (offending_line_found)
- {
- mesh_changed = true;
- break;
- }
- }
- }
-
-
- // there is another thing here:
- // if any of the lines will be
- // refined, then we may not
- // coarsen the present cell
- // similarly, if any of the lines
- // *is* already refined, we may
- // not coarsen the current
- // cell. however, there's a
- // catch: if the line is refined,
- // but the cell behind it is
- // going to be coarsened, then
- // the situation changes. if we
- // forget this second condition,
- // the refine_and_coarsen_3d test
- // will start to fail. note that
- // to know which cells are going
- // to be coarsened, the call for
- // fix_coarsen_flags above is
- // necessary
- for (typename Triangulation<dim,spacedim>::cell_iterator
- cell=triangulation.last(); cell!=triangulation.end(); --cell)
- {
- if (cell->user_flag_set())
- for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
- if (cell->line(line)->has_children() &&
- (cell->line(line)->child(0)->user_flag_set() ||
- cell->line(line)->child(1)->user_flag_set()))
- {
- for (unsigned int c=0; c<cell->n_children(); ++c)
- cell->child(c)->clear_coarsen_flag ();
- cell->clear_user_flag();
- for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
- if (GeometryInfo<dim>::line_refinement_case(cell->refinement_case(), l)
- ==RefinementCase<1>::cut_x)
- // flag a line, that is refined
- // and will stay so
- cell->line(l)->set_user_flag();
- mesh_changed = true;
- break;
- }
- }
- }
- while (mesh_changed == true);
- }
-
-
-
- /**
- * Helper function for
- * @p fix_coarsen_flags. Return wether
- * coarsening of this cell is allowed.
- * Coarsening can be forbidden if the
- * neighboring cells are or will be
- * refined twice along the common face.
- */
- template <int dim, int spacedim>
- static
- bool
- coarsening_allowed (const typename Triangulation<dim,spacedim>::cell_iterator& cell)
- {
- // in 1d, coarsening is
- // always allowed since we
- // don't enforce the 2:1
- // constraint there
- if (dim == 1)
- return true;
-
- const RefinementCase<dim> ref_case = cell->refinement_case();
- for (unsigned int n=0; n<GeometryInfo<dim>::faces_per_cell; ++n)
- {
- // if the cell is not refined
- // along that face, coarsening
- // will not change anything, so
- // do nothing. the same applies,
- // if the face is at the boandary
- const RefinementCase<dim-1> face_ref_case =
- GeometryInfo<dim>::face_refinement_case(cell->refinement_case(), n);
-
- const unsigned int n_subfaces
- = GeometryInfo<dim-1>::n_children(face_ref_case);
-
- if (n_subfaces == 0 || cell->at_boundary(n))
- continue;
- for (unsigned int c=0; c<n_subfaces; ++c)
- {
- const typename Triangulation<dim,spacedim>::cell_iterator
- child = cell->child(GeometryInfo<dim>::
- child_cell_on_face(ref_case,
- n,c));
-
- const typename Triangulation<dim,spacedim>::cell_iterator
- child_neighbor = child->neighbor(n);
- if (!child->neighbor_is_coarser(n))
- // in 2d, if the child's neighbor
- // is coarser, then it has no
- // children. however, in 3d it
- // might be otherwise. consider
- // for example, that our face
- // might be refined with cut_x,
- // but the neighbor is refined
- // with cut_xy at that face. then
- // the neighbor pointers of the
- // children of our cell will point
- // to the common neighbor cell,
- // not to its children. what we
- // really want to know in the
- // following is, wether the
- // neighbor cell is refined twice
- // with reference to our cell.
- // that only has to be asked, if
- // the child's neighbor is not a
- // coarser one.
- if ((child_neighbor->has_children() &&
- !child_neighbor->user_flag_set())||
- // neighbor has children, which
- // are further refined along
- // the face, otherwise
- // something went wrong in the
- // contruction of neighbor
- // pointers. then only allow
- // coarsening if this neighbor
- // will be coarsened as well
- // (user_pointer is set). the
- // same applies, if the
- // neighbors children are not
- // refined but will be after
- // refinement
- child_neighbor->refine_flag_set())
- return false;
- }
- }
- return true;
- }
- };
- }
-}
-
-
-template <int dim, int spacedim>
-const StraightBoundary<dim,spacedim>
-Triangulation<dim, spacedim>::straight_boundary = StraightBoundary<dim,spacedim>();
-
-
-
-template <int dim, int spacedim>
-const unsigned int
-Triangulation<dim, spacedim>::dimension;
-
-
-
-template <int dim, int spacedim>
-Triangulation<dim, spacedim>::
-Triangulation (const MeshSmoothing smooth_grid,
- const bool check_for_distorted_cells)
- :
- smooth_grid(smooth_grid),
- faces(NULL),
- anisotropic_refinement(false),
- check_for_distorted_cells(check_for_distorted_cells)
-{
- // set default boundary for all
- // possible components
- for (unsigned int i=0;i<255;++i)
- boundary[i] = &straight_boundary;
-}
-
-
-template <int dim, int spacedim>
-Triangulation<dim, spacedim>::
-Triangulation (const Triangulation<dim, spacedim> &)
- // do not set any subscriptors;
- // anyway, calling this constructor
- // is an error!
- :
- Subscriptor(),
- check_for_distorted_cells(check_for_distorted_cells)
-{
- Assert (false, ExcInternalError());
-}
-
-
-
-template <int dim, int spacedim>
-Triangulation<dim, spacedim>::~Triangulation ()
-{
- for (unsigned int i=0; i<levels.size(); ++i)
- delete levels[i];
- levels.clear ();
- delete faces;
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::clear ()
-{
- clear_despite_subscriptions();
-}
-
-
-
-template <int dim, int spacedim>
-void
-Triangulation<dim, spacedim>::set_mesh_smoothing(const MeshSmoothing mesh_smoothing)
-{
- Assert (n_levels() == 0, ExcTriangulationNotEmpty ());
- smooth_grid=mesh_smoothing;
-}
-
-
-
-template <int dim, int spacedim>
-void
-Triangulation<dim, spacedim>::set_boundary (const unsigned int number,
- const Boundary<dim, spacedim>& boundary_object)
-{
- Assert(number<255, ExcIndexRange(number,0,255));
-
- boundary[number] = &boundary_object;
-}
-
-
-
-template <int dim, int spacedim>
-void
-Triangulation<dim, spacedim>::set_boundary (const unsigned int number)
-{
- set_boundary (number, straight_boundary);
-}
-
-
-
-template <int dim, int spacedim>
-const Boundary<dim, spacedim> &
-Triangulation<dim, spacedim>::get_boundary (const unsigned int number) const
-{
- Assert(number<255, ExcIndexRange(number,0,255));
-
- return *(boundary[number]);
-}
-
-
-template <int dim, int spacedim>
-std::vector<unsigned char>
-Triangulation<dim, spacedim>::get_boundary_indicators () const
-{
- // in 1d, the situation is simpler:
- if (dim == 1)
- return std::vector<unsigned char> (0);;
-
- std::vector<bool> bi_exists(255, false);
- active_cell_iterator cell=begin_active();
- for (; cell!=end(); ++cell)
- for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->at_boundary(face))
- bi_exists[cell->face(face)->boundary_indicator()]=true;
-
- const unsigned int n_bi=
- std::count(bi_exists.begin(), bi_exists.end(), true);
-
- std::vector<unsigned char> boundary_indicators(n_bi);
- unsigned int bi_counter=0;
- for (unsigned int i=0; i<bi_exists.size(); ++i)
- if (bi_exists[i]==true)
- boundary_indicators[bi_counter++]=i;
-
- return boundary_indicators;
-}
-
-
-
-/*-----------------------------------------------------------------*/
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::copy_triangulation (const Triangulation<dim, spacedim> &old_tria)
-{
- Assert (vertices.size() == 0, ExcTriangulationNotEmpty());
- Assert (levels.size () == 0, ExcTriangulationNotEmpty());
- Assert (faces == NULL, ExcTriangulationNotEmpty());
-
- Assert (old_tria.levels.size() != 0, ExcInternalError());
- Assert (old_tria.vertices.size() != 0, ExcInternalError());
- Assert (dim == 1 || old_tria.faces != NULL, ExcInternalError());
-
-
- // copy normal elements
- vertices = old_tria.vertices;
- vertices_used = old_tria.vertices_used;
- anisotropic_refinement = old_tria.anisotropic_refinement;
- smooth_grid = old_tria.smooth_grid;
-
- faces = new internal::Triangulation::TriaFaces<dim>(*old_tria.faces);
-
- for (unsigned i=0;i<255;++i)
- boundary[i] = old_tria.boundary[i];
-
- levels.reserve (old_tria.levels.size());
- for (unsigned int level=0; level<old_tria.levels.size(); ++level)
- levels.push_back (new internal::Triangulation::TriaLevel<dim>(*old_tria.levels[level]));
-
- number_cache = old_tria.number_cache;
-
- // inform RefinementListeners of old_tria of
- // the copy operation
- typename std::list<RefinementListener *>::iterator ref_listener =
- old_tria.refinement_listeners.begin (),
- end_listener = old_tria.refinement_listeners.end ();
- for (; ref_listener != end_listener; ++ref_listener)
- (*ref_listener)->copy_notification (old_tria, *this);
-
- // note that we need not copy the
- // subscriptor!
-}
-
-
-
-template <int dim, int spacedim>
-void
-Triangulation<dim,spacedim>::
-create_triangulation_compatibility (const std::vector<Point<spacedim> > &v,
- const std::vector<CellData<dim> > &cells,
- const SubCellData &subcelldata)
-{
- std::vector<CellData<dim> > reordered_cells (cells);
- SubCellData reordered_subcelldata (subcelldata);
-
- // in-place reordering of data
- reorder_compatibility (reordered_cells, reordered_subcelldata);
-
- // now create triangulation from
- // reordered data
- create_triangulation(v, reordered_cells, reordered_subcelldata);
-}
-
-
-template <int dim, int spacedim>
-void
-Triangulation<dim,spacedim>::
-create_triangulation (const std::vector<Point<spacedim> > &v,
- const std::vector<CellData<dim> > &cells,
- const SubCellData &subcelldata)
-{
- Assert (vertices.size() == 0, ExcTriangulationNotEmpty());
- Assert (levels.size() == 0, ExcTriangulationNotEmpty());
- Assert (faces == NULL, ExcTriangulationNotEmpty());
- // check that no forbidden arrays
- // are used
- Assert (subcelldata.check_consistency(dim), ExcInternalError());
-
- // try to create a triangulation;
- // if this fails, we still want to
- // throw an exception but if we
- // just do so we'll get into
- // trouble because sometimes other
- // objects are already attached to
- // it:
- try
- {
- internal::Triangulation::Implementation::create_triangulation (v, cells, subcelldata, *this);
- }
- catch (...)
- {
- clear_despite_subscriptions();
- throw;
- }
-
- compute_number_cache (*this, levels.size(), number_cache);
-
- // now verify that there are indeed
- // no distorted cells. as per the
- // documentation of this class, we
- // first collect all distorted
- // cells and then throw an
- // exception if there are any
- if (check_for_distorted_cells == true)
- {
- DistortedCellList distorted_cells = collect_distorted_coarse_cells (*this);
- // throw the array (and fill the
- // various location fields) if
- // there are distorted
- // cells. otherwise, just fall off
- // the end of the function
- AssertThrow (distorted_cells.distorted_cells.size() == 0,
- distorted_cells);
- }
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::distort_random (const double factor,
- const bool keep_boundary)
-{
- internal::Triangulation::Implementation::distort_random (factor, keep_boundary, *this);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::set_all_refine_flags ()
-{
- active_cell_iterator cell = begin_active(),
- endc = end();
-
- for (; cell != endc; ++cell)
- {
- cell->clear_coarsen_flag();
- cell->set_refine_flag ();
- }
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::refine_global (const unsigned int times)
-{
- for (unsigned int i=0; i<times; ++i)
- {
- set_all_refine_flags();
- execute_coarsening_and_refinement ();
- }
-}
-
-
-
-/*-------------------- refine/coarsen flags -------------------------*/
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_refine_flags (std::vector<bool> &v) const
-{
- v.resize (dim*n_active_cells(), false);
- std::vector<bool>::iterator i = v.begin();
- active_cell_iterator cell = begin_active(),
- endc = end();
- for (; cell!=endc; ++cell)
- for (unsigned int j=0; j<dim; ++j,++i)
- if (cell->refine_flag_set() & (1<<j) )
- *i = true;
-
- Assert (i == v.end(), ExcInternalError());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_refine_flags (std::ostream &out) const
-{
- std::vector<bool> v;
- save_refine_flags (v);
- write_bool_vector (mn_tria_refine_flags_begin, v, mn_tria_refine_flags_end,
- out);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_refine_flags (std::istream &in)
-{
- std::vector<bool> v;
- read_bool_vector (mn_tria_refine_flags_begin, v, mn_tria_refine_flags_end,
- in);
- load_refine_flags (v);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_refine_flags (const std::vector<bool> &v)
-{
- AssertThrow (v.size() == dim*n_active_cells(), ExcGridReadError());
-
- active_cell_iterator cell = begin_active(),
- endc = end();
- std::vector<bool>::const_iterator i = v.begin();
- for (; cell!=endc; ++cell)
- {
- unsigned int ref_case=0;
-
- for(unsigned int j=0; j<dim; ++j, ++i)
- if (*i == true)
- ref_case+=1<<j;
- Assert(ref_case<RefinementCase<dim>::isotropic_refinement+1,
- ExcGridReadError());
- if (ref_case>0)
- cell->set_refine_flag(RefinementCase<dim>(ref_case));
- else
- cell->clear_refine_flag();
- }
-
- Assert (i == v.end(), ExcInternalError());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_coarsen_flags (std::vector<bool> &v) const
-{
- v.resize (n_active_cells(), false);
- std::vector<bool>::iterator i = v.begin();
- active_cell_iterator cell = begin_active(),
- endc = end();
- for (; cell!=endc; ++cell, ++i)
- *i = cell->coarsen_flag_set();
-
- Assert (i == v.end(), ExcInternalError());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_coarsen_flags (std::ostream &out) const
-{
- std::vector<bool> v;
- save_coarsen_flags (v);
- write_bool_vector (mn_tria_coarsen_flags_begin, v, mn_tria_coarsen_flags_end,
- out);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_coarsen_flags (std::istream &in)
-{
- std::vector<bool> v;
- read_bool_vector (mn_tria_coarsen_flags_begin, v, mn_tria_coarsen_flags_end,
- in);
- load_coarsen_flags (v);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_coarsen_flags (const std::vector<bool> &v)
-{
- Assert (v.size() == n_active_cells(), ExcGridReadError());
-
- active_cell_iterator cell = begin_active(),
- endc = end();
- std::vector<bool>::const_iterator i = v.begin();
- for (; cell!=endc; ++cell, ++i)
- if (*i == true)
- cell->set_coarsen_flag();
- else
- cell->clear_coarsen_flag();
-
- Assert (i == v.end(), ExcInternalError());
-}
-
-
-template <int dim, int spacedim>
-bool Triangulation<dim,spacedim>::get_anisotropic_refinement_flag() const
-{
- return anisotropic_refinement;
-}
-
-
-
-/*-------------------- user data/flags -------------------------*/
-
-
-namespace
-{
- // clear user data of cells
- template <int dim>
- void clear_user_data (std::vector<internal::Triangulation::TriaLevel<dim>*> &levels)
- {
- for (unsigned int level=0;level<levels.size();++level)
- levels[level]->cells.clear_user_data();
- }
-
-
- // clear user data of faces
- void clear_user_data (internal::Triangulation::TriaFaces<1> *)
- {
- // nothing to do in 1d
- }
-
-
- void clear_user_data (internal::Triangulation::TriaFaces<2> *faces)
- {
- faces->lines.clear_user_data();
- }
-
-
- void clear_user_data (internal::Triangulation::TriaFaces<3> *faces)
- {
- faces->lines.clear_user_data();
- faces->quads.clear_user_data();
- }
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim,spacedim>::clear_user_data ()
-{
- // let functions in anonymous namespace do their work
- dealii::clear_user_data (levels);
- dealii::clear_user_data (faces);
-}
-
-
-
-namespace
-{
- void clear_user_flags_line (std::vector<internal::Triangulation::TriaLevel<1>*> &levels,
- internal::Triangulation::TriaFaces<1> *)
- {
- for (unsigned int level=0; level<levels.size(); ++level)
- levels[level]->cells.clear_user_flags();
- }
-
- template <int dim>
- void clear_user_flags_line (std::vector<internal::Triangulation::TriaLevel<dim>*> &,
- internal::Triangulation::TriaFaces<dim> *faces)
- {
- faces->lines.clear_user_flags();
- }
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim,spacedim>::clear_user_flags_line ()
-{
- dealii::clear_user_flags_line (levels, faces);
-}
-
-
-
-namespace
-{
- void clear_user_flags_quad (std::vector<internal::Triangulation::TriaLevel<1>*> &,
- internal::Triangulation::TriaFaces<1> *)
- {
- // nothing to do in 1d
- }
-
- void clear_user_flags_quad (std::vector<internal::Triangulation::TriaLevel<2>*> &levels,
- internal::Triangulation::TriaFaces<2> *)
- {
- for (unsigned int level=0; level<levels.size(); ++level)
- levels[level]->cells.clear_user_flags();
- }
-
- template <int dim>
- void clear_user_flags_quad (std::vector<internal::Triangulation::TriaLevel<dim>*> &,
- internal::Triangulation::TriaFaces<dim> *faces)
- {
- faces->quads.clear_user_flags();
- }
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim,spacedim>::clear_user_flags_quad ()
-{
- dealii::clear_user_flags_quad (levels, faces);
-}
-
-
-
-namespace
-{
- void clear_user_flags_hex (std::vector<internal::Triangulation::TriaLevel<1>*> &,
- internal::Triangulation::TriaFaces<1> *)
- {
- // nothing to do in 1d
- }
-
-
- void clear_user_flags_hex (std::vector<internal::Triangulation::TriaLevel<2>*> &,
- internal::Triangulation::TriaFaces<2> *)
- {
- // nothing to do in 2d
- }
-
- void clear_user_flags_hex (std::vector<internal::Triangulation::TriaLevel<3>*> &levels,
- internal::Triangulation::TriaFaces<3> *)
- {
- for (unsigned int level=0; level<levels.size(); ++level)
- levels[level]->cells.clear_user_flags();
- }
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim,spacedim>::clear_user_flags_hex ()
-{
- dealii::clear_user_flags_hex (levels, faces);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim,spacedim>::clear_user_flags ()
-{
- clear_user_flags_line ();
- clear_user_flags_quad ();
- clear_user_flags_hex ();
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim,spacedim>::clear_user_pointers ()
-{
- clear_user_data();
-}
-
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_flags (std::ostream &out) const
-{
- save_user_flags_line (out);
-
- if (dim>=2)
- save_user_flags_quad (out);
-
- if (dim>=3)
- save_user_flags_hex (out);
-
- if (dim >= 4)
- Assert (false, ExcNotImplemented());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_flags (std::vector<bool> &v) const
-{
- // clear vector and append
- // all the stuff later on
- v.clear ();
-
- std::vector<bool> tmp;
-
- save_user_flags_line (tmp);
- v.insert (v.end(), tmp.begin(), tmp.end());
-
- if (dim >= 2)
- {
- save_user_flags_quad (tmp);
- v.insert (v.end(), tmp.begin(), tmp.end());
- }
-
- if (dim >= 3)
- {
- save_user_flags_hex (tmp);
- v.insert (v.end(), tmp.begin(), tmp.end());
- }
-
- if (dim >= 4)
- Assert (false, ExcNotImplemented());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_flags (std::istream &in)
-{
- load_user_flags_line (in);
-
- if (dim>=2)
- load_user_flags_quad (in);
-
- if (dim>=3)
- load_user_flags_hex (in);
-
- if (dim >= 4)
- Assert (false, ExcNotImplemented());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_flags (const std::vector<bool> &v)
-{
- Assert (v.size() == n_lines()+n_quads()+n_hexs(), ExcInternalError());
- std::vector<bool> tmp;
-
- // first extract the flags
- // belonging to lines
- tmp.insert (tmp.end(),
- v.begin(), v.begin()+n_lines());
- // and set the lines
- load_user_flags_line (tmp);
-
- if (dim >= 2)
- {
- tmp.clear ();
- tmp.insert (tmp.end(),
- v.begin()+n_lines(), v.begin()+n_lines()+n_quads());
- load_user_flags_quad (tmp);
- }
-
- if (dim >= 3)
- {
- tmp.clear();
- tmp.insert (tmp.end(),
- v.begin()+n_lines()+n_quads(), v.begin()+n_lines()+n_quads()+n_hexs());
- load_user_flags_hex (tmp);
- }
-
- if (dim >= 4)
- Assert (false, ExcNotImplemented());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_flags_line (std::vector<bool> &v) const
-{
- v.resize (n_lines(), false);
- std::vector<bool>::iterator i = v.begin();
- line_iterator line = begin_line(),
- endl = end_line();
- for (; line!=endl; ++line, ++i)
- *i = line->user_flag_set();
-
- Assert (i == v.end(), ExcInternalError());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_flags_line (std::ostream &out) const
-{
- std::vector<bool> v;
- save_user_flags_line (v);
- write_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
- out);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_flags_line (std::istream &in)
-{
- std::vector<bool> v;
- read_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
- in);
- load_user_flags_line (v);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_flags_line (const std::vector<bool> &v)
-{
- Assert (v.size() == n_lines(), ExcGridReadError());
-
- line_iterator line = begin_line(),
- endl = end_line();
- std::vector<bool>::const_iterator i = v.begin();
- for (; line!=endl; ++line, ++i)
- if (*i == true)
- line->set_user_flag();
- else
- line->clear_user_flag();
-
- Assert (i == v.end(), ExcInternalError());
-}
-
-
-namespace
-{
- template <typename Iterator>
- bool get_user_flag (const Iterator &i)
- {
- return i->user_flag_set();
- }
-
-
-
- template <int structdim, int dim, int spacedim>
- bool get_user_flag (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &)
- {
- Assert (false, ExcInternalError());
- return false;
- }
-
-
-
- template <typename Iterator>
- void set_user_flag (const Iterator &i)
- {
- i->set_user_flag();
- }
-
-
-
- template <int structdim, int dim, int spacedim>
- void set_user_flag (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &)
- {
- Assert (false, ExcInternalError());
- }
-
-
-
- template <typename Iterator>
- void clear_user_flag (const Iterator &i)
- {
- i->clear_user_flag();
- }
-
-
-
- template <int structdim, int dim, int spacedim>
- void clear_user_flag (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &)
- {
- Assert (false, ExcInternalError());
- }
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_flags_quad (std::vector<bool> &v) const
-{
- v.resize (n_quads(), false);
-
- if (dim >= 2)
- {
- std::vector<bool>::iterator i = v.begin();
- quad_iterator quad = begin_quad(),
- endq = end_quad();
- for (; quad!=endq; ++quad, ++i)
- *i = get_user_flag (quad);
-
- Assert (i == v.end(), ExcInternalError());
- }
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_flags_quad (std::ostream &out) const
-{
- std::vector<bool> v;
- save_user_flags_quad (v);
- write_bool_vector (mn_tria_quad_user_flags_begin, v, mn_tria_quad_user_flags_end,
- out);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_flags_quad (std::istream &in)
-{
- std::vector<bool> v;
- read_bool_vector (mn_tria_quad_user_flags_begin, v, mn_tria_quad_user_flags_end,
- in);
- load_user_flags_quad (v);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_flags_quad (const std::vector<bool> &v)
-{
- Assert (v.size() == n_quads(), ExcGridReadError());
-
- if (dim >= 2)
- {
- quad_iterator quad = begin_quad(),
- endq = end_quad();
- std::vector<bool>::const_iterator i = v.begin();
- for (; quad!=endq; ++quad, ++i)
- if (*i == true)
- set_user_flag(quad);
- else
- clear_user_flag(quad);
-
- Assert (i == v.end(), ExcInternalError());
- }
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_flags_hex (std::vector<bool> &v) const
-{
- v.resize (n_hexs(), false);
-
- if (dim >= 3)
- {
- std::vector<bool>::iterator i = v.begin();
- hex_iterator hex = begin_hex(),
- endh = end_hex();
- for (; hex!=endh; ++hex, ++i)
- *i = get_user_flag (hex);
-
- Assert (i == v.end(), ExcInternalError());
- }
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_flags_hex (std::ostream &out) const
-{
- std::vector<bool> v;
- save_user_flags_hex (v);
- write_bool_vector (mn_tria_hex_user_flags_begin, v, mn_tria_hex_user_flags_end,
- out);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_flags_hex (std::istream &in)
-{
- std::vector<bool> v;
- read_bool_vector (mn_tria_hex_user_flags_begin, v, mn_tria_hex_user_flags_end,
- in);
- load_user_flags_hex (v);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_flags_hex (const std::vector<bool> &v)
-{
- Assert (v.size() == n_hexs(), ExcGridReadError());
-
- if (dim >= 3)
- {
- hex_iterator hex = begin_hex(),
- endh = end_hex();
- std::vector<bool>::const_iterator i = v.begin();
- for (; hex!=endh; ++hex, ++i)
- if (*i == true)
- set_user_flag(hex);
- else
- clear_user_flag(hex);
-
- Assert (i == v.end(), ExcInternalError());
- }
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_indices (std::vector<unsigned int> &v) const
-{
- // clear vector and append all the
- // stuff later on
- v.clear ();
-
- std::vector<unsigned int> tmp;
-
- save_user_indices_line (tmp);
- v.insert (v.end(), tmp.begin(), tmp.end());
-
- if (dim >= 2)
- {
- save_user_indices_quad (tmp);
- v.insert (v.end(), tmp.begin(), tmp.end());
- }
-
- if (dim >= 3)
- {
- save_user_indices_hex (tmp);
- v.insert (v.end(), tmp.begin(), tmp.end());
- }
-
- if (dim >= 4)
- Assert (false, ExcNotImplemented());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_indices (const std::vector<unsigned int> &v)
-{
- Assert (v.size() == n_lines()+n_quads()+n_hexs(), ExcInternalError());
- std::vector<unsigned int> tmp;
-
- // first extract the indices
- // belonging to lines
- tmp.insert (tmp.end(),
- v.begin(), v.begin()+n_lines());
- // and set the lines
- load_user_indices_line (tmp);
-
- if (dim >= 2)
- {
- tmp.clear ();
- tmp.insert (tmp.end(),
- v.begin()+n_lines(), v.begin()+n_lines()+n_quads());
- load_user_indices_quad (tmp);
- }
-
- if (dim >= 3)
- {
- tmp.clear ();
- tmp.insert (tmp.end(),
- v.begin()+n_lines()+n_quads(), v.begin()+n_lines()+n_quads()+n_hexs());
- load_user_indices_hex (tmp);
- }
-
- if (dim >= 4)
- Assert (false, ExcNotImplemented());
-}
-
-
-
-namespace
-{
- template <typename Iterator>
- unsigned int get_user_index (const Iterator &i)
- {
- return i->user_index();
- }
-
-
-
- template <int structdim, int dim, int spacedim>
- unsigned int get_user_index (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &)
- {
- Assert (false, ExcInternalError());
- return numbers::invalid_unsigned_int;
- }
-
-
-
- template <typename Iterator>
- void set_user_index (const Iterator &i,
- const unsigned int x)
- {
- i->set_user_index(x);
- }
-
-
-
- template <int structdim, int dim, int spacedim>
- void set_user_index (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &,
- const unsigned int)
- {
- Assert (false, ExcInternalError());
- }
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_indices_line (std::vector<unsigned int> &v) const
-{
- v.resize (n_lines(), 0);
- std::vector<unsigned int>::iterator i = v.begin();
- line_iterator line = begin_line(),
- endl = end_line();
- for (; line!=endl; ++line, ++i)
- *i = line->user_index();
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_indices_line (const std::vector<unsigned int> &v)
-{
- Assert (v.size() == n_lines(), ExcGridReadError());
-
- line_iterator line = begin_line(),
- endl = end_line();
- std::vector<unsigned int>::const_iterator i = v.begin();
- for (; line!=endl; ++line, ++i)
- line->set_user_index(*i);
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_indices_quad (std::vector<unsigned int> &v) const
-{
- v.resize (n_quads(), 0);
-
- if (dim >= 2)
- {
- std::vector<unsigned int>::iterator i = v.begin();
- quad_iterator quad = begin_quad(),
- endq = end_quad();
- for (; quad!=endq; ++quad, ++i)
- *i = get_user_index(quad);
- }
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_indices_quad (const std::vector<unsigned int> &v)
-{
- Assert (v.size() == n_quads(), ExcGridReadError());
-
- if (dim >= 2)
- {
- quad_iterator quad = begin_quad(),
- endq = end_quad();
- std::vector<unsigned int>::const_iterator i = v.begin();
- for (; quad!=endq; ++quad, ++i)
- set_user_index(quad, *i);
- }
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_indices_hex (std::vector<unsigned int> &v) const
-{
- v.resize (n_hexs(), 0);
-
- if (dim >= 3)
- {
- std::vector<unsigned int>::iterator i = v.begin();
- hex_iterator hex = begin_hex(),
- endh = end_hex();
- for (; hex!=endh; ++hex, ++i)
- *i = get_user_index(hex);
- }
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_indices_hex (const std::vector<unsigned int> &v)
-{
- Assert (v.size() == n_hexs(), ExcGridReadError());
-
- if (dim >= 3)
- {
- hex_iterator hex = begin_hex(),
- endh = end_hex();
- std::vector<unsigned int>::const_iterator i = v.begin();
- for (; hex!=endh; ++hex, ++i)
- set_user_index(hex, *i);
- }
-}
-
-
-
-//---------------- user pointers ----------------------------------------//
-
-
-namespace
-{
- template <typename Iterator>
- void * get_user_pointer (const Iterator &i)
- {
- return i->user_pointer();
- }
-
-
-
- template <int structdim, int dim, int spacedim>
- void * get_user_pointer (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &)
- {
- Assert (false, ExcInternalError());
- return 0;
- }
-
-
-
- template <typename Iterator>
- void set_user_pointer (const Iterator &i,
- void * x)
- {
- i->set_user_pointer(x);
- }
-
-
-
- template <int structdim, int dim, int spacedim>
- void set_user_pointer (const TriaIterator<InvalidAccessor<structdim,dim,spacedim> > &,
- void *)
- {
- Assert (false, ExcInternalError());
- }
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_pointers (std::vector<void *> &v) const
-{
- // clear vector and append all the
- // stuff later on
- v.clear ();
-
- std::vector<void *> tmp;
-
- save_user_pointers_line (tmp);
- v.insert (v.end(), tmp.begin(), tmp.end());
-
- if (dim >= 2)
- {
- save_user_pointers_quad (tmp);
- v.insert (v.end(), tmp.begin(), tmp.end());
- }
-
- if (dim >= 3)
- {
- save_user_pointers_hex (tmp);
- v.insert (v.end(), tmp.begin(), tmp.end());
- }
-
- if (dim >= 4)
- Assert (false, ExcNotImplemented());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_pointers (const std::vector<void *> &v)
-{
- Assert (v.size() == n_lines()+n_quads()+n_hexs(), ExcInternalError());
- std::vector<void *> tmp;
-
- // first extract the pointers
- // belonging to lines
- tmp.insert (tmp.end(),
- v.begin(), v.begin()+n_lines());
- // and set the lines
- load_user_pointers_line (tmp);
-
- if (dim >= 2)
- {
- tmp.clear ();
- tmp.insert (tmp.end(),
- v.begin()+n_lines(), v.begin()+n_lines()+n_quads());
- load_user_pointers_quad (tmp);
- }
-
- if (dim >= 3)
- {
- tmp.clear ();
- tmp.insert (tmp.end(),
- v.begin()+n_lines()+n_quads(), v.begin()+n_lines()+n_quads()+n_hexs());
- load_user_pointers_hex (tmp);
- }
-
- if (dim >= 4)
- Assert (false, ExcNotImplemented());
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_pointers_line (std::vector<void *> &v) const
-{
- v.resize (n_lines(), 0);
- std::vector<void *>::iterator i = v.begin();
- line_iterator line = begin_line(),
- endl = end_line();
- for (; line!=endl; ++line, ++i)
- *i = line->user_pointer();
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_pointers_line (const std::vector<void *> &v)
-{
- Assert (v.size() == n_lines(), ExcGridReadError());
-
- line_iterator line = begin_line(),
- endl = end_line();
- std::vector<void *>::const_iterator i = v.begin();
- for (; line!=endl; ++line, ++i)
- line->set_user_pointer(*i);
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_pointers_quad (std::vector<void *> &v) const
-{
- v.resize (n_quads(), 0);
-
- if (dim >= 2)
- {
- std::vector<void *>::iterator i = v.begin();
- quad_iterator quad = begin_quad(),
- endq = end_quad();
- for (; quad!=endq; ++quad, ++i)
- *i = get_user_pointer(quad);
- }
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_pointers_quad (const std::vector<void *> &v)
-{
- Assert (v.size() == n_quads(), ExcGridReadError());
-
- if (dim >= 2)
- {
- quad_iterator quad = begin_quad(),
- endq = end_quad();
- std::vector<void *>::const_iterator i = v.begin();
- for (; quad!=endq; ++quad, ++i)
- set_user_pointer(quad, *i);
- }
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::save_user_pointers_hex (std::vector<void *> &v) const
-{
- v.resize (n_hexs(), 0);
-
- if (dim >= 3)
- {
- std::vector<void *>::iterator i = v.begin();
- hex_iterator hex = begin_hex(),
- endh = end_hex();
- for (; hex!=endh; ++hex, ++i)
- *i = get_user_pointer(hex);
- }
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::load_user_pointers_hex (const std::vector<void *> &v)
-{
- Assert (v.size() == n_hexs(), ExcGridReadError());
-
- if (dim >= 3)
- {
- hex_iterator hex = begin_hex(),
- endh = end_hex();
- std::vector<void *>::const_iterator i = v.begin();
- for (; hex!=endh; ++hex, ++i)
- set_user_pointer(hex, *i);
- }
-}
-
-
-
-/*------------------------ Cell iterator functions ------------------------*/
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_cell_iterator
-Triangulation<dim,spacedim>::begin_raw (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- return begin_raw_line (level);
- case 2:
- return begin_raw_quad (level);
- case 3:
- return begin_raw_hex (level);
- default:
- Assert (false, ExcNotImplemented());
- return raw_cell_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::cell_iterator
-Triangulation<dim,spacedim>::begin (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- return begin_line (level);
- case 2:
- return begin_quad (level);
- case 3:
- return begin_hex (level);
- default:
- Assert (false, ExcImpossibleInDim(dim));
- return cell_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::active_cell_iterator
-Triangulation<dim,spacedim>::begin_active (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- return begin_active_line (level);
- case 2:
- return begin_active_quad (level);
- case 3:
- return begin_active_hex (level);
- default:
- Assert (false, ExcNotImplemented());
- return active_cell_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_cell_iterator
-Triangulation<dim,spacedim>::last_raw () const
-{
- switch (dim)
- {
- case 1:
- return last_raw_line ();
- case 2:
- return last_raw_quad ();
- case 3:
- return last_raw_hex ();
- default:
- Assert (false, ExcNotImplemented());
- return raw_cell_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_cell_iterator
-Triangulation<dim,spacedim>::last_raw (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- return last_raw_line (level);
- case 2:
- return last_raw_quad (level);
- case 3:
- return last_raw_hex (level);
- default:
- Assert (false, ExcNotImplemented());
- return raw_cell_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::cell_iterator
-Triangulation<dim,spacedim>::last () const
-{
- switch (dim)
- {
- case 1:
- return last_line ();
- case 2:
- return last_quad ();
- case 3:
- return last_hex ();
- default:
- Assert (false, ExcNotImplemented());
- return cell_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::cell_iterator
-Triangulation<dim,spacedim>::last (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- return last_line (level);
- case 2:
- return last_quad (level);
- case 3:
- return last_hex (level);
- default:
- Assert (false, ExcNotImplemented());
- return cell_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::active_cell_iterator
-Triangulation<dim,spacedim>::last_active () const
-{
- switch (dim)
- {
- case 1:
- return last_active_line ();
- case 2:
- return last_active_quad ();
- case 3:
- return last_active_hex ();
- default:
- Assert (false, ExcNotImplemented());
- return active_cell_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::active_cell_iterator
-Triangulation<dim,spacedim>::last_active (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- return last_active_line (level);
- case 2:
- return last_active_quad (level);
- case 3:
- return last_active_hex (level);
- default:
- Assert (false, ExcNotImplemented());
- return active_cell_iterator();
- }
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_cell_iterator
-Triangulation<dim,spacedim>::end () const
-{
- switch (dim)
- {
- case 1:
- return end_line();
- case 2:
- return end_quad();
- case 3:
- return end_hex();
- default:
- Assert (false, ExcImpossibleInDim(dim));
- return raw_cell_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_cell_iterator
-Triangulation<dim, spacedim>::end_raw (const unsigned int level) const
-{
- return (level == levels.size()-1 ?
- end() :
- begin_raw (level+1));
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::cell_iterator
-Triangulation<dim, spacedim>::end (const unsigned int level) const
-{
- return (level == levels.size()-1 ?
- cell_iterator(end()) :
- begin (level+1));
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_cell_iterator
-Triangulation<dim, spacedim>::end_active (const unsigned int level) const
-{
- return (level == levels.size()-1 ?
- active_cell_iterator(end()) :
- begin_active (level+1));
-}
-
-
-/*------------------------ Face iterator functions ------------------------*/
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_face_iterator
-Triangulation<dim,spacedim>::begin_raw_face () const
-{
- switch (dim)
- {
- case 1:
- Assert (false, ExcImpossibleInDim(1));
- return raw_face_iterator();
- case 2:
- return begin_raw_line ();
- case 3:
- return begin_raw_quad ();
- default:
- Assert (false, ExcNotImplemented());
- return raw_face_iterator ();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::face_iterator
-Triangulation<dim,spacedim>::begin_face () const
-{
- switch (dim)
- {
- case 1:
- Assert (false, ExcImpossibleInDim(1));
- return raw_face_iterator();
- case 2:
- return begin_line ();
- case 3:
- return begin_quad ();
- default:
- Assert (false, ExcNotImplemented());
- return face_iterator ();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::active_face_iterator
-Triangulation<dim,spacedim>::begin_active_face () const
-{
- switch (dim)
- {
- case 1:
- Assert (false, ExcImpossibleInDim(1));
- return raw_face_iterator();
- case 2:
- return begin_active_line ();
- case 3:
- return begin_active_quad ();
- default:
- Assert (false, ExcNotImplemented());
- return active_face_iterator ();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_face_iterator
-Triangulation<dim, spacedim>::end_raw_face () const
-{
- return end_face();
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_face_iterator
-Triangulation<dim,spacedim>::end_face () const
-{
- switch (dim)
- {
- case 1:
- Assert (false, ExcImpossibleInDim(1));
- return raw_face_iterator();
- case 2:
- return end_line ();
- case 3:
- return end_quad ();
- default:
- Assert (false, ExcNotImplemented());
- return raw_face_iterator ();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_face_iterator
-Triangulation<dim, spacedim>::end_active_face () const
-{
- return active_face_iterator(end_face());
-}
-
-
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_face_iterator
-Triangulation<dim,spacedim>::last_raw_face () const
-{
- switch (dim)
- {
- case 1:
- Assert (false, ExcImpossibleInDim(1));
- return raw_face_iterator();
- case 2:
- return last_raw_line ();
- case 3:
- return last_raw_quad ();
- default:
- Assert (false, ExcNotImplemented());
- return raw_face_iterator ();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::face_iterator
-Triangulation<dim,spacedim>::last_face () const
-{
- switch (dim)
- {
- case 1:
- Assert (false, ExcImpossibleInDim(1));
- return raw_face_iterator();
- case 2:
- return last_line ();
- case 3:
- return last_quad ();
- default:
- Assert (false, ExcNotImplemented());
- return raw_face_iterator ();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::active_face_iterator
-Triangulation<dim,spacedim>::last_active_face () const
-{
- switch (dim)
- {
- case 1:
- Assert (false, ExcImpossibleInDim(1));
- return raw_face_iterator();
- case 2:
- return last_active_line ();
- case 3:
- return last_active_quad ();
- default:
- Assert (false, ExcNotImplemented());
- return raw_face_iterator ();
- }
-}
-
-
-/*------------------------ Line iterator functions ------------------------*/
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_line_iterator
-Triangulation<dim, spacedim>::begin_raw_line (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- Assert (level<levels.size(), ExcInvalidLevel(level));
-
- if (levels[level]->cells.cells.size() == 0)
- return end_line ();
-
- return raw_line_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
- level,
- 0);
-
- default:
- Assert (level == 0, ExcFacesHaveNoLevel());
- return raw_line_iterator (const_cast<Triangulation<dim, spacedim>*>(this),
- 0,
- 0);
- }
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::line_iterator
-Triangulation<dim, spacedim>::begin_line (const unsigned int level) const
-{
- // level is checked in begin_raw
- raw_line_iterator ri = begin_raw_line (level);
- if (ri.state() != IteratorState::valid)
- return ri;
- while (ri->used() == false)
- if ((++ri).state() != IteratorState::valid)
- return ri;
- return ri;
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_line_iterator
-Triangulation<dim, spacedim>::begin_active_line (const unsigned int level) const
-{
- // level is checked in begin_raw
- line_iterator i = begin_line (level);
- if (i.state() != IteratorState::valid)
- return i;
- while (i->has_children())
- if ((++i).state() != IteratorState::valid)
- return i;
- return i;
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_line_iterator
-Triangulation<dim, spacedim>::end_line () const
-{
- return raw_line_iterator (const_cast<Triangulation<dim, spacedim>*>(this),
- -1,
- -1);
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_line_iterator
-Triangulation<dim, spacedim>::last_raw_line (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- Assert (level<levels.size(), ExcInvalidLevel(level));
- Assert (levels[level]->cells.cells.size() != 0,
- ExcEmptyLevel (level));
-
- return raw_line_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
- level,
- levels[level]->cells.cells.size()-1);
-
- default:
- Assert (level == 0, ExcFacesHaveNoLevel());
- return raw_line_iterator (const_cast<Triangulation<dim, spacedim>*>(this),
- 0,
- n_raw_lines()-1);
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_line_iterator
-Triangulation<dim, spacedim>::last_raw_line () const
-{
- if (dim == 1)
- return last_raw_line (levels.size()-1);
- else
- return last_raw_line (0);
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::line_iterator
-Triangulation<dim, spacedim>::last_line (const unsigned int level) const
-{
- // level is checked in last_raw
- raw_line_iterator ri = last_raw_line(level);
- if (ri->used()==true)
- return ri;
- while ((--ri).state() == IteratorState::valid)
- if (ri->used()==true)
- return ri;
- return ri;
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::line_iterator
-Triangulation<dim, spacedim>::last_line () const
-{
- if (dim == 1)
- return last_line (levels.size()-1);
- else
- return last_line (0);
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_line_iterator
-Triangulation<dim, spacedim>::last_active_line (const unsigned int level) const
-{
- // level is checked in last_raw
- line_iterator i = last_line(level);
- if (i->has_children()==false)
- return i;
- while ((--i).state() == IteratorState::valid)
- if (i->has_children()==false)
- return i;
- return i;
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_line_iterator
-Triangulation<dim, spacedim>::last_active_line () const
-{
- if (dim == 1)
- return last_active_line (levels.size()-1);
- else
- return last_active_line (0);
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_line_iterator
-Triangulation<dim, spacedim>::end_raw_line (const unsigned int level) const
-{
- Assert (dim == 1 || level == 0, ExcFacesHaveNoLevel());
- if (dim == 1)
- return (level == levels.size()-1 ?
- end_line() :
- begin_raw_line (level+1));
- else
- return end_line();
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::line_iterator
-Triangulation<dim, spacedim>::end_line (const unsigned int level) const
-{
- Assert (dim == 1 || level == 0, ExcFacesHaveNoLevel());
- if (dim == 1)
- return (level == levels.size()-1 ?
- line_iterator(end_line()) :
- begin_line (level+1));
- else
- return line_iterator(end_line());
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_line_iterator
-Triangulation<dim, spacedim>::end_active_line (const unsigned int level) const
-{
- Assert (dim == 1 || level == 0, ExcFacesHaveNoLevel());
- if (dim == 1)
- return (level == levels.size()-1 ?
- active_line_iterator(end_line()) :
- begin_active_line (level+1));
- else
- return active_line_iterator(end_line());
-}
-
-
-
-/*------------------------ Quad iterator functions ------------------------*/
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_quad_iterator
-Triangulation<dim,spacedim>::begin_raw_quad (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- Assert (false, ExcImpossibleInDim(1));
- return raw_hex_iterator();
- case 2:
- {
- Assert (level<levels.size(), ExcInvalidLevel(level));
-
- if (levels[level]->cells.cells.size() == 0)
- return end_quad();
-
- return raw_quad_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
- level,
- 0);
- }
-
- case 3:
- {
- Assert (level == 0, ExcFacesHaveNoLevel());
-
- return raw_quad_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
- 0,
- 0);
- }
-
-
- default:
- Assert (false, ExcNotImplemented());
- return raw_hex_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::quad_iterator
-Triangulation<dim,spacedim>::begin_quad (const unsigned int level) const
-{
- // level is checked in begin_raw
- raw_quad_iterator ri = begin_raw_quad (level);
- if (ri.state() != IteratorState::valid)
- return ri;
- while (ri->used() == false)
- if ((++ri).state() != IteratorState::valid)
- return ri;
- return ri;
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::active_quad_iterator
-Triangulation<dim,spacedim>::begin_active_quad (const unsigned int level) const
-{
- // level is checked in begin_raw
- quad_iterator i = begin_quad (level);
- if (i.state() != IteratorState::valid)
- return i;
- while (i->has_children())
- if ((++i).state() != IteratorState::valid)
- return i;
- return i;
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_quad_iterator
-Triangulation<dim, spacedim>::end_raw_quad (const unsigned int level) const
-{
- Assert (dim == 2 || level == 0, ExcFacesHaveNoLevel());
- if (dim == 2)
- return (level == levels.size()-1 ?
- end_quad() :
- begin_raw_quad (level+1));
- else
- return end_quad();
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::quad_iterator
-Triangulation<dim, spacedim>::end_quad (const unsigned int level) const
-{
- Assert (dim == 2 || level == 0, ExcFacesHaveNoLevel());
- if (dim == 2)
- return (level == levels.size()-1 ?
- quad_iterator(end_quad()) :
- begin_quad (level+1));
- else
- return quad_iterator(end_quad());
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_quad_iterator
-Triangulation<dim, spacedim>::end_active_quad (const unsigned int level) const
-{
- Assert(dim == 2 || level == 0, ExcFacesHaveNoLevel());
- if (dim == 2)
- return (level == levels.size()-1 ?
- active_quad_iterator(end_quad()) :
- begin_active_quad (level+1));
- else
- return active_quad_iterator(end_quad());
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_quad_iterator
-Triangulation<dim,spacedim>::end_quad () const
-{
- return raw_quad_iterator (const_cast<Triangulation<dim, spacedim>*>(this),
- -1,
- -1);
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_quad_iterator
-Triangulation<dim,spacedim>::last_raw_quad (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- Assert (false, ExcImpossibleInDim(1));
- return raw_quad_iterator();
- case 2:
- Assert (level<levels.size(),
- ExcInvalidLevel(level));
- Assert (levels[level]->cells.cells.size() != 0,
- ExcEmptyLevel (level));
- return raw_quad_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
- level,
- levels[level]->cells.cells.size()-1);
- case 3:
- Assert (level == 0, ExcFacesHaveNoLevel());
- return raw_quad_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
- 0,
- n_raw_quads()-1);
- default:
- Assert (false, ExcNotImplemented());
- return raw_quad_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_quad_iterator
-Triangulation<dim,spacedim>::last_raw_quad () const
-{
- if (dim == 2)
- return last_raw_quad (levels.size()-1);
- else
- return last_raw_quad (0);
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::quad_iterator
-Triangulation<dim,spacedim>::last_quad (const unsigned int level) const
-{
- // level is checked in last_raw
- raw_quad_iterator ri = last_raw_quad(level);
- if (ri->used()==true)
- return ri;
- while ((--ri).state() == IteratorState::valid)
- if (ri->used()==true)
- return ri;
- return ri;
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::quad_iterator
-Triangulation<dim,spacedim>::last_quad () const
-{
- if (dim == 2)
- return last_quad (levels.size()-1);
- else
- return last_quad (0);
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::active_quad_iterator
-Triangulation<dim,spacedim>::last_active_quad (const unsigned int level) const
-{
- // level is checked in last_raw
- quad_iterator i = last_quad(level);
- if (i->has_children()==false)
- return i;
- while ((--i).state() == IteratorState::valid)
- if (i->has_children()==false)
- return i;
- return i;
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::active_quad_iterator
-Triangulation<dim,spacedim>::last_active_quad () const
-{
- if (dim == 2)
- return last_active_quad (levels.size()-1);
- else
- return last_active_quad (0);
-}
-
-
-/*------------------------ Hex iterator functions ------------------------*/
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::raw_hex_iterator
-Triangulation<dim,spacedim>::begin_raw_hex (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- case 2:
- Assert (false, ExcImpossibleInDim(1));
- return raw_hex_iterator();
- case 3:
- {
- Assert (level<levels.size(), ExcInvalidLevel(level));
-
- if (levels[level]->cells.cells.size() == 0)
- return end_hex();
-
- return raw_hex_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
- level,
- 0);
- }
-
- default:
- Assert (false, ExcNotImplemented());
- return raw_hex_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::hex_iterator
-Triangulation<dim,spacedim>::begin_hex (const unsigned int level) const
-{
- // level is checked in begin_raw
- raw_hex_iterator ri = begin_raw_hex (level);
- if (ri.state() != IteratorState::valid)
- return ri;
- while (ri->used() == false)
- if ((++ri).state() != IteratorState::valid)
- return ri;
- return ri;
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_hex_iterator
-Triangulation<dim, spacedim>::begin_active_hex (const unsigned int level) const
-{
- // level is checked in begin_raw
- hex_iterator i = begin_hex (level);
- if (i.state() != IteratorState::valid)
- return i;
- while (i->has_children())
- if ((++i).state() != IteratorState::valid)
- return i;
- return i;
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_hex_iterator
-Triangulation<dim, spacedim>::end_raw_hex (const unsigned int level) const
-{
- return (level == levels.size()-1 ?
- end_hex() :
- begin_raw_hex (level+1));
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::hex_iterator
-Triangulation<dim, spacedim>::end_hex (const unsigned int level) const
-{
- return (level == levels.size()-1 ?
- hex_iterator(end_hex()) :
- begin_hex (level+1));
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_hex_iterator
-Triangulation<dim, spacedim>::end_active_hex (const unsigned int level) const
-{
- return (level == levels.size()-1 ?
- active_hex_iterator(end_hex()) :
- begin_active_hex (level+1));
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_hex_iterator
-Triangulation<dim, spacedim>::end_hex () const
-{
- return raw_hex_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
- -1,
- -1);
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_hex_iterator
-Triangulation<dim, spacedim>::last_raw_hex (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- case 2:
- Assert (false, ExcImpossibleInDim(dim));
- return raw_hex_iterator();
-
- case 3:
- Assert (level<levels.size(),
- ExcInvalidLevel(level));
- Assert (levels[level]->cells.cells.size() != 0,
- ExcEmptyLevel (level));
-
- return raw_hex_iterator (const_cast<Triangulation<dim,spacedim>*>(this),
- level,
- levels[level]->cells.cells.size()-1);
- default:
- Assert (false, ExcNotImplemented());
- return raw_hex_iterator();
- }
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::raw_hex_iterator
-Triangulation<dim, spacedim>::last_raw_hex () const
-{
- return last_raw_hex (levels.size()-1);
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::hex_iterator
-Triangulation<dim, spacedim>::last_hex (const unsigned int level) const
-{
- // level is checked in last_raw
- raw_hex_iterator ri = last_raw_hex(level);
- if (ri->used()==true)
- return ri;
- while ((--ri).state() == IteratorState::valid)
- if (ri->used()==true)
- return ri;
- return ri;
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::hex_iterator
-Triangulation<dim, spacedim>::last_hex () const
-{
- return last_hex (levels.size()-1);
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_hex_iterator
-Triangulation<dim, spacedim>::last_active_hex (const unsigned int level) const
-{
- // level is checked in last_raw
- hex_iterator i = last_hex(level);
- if (i->has_children()==false)
- return i;
- while ((--i).state() == IteratorState::valid)
- if (i->has_children()==false)
- return i;
- return i;
-}
-
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim, spacedim>::active_hex_iterator
-Triangulation<dim, spacedim>::last_active_hex () const
-{
- return last_active_hex (levels.size()-1);
-}
-
-
-
-// -------------------------------- number of cells etc ---------------
-
-
-namespace internal
-{
- namespace Triangulation
- {
- inline
- unsigned int
- n_cells (const internal::Triangulation::NumberCache<1> &c)
- {
- return c.n_lines;
- }
-
-
- inline
- unsigned int
- n_active_cells (const internal::Triangulation::NumberCache<1> &c)
- {
- return c.n_active_lines;
- }
-
-
- inline
- unsigned int
- n_cells (const internal::Triangulation::NumberCache<2> &c)
- {
- return c.n_quads;
- }
-
-
- inline
- unsigned int
- n_active_cells (const internal::Triangulation::NumberCache<2> &c)
- {
- return c.n_active_quads;
- }
-
-
- inline
- unsigned int
- n_cells (const internal::Triangulation::NumberCache<3> &c)
- {
- return c.n_hexes;
- }
-
-
- inline
- unsigned int
- n_active_cells (const internal::Triangulation::NumberCache<3> &c)
- {
- return c.n_active_hexes;
- }
- }
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_cells () const
-{
- return internal::Triangulation::n_cells (number_cache);
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_cells () const
-{
- return internal::Triangulation::n_active_cells (number_cache);
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_faces () const
-{
- switch (dim)
- {
- case 1:
- return 0;
- case 2:
- return n_lines();
- case 3:
- return n_quads();
- default:
- Assert (false, ExcNotImplemented());
- }
- return 0;
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_raw_faces () const
-{
- switch (dim)
- {
- case 2:
- return n_raw_lines();
- case 3:
- return n_raw_quads();
- default:
- Assert (false, ExcNotImplemented());
- }
- return 0;
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_faces () const
-{
- switch (dim)
- {
- case 1:
- return 0;
- case 2:
- return n_active_lines();
- case 3:
- return n_active_quads();
- default:
- Assert (false, ExcNotImplemented());
- }
- return 0;
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_raw_cells (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- return n_raw_lines(level);
- case 2:
- return n_raw_quads(level);
- case 3:
- return n_raw_hexs(level);
- default:
- Assert (false, ExcNotImplemented());
- }
- return 0;
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_cells (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- return n_lines(level);
- case 2:
- return n_quads(level);
- case 3:
- return n_hexs(level);
- default:
- Assert (false, ExcNotImplemented());
- }
- return 0;
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_cells (const unsigned int level) const
-{
- switch (dim)
- {
- case 1:
- return n_active_lines(level);
- case 2:
- return n_active_quads(level);
- case 3:
- return n_active_hexs(level);
- default:
- Assert (false, ExcNotImplemented());
- }
- return 0;
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_lines () const
-{
- return number_cache.n_lines;
-}
-
-
-#if deal_II_dimension == 1
-
-
-
-template <>
-unsigned int Triangulation<1,1>::n_raw_lines (const unsigned int level) const
-{
- Assert(level < n_levels(), ExcIndexRange(level,0,n_levels()));
- return levels[level]->cells.cells.size();
-}
-
-
-template <>
-unsigned int Triangulation<1,1>::n_raw_lines () const
-{
- Assert(false, ExcNotImplemented());
- return 0;
-}
-
-
-
-template <>
-unsigned int Triangulation<1,2>::n_raw_lines (const unsigned int level) const
-{
- Assert(level < n_levels(), ExcIndexRange(level,0,n_levels()));
- return levels[level]->cells.cells.size();
-}
-
-
-template <>
-unsigned int Triangulation<1,2>::n_raw_lines () const
-{
- Assert(false, ExcNotImplemented());
- return 0;
-}
-
-#endif
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_raw_lines (const unsigned int) const
-{
- Assert(false, ExcFacesHaveNoLevel());
- return 0;
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_raw_lines () const
-{
- return faces->lines.cells.size();
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_lines (const unsigned int level) const
-{
- Assert (level < number_cache.n_lines_level.size(),
- ExcIndexRange (level, 0, number_cache.n_lines_level.size()));
- Assert (dim == 1, ExcFacesHaveNoLevel());
- return number_cache.n_lines_level[level];
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_lines () const
-{
- return number_cache.n_active_lines;
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_lines (const unsigned int level) const
-{
- Assert (level < number_cache.n_lines_level.size(),
- ExcIndexRange (level, 0, number_cache.n_lines_level.size()));
- Assert (dim == 1, ExcFacesHaveNoLevel());
-
- return number_cache.n_active_lines_level[level];
-}
-
-
-#if deal_II_dimension == 1
-
-template <>
-unsigned int Triangulation<1,1>::n_quads () const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,1>::n_quads (const unsigned int) const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,1>::n_raw_quads (const unsigned int) const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,1>::n_raw_hexs (const unsigned int) const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,1>::n_active_quads (const unsigned int) const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,1>::n_active_quads () const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,2>::n_quads () const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,2>::n_quads (const unsigned int) const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,2>::n_raw_quads (const unsigned int) const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,2>::n_raw_hexs (const unsigned int) const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,2>::n_active_quads (const unsigned int) const
-{
- return 0;
-}
-
-
-template <>
-unsigned int Triangulation<1,2>::n_active_quads () const
-{
- return 0;
-}
-
-
-#endif
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_quads () const
-{
- return number_cache.n_quads;
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_quads (const unsigned int level) const
-{
- Assert (dim == 2, ExcFacesHaveNoLevel());
- Assert (level < number_cache.n_quads_level.size(),
- ExcIndexRange (level, 0, number_cache.n_quads_level.size()));
- return number_cache.n_quads_level[level];
-}
-
-#if deal_II_dimension == 2
-
-
-template <>
-unsigned int Triangulation<2,2>::n_raw_quads (const unsigned int level) const
-{
- Assert(level < n_levels(), ExcIndexRange(level,0,n_levels()));
- return levels[level]->cells.cells.size();
-}
-
-
-
-template <>
-unsigned int Triangulation<2,3>::n_raw_quads (const unsigned int level) const
-{
- Assert(level < n_levels(), ExcIndexRange(level,0,n_levels()));
- return levels[level]->cells.cells.size();
-}
-
-#endif
-
-#if deal_II_dimension == 3
-
-template <>
-unsigned int Triangulation<3,3>::n_raw_quads (const unsigned int) const
-{
- Assert(false, ExcFacesHaveNoLevel());
- return 0;
-}
-
-#endif
-
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_raw_quads () const
-{
- Assert (false, ExcNotImplemented());
- return 0;
-}
-
-
-#if deal_II_dimension == 3
-
-template <>
-unsigned int Triangulation<3,3>::n_raw_quads () const
-{
- return faces->quads.cells.size();
-}
-
-#endif
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_quads () const
-{
- return number_cache.n_active_quads;
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_quads (const unsigned int level) const
-{
- Assert (level < number_cache.n_quads_level.size(),
- ExcIndexRange (level, 0, number_cache.n_quads_level.size()));
- Assert (dim == 2, ExcFacesHaveNoLevel());
-
- return number_cache.n_active_quads_level[level];
-}
-
-
-#if deal_II_dimension < 3
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_hexs () const
-{
- return 0;
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_hexs (const unsigned int) const
-{
- return 0;
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_raw_hexs (const unsigned int) const
-{
- return 0;
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_hexs () const
-{
- return 0;
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_hexs (const unsigned int) const
-{
- return 0;
-}
-
-
-#else
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_hexs () const
-{
- return number_cache.n_hexes;
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_hexs (const unsigned int level) const
-{
- Assert (level < number_cache.n_hexes_level.size(),
- ExcIndexRange (level, 0, number_cache.n_hexes_level.size()));
-
- return number_cache.n_hexes_level[level];
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_raw_hexs (const unsigned int level) const
-{
- Assert(level < n_levels(), ExcIndexRange(level,0,n_levels()));
- return levels[level]->cells.cells.size();
-}
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_hexs () const
-{
- return number_cache.n_active_hexes;
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::n_active_hexs (const unsigned int level) const
-{
- Assert (level < number_cache.n_hexes_level.size(),
- ExcIndexRange (level, 0, number_cache.n_hexes_level.size()));
-
- return number_cache.n_active_hexes_level[level];
-}
-
-
-#endif
-
-
-template <int dim, int spacedim>
-unsigned int
-Triangulation<dim, spacedim>::n_used_vertices () const
-{
- return std::count_if (vertices_used.begin(), vertices_used.end(),
- std::bind2nd (std::equal_to<bool>(), true));
-}
-
-
-
-template <int dim, int spacedim>
-const std::vector<bool> &
-Triangulation<dim, spacedim>::get_used_vertices () const
-{
- return vertices_used;
-}
-
-
-#if deal_II_dimension == 1
-
-
-template <>
-unsigned int Triangulation<1,1>::max_adjacent_cells () const
-{
- return 2;
-}
-
-#endif
-
-
-template <int dim, int spacedim>
-unsigned int Triangulation<dim, spacedim>::max_adjacent_cells () const
-{
- cell_iterator cell = begin(0),
- endc = (n_levels() > 1 ? begin(1) : cell_iterator(end()));
- // store the largest index of the
- // vertices used on level 0
- unsigned int max_vertex_index = 0;
- for (; cell!=endc; ++cell)
- for (unsigned vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
- if (cell->vertex_index(vertex) > max_vertex_index)
- max_vertex_index = cell->vertex_index(vertex);
-
- // store the number of times a cell
- // touches a vertex. An unsigned
- // int should suffice, even for
- // larger dimensions
- std::vector<unsigned short int> usage_count (max_vertex_index+1, 0);
- // touch a vertex's usage count
- // everytime we find an adjacent
- // element
- for (cell=begin(); cell!=endc; ++cell)
- for (unsigned vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
- ++usage_count[cell->vertex_index(vertex)];
-
- return std::max (GeometryInfo<dim>::vertices_per_cell,
- static_cast<unsigned int>(*std::max_element (usage_count.begin(),
- usage_count.end())));
-}
-
-
-
-template <int dim, int spacedim>
-void
-Triangulation<dim, spacedim>::execute_coarsening_and_refinement ()
-{
- prepare_coarsening_and_refinement ();
-
- // verify a case with which we have had
- // some difficulty in the past (see the
- // deal.II/coarsening_* tests)
- if (smooth_grid & limit_level_difference_at_vertices)
- Assert (satisfies_level1_at_vertex_rule (*this) == true,
- ExcInternalError());
-
- // Inform RefinementListeners
- // about beginning of refinement.
- typename std::list<RefinementListener *>::iterator ref_listener =
- refinement_listeners.begin (),
- end_listener = refinement_listeners.end ();
- for (; ref_listener != end_listener; ++ref_listener)
- (*ref_listener)->pre_refinement_notification (*this);
-
- execute_coarsening();
-
- const DistortedCellList
- cells_with_distorted_children = execute_refinement();
-
- // verify a case with which we have had
- // some difficulty in the past (see the
- // deal.II/coarsening_* tests)
- if (smooth_grid & limit_level_difference_at_vertices)
- Assert (satisfies_level1_at_vertex_rule (*this) == true,
- ExcInternalError());
-
-#if deal_II_dimension > 1
- // finally build up neighbor connectivity
- // information
- update_neighbors(*this);
-#endif
-
- // Inform RefinementListeners
- // about end of refinement.
- for (ref_listener = refinement_listeners.begin ();
- ref_listener != end_listener; ++ref_listener)
- (*ref_listener)->post_refinement_notification (*this);
-
- AssertThrow (cells_with_distorted_children.distorted_cells.size() == 0,
- cells_with_distorted_children);
-}
-
-
-template<int dim, int spacedim>
-void
-Triangulation<dim, spacedim>::clear_despite_subscriptions()
-{
- // This is the former function
- // clear without the assertion in
- // the beginning.
- for (unsigned int i=0; i<levels.size(); ++i)
- delete levels[i];
- levels.clear ();
-
- delete faces;
- faces = NULL;
-
- vertices.clear ();
- vertices_used.clear ();
-
- for (unsigned int i=0; i<255; ++i)
- boundary[i] = &straight_boundary;
-
- number_cache = internal::Triangulation::NumberCache<dim>();
-}
-
-
-template <int dim, int spacedim>
-typename Triangulation<dim,spacedim>::DistortedCellList
-Triangulation<dim,spacedim>::execute_refinement ()
-{
- const DistortedCellList
- cells_with_distorted_children
- =
- internal::Triangulation::Implementation::
- execute_refinement (*this,check_for_distorted_cells);
-
-
-
- // re-compute number of lines
- compute_number_cache (*this, levels.size(), number_cache);
-
-#ifdef DEBUG
- for (unsigned int level=0; level<levels.size(); ++level)
- levels[level]->cells.monitor_memory (dim);
-
- // check whether really all
- // refinement flags are reset (also
- // of previously non-active cells
- // which we may not have
- // touched. If the refinement flag
- // of a non-active cell is set,
- // something went wrong since the
- // cell-accessors should have
- // caught this)
- cell_iterator cell = begin(),
- endc = end();
- while (cell != endc)
- Assert (!(cell++)->refine_flag_set(), ExcInternalError ());
-#endif
-
- return cells_with_distorted_children;
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::execute_coarsening ()
-{
- // create a vector counting for each line how
- // many cells contain this line. in 3D, this
- // is used later on to decide which lines can
- // be deleted after coarsening a cell. in
- // other dimensions it will be ignored
- std::vector<unsigned int> line_cell_count = count_cells_bounded_by_line (*this);
- std::vector<unsigned int> quad_cell_count = count_cells_bounded_by_quad (*this);
-
- // loop over all cells. Flag all
- // cells of which all children are
- // flagged for
- // coarsening and delete the childrens'
- // flags. In effect, only those
- // cells are flagged of which originally
- // all children were flagged and for which
- // all children are on the same refinement
- // level. For flagging, the user flags are
- // used, to avoid confusion and because
- // non-active cells can't be flagged for
- // coarsening. Note that because of the
- // effects of @p{fix_coarsen_flags}, of a
- // cell either all or no children must
- // be flagged for coarsening, so it is
- // ok to only check the first child
- clear_user_flags ();
-
- cell_iterator cell = begin(),
- endc = end();
- for (; cell!=endc; ++cell)
- if (!cell->active())
- if (cell->child(0)->coarsen_flag_set())
- {
- cell->set_user_flag();
- for (unsigned int child=0; child<cell->n_children(); ++child)
- {
- Assert (cell->child(child)->coarsen_flag_set(),
- ExcInternalError());
- cell->child(child)->clear_coarsen_flag();
- }
- }
-
-
- // now do the actual coarsening
- // step. Since the loop goes over
- // used cells we only need not
- // worry about deleting some cells
- // since the ++operator will then
- // just hop over them if we should
- // hit one. Do the loop in the
- // reverse way since we may only
- // delete some cells if their
- // neighbors have already been
- // deleted (if the latter are on a
- // higher level for example)
- //
- // if there is only one level,
- // there can not be anything to do
- if (levels.size() >= 2)
- for (cell = last(levels.size()-2); cell!=endc; --cell)
- if (cell->user_flag_set())
- // use a separate function,
- // since this is dimension
- // specific
- internal::Triangulation::Implementation::delete_children (*this, cell,
- line_cell_count, quad_cell_count);
-
- // re-compute number of lines and
- // quads
- compute_number_cache (*this, levels.size(), number_cache);
-
- // in principle no user flags
- // should be
- // set any more at this point
-#if DEBUG
- for (cell=begin(); cell!=endc; ++cell)
- Assert (cell->user_flag_set() == false, ExcInternalError());
-#endif
-}
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::fix_coarsen_flags ()
-{
- // copy a piece of code from
- // prepare_coarsening_and_refinement that
- // ensures that the level difference at
- // vertices is limited if so desired. we
- // need this code here since at least in 1d
- // we don't call the dimension-independent
- // version of
- // prepare_coarsening_and_refinement
- // function. in 2d and 3d, having this hunk
- // here makes our lives a bit easier as
- // well as it takes care of these cases
- // earlier than it would otherwise happen.
- //
- // the main difference to the code
- // in p_c_and_r is that here we
- // absolutely have to make sure
- // that we get things right,
- // i.e. that in particular we set
- // flags right if
- // limit_level_difference_at_vertices
- // is set. to do so we iterate
- // until the flags don't change any
- // more
- std::vector<bool> previous_coarsen_flags (n_active_cells());
- save_coarsen_flags (previous_coarsen_flags);
-
- std::vector<int> vertex_level (vertices.size(), 0);
-
- bool continue_iterating = true;
-
- do
- {
- if (smooth_grid & limit_level_difference_at_vertices)
- {
- Assert(!anisotropic_refinement,
- ExcMessage("In case of anisotropic refinement the "
- "limit_level_difference_at_vertices flag for "
- "mesh smoothing must not be set!"));
-
- // store highest level one
- // of the cells adjacent to
- // a vertex belongs to
- std::fill (vertex_level.begin(), vertex_level.end(), 0);
- active_cell_iterator cell = begin_active(),
- endc = end();
- for (; cell!=endc; ++cell)
- {
- if (cell->refine_flag_set())
- 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())
- 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 try to
- // correct this by
- // iterating over the
- // entire process until
- // we are converged
- Assert (cell->coarsen_flag_set(), ExcInternalError());
- 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
- // update the vertex levels on the
- // adjacent vertices and maybe
- // already flag additional cells in
- // this loop
- //
- // note that not only may we have
- // to add additional refinement
- // flags, but we will also have to
- // remove coarsening flags on cells
- // adjacent to vertices that will
- // see refinement
- for (cell=last_active(); cell != endc; --cell)
- 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
- // cells of which all children are
- // flagged for coarsening and
- // delete the childrens'
- // flags. Also delete all flags of
- // cells for which not all children
- // of a cell are flagged. In
- // effect, only those cells are
- // flagged of which originally all
- // children were flagged and for
- // which all children are on the
- // same refinement level. For
- // flagging, the user flags are
- // used, to avoid confusion and
- // because non-active cells can't
- // be flagged for coarsening
- //
- // In effect, all coarsen flags are
- // turned into user flags of the
- // mother cell if coarsening is
- // possible or deleted
- // otherwise.
- clear_user_flags ();
- // Coarsen flags of
- // cells with no mother cell,
- // i.e. on the coarsest level are
- // deleted explicitly.
- active_cell_iterator acell = begin_active(0),
- end_ac = end_active(0);
- for (; acell!=end_ac; ++acell)
- acell->clear_coarsen_flag();
-
- cell_iterator cell = begin(),
- endc = end();
- for (; cell!=endc; ++cell)
- {
- // nothing to do if we are
- // already on the finest level
- if (cell->active())
- continue;
-
- const unsigned int n_children=cell->n_children();
- unsigned int flagged_children=0;
- for (unsigned int child=0; child<n_children; ++child)
- if (cell->child(child)->active() &&
- cell->child(child)->coarsen_flag_set())
- {
- ++flagged_children;
- // clear flag since we
- // don't need it anymore
- cell->child(child)->clear_coarsen_flag();
- }
-
- // flag this cell for
- // coarsening if all children
- // were flagged
- if (flagged_children == n_children)
- cell->set_user_flag();
- }
-
- // in principle no coarsen flags
- // should be set any more at this
- // point
-#if DEBUG
- for (cell=begin(); cell!=endc; ++cell)
- Assert (cell->coarsen_flag_set() == false, ExcInternalError());
-#endif
-
- // now loop over all cells which have the
- // user flag set. their children were
- // flagged for coarsening. set the coarsen
- // flag again if we are sure that none of
- // the neighbors of these children are
- // refined, or will be refined, since then
- // we would get a two-level jump in
- // refinement. on the other hand, if one of
- // the children's neighbors has their user
- // flag set, then we know that its children
- // will go away by coarsening, and we will
- // be ok.
- //
- // note on the other hand that we do allow
- // level-2 jumps in refinement between
- // neighbors in 1d, so this whole procedure
- // is only necessary if we are not in 1d
- //
- // since we remove some coarsening/user
- // flags in the process, we have to work
- // from the finest level to the coarsest
- // one, since we occasionally inspect user
- // flags of cells on finer levels and need
- // to be sure that these flags are final
- for (cell=last(); cell!=endc; --cell)
- if (cell->user_flag_set())
- // if allowed: flag the
- // children for coarsening
- if (internal::Triangulation::Implementation::template coarsening_allowed<dim,spacedim>(cell))
- for (unsigned int c=0; c<cell->n_children(); ++c)
- {
- Assert (cell->child(c)->refine_flag_set()==false,
- ExcInternalError());
-
- cell->child(c)->set_coarsen_flag();
- }
-
- // clear all user flags again, now that we
- // don't need them any more
- clear_user_flags ();
-
-
- // now see if anything has
- // changed in the last
- // iteration of this function
- std::vector<bool> current_coarsen_flags (n_active_cells());
- save_coarsen_flags (current_coarsen_flags);
-
- continue_iterating = (current_coarsen_flags != previous_coarsen_flags);
- previous_coarsen_flags = current_coarsen_flags;
- }
- while (continue_iterating == true);
-}
-
-
-#if deal_II_dimension == 1
-
-template <>
-bool Triangulation<1,1>::prepare_coarsening_and_refinement ()
-{
- // save the flags to determine
- // whether something was changed in
- // the course of this function
- std::vector<bool> flags_before;
- save_coarsen_flags (flags_before);
-
- // do nothing in 1d, except setting
- // the coarsening flags correctly
- fix_coarsen_flags ();
-
- std::vector<bool> flags_after;
- save_coarsen_flags (flags_after);
-
- return (flags_before != flags_after);
-}
-
-
-template <>
-bool Triangulation<1,2>::prepare_coarsening_and_refinement ()
-{
- // save the flags to determine
- // whether something was changed in
- // the course of this function
- std::vector<bool> flags_before;
- save_coarsen_flags (flags_before);
-
- // do nothing in 1d, except setting
- // the coarsening flags correctly
- fix_coarsen_flags ();
-
- std::vector<bool> flags_after;
- save_coarsen_flags (flags_after);
-
- return (flags_before != flags_after);
-}
-
-
-#endif
-
-
-namespace
-{
-
- // check if the given @param cell marked
- // for coarsening would produce an
- // unrefined island. To break up long
- // chains of these cells we recursively
- // check our neighbors in case we change
- // this cell. This reduces the number of
- // outer iterations dramatically.
- template <int dim, int spacedim>
- void
- possibly_do_not_produce_unrefined_islands(
- const typename Triangulation<dim,spacedim>::cell_iterator &cell)
- {
- Assert (cell->has_children(), ExcInternalError());
-
- unsigned int n_neighbors=0;
- // count all neighbors
- // that will be refined
- // along the face of our
- // cell after the next
- // step
- unsigned int count=0;
- for (unsigned int n=0; n<GeometryInfo<dim>::faces_per_cell; ++n)
- {
- const typename Triangulation<dim,spacedim>::cell_iterator neighbor = cell->neighbor(n);
- if (neighbor.state() == IteratorState::valid)
- {
- ++n_neighbors;
- if (face_will_be_refined_by_neighbor(cell,n))
- ++count;
- }
- }
- // clear coarsen flags if
- // either all existing
- // neighbors will be
- // refined or all but one
- // will be and the cell
- // is in the interior of
- // the domain
- if (count==n_neighbors ||
- (count>=n_neighbors-1 &&
- n_neighbors == GeometryInfo<dim>::faces_per_cell) )
- {
- for (unsigned int c=0; c<cell->n_children(); ++c)
- cell->child(c)->clear_coarsen_flag();
-
- for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- if (!cell->at_boundary(face)
- &&
- ( !cell->neighbor(face)->active() )
- && (cell_will_be_coarsened(cell->neighbor(face))) )
- possibly_do_not_produce_unrefined_islands<dim,spacedim>( cell->neighbor(face) );
- }
- }
-
-
- // see if the current cell needs to
- // be refined to avoid unrefined
- // islands.
- //
- // there are sometimes chains of
- // cells that induce refinement of
- // each other. to avoid running the
- // loop in
- // prepare_coarsening_and_refinement
- // over and over again for each one
- // of them, at least for the
- // isotropic refinement case we
- // seek to flag neighboring
- // elements as well as
- // necessary. this takes care of
- // (slightly pathological) cases
- // like deal.II/mesh_smoothing_03
- template <int dim, int spacedim>
- void
- possibly_refine_unrefined_island
- (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
- const bool allow_anisotropic_smoothing)
- {
- Assert (cell->has_children() == false, ExcInternalError());
- Assert (cell->refine_flag_set() == false, ExcInternalError());
-
-
- // now we provide two
- // algorithms. the first one is
- // the standard one, coming from
- // the time, where only isotropic
- // refinement was possible. it
- // simply counts the neighbors
- // that are or will be refined
- // and compares to the number of
- // other ones. the second one
- // does this check independently
- // for each direction: if all
- // neighbors in one direction
- // (normally two, at the boundary
- // only one) are refined, the
- // current cell is flagged to be
- // refined in an according
- // direction.
-
- if (allow_anisotropic_smoothing == false)
- {
- // use first algorithm
- unsigned int refined_neighbors = 0,
- unrefined_neighbors = 0;
- for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- if (!cell->at_boundary(face))
- {
- if (face_will_be_refined_by_neighbor(cell,face))
- ++refined_neighbors;
- else
- ++unrefined_neighbors;
- }
-
- if (unrefined_neighbors < refined_neighbors)
- {
- cell->clear_coarsen_flag();
- cell->set_refine_flag ();
-
- // ok, so now we have
- // flagged this cell. if
- // we know that there
- // were any unrefined
- // neighbors at all, see
- // if any of those will
- // have to be refined as
- // well
- if (unrefined_neighbors > 0)
- for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- if (!cell->at_boundary(face)
- &&
- (face_will_be_refined_by_neighbor(cell,face) == false)
- &&
- (cell->neighbor(face)->has_children() == false)
- &&
- (cell->neighbor(face)->refine_flag_set() == false))
- possibly_refine_unrefined_island<dim,spacedim>
- (cell->neighbor(face),
- allow_anisotropic_smoothing);
- }
- }
- else
- {
- // variable to store the cell
- // refine case needed to
- // fulfill all smoothing
- // requirements
- RefinementCase<dim> smoothing_cell_refinement_case
- = RefinementCase<dim>::no_refinement;
-
- // use second algorithm, do
- // the check individually for
- // each direction
- for (unsigned int face_pair=0;
- face_pair<GeometryInfo<dim>::faces_per_cell/2; ++face_pair)
- {
- // variable to store the
- // cell refine case
- // needed to refine at
- // the current face pair
- // in the same way as the
- // neighbors do...
- RefinementCase<dim> directional_cell_refinement_case
- = RefinementCase<dim>::isotropic_refinement;
-
- for (unsigned int face_index=0; face_index<2; ++face_index)
- {
- unsigned int face=2*face_pair+face_index;
- // variable to store
- // the refine case
- // (to come) of the
- // face under
- // consideration
- RefinementCase<dim-1> expected_face_ref_case
- = RefinementCase<dim-1>::no_refinement;
-
- if (cell->neighbor(face).state() == IteratorState::valid)
- face_will_be_refined_by_neighbor<dim,spacedim>(cell,face,expected_face_ref_case);
- // now extract which
- // refine case would
- // be necessary to
- // achive the same
- // face
- // refinement. set
- // the intersection
- // with other
- // requirements for
- // the same
- // direction.
-
- // note: using the
- // intersection is
- // not an obvious
- // decision, we could
- // also argue that it
- // is more natural to
- // use the
- // union. however,
- // intersection is
- // the less
- // aggressive tactic
- // and favours a
- // smaller number of
- // refined cells over
- // an intensive
- // smoothing. this
- // way we try not to
- // loose too much of
- // the effort we put
- // in anisotropic
- // refinement
- // indicators due to
- // overly aggressive
- // smoothing...
- directional_cell_refinement_case
- = (directional_cell_refinement_case &
- GeometryInfo<dim>::min_cell_refinement_case_for_face_refinement(
- expected_face_ref_case,
- face,
- cell->face_orientation(face),
- cell->face_flip(face),
- cell->face_rotation(face)));
- }//for both face indices
- // if both requirements
- // sum up to something
- // useful, add this to
- // the refine case for
- // smoothing. note: if
- // directional_cell_refinement_case
- // is isotropic still,
- // then something went
- // wrong...
- Assert(directional_cell_refinement_case <
- RefinementCase<dim>::isotropic_refinement,
- ExcInternalError());
- smoothing_cell_refinement_case = smoothing_cell_refinement_case |
- directional_cell_refinement_case;
- }//for all face_pairs
- // no we collected
- // contributions from all
- // directions. combine the
- // new flags with the
- // existing refine case, but
- // only if smoothing is
- // required
- if (smoothing_cell_refinement_case)
- {
- cell->clear_coarsen_flag();
- cell->set_refine_flag(cell->refine_flag_set() |
- smoothing_cell_refinement_case);
- }
- }
- }
-}
-
-
-template <int dim, int spacedim>
-bool Triangulation<dim,spacedim>::prepare_coarsening_and_refinement ()
-{
- // save the flags to determine
- // whether something was changed in
- // the course of this function
- std::vector<bool> flags_before[2];
- save_coarsen_flags (flags_before[0]);
- save_refine_flags (flags_before[1]);
-
- // save the flags at the outset of
- // each loop. we do so in order to
- // find out whether something was
- // changed in the present loop, in
- // which case we would have to
- // re-run the loop. the other
- // possibility to find this out
- // would be to set a flag
- // @p{something_changed} to true
- // each time we change something.
- // however, sometimes one change in
- // one of the parts of the loop is
- // undone by another one, so we
- // might end up in an endless
- // loop. we could be tempted to
- // break this loop at an arbitrary
- // number of runs, but that would
- // not be a clean solution, since
- // we would either have to
- // 1/ break the loop too early, in which
- // case the promise that a second
- // call to this function immediately
- // after the first one does not
- // change anything, would be broken,
- // or
- // 2/ we do as many loops as there are
- // levels. we know that information
- // is transported over one level
- // in each run of the loop, so this
- // is enough. Unfortunately, each
- // loop is rather expensive, so
- // we chose the way presented here
- std::vector<bool> flags_before_loop[2] = {flags_before[0],
- flags_before[1]};
-
- // now for what is done in each
- // loop: we have to fulfill several
- // tasks at the same time, namely
- // several mesh smoothing
- // algorithms and mesh
- // regularisation, by which we mean
- // that the next mesh fulfills
- // several requirements such as no
- // double refinement at each face
- // or line, etc.
- //
- // since doing these things at once
- // seems almost impossible (in the
- // first year of this library, they
- // were done in two functions, one
- // for refinement and one for
- // coarsening, and most things
- // within these were done at once,
- // so the code was rather
- // impossible to join into this,
- // only, function), we do them one
- // after each other. the order in
- // which we do them is such that
- // the important tasks, namely
- // regularisation, are done last
- // and the least important things
- // are done the first. the
- // following order is chosen:
- //
- // 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 by coarsening.
- // As coarsen flags will never be added,
- // this can be done once and for all
- // before the actual loop starts.
- // 1/ do not coarsen a cell if
- // 'most of the neighbors' will be
- // refined after the step. This is
- // to prevent occurence of
- // unrefined islands.
- // 2/ eliminate refined islands in the
- // interior and at the boundary. since
- // they don't do much harm besides
- // increasing the number of degrees
- // of freedom, doing this has a
- // rather low priority.
- // 3/ limit the level difference of
- // neighboring cells at each vertex.
- // 4/ eliminate unrefined islands. this
- // has higher priority since this
- // diminishes the approximation
- // properties not only of the unrefined
- // island, but also of the surrounding
- // patch.
- // 5/ ensure patch level 1. Then the
- // triangulation consists of patches,
- // i.e. of cells that are
- // refined once. It follows that if at
- // least one of the children of a cell
- // is or will be refined than all children
- // need to be refined. This step
- // only sets refinement flags and does
- // not set coarsening flags.
- // If the patch_level_1 flag is set, then
- // eliminate_unrefined_islands,
- // eliminate_refined_inner_islands and
- // eliminate_refined_boundary_islands will
- // be fulfilled automatically and do not
- // need to be enforced separately.
- // 6/ take care of the requirement that no
- // double refinement is done at each face
- // 7/ take care that no double refinement
- // is done at each line in 3d or higher
- // dimensions.
- // 8/ make sure that all children of each
- // cell are either flagged for coarsening
- // or none of the children is
- //
- // For some of these steps, it is
- // known that they
- // interact. Namely, it is not
- // possible to guarantee that after
- // step 6 another step 5 would have
- // no effect; the same holds for
- // the opposite order and also when
- // taking into account step
- // 7. however, it is important to
- // guarantee that step five or six
- // do not undo something that step
- // 5 did, and step 7 not something
- // of step 6, otherwise the
- // requirements will not be
- // satisfied even if the loop
- // terminates. this is accomplished
- // by the fact that steps 5 and 6
- // only *add* refinement flags and
- // delete coarsening flags
- // (therefore, step 6 can't undo
- // something that step 4 already
- // did), and step 7 only deletes
- // coarsening flags, never adds
- // some. step 7 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 by coarsening.
- if (((smooth_grid & coarsest_level_1) ||
- (smooth_grid & patch_level_1)) && n_levels()>=2)
- {
- active_cell_iterator
- cell=begin_active(1),
- endc=end_active(1);
-
- for (; cell!=endc; ++cell)
- cell->clear_coarsen_flag();
- }
-
- 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
- // occurence of unrefined islands.
- // If patch_level_1 is set, this will
- // be automatically fulfilled.
- if (smooth_grid & do_not_produce_unrefined_islands &&
- !(smooth_grid & patch_level_1))
- {
- cell_iterator cell;
- const cell_iterator endc = end();
-
- for (cell=begin(); cell!=endc; ++cell)
- {
- // only do something if this
- // cell will be coarsened
- if (!cell->active() && cell_will_be_coarsened(cell))
- possibly_do_not_produce_unrefined_islands<dim,spacedim>(cell);
- }
- }
-
-
- //////////////////////////////////////
- // STEP 2:
- // eliminate refined islands in the
- // interior and at the boundary. since
- // they don't do much harm besides
- // increasing the number of degrees of
- // freedom, doing this has a rather low
- // priority.
- // If patch_level_1 is set, this will
- // be automatically fulfilled.
- //
- // there is one corner case
- // to consider: if this is a
- // distributed
- // triangulation, there may
- // be refined islands on the
- // boundary of which we own
- // only part (e.g. a single
- // cell in the corner of a
- // domain). the rest of the
- // island is ghost cells and
- // it *looks* like the area
- // around it (artificial
- // cells) are coarser but
- // this is only because they
- // may actually be equally
- // fine on other
- // processors. it's hard to
- // detect this case but we
- // can do the following:
- // only set coarsen flags to
- // remove this refined
- // island if all cells we
- // want to set flags on are
- // locally owned
- if (smooth_grid & (eliminate_refined_inner_islands |
- eliminate_refined_boundary_islands) &&
- !(smooth_grid & patch_level_1))
- {
- cell_iterator cell;
- const cell_iterator endc = end();
-
- for (cell=begin(); cell!=endc; ++cell)
- if (!cell->active() ||
- (cell->active() &&
- cell->refine_flag_set() &&
- !cell->is_ghost() &&
- !cell->is_artificial()))
- {
- // check whether all
- // children are
- // active, i.e. not
- // refined
- // themselves. This
- // is a precondition
- // that the children
- // may be coarsened
- // away. If the cell
- // is only flagged
- // for refinement,
- // then all future
- // children will be
- // active
- bool all_children_active = true;
- if (!cell->active())
- for (unsigned int c=0; c<cell->n_children(); ++c)
- if (!cell->child(c)->active() ||
- cell->child(c)->is_ghost() ||
- cell->child(c)->is_artificial())
- {
- all_children_active = false;
- break;
- }
-
- if (all_children_active)
- {
- // count number
- // of refined and
- // unrefined
- // neighbors of
- // cell.
- // neighbors on
- // lower levels
- // are counted as
- // unrefined
- // since they can
- // only get to
- // the same level
- // as this cell
- // by the next
- // refinement
- // cycle
- unsigned int unrefined_neighbors = 0,
- total_neighbors = 0;
-
- for (unsigned int n=0; n<GeometryInfo<dim>::faces_per_cell; ++n)
- {
- const cell_iterator neighbor = cell->neighbor(n);
- if (neighbor.state() == IteratorState::valid)
- {
- ++total_neighbors;
-
- if (!face_will_be_refined_by_neighbor(cell,n))
- ++unrefined_neighbors;
- }
-
- }
-
- // if all
- // neighbors
- // unrefined:
- // mark this cell
- // for coarsening
- // or don't
- // refine if
- // marked for
- // that
- //
- // also do the
- // distinction
- // between the
- // two versions
- // of the
- // eliminate_refined_*_islands
- // flag
- //
- // the last check
- // is whether
- // there are any
- // neighbors at
- // all. if not
- // so, then we
- // are (e.g.) on
- // the coarsest
- // grid with one
- // cell, for
- // which, of
- // course, we do
- // not remove the
- // refine flag.
- if ((unrefined_neighbors == total_neighbors)
- &&
- (((unrefined_neighbors==GeometryInfo<dim>::faces_per_cell) &&
- (smooth_grid & eliminate_refined_inner_islands)) ||
- ((unrefined_neighbors<GeometryInfo<dim>::faces_per_cell) &&
- (smooth_grid & eliminate_refined_boundary_islands)) )
- &&
- (total_neighbors != 0))
- {
- if (!cell->active())
- for (unsigned int c=0; c<cell->n_children(); ++c)
- {
- cell->child(c)->clear_refine_flag ();
- cell->child(c)->set_coarsen_flag ();
- }
- else
- cell->clear_refine_flag();
- }
- }
- }
- }
-
- //////////////////////////////////////
- // STEP 3:
- // limit the level difference of
- // neighboring cells at each vertex.
- //
- // in case of anisotropic refinement
- // this does not make sense. as soon
- // as one cell is anisotropically
- // refined, an Assertion is
- // thrown. therefore we can ignore
- // this problem later on
- if (smooth_grid & limit_level_difference_at_vertices)
- {
- Assert(!anisotropic_refinement,
- ExcMessage("In case of anisotropic refinement the "
- "limit_level_difference_at_vertices flag for "
- "mesh smoothing must not be set!"));
-
- // store highest level one
- // of the cells adjacent to
- // a vertex belongs to
- std::vector<int> vertex_level (vertices.size(), 0);
- active_cell_iterator cell = begin_active(),
- endc = end();
- for (; cell!=endc; ++cell)
- {
- if (cell->refine_flag_set())
- 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())
- 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
- Assert (cell->coarsen_flag_set(), ExcInternalError());
- 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
- // update the vertex levels on the
- // adjacent vertices and maybe
- // already flag additional cells in
- // this loop
- //
- // note that not only may we have
- // to add additional refinement
- // flags, but we will also have to
- // remove coarsening flags on cells
- // adjacent to vertices that will
- // see refinement
- for (cell=last_active(); cell != endc; --cell)
- 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
- }
- }
- }
-
- /////////////////////////////////////
- // STEP 4:
- // eliminate unrefined
- // islands. this has higher
- // priority since this
- // diminishes the
- // approximation properties
- // not only of the unrefined
- // island, but also of the
- // surrounding patch.
- //
- // do the loop from finest
- // to coarsest cells since
- // we may trigger a cascade
- // by marking cells for
- // refinement which may
- // trigger more cells
- // further down below
- if (smooth_grid & eliminate_unrefined_islands)
- {
- active_cell_iterator cell=last_active(),
- endc=end();
-
- for (; cell != endc; --cell)
- // only do something if
- // cell is not already
- // flagged for
- // (isotropic) refinement
- if (cell->refine_flag_set() != RefinementCase<dim>::isotropic_refinement)
- possibly_refine_unrefined_island<dim,spacedim>
- (cell,
- (smooth_grid & allow_anisotropic_smoothing) != 0);
- }
-
- /////////////////////////////////
- // STEP 5:
- // ensure patch level 1.
- //
- // Introduce some terminology:
- // - a cell that is refined
- // once is a patch of
- // level 1 simply called patch.
- // - a cell that is globally
- // refined twice is called
- // a patch of level 2.
- // - patch level n says that
- // the triangulation consists
- // of patches of level n.
- // This makes sense only
- // if the grid is already at
- // least n times globally
- // refined.
- //
- // E.g. from patch level 1
- // follows: if at least one
- // of the children of a cell
- // is or will be refined
- // than enforce all
- // children to be
- // refined.
-
- // This step 4 only
- // sets refinement flags and
- // does not set coarsening
- // flags.
- if (smooth_grid & patch_level_1)
- {
- // An important assumption
- // (A) is that before
- // calling this function
- // the grid was already of
- // patch level 1.
-
- // loop over all cells
- // whose children are all
- // active. (By assumption
- // (A) either all or none
- // of the children are
- // active). If the refine
- // flag of at least one of
- // the children is set then
- // set_refine_flag and
- // clear_coarsen_flag of
- // all children.
- for (cell_iterator cell = begin(); cell != end(); ++cell)
- if (!cell->active())
- {
- // ensure the
- // invariant. we can
- // then check whether
- // all of its
- // children are
- // further refined or
- // not by simply
- // looking at the
- // first child
- Assert (cell_is_patch_level_1(cell),
- ExcInternalError());
- if (cell->child(0)->has_children() == true)
- continue;
-
- // cell is found to
- // be a patch.
- // combine the refine
- // cases of all
- // children
- RefinementCase<dim> combined_ref_case = RefinementCase<dim>::no_refinement;
- for (unsigned int i=0; i<cell->n_children(); ++i)
- combined_ref_case = combined_ref_case |
- cell->child(i)->refine_flag_set();
- if (combined_ref_case != RefinementCase<dim>::no_refinement)
- for (unsigned int i=0; i<cell->n_children(); ++i)
- {
- cell_iterator child = cell->child(i);
-
- child->clear_coarsen_flag();
- child->set_refine_flag(combined_ref_case);
- }
- }
-
- // The code above dealt
- // with the case where we
- // may get a
- // non-patch_level_1 mesh
- // from refinement. Now
- // also deal with the case
- // where we could get such
- // a mesh by coarsening.
- // Coarsen the children
- // (and remove the
- // grandchildren) only if
- // all cell->grandchild(i)
- // ->coarsen_flag_set()
- // are set.
- //
- // for a case where this is
- // a bit tricky, take a
- // look at the
- // mesh_smoothing_0[12]
- // testcases
- for (cell_iterator cell = begin(); cell != end(); ++cell)
- {
- // check if this cell
- // has active
- // grandchildren. note
- // that we know that it
- // is patch_level_1,
- // i.e. if one of its
- // children is active
- // then so are all, and
- // it isn't going to
- // have any
- // grandchildren at
- // all:
- if (cell->active()
- ||
- cell->child(0)->active())
- continue;
-
- // cell is not active,
- // and so are none of
- // its children. check
- // the
- // grandchildren. note
- // that the children
- // are also
- // patch_level_1, and
- // so we only ever need
- // to check their first
- // child
- const unsigned int n_children=cell->n_children();
- bool has_active_grandchildren = false;
-
- for (unsigned int i=0; i<n_children; ++i)
- if (cell->child(i)->child(0)->active())
- {
- has_active_grandchildren = true;
- break;
- }
-
- if (has_active_grandchildren == false)
- continue;
-
-
- // ok, there are active
- // grandchildren. see
- // if either all or
- // none of them are
- // flagged for
- // coarsening
- unsigned int n_grandchildren=0;
- // count all coarsen
- // flags of the
- // grandchildren.
- unsigned int n_coarsen_flags=0;
- // cell is not a
- // patch (of level 1)
- // as it has a
- // grandchild. Is
- // cell a patch of
- // level 2??
- // Therefore: find
- // out whether all
- // cell->child(i) are
- // patches
- for (unsigned int c=0; c<n_children; ++c)
- {
- // get at the
- // child. by
- // assumption
- // (A), and the
- // check by which
- // we got here,
- // the child is
- // not active
- cell_iterator child=cell->child(c);
-
- const unsigned int nn_children=child->n_children();
- n_grandchildren += nn_children;
-
- // if child is
- // found to be a
- // patch of
- // active cells
- // itself, then
- // add up how
- // many of its
- // children are
- // supposed to be
- // coarsened
- if (child->child(0)->active())
- for (unsigned int cc=0; cc<nn_children; ++cc)
- if (child->child(cc)->coarsen_flag_set())
- ++n_coarsen_flags;
- }
-
- // if not all
- // grandchildren are
- // supposed to be
- // coarsened
- // (e.g. because some
- // simply don't have
- // the flag set, or
- // because they are not
- // active and therefore
- // cannot carry the
- // flag), then remove
- // the coarsen flag
- // from all of the
- // active
- // grandchildren. note
- // that there may be
- // coarsen flags on the
- // grandgrandchildren
- // -- we don't clear
- // them here, but we'll
- // get to them in later
- // iterations if
- // necessary
- //
- // there is nothing
- // we have to do if
- // no coarsen flags
- // have been set at
- // all
- if ((n_coarsen_flags != n_grandchildren)
- &&
- (n_coarsen_flags > 0))
- for (unsigned int c=0; c<n_children; ++c)
- {
- const cell_iterator child = cell->child(c);
- if (child->child(0)->active())
- for (unsigned int cc=0; cc<child->n_children(); ++cc)
- child->child(cc)->clear_coarsen_flag();
- }
- }
- }
-
- //////////////////////////////////
- //
- // at the boundary we could end up with
- // cells with negative volume or at
- // least with a part, that is negative,
- // if the cell is refined
- // anisotropically. we have to check,
- // whether that can happen
- internal::Triangulation::Implementation::prevent_distorted_boundary_cells(*this);
-
- /////////////////////////////////
- // STEP 6:
- // take care of the requirement that no
- // double refinement is done at each face
- //
- // in case of anisotropic refinement
- // it is only likely, but not sure,
- // that the cells, which are more
- // refined along a certain face common
- // to two cells are on a higher
- // level. therefore we cannot be sure,
- // that the requirement of no double
- // refinement is fulfilled after a
- // single pass of the following
- // actions. We could just wait for the
- // next global loop. when this
- // function terminates, the
- // requirement will be
- // fullfilled. However, it might be
- // faster to insert an inner loop
- // here.
- bool changed = true;
- while (changed)
- {
- changed=false;
- active_cell_iterator cell=last_active(),
- endc=end();
-
- for (; cell != endc; --cell)
- if (cell->refine_flag_set())
- {
- // loop over neighbors of cell
- for (unsigned int i=0; i<GeometryInfo<dim>::faces_per_cell; ++i)
- {
- // only do something if the
- // face is not at the boundary
- // and if the face will be
- // refined with the RefineCase
- // currently flagged for
- if (cell->neighbor(i).state() == IteratorState::valid &&
- (GeometryInfo<dim>::face_refinement_case(cell->refine_flag_set(),
- i)
- != RefinementCase<dim-1>::no_refinement))
- {
- // 1) if the neighbor has
- // children: nothing to
- // worry about.
- // 2) if the neighbor is
- // active and a coarser
- // one, ensure, that its
- // refine_flag is set
- // 3) if the neighbor is
- // active and as
- // refined along the face
- // as our current cell,
- // make sure, that no
- // coarsen_flag is set. if
- // we remove the coarsen
- // flag of our neighbor,
- // fix_coarsen_flags() makes
- // sure, that the mother
- // cell will not be
- // coarsened
- if (cell->neighbor(i)->active())
- {
- if (cell->neighbor_is_coarser(i))
- {
- if (cell->neighbor(i)->coarsen_flag_set())
- cell->neighbor(i)->clear_coarsen_flag();
- // we'll set the
- // refine flag
- // for this
- // neighbor
- // below. we
- // note, that we
- // have changed
- // something by
- // setting the
- // changed flag
- // to true. We do
- // not need to do
- // so, if we just
- // removed the
- // coarsen flag,
- // as the changed
- // flag only
- // indicates the
- // need to re-run
- // the inner
- // loop. however,
- // we only loop
- // over cells
- // flagged for
- // refinement
- // here, so
- // nothing to
- // worry about if
- // we remove
- // coarsen flags
-
- if (dim==2)
- {
- if (smooth_grid & allow_anisotropic_smoothing)
- changed=cell->neighbor(i)->flag_for_face_refinement(cell->neighbor_of_coarser_neighbor(i).first,
- RefinementCase<dim-1>::cut_x);
- else
- {
- if (!cell->neighbor(i)->refine_flag_set())
- changed=true;
- cell->neighbor(i)->set_refine_flag();
- }
- }
- else //i.e. if (dim==3)
- {
-// ugly situations might arise here, consider the following situation, which
-// shows neighboring cells at the common face, where the upper right element is
-// coarser at the given face. Now the upper child element of the lower left
-// wants to refine according to cut_z, such that there is a 'horizontal'
-// refinement of the face marked with #####
-//
-// / /
-// / /
-// *---------------*
-// | |
-// | |
-// | |
-// | |
-// | |
-// | | /
-// | |/
-// *---------------*
-//
-//
-// *---------------*
-// /| /|
-// / | ##### / |
-// | |
-// *---------------*
-// /| /|
-// / | / |
-// | |
-// *---------------*
-// / /
-// / /
-//
-// this introduces too many hanging nodes and the neighboring (coarser) cell
-// (upper right) has to be refined. If it is only refined according to cut_z,
-// then everything is ok:
-//
-// / /
-// / /
-// *---------------*
-// | |
-// | | /
-// | |/
-// *---------------*
-// | |
-// | | /
-// | |/
-// *---------------*
-//
-//
-// *---------------*
-// /| /|
-// / *---------------*
-// /| /|
-// *---------------*
-// /| /|
-// / | / |
-// | |
-// *---------------*
-// / /
-// / /
-//
-// if however the cell wants to refine itself in an other way, or if we disallow
-// anisotropic smoothing, then simply refining the neighbor isotropically is not
-// going to work, since this introduces a refinement of face ##### with both
-// cut_x and cut_y, which is not possible:
-//
-// / / /
-// / / /
-// *-------*-------*
-// | | |
-// | | | /
-// | | |/
-// *-------*-------*
-// | | |
-// | | | /
-// | | |/
-// *-------*-------*
-//
-//
-// *---------------*
-// /| /|
-// / *---------------*
-// /| /|
-// *---------------*
-// /| /|
-// / | / |
-// | |
-// *---------------*
-// / /
-// / /
-//
-// thus, in this case we also need to refine our current cell in the new
-// direction:
-//
-// / / /
-// / / /
-// *-------*-------*
-// | | |
-// | | | /
-// | | |/
-// *-------*-------*
-// | | |
-// | | | /
-// | | |/
-// *-------*-------*
-//
-//
-// *-------*-------*
-// /| /| /|
-// / *-------*-------*
-// /| /| /|
-// *-------*-------*
-// /| / /|
-// / | / |
-// | |
-// *---------------*
-// / /
-// / /
-
- std::pair<unsigned int, unsigned int> nb_indices
- =cell->neighbor_of_coarser_neighbor(i);
- unsigned int refined_along_x=0,
- refined_along_y=0,
- to_be_refined_along_x=0,
- to_be_refined_along_y=0;
-
- const int this_face_index=cell->face_index(i);
-
-// step 1: detect, along which axis the face is currently refined
- if ((this_face_index
- == cell->neighbor(i)->face(nb_indices.first)->child_index(0)) ||
- (this_face_index
- == cell->neighbor(i)->face(nb_indices.first)->child_index(1)))
- {
- // this
- // might
- // be an
- // anisotropic
- // child. get
- // the
- // face
- // refine
- // case
- // of the
- // neighbors
- // face
- // and
- // count
- // refinements
- // in x
- // and y
- // direction.
- RefinementCase<dim-1> frc=cell->neighbor(i)->face(nb_indices.first)->refinement_case();
- if (frc & RefinementCase<dim>::cut_x)
- ++refined_along_x;
- if (frc & RefinementCase<dim>::cut_y)
- ++refined_along_y;
- }
- else
- // this has
- // to be an
- // isotropic
- // child
- {
- ++refined_along_x;
- ++refined_along_y;
- }
-// step 2: detect, along which axis the face has to be refined given the current
-// refine flag
- RefinementCase<dim-1> flagged_frc=
- GeometryInfo<dim>::face_refinement_case(cell->refine_flag_set(),
- i,
- cell->face_orientation(i),
- cell->face_flip(i),
- cell->face_rotation(i));
- if (flagged_frc & RefinementCase<dim>::cut_x)
- ++to_be_refined_along_x;
- if (flagged_frc & RefinementCase<dim>::cut_y)
- ++to_be_refined_along_y;
-
-// step 3: set the refine flag of the (coarser and active) neighbor.
- if ((smooth_grid & allow_anisotropic_smoothing) ||
- cell->neighbor(i)->refine_flag_set())
- {
- if (refined_along_x + to_be_refined_along_x > 1)
- changed |= cell->neighbor(i)->flag_for_face_refinement(nb_indices.first,
- RefinementCase<dim-1>::cut_axis(0));
- if (refined_along_y + to_be_refined_along_y > 1)
- changed |= cell->neighbor(i)->flag_for_face_refinement(nb_indices.first,
- RefinementCase<dim-1>::cut_axis(1));
- }
- else
- {
- if (cell->neighbor(i)->refine_flag_set()!=RefinementCase<dim>::isotropic_refinement)
- changed=true;
- cell->neighbor(i)->set_refine_flag();
- }
-
-// step 4: if necessary (see above) add to the refine flag of the current cell
- cell_iterator nb=cell->neighbor(i);
- RefinementCase<dim-1> nb_frc
- = GeometryInfo<dim>::face_refinement_case(nb->refine_flag_set(),
- nb_indices.first,
- nb->face_orientation(nb_indices.first),
- nb->face_flip(nb_indices.first),
- nb->face_rotation(nb_indices.first));
- if ((nb_frc & RefinementCase<dim>::cut_x) &&
- !(refined_along_x || to_be_refined_along_x))
- changed |= cell->flag_for_face_refinement(i,RefinementCase<dim-1>::cut_axis(0));
- if ((nb_frc & RefinementCase<dim>::cut_y) &&
- !(refined_along_y || to_be_refined_along_y))
- changed |= cell->flag_for_face_refinement(i,RefinementCase<dim-1>::cut_axis(1));
- }
- }// if neighbor is coarser
- else // -> now the neighbor is not coarser
- {
- cell->neighbor(i)->clear_coarsen_flag();
- const unsigned int nb_nb=cell->neighbor_of_neighbor(i);
- const cell_iterator neighbor=cell->neighbor(i);
- RefinementCase<dim-1> face_ref_case=
- GeometryInfo<dim>::face_refinement_case(neighbor->refine_flag_set(),
- nb_nb,
- neighbor->face_orientation(nb_nb),
- neighbor->face_flip(nb_nb),
- neighbor->face_rotation(nb_nb));
- RefinementCase<dim-1> needed_face_ref_case
- =GeometryInfo<dim>::face_refinement_case(cell->refine_flag_set(),
- i,
- cell->face_orientation(i),
- cell->face_flip(i),
- cell->face_rotation(i));
- // if the
- // neighbor wants
- // to refine the
- // face with
- // cut_x and we
- // want cut_y or
- // vice versa, we
- // have to refine
- // isotropically
- // at the given
- // face
- if ((face_ref_case==RefinementCase<dim>::cut_x && needed_face_ref_case==RefinementCase<dim>::cut_y) ||
- (face_ref_case==RefinementCase<dim>::cut_y && needed_face_ref_case==RefinementCase<dim>::cut_x))
- {
- changed=cell->flag_for_face_refinement(i, face_ref_case);
- neighbor->flag_for_face_refinement(nb_nb, needed_face_ref_case);
- }
- }
- }
- else //-> the neighbor is not active
- {
- RefinementCase<dim-1> face_ref_case = cell->face(i)->refinement_case(),
- needed_face_ref_case = GeometryInfo<dim>::face_refinement_case(cell->refine_flag_set(),
- i,
- cell->face_orientation(i),
- cell->face_flip(i),
- cell->face_rotation(i));
- // if the face is
- // refined with cut_x
- // and we want cut_y
- // or vice versa, we
- // have to refine
- // isotropically at
- // the given face
- if ((face_ref_case==RefinementCase<dim>::cut_x && needed_face_ref_case==RefinementCase<dim>::cut_y) ||
- (face_ref_case==RefinementCase<dim>::cut_y && needed_face_ref_case==RefinementCase<dim>::cut_x))
- changed=cell->flag_for_face_refinement(i, face_ref_case);
- }
- }
- }
- }
- }
-
- //////////////////////////////////////
- // STEP 7:
- // take care that no double refinement
- // is done at each line in 3d or higher
- // dimensions.
- internal::Triangulation::Implementation::prepare_refinement_dim_dependent (*this);
-
- //////////////////////////////////////
- // STEP 8:
- // make sure that all children of each
- // cell are either flagged for coarsening
- // or none of the children is
- fix_coarsen_flags ();
- // get the refinement and coarsening
- // flags
- std::vector<bool> flags_after_loop[2];
- save_coarsen_flags (flags_after_loop[0]);
- save_refine_flags (flags_after_loop[1]);
-
- // find out whether something was
- // changed in this loop
- mesh_changed_in_this_loop
- = ((flags_before_loop[0] != flags_after_loop[0]) ||
- (flags_before_loop[1] != flags_after_loop[1]));
-
- // set the flags for the next loop
- // already
- flags_before_loop[0].swap(flags_after_loop[0]);
- flags_before_loop[1].swap(flags_after_loop[1]);
- }
- while (mesh_changed_in_this_loop);
-
-
- // find out whether something was really
- // changed in this function. Note that
- // @p{flags_before_loop} represents the
- // state after the last loop, i.e.
- // the present state
- return ((flags_before[0] != flags_before_loop[0]) ||
- (flags_before[1] != flags_before_loop[1]));
-}
-
-
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::write_bool_vector (const unsigned int magic_number1,
- const std::vector<bool> &v,
- const unsigned int magic_number2,
- std::ostream &out)
-{
- const unsigned int N = v.size();
- unsigned char *flags = new unsigned char[N/8+1];
- for (unsigned int i=0; i<N/8+1; ++i) flags[i]=0;
-
- for (unsigned int position=0; position<N; ++position)
- flags[position/8] |= (v[position] ? (1<<(position%8)) : 0);
-
- AssertThrow (out, ExcIO());
-
- // format:
- // 0. magic number
- // 1. number of flags
- // 2. the flags
- // 3. magic number
- out << magic_number1 << ' ' << N << std::endl;
- for (unsigned int i=0; i<N/8+1; ++i)
- out << static_cast<unsigned int>(flags[i]) << ' ';
-
- out << std::endl << magic_number2 << std::endl;
-
- delete[] flags;
-
- AssertThrow (out, ExcIO());
-}
-
-
-template <int dim, int spacedim>
-void Triangulation<dim, spacedim>::read_bool_vector (const unsigned int magic_number1,
- std::vector<bool> &v,
- const unsigned int magic_number2,
- std::istream &in)
-{
- AssertThrow (in, ExcIO());
-
- unsigned int magic_number;
- in >> magic_number;
- AssertThrow (magic_number==magic_number1, ExcGridReadError());
-
- unsigned int N;
- in >> N;
- v.resize (N);
-
- unsigned char *flags = new unsigned char[N/8+1];
- unsigned short int tmp;
- for (unsigned int i=0; i<N/8+1; ++i)
- {
- in >> tmp;
- flags[i] = tmp;
- }
-
- for (unsigned int position=0; position!=N; ++position)
- v[position] = (flags[position/8] & (1<<(position%8)));
-
- in >> magic_number;
- AssertThrow (magic_number==magic_number2, ExcGridReadError());
-
- delete[] flags;
-
- AssertThrow (in, ExcIO());
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int
-Triangulation<dim, spacedim>::memory_consumption () const
-{
- unsigned int mem = 0;
- mem += MemoryConsumption::memory_consumption(levels);
- for (unsigned int i=0; i<levels.size(); ++i)
- mem += MemoryConsumption::memory_consumption (*levels[i]);
- mem += MemoryConsumption::memory_consumption (vertices);
- mem += MemoryConsumption::memory_consumption (vertices_used);
- mem += sizeof(boundary);
- mem += sizeof(smooth_grid);
- mem += MemoryConsumption::memory_consumption (number_cache);
- mem += sizeof (faces);
- mem += MemoryConsumption::memory_consumption (*faces);
-
- return mem;
-}
-
-
-
-
-template<int dim, int spacedim>
-Triangulation<dim, spacedim>::RefinementListener::~RefinementListener ()
-{}
-
-
-
-template<int dim, int spacedim>
-Triangulation<dim, spacedim>::DistortedCellList::~DistortedCellList () throw ()
-{
- // don't do anything here. the compiler
- // will automatically convert any
- // exceptions created by the destructors of
- // the member variables into abort() in
- // order to satisfy the throw()
- // specification
-}
-
-
-
-
-template<int dim, int spacedim>
-void Triangulation<dim, spacedim>::
-RefinementListener::pre_refinement_notification (const Triangulation<dim, spacedim> &)
-{}
-
-
-
-template<int dim, int spacedim>
-void Triangulation<dim, spacedim>::
-RefinementListener::post_refinement_notification (const Triangulation<dim, spacedim> &)
-{}
-
-
-
-template<int dim, int spacedim>
-void Triangulation<dim, spacedim>::
-RefinementListener::copy_notification (const Triangulation<dim, spacedim> &,
- const Triangulation<dim, spacedim> &)
-{}
-
-
-
-template<int dim, int spacedim>
-void
-Triangulation<dim, spacedim>::add_refinement_listener (RefinementListener &listener) const
-{
- refinement_listeners.push_back (&listener);
-}
-
-
-
-template<int dim, int spacedim>
-void
-Triangulation<dim, spacedim>::remove_refinement_listener (RefinementListener &listener) const
-{
- typename std::list<RefinementListener *>::iterator p =
- std::find (refinement_listeners.begin (),
- refinement_listeners.end (),
- &listener);
- Assert (p != refinement_listeners.end (), ExcInternalError ());
- refinement_listeners.erase (p);
-}
-
-
-
-// explicit instantiations
-template class Triangulation<deal_II_dimension>;
-
-#if deal_II_dimension == 1
-template class Triangulation<1,2>;
-
-// this is a hack: we need to instantiate this one function because
-// TriaAccessor<1,1,3> uses it. We could instead instantiate
-// Triangulation<1,3>, but that requires a lot more specializations of
-// functions that currently only exist for <1,1> and <1,2>
-template
-const Boundary<1,3> &
-Triangulation<1,3>::get_boundary (const unsigned int number) const;
-
-#else
-# if deal_II_dimension == 2
-template class Triangulation<2,3>;
-# endif
-#endif
-
-DEAL_II_NAMESPACE_CLOSE
-
--- /dev/null
+//---------------------------------------------------------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 2010 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------------------------------------------------------
+
+
+
+for (deal_II_dimension : DIMENSIONS)
+{
+ template class Triangulation<deal_II_dimension>;
+
+#if deal_II_dimension < 3
+ template class Triangulation<deal_II_dimension,deal_II_dimension+1>;
+#endif
+}
projects / dealii.git / commitdiff