]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Move distribute_local_to_global from arbitrary accessors to cell accessors.
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Wed, 26 Apr 2006 20:56:57 +0000 (20:56 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Wed, 26 Apr 2006 20:56:57 +0000 (20:56 +0000)
git-svn-id: https://svn.dealii.org/trunk@12913 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/include/dofs/dof_accessor.h
deal.II/deal.II/include/dofs/dof_accessor.templates.h
deal.II/doc/news/changes.html

index 56915ac1b4b8733e852022f7c7b3f24e4be92daf..226cbe2f59d2c7000f6c399a5f09212d9032ef99 100644 (file)
@@ -466,41 +466,6 @@ class DoFObjectAccessor : public DoFAccessor<DH>,
                                      * access to the DoF data.
                                      */
     TriaIterator<dim,DoFObjectAccessor<celldim, DH> > child (const unsigned int) const;
-
-                                    /**
-                                     * Distribute a local (cell
-                                     * based) vector to a global one
-                                     * by mapping the local numbering
-                                     * of the degrees of freedom to
-                                     * the global one and entering
-                                     * the local values into the
-                                     * global vector.
-                                     *
-                                     * The elements are
-                                     * <em>added</em> up to the
-                                     * elements in the global vector,
-                                     * rather than just set, since
-                                     * this is usually what one
-                                     * wants.
-                                     */
-    template <typename number, typename OutputVector>
-    void
-    distribute_local_to_global (const Vector<number> &local_source,
-                                OutputVector         &global_destination) const;
-
-                                    /**
-                                     * This function does much the same as
-                                     * the
-                                     * <tt>distribute_local_to_global(Vector,Vector)</tt>
-                                     * function, but operates on matrices
-                                     * instead of vectors. The sparse matrix
-                                     * is supposed to have non-zero entry
-                                     * slots where required.
-                                     */
-    template <typename number, typename OutputMatrix>
-    void
-    distribute_local_to_global (const FullMatrix<number> &local_source,
-                                OutputMatrix             &global_destination) const;
     
                                     /**
                                      * Implement the copy operator needed
@@ -785,39 +750,6 @@ class DoFObjectAccessor<1, DH> :
                                      * access to the DoF data.
                                      */
     TriaIterator<DH::dimension,DoFObjectAccessor<1,DH> > child (const unsigned int) const;
-
-                                    /**
-                                     * Distribute a local (cell based) vector
-                                     * to a global one by mapping the local
-                                     * numbering of the degrees of freedom to
-                                     * the global one and entering the local
-                                     * values into the global vector.
-                                     *
-                                     * The elements are
-                                     * <em>added</em> up to the
-                                     * elements in the global vector,
-                                     * rather than just set, since
-                                     * this is usually what one
-                                     * wants.
-                                     */
-    template <typename number, typename OutputVector>
-    void
-    distribute_local_to_global (const Vector<number> &local_source,
-                                OutputVector         &global_destination) const;
-
-                                    /**
-                                     * This function does much the same as
-                                     * the
-                                     * <tt>distribute_local_to_global(Vector,Vector)</tt>
-                                     * function, but operates on matrices
-                                     * instead of vectors. The sparse matrix
-                                     * is supposed to have non-zero entry
-                                     * slots where required.
-                                     */
-    template <typename number, typename OutputMatrix>
-    void
-    distribute_local_to_global (const FullMatrix<number> &local_source,
-                                OutputMatrix             &global_destination) const;
     
                                     /**
                                      * Implement the copy operator needed
@@ -1056,39 +988,6 @@ class DoFObjectAccessor<2, DH> :
                                      */
     TriaIterator<DH::dimension,DoFObjectAccessor<2, DH> >
     child (const unsigned int) const;
-
-                                    /**
-                                     * Distribute a local (cell based) vector
-                                     * to a global one by mapping the local
-                                     * numbering of the degrees of freedom to
-                                     * the global one and entering the local
-                                     * values into the global vector.
-                                     *
-                                     * The elements are
-                                     * <em>added</em> up to the
-                                     * elements in the global vector,
-                                     * rather than just set, since
-                                     * this is usually what one
-                                     * wants.
-                                     */
-    template <typename number, typename OutputVector>
-    void
-    distribute_local_to_global (const Vector<number> &local_source,
-                                OutputVector         &global_destination) const;
-
-                                    /**
-                                     * This function does much the same as
-                                     * the
-                                     * <tt>distribute_local_to_global(Vector,Vector)</tt>
-                                     * function, but operates on matrices
-                                     * instead of vectors. The sparse matrix
-                                     * is supposed to have non-zero entry
-                                     * slots where required.
-                                     */
-    template <typename number, typename OutputMatrix>
-    void
-    distribute_local_to_global (const FullMatrix<number> &local_source,
-                                OutputMatrix             &global_destination) const;
     
                                     /**
                                      * Implement the copy operator needed
@@ -1333,41 +1232,6 @@ class DoFObjectAccessor<3, DH> :
                                      * access to the DoF data.
                                      */
     TriaIterator<DH::dimension,DoFObjectAccessor<3, DH> > child (const unsigned int) const;
-
-                                    /**
-                                     * Distribute a local (cell
-                                     * based) vector to a global one
-                                     * by mapping the local numbering
-                                     * of the degrees of freedom to
-                                     * the global one and entering
-                                     * the local values into the
-                                     * global vector.
-                                     *
-                                     * The elements are
-                                     * <em>added</em> up to the
-                                     * elements in the global vector,
-                                     * rather than just set, since
-                                     * this is usually what one
-                                     * wants.
-                                     */
-    template <typename number, typename OutputVector>
-    void
-    distribute_local_to_global (const Vector<number> &local_source,
-                                OutputVector         &global_destination) const;
-
-                                    /**
-                                     * This function does much the same as
-                                     * the
-                                     * <tt>distribute_local_to_global(Vector,Vector)</tt>
-                                     * function, but operates on matrices
-                                     * instead of vectors. The sparse matrix
-                                     * is supposed to have non-zero entry
-                                     * slots where required.
-                                     */
-    template <typename number, typename OutputMatrix>
-    void
-    distribute_local_to_global (const FullMatrix<number> &local_source,
-                                OutputMatrix             &global_destination) const;
     
                                     /**
                                      * Implement the copy operator needed
@@ -1694,6 +1558,43 @@ class DoFCellAccessor :  public DoFObjectAccessor<DH::dimension,DH>
                                      * with them at all.
                                      */
     void get_dof_indices (std::vector<unsigned int> &dof_indices) const;
+
+                                    /**
+                                     * Distribute a local (cell
+                                     * based) vector to a global one
+                                     * by mapping the local numbering
+                                     * of the degrees of freedom to
+                                     * the global one and entering
+                                     * the local values into the
+                                     * global vector.
+                                     *
+                                     * The elements are
+                                     * <em>added</em> up to the
+                                     * elements in the global vector,
+                                     * rather than just set, since
+                                     * this is usually what one
+                                     * wants.
+                                     */
+    template <typename number, typename OutputVector>
+    void
+    distribute_local_to_global (const Vector<number> &local_source,
+                                OutputVector         &global_destination) const;
+
+                                    /**
+                                     * This function does much the
+                                     * same as the
+                                     * <tt>distribute_local_to_global(Vector,Vector)</tt>
+                                     * function, but operates on
+                                     * matrices instead of
+                                     * vectors. If the matrix type is
+                                     * a sparse matrix then it is
+                                     * supposed to have non-zero
+                                     * entry slots where required.
+                                     */
+    template <typename number, typename OutputMatrix>
+    void
+    distribute_local_to_global (const FullMatrix<number> &local_source,
+                                OutputMatrix             &global_destination) const;
     
   private:
                                     /**
index 68019357500a3b758f3daa4057de7870616fd740..c1fd53f8342bfae42d19ca4d8a870366ddcbf632 100644 (file)
@@ -297,99 +297,6 @@ DoFObjectAccessor<1,DH>::set_active_fe_index (const unsigned int i)
 
 
 
-template <class DH>
-template <typename number, typename OutputVector>
-inline
-void
-DoFObjectAccessor<1,DH>::
-distribute_local_to_global (const Vector<number> &local_source,
-                           OutputVector         &global_destination) const
-{
-                                  // since the exception classes are
-                                  // from a template dependent base
-                                  // class, we have to fully qualify
-                                  // them. to work around more
-                                  // trouble, typedef the template
-                                  // dependent base class to a
-                                  // non-template dependent name and
-                                  // use that to specify the
-                                  // qualified exception names
-  typedef DoFAccessor<DH> BaseClass;
-  
-  Assert (this->dof_handler != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (&this->get_fe() != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (local_source.size() == (2*this->get_fe().dofs_per_vertex +
-                                 this->get_fe().dofs_per_line),
-         typename BaseClass::ExcVectorDoesNotMatch());
-  Assert (this->dof_handler->n_dofs() == global_destination.size(),
-         typename BaseClass::ExcVectorDoesNotMatch());
-
-  const unsigned int n_dofs = local_source.size();
-
-//TODO[WB]: This function could me made more efficient. First, it allocates memory, which could be avoided by passing in another argument as a scratch array. second, the elementwise access is really slow if we use PETSc vectors/matrices. This should be fixed eventually
-  
-                                  // get indices of dofs
-  std::vector<unsigned int> dofs (n_dofs);
-  get_dof_indices (dofs);
-  
-                                  // distribute cell vector
-  for (unsigned int j=0; j<n_dofs; ++j)
-    global_destination(dofs[j]) += local_source(j);
-}
-
-
-
-template <class DH>
-template <typename number, typename OutputMatrix>
-inline
-void
-DoFObjectAccessor<1,DH>::
-distribute_local_to_global (const FullMatrix<number> &local_source,
-                           OutputMatrix             &global_destination) const
-{
-                                  // since the exception classes are
-                                  // from a template dependent base
-                                  // class, we have to fully qualify
-                                  // them. to work around more
-                                  // trouble, typedef the template
-                                  // dependent base class to a
-                                  // non-template dependent name and
-                                  // use that to specify the
-                                  // qualified exception names
-  typedef DoFAccessor<DH> BaseClass;
-  
-  Assert (this->dof_handler != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (&this->get_fe() != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (local_source.m() == (2*this->get_fe().dofs_per_vertex +
-                               this->get_fe().dofs_per_line),
-         typename BaseClass::ExcVectorDoesNotMatch());
-  Assert (local_source.m() == local_source.n(),
-         typename BaseClass::ExcMatrixDoesNotMatch());
-  Assert (this->dof_handler->n_dofs() == global_destination.m(),
-         typename BaseClass::ExcMatrixDoesNotMatch());
-  Assert (global_destination.m() == global_destination.n(),
-         typename BaseClass::ExcMatrixDoesNotMatch());
-
-  const unsigned int n_dofs = local_source.m();
-
-//TODO[WB]: This function could me made more efficient. First, it allocates memory, which could be avoided by passing in another argument as a scratch array. second, the elementwise access is really slow if we use PETSc vectors/matrices. This should be fixed eventually
-
-                                  // get indices of dofs
-  std::vector<unsigned int> dofs (n_dofs);
-  get_dof_indices (dofs);
-  
-                                  // distribute cell matrix
-  for (unsigned int i=0; i<n_dofs; ++i)
-    for (unsigned int j=0; j<n_dofs; ++j)
-      global_destination.add(dofs[i], dofs[j], local_source(i,j));
-}
-
-
-
 template <class DH>
 inline
 void
@@ -611,106 +518,6 @@ DoFObjectAccessor<2,DH>::set_active_fe_index (const unsigned int i)
 
 
 
-template <class DH>
-template <typename number, typename OutputVector>
-inline
-void
-DoFObjectAccessor<2,DH>::
-distribute_local_to_global (const Vector<number> &local_source,
-                           OutputVector         &global_destination) const
-{
-                                  // since the exception classes are
-                                  // from a template dependent base
-                                  // class, we have to fully qualify
-                                  // them. to work around more
-                                  // trouble, typedef the template
-                                  // dependent base class to a
-                                  // non-template dependent name and
-                                  // use that to specify the
-                                  // qualified exception names
-  typedef DoFAccessor<DH> BaseClass;
-  
-  Assert (this->dof_handler != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (&this->get_fe() != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (local_source.size() == (4*this->dof_handler->get_fe().dofs_per_vertex +
-                                 4*this->dof_handler->get_fe().dofs_per_line +
-                                 this->dof_handler->get_fe().dofs_per_quad),
-         typename BaseClass::ExcVectorDoesNotMatch());
-  Assert (this->dof_handler->n_dofs() == global_destination.size(),
-         typename BaseClass::ExcVectorDoesNotMatch());
-
-  Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
-          ExcMessage ("DoFHandler not initialized"));
-
-  const unsigned int n_dofs = local_source.size();
-  
-//TODO[WB]: This function could me made more efficient. First, it allocates memory, which could be avoided by passing in another argument as a scratch array. second, the elementwise access is really slow if we use PETSc vectors/matrices. This should be fixed eventually
-
-                                  // get indices of dofs
-  std::vector<unsigned int> dofs (n_dofs);
-  get_dof_indices (dofs);
-  
-                                  // distribute cell vector
-  for (unsigned int j=0; j<n_dofs; ++j)
-    global_destination(dofs[j]) += local_source(j);
-}
-
-
-
-template <class DH>
-template <typename number, typename OutputMatrix>
-inline
-void
-DoFObjectAccessor<2,DH>::
-distribute_local_to_global (const FullMatrix<number> &local_source,
-                           OutputMatrix             &global_destination) const
-{
-                                  // since the exception classes are
-                                  // from a template dependent base
-                                  // class, we have to fully qualify
-                                  // them. to work around more
-                                  // trouble, typedef the template
-                                  // dependent base class to a
-                                  // non-template dependent name and
-                                  // use that to specify the
-                                  // qualified exception names
-  typedef DoFAccessor<DH> BaseClass;
-  
-  Assert (this->dof_handler != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (&this->get_fe() != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (local_source.m() == (4*this->dof_handler->get_fe().dofs_per_vertex +
-                               4*this->dof_handler->get_fe().dofs_per_line +
-                               this->dof_handler->get_fe().dofs_per_quad),
-         typename BaseClass::ExcVectorDoesNotMatch());
-  Assert (local_source.m() == local_source.n(),
-         typename BaseClass::ExcMatrixDoesNotMatch());
-  Assert (this->dof_handler->n_dofs() == global_destination.m(),
-         typename BaseClass::ExcMatrixDoesNotMatch());
-  Assert (global_destination.m() == global_destination.n(),
-         typename BaseClass::ExcMatrixDoesNotMatch());
-  Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
-          ExcMessage ("DoFHandler not initialized"));
-
-  const unsigned int n_dofs = local_source.m();
-
-//TODO[WB]: This function could me made more efficient. First, it allocates memory, which could be avoided by passing in another argument as a scratch array. second, the elementwise access is really slow if we use PETSc vectors/matrices. This should be fixed eventually
-
-                                  // get indices of dofs
-  std::vector<unsigned int> dofs (n_dofs);
-  get_dof_indices (dofs);
-  
-                                  // distribute cell matrix
-  for (unsigned int i=0; i<n_dofs; ++i)
-    for (unsigned int j=0; j<n_dofs; ++j)
-      global_destination.add(dofs[i], dofs[j], local_source(i,j));
-}
-
-
-
 template <class DH>
 inline
 void
@@ -949,107 +756,6 @@ DoFObjectAccessor<3,DH>::set_active_fe_index (const unsigned int i)
 
 
 
-template <class DH>
-template <typename number, typename OutputVector>
-inline
-void
-DoFObjectAccessor<3,DH>::
-distribute_local_to_global (const Vector<number> &local_source,
-                           OutputVector         &global_destination) const
-{
-                                  // since the exception classes are
-                                  // from a template dependent base
-                                  // class, we have to fully qualify
-                                  // them. to work around more
-                                  // trouble, typedef the template
-                                  // dependent base class to a
-                                  // non-template dependent name and
-                                  // use that to specify the
-                                  // qualified exception names
-  typedef DoFAccessor<DH> BaseClass;
-  
-  Assert (this->dof_handler != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (&this->get_fe() != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (local_source.size() == (8*this->get_fe().dofs_per_vertex +
-                                  12*this->get_fe().dofs_per_line +
-                                  6*this->get_fe().dofs_per_quad +
-                                  this->get_fe().dofs_per_hex),
-         typename BaseClass::ExcVectorDoesNotMatch());
-  Assert (this->dof_handler->n_dofs() == global_destination.size(),
-         typename BaseClass::ExcVectorDoesNotMatch());
-  Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
-          ExcMessage ("DoFHandler not initialized"));
-
-  const unsigned int n_dofs = local_source.size();
-  
-//TODO[WB]: This function could me made more efficient. First, it allocates memory, which could be avoided by passing in another argument as a scratch array. second, the elementwise access is really slow if we use PETSc vectors/matrices. This should be fixed eventually
-
-                                  // get indices of dofs
-  std::vector<unsigned int> dofs (n_dofs);
-  get_dof_indices (dofs);
-  
-                                  // distribute cell vector
-  for (unsigned int j=0; j<n_dofs; ++j)
-    global_destination(dofs[j]) += local_source(j);
-}
-
-
-
-template <class DH>
-template <typename number, typename OutputMatrix>
-inline
-void
-DoFObjectAccessor<3,DH>::
-distribute_local_to_global (const FullMatrix<number> &local_source,
-                           OutputMatrix             &global_destination) const
-{
-                                  // since the exception classes are
-                                  // from a template dependent base
-                                  // class, we have to fully qualify
-                                  // them. to work around more
-                                  // trouble, typedef the template
-                                  // dependent base class to a
-                                  // non-template dependent name and
-                                  // use that to specify the
-                                  // qualified exception names
-  typedef DoFAccessor<DH> BaseClass;
-  
-  Assert (this->dof_handler != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (&this->get_fe() != 0,
-         typename BaseClass::ExcInvalidObject());
-  Assert (local_source.m() == (8*this->get_fe().dofs_per_vertex +
-                               12*this->get_fe().dofs_per_line +
-                               6*this->get_fe().dofs_per_quad +
-                               this->get_fe().dofs_per_hex),
-         typename BaseClass::ExcVectorDoesNotMatch());
-  Assert (local_source.m() == local_source.n(),
-         typename BaseClass::ExcMatrixDoesNotMatch());
-  Assert (this->dof_handler->n_dofs() == global_destination.m(),
-         typename BaseClass::ExcMatrixDoesNotMatch());
-  Assert (global_destination.m() == global_destination.n(),
-         typename BaseClass::ExcMatrixDoesNotMatch());
-  Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
-          ExcMessage ("DoFHandler not initialized"));
-
-  const unsigned int n_dofs = local_source.m();
-
-//TODO[WB]: This function could me made more efficient. First, it allocates memory, which could be avoided by passing in another argument as a scratch array. second, the elementwise access is really slow if we use PETSc vectors/matrices. This should be fixed eventually
-
-                                  // get indices of dofs
-  std::vector<unsigned int> dofs (n_dofs);
-  get_dof_indices (dofs);
-  
-                                  // distribute cell matrix
-  for (unsigned int i=0; i<n_dofs; ++i)
-    for (unsigned int j=0; j<n_dofs; ++j)
-      global_destination.add(dofs[i], dofs[j], local_source(i,j));
-}
-
-
-
 template <class DH>
 void DoFObjectAccessor<3,DH>::copy_from (const DoFObjectAccessor<3,DH> &a)
 {
@@ -1968,4 +1674,98 @@ get_dof_indices (std::vector<unsigned int> &dof_indices) const
 }
 
 
+
+template <class DH>
+template <typename number, typename OutputVector>
+inline
+void
+DoFCellAccessor<DH>::
+distribute_local_to_global (const Vector<number> &local_source,
+                           OutputVector         &global_destination) const
+{
+                                  // since the exception classes are
+                                  // from a template dependent base
+                                  // class, we have to fully qualify
+                                  // them. to work around more
+                                  // trouble, typedef the template
+                                  // dependent base class to a
+                                  // non-template dependent name and
+                                  // use that to specify the
+                                  // qualified exception names
+  typedef DoFAccessor<DH> BaseClass;
+  
+  Assert (this->dof_handler != 0,
+         typename BaseClass::ExcInvalidObject());
+  Assert (&this->get_fe() != 0,
+         typename BaseClass::ExcInvalidObject());
+  Assert (local_source.size() == (2*this->get_fe().dofs_per_vertex +
+                                 this->get_fe().dofs_per_line),
+         typename BaseClass::ExcVectorDoesNotMatch());
+  Assert (this->dof_handler->n_dofs() == global_destination.size(),
+         typename BaseClass::ExcVectorDoesNotMatch());
+
+  const unsigned int n_dofs = local_source.size();
+
+//TODO[WB]: This function could me made more efficient. First, it allocates memory, which could be avoided by passing in another argument as a scratch array. second, the elementwise access is really slow if we use PETSc vectors/matrices. This should be fixed eventually
+  
+                                  // get indices of dofs
+  std::vector<unsigned int> dofs (n_dofs);
+  this->get_dof_indices (dofs);
+  
+                                  // distribute cell vector
+  for (unsigned int j=0; j<n_dofs; ++j)
+    global_destination(dofs[j]) += local_source(j);
+}
+
+
+
+template <class DH>
+template <typename number, typename OutputMatrix>
+inline
+void
+DoFCellAccessor<DH>::
+distribute_local_to_global (const FullMatrix<number> &local_source,
+                           OutputMatrix             &global_destination) const
+{
+                                  // since the exception classes are
+                                  // from a template dependent base
+                                  // class, we have to fully qualify
+                                  // them. to work around more
+                                  // trouble, typedef the template
+                                  // dependent base class to a
+                                  // non-template dependent name and
+                                  // use that to specify the
+                                  // qualified exception names
+  typedef DoFAccessor<DH> BaseClass;
+  
+  Assert (this->dof_handler != 0,
+         typename BaseClass::ExcInvalidObject());
+  Assert (&this->get_fe() != 0,
+         typename BaseClass::ExcInvalidObject());
+  Assert (local_source.m() == (2*this->get_fe().dofs_per_vertex +
+                               this->get_fe().dofs_per_line),
+         typename BaseClass::ExcVectorDoesNotMatch());
+  Assert (local_source.m() == local_source.n(),
+         typename BaseClass::ExcMatrixDoesNotMatch());
+  Assert (this->dof_handler->n_dofs() == global_destination.m(),
+         typename BaseClass::ExcMatrixDoesNotMatch());
+  Assert (global_destination.m() == global_destination.n(),
+         typename BaseClass::ExcMatrixDoesNotMatch());
+
+  const unsigned int n_dofs = local_source.m();
+
+//TODO[WB]: This function could me made more efficient. First, it allocates memory, which could be avoided by passing in another argument as a scratch array. second, the elementwise access is really slow if we use PETSc vectors/matrices. This should be fixed eventually
+
+                                  // get indices of dofs
+  std::vector<unsigned int> dofs (n_dofs);
+  this->get_dof_indices (dofs);
+  
+                                  // distribute cell matrix
+  for (unsigned int i=0; i<n_dofs; ++i)
+    for (unsigned int j=0; j<n_dofs; ++j)
+      global_destination.add(dofs[i], dofs[j], local_source(i,j));
+}
+
+
+
 #endif
index 2c9cb90c7c4845b49ded1f1c55124e9575947898..540a72ad66aecef92e7320efd8e67c62c4ffaf8c 100644 (file)
@@ -44,6 +44,19 @@ inconvenience this causes.
 
 
 <ol>
+  <li> <p>
+       Changed: The <code
+       class="member">distribute_local_to_global</code> functions have
+       been moved from the classes implementing accessors to arbitrary
+       objects in the triangulation to the cell accessors, to
+       facilitate the implementation of hp methods. That means
+       that you can't call these functions for face or edge iterators
+       any more, but only cells. Since this is what is usually
+       desired, this should not be too severe a restriction.
+       <br> 
+       (WB 2006/04/26)
+       </p>
+
   <li> <p>
        Changed: The template argument of the <code
        class="class">InterGridMap</code> class has been changed. Code

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.