Prefer PolynomialType to POLY.

diff --git a/include/deal.II/base/tensor_product_polynomials.h b/include/deal.II/base/tensor_product_polynomials.h
index 8f71e53ae1173e1001e345f022a181ad7b070931..daff8beebca73bf5d07c5ebec574f00cd2183849 100644 (file)
--- a/include/deal.II/base/tensor_product_polynomials.h
+++ b/include/deal.II/base/tensor_product_polynomials.h
@@ -60,7 +60,7 @@ DEAL_II_NAMESPACE_OPEN
  * @author Ralf Hartmann, 2000, 2004, Guido Kanschat, 2000, Wolfgang Bangerth
  * 2003
  */
-template <int dim, typename POLY=Polynomials::Polynomial<double> >
+template <int dim, typename PolynomialType=Polynomials::Polynomial<double> >
 class TensorProductPolynomials
 {
 public:
@@ -73,8 +73,8 @@ public:
   /**
    * Constructor. <tt>pols</tt> is a vector of objects that should be derived
    * or otherwise convertible to one-dimensional polynomial objects of type @p
-   * POLY (template argument of class). It will be copied element by element
-   * into a private variable.
+   * PolynomialType (template argument of class). It will be copied element by
+   * element into a private variable.
    */
   template <class Pol>
   TensorProductPolynomials (const std::vector<Pol> &pols);
@@ -193,7 +193,7 @@ protected:
   /**
    * Copy of the vector <tt>pols</tt> of polynomials given to the constructor.
    */
-  std::vector<POLY> polynomials;
+  std::vector<PolynomialType> polynomials;
 
   /**
    * Number of tensor product polynomials. See n().
@@ -380,10 +380,10 @@ private:
 /* ---------------- template and inline functions ---------- */
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 template <class Pol>
 inline
-TensorProductPolynomials<dim,POLY>::
+TensorProductPolynomials<dim,PolynomialType>::
 TensorProductPolynomials(const std::vector<Pol> &pols)
   :
   polynomials (pols.begin(), pols.end()),
@@ -402,10 +402,10 @@ TensorProductPolynomials(const std::vector<Pol> &pols)
 
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 inline
 unsigned int
-TensorProductPolynomials<dim,POLY>::n() const
+TensorProductPolynomials<dim,PolynomialType>::n() const
 {
   if (dim == 0)
     return numbers::invalid_unsigned_int;
@@ -415,28 +415,29 @@ TensorProductPolynomials<dim,POLY>::n() const
 
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 inline
 const std::vector<unsigned int> &
-TensorProductPolynomials<dim,POLY>::get_numbering() const
+TensorProductPolynomials<dim,PolynomialType>::get_numbering() const
 {
   return index_map;
 }
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 inline
 const std::vector<unsigned int> &
-TensorProductPolynomials<dim,POLY>::get_numbering_inverse() const
+TensorProductPolynomials<dim,PolynomialType>::get_numbering_inverse() const
 {
   return index_map_inverse;
 }
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 template <int order>
 Tensor<order,dim>
-TensorProductPolynomials<dim,POLY>::compute_derivative (const unsigned int i,
-                                                        const Point<dim> &p) const
+TensorProductPolynomials<dim,PolynomialType>::compute_derivative
+(const unsigned int  i,
+ const Point<dim>   &p) const
 {
   unsigned int indices[dim];
   compute_index (i, indices);

diff --git a/include/deal.II/fe/fe_dg_vector.h b/include/deal.II/fe/fe_dg_vector.h
index 254fd109061ba1faa810eb08b75b3f4ac36021de..bb575e02322df30945917bf19adf3a79e690f3c8 100644 (file)
--- a/include/deal.II/fe/fe_dg_vector.h
+++ b/include/deal.II/fe/fe_dg_vector.h
@@ -43,7 +43,7 @@ template <int dim, int spacedim> class MappingQ;
  * are suitable for DG and hybrid formulations involving these function
  * spaces.
  *
- * The template argument <tt>POLY</tt> refers to a vector valued polynomial
+ * The template argument <tt>PolynomialType</tt> refers to a vector valued polynomial
  * space like PolynomialsRaviartThomas or PolynomialsNedelec. Note that the
  * dimension of the polynomial space and the argument <tt>dim</tt> must
  * coincide.
@@ -52,10 +52,10 @@ template <int dim, int spacedim> class MappingQ;
  * @author Guido Kanschat
  * @date 2010
  */
-template <class POLY, int dim, int spacedim=dim>
+template <class PolynomialType, int dim, int spacedim=dim>
 class FE_DGVector
   :
-  public FE_PolyTensor<POLY, dim, spacedim>
+  public FE_PolyTensor<PolynomialType, dim, spacedim>
 {
 public:
   /**

diff --git a/include/deal.II/fe/fe_dg_vector.templates.h b/include/deal.II/fe/fe_dg_vector.templates.h
index b972a85af3d3110dbcbf485d2cfbb2d070dac72e..17e10b14cc15dbf22404ab4651166bdbb354ea97 100644 (file)
--- a/include/deal.II/fe/fe_dg_vector.templates.h
+++ b/include/deal.II/fe/fe_dg_vector.templates.h
@@ -23,16 +23,16 @@ DEAL_II_NAMESPACE_OPEN
 
 //TODO:[GK] deg+1 is wrong here and should be fixed after FiniteElementData was cleaned up
 
-template <class POLY, int dim, int spacedim>
-FE_DGVector<POLY,dim,spacedim>::FE_DGVector (
+template <class PolynomialType, int dim, int spacedim>
+FE_DGVector<PolynomialType,dim,spacedim>::FE_DGVector (
   const unsigned int deg, MappingType map)
   :
-  FE_PolyTensor<POLY, dim, spacedim>(
+  FE_PolyTensor<PolynomialType, dim, spacedim>(
     deg,
     FiniteElementData<dim>(
       get_dpo_vector(deg), dim, deg+1, FiniteElementData<dim>::L2, 1),
-    std::vector<bool>(POLY::compute_n_pols(deg), true),
-    std::vector<ComponentMask>(POLY::compute_n_pols(deg),
+    std::vector<bool>(PolynomialType::compute_n_pols(deg), true),
+    std::vector<ComponentMask>(PolynomialType::compute_n_pols(deg),
                                ComponentMask(dim,true)))
 {
   this->mapping_type = map;
@@ -47,17 +47,17 @@ FE_DGVector<POLY,dim,spacedim>::FE_DGVector (
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 FiniteElement<dim, spacedim> *
-FE_DGVector<POLY,dim,spacedim>::clone() const
+FE_DGVector<PolynomialType,dim,spacedim>::clone() const
 {
-  return new FE_DGVector<POLY, dim, spacedim>(*this);
+  return new FE_DGVector<PolynomialType, dim, spacedim>(*this);
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 std::string
-FE_DGVector<POLY,dim,spacedim>::get_name() const
+FE_DGVector<PolynomialType,dim,spacedim>::get_name() const
 {
   std::ostringstream namebuf;
   namebuf << "FE_DGVector_" << this->poly_space.name()
@@ -66,59 +66,60 @@ FE_DGVector<POLY,dim,spacedim>::get_name() const
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 std::vector<unsigned int>
-FE_DGVector<POLY,dim,spacedim>::get_dpo_vector (const unsigned int deg)
+FE_DGVector<PolynomialType,dim,spacedim>::get_dpo_vector (const unsigned int deg)
 {
   std::vector<unsigned int> dpo(dim+1);
-  dpo[dim] = POLY::compute_n_pols(deg);
+  dpo[dim] = PolynomialType::compute_n_pols(deg);
 
   return dpo;
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 bool
-FE_DGVector<POLY,dim,spacedim>::has_support_on_face (const unsigned int,
-                                                     const unsigned int) const
+FE_DGVector<PolynomialType,dim,spacedim>::has_support_on_face
+(const unsigned int,
+ const unsigned int) const
 {
   return true;
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_DGVector<POLY,dim,spacedim>::interpolate(
-  std::vector<double> &,
-  const std::vector<double> &) const
+FE_DGVector<PolynomialType,dim,spacedim>::interpolate
+(std::vector<double> &,
+ const std::vector<double> &) const
 {
   Assert(false, ExcNotImplemented());
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_DGVector<POLY,dim,spacedim>::interpolate(
-  std::vector<double> & /*local_dofs*/,
-  const std::vector<Vector<double> > & /*values*/,
-  unsigned int /*offset*/) const
+FE_DGVector<PolynomialType,dim,spacedim>::interpolate
+(std::vector<double> & /*local_dofs*/,
+ const std::vector<Vector<double> > & /*values*/,
+ unsigned int /*offset*/) const
 {
   Assert(false, ExcNotImplemented());
 }
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_DGVector<POLY,dim,spacedim>::interpolate(
-  std::vector<double> & /*local_dofs*/,
-  const VectorSlice<const std::vector<std::vector<double> > > & /*values*/) const
+FE_DGVector<PolynomialType,dim,spacedim>::interpolate
+(std::vector<double> & /*local_dofs*/,
+ const VectorSlice<const std::vector<std::vector<double> > > & /*values*/) const
 {
   Assert(false, ExcNotImplemented());
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 std::size_t
-FE_DGVector<POLY,dim,spacedim>::memory_consumption() const
+FE_DGVector<PolynomialType,dim,spacedim>::memory_consumption() const
 {
   Assert(false, ExcNotImplemented());
   return 0;

diff --git a/include/deal.II/fe/fe_poly.h b/include/deal.II/fe/fe_poly.h
index b74c75cb62f092cbd4b61df9c4d91a388736af92..134b5ef3a06c5c9d900b30381a4b7414f655c5f3 100644 (file)
--- a/include/deal.II/fe/fe_poly.h
+++ b/include/deal.II/fe/fe_poly.h
@@ -31,7 +31,7 @@ DEAL_II_NAMESPACE_OPEN
  * TensorProductPolynomials or PolynomialSpace classes.
  *
  * Every class conforming to the following interface can be used as template
- * parameter POLY.
+ * parameter PolynomialType.
  *
  * @code
  * static const unsigned int dimension;
@@ -65,14 +65,14 @@ DEAL_II_NAMESPACE_OPEN
  * @author Ralf Hartmann 2004, Guido Kanschat, 2009
  */
 
-template <class POLY, int dim=POLY::dimension, int spacedim=dim>
+template <class PolynomialType, int dim=PolynomialType::dimension, int spacedim=dim>
 class FE_Poly : public FiniteElement<dim,spacedim>
 {
 public:
   /**
    * Constructor.
    */
-  FE_Poly (const POLY &poly_space,
+  FE_Poly (const PolynomialType &poly_space,
            const FiniteElementData<dim> &fe_data,
            const std::vector<bool> &restriction_is_additive_flags,
            const std::vector<ComponentMask> &nonzero_components);
@@ -91,13 +91,13 @@ public:
   /**
    * Return the numbering of the underlying polynomial space compared to
    * lexicographic ordering of the basis functions. Returns
-   * POLY::get_numbering().
+   * PolynomialType::get_numbering().
    */
   std::vector<unsigned int> get_poly_space_numbering() const;
 
   /**
    * Return the inverse numbering of the underlying polynomial space. Returns
-   * POLY::get_numbering_inverse().
+   * PolynomialType::get_numbering_inverse().
    */
   std::vector<unsigned int> get_poly_space_numbering_inverse() const;
 
@@ -463,9 +463,9 @@ protected:
                              const unsigned int                                                dof) const;
 
   /**
-   * The polynomial space. Its type is given by the template parameter POLY.
+   * The polynomial space. Its type is given by the template parameter PolynomialType.
    */
-  POLY poly_space;
+  PolynomialType poly_space;
 };
 
 /*@}*/

diff --git a/include/deal.II/fe/fe_poly.templates.h b/include/deal.II/fe/fe_poly.templates.h
index fb160960b242301d6536f3c7aba006a9441089c7..c55bf59053b5417b78b6c139c39b03cb22bdfb41 100644 (file)
--- a/include/deal.II/fe/fe_poly.templates.h
+++ b/include/deal.II/fe/fe_poly.templates.h
@@ -25,43 +25,45 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-template <class POLY, int dim, int spacedim>
-FE_Poly<POLY,dim,spacedim>::FE_Poly (const POLY &poly_space,
-                                     const FiniteElementData<dim> &fe_data,
-                                     const std::vector<bool> &restriction_is_additive_flags,
-                                     const std::vector<ComponentMask> &nonzero_components):
+template <class PolynomialType, int dim, int spacedim>
+FE_Poly<PolynomialType,dim,spacedim>::FE_Poly
+(const PolynomialType             &poly_space,
+ const FiniteElementData<dim>     &fe_data,
+ const std::vector<bool>          &restriction_is_additive_flags,
+ const std::vector<ComponentMask> &nonzero_components):
   FiniteElement<dim,spacedim> (fe_data,
                                restriction_is_additive_flags,
                                nonzero_components),
   poly_space(poly_space)
 {
-  AssertDimension(dim, POLY::dimension);
+  AssertDimension(dim, PolynomialType::dimension);
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 unsigned int
-FE_Poly<POLY,dim,spacedim>::get_degree () const
+FE_Poly<PolynomialType,dim,spacedim>::get_degree () const
 {
   return this->degree;
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 double
-FE_Poly<POLY,dim,spacedim>::shape_value (const unsigned int i,
-                                         const Point<dim> &p) const
+FE_Poly<PolynomialType,dim,spacedim>::shape_value (const unsigned int i,
+                                                   const Point<dim>  &p) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   return poly_space.compute_value(i, p);
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 double
-FE_Poly<POLY,dim,spacedim>::shape_value_component (const unsigned int i,
-                                                   const Point<dim> &p,
-                                                   const unsigned int component) const
+FE_Poly<PolynomialType,dim,spacedim>::shape_value_component
+(const unsigned int  i,
+ const Point<dim>   &p,
+ const unsigned int  component) const
 {
   (void)component;
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
@@ -71,10 +73,10 @@ FE_Poly<POLY,dim,spacedim>::shape_value_component (const unsigned int i,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<1,dim>
-FE_Poly<POLY,dim,spacedim>::shape_grad (const unsigned int i,
-                                        const Point<dim> &p) const
+FE_Poly<PolynomialType,dim,spacedim>::shape_grad (const unsigned int i,
+                                                  const Point<dim>  &p) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   return poly_space.template compute_derivative<1>(i, p);
@@ -82,11 +84,11 @@ FE_Poly<POLY,dim,spacedim>::shape_grad (const unsigned int i,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<1,dim>
-FE_Poly<POLY,dim,spacedim>::shape_grad_component (const unsigned int i,
-                                                  const Point<dim> &p,
-                                                  const unsigned int component) const
+FE_Poly<PolynomialType,dim,spacedim>::shape_grad_component (const unsigned int  i,
+                                                            const Point<dim>   &p,
+                                                            const unsigned int  component) const
 {
   (void)component;
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
@@ -96,10 +98,10 @@ FE_Poly<POLY,dim,spacedim>::shape_grad_component (const unsigned int i,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<2,dim>
-FE_Poly<POLY,dim,spacedim>::shape_grad_grad (const unsigned int i,
-                                             const Point<dim> &p) const
+FE_Poly<PolynomialType,dim,spacedim>::shape_grad_grad (const unsigned int i,
+                                                       const Point<dim>  &p) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   return poly_space.template compute_derivative<2>(i, p);
@@ -107,11 +109,12 @@ FE_Poly<POLY,dim,spacedim>::shape_grad_grad (const unsigned int i,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<2,dim>
-FE_Poly<POLY,dim,spacedim>::shape_grad_grad_component (const unsigned int i,
-                                                       const Point<dim> &p,
-                                                       const unsigned int component) const
+FE_Poly<PolynomialType,dim,spacedim>::shape_grad_grad_component
+(const unsigned int  i,
+ const Point<dim>   &p,
+ const unsigned int  component) const
 {
   (void)component;
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
@@ -121,10 +124,10 @@ FE_Poly<POLY,dim,spacedim>::shape_grad_grad_component (const unsigned int i,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<3,dim>
-FE_Poly<POLY,dim,spacedim>::shape_3rd_derivative (const unsigned int i,
-                                                  const Point<dim> &p) const
+FE_Poly<PolynomialType,dim,spacedim>::shape_3rd_derivative (const unsigned int i,
+                                                            const Point<dim>  &p) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   return poly_space.template compute_derivative<3>(i, p);
@@ -132,11 +135,12 @@ FE_Poly<POLY,dim,spacedim>::shape_3rd_derivative (const unsigned int i,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<3,dim>
-FE_Poly<POLY,dim,spacedim>::shape_3rd_derivative_component (const unsigned int i,
-                                                            const Point<dim> &p,
-                                                            const unsigned int component) const
+FE_Poly<PolynomialType,dim,spacedim>::shape_3rd_derivative_component
+(const unsigned int  i,
+ const Point<dim>   &p,
+ const unsigned int  component) const
 {
   (void)component;
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
@@ -146,10 +150,10 @@ FE_Poly<POLY,dim,spacedim>::shape_3rd_derivative_component (const unsigned int i
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<4,dim>
-FE_Poly<POLY,dim,spacedim>::shape_4th_derivative (const unsigned int i,
-                                                  const Point<dim> &p) const
+FE_Poly<PolynomialType,dim,spacedim>::shape_4th_derivative (const unsigned int i,
+                                                            const Point<dim>  &p) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   return poly_space.template compute_derivative<4>(i, p);
@@ -157,11 +161,12 @@ FE_Poly<POLY,dim,spacedim>::shape_4th_derivative (const unsigned int i,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<4,dim>
-FE_Poly<POLY,dim,spacedim>::shape_4th_derivative_component (const unsigned int i,
-                                                            const Point<dim> &p,
-                                                            const unsigned int component) const
+FE_Poly<PolynomialType,dim,spacedim>::shape_4th_derivative_component
+(const unsigned int  i,
+ const Point<dim>   &p,
+ const unsigned int  component) const
 {
   (void)component;
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
@@ -176,18 +181,18 @@ FE_Poly<POLY,dim,spacedim>::shape_4th_derivative_component (const unsigned int i
 //---------------------------------------------------------------------------
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 UpdateFlags
-FE_Poly<POLY,dim,spacedim>::requires_update_flags (const UpdateFlags flags) const
+FE_Poly<PolynomialType,dim,spacedim>::requires_update_flags (const UpdateFlags flags) const
 {
   return update_once(flags) | update_each(flags);
 }
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 UpdateFlags
-FE_Poly<POLY,dim,spacedim>::update_once (const UpdateFlags flags) const
+FE_Poly<PolynomialType,dim,spacedim>::update_once (const UpdateFlags flags) const
 {
   // for this kind of elements, only
   // the values can be precomputed
@@ -199,9 +204,9 @@ FE_Poly<POLY,dim,spacedim>::update_once (const UpdateFlags flags) const
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 UpdateFlags
-FE_Poly<POLY,dim,spacedim>::update_each (const UpdateFlags flags) const
+FE_Poly<PolynomialType,dim,spacedim>::update_each (const UpdateFlags flags) const
 {
   UpdateFlags out = update_default;
 
@@ -228,9 +233,9 @@ FE_Poly<POLY,dim,spacedim>::update_each (const UpdateFlags flags) const
 //---------------------------------------------------------------------------
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_Poly<POLY,dim,spacedim>::
+FE_Poly<PolynomialType,dim,spacedim>::
 fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
                 const CellSimilarity::Similarity                                     cell_similarity,
                 const Quadrature<dim>                                               &quadrature,
@@ -292,9 +297,9 @@ fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_Poly<POLY,dim,spacedim>::
+FE_Poly<PolynomialType,dim,spacedim>::
 fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator           &cell,
                      const unsigned int                                                   face_no,
                      const Quadrature<dim-1>                                             &quadrature,
@@ -369,9 +374,9 @@ fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator
     }
 }
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_Poly<POLY,dim,spacedim>::
+FE_Poly<PolynomialType,dim,spacedim>::
 fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator           &cell,
                         const unsigned int                                                   face_no,
                         const unsigned int                                                   sub_no,
@@ -450,9 +455,9 @@ fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterato
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 inline void
-FE_Poly<POLY,dim,spacedim>::
+FE_Poly<PolynomialType,dim,spacedim>::
 correct_third_derivatives (internal::FEValues::FiniteElementRelatedData<dim,spacedim>       &output_data,
                            const internal::FEValues::MappingRelatedData<dim,spacedim>       &mapping_data,
                            const unsigned int                                                n_q_points,
@@ -479,36 +484,36 @@ correct_third_derivatives (internal::FEValues::FiniteElementRelatedData<dim,spac
 
 namespace internal
 {
-  template <class POLY>
+  template <class PolynomialType>
   inline
   std::vector<unsigned int>
-  get_poly_space_numbering (const POLY &)
+  get_poly_space_numbering (const PolynomialType &)
   {
     Assert (false, ExcNotImplemented());
     return std::vector<unsigned int>();
   }
 
-  template <class POLY>
+  template <class PolynomialType>
   inline
   std::vector<unsigned int>
-  get_poly_space_numbering_inverse (const POLY &)
+  get_poly_space_numbering_inverse (const PolynomialType &)
   {
     Assert (false, ExcNotImplemented());
     return std::vector<unsigned int>();
   }
 
-  template <int dim, typename POLY>
+  template <int dim, typename PolynomialType>
   inline
   std::vector<unsigned int>
-  get_poly_space_numbering (const TensorProductPolynomials<dim,POLY> &poly)
+  get_poly_space_numbering (const TensorProductPolynomials<dim,PolynomialType> &poly)
   {
     return poly.get_numbering();
   }
 
-  template <int dim, typename POLY>
+  template <int dim, typename PolynomialType>
   inline
   std::vector<unsigned int>
-  get_poly_space_numbering_inverse (const TensorProductPolynomials<dim,POLY> &poly)
+  get_poly_space_numbering_inverse (const TensorProductPolynomials<dim,PolynomialType> &poly)
   {
     return poly.get_numbering_inverse();
   }
@@ -532,9 +537,9 @@ namespace internal
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 std::vector<unsigned int>
-FE_Poly<POLY,dim,spacedim>::get_poly_space_numbering () const
+FE_Poly<PolynomialType,dim,spacedim>::get_poly_space_numbering () const
 {
   return internal::get_poly_space_numbering (poly_space);
 }
@@ -542,9 +547,9 @@ FE_Poly<POLY,dim,spacedim>::get_poly_space_numbering () const
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 std::vector<unsigned int>
-FE_Poly<POLY,dim,spacedim>::get_poly_space_numbering_inverse () const
+FE_Poly<PolynomialType,dim,spacedim>::get_poly_space_numbering_inverse () const
 {
   return internal::get_poly_space_numbering_inverse (poly_space);
 }

diff --git a/include/deal.II/fe/fe_poly_face.h b/include/deal.II/fe/fe_poly_face.h
index 4e53f7408b5d8b0c88f6561d14397208876c24ef..649097de6629fed0f4871fcd7e21719e58d9c8d7 100644 (file)
--- a/include/deal.II/fe/fe_poly_face.h
+++ b/include/deal.II/fe/fe_poly_face.h
@@ -35,7 +35,7 @@ DEAL_II_NAMESPACE_OPEN
  * classes.
  *
  * Every class that implements the following functions can be used as template
- * parameter POLY.
+ * parameter PolynomialType.
  *
  * @code
  * double compute_value (const unsigned int i,
@@ -57,14 +57,14 @@ DEAL_II_NAMESPACE_OPEN
  *
  * @author Guido Kanschat, 2009
  */
-template <class POLY, int dim=POLY::dimension+1, int spacedim=dim>
+template <class PolynomialType, int dim=PolynomialType::dimension+1, int spacedim=dim>
 class FE_PolyFace : public FiniteElement<dim,spacedim>
 {
 public:
   /**
    * Constructor.
    */
-  FE_PolyFace (const POLY &poly_space,
+  FE_PolyFace (const PolynomialType &poly_space,
                const FiniteElementData<dim> &fe_data,
                const std::vector<bool> &restriction_is_additive_flags);
 
@@ -264,9 +264,9 @@ protected:
   };
 
   /**
-   * The polynomial space. Its type is given by the template parameter POLY.
+   * The polynomial space. Its type is given by the template parameter PolynomialType.
    */
-  POLY poly_space;
+  PolynomialType poly_space;
 };
 
 /*@}*/

diff --git a/include/deal.II/fe/fe_poly_face.templates.h b/include/deal.II/fe/fe_poly_face.templates.h
index abeb919b7525606e27b14a54ef34fae649d2e6f5..5b45aaaa8662437634a42f38d1ef1572db289d91 100644 (file)
--- a/include/deal.II/fe/fe_poly_face.templates.h
+++ b/include/deal.II/fe/fe_poly_face.templates.h
@@ -22,9 +22,9 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-template <class POLY, int dim, int spacedim>
-FE_PolyFace<POLY,dim,spacedim>::FE_PolyFace (
-  const POLY &poly_space,
+template <class PolynomialType, int dim, int spacedim>
+FE_PolyFace<PolynomialType,dim,spacedim>::FE_PolyFace (
+  const PolynomialType &poly_space,
   const FiniteElementData<dim> &fe_data,
   const std::vector<bool> &restriction_is_additive_flags):
   FiniteElement<dim,spacedim> (fe_data,
@@ -32,13 +32,13 @@ FE_PolyFace<POLY,dim,spacedim>::FE_PolyFace (
                                std::vector<ComponentMask> (1, ComponentMask(1,true))),
   poly_space(poly_space)
 {
-  AssertDimension(dim, POLY::dimension+1);
+  AssertDimension(dim, PolynomialType::dimension+1);
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 unsigned int
-FE_PolyFace<POLY,dim,spacedim>::get_degree () const
+FE_PolyFace<PolynomialType,dim,spacedim>::get_degree () const
 {
   return this->degree;
 }
@@ -49,26 +49,26 @@ FE_PolyFace<POLY,dim,spacedim>::get_degree () const
 //---------------------------------------------------------------------------
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 UpdateFlags
-FE_PolyFace<POLY,dim,spacedim>::requires_update_flags (const UpdateFlags flags) const
+FE_PolyFace<PolynomialType,dim,spacedim>::requires_update_flags (const UpdateFlags flags) const
 {
   return update_once(flags) | update_each(flags);
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 UpdateFlags
-FE_PolyFace<POLY,dim,spacedim>::update_once (const UpdateFlags) const
+FE_PolyFace<PolynomialType,dim,spacedim>::update_once (const UpdateFlags) const
 {
   return update_default;
 }
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 UpdateFlags
-FE_PolyFace<POLY,dim,spacedim>::update_each (const UpdateFlags flags) const
+FE_PolyFace<PolynomialType,dim,spacedim>::update_each (const UpdateFlags flags) const
 {
   UpdateFlags out = flags & update_values;
   if (flags & update_gradients)
@@ -85,9 +85,9 @@ FE_PolyFace<POLY,dim,spacedim>::update_each (const UpdateFlags flags) const
 //---------------------------------------------------------------------------
 // Fill data of FEValues
 //---------------------------------------------------------------------------
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_PolyFace<POLY,dim,spacedim>::
+FE_PolyFace<PolynomialType,dim,spacedim>::
 fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
                 const CellSimilarity::Similarity                                     ,
                 const Quadrature<dim> &,
@@ -103,9 +103,9 @@ fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_PolyFace<POLY,dim,spacedim>::
+FE_PolyFace<PolynomialType,dim,spacedim>::
 fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
                      const unsigned int                                                   face_no,
                      const Quadrature<dim-1>                                             &quadrature,
@@ -173,9 +173,9 @@ fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_PolyFace<POLY,dim,spacedim>::
+FE_PolyFace<PolynomialType,dim,spacedim>::
 fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
                         const unsigned int                                                   face_no,
                         const unsigned int                                                   sub_no,

diff --git a/include/deal.II/fe/fe_poly_tensor.h b/include/deal.II/fe/fe_poly_tensor.h
index 2fb7e5c70338c63bb5c3b04a046d5f0107bbdbbf..1d014d47f551f5e8c2aa8b679809f1f13b1a6145 100644 (file)
--- a/include/deal.II/fe/fe_poly_tensor.h
+++ b/include/deal.II/fe/fe_poly_tensor.h
@@ -30,7 +30,7 @@ DEAL_II_NAMESPACE_OPEN
  * PolynomialsBDM and PolynomialsRaviartThomas.
  *
  * Every class that implements following function can be used as template
- * parameter POLY.
+ * parameter PolynomialType.
  *
  * @code
  * void compute (const Point<dim>            &unit_point,
@@ -94,7 +94,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * @note The matrix #inverse_node_matrix should have dimensions zero before
  * this piece of code is executed. Only then, shape_value_component() will
- * return the raw polynomial <i>j</i> as defined in the polynomial space POLY.
+ * return the raw polynomial <i>j</i> as defined in the polynomial space PolynomialType.
  *
  * <h4>Setting the transformation</h4>
  *
@@ -111,7 +111,7 @@ DEAL_II_NAMESPACE_OPEN
  * @author Guido Kanschat
  * @date 2005
  */
-template <class POLY, int dim, int spacedim=dim>
+template <class PolynomialType, int dim, int spacedim=dim>
 class FE_PolyTensor : public FiniteElement<dim,spacedim>
 {
 public:
@@ -397,9 +397,9 @@ protected:
 
 
   /**
-   * The polynomial space. Its type is given by the template parameter POLY.
+   * The polynomial space. Its type is given by the template parameter PolynomialType.
    */
-  POLY poly_space;
+  PolynomialType poly_space;
 
   /**
    * The inverse of the matrix <i>a<sub>ij</sub></i> of node values

diff --git a/include/deal.II/fe/fe_q_base.h b/include/deal.II/fe/fe_q_base.h
index a5a9f8337709ebe8760ec329a7770cf047605d55..c33471332f98b6e3c54ea08319130cf9fa30e053 100644 (file)
--- a/include/deal.II/fe/fe_q_base.h
+++ b/include/deal.II/fe/fe_q_base.h
@@ -35,14 +35,14 @@ DEAL_II_NAMESPACE_OPEN
  * 2001, 2004, 2005; Oliver Kayser-Herold, 2004; Katharina Kormann, 2008;
  * Martin Kronbichler, 2008, 2013
  */
-template <class POLY, int dim=POLY::dimension, int spacedim=dim>
-class FE_Q_Base : public FE_Poly<POLY,dim,spacedim>
+template <class PolynomialType, int dim=PolynomialType::dimension, int spacedim=dim>
+class FE_Q_Base : public FE_Poly<PolynomialType,dim,spacedim>
 {
 public:
   /**
    * Constructor.
    */
-  FE_Q_Base (const POLY &poly_space,
+  FE_Q_Base (const PolynomialType &poly_space,
              const FiniteElementData<dim> &fe_data,
              const std::vector<bool> &restriction_is_additive_flags);
 
@@ -317,7 +317,7 @@ protected:
   /*
    * Declare implementation friend.
    */
-  friend struct FE_Q_Base<POLY,dim,spacedim>::Implementation;
+  friend struct FE_Q_Base<PolynomialType,dim,spacedim>::Implementation;
 
 private:
   /*

diff --git a/include/deal.II/fe/mapping_q.h b/include/deal.II/fe/mapping_q.h
index 545d6fc37a63c4b4cbfb9879676c340dc82ff65d..d0fec52125ca6df14fbfc338cf95c5b159e33296 100644 (file)
--- a/include/deal.II/fe/mapping_q.h
+++ b/include/deal.II/fe/mapping_q.h
@@ -22,7 +22,7 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-template <int dim, typename POLY> class TensorProductPolynomials;
+template <int dim, typename PolynomialType> class TensorProductPolynomials;
 
 
 /*!@addtogroup mapping */

diff --git a/source/base/tensor_product_polynomials.cc b/source/base/tensor_product_polynomials.cc
index 4349369801f3536c89bcebce4bbfb9bbc034d097..d1700253babeed0773d38aca986981286121ad43 100644 (file)
--- a/source/base/tensor_product_polynomials.cc
+++ b/source/base/tensor_product_polynomials.cc
@@ -73,10 +73,10 @@ namespace internal
 
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 inline
 void
-TensorProductPolynomials<dim,POLY>::
+TensorProductPolynomials<dim,PolynomialType>::
 compute_index (const unsigned int i,
                unsigned int       (&indices)[(dim > 0 ? dim : 1)]) const
 {
@@ -87,9 +87,9 @@ compute_index (const unsigned int i,
 
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 void
-TensorProductPolynomials<dim,POLY>::output_indices(std::ostream &out) const
+TensorProductPolynomials<dim,PolynomialType>::output_indices(std::ostream &out) const
 {
   unsigned int ix[dim];
   for (unsigned int i=0; i<n_tensor_pols; ++i)
@@ -104,10 +104,10 @@ TensorProductPolynomials<dim,POLY>::output_indices(std::ostream &out) const
 
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 void
-TensorProductPolynomials<dim,POLY>::set_numbering(
-  const std::vector<unsigned int> &renumber)
+TensorProductPolynomials<dim,PolynomialType>::set_numbering
+(const std::vector<unsigned int> &renumber)
 {
   Assert(renumber.size()==index_map.size(),
          ExcDimensionMismatch(renumber.size(), index_map.size()));
@@ -131,10 +131,11 @@ TensorProductPolynomials<0,Polynomials::Polynomial<double> >
 
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 double
-TensorProductPolynomials<dim,POLY>::compute_value (const unsigned int i,
-                                                   const Point<dim> &p) const
+TensorProductPolynomials<dim,PolynomialType>::compute_value
+(const unsigned int  i,
+ const Point<dim>   &p) const
 {
   Assert(dim>0, ExcNotImplemented());
 
@@ -150,10 +151,10 @@ TensorProductPolynomials<dim,POLY>::compute_value (const unsigned int i,
 
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 Tensor<1,dim>
-TensorProductPolynomials<dim,POLY>::compute_grad (const unsigned int i,
-                                                  const Point<dim> &p) const
+TensorProductPolynomials<dim,PolynomialType>::compute_grad (const unsigned int  i,
+                                                            const Point<dim>   &p) const
 {
   unsigned int indices[dim];
   compute_index (i, indices);
@@ -186,10 +187,11 @@ TensorProductPolynomials<dim,POLY>::compute_grad (const unsigned int i,
 
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 Tensor<2,dim>
-TensorProductPolynomials<dim,POLY>::compute_grad_grad (const unsigned int i,
-                                                       const Point<dim> &p) const
+TensorProductPolynomials<dim,PolynomialType>::compute_grad_grad
+(const unsigned int  i,
+ const Point<dim>   &p) const
 {
   unsigned int indices[dim];
   compute_index (i, indices);
@@ -231,9 +233,9 @@ TensorProductPolynomials<dim,POLY>::compute_grad_grad (const unsigned int i,
 
 
 
-template <int dim, typename POLY>
+template <int dim, typename PolynomialType>
 void
-TensorProductPolynomials<dim,POLY>::
+TensorProductPolynomials<dim,PolynomialType>::
 compute (const Point<dim>            &p,
          std::vector<double>         &values,
          std::vector<Tensor<1,dim> > &grads,

diff --git a/source/fe/fe_poly_tensor.cc b/source/fe/fe_poly_tensor.cc
index 99aa1f533a94c02b054e7e59f254c75f4c0d60e7..9aaad2904ee069628878c5cbdf4f66e8210b7bed 100644 (file)
--- a/source/fe/fe_poly_tensor.cc
+++ b/source/fe/fe_poly_tensor.cc
@@ -131,16 +131,17 @@ namespace
 
 
 
-template <class POLY, int dim, int spacedim>
-FE_PolyTensor<POLY,dim,spacedim>::FE_PolyTensor (const unsigned int degree,
-                                                 const FiniteElementData<dim> &fe_data,
-                                                 const std::vector<bool> &restriction_is_additive_flags,
-                                                 const std::vector<ComponentMask> &nonzero_components)
+template <class PolynomialType, int dim, int spacedim>
+FE_PolyTensor<PolynomialType,dim,spacedim>::FE_PolyTensor
+(const unsigned int                degree,
+ const FiniteElementData<dim>     &fe_data,
+ const std::vector<bool>          &restriction_is_additive_flags,
+ const std::vector<ComponentMask> &nonzero_components)
   :
   FiniteElement<dim,spacedim> (fe_data,
                                restriction_is_additive_flags,
                                nonzero_components),
-  poly_space(POLY(degree))
+  poly_space(PolynomialType(degree))
 {
   cached_point(0) = -1;
   // Set up the table converting
@@ -156,9 +157,10 @@ FE_PolyTensor<POLY,dim,spacedim>::FE_PolyTensor (const unsigned int degree,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 double
-FE_PolyTensor<POLY,dim,spacedim>::shape_value (const unsigned int, const Point<dim> &) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::shape_value
+(const unsigned int, const Point<dim> &) const
 
 {
   typedef    FiniteElement<dim,spacedim> FEE;
@@ -168,11 +170,12 @@ FE_PolyTensor<POLY,dim,spacedim>::shape_value (const unsigned int, const Point<d
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 double
-FE_PolyTensor<POLY,dim,spacedim>::shape_value_component (const unsigned int i,
-                                                         const Point<dim> &p,
-                                                         const unsigned int component) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::shape_value_component
+(const unsigned int  i,
+ const Point<dim>   &p,
+ const unsigned int  component) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   Assert (component < dim, ExcIndexRange (component, 0, dim));
@@ -198,10 +201,10 @@ FE_PolyTensor<POLY,dim,spacedim>::shape_value_component (const unsigned int i,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<1,dim>
-FE_PolyTensor<POLY,dim,spacedim>::shape_grad (const unsigned int,
-                                              const Point<dim> &) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::shape_grad (const unsigned int,
+                                                        const Point<dim> &) const
 {
   typedef    FiniteElement<dim,spacedim> FEE;
   Assert(false, typename FEE::ExcFENotPrimitive());
@@ -210,11 +213,12 @@ FE_PolyTensor<POLY,dim,spacedim>::shape_grad (const unsigned int,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<1,dim>
-FE_PolyTensor<POLY,dim,spacedim>::shape_grad_component (const unsigned int i,
-                                                        const Point<dim> &p,
-                                                        const unsigned int component) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::shape_grad_component
+(const unsigned int  i,
+ const Point<dim>   &p,
+ const unsigned int  component) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   Assert (component < dim, ExcIndexRange (component, 0, dim));
@@ -241,9 +245,11 @@ FE_PolyTensor<POLY,dim,spacedim>::shape_grad_component (const unsigned int i,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<2,dim>
-FE_PolyTensor<POLY,dim,spacedim>::shape_grad_grad (const unsigned int, const Point<dim> &) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::shape_grad_grad
+(const unsigned int,
+ const Point<dim> &) const
 {
   typedef    FiniteElement<dim,spacedim> FEE;
   Assert(false, typename FEE::ExcFENotPrimitive());
@@ -252,11 +258,12 @@ FE_PolyTensor<POLY,dim,spacedim>::shape_grad_grad (const unsigned int, const Poi
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 Tensor<2,dim>
-FE_PolyTensor<POLY,dim,spacedim>::shape_grad_grad_component (const unsigned int i,
-    const Point<dim> &p,
-    const unsigned int component) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::shape_grad_grad_component
+(const unsigned int  i,
+ const Point<dim>   &p,
+ const unsigned int  component) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   Assert (component < dim, ExcIndexRange (component, 0, dim));
@@ -286,17 +293,18 @@ FE_PolyTensor<POLY,dim,spacedim>::shape_grad_grad_component (const unsigned int
 // Fill data of FEValues
 //---------------------------------------------------------------------------
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_PolyTensor<POLY,dim,spacedim>::
-fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator           &cell,
-                const CellSimilarity::Similarity                                     cell_similarity,
-                const Quadrature<dim>                                               &quadrature,
-                const Mapping<dim,spacedim>                                         &mapping,
-                const typename Mapping<dim,spacedim>::InternalDataBase              &mapping_internal,
-                const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
-                const typename FiniteElement<dim,spacedim>::InternalDataBase        &fe_internal,
-                dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::
+fill_fe_values
+(const typename Triangulation<dim,spacedim>::cell_iterator           &cell,
+ const CellSimilarity::Similarity                                     cell_similarity,
+ const Quadrature<dim>                                               &quadrature,
+ const Mapping<dim,spacedim>                                         &mapping,
+ const typename Mapping<dim,spacedim>::InternalDataBase              &mapping_internal,
+ const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const typename FiniteElement<dim,spacedim>::InternalDataBase        &fe_internal,
+ dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
 {
   // convert data object to internal
   // data for this class. fails with
@@ -755,17 +763,18 @@ fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_PolyTensor<POLY,dim,spacedim>::
-fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator           &cell,
-                     const unsigned int                                                   face_no,
-                     const Quadrature<dim-1>                                             &quadrature,
-                     const Mapping<dim,spacedim>                                         &mapping,
-                     const typename Mapping<dim,spacedim>::InternalDataBase              &mapping_internal,
-                     const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
-                     const typename FiniteElement<dim,spacedim>::InternalDataBase        &fe_internal,
-                     dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::
+fill_fe_face_values
+(const typename Triangulation<dim,spacedim>::cell_iterator           &cell,
+ const unsigned int                                                   face_no,
+ const Quadrature<dim-1>                                             &quadrature,
+ const Mapping<dim,spacedim>                                         &mapping,
+ const typename Mapping<dim,spacedim>::InternalDataBase              &mapping_internal,
+ const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const typename FiniteElement<dim,spacedim>::InternalDataBase        &fe_internal,
+ dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
 {
   // convert data object to internal
   // data for this class. fails with
@@ -1214,18 +1223,19 @@ fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_PolyTensor<POLY,dim,spacedim>::
-fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator           &cell,
-                        const unsigned int                                                   face_no,
-                        const unsigned int                                                   sub_no,
-                        const Quadrature<dim-1>                                             &quadrature,
-                        const Mapping<dim,spacedim>                                         &mapping,
-                        const typename Mapping<dim,spacedim>::InternalDataBase              &mapping_internal,
-                        const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
-                        const typename FiniteElement<dim,spacedim>::InternalDataBase        &fe_internal,
-                        dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::
+fill_fe_subface_values
+(const typename Triangulation<dim,spacedim>::cell_iterator           &cell,
+ const unsigned int                                                   face_no,
+ const unsigned int                                                   sub_no,
+ const Quadrature<dim-1>                                             &quadrature,
+ const Mapping<dim,spacedim>                                         &mapping,
+ const typename Mapping<dim,spacedim>::InternalDataBase              &mapping_internal,
+ const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const typename FiniteElement<dim,spacedim>::InternalDataBase        &fe_internal,
+ dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
 {
   // convert data object to internal
   // data for this class. fails with
@@ -1676,17 +1686,17 @@ fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterato
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 UpdateFlags
-FE_PolyTensor<POLY,dim,spacedim>::requires_update_flags(const UpdateFlags flags) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::requires_update_flags(const UpdateFlags flags) const
 {
   return update_once(flags) | update_each(flags);
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 UpdateFlags
-FE_PolyTensor<POLY,dim,spacedim>::update_once (const UpdateFlags flags) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::update_once (const UpdateFlags flags) const
 {
   const bool values_once = (mapping_type == mapping_none);
 
@@ -1699,9 +1709,9 @@ FE_PolyTensor<POLY,dim,spacedim>::update_once (const UpdateFlags flags) const
 }
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 UpdateFlags
-FE_PolyTensor<POLY,dim,spacedim>::update_each (const UpdateFlags flags) const
+FE_PolyTensor<PolynomialType,dim,spacedim>::update_each (const UpdateFlags flags) const
 {
   UpdateFlags out = update_default;
 

diff --git a/source/fe/fe_q_base.cc b/source/fe/fe_q_base.cc
index 3c2b3d39e232b7fa0c471f74e0e0e9dd83b8c0db..9137d03e3703141bb6d413f0646cf19440ee71aa 100644 (file)
--- a/source/fe/fe_q_base.cc
+++ b/source/fe/fe_q_base.cc
@@ -102,8 +102,8 @@ namespace FE_Q_Helper
  * A class with the same purpose as the similarly named class of the
  * Triangulation class. See there for more information.
  */
-template <class POLY, int xdim, int xspacedim>
-struct FE_Q_Base<POLY,xdim,xspacedim>::Implementation
+template <class PolynomialType, int xdim, int xspacedim>
+struct FE_Q_Base<PolynomialType,xdim,xspacedim>::Implementation
 {
   /**
    * Initialize the hanging node constraints matrices. Called from the
@@ -112,7 +112,7 @@ struct FE_Q_Base<POLY,xdim,xspacedim>::Implementation
   template <int spacedim>
   static
   void initialize_constraints (const std::vector<Point<1> > &,
-                               FE_Q_Base<POLY,1,spacedim> &)
+                               FE_Q_Base<PolynomialType,1,spacedim> &)
   {
     // no constraints in 1d
   }
@@ -121,12 +121,12 @@ struct FE_Q_Base<POLY,xdim,xspacedim>::Implementation
   template <int spacedim>
   static
   void initialize_constraints (const std::vector<Point<1> > &/*points*/,
-                               FE_Q_Base<POLY,2,spacedim> &fe)
+                               FE_Q_Base<PolynomialType,2,spacedim> &fe)
   {
     const unsigned int dim = 2;
 
     unsigned int q_deg = fe.degree;
-    if (types_are_equal<POLY, TensorProductPolynomialsBubbles<dim> >::value)
+    if (types_are_equal<PolynomialType, TensorProductPolynomialsBubbles<dim> >::value)
       q_deg = fe.degree-1;
 
     // restricted to each face, the traces of the shape functions is an
@@ -228,12 +228,12 @@ struct FE_Q_Base<POLY,xdim,xspacedim>::Implementation
   template <int spacedim>
   static
   void initialize_constraints (const std::vector<Point<1> > &/*points*/,
-                               FE_Q_Base<POLY,3,spacedim> &fe)
+                               FE_Q_Base<PolynomialType,3,spacedim> &fe)
   {
     const unsigned int dim = 3;
 
     unsigned int q_deg = fe.degree;
-    if (types_are_equal<POLY,TensorProductPolynomialsBubbles<dim> >::value)
+    if (types_are_equal<PolynomialType,TensorProductPolynomialsBubbles<dim> >::value)
       q_deg = fe.degree-1;
 
     // For a detailed documentation of the interpolation see the
@@ -408,23 +408,24 @@ struct FE_Q_Base<POLY,xdim,xspacedim>::Implementation
 
 
 
-template <class POLY, int dim, int spacedim>
-FE_Q_Base<POLY,dim,spacedim>::FE_Q_Base (const POLY &poly_space,
-                                         const FiniteElementData<dim> &fe_data,
-                                         const std::vector<bool> &restriction_is_additive_flags)
+template <class PolynomialType, int dim, int spacedim>
+FE_Q_Base<PolynomialType,dim,spacedim>::FE_Q_Base
+(const PolynomialType         &poly_space,
+ const FiniteElementData<dim> &fe_data,
+ const std::vector<bool>      &restriction_is_additive_flags)
   :
-  FE_Poly<POLY,dim,spacedim>(poly_space, fe_data, restriction_is_additive_flags,
-                             std::vector<ComponentMask>(1, std::vector<bool>(1,true))),
-  q_degree (types_are_equal<POLY, TensorProductPolynomialsBubbles<dim> >::value
+  FE_Poly<PolynomialType,dim,spacedim>(poly_space, fe_data, restriction_is_additive_flags,
+                                       std::vector<ComponentMask>(1, std::vector<bool>(1,true))),
+  q_degree (types_are_equal<PolynomialType, TensorProductPolynomialsBubbles<dim> >::value
             ?this->degree-1
             :this->degree)
 {}
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_Q_Base<POLY,dim,spacedim>::initialize (const std::vector<Point<1> > &points)
+FE_Q_Base<PolynomialType,dim,spacedim>::initialize (const std::vector<Point<1> > &points)
 {
   Assert (points[0][0] == 0,
           ExcMessage ("The first support point has to be zero."));
@@ -465,15 +466,15 @@ FE_Q_Base<POLY,dim,spacedim>::initialize (const std::vector<Point<1> > &points)
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_Q_Base<POLY,dim,spacedim>::
+FE_Q_Base<PolynomialType,dim,spacedim>::
 get_interpolation_matrix (const FiniteElement<dim,spacedim> &x_source_fe,
-                          FullMatrix<double>       &interpolation_matrix) const
+                          FullMatrix<double>                &interpolation_matrix) const
 {
   // go through the list of elements we can interpolate from
-  if (const FE_Q_Base<POLY,dim,spacedim> *source_fe
-      = dynamic_cast<const FE_Q_Base<POLY,dim,spacedim>*>(&x_source_fe))
+  if (const FE_Q_Base<PolynomialType,dim,spacedim> *source_fe
+      = dynamic_cast<const FE_Q_Base<PolynomialType,dim,spacedim>*>(&x_source_fe))
     {
       // ok, source is a Q element, so we will be able to do the work
       Assert (interpolation_matrix.m() == this->dofs_per_cell,
@@ -559,11 +560,11 @@ get_interpolation_matrix (const FiniteElement<dim,spacedim> &x_source_fe,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_Q_Base<POLY,dim,spacedim>::
+FE_Q_Base<PolynomialType,dim,spacedim>::
 get_face_interpolation_matrix (const FiniteElement<dim,spacedim> &source_fe,
-                               FullMatrix<double>       &interpolation_matrix) const
+                               FullMatrix<double>                &interpolation_matrix) const
 {
   Assert (dim > 1, ExcImpossibleInDim(1));
   get_subface_interpolation_matrix (source_fe, numbers::invalid_unsigned_int,
@@ -572,20 +573,20 @@ get_face_interpolation_matrix (const FiniteElement<dim,spacedim> &source_fe,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_Q_Base<POLY,dim,spacedim>::
+FE_Q_Base<PolynomialType,dim,spacedim>::
 get_subface_interpolation_matrix (const FiniteElement<dim,spacedim> &x_source_fe,
-                                  const unsigned int        subface,
-                                  FullMatrix<double>       &interpolation_matrix) const
+                                  const unsigned int                 subface,
+                                  FullMatrix<double>                &interpolation_matrix) const
 {
   Assert (interpolation_matrix.m() == x_source_fe.dofs_per_face,
           ExcDimensionMismatch (interpolation_matrix.m(),
                                 x_source_fe.dofs_per_face));
 
   // see if source is a Q element
-  if (const FE_Q_Base<POLY,dim,spacedim> *source_fe
-      = dynamic_cast<const FE_Q_Base<POLY,dim,spacedim> *>(&x_source_fe))
+  if (const FE_Q_Base<PolynomialType,dim,spacedim> *source_fe
+      = dynamic_cast<const FE_Q_Base<PolynomialType,dim,spacedim> *>(&x_source_fe))
     {
       // have this test in here since a table of size 2x0 reports its size as
       // 0x0
@@ -665,9 +666,9 @@ get_subface_interpolation_matrix (const FiniteElement<dim,spacedim> &x_source_fe
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 bool
-FE_Q_Base<POLY,dim,spacedim>::hp_constraints_are_implemented () const
+FE_Q_Base<PolynomialType,dim,spacedim>::hp_constraints_are_implemented () const
 {
   return true;
 }
@@ -675,16 +676,16 @@ FE_Q_Base<POLY,dim,spacedim>::hp_constraints_are_implemented () const
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 std::vector<std::pair<unsigned int, unsigned int> >
-FE_Q_Base<POLY,dim,spacedim>::
+FE_Q_Base<PolynomialType,dim,spacedim>::
 hp_vertex_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const
 {
   // we can presently only compute these identities if both FEs are FE_Qs or
   // if the other one is an FE_Nothing. in the first case, there should be
   // exactly one single DoF of each FE at a vertex, and they should have
   // identical value
-  if (dynamic_cast<const FE_Q_Base<POLY,dim,spacedim>*>(&fe_other) != 0)
+  if (dynamic_cast<const FE_Q_Base<PolynomialType,dim,spacedim>*>(&fe_other) != 0)
     {
       return
         std::vector<std::pair<unsigned int, unsigned int> >
@@ -716,14 +717,15 @@ hp_vertex_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 std::vector<std::pair<unsigned int, unsigned int> >
-FE_Q_Base<POLY,dim,spacedim>::
+FE_Q_Base<PolynomialType,dim,spacedim>::
 hp_line_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const
 {
   // we can presently only compute these identities if both FEs are FE_Qs or
   // if the other one is an FE_Nothing
-  if (const FE_Q_Base<POLY,dim,spacedim> *fe_q_other = dynamic_cast<const FE_Q_Base<POLY,dim,spacedim>*>(&fe_other))
+  if (const FE_Q_Base<PolynomialType,dim,spacedim> *fe_q_other
+      = dynamic_cast<const FE_Q_Base<PolynomialType,dim,spacedim>*>(&fe_other))
     {
       // dofs are located along lines, so two dofs are identical if they are
       // located at identical positions. if we had only equidistant points, we
@@ -778,14 +780,15 @@ hp_line_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 std::vector<std::pair<unsigned int, unsigned int> >
-FE_Q_Base<POLY,dim,spacedim>::
+FE_Q_Base<PolynomialType,dim,spacedim>::
 hp_quad_dof_identities (const FiniteElement<dim,spacedim>        &fe_other) const
 {
   // we can presently only compute these identities if both FEs are FE_Qs or
   // if the other one is an FE_Nothing
-  if (const FE_Q_Base<POLY,dim,spacedim> *fe_q_other = dynamic_cast<const FE_Q_Base<POLY,dim,spacedim>*>(&fe_other))
+  if (const FE_Q_Base<PolynomialType,dim,spacedim> *fe_q_other
+      = dynamic_cast<const FE_Q_Base<PolynomialType,dim,spacedim>*>(&fe_other))
     {
       // this works exactly like the line case above, except that now we have
       // to have two indices i1, i2 and j1, j2 to characterize the dofs on the
@@ -844,13 +847,13 @@ hp_quad_dof_identities (const FiniteElement<dim,spacedim>        &fe_other) cons
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_Q_Base<POLY,dim,spacedim>::
+FE_Q_Base<PolynomialType,dim,spacedim>::
 compare_for_face_domination (const FiniteElement<dim,spacedim> &fe_other) const
 {
-  if (const FE_Q_Base<POLY,dim,spacedim> *fe_q_other
-      = dynamic_cast<const FE_Q_Base<POLY,dim,spacedim>*>(&fe_other))
+  if (const FE_Q_Base<PolynomialType,dim,spacedim> *fe_q_other
+      = dynamic_cast<const FE_Q_Base<PolynomialType,dim,spacedim>*>(&fe_other))
     {
       if (this->degree < fe_q_other->degree)
         return FiniteElementDomination::this_element_dominates;
@@ -884,8 +887,9 @@ compare_for_face_domination (const FiniteElement<dim,spacedim> &fe_other) const
 
 
 
-template <class POLY, int dim, int spacedim>
-void FE_Q_Base<POLY,dim,spacedim>::initialize_unit_support_points (const std::vector<Point<1> > &points)
+template <class PolynomialType, int dim, int spacedim>
+void FE_Q_Base<PolynomialType,dim,spacedim>::initialize_unit_support_points
+(const std::vector<Point<1> > &points)
 {
   const std::vector<unsigned int> &index_map_inverse=
     this->poly_space.get_numbering_inverse();
@@ -900,8 +904,9 @@ void FE_Q_Base<POLY,dim,spacedim>::initialize_unit_support_points (const std::ve
 
 
 
-template <class POLY, int dim, int spacedim>
-void FE_Q_Base<POLY,dim,spacedim>::initialize_unit_face_support_points (const std::vector<Point<1> > &points)
+template <class PolynomialType, int dim, int spacedim>
+void FE_Q_Base<PolynomialType,dim,spacedim>::initialize_unit_face_support_points
+(const std::vector<Point<1> > &points)
 {
   // no faces in 1d, so nothing to do
   if (dim == 1)
@@ -923,9 +928,9 @@ void FE_Q_Base<POLY,dim,spacedim>::initialize_unit_face_support_points (const st
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_Q_Base<POLY,dim,spacedim>::initialize_quad_dof_index_permutation ()
+FE_Q_Base<PolynomialType,dim,spacedim>::initialize_quad_dof_index_permutation ()
 {
   // for 1D and 2D, do nothing
   if (dim < 3)
@@ -990,9 +995,9 @@ FE_Q_Base<POLY,dim,spacedim>::initialize_quad_dof_index_permutation ()
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 unsigned int
-FE_Q_Base<POLY,dim,spacedim>::
+FE_Q_Base<PolynomialType,dim,spacedim>::
 face_to_cell_index (const unsigned int face_index,
                     const unsigned int face,
                     const bool face_orientation,
@@ -1111,9 +1116,9 @@ face_to_cell_index (const unsigned int face_index,
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 std::vector<unsigned int>
-FE_Q_Base<POLY,dim,spacedim>::get_dpo_vector(const unsigned int deg)
+FE_Q_Base<PolynomialType,dim,spacedim>::get_dpo_vector(const unsigned int deg)
 {
   AssertThrow(deg>0,ExcMessage("FE_Q needs to be of degree > 0."));
   std::vector<unsigned int> dpo(dim+1, 1U);
@@ -1124,18 +1129,19 @@ FE_Q_Base<POLY,dim,spacedim>::get_dpo_vector(const unsigned int deg)
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 void
-FE_Q_Base<POLY,dim,spacedim>::initialize_constraints (const std::vector<Point<1> > &points)
+FE_Q_Base<PolynomialType,dim,spacedim>::initialize_constraints
+(const std::vector<Point<1> > &points)
 {
   Implementation::initialize_constraints (points, *this);
 }
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 const FullMatrix<double> &
-FE_Q_Base<POLY,dim,spacedim>
+FE_Q_Base<PolynomialType,dim,spacedim>
 ::get_prolongation_matrix (const unsigned int child,
                            const RefinementCase<dim> &refinement_case) const
 {
@@ -1310,9 +1316,9 @@ FE_Q_Base<POLY,dim,spacedim>
 
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 const FullMatrix<double> &
-FE_Q_Base<POLY,dim,spacedim>
+FE_Q_Base<PolynomialType,dim,spacedim>
 ::get_restriction_matrix (const unsigned int child,
                           const RefinementCase<dim> &refinement_case) const
 {
@@ -1446,10 +1452,11 @@ FE_Q_Base<POLY,dim,spacedim>
 //---------------------------------------------------------------------------
 
 
-template <class POLY, int dim, int spacedim>
+template <class PolynomialType, int dim, int spacedim>
 bool
-FE_Q_Base<POLY,dim,spacedim>::has_support_on_face (const unsigned int shape_index,
-                                                   const unsigned int face_index) const
+FE_Q_Base<PolynomialType,dim,spacedim>::has_support_on_face
+(const unsigned int shape_index,
+ const unsigned int face_index) const
 {
   Assert (shape_index < this->dofs_per_cell,
           ExcIndexRange (shape_index, 0, this->dofs_per_cell));
@@ -1546,9 +1553,9 @@ FE_Q_Base<POLY,dim,spacedim>::has_support_on_face (const unsigned int shape_inde
 
 
 
-template <typename POLY, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
 std::pair<Table<2,bool>, std::vector<unsigned int> >
-FE_Q_Base<POLY,dim,spacedim>::get_constant_modes () const
+FE_Q_Base<PolynomialType,dim,spacedim>::get_constant_modes () const
 {
   Table<2,bool> constant_modes(1, this->dofs_per_cell);
   // We here just care for the constant mode due to the polynomial space

diff --git a/tests/base/anisotropic_1.cc b/tests/base/anisotropic_1.cc
index 17fd2b860a9f67aa336151697ed0c02a26fc2517..31c308db77f2a70cb262204c6fc4253ea3be54bd 100644 (file)
--- a/tests/base/anisotropic_1.cc
+++ b/tests/base/anisotropic_1.cc
@@ -32,10 +32,10 @@
 using namespace Polynomials;
 
 
-template<int dim, class POLY1, class POLY2>
-void check_poly(const Point<dim> &x,
-                const POLY1      &p,
-                const POLY2      &q)
+template<int dim, class PolynomialType1, class PolynomialType2>
+void check_poly(const Point<dim>      &x,
+                const PolynomialType1 &p,
+                const PolynomialType2 &q)
 {
   const unsigned int n = p.n();
 

diff --git a/tests/base/polynomial_test.cc b/tests/base/polynomial_test.cc
index ab8f3251b64327c0be77881eb93d2b94d6d09ac0..16914f9bdab598286ea5d9e964fd648634a11a46 100644 (file)
--- a/tests/base/polynomial_test.cc
+++ b/tests/base/polynomial_test.cc
@@ -33,9 +33,9 @@
 using namespace Polynomials;
 
 
-template<int dim, class POLY>
-void check_poly(const Point<dim> &x,
-                const POLY &p)
+template<int dim, class PolynomialType>
+void check_poly(const Point<dim>     &x,
+                const PolynomialType &p)
 {
   const unsigned int n = p.n();
   const double eps = 5.0e-15;

diff --git a/tests/base/polynomials_tensor.cc b/tests/base/polynomials_tensor.cc
index 759873345f02beefa95e345644f1c92d7aae4a9f..1ddc6001aa416b36cc86eaa04a52229c47314789 100644 (file)
--- a/tests/base/polynomials_tensor.cc
+++ b/tests/base/polynomials_tensor.cc
@@ -30,9 +30,9 @@
 
 using namespace std;
 
-template<int dim, class POLY>
-void check_point (const Point<dim> &x,
-                  const POLY &p)
+template<int dim, class PolynomialType>
+void check_point (const Point<dim>     &x,
+                  const PolynomialType &p)
 {
   const unsigned int n = p.n();
   std::vector<Tensor<1,dim> > values(n);