]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Make many functions inline and put them into the header files, but only when optimize...
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Fri, 19 Mar 1999 18:15:19 +0000 (18:15 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Fri, 19 Mar 1999 18:15:19 +0000 (18:15 +0000)
git-svn-id: https://svn.dealii.org/trunk@1026 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/Attic/examples/grid/grid_test.cc
deal.II/deal.II/include/dofs/dof_accessor.h
deal.II/deal.II/include/dofs/dof_accessor.templates.h [new file with mode: 0644]
deal.II/deal.II/include/grid/tria_accessor.h
deal.II/deal.II/include/grid/tria_accessor.templates.h [new file with mode: 0644]
deal.II/deal.II/include/grid/tria_iterator.h
deal.II/deal.II/include/grid/tria_iterator.templates.h
deal.II/deal.II/source/Makefile
deal.II/deal.II/source/dofs/dof_accessor.cc
deal.II/deal.II/source/grid/tria_accessor.cc
tests/big-tests/grid/grid_test.cc

index fe2dd4feff905622e23c33a35c315f33a41e1c8c..f4aa02e899a952817ae7938baf9f85d09a8f3345 100644 (file)
@@ -3,6 +3,7 @@
 
 
 #include <grid/tria_boundary.h>
+#include <grid/tria_accessor.h>
 #include <grid/tria_iterator.h>
 #include <grid/tria.h>
 #include <fstream>
index 6902d0f0fcb2ed23c3241e9e3711db6281a1279e..5c9e04ac887d1a93bf1c90af81697001c1ac78d3 100644 (file)
 #include <vector>
 
 
+// note: in non-debug mode, i.e. with optimizations, the file
+// dof_accessor.templates.h is included at the end of this file.
+// this includes a lot of templates and thus makes compilation
+// slower, but at the same time allows for more aggressive
+// inlining and thus faster code.
+
+
 
 /**
  * Define the basis for accessors to the degrees of freedom.
@@ -805,10 +812,6 @@ class DoFCellAccessor :  public DoFSubstructAccessor<dim> {
     template <typename number>
     void get_interpolated_dof_values (const Vector<number> &values,
                                      Vector<number>       &interpolated_values) const;
-//     void get_interpolated_dof_values (const Vector<double> &values,
-//                                   Vector<double>       &interpolated_values) const;
-//     void get_interpolated_dof_values (const Vector<float> &values,
-//                                   Vector<float>       &interpolated_values) const;
 
                                     /**
                                      * This function is the counterpart to
@@ -907,6 +910,10 @@ class DoFCellAccessor :  public DoFSubstructAccessor<dim> {
 
 
 
+// if in optimized mode: include more templates
+#ifndef DEBUG
+#  include "dof_accessor.templates.h"
+#endif
 
 
 
diff --git a/deal.II/deal.II/include/dofs/dof_accessor.templates.h b/deal.II/deal.II/include/dofs/dof_accessor.templates.h
new file mode 100644 (file)
index 0000000..4ef917f
--- /dev/null
@@ -0,0 +1,394 @@
+/*----------------------------   dof_accessor.templates.h     ---------------------------*/
+/*      $Id$                 */
+#ifndef __dof_accessor_templates_H
+#define __dof_accessor_templates_H
+/*----------------------------   dof_accessor.templates.h     ---------------------------*/
+
+
+#include <grid/dof_accessor.h>
+#include <grid/dof.h>
+#include <grid/dof_levels.h>
+#include <grid/tria_iterator.h>
+#include <grid/tria_iterator.templates.h>
+#include <fe/fe.h>
+
+#include <lac/vector.h>
+#include <lac/fullmatrix.h>
+#include <lac/sparsematrix.h>
+
+#include <vector>
+
+
+/*------------------------- Functions: DoFLineAccessor -----------------------*/
+
+template <int dim, typename BaseClass>
+inline
+int DoFLineAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+                                  // make sure a FE has been selected
+                                  // and enough room was reserved
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (i<dof_handler->selected_fe->dofs_per_line,
+         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_line));
+
+  return dof_handler->levels[present_level]
+    ->line_dofs[present_index*dof_handler->selected_fe->dofs_per_line+i];
+};
+
+
+
+
+template <int dim, typename BaseClass>
+inline
+int DoFLineAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
+                                                     const unsigned int i) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (vertex<2, ExcInvalidIndex (i,0,2));
+  Assert (i<dof_handler->selected_fe->dofs_per_vertex,
+         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_vertex));
+
+  const unsigned int dof_number = (vertex_index(vertex) *
+                                  dof_handler->selected_fe->dofs_per_vertex +
+                                  i);
+  return dof_handler->vertex_dofs[dof_number];
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+void
+DoFLineAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_indices.size() == (2*dof_handler->get_fe().dofs_per_vertex +
+                                dof_handler->get_fe().dofs_per_line),
+         ExcVectorDoesNotMatch());
+
+  const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
+                    dofs_per_line   = dof_handler->get_fe().dofs_per_line;
+  vector<int>::iterator next = dof_indices.begin();
+  for (unsigned int vertex=0; vertex<2; ++vertex)
+    for (unsigned int d=0; d<dofs_per_vertex; ++d)
+      *next++ = vertex_dof_index(vertex,d);
+  for (unsigned int d=0; d<dofs_per_line; ++d)
+    *next++ = dof_index(d);
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+TriaIterator<dim,DoFLineAccessor<dim,BaseClass> >
+DoFLineAccessor<dim,BaseClass>::child (const unsigned int i) const {
+  TriaIterator<dim,DoFLineAccessor<dim,BaseClass> > q (tria,
+                                                      present_level+1,
+                                                      child_index (i),
+                                                      dof_handler);
+  
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+void
+DoFLineAccessor<dim,BaseClass>::copy_from (const DoFLineAccessor<dim,BaseClass> &a) {
+  BaseClass::copy_from (a);
+  set_dof_handler (a.dof_handler);
+};
+
+
+
+
+/*------------------------- Functions: DoFQuadAccessor -----------------------*/
+
+template <int dim, typename BaseClass>
+inline
+int DoFQuadAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+                                  // make sure a FE has been selected
+                                  // and enough room was reserved
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (i<dof_handler->selected_fe->dofs_per_quad,
+         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_quad));
+
+  return dof_handler->levels[present_level]
+    ->quad_dofs[present_index*dof_handler->selected_fe->dofs_per_quad+i];
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+int DoFQuadAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
+                                                     const unsigned int i) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (vertex<4, ExcInvalidIndex (i,0,4));
+  Assert (i<dof_handler->selected_fe->dofs_per_vertex,
+         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_vertex));
+
+  const unsigned int dof_number = (vertex_index(vertex) *
+                                  dof_handler->selected_fe->dofs_per_vertex +
+                                  i);
+  return dof_handler->vertex_dofs[dof_number];
+};
+
+
+  
+template <int dim, typename BaseClass>
+inline
+void
+DoFQuadAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_indices.size() == (4*dof_handler->get_fe().dofs_per_vertex +
+                                4*dof_handler->get_fe().dofs_per_line +
+                                dof_handler->get_fe().dofs_per_quad),
+         ExcVectorDoesNotMatch());
+
+  const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
+                    dofs_per_line   = dof_handler->get_fe().dofs_per_line,
+                    dofs_per_quad   = dof_handler->get_fe().dofs_per_quad;
+  vector<int>::iterator next = dof_indices.begin();
+  for (unsigned int vertex=0; vertex<4; ++vertex)
+    for (unsigned int d=0; d<dofs_per_vertex; ++d)
+      *next++ = vertex_dof_index(vertex,d);
+  for (unsigned int line=0; line<4; ++line)
+    for (unsigned int d=0; d<dofs_per_line; ++d)
+      *next++ = this->line(line)->dof_index(d);
+  for (unsigned int d=0; d<dofs_per_quad; ++d)
+    *next++ = dof_index(d);
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
+DoFQuadAccessor<dim,BaseClass>::line (const unsigned int i) const {
+  Assert (i<4, ExcInvalidIndex (i, 0, 4));
+
+  return TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
+    (
+      tria,
+      present_level,
+      line_index (i),
+      dof_handler
+    );
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+TriaIterator<dim,DoFQuadAccessor<dim,BaseClass> >
+DoFQuadAccessor<dim,BaseClass>::child (const unsigned int i) const {
+  TriaIterator<dim,DoFQuadAccessor<dim,BaseClass> > q (tria,
+                                                      present_level+1,
+                                                      child_index (i),
+                                                      dof_handler);
+  
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+void
+DoFQuadAccessor<dim,BaseClass>::copy_from (const DoFQuadAccessor<dim,BaseClass> &a) {
+  BaseClass::copy_from (a);
+  set_dof_handler (a.dof_handler);
+};
+
+
+
+
+/*------------------------- Functions: DoFHexAccessor -----------------------*/
+
+
+template <int dim, typename BaseClass>
+inline
+int DoFHexAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+                                  // make sure a FE has been selected
+                                  // and enough room was reserved
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (i<dof_handler->selected_fe->dofs_per_hex,
+         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_hex));
+
+  return dof_handler->levels[present_level]
+    ->hex_dofs[present_index*dof_handler->selected_fe->dofs_per_hex+i];
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+int DoFHexAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
+                                                     const unsigned int i) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (vertex<8, ExcInvalidIndex (i,0,8));
+  Assert (i<dof_handler->selected_fe->dofs_per_vertex,
+         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_vertex));
+
+  const unsigned int dof_number = (vertex_index(vertex) *
+                                  dof_handler->selected_fe->dofs_per_vertex +
+                                  i);
+  return dof_handler->vertex_dofs[dof_number];
+};
+
+
+  
+template <int dim, typename BaseClass>
+inline
+void
+DoFHexAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_indices.size() == (8*dof_handler->get_fe().dofs_per_vertex +
+                                12*dof_handler->get_fe().dofs_per_line +
+                                6*dof_handler->get_fe().dofs_per_quad +
+                                dof_handler->get_fe().dofs_per_hex),
+         ExcVectorDoesNotMatch());
+
+  const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
+                    dofs_per_line   = dof_handler->get_fe().dofs_per_line,
+                    dofs_per_quad   = dof_handler->get_fe().dofs_per_quad,
+                    dofs_per_hex    = dof_handler->get_fe().dofs_per_hex;
+  vector<int>::iterator next = dof_indices.begin();
+  for (unsigned int vertex=0; vertex<8; ++vertex)
+    for (unsigned int d=0; d<dofs_per_vertex; ++d)
+      *next++ = vertex_dof_index(vertex,d);
+  for (unsigned int line=0; line<12; ++line)
+    for (unsigned int d=0; d<dofs_per_line; ++d)
+      *next++ = this->line(line)->dof_index(d);
+  for (unsigned int quad=0; quad<6; ++quad)
+    for (unsigned int d=0; d<dofs_per_quad; ++d)
+      *next++ = this->quad(quad)->dof_index(d);
+  for (unsigned int d=0; d<dofs_per_hex; ++d)
+    *next++ = dof_index(d);
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
+DoFHexAccessor<dim,BaseClass>::line (const unsigned int i) const {
+  TriaIterator<dim,LineAccessor<dim> > l = BaseClass::line(i);
+  return TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
+    (
+      tria,
+      present_level,
+      l->index(),
+      dof_handler
+    );
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+TriaIterator<dim,DoFQuadAccessor<dim,QuadAccessor<dim> > >
+DoFHexAccessor<dim,BaseClass>::quad (const unsigned int i) const {
+  Assert (i<6, ExcInvalidIndex (i, 0, 6));
+
+  return TriaIterator<dim,DoFQuadAccessor<dim,QuadAccessor<dim> > >
+    (
+      tria,
+      present_level,
+      quad_index (i),
+      dof_handler
+    );
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+TriaIterator<dim,DoFHexAccessor<dim,BaseClass> >
+DoFHexAccessor<dim,BaseClass>::child (const unsigned int i) const {
+  TriaIterator<dim,DoFHexAccessor<dim,BaseClass> > q (tria,
+                                                     present_level+1,
+                                                     child_index (i),
+                                                     dof_handler);
+  
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+template <int dim, typename BaseClass>
+void DoFHexAccessor<dim,BaseClass>::copy_from (const DoFHexAccessor<dim,BaseClass> &a) {
+  BaseClass::copy_from (a);
+  set_dof_handler (a.dof_handler);
+};
+
+
+
+
+/*------------------------- Functions: DoFCellAccessor -----------------------*/
+
+
+template <int dim>
+inline
+TriaIterator<dim,DoFCellAccessor<dim> >
+DoFCellAccessor<dim>::neighbor (const unsigned int i) const {
+  TriaIterator<dim,DoFCellAccessor<dim> > q (tria,
+                                            neighbor_level (i),
+                                            neighbor_index (i),
+                                            dof_handler);
+  
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsNeighbor());
+#endif
+  return q;
+};
+
+
+
+template <int dim>
+inline
+TriaIterator<dim,DoFCellAccessor<dim> >
+DoFCellAccessor<dim>::child (const unsigned int i) const {
+  TriaIterator<dim,DoFCellAccessor<dim> > q (tria,
+                                            present_level+1,
+                                            child_index (i),
+                                            dof_handler);
+  
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+
+
+
+
+/*----------------------------   dof_accessor.templates.h     ---------------------------*/
+/* end of #ifndef __dof_accessor_templates_H */
+#endif
+/*----------------------------   dof_accessor.templates.h     ---------------------------*/
index 35fbf9bcb442effee9a904c2f46b15ad287c7c9e..b2edfc5653f937b8e2e8939f626ba319c2bb2b95 100644 (file)
@@ -9,20 +9,18 @@
 #include <base/exceptions.h>
 #include <base/forward-declarations.h>
 #include <basic/forward-declarations.h>
+#include <grid/tria_iterator_base.h>
 
 
+// note: in non-debug mode, i.e. with optimizations, the file
+// tria_accessor.templates.h is included at the end of this file.
+// this includes a lot of templates and thus makes compilation
+// slower, but at the same time allows for more aggressive
+// inlining and thus faster code.
 
 
 
 
-/**
- *   The three states an iterator can be in: valid, past-the-end and
- *   invalid.
- */
-enum IteratorState { valid, past_the_end, invalid };
-
-
-
 
 
 /**
@@ -1280,6 +1278,11 @@ class TriaSubstructAccessor;
 template <>
 class TriaSubstructAccessor<1> :  public LineAccessor<1> {
   public:
+                                    /**
+                                     * Propagate the AccessorData type
+                                     * into the present class.
+                                     */
+    typedef typename LineAccessor<1>::AccessorData AccessorData;
                                     /**
                                      * Constructor
                                      */
@@ -1308,6 +1311,11 @@ class TriaSubstructAccessor<1> :  public LineAccessor<1> {
 template <>
 class TriaSubstructAccessor<2> : public QuadAccessor<2> {
   public:
+                                    /**
+                                     * Propagate the AccessorData type
+                                     * into the present class.
+                                     */
+    typedef typename QuadAccessor<2>::AccessorData AccessorData;
                                     /**
                                      * Constructor
                                      */
@@ -1337,6 +1345,12 @@ class TriaSubstructAccessor<2> : public QuadAccessor<2> {
 template <>
 class TriaSubstructAccessor<3> : public HexAccessor<3> {
   public:
+                                    /**
+                                     * Propagate the AccessorData type
+                                     * into the present class.
+                                     */
+    typedef typename HexAccessor<3>::AccessorData AccessorData;
+    
                                     /**
                                      * Constructor
                                      */
@@ -1377,6 +1391,12 @@ class TriaSubstructAccessor<3> : public HexAccessor<3> {
 template <int dim>
 class CellAccessor :  public TriaSubstructAccessor<dim> {
   public:
+                                    /**
+                                     * Propagate the AccessorData type
+                                     * into the present class.
+                                     */
+    typedef typename TriaSubstructAccessor<dim>::AccessorData AccessorData;
+    
                                     /**
                                      *  Constructor.
                                      */
@@ -1536,11 +1556,18 @@ class CellAccessor :  public TriaSubstructAccessor<dim> {
 
 
 
-
-
+// if in optimized mode: include more templates
+#ifndef DEBUG
+#  include "tria_accessor.templates.h"
+#endif
 
 
 /*----------------------------   tria_accessor.h     ---------------------------*/
 /* end of #ifndef __tria_accessor_H */
 #endif
 /*----------------------------   tria_accessor.h     ---------------------------*/
+
+
+
+
+
diff --git a/deal.II/deal.II/include/grid/tria_accessor.templates.h b/deal.II/deal.II/include/grid/tria_accessor.templates.h
new file mode 100644 (file)
index 0000000..6035ebf
--- /dev/null
@@ -0,0 +1,747 @@
+/*----------------------------   tria_accessor.templates.h     ---------------------------*/
+/*      $Id$                 */
+#ifndef __tria_accessor_templates_H
+#define __tria_accessor_templates_H
+/*----------------------------   tria_accessor.templates.h     ---------------------------*/
+
+
+#include <grid/tria.h>
+#include <grid/tria_levels.h>
+#include <grid/tria_iterator.h>
+#include <grid/tria_accessor.h>
+#include <grid/tria_iterator.templates.h>
+#include <grid/geometry_info.h>
+
+#include <cmath>
+
+
+/*------------------------ Functions: TriaAccessor ---------------------------*/
+
+
+template <int dim>
+inline
+void
+TriaAccessor<dim>::copy_from (const TriaAccessor<dim> &a) {
+  present_level = a.present_level;
+  present_index = a.present_index;
+  tria = a.tria;
+};
+
+
+template <int dim>
+inline
+bool
+TriaAccessor<dim>::operator == (const TriaAccessor<dim> &a) const {
+  Assert (tria == a.tria, ExcCantCompareIterators());
+  return ((present_index == a.present_index) &&
+         (present_level == a.present_level));
+};
+
+
+
+template <int dim>
+inline
+bool
+TriaAccessor<dim>::operator != (const TriaAccessor<dim> &a) const {
+  Assert (tria == a.tria, ExcCantCompareIterators());
+  return ((present_index != a.present_index) ||
+         (present_level != a.present_level));
+};
+
+
+
+template <int dim>
+inline
+int
+TriaAccessor<dim>::level () const {
+  return present_level;
+};
+
+
+  
+template <int dim>
+inline
+int
+TriaAccessor<dim>::index () const {
+  return present_index;
+};
+  
+
+
+template <int dim>
+inline
+IteratorState
+TriaAccessor<dim>::state () const {
+  if ((present_level>=0) && (present_index>=0))
+    return valid;
+  else
+    if ((present_level==-1) && (present_index==-1))
+      return past_the_end;
+    else
+      return invalid;
+};
+
+
+
+/*------------------------ Functions: LineAccessor ---------------------------*/
+
+
+
+
+template <int dim>
+inline
+bool
+LineAccessor<dim>::used () const {
+  Assert (state() == valid, ExcDereferenceInvalidObject());
+  return tria->levels[present_level]->lines.used[present_index];
+};
+
+
+
+
+template <int dim>
+inline
+bool
+LineAccessor<dim>::user_flag_set () const {
+  Assert (used(), ExcCellNotUsed());
+  return tria->levels[present_level]->lines.user_flags[present_index];
+};
+
+
+
+template <int dim>
+inline
+void
+LineAccessor<dim>::set_user_flag () const {
+  Assert (used(), ExcCellNotUsed());
+  tria->levels[present_level]->lines.user_flags[present_index] = true;
+};
+
+
+
+template <int dim>
+inline
+void
+LineAccessor<dim>::clear_user_flag () const {
+  Assert (used(), ExcCellNotUsed());
+  tria->levels[present_level]->lines.user_flags[present_index] = false;
+};
+
+
+
+
+template <int dim>
+inline
+TriaIterator<dim,LineAccessor<dim> >
+LineAccessor<dim>::child (const unsigned int i) const {
+  Assert (i<2, ExcInvalidIndex(i,0,1));
+  
+  TriaIterator<dim,LineAccessor<dim> > q (tria, present_level+1, child_index (i));
+  
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+template <int dim>
+inline
+int
+LineAccessor<dim>::child_index (unsigned int i) const {
+  Assert (i<2, ExcInvalidIndex(i,0,1));
+  return tria->levels[present_level]->lines.children[present_index]+i;
+};
+
+
+
+
+template <int dim>
+inline
+bool
+LineAccessor<dim>::has_children () const {
+  Assert (state() == valid, ExcDereferenceInvalidObject());
+  return (tria->levels[present_level]->lines.children[present_index] != -1);
+}
+
+
+
+template <int dim>
+inline
+void
+LineAccessor<dim>::operator ++ () {
+  ++present_index;
+                                  // is index still in the range of
+                                  // the vector?
+  while (present_index
+        >=
+        (int)tria->levels[present_level]->lines.lines.size())
+    {
+                                      // no -> go one level up until we find
+                                      // one with more than zero cells
+      ++present_level;
+      present_index = 0;
+                                      // highest level reached?
+      if (present_level >= (int)tria->levels.size()) 
+       {
+                                          // return with past the end pointer
+         present_level = present_index = -1;
+         return;
+       };
+    };
+};
+
+
+
+template <int dim>
+inline
+void
+LineAccessor<dim>::operator -- () {
+  --present_index;
+                                  // is index still in the range of
+                                  // the vector?
+  while (present_index < 0) 
+    {
+                                      // no -> go one level down
+      --present_level;
+                                      // lowest level reached?
+      if (present_level == -1) 
+       {
+                                          // return with past the end pointer
+         present_level = present_index = -1;
+         return;
+       };
+                                      // else
+      present_index = tria->levels[present_level]->lines.lines.size()-1;
+    };
+};
+
+
+
+
+/*------------------------ Functions: QuadAccessor ---------------------------*/
+
+
+
+template <int dim>
+inline
+bool
+QuadAccessor<dim>::used () const {
+  Assert (state() == valid, ExcDereferenceInvalidObject());
+  return tria->levels[present_level]->quads.used[present_index];
+};
+
+
+
+
+template <int dim>
+inline
+bool
+QuadAccessor<dim>::user_flag_set () const {
+  Assert (used(), ExcCellNotUsed());
+  return tria->levels[present_level]->quads.user_flags[present_index];
+};
+
+
+
+template <int dim>
+inline
+void
+QuadAccessor<dim>::set_user_flag () const {
+  Assert (used(), ExcCellNotUsed());
+  tria->levels[present_level]->quads.user_flags[present_index] = true;
+};
+
+
+
+template <int dim>
+inline
+void
+QuadAccessor<dim>::clear_user_flag () const {
+  Assert (used(), ExcCellNotUsed());
+  tria->levels[present_level]->quads.user_flags[present_index] = false;
+};
+
+
+
+
+template <int dim>
+inline
+TriaIterator<dim,LineAccessor<dim> >
+QuadAccessor<dim>::line (const unsigned int i) const {
+  return
+    TriaIterator<dim,LineAccessor<dim> >
+    (
+      tria,
+      present_level,
+      line_index (i)
+    );
+};
+
+
+
+template <int dim>
+inline
+unsigned int
+QuadAccessor<dim>::line_index (unsigned int i) const {
+  Assert (i<4, ExcInvalidIndex(i,0,3));
+
+  return tria->levels[present_level]->quads.quads[present_index].line(i);
+};
+
+
+
+template <int dim>
+inline
+TriaIterator<dim,QuadAccessor<dim> >
+QuadAccessor<dim>::child (const unsigned int i) const {
+  Assert (i<4, ExcInvalidIndex(i,0,3));
+  
+  TriaIterator<dim,QuadAccessor<dim> > q (tria, present_level+1, child_index (i));
+  
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+template <int dim>
+inline
+int QuadAccessor<dim>::child_index (unsigned int i) const {
+  Assert (i<4, ExcInvalidIndex(i,0,3));
+  return tria->levels[present_level]->quads.children[present_index]+i;
+};
+
+
+
+
+template <int dim>
+inline
+bool
+QuadAccessor<dim>::has_children () const {
+  Assert (state() == valid, ExcDereferenceInvalidObject());
+  return (tria->levels[present_level]->quads.children[present_index] != -1);
+};
+
+
+
+template <int dim>
+inline
+void
+QuadAccessor<dim>::operator ++ () {
+  ++present_index;
+                                  // is index still in the range of
+                                  // the vector?
+  while (present_index
+        >=
+        (int)tria->levels[present_level]->quads.quads.size()) 
+    {
+                                      // no -> go one level up
+      ++present_level;
+      present_index = 0;
+                                      // highest level reached?
+      if (present_level >= (int)tria->levels.size()) 
+       {
+                                          // return with past the end pointer
+         present_level = present_index = -1;
+         return;
+       };
+    };
+};
+
+
+
+template <int dim>
+inline
+void
+QuadAccessor<dim>::operator -- () {
+  --present_index;
+                                  // is index still in the range of
+                                  // the vector?
+  while (present_index < 0) 
+    {
+                                      // no -> go one level down
+      --present_level;
+                                      // lowest level reached?
+      if (present_level == -1) 
+       {
+                                          // return with past the end pointer
+         present_level = present_index = -1;
+         return;
+       };
+                                      // else
+      present_index = tria->levels[present_level]->quads.quads.size()-1;
+    };
+};
+
+
+
+
+/*------------------------ Functions: HexAccessor ---------------------------*/
+
+
+
+template <int dim>
+inline
+bool
+HexAccessor<dim>::used () const {
+  Assert (state() == valid, ExcDereferenceInvalidObject());
+  return tria->levels[present_level]->hexes.used[present_index];
+};
+
+
+
+template <int dim>
+inline
+bool
+HexAccessor<dim>::user_flag_set () const {
+  Assert (used(), ExcCellNotUsed());
+  return tria->levels[present_level]->hexes.user_flags[present_index];
+};
+
+
+
+template <int dim>
+inline
+void
+HexAccessor<dim>::set_user_flag () const {
+  Assert (used(), ExcCellNotUsed());
+  tria->levels[present_level]->hexes.user_flags[present_index] = true;
+};
+
+
+
+template <int dim>
+inline
+void HexAccessor<dim>::clear_user_flag () const {
+  Assert (used(), ExcCellNotUsed());
+  tria->levels[present_level]->hexes.user_flags[present_index] = false;
+};
+
+
+
+
+template <int dim>
+inline
+TriaIterator<dim,LineAccessor<dim> >
+HexAccessor<dim>::line (const unsigned int i) const {
+  Assert (used(), ExcCellNotUsed());
+  Assert (i<12, ExcInvalidIndex (i,0,11));
+  
+  if (i<4)
+    return quad(0)->line(i);
+  else
+    if (i<8)
+      return quad(1)->line(i-4);
+    else
+      switch (i) 
+       {
+         case 8:
+               return quad(2)->line(3);
+         case 9:
+               return quad(2)->line(1);
+         case 10:
+               return quad(4)->line(1);
+         case 11:
+               return quad(4)->line(3);
+       };
+  Assert (false, ExcInvalidIndex(i,0,11));
+  return TriaIterator<dim,LineAccessor<dim> >(tria, -1, -1, 0);
+};
+
+
+
+template <int dim>
+inline
+TriaIterator<dim,QuadAccessor<dim> >
+HexAccessor<dim>::quad (const unsigned int i) const {
+  Assert (used(), ExcCellNotUsed());
+  return
+    TriaIterator<dim,QuadAccessor<dim> >
+    (
+      tria,
+      present_level,
+      quad_index (i)
+    );
+};
+
+
+
+template <int dim>
+inline
+unsigned int
+HexAccessor<dim>::quad_index (unsigned int i) const {
+  Assert (i<6, ExcInvalidIndex(i,0,5));
+
+  return tria->levels[present_level]->hexes.hexes[present_index].quad(i);
+};
+
+
+
+template <int dim>
+inline
+TriaIterator<dim,HexAccessor<dim> >
+HexAccessor<dim>::child (const unsigned int i) const {
+  Assert (i<6, ExcInvalidIndex(i,0,5));
+  
+  TriaIterator<dim,HexAccessor<dim> > q (tria, present_level+1, child_index (i));
+  
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+template <int dim>
+inline
+int HexAccessor<dim>::child_index (unsigned int i) const {
+  Assert (i<8, ExcInvalidIndex(i,0,7));
+  return tria->levels[present_level]->hexes.children[present_index]+i;
+};
+
+
+
+
+template <int dim>
+inline
+void
+HexAccessor<dim>::operator ++ () {
+  ++present_index;
+                                  // is index still in the range of
+                                  // the vector?
+  while (present_index
+        >=
+        (int)tria->levels[present_level]->hexes.hexes.size()) 
+    {
+                                      // no -> go one level up
+      ++present_level;
+      present_index = 0;
+                                      // highest level reached?
+      if (present_level >= (int)tria->levels.size()) 
+       {
+                                          // return with past the end pointer
+         present_level = present_index = -1;
+         return;
+       };
+    };
+};
+
+
+
+template <int dim>
+inline
+void
+HexAccessor<dim>::operator -- () {
+  --present_index;
+                                  // is index still in the range of
+                                  // the vector?
+  while (present_index < 0) 
+    {
+                                      // no -> go one level down
+      --present_level;
+                                      // lowest level reached?
+      if (present_level == -1) 
+       {
+                                          // return with past the end pointer
+         present_level = present_index = -1;
+         return;
+       };
+                                      // else
+      present_index = tria->levels[present_level]->hexes.hexes.size()-1;
+    };
+};
+
+
+
+
+/*------------------------ Functions: CellAccessor<dim> -----------------------*/
+
+
+template <>
+inline
+Triangulation<1>::face_iterator
+CellAccessor<1>::face (const unsigned int) const {
+  Assert (false, ExcNotUsefulForThisDimension());
+  return 0;
+};
+
+
+
+template <>
+inline
+Triangulation<2>::face_iterator
+CellAccessor<2>::face (const unsigned int i) const {
+  return line(i);
+};
+
+
+
+template <>
+inline
+Triangulation<3>::face_iterator
+CellAccessor<3>::face (const unsigned int i) const {
+  return quad(i);
+};
+
+
+
+template <int dim>
+inline
+int
+CellAccessor<dim>::neighbor_index (const unsigned int i) const {
+  Assert (i<GeometryInfo<dim>::faces_per_cell,
+         typename TriaSubstructAccessor<dim>::ExcInvalidNeighbor(i));
+  return tria->levels[present_level]->
+    neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].second;
+};
+
+
+
+template <int dim>
+inline
+int
+CellAccessor<dim>::neighbor_level (const unsigned int i) const {
+  Assert (i<GeometryInfo<dim>::faces_per_cell,
+         typename TriaSubstructAccessor<dim>::ExcInvalidNeighbor(i));
+  return tria->levels[present_level]->
+    neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].first;
+};
+
+
+
+
+template <int dim>
+inline
+bool
+CellAccessor<dim>::refine_flag_set () const {
+  Assert (used(), typename TriaSubstructAccessor<dim>::ExcCellNotUsed());
+                                  // cells flagged for refinement must be active
+                                  // (the #set_refine_flag# function checks this,
+                                  // but activity may change when refinement is
+                                  // executed and for some reason the refine
+                                  // flag is not cleared).
+  Assert (active() ||  !tria->levels[present_level]->refine_flags[present_index],
+         ExcRefineCellNotActive());
+  return tria->levels[present_level]->refine_flags[present_index];
+};
+
+
+
+template <int dim>
+inline
+void
+CellAccessor<dim>::set_refine_flag () const {
+  Assert (used() && active(), ExcRefineCellNotActive());
+  Assert (!coarsen_flag_set(), ExcCellFlaggedForCoarsening());
+  
+  tria->levels[present_level]->refine_flags[present_index] = true;
+};
+
+
+
+template <int dim>
+inline
+void
+CellAccessor<dim>::clear_refine_flag () const {
+  Assert (used() && active(), ExcRefineCellNotActive());
+  tria->levels[present_level]->refine_flags[present_index] = false;
+};
+
+
+
+template <int dim>
+inline
+bool
+CellAccessor<dim>::coarsen_flag_set () const {
+  Assert (used(), typename TriaSubstructAccessor<dim>::ExcCellNotUsed());
+                                  // cells flagged for coarsening must be active
+                                  // (the #set_refine_flag# function checks this,
+                                  // but activity may change when refinement is
+                                  // executed and for some reason the refine
+                                  // flag is not cleared).
+  Assert (active() ||  !tria->levels[present_level]->coarsen_flags[present_index],
+         ExcRefineCellNotActive());
+  return tria->levels[present_level]->coarsen_flags[present_index];
+};
+
+
+
+template <int dim>
+inline
+void
+CellAccessor<dim>::set_coarsen_flag () const {
+  Assert (used() && active(), ExcRefineCellNotActive());
+  Assert (!refine_flag_set(), ExcCellFlaggedForRefinement());
+  
+  tria->levels[present_level]->coarsen_flags[present_index] = true;
+};
+
+
+
+template <int dim>
+inline
+void
+CellAccessor<dim>::clear_coarsen_flag () const {
+  Assert (used() && active(), ExcRefineCellNotActive());
+  tria->levels[present_level]->coarsen_flags[present_index] = false;
+};
+
+
+
+template <int dim>
+inline
+TriaIterator<dim,CellAccessor<dim> >
+CellAccessor<dim>::neighbor (const unsigned int i) const {
+  TriaIterator<dim,CellAccessor<dim> > q (tria, neighbor_level (i), neighbor_index (i));
+
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(),
+           typename TriaSubstructAccessor<dim>::ExcUnusedCellAsNeighbor());
+#endif
+  return q;
+};
+
+
+
+template <int dim>
+inline
+TriaIterator<dim,CellAccessor<dim> >
+CellAccessor<dim>::child (const unsigned int i) const {
+  TriaIterator<dim,CellAccessor<dim> > q (tria, present_level+1, child_index (i));
+
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(),
+           typename TriaSubstructAccessor<dim>::ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+template <int dim>
+inline
+bool
+CellAccessor<dim>::active () const {
+  return !has_children();
+};
+
+
+
+
+
+
+/*----------------------------   tria_accessor.templates.h     ---------------------------*/
+/* end of #ifndef __tria_accessor_templates_H */
+#endif
+/*----------------------------   tria_accessor.templates.h     ---------------------------*/
index 5e7ef319e3b7109d1d314cae4082cede25a119d7..71f6e77fb80c005613625d11329ae88bedb81aa3 100644 (file)
 #include <iostream>
 #include <base/exceptions.h>
 #include <base/point.h>
-#include <grid/tria_accessor.h>
-
+#include <grid/tria_iterator_base.h>
+//#include <grid/tria_accessor.h>
 
+// note: in non-debug mode, i.e. with optimizations, the file
+// tria_iterator.templates.h is included at the end of this file.
+// this includes a lot of templates and thus makes compilation
+// slower, but at the same time allows for more aggressive
+// inlining and thus faster code.
 
 
 
@@ -1010,6 +1015,12 @@ ostream & operator << (ostream &out, const TriaActiveIterator<dim,Accessor> &i)
 
 
 
+// if in optimized mode: include more templates
+#ifndef DEBUG
+#  include "tria_iterator.templates.h"
+#endif
+
+
 /*----------------------------   tria-iterator.h     ---------------------------*/
 /* end of #ifndef __tria_iterator_H */
 #endif
index 7dce8b431ce4f528a0348b52a6b0db84ced801e1..a70ed1a0dfdb230f494629092e20018555fcabc2 100644 (file)
@@ -1,5 +1,9 @@
-/* $Id$ */
-/*      Copyright W. Bangerth, University of Heidelberg, 1998 */
+/*----------------------------   tria_iterator.templates.h     ---------------------------*/
+/*      Copyright W. Bangerth, University of Heidelberg, 1998                             */
+/*      $Id$                 */
+#ifndef __tria_iterator_templates_H
+#define __tria_iterator_templates_H
+/*----------------------------   tria_iterator.templates.h     ---------------------------*/
 
 #include <grid/tria.h>
 #include <grid/tria_iterator.h>
 
 
 template <int dim, typename Accessor>
+inline
 TriaRawIterator<dim,Accessor>::TriaRawIterator () :
                accessor (0, -2, -2, 0) {};
 
 
 
 template <int dim, typename Accessor>
+inline
 TriaRawIterator<dim,Accessor>::TriaRawIterator (const TriaRawIterator<dim,Accessor> &i) :
                accessor (i.accessor) {};
 
 
 
 template <int dim, typename Accessor>
+inline
 TriaRawIterator<dim,Accessor>::TriaRawIterator (Triangulation<dim> *parent,
                                                const int           level,
                                                const int           index,
@@ -37,6 +44,7 @@ TriaRawIterator<dim,Accessor>::TriaRawIterator (Triangulation<dim> *parent,
 
 
 template <int dim, typename Accessor>
+inline
 TriaRawIterator<dim,Accessor> &
 TriaRawIterator<dim,Accessor>::operator = (const TriaRawIterator<dim,Accessor> &i) {
   accessor.copy_from (i.accessor);
@@ -47,6 +55,7 @@ TriaRawIterator<dim,Accessor>::operator = (const TriaRawIterator<dim,Accessor> &
 
 
 template <int dim, typename Accessor>
+inline
 bool
 TriaRawIterator<dim,Accessor>::operator == (const TriaRawIterator<dim,Accessor> &i) const {
   return accessor == i.accessor;
@@ -55,6 +64,7 @@ TriaRawIterator<dim,Accessor>::operator == (const TriaRawIterator<dim,Accessor>
 
 
 template <int dim, typename Accessor>
+inline
 bool
 TriaRawIterator<dim,Accessor>::operator != (const TriaRawIterator<dim,Accessor> &i) const {
   return accessor != i.accessor;
@@ -63,7 +73,9 @@ TriaRawIterator<dim,Accessor>::operator != (const TriaRawIterator<dim,Accessor>
 
 
 template <int dim, typename Accessor>
-TriaRawIterator<dim,Accessor> TriaRawIterator<dim,Accessor>::operator ++ (int) {
+inline
+TriaRawIterator<dim,Accessor>
+TriaRawIterator<dim,Accessor>::operator ++ (int) {
   TriaRawIterator<dim,Accessor> tmp(*this);
   operator++ ();
   
@@ -73,7 +85,9 @@ TriaRawIterator<dim,Accessor> TriaRawIterator<dim,Accessor>::operator ++ (int) {
 
 
 template <int dim, typename Accessor>
-TriaRawIterator<dim,Accessor> TriaRawIterator<dim,Accessor>::operator -- (int) {
+inline
+TriaRawIterator<dim,Accessor>
+TriaRawIterator<dim,Accessor>::operator -- (int) {
   TriaRawIterator<dim,Accessor> tmp(*this);
   operator-- ();
   
@@ -87,11 +101,13 @@ TriaRawIterator<dim,Accessor> TriaRawIterator<dim,Accessor>::operator -- (int) {
 
 
 template <int dim, typename Accessor>
+inline
 TriaIterator<dim,Accessor>::TriaIterator () :
                TriaRawIterator<dim,Accessor> () {};
 
 
 template <int dim, typename Accessor>
+inline
 TriaIterator<dim,Accessor>::
 TriaIterator (const TriaIterator<dim,Accessor> &i) :
                TriaRawIterator<dim,Accessor> (static_cast<TriaRawIterator<dim,Accessor> >(i)) {};
@@ -99,6 +115,7 @@ TriaIterator (const TriaIterator<dim,Accessor> &i) :
 
 
 template <int dim, typename Accessor>
+inline
 TriaIterator<dim,Accessor>::
 TriaIterator (const TriaRawIterator<dim,Accessor> &i) :
                TriaRawIterator<dim,Accessor> (i)
@@ -119,6 +136,7 @@ TriaIterator (const TriaRawIterator<dim,Accessor> &i) :
 
 
 template <int dim, typename Accessor>
+inline
 TriaIterator<dim,Accessor>::TriaIterator (Triangulation<dim> *parent,
                                          const int           level,
                                          const int           index,
@@ -141,6 +159,7 @@ TriaIterator<dim,Accessor>::TriaIterator (Triangulation<dim> *parent,
 
 
 template <int dim, typename Accessor>
+inline
 TriaIterator<dim,Accessor> &
 TriaIterator<dim,Accessor>::operator = (const TriaIterator<dim,Accessor> &i) {
   accessor.copy_from (i.accessor);
@@ -149,6 +168,7 @@ TriaIterator<dim,Accessor>::operator = (const TriaIterator<dim,Accessor> &i) {
 
 
 template <int dim, typename Accessor>
+inline
 TriaIterator<dim,Accessor> &
 TriaIterator<dim,Accessor>::operator = (const TriaRawIterator<dim,Accessor> &i) {
   accessor.copy_from (i.accessor);
@@ -169,6 +189,7 @@ TriaIterator<dim,Accessor>::operator = (const TriaRawIterator<dim,Accessor> &i)
 
 
 template <int dim, typename Accessor>
+inline
 TriaIterator<dim,Accessor> & TriaIterator<dim,Accessor>::operator ++ () {
   while (TriaRawIterator<dim,Accessor>::operator++(),
         (state() == valid))
@@ -180,6 +201,7 @@ TriaIterator<dim,Accessor> & TriaIterator<dim,Accessor>::operator ++ () {
 
 
 template <int dim, typename Accessor>
+inline
 TriaIterator<dim,Accessor>  TriaIterator<dim,Accessor>::operator ++ (int) {
   TriaIterator<dim,Accessor> tmp(*this);
   operator++ ();
@@ -190,7 +212,9 @@ TriaIterator<dim,Accessor>  TriaIterator<dim,Accessor>::operator ++ (int) {
 
 
 template <int dim, typename Accessor>
-TriaIterator<dim,Accessor> & TriaIterator<dim,Accessor>::operator -- () {
+inline
+TriaIterator<dim,Accessor> &
+TriaIterator<dim,Accessor>::operator -- () {
   while (TriaRawIterator<dim,Accessor>::operator--(),
         (state() == valid))
     if (accessor.used() == true)
@@ -200,7 +224,9 @@ TriaIterator<dim,Accessor> & TriaIterator<dim,Accessor>::operator -- () {
 
 
 template <int dim, typename Accessor>
-TriaIterator<dim,Accessor>  TriaIterator<dim,Accessor>::operator -- (int) {
+inline
+TriaIterator<dim,Accessor>
+TriaIterator<dim,Accessor>::operator -- (int) {
   TriaIterator<dim,Accessor> tmp(*this);
   operator-- ();
   
@@ -213,12 +239,14 @@ TriaIterator<dim,Accessor>  TriaIterator<dim,Accessor>::operator -- (int) {
 
 
 template <int dim, typename Accessor>
+inline
 TriaActiveIterator<dim,Accessor>::TriaActiveIterator () :
                TriaIterator<dim,Accessor> () {};
 
 
 
 template <int dim, typename Accessor>
+inline
 TriaActiveIterator<dim,Accessor>::
 TriaActiveIterator (const TriaActiveIterator<dim,Accessor> &i) :
                TriaIterator<dim,Accessor> (static_cast<TriaIterator<dim,Accessor> >(i)) {};
@@ -226,6 +254,7 @@ TriaActiveIterator (const TriaActiveIterator<dim,Accessor> &i) :
 
 
 template <int dim, typename Accessor>
+inline
 TriaActiveIterator<dim,Accessor>::
 TriaActiveIterator (const TriaRawIterator<dim,Accessor> &i) :
                TriaIterator<dim,Accessor> (i)
@@ -245,6 +274,7 @@ TriaActiveIterator (const TriaRawIterator<dim,Accessor> &i) :
 
 
 template <int dim, typename Accessor>
+inline
 TriaActiveIterator<dim,Accessor>::
 TriaActiveIterator (const TriaIterator<dim,Accessor> &i) :
                TriaIterator<dim,Accessor> (i)
@@ -265,6 +295,7 @@ TriaActiveIterator (const TriaIterator<dim,Accessor> &i) :
 
 
 template <int dim, typename Accessor>
+inline
 TriaActiveIterator<dim,Accessor>::TriaActiveIterator (Triangulation<dim> *parent,
                                                      const int           level,
                                                      const int           index,
@@ -287,6 +318,7 @@ TriaActiveIterator<dim,Accessor>::TriaActiveIterator (Triangulation<dim> *parent
 
 
 template <int dim, typename Accessor>
+inline
 TriaActiveIterator<dim,Accessor> &
 TriaActiveIterator<dim,Accessor>::operator = (const TriaActiveIterator<dim,Accessor> &i) {
   accessor.copy_from (i.accessor);
@@ -296,6 +328,7 @@ TriaActiveIterator<dim,Accessor>::operator = (const TriaActiveIterator<dim,Acces
 
 
 template <int dim, typename Accessor>
+inline
 TriaActiveIterator<dim,Accessor> &
 TriaActiveIterator<dim,Accessor>::operator = (const TriaRawIterator<dim,Accessor> &i) {
   accessor.copy_from (i.accessor);
@@ -316,6 +349,7 @@ TriaActiveIterator<dim,Accessor>::operator = (const TriaRawIterator<dim,Accessor
 
 
 template <int dim, typename Accessor>
+inline
 TriaActiveIterator<dim,Accessor> &
 TriaActiveIterator<dim,Accessor>::operator = (const TriaIterator<dim,Accessor> &i) {
   accessor.copy_from (i.accessor);
@@ -336,7 +370,9 @@ TriaActiveIterator<dim,Accessor>::operator = (const TriaIterator<dim,Accessor> &
 
 
 template <int dim, typename Accessor>
-TriaActiveIterator<dim,Accessor> & TriaActiveIterator<dim,Accessor>::operator ++ () {
+inline
+TriaActiveIterator<dim,Accessor> &
+TriaActiveIterator<dim,Accessor>::operator ++ () {
   while (TriaIterator<dim,Accessor>::operator++(),
         (state() == valid))
     if (accessor.has_children() == false)
@@ -347,7 +383,9 @@ TriaActiveIterator<dim,Accessor> & TriaActiveIterator<dim,Accessor>::operator ++
 
 
 template <int dim, typename Accessor>
-TriaActiveIterator<dim,Accessor> TriaActiveIterator<dim,Accessor>::operator ++ (int) {
+inline
+TriaActiveIterator<dim,Accessor>
+TriaActiveIterator<dim,Accessor>::operator ++ (int) {
   TriaActiveIterator<dim,Accessor> tmp(*this);
   operator++ ();
   
@@ -357,7 +395,9 @@ TriaActiveIterator<dim,Accessor> TriaActiveIterator<dim,Accessor>::operator ++ (
 
 
 template <int dim, typename Accessor>
-TriaActiveIterator<dim,Accessor> & TriaActiveIterator<dim,Accessor>::operator -- () {
+inline
+TriaActiveIterator<dim,Accessor> &
+TriaActiveIterator<dim,Accessor>::operator -- () {
   while (TriaIterator<dim,Accessor>::operator--(),
         (state() == valid))
     if (accessor.has_children() == false)
@@ -368,6 +408,7 @@ TriaActiveIterator<dim,Accessor> & TriaActiveIterator<dim,Accessor>::operator --
 
 
 template <int dim, typename Accessor>
+inline
 TriaActiveIterator<dim,Accessor> TriaActiveIterator<dim,Accessor>::operator -- (int) {
   TriaActiveIterator<dim,Accessor> tmp(*this);
   operator-- ();
@@ -378,8 +419,7 @@ TriaActiveIterator<dim,Accessor> TriaActiveIterator<dim,Accessor>::operator -- (
 
 
 
-
-
-
-
-
+/*----------------------------   tria_iterator.templates.h     ---------------------------*/
+/* end of #ifndef __tria_iterator_templates_H */
+#endif
+/*----------------------------   tria_iterator.templates.h     ---------------------------*/
index 639e8e4192e5c0d96f4e6ff2bc141ceab99b494c..12db3c5ef6f81c8d7769d33c2606029c0af8e7e3 100644 (file)
@@ -173,6 +173,7 @@ ifneq (1,${recursive-make-fwd-decl})
                | perl -pe 's!(\.\./lib/2d/[^ ]+)_DIM_PLACEHOLDER!$$1_2d!g;' \
                | perl -pe 's!(\.\./lib/3d/[^ ]+)_DIM_PLACEHOLDER!$$1_3d!g;' \
                >> ../lib/Makefile.dep
+       @echo ============================ Done
 else
        @echo ============================ Not remaking Makefile since in nested mode
 endif
index 31afbea681edc2a973e0929e3736526dde852446..33787933cdc46fc55a091c9761a6688f86a5bd09 100644 (file)
@@ -4,6 +4,7 @@
 
 
 #include <grid/dof_accessor.h>
+#include <grid/dof_accessor.templates.h>
 #include <grid/dof.h>
 #include <grid/dof_levels.h>
 #include <grid/tria_iterator.h>
 /*------------------------- Functions: DoFLineAccessor -----------------------*/
 
 
-template <int dim, typename BaseClass>
-inline
-int DoFLineAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-                                  // make sure a FE has been selected
-                                  // and enough room was reserved
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
-  Assert (i<dof_handler->selected_fe->dofs_per_line,
-         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_line));
-
-  return dof_handler->levels[present_level]
-    ->line_dofs[present_index*dof_handler->selected_fe->dofs_per_line+i];
-};
-
-
-
-
 
 template <int dim, typename BaseClass>
 void DoFLineAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
@@ -58,24 +42,6 @@ void DoFLineAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
 
 
 
-template <int dim, typename BaseClass>
-inline
-int DoFLineAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
-                                                     const unsigned int i) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
-  Assert (vertex<2, ExcInvalidIndex (i,0,2));
-  Assert (i<dof_handler->selected_fe->dofs_per_vertex,
-         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_vertex));
-
-  const unsigned int dof_number = (vertex_index(vertex) *
-                                  dof_handler->selected_fe->dofs_per_vertex +
-                                  i);
-  return dof_handler->vertex_dofs[dof_number];
-};
-
-
-  
 template <int dim, typename BaseClass>
 void DoFLineAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int vertex,
                                                           const unsigned int i,
@@ -94,44 +60,6 @@ void DoFLineAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int ve
 
 
 
-template <int dim, typename BaseClass>
-void
-DoFLineAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
-  Assert (dof_indices.size() == (2*dof_handler->get_fe().dofs_per_vertex +
-                                dof_handler->get_fe().dofs_per_line),
-         ExcVectorDoesNotMatch());
-
-  const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
-                    dofs_per_line   = dof_handler->get_fe().dofs_per_line;
-  vector<int>::iterator next = dof_indices.begin();
-  for (unsigned int vertex=0; vertex<2; ++vertex)
-    for (unsigned int d=0; d<dofs_per_vertex; ++d)
-      *next++ = vertex_dof_index(vertex,d);
-  for (unsigned int d=0; d<dofs_per_line; ++d)
-    *next++ = dof_index(d);
-};
-
-
-
-template <int dim, typename BaseClass>
-TriaIterator<dim,DoFLineAccessor<dim,BaseClass> >
-DoFLineAccessor<dim,BaseClass>::child (const unsigned int i) const {
-  TriaIterator<dim,DoFLineAccessor<dim,BaseClass> > q (tria,
-                                                      present_level+1,
-                                                      child_index (i),
-                                                      dof_handler);
-  
-#ifdef DEBUG
-  if (q.state() != past_the_end)
-    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
-#endif
-  return q;
-};
-
-
-
 template <int dim, typename BaseClass>
 void DoFLineAccessor<dim,BaseClass>::
 distribute_local_to_global (const Vector<double> &local_source,
@@ -187,33 +115,9 @@ distribute_local_to_global (const FullMatrix<double> &local_source,
 
 
 
-template <int dim, typename BaseClass>
-void DoFLineAccessor<dim,BaseClass>::copy_from (const DoFLineAccessor<dim,BaseClass> &a) {
-  BaseClass::copy_from (a);
-  set_dof_handler (a.dof_handler);
-};
-
-
-
 /*------------------------- Functions: DoFQuadAccessor -----------------------*/
 
 
-template <int dim, typename BaseClass>
-inline
-int DoFQuadAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-                                  // make sure a FE has been selected
-                                  // and enough room was reserved
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
-  Assert (i<dof_handler->selected_fe->dofs_per_quad,
-         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_quad));
-
-  return dof_handler->levels[present_level]
-    ->quad_dofs[present_index*dof_handler->selected_fe->dofs_per_quad+i];
-};
-
-
-
 template <int dim, typename BaseClass>
 void DoFQuadAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
                                                    const int index) const {
@@ -230,24 +134,6 @@ void DoFQuadAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
 
 
 
-template <int dim, typename BaseClass>
-inline
-int DoFQuadAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
-                                                     const unsigned int i) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
-  Assert (vertex<4, ExcInvalidIndex (i,0,4));
-  Assert (i<dof_handler->selected_fe->dofs_per_vertex,
-         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_vertex));
-
-  const unsigned int dof_number = (vertex_index(vertex) *
-                                  dof_handler->selected_fe->dofs_per_vertex +
-                                  i);
-  return dof_handler->vertex_dofs[dof_number];
-};
-
-
-  
 template <int dim, typename BaseClass>
 void DoFQuadAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int vertex,
                                                           const unsigned int i,
@@ -266,65 +152,6 @@ void DoFQuadAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int ve
 
 
 
-template <int dim, typename BaseClass>
-void
-DoFQuadAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
-  Assert (dof_indices.size() == (4*dof_handler->get_fe().dofs_per_vertex +
-                                4*dof_handler->get_fe().dofs_per_line +
-                                dof_handler->get_fe().dofs_per_quad),
-         ExcVectorDoesNotMatch());
-
-  const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
-                    dofs_per_line   = dof_handler->get_fe().dofs_per_line,
-                    dofs_per_quad   = dof_handler->get_fe().dofs_per_quad;
-  vector<int>::iterator next = dof_indices.begin();
-  for (unsigned int vertex=0; vertex<4; ++vertex)
-    for (unsigned int d=0; d<dofs_per_vertex; ++d)
-      *next++ = vertex_dof_index(vertex,d);
-  for (unsigned int line=0; line<4; ++line)
-    for (unsigned int d=0; d<dofs_per_line; ++d)
-      *next++ = this->line(line)->dof_index(d);
-  for (unsigned int d=0; d<dofs_per_quad; ++d)
-    *next++ = dof_index(d);
-};
-
-
-
-template <int dim, typename BaseClass>
-TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
-DoFQuadAccessor<dim,BaseClass>::line (const unsigned int i) const {
-  Assert (i<4, ExcInvalidIndex (i, 0, 4));
-
-  return TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
-    (
-      tria,
-      present_level,
-      line_index (i),
-      dof_handler
-    );
-};
-
-
-
-template <int dim, typename BaseClass>
-TriaIterator<dim,DoFQuadAccessor<dim,BaseClass> >
-DoFQuadAccessor<dim,BaseClass>::child (const unsigned int i) const {
-  TriaIterator<dim,DoFQuadAccessor<dim,BaseClass> > q (tria,
-                                                      present_level+1,
-                                                      child_index (i),
-                                                      dof_handler);
-  
-#ifdef DEBUG
-  if (q.state() != past_the_end)
-    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
-#endif
-  return q;
-};
-
-
-
 template <int dim, typename BaseClass>
 void DoFQuadAccessor<dim,BaseClass>::
 distribute_local_to_global (const Vector<double> &local_source,
@@ -382,33 +209,10 @@ distribute_local_to_global (const FullMatrix<double> &local_source,
 
 
 
-template <int dim, typename BaseClass>
-void DoFQuadAccessor<dim,BaseClass>::copy_from (const DoFQuadAccessor<dim,BaseClass> &a) {
-  BaseClass::copy_from (a);
-  set_dof_handler (a.dof_handler);
-};
-
-
 
 /*------------------------- Functions: DoFHexAccessor -----------------------*/
 
 
-template <int dim, typename BaseClass>
-inline
-int DoFHexAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-                                  // make sure a FE has been selected
-                                  // and enough room was reserved
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
-  Assert (i<dof_handler->selected_fe->dofs_per_hex,
-         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_hex));
-
-  return dof_handler->levels[present_level]
-    ->hex_dofs[present_index*dof_handler->selected_fe->dofs_per_hex+i];
-};
-
-
-
 template <int dim, typename BaseClass>
 void DoFHexAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
                                                    const int index) const {
@@ -425,24 +229,6 @@ void DoFHexAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
 
 
 
-template <int dim, typename BaseClass>
-inline
-int DoFHexAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
-                                                     const unsigned int i) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
-  Assert (vertex<8, ExcInvalidIndex (i,0,8));
-  Assert (i<dof_handler->selected_fe->dofs_per_vertex,
-         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_vertex));
-
-  const unsigned int dof_number = (vertex_index(vertex) *
-                                  dof_handler->selected_fe->dofs_per_vertex +
-                                  i);
-  return dof_handler->vertex_dofs[dof_number];
-};
-
-
-  
 template <int dim, typename BaseClass>
 void DoFHexAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int vertex,
                                                           const unsigned int i,
@@ -461,85 +247,6 @@ void DoFHexAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int ver
 
 
 
-template <int dim, typename BaseClass>
-void
-DoFHexAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
-  Assert (dof_indices.size() == (8*dof_handler->get_fe().dofs_per_vertex +
-                                12*dof_handler->get_fe().dofs_per_line +
-                                6*dof_handler->get_fe().dofs_per_quad +
-                                dof_handler->get_fe().dofs_per_hex),
-         ExcVectorDoesNotMatch());
-
-  const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
-                    dofs_per_line   = dof_handler->get_fe().dofs_per_line,
-                    dofs_per_quad   = dof_handler->get_fe().dofs_per_quad,
-                    dofs_per_hex    = dof_handler->get_fe().dofs_per_hex;
-  vector<int>::iterator next = dof_indices.begin();
-  for (unsigned int vertex=0; vertex<8; ++vertex)
-    for (unsigned int d=0; d<dofs_per_vertex; ++d)
-      *next++ = vertex_dof_index(vertex,d);
-  for (unsigned int line=0; line<12; ++line)
-    for (unsigned int d=0; d<dofs_per_line; ++d)
-      *next++ = this->line(line)->dof_index(d);
-  for (unsigned int quad=0; quad<6; ++quad)
-    for (unsigned int d=0; d<dofs_per_quad; ++d)
-      *next++ = this->quad(quad)->dof_index(d);
-  for (unsigned int d=0; d<dofs_per_hex; ++d)
-    *next++ = dof_index(d);
-};
-
-
-
-template <int dim, typename BaseClass>
-TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
-DoFHexAccessor<dim,BaseClass>::line (const unsigned int i) const {
-  TriaIterator<dim,LineAccessor<dim> > l = BaseClass::line(i);
-  return TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
-    (
-      tria,
-      present_level,
-      l->index(),
-      dof_handler
-    );
-};
-
-
-
-template <int dim, typename BaseClass>
-TriaIterator<dim,DoFQuadAccessor<dim,QuadAccessor<dim> > >
-DoFHexAccessor<dim,BaseClass>::quad (const unsigned int i) const {
-  Assert (i<6, ExcInvalidIndex (i, 0, 6));
-
-  return TriaIterator<dim,DoFQuadAccessor<dim,QuadAccessor<dim> > >
-    (
-      tria,
-      present_level,
-      quad_index (i),
-      dof_handler
-    );
-};
-
-
-
-template <int dim, typename BaseClass>
-TriaIterator<dim,DoFHexAccessor<dim,BaseClass> >
-DoFHexAccessor<dim,BaseClass>::child (const unsigned int i) const {
-  TriaIterator<dim,DoFHexAccessor<dim,BaseClass> > q (tria,
-                                                     present_level+1,
-                                                     child_index (i),
-                                                     dof_handler);
-  
-#ifdef DEBUG
-  if (q.state() != past_the_end)
-    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
-#endif
-  return q;
-};
-
-
-
 template <int dim, typename BaseClass>
 void DoFHexAccessor<dim,BaseClass>::
 distribute_local_to_global (const Vector<double> &local_source,
@@ -599,52 +306,11 @@ distribute_local_to_global (const FullMatrix<double> &local_source,
 
 
 
-template <int dim, typename BaseClass>
-void DoFHexAccessor<dim,BaseClass>::copy_from (const DoFHexAccessor<dim,BaseClass> &a) {
-  BaseClass::copy_from (a);
-  set_dof_handler (a.dof_handler);
-};
-
-
-
-
 
 
 
 /*------------------------- Functions: DoFCellAccessor -----------------------*/
 
-template <int dim>
-TriaIterator<dim,DoFCellAccessor<dim> >
-DoFCellAccessor<dim>::neighbor (const unsigned int i) const {
-  TriaIterator<dim,DoFCellAccessor<dim> > q (tria,
-                                            neighbor_level (i),
-                                            neighbor_index (i),
-                                            dof_handler);
-  
-#ifdef DEBUG
-  if (q.state() != past_the_end)
-    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsNeighbor());
-#endif
-  return q;
-};
-
-
-
-template <int dim>
-TriaIterator<dim,DoFCellAccessor<dim> >
-DoFCellAccessor<dim>::child (const unsigned int i) const {
-  TriaIterator<dim,DoFCellAccessor<dim> > q (tria,
-                                            present_level+1,
-                                            child_index (i),
-                                            dof_handler);
-  
-#ifdef DEBUG
-  if (q.state() != past_the_end)
-    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
-#endif
-  return q;
-};
-
 
 
 #if deal_II_dimension == 1
index d580f5ebed0d220bb99c7ddda6aa6863a9e94059..3b82da72ebe710393d28911ab5652c7cdf711871 100644 (file)
@@ -6,6 +6,7 @@
 #include <grid/tria_levels.h>
 #include <grid/tria_iterator.h>
 #include <grid/tria_accessor.h>
+#include <grid/tria_accessor.templates.h>
 #include <grid/tria_iterator.templates.h>
 #include <grid/geometry_info.h>
 
 
 
 
-/*------------------------ Functions: LineAccessor ---------------------------*/
-
-template <int dim>
-void TriaAccessor<dim>::copy_from (const TriaAccessor<dim> &a) {
-  present_level = a.present_level;
-  present_index = a.present_index;
-  tria = a.tria;
-};
-
-
-template <int dim>
-bool TriaAccessor<dim>::operator == (const TriaAccessor<dim> &a) const {
-  Assert (tria == a.tria, ExcCantCompareIterators());
-  return ((present_index == a.present_index) &&
-         (present_level == a.present_level));
-};
-
-
-
-template <int dim>
-bool TriaAccessor<dim>::operator != (const TriaAccessor<dim> &a) const {
-  Assert (tria == a.tria, ExcCantCompareIterators());
-  return ((present_index != a.present_index) ||
-         (present_level != a.present_level));
-};
-
-
-
-template <int dim>
-int TriaAccessor<dim>::level () const {
-  return present_level;
-};
-
-
-  
-template <int dim>
-int TriaAccessor<dim>::index () const {
-  return present_index;
-};
-  
-
-
-
-template <int dim>
-IteratorState TriaAccessor<dim>::state () const {
-  if ((present_level>=0) && (present_index>=0))
-    return valid;
-  else
-    if ((present_level==-1) && (present_index==-1))
-      return past_the_end;
-    else
-      return invalid;
-};
-
-
-
-
 
 
 
@@ -99,14 +42,6 @@ LineAccessor<dim>::vertex (const unsigned int i) const {
 
 
 
-template <int dim>
-bool LineAccessor<dim>::used () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
-  return tria->levels[present_level]->lines.used[present_index];
-};
-
-
-
 template <int dim>
 void LineAccessor<dim>::set_used_flag () const {
   Assert (state() == valid, ExcDereferenceInvalidObject());
@@ -122,29 +57,6 @@ void LineAccessor<dim>::clear_used_flag () const {
 };
 
 
-template <int dim>
-bool LineAccessor<dim>::user_flag_set () const {
-  Assert (used(), ExcCellNotUsed());
-  return tria->levels[present_level]->lines.user_flags[present_index];
-};
-
-
-
-template <int dim>
-void LineAccessor<dim>::set_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
-  tria->levels[present_level]->lines.user_flags[present_index] = true;
-};
-
-
-
-template <int dim>
-void LineAccessor<dim>::clear_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
-  tria->levels[present_level]->lines.user_flags[present_index] = false;
-};
-
-
 
 template <int dim>
 void LineAccessor<dim>::recursively_set_user_flag () const {
@@ -189,33 +101,7 @@ void * LineAccessor<dim>::user_pointer () const {
   Assert (used(), ExcCellNotUsed());
   return tria->levels[present_level]->lines.user_pointers[present_index];
 };
-
-  
-
-
-template <int dim>
-TriaIterator<dim,LineAccessor<dim> >
-LineAccessor<dim>::child (const unsigned int i) const {
-  Assert (i<2, ExcInvalidIndex(i,0,1));
   
-  TriaIterator<dim,LineAccessor<dim> > q (tria, present_level+1, child_index (i));
-  
-#ifdef DEBUG
-  if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsChild());
-#endif
-  return q;
-};
-
-
-template <int dim>
-int LineAccessor<dim>::child_index (unsigned int i) const {
-  Assert (i<2, ExcInvalidIndex(i,0,1));
-  return tria->levels[present_level]->lines.children[present_index]+i;
-};
-
-
-
 
 template <int dim>
 void LineAccessor<dim>::set_children (const int index) const {
@@ -235,62 +121,6 @@ void LineAccessor<dim>::clear_children () const {
 
 
 
-template <int dim>
-bool LineAccessor<dim>::has_children () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
-  return (tria->levels[present_level]->lines.children[present_index] != -1);
-}
-
-
-
-template <int dim>
-void LineAccessor<dim>::operator ++ () {
-  ++present_index;
-                                  // is index still in the range of
-                                  // the vector?
-  while (present_index
-        >=
-        (int)tria->levels[present_level]->lines.lines.size())
-    {
-                                      // no -> go one level up until we find
-                                      // one with more than zero cells
-      ++present_level;
-      present_index = 0;
-                                      // highest level reached?
-      if (present_level >= (int)tria->levels.size()) 
-       {
-                                          // return with past the end pointer
-         present_level = present_index = -1;
-         return;
-       };
-    };
-};
-
-
-
-template <int dim>
-void LineAccessor<dim>::operator -- () {
-  --present_index;
-                                  // is index still in the range of
-                                  // the vector?
-  while (present_index < 0) 
-    {
-                                      // no -> go one level down
-      --present_level;
-                                      // lowest level reached?
-      if (present_level == -1) 
-       {
-                                          // return with past the end pointer
-         present_level = present_index = -1;
-         return;
-       };
-                                      // else
-      present_index = tria->levels[present_level]->lines.lines.size()-1;
-    };
-};
-
-
-
 template <int dim>
 unsigned char LineAccessor<dim>::boundary_indicator () const {
   Assert (dim>=2, ExcNotUsefulForThisDimension());
@@ -391,16 +221,10 @@ QuadAccessor<dim>::vertex (const unsigned int i) const {
 
 
 
-template <int dim>
-bool QuadAccessor<dim>::used () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
-  return tria->levels[present_level]->quads.used[present_index];
-};
-
-
 
 template <int dim>
-void QuadAccessor<dim>::set_used_flag () const {
+void
+QuadAccessor<dim>::set_used_flag () const {
   Assert (state() == valid, ExcDereferenceInvalidObject());
   tria->levels[present_level]->quads.used[present_index] = true;
 };
@@ -415,31 +239,6 @@ void QuadAccessor<dim>::clear_used_flag () const {
 
 
 
-
-template <int dim>
-bool QuadAccessor<dim>::user_flag_set () const {
-  Assert (used(), ExcCellNotUsed());
-  return tria->levels[present_level]->quads.user_flags[present_index];
-};
-
-
-
-template <int dim>
-void QuadAccessor<dim>::set_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
-  tria->levels[present_level]->quads.user_flags[present_index] = true;
-};
-
-
-
-template <int dim>
-void QuadAccessor<dim>::clear_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
-  tria->levels[present_level]->quads.user_flags[present_index] = false;
-};
-
-
-
 template <int dim>
 void QuadAccessor<dim>::recursively_set_user_flag () const {
   set_user_flag ();
@@ -486,54 +285,6 @@ void * QuadAccessor<dim>::user_pointer () const {
 
 
 
-
-template <int dim>
-TriaIterator<dim,LineAccessor<dim> >
-QuadAccessor<dim>::line (const unsigned int i) const {
-  return
-    TriaIterator<dim,LineAccessor<dim> >
-    (
-      tria,
-      present_level,
-      line_index (i)
-    );
-};
-
-
-
-template <int dim>
-unsigned int QuadAccessor<dim>::line_index (unsigned int i) const {
-  Assert (i<4, ExcInvalidIndex(i,0,3));
-
-  return tria->levels[present_level]->quads.quads[present_index].line(i);
-};
-
-
-
-template <int dim>
-TriaIterator<dim,QuadAccessor<dim> >
-QuadAccessor<dim>::child (const unsigned int i) const {
-  Assert (i<4, ExcInvalidIndex(i,0,3));
-  
-  TriaIterator<dim,QuadAccessor<dim> > q (tria, present_level+1, child_index (i));
-  
-#ifdef DEBUG
-  if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsChild());
-#endif
-  return q;
-};
-
-
-
-template <int dim>
-int QuadAccessor<dim>::child_index (unsigned int i) const {
-  Assert (i<4, ExcInvalidIndex(i,0,3));
-  return tria->levels[present_level]->quads.children[present_index]+i;
-};
-
-
-
 template <int dim>
 void QuadAccessor<dim>::set_children (const int index) const {
   Assert (used(), ExcCellNotUsed());
@@ -552,61 +303,6 @@ void QuadAccessor<dim>::clear_children () const {
 
 
 
-template <int dim>
-bool QuadAccessor<dim>::has_children () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
-  return (tria->levels[present_level]->quads.children[present_index] != -1);
-};
-
-
-
-template <int dim>
-void QuadAccessor<dim>::operator ++ () {
-  ++present_index;
-                                  // is index still in the range of
-                                  // the vector?
-  while (present_index
-        >=
-        (int)tria->levels[present_level]->quads.quads.size()) 
-    {
-                                      // no -> go one level up
-      ++present_level;
-      present_index = 0;
-                                      // highest level reached?
-      if (present_level >= (int)tria->levels.size()) 
-       {
-                                          // return with past the end pointer
-         present_level = present_index = -1;
-         return;
-       };
-    };
-};
-
-
-
-template <int dim>
-void QuadAccessor<dim>::operator -- () {
-  --present_index;
-                                  // is index still in the range of
-                                  // the vector?
-  while (present_index < 0) 
-    {
-                                      // no -> go one level down
-      --present_level;
-                                      // lowest level reached?
-      if (present_level == -1) 
-       {
-                                          // return with past the end pointer
-         present_level = present_index = -1;
-         return;
-       };
-                                      // else
-      present_index = tria->levels[present_level]->quads.quads.size()-1;
-    };
-};
-
-
-
 template <int dim>
 unsigned char QuadAccessor<dim>::boundary_indicator () const {
   Assert (dim>=3, ExcNotUsefulForThisDimension());
@@ -828,14 +524,6 @@ HexAccessor<dim>::vertex (const unsigned int i) const {
 
 
 
-template <int dim>
-bool HexAccessor<dim>::used () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
-  return tria->levels[present_level]->hexes.used[present_index];
-};
-
-
-
 template <int dim>
 void HexAccessor<dim>::set_used_flag () const {
   Assert (state() == valid, ExcDereferenceInvalidObject());
@@ -853,30 +541,6 @@ void HexAccessor<dim>::clear_used_flag () const {
 
 
 
-template <int dim>
-bool HexAccessor<dim>::user_flag_set () const {
-  Assert (used(), ExcCellNotUsed());
-  return tria->levels[present_level]->hexes.user_flags[present_index];
-};
-
-
-
-template <int dim>
-void HexAccessor<dim>::set_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
-  tria->levels[present_level]->hexes.user_flags[present_index] = true;
-};
-
-
-
-template <int dim>
-void HexAccessor<dim>::clear_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
-  tria->levels[present_level]->hexes.user_flags[present_index] = false;
-};
-
-
-
 template <int dim>
 void HexAccessor<dim>::recursively_set_user_flag () const {
   set_user_flag ();
@@ -923,84 +587,6 @@ void * HexAccessor<dim>::user_pointer () const {
 
 
 
-
-template <int dim>
-TriaIterator<dim,LineAccessor<dim> >
-HexAccessor<dim>::line (const unsigned int i) const {
-  Assert (used(), ExcCellNotUsed());
-  Assert (i<12, ExcInvalidIndex (i,0,11));
-  
-  if (i<4)
-    return quad(0)->line(i);
-  else
-    if (i<8)
-      return quad(1)->line(i-4);
-    else
-      switch (i) 
-       {
-         case 8:
-               return quad(2)->line(3);
-         case 9:
-               return quad(2)->line(1);
-         case 10:
-               return quad(4)->line(1);
-         case 11:
-               return quad(4)->line(3);
-       };
-  Assert (false, ExcInvalidIndex(i,0,11));
-  return TriaIterator<dim,LineAccessor<dim> >(tria, -1, -1, 0);
-};
-
-
-
-template <int dim>
-TriaIterator<dim,QuadAccessor<dim> >
-HexAccessor<dim>::quad (const unsigned int i) const {
-  Assert (used(), ExcCellNotUsed());
-  return
-    TriaIterator<dim,QuadAccessor<dim> >
-    (
-      tria,
-      present_level,
-      quad_index (i)
-    );
-};
-
-
-
-template <int dim>
-unsigned int HexAccessor<dim>::quad_index (unsigned int i) const {
-  Assert (i<6, ExcInvalidIndex(i,0,5));
-
-  return tria->levels[present_level]->hexes.hexes[present_index].quad(i);
-};
-
-
-
-template <int dim>
-TriaIterator<dim,HexAccessor<dim> >
-HexAccessor<dim>::child (const unsigned int i) const {
-  Assert (i<6, ExcInvalidIndex(i,0,5));
-  
-  TriaIterator<dim,HexAccessor<dim> > q (tria, present_level+1, child_index (i));
-  
-#ifdef DEBUG
-  if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsChild());
-#endif
-  return q;
-};
-
-
-
-template <int dim>
-int HexAccessor<dim>::child_index (unsigned int i) const {
-  Assert (i<8, ExcInvalidIndex(i,0,7));
-  return tria->levels[present_level]->hexes.children[present_index]+i;
-};
-
-
-
 template <int dim>
 void HexAccessor<dim>::set_children (const int index) const {
   Assert (used(), ExcCellNotUsed());
@@ -1027,53 +613,6 @@ bool HexAccessor<dim>::has_children () const {
 
 
 
-template <int dim>
-void HexAccessor<dim>::operator ++ () {
-  ++present_index;
-                                  // is index still in the range of
-                                  // the vector?
-  while (present_index
-        >=
-        (int)tria->levels[present_level]->hexes.hexes.size()) 
-    {
-                                      // no -> go one level up
-      ++present_level;
-      present_index = 0;
-                                      // highest level reached?
-      if (present_level >= (int)tria->levels.size()) 
-       {
-                                          // return with past the end pointer
-         present_level = present_index = -1;
-         return;
-       };
-    };
-};
-
-
-
-template <int dim>
-void HexAccessor<dim>::operator -- () {
-  --present_index;
-                                  // is index still in the range of
-                                  // the vector?
-  while (present_index < 0) 
-    {
-                                      // no -> go one level down
-      --present_level;
-                                      // lowest level reached?
-      if (present_level == -1) 
-       {
-                                          // return with past the end pointer
-         present_level = present_index = -1;
-         return;
-       };
-                                      // else
-      present_index = tria->levels[present_level]->hexes.hexes.size()-1;
-    };
-};
-
-
-
 template <int dim>
 unsigned char HexAccessor<dim>::boundary_indicator () const {
   Assert (dim<4, ExcNotUsefulForThisDimension());
@@ -1899,16 +1438,9 @@ void CellAccessor<1>::set_material_id (const unsigned char mat_id) const {
 };
 
 
-
-template <>
-Triangulation<1>::face_iterator
-CellAccessor<1>::face (const unsigned int) const {
-  Assert (false, ExcNotUsefulForThisDimension());
-  return 0;
-};
-
 #endif
 
+
 /*------------------------ Functions: CellAccessor<2> -----------------------*/
 
 
@@ -1938,14 +1470,6 @@ void CellAccessor<2>::set_material_id (const unsigned char mat_id) const {
     = mat_id;                                           
 };
 
-
-
-template <>
-Triangulation<2>::face_iterator
-CellAccessor<2>::face (const unsigned int i) const {
-  return line(i);
-};
-
 #endif
 
 
@@ -1981,40 +1505,12 @@ void CellAccessor<3>::set_material_id (const unsigned char mat_id) const {
     = mat_id;                                           
 };
 
-
-
-template <>
-Triangulation<3>::face_iterator
-CellAccessor<3>::face (const unsigned int i) const {
-  return quad(i);
-};
-
 #endif
 
 
 /*------------------------ Functions: CellAccessor<dim> -----------------------*/
 
 
-template <int dim>
-int CellAccessor<dim>::neighbor_index (const unsigned int i) const {
-  Assert (i<GeometryInfo<dim>::faces_per_cell,
-         typename TriaSubstructAccessor<dim>::ExcInvalidNeighbor(i));
-  return tria->levels[present_level]->
-    neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].second;
-};
-
-
-
-template <int dim>
-int CellAccessor<dim>::neighbor_level (const unsigned int i) const {
-  Assert (i<GeometryInfo<dim>::faces_per_cell,
-         typename TriaSubstructAccessor<dim>::ExcInvalidNeighbor(i));
-  return tria->levels[present_level]->
-    neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].first;
-};
-
-
-
 template <int dim>
 void CellAccessor<dim>::set_neighbor (const unsigned int i,
                                      const TriaIterator<dim,CellAccessor<dim> > &pointer) const {
@@ -2055,114 +1551,6 @@ bool CellAccessor<dim>::at_boundary (const unsigned int i) const {
 
 
 
-template <int dim>
-bool CellAccessor<dim>::refine_flag_set () const {
-  Assert (used(), typename TriaSubstructAccessor<dim>::ExcCellNotUsed());
-                                  // cells flagged for refinement must be active
-                                  // (the #set_refine_flag# function checks this,
-                                  // but activity may change when refinement is
-                                  // executed and for some reason the refine
-                                  // flag is not cleared).
-  Assert (active() ||  !tria->levels[present_level]->refine_flags[present_index],
-         ExcRefineCellNotActive());
-  return tria->levels[present_level]->refine_flags[present_index];
-};
-
-
-
-template <int dim>
-void CellAccessor<dim>::set_refine_flag () const {
-  Assert (used() && active(), ExcRefineCellNotActive());
-  Assert (!coarsen_flag_set(), ExcCellFlaggedForCoarsening());
-  
-  tria->levels[present_level]->refine_flags[present_index] = true;
-};
-
-
-
-template <int dim>
-void CellAccessor<dim>::clear_refine_flag () const {
-  Assert (used() && active(), ExcRefineCellNotActive());
-  tria->levels[present_level]->refine_flags[present_index] = false;
-};
-
-
-
-template <int dim>
-bool CellAccessor<dim>::coarsen_flag_set () const {
-  Assert (used(), typename TriaSubstructAccessor<dim>::ExcCellNotUsed());
-                                  // cells flagged for coarsening must be active
-                                  // (the #set_refine_flag# function checks this,
-                                  // but activity may change when refinement is
-                                  // executed and for some reason the refine
-                                  // flag is not cleared).
-  Assert (active() ||  !tria->levels[present_level]->coarsen_flags[present_index],
-         ExcRefineCellNotActive());
-  return tria->levels[present_level]->coarsen_flags[present_index];
-};
-
-
-
-template <int dim>
-void CellAccessor<dim>::set_coarsen_flag () const {
-  Assert (used() && active(), ExcRefineCellNotActive());
-  Assert (!refine_flag_set(), ExcCellFlaggedForRefinement());
-  
-  tria->levels[present_level]->coarsen_flags[present_index] = true;
-};
-
-
-
-template <int dim>
-void CellAccessor<dim>::clear_coarsen_flag () const {
-  Assert (used() && active(), ExcRefineCellNotActive());
-  tria->levels[present_level]->coarsen_flags[present_index] = false;
-};
-
-
-
-template <int dim>
-TriaIterator<dim,CellAccessor<dim> >
-CellAccessor<dim>::neighbor (const unsigned int i) const {
-  TriaIterator<dim,CellAccessor<dim> > q (tria, neighbor_level (i), neighbor_index (i));
-
-#ifdef DEBUG
-  if (q.state() != past_the_end)
-    Assert (q->used(),
-           typename TriaSubstructAccessor<dim>::ExcUnusedCellAsNeighbor());
-#endif
-  return q;
-};
-
-
-
-template <int dim>
-TriaIterator<dim,CellAccessor<dim> >
-CellAccessor<dim>::child (const unsigned int i) const {
-  TriaIterator<dim,CellAccessor<dim> > q (tria, present_level+1, child_index (i));
-
-#ifdef DEBUG
-  if (q.state() != past_the_end)
-    Assert (q->used(),
-           typename TriaSubstructAccessor<dim>::ExcUnusedCellAsChild());
-#endif
-  return q;
-};
-
-
-
-template <int dim>
-bool CellAccessor<dim>::active () const {
-  return !has_children();
-};
-
-
-
-
-
-
-
-
 
 
 // explicit instantiations
index fe2dd4feff905622e23c33a35c315f33a41e1c8c..f4aa02e899a952817ae7938baf9f85d09a8f3345 100644 (file)
@@ -3,6 +3,7 @@
 
 
 #include <grid/tria_boundary.h>
+#include <grid/tria_accessor.h>
 #include <grid/tria_iterator.h>
 #include <grid/tria.h>
 #include <fstream>

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.