unify exceptions and add groups to VectorTools functions

git-svn-id: https://svn.dealii.org/trunk@14793 0785d39b-7218-0410-832d-ea1e28bc413d

diff --git a/deal.II/deal.II/include/fe/fe_tools.h b/deal.II/deal.II/include/fe/fe_tools.h
index 5021bf6424e55c00fc01e5f0bb54c0a3a7ed2880..88ee8312329df7fa122137fa8e64113b9f34dc55 100644 (file)
--- a/deal.II/deal.II/include/fe/fe_tools.h
+++ b/deal.II/deal.II/include/fe/fe_tools.h
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
+//    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -1182,7 +1182,7 @@ class FETools
                                      *
                                      * @ingroup Exceptions
                                       */
-    DeclException0 (ExcFEMustBePrimitive);
+    DeclException0 (ExcFENotPrimitive);
                                     /**
                                      * Exception
                                      *

diff --git a/deal.II/deal.II/include/numerics/vectors.h b/deal.II/deal.II/include/numerics/vectors.h
index 148f197f9ff450d64808bb489c294367b30cece5..9f07bf08cb45740307f4f6837749016dc7ee20fe 100644 (file)
--- a/deal.II/deal.II/include/numerics/vectors.h
+++ b/deal.II/deal.II/include/numerics/vectors.h
@@ -394,7 +394,10 @@ class VectorTools
          W1infty_norm
 
     };
-
+/**
+ * @name Interpolation and projection
+ */
+                                    //@{
                                     /**
                                      * Compute the interpolation of
                                      * @p function at the support
@@ -523,7 +526,7 @@ class VectorTools
                         const bool                project_to_boundary_first = false);
 
                                     /**
-                                     * Calls the @p project
+                                     * Calls the project()
                                      * function, see above, with
                                      * <tt>mapping=MappingQ1@<dim@>()</tt>.
                                      */
@@ -539,191 +542,6 @@ class VectorTools
                                                                  Quadrature<dim-1>(0)),
                         const bool                project_to_boundary_first = false);
 
-                                    /**
-                                     * Create a right hand side
-                                     * vector. Prior content of the
-                                     * given @p rhs_vector vector is
-                                     * deleted.
-                                     *
-                                     * See the general documentation of this
-                                     * class for further information.
-                                     */
-    template <int dim>
-    static void create_right_hand_side (const Mapping<dim>    &mapping,
-                                       const DoFHandler<dim> &dof,
-                                       const Quadrature<dim> &q,
-                                       const Function<dim>   &rhs,
-                                       Vector<double>        &rhs_vector);
-
-                                    /**
-                                     * Calls the @p create_right_hand_side
-                                     * function, see above, with
-                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
-                                     */
-    template <int dim>
-    static void create_right_hand_side (const DoFHandler<dim> &dof,
-                                       const Quadrature<dim> &q,
-                                       const Function<dim>   &rhs,
-                                       Vector<double>        &rhs_vector);
-
-                                    /**
-                                     * Like the previous set of functions,
-                                     * but for hp objects.
-                                     */
-    template <int dim>
-    static void create_right_hand_side (const hp::MappingCollection<dim>    &mapping,
-                                       const hp::DoFHandler<dim> &dof,
-                                       const hp::QCollection<dim> &q,
-                                       const Function<dim>   &rhs,
-                                       Vector<double>        &rhs_vector);
-
-                                    /**
-                                     * Like the previous set of functions,
-                                     * but for hp objects.
-                                     */
-    template <int dim>
-    static void create_right_hand_side (const hp::DoFHandler<dim> &dof,
-                                       const hp::QCollection<dim> &q,
-                                       const Function<dim>   &rhs,
-                                       Vector<double>        &rhs_vector);
-    
-                                    /**
-                                     * Create a right hand side
-                                     * vector for a point source at point @p p.
-                                      * Prior content of the
-                                     * given @p rhs_vector vector is
-                                     * deleted.
-                                     *
-                                     * See the general documentation of this
-                                     * class for further information.
-                                     */
-    template <int dim>
-    static void create_point_source_vector(const Mapping<dim>    &mapping,
-                                           const DoFHandler<dim> &dof,
-                                           const Point<dim>      &p,
-                                           Vector<double>        &rhs_vector);
-
-                                    /**
-                                     * Calls the @p create_point_source_vector
-                                     * function, see above, with
-                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
-                                     */
-    template <int dim>
-    static void create_point_source_vector(const DoFHandler<dim> &dof,
-                                           const Point<dim>      &p,
-                                           Vector<double>        &rhs_vector);
-
-                                    /**
-                                     * Like the previous set of functions,
-                                     * but for hp objects.
-                                     */
-    template <int dim>
-    static void create_point_source_vector(const hp::MappingCollection<dim>    &mapping,
-                                           const hp::DoFHandler<dim> &dof,
-                                           const Point<dim>      &p,
-                                           Vector<double>        &rhs_vector);
-
-                                    /**
-                                     * Like the previous set of functions,
-                                     * but for hp objects. The function uses
-                                     * the default Q1 mapping object. Note
-                                     * that if your hp::DoFHandler uses any
-                                     * active fe index other than zero, then
-                                     * you need to call the function above
-                                     * that provides a mapping object for
-                                     * each active fe index.
-                                     */
-    template <int dim>
-    static void create_point_source_vector(const hp::DoFHandler<dim> &dof,
-                                           const Point<dim>      &p,
-                                           Vector<double>        &rhs_vector);
-    
-                                     /**
-                                     * Create a right hand side
-                                     * vector from boundary
-                                     * forces. Prior content of the
-                                     * given @p rhs_vector vector is
-                                     * deleted.
-                                     *
-                                     * See the general documentation of this
-                                     * class for further information.
-                                     */
-    template <int dim>
-    static void create_boundary_right_hand_side (const Mapping<dim>      &mapping,
-                                                const DoFHandler<dim>   &dof,
-                                                const Quadrature<dim-1> &q,
-                                                const Function<dim>     &rhs,
-                                                Vector<double>          &rhs_vector,
-                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
-
-                                    /**
-                                     * Specialization of above
-                                     * function for 1d. Since the
-                                     * computation is not useful in
-                                     * 1d, this function simply
-                                     * throws an exception.
-                                     */
-    static void create_boundary_right_hand_side (const Mapping<1>    &mapping,
-                                                const DoFHandler<1> &dof,
-                                                const Quadrature<0> &q,
-                                                const Function<1>   &rhs,
-                                                Vector<double>      &rhs_vector,
-                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
-
-                                    /**
-                                     * Calls the
-                                     * @p create_boundary_right_hand_side
-                                     * function, see above, with
-                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
-                                     */
-    template <int dim>
-    static void create_boundary_right_hand_side (const DoFHandler<dim>   &dof,
-                                                const Quadrature<dim-1> &q,
-                                                const Function<dim>     &rhs,
-                                                Vector<double>          &rhs_vector,
-                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
-
-                                     /**
-                                     * Same as the set of functions above,
-                                     * but for hp objects.
-                                     */
-    template <int dim>
-    static void create_boundary_right_hand_side (const hp::MappingCollection<dim>      &mapping,
-                                                const hp::DoFHandler<dim>   &dof,
-                                                const hp::QCollection<dim-1> &q,
-                                                const Function<dim>     &rhs,
-                                                Vector<double>          &rhs_vector,
-                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
-
-                                    /**
-                                     * Specialization of above
-                                     * function for 1d. Since the
-                                     * computation is not useful in
-                                     * 1d, this function simply
-                                     * throws an exception.
-                                     */
-    static void create_boundary_right_hand_side (const hp::MappingCollection<1>    &mapping,
-                                                const hp::DoFHandler<1> &dof,
-                                                const hp::QCollection<0> &q,
-                                                const Function<1>   &rhs,
-                                                Vector<double>      &rhs_vector,
-                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
-
-                                    /**
-                                     * Calls the @p
-                                     * create_boundary_right_hand_side
-                                     * function, see above, with a single Q1
-                                     * mapping as collection. This function
-                                     * therefore will only work if the only
-                                     * active fe index in use is zero.
-                                     */
-    template <int dim>
-    static void create_boundary_right_hand_side (const hp::DoFHandler<dim>   &dof,
-                                                const hp::QCollection<dim-1> &q,
-                                                const Function<dim>     &rhs,
-                                                Vector<double>          &rhs_vector,
-                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
-
                                     /**
                                      * Prepare Dirichlet boundary
                                      * conditions.  Make up the list
@@ -947,6 +765,204 @@ class VectorTools
                                         const Quadrature<dim-1>  &q,
                                         std::map<unsigned int,double> &boundary_values);
 
+                                    //@}
+                                    /**
+                                     * @name Assembling of right hand sides
+                                     */
+                                    //@{
+    
+                                    /**
+                                     * Create a right hand side
+                                     * vector. Prior content of the
+                                     * given @p rhs_vector vector is
+                                     * deleted.
+                                     *
+                                     * See the general documentation of this
+                                     * class for further information.
+                                     */
+    template <int dim>
+    static void create_right_hand_side (const Mapping<dim>    &mapping,
+                                       const DoFHandler<dim> &dof,
+                                       const Quadrature<dim> &q,
+                                       const Function<dim>   &rhs,
+                                       Vector<double>        &rhs_vector);
+
+                                    /**
+                                     * Calls the @p create_right_hand_side
+                                     * function, see above, with
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
+                                     */
+    template <int dim>
+    static void create_right_hand_side (const DoFHandler<dim> &dof,
+                                       const Quadrature<dim> &q,
+                                       const Function<dim>   &rhs,
+                                       Vector<double>        &rhs_vector);
+
+                                    /**
+                                     * Like the previous set of functions,
+                                     * but for hp objects.
+                                     */
+    template <int dim>
+    static void create_right_hand_side (const hp::MappingCollection<dim>    &mapping,
+                                       const hp::DoFHandler<dim> &dof,
+                                       const hp::QCollection<dim> &q,
+                                       const Function<dim>   &rhs,
+                                       Vector<double>        &rhs_vector);
+
+                                    /**
+                                     * Like the previous set of functions,
+                                     * but for hp objects.
+                                     */
+    template <int dim>
+    static void create_right_hand_side (const hp::DoFHandler<dim> &dof,
+                                       const hp::QCollection<dim> &q,
+                                       const Function<dim>   &rhs,
+                                       Vector<double>        &rhs_vector);
+    
+                                    /**
+                                     * Create a right hand side
+                                     * vector for a point source at point @p p.
+                                      * Prior content of the
+                                     * given @p rhs_vector vector is
+                                     * deleted.
+                                     *
+                                     * See the general documentation of this
+                                     * class for further information.
+                                     */
+    template <int dim>
+    static void create_point_source_vector(const Mapping<dim>    &mapping,
+                                           const DoFHandler<dim> &dof,
+                                           const Point<dim>      &p,
+                                           Vector<double>        &rhs_vector);
+
+                                    /**
+                                     * Calls the @p create_point_source_vector
+                                     * function, see above, with
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
+                                     */
+    template <int dim>
+    static void create_point_source_vector(const DoFHandler<dim> &dof,
+                                           const Point<dim>      &p,
+                                           Vector<double>        &rhs_vector);
+
+                                    /**
+                                     * Like the previous set of functions,
+                                     * but for hp objects.
+                                     */
+    template <int dim>
+    static void create_point_source_vector(const hp::MappingCollection<dim>    &mapping,
+                                           const hp::DoFHandler<dim> &dof,
+                                           const Point<dim>      &p,
+                                           Vector<double>        &rhs_vector);
+
+                                    /**
+                                     * Like the previous set of functions,
+                                     * but for hp objects. The function uses
+                                     * the default Q1 mapping object. Note
+                                     * that if your hp::DoFHandler uses any
+                                     * active fe index other than zero, then
+                                     * you need to call the function above
+                                     * that provides a mapping object for
+                                     * each active fe index.
+                                     */
+    template <int dim>
+    static void create_point_source_vector(const hp::DoFHandler<dim> &dof,
+                                           const Point<dim>      &p,
+                                           Vector<double>        &rhs_vector);
+    
+                                     /**
+                                     * Create a right hand side
+                                     * vector from boundary
+                                     * forces. Prior content of the
+                                     * given @p rhs_vector vector is
+                                     * deleted.
+                                     *
+                                     * See the general documentation of this
+                                     * class for further information.
+                                     */
+    template <int dim>
+    static void create_boundary_right_hand_side (const Mapping<dim>      &mapping,
+                                                const DoFHandler<dim>   &dof,
+                                                const Quadrature<dim-1> &q,
+                                                const Function<dim>     &rhs,
+                                                Vector<double>          &rhs_vector,
+                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
+
+                                    /**
+                                     * Specialization of above
+                                     * function for 1d. Since the
+                                     * computation is not useful in
+                                     * 1d, this function simply
+                                     * throws an exception.
+                                     */
+    static void create_boundary_right_hand_side (const Mapping<1>    &mapping,
+                                                const DoFHandler<1> &dof,
+                                                const Quadrature<0> &q,
+                                                const Function<1>   &rhs,
+                                                Vector<double>      &rhs_vector,
+                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
+
+                                    /**
+                                     * Calls the
+                                     * @p create_boundary_right_hand_side
+                                     * function, see above, with
+                                     * <tt>mapping=MappingQ1@<dim@>()</tt>.
+                                     */
+    template <int dim>
+    static void create_boundary_right_hand_side (const DoFHandler<dim>   &dof,
+                                                const Quadrature<dim-1> &q,
+                                                const Function<dim>     &rhs,
+                                                Vector<double>          &rhs_vector,
+                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
+
+                                     /**
+                                     * Same as the set of functions above,
+                                     * but for hp objects.
+                                     */
+    template <int dim>
+    static void create_boundary_right_hand_side (const hp::MappingCollection<dim>      &mapping,
+                                                const hp::DoFHandler<dim>   &dof,
+                                                const hp::QCollection<dim-1> &q,
+                                                const Function<dim>     &rhs,
+                                                Vector<double>          &rhs_vector,
+                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
+
+                                    /**
+                                     * Specialization of above
+                                     * function for 1d. Since the
+                                     * computation is not useful in
+                                     * 1d, this function simply
+                                     * throws an exception.
+                                     */
+    static void create_boundary_right_hand_side (const hp::MappingCollection<1>    &mapping,
+                                                const hp::DoFHandler<1> &dof,
+                                                const hp::QCollection<0> &q,
+                                                const Function<1>   &rhs,
+                                                Vector<double>      &rhs_vector,
+                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
+
+                                    /**
+                                     * Calls the @p
+                                     * create_boundary_right_hand_side
+                                     * function, see above, with a single Q1
+                                     * mapping as collection. This function
+                                     * therefore will only work if the only
+                                     * active fe index in use is zero.
+                                     */
+    template <int dim>
+    static void create_boundary_right_hand_side (const hp::DoFHandler<dim>   &dof,
+                                                const hp::QCollection<dim-1> &q,
+                                                const Function<dim>     &rhs,
+                                                Vector<double>          &rhs_vector,
+                                                const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
+
+                                    //@}
+                                    /**
+                                     * @name Evaluation of functions
+                                     * and errors
+                                     */
+                                    //@{
+    
                                     /**
                                      * Compute the error of the
                                      * finite element solution.
@@ -1200,7 +1216,13 @@ class VectorTools
                  const DoFHandler<dim> &dof,
                 const InVector        &fe_function,
                 const Point<dim>      &point);
-
+    
+                                    //@}
+                                    /**
+                                     * Mean value operations
+                                     */
+                                    //@{
+    
                                      /**
                                      * Subtract the (algebraic) mean value
                                      * from a vector. This function is most
@@ -1280,15 +1302,8 @@ class VectorTools
                                      const Quadrature<dim> &quadrature,
                                      const InVector        &v,
                                      const unsigned int     component);
+                                    //@}
 
-                                    /**
-                                     * Exception
-                                     */
-    DeclException0 (ExcInvalidFE);
-                                    /**
-                                     * Exception
-                                     */
-    DeclException0 (ExcFENotPrimitive);
                                     /**
                                      * Exception
                                      */
@@ -1296,10 +1311,6 @@ class VectorTools
                                     /**
                                      * Exception
                                      */
-    DeclException0 (ExcComponentMismatch);
-                                    /**
-                                     * Exception
-                                     */
     DeclException0 (ExcNonInterpolatingFE);
                                      /**
                                       * Exception

diff --git a/deal.II/deal.II/include/numerics/vectors.templates.h b/deal.II/deal.II/include/numerics/vectors.templates.h
index 84661e3da37ed4c834bf57f87bb7e0487eea55c7..13e5071a7edc52524688910f75a4dcdb8ca5f045 100644 (file)
--- a/deal.II/deal.II/include/numerics/vectors.templates.h
+++ b/deal.II/deal.II/include/numerics/vectors.templates.h
@@ -29,6 +29,7 @@
 #include <dofs/dof_constraints.h>
 #include <dofs/dof_tools.h>
 #include <fe/fe.h>
+#include <fe/fe_tools.h>
 #include <hp/fe_values.h>
 #include <fe/mapping_q1.h>
 #include <hp/mapping_collection.h>
@@ -52,7 +53,8 @@ void VectorTools::interpolate (const Mapping<dim>    &mapping,
                               VECTOR                &vec)
 {
   Assert (dof.get_fe().n_components() == function.n_components,
-         ExcComponentMismatch());
+         ExcDimensionMismatch(dof.get_fe().n_components(),
+                              function.n_components));
   
   const hp::FECollection<dim> fe (dof.get_fe());
   const unsigned int          n_components = fe.n_components();
@@ -395,7 +397,8 @@ void VectorTools::project (const Mapping<dim>       &mapping,
                           const bool                project_to_boundary_first)
 {
   Assert (dof.get_fe().n_components() == function.n_components,
-         ExcInvalidFE());
+         ExcDimensionMismatch(dof.get_fe().n_components(),
+                              function.n_components));
 
   Assert (vec_result.size() == dof.n_dofs(),
           ExcDimensionMismatch (vec_result.size(), dof.n_dofs()));
@@ -507,7 +510,7 @@ void VectorTools::create_right_hand_side (const Mapping<dim>    &mapping,
 {
   const FiniteElement<dim> &fe  = dof_handler.get_fe();
   Assert (fe.n_components() == rhs_function.n_components,
-         ExcComponentMismatch());
+         ExcDimensionMismatch(fe.n_components(), rhs_function.n_components));
   Assert (rhs_vector.size() == dof_handler.n_dofs(),
          ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
   rhs_vector = 0;
@@ -632,7 +635,7 @@ void VectorTools::create_right_hand_side (const hp::MappingCollection<dim>    &m
 {
   const hp::FECollection<dim> &fe  = dof_handler.get_fe();
   Assert (fe.n_components() == rhs_function.n_components,
-         ExcComponentMismatch());
+         ExcDimensionMismatch(fe.n_components(), rhs_function.n_components));
   Assert (rhs_vector.size() == dof_handler.n_dofs(),
          ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
   rhs_vector = 0;
@@ -867,7 +870,7 @@ VectorTools::create_boundary_right_hand_side (const Mapping<dim>      &mapping,
 {
   const FiniteElement<dim> &fe  = dof_handler.get_fe();
   Assert (fe.n_components() == rhs_function.n_components,
-         ExcComponentMismatch());
+         ExcDimensionMismatch(fe.n_components(), rhs_function.n_components));
   Assert (rhs_vector.size() == dof_handler.n_dofs(),
          ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
   
@@ -1021,7 +1024,7 @@ VectorTools::create_boundary_right_hand_side (const hp::MappingCollection<dim>
 {
   const hp::FECollection<dim> &fe  = dof_handler.get_fe();
   Assert (fe.n_components() == rhs_function.n_components,
-         ExcComponentMismatch());
+         ExcDimensionMismatch(fe.n_components(), rhs_function.n_components));
   Assert (rhs_vector.size() == dof_handler.n_dofs(),
          ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
   
@@ -1215,7 +1218,7 @@ VectorTools::interpolate_boundary_values (const Mapping<1>         &,
                                    // cell
   const FiniteElement<1> &fe = outermost_cell->get_fe();
   Assert (fe.n_components() == boundary_function.n_components,
-         ExcComponentMismatch());
+         ExcDimensionMismatch(fe.n_components(), boundary_function.n_components));
 
                                   // set the component mask to either
                                   // the original value or a vector
@@ -1224,7 +1227,7 @@ VectorTools::interpolate_boundary_values (const Mapping<1>         &,
                                          std::vector<bool> (fe.n_components(), true) :
                                          component_mask_);
   Assert (std::count(component_mask.begin(), component_mask.end(), true) > 0,
-         ExcComponentMismatch());
+         ExcNoComponentSelected());
 
                                   // now set the value of the
                                   // outermost degree of
@@ -1311,7 +1314,7 @@ interpolate_boundary_values (const Mapping<dim>            &mapping,
   for (typename FunctionMap<dim>::type::const_iterator i=function_map.begin();
        i!=function_map.end(); ++i)
     Assert (n_components == i->second->n_components,
-           ExcInvalidFE());
+           ExcDimensionMismatch(n_components, i->second->n_components));
 
                                   // set the component mask to either
                                   // the original value or a vector
@@ -1320,7 +1323,7 @@ interpolate_boundary_values (const Mapping<dim>            &mapping,
                                          std::vector<bool> (n_components, true) :
                                          component_mask_);
   Assert (std::count(component_mask.begin(), component_mask.end(), true) > 0,
-         ExcComponentMismatch());
+         ExcNoComponentSelected());
 
                                   // field to store the indices
   std::vector<unsigned int> face_dofs;
@@ -1537,7 +1540,7 @@ interpolate_boundary_values (const Mapping<dim>            &mapping,
                           for (unsigned int c=0; c<n_components; ++c)
                             if (fe.get_nonzero_components(cell_i)[c])
                               Assert (component_mask[c] == false,
-                                      ExcFENotPrimitive());
+                                      FETools::ExcFENotPrimitive());
 
                                                          // let's pick
                                                          // the first
@@ -1681,7 +1684,8 @@ VectorTools::project_boundary_values (const Mapping<dim>       &mapping,
 //    acceptable for higher dimensions. Fix this.
 
   Assert (dof.get_fe().n_components() == boundary_functions.begin()->second->n_components,
-         ExcComponentMismatch());
+         ExcDimensionMismatch(dof.get_fe().n_components(),
+                              boundary_functions.begin()->second->n_components));
   
   std::vector<unsigned int> dof_to_boundary_mapping;
   std::set<unsigned char> selected_boundary_components;

diff --git a/deal.II/deal.II/source/fe/fe_tools.cc b/deal.II/deal.II/source/fe/fe_tools.cc
index 3b17e2ae8a9ab217fadb2ba4f22f90ea4d18af3a..ed50d20c07b168045068fb7eb20a7568c8595780 100644 (file)
--- a/deal.II/deal.II/source/fe/fe_tools.cc
+++ b/deal.II/deal.II/source/fe/fe_tools.cc
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
+//    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -375,8 +375,8 @@ void FETools::get_interpolation_matrix (const FiniteElement<dim> &fe1,
                                   // way. note that this will only
                                   // work if the element is
                                   // primitive, so check this first
-  Assert (fe1.is_primitive() == true, ExcFEMustBePrimitive());
-  Assert (fe2.is_primitive() == true, ExcFEMustBePrimitive());
+  Assert (fe1.is_primitive() == true, ExcFENotPrimitive());
+  Assert (fe2.is_primitive() == true, ExcFENotPrimitive());
 
                                   // Initialize FEValues for fe1 at
                                   // the unit support points of the