Prefer RelaxationType to RELAX or RELAXATION.

diff --git a/include/deal.II/lac/solver_relaxation.h b/include/deal.II/lac/solver_relaxation.h
index 1c67e3080e6e9ea3cc61d1335754bc4bc90e50a4..fad56a269b857c304733f619a172d9a6360dd281 100644 (file)
--- a/include/deal.II/lac/solver_relaxation.h
+++ b/include/deal.II/lac/solver_relaxation.h
@@ -79,12 +79,12 @@ public:
    * R(x_k,b)$. The matrix <i>A</i> itself is only used to compute the
    * residual.
    */
-  template<typename MatrixType, class RELAXATION>
+  template<typename MatrixType, class RelaxationType>
   void
-  solve (const MatrixType &A,
-         VectorType       &x,
-         const VectorType &b,
-         const RELAXATION &R);
+  solve (const MatrixType     &A,
+         VectorType           &x,
+         const VectorType     &b,
+         const RelaxationType &R);
 };
 
 //----------------------------------------------------------------------//
@@ -104,12 +104,12 @@ SolverRelaxation<VectorType>::~SolverRelaxation()
 
 
 template <class VectorType>
-template <typename MatrixType, class RELAXATION>
+template <typename MatrixType, class RelaxationType>
 void
-SolverRelaxation<VectorType>::solve (const MatrixType &A,
-                                     VectorType       &x,
-                                     const VectorType &b,
-                                     const RELAXATION &R)
+SolverRelaxation<VectorType>::solve (const MatrixType     &A,
+                                     VectorType           &x,
+                                     const VectorType     &b,
+                                     const RelaxationType &R)
 {
   GrowingVectorMemory<VectorType> mem;
   SolverControl::State conv=SolverControl::iterate;

diff --git a/include/deal.II/multigrid/mg_block_smoother.h b/include/deal.II/multigrid/mg_block_smoother.h
index 53ae1fe224637a4de9ac05e65ac0a895bae589f3..1408e90a941995e50b79e5ee98a66e81b9d29be7 100644 (file)
--- a/include/deal.II/multigrid/mg_block_smoother.h
+++ b/include/deal.II/multigrid/mg_block_smoother.h
@@ -43,7 +43,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * @author Guido Kanschat, 2005
  */
-template <typename MatrixType, class RELAX, typename number>
+template <typename MatrixType, class RelaxationType, typename number>
 class MGSmootherBlock
   : public MGSmootherBase<BlockVector<number> >
 {
@@ -71,9 +71,9 @@ public:
    * This function stores pointers to the level matrices and smoothing
    * operator for each level.
    */
-  template <class MGMatrixType, class MGRELAX>
-  void initialize (const MGMatrixType &matrices,
-                   const MGRELAX      &smoothers);
+  template <class MGMatrixType, class MGRelaxationType>
+  void initialize (const MGMatrixType     &matrices,
+                   const MGRelaxationType &smoothers);
 
   /**
    * Empty all vectors.
@@ -122,7 +122,7 @@ private:
   /**
    * Pointer to the matrices.
    */
-  MGLevelObject<PointerMatrix<RELAX, BlockVector<number> > > smoothers;
+  MGLevelObject<PointerMatrix<RelaxationType, BlockVector<number> > > smoothers;
 
   /**
    * Number of smoothing steps.
@@ -162,9 +162,9 @@ private:
 
 #ifndef DOXYGEN
 
-template <typename MatrixType, class RELAX, typename number>
+template <typename MatrixType, class RelaxationType, typename number>
 inline
-MGSmootherBlock<MatrixType, RELAX, number>::MGSmootherBlock
+MGSmootherBlock<MatrixType, RelaxationType, number>::MGSmootherBlock
 (VectorMemory<BlockVector<number> > &mem,
  const unsigned int                  steps,
  const bool                          variable,
@@ -181,9 +181,9 @@ MGSmootherBlock<MatrixType, RELAX, number>::MGSmootherBlock
 {}
 
 
-template <typename MatrixType, class RELAX, typename number>
+template <typename MatrixType, class RelaxationType, typename number>
 inline void
-MGSmootherBlock<MatrixType, RELAX, number>::clear ()
+MGSmootherBlock<MatrixType, RelaxationType, number>::clear ()
 {
   unsigned int i=matrices.min_level(),
                max_level=matrices.max_level();
@@ -195,11 +195,11 @@ MGSmootherBlock<MatrixType, RELAX, number>::clear ()
 }
 
 
-template <typename MatrixType, class RELAX, typename number>
-template <class MGMatrixType, class MGRELAX>
+template <typename MatrixType, class RelaxationType, typename number>
+template <class MGMatrixType, class MGRelaxationType>
 inline void
-MGSmootherBlock<MatrixType, RELAX, number>::initialize (const MGMatrixType &m,
-                                                        const MGRELAX      &s)
+MGSmootherBlock<MatrixType, RelaxationType, number>::initialize (const MGMatrixType &m,
+    const MGRelaxationType &s)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -214,56 +214,56 @@ MGSmootherBlock<MatrixType, RELAX, number>::initialize (const MGMatrixType &m,
     }
 }
 
-template <typename MatrixType, class RELAX, typename number>
+template <typename MatrixType, class RelaxationType, typename number>
 inline void
-MGSmootherBlock<MatrixType, RELAX, number>::
+MGSmootherBlock<MatrixType, RelaxationType, number>::
 set_steps (const unsigned int s)
 {
   steps = s;
 }
 
 
-template <typename MatrixType, class RELAX, typename number>
+template <typename MatrixType, class RelaxationType, typename number>
 inline void
-MGSmootherBlock<MatrixType, RELAX, number>::
+MGSmootherBlock<MatrixType, RelaxationType, number>::
 set_variable (const bool flag)
 {
   variable = flag;
 }
 
 
-template <typename MatrixType, class RELAX, typename number>
+template <typename MatrixType, class RelaxationType, typename number>
 inline void
-MGSmootherBlock<MatrixType, RELAX, number>::
+MGSmootherBlock<MatrixType, RelaxationType, number>::
 set_symmetric (const bool flag)
 {
   symmetric = flag;
 }
 
 
-template <typename MatrixType, class RELAX, typename number>
+template <typename MatrixType, class RelaxationType, typename number>
 inline void
-MGSmootherBlock<MatrixType, RELAX, number>::
+MGSmootherBlock<MatrixType, RelaxationType, number>::
 set_transpose (const bool flag)
 {
   transpose = flag;
 }
 
 
-template <typename MatrixType, class RELAX, typename number>
+template <typename MatrixType, class RelaxationType, typename number>
 inline void
-MGSmootherBlock<MatrixType, RELAX, number>::
+MGSmootherBlock<MatrixType, RelaxationType, number>::
 set_reverse (const bool flag)
 {
   reverse = flag;
 }
 
 
-template <typename MatrixType, class RELAX, typename number>
+template <typename MatrixType, class RelaxationType, typename number>
 inline void
-MGSmootherBlock<MatrixType, RELAX, number>::smooth(const unsigned int   level,
-                                                   BlockVector<number> &u,
-                                                   const BlockVector<number> &rhs) const
+MGSmootherBlock<MatrixType, RelaxationType, number>::smooth(const unsigned int         level,
+                                                            BlockVector<number>       &u,
+                                                            const BlockVector<number> &rhs) const
 {
   deallog.push("Smooth");
 

diff --git a/include/deal.II/multigrid/mg_smoother.h b/include/deal.II/multigrid/mg_smoother.h
index 3dded6693c6eff59e9d01a0564ee55b5fd00155a..2906a57b3858c393d29da782b7645020f1b07696 100644 (file)
--- a/include/deal.II/multigrid/mg_smoother.h
+++ b/include/deal.II/multigrid/mg_smoother.h
@@ -180,8 +180,8 @@ namespace mg
    * @author Guido Kanschat,
    * @date 2003, 2009, 2010
    */
-  template<class RELAX, typename VectorType>
-  class SmootherRelaxation : public MGLevelObject<RELAX>, public MGSmoother<VectorType>
+  template<class RelaxationType, typename VectorType>
+  class SmootherRelaxation : public MGLevelObject<RelaxationType>, public MGSmoother<VectorType>
   {
   public:
     /**
@@ -196,12 +196,13 @@ namespace mg
      * Initialize for matrices. This function initializes the smoothing
      * operator with the same smoother for each level.
      *
-     * @p additional_data is an object of type @p RELAX::AdditionalData and is
+     * @p additional_data is an object of type @p RelaxationType::AdditionalData and is
      * handed to the initialization function of the relaxation method.
      */
     template <typename MatrixType2>
     void initialize (const MGLevelObject<MatrixType2>     &matrices,
-                     const typename RELAX::AdditionalData &additional_data = typename RELAX::AdditionalData());
+                     const typename RelaxationType::AdditionalData &additional_data
+                     = typename RelaxationType::AdditionalData());
 
     /**
      * Initialize matrices and additional data for each level.
@@ -270,7 +271,7 @@ namespace mg
  *
  * @author Guido Kanschat, 2003
  */
-template<typename MatrixType, class RELAX, typename VectorType>
+template<typename MatrixType, class RelaxationType, typename VectorType>
 class MGSmootherRelaxation : public MGSmoother<VectorType>
 {
 public:
@@ -287,19 +288,20 @@ public:
    * matrices and initializes the smoothing operator with the same smoother
    * for each level.
    *
-   * @p additional_data is an object of type @p RELAX::AdditionalData and is
-   * handed to the initialization function of the relaxation method.
+   * @p additional_data is an object of type @p RelaxationType::AdditionalData
+   * and is handed to the initialization function of the relaxation method.
    */
   template <typename MatrixType2>
   void initialize (const MGLevelObject<MatrixType2>     &matrices,
-                   const typename RELAX::AdditionalData &additional_data = typename RELAX::AdditionalData());
+                   const typename RelaxationType::AdditionalData &additional_data
+                   = typename RelaxationType::AdditionalData());
 
   /**
    * Initialize for matrices. This function stores pointers to the level
    * matrices and initializes the smoothing operator with the according
    * smoother for each level.
    *
-   * @p additional_data is an object of type @p RELAX::AdditionalData and is
+   * @p additional_data is an object of type @p RelaxationType::AdditionalData and is
    * handed to the initialization function of the relaxation method.
    */
   template <typename MatrixType2, class DATA>
@@ -312,7 +314,7 @@ public:
    * This function stores pointers to the level matrices and initializes the
    * smoothing operator with the same smoother for each level.
    *
-   * @p additional_data is an object of type @p RELAX::AdditionalData and is
+   * @p additional_data is an object of type @p RelaxationType::AdditionalData and is
    * handed to the initialization function of the relaxation method.
    */
   template <typename MatrixType2, class DATA>
@@ -327,7 +329,7 @@ public:
    * This function stores pointers to the level matrices and initializes the
    * smoothing operator with the according smoother for each level.
    *
-   * @p additional_data is an object of type @p RELAX::AdditionalData and is
+   * @p additional_data is an object of type @p RelaxationType::AdditionalData and is
    * handed to the initialization function of the relaxation method.
    */
   template <typename MatrixType2, class DATA>
@@ -351,7 +353,7 @@ public:
   /**
    * Object containing relaxation methods.
    */
-  MGLevelObject<RELAX> smoothers;
+  MGLevelObject<RelaxationType> smoothers;
 
   /**
    * Memory used by this object.
@@ -574,9 +576,9 @@ MGSmoother<VectorType>::set_transpose (const bool flag)
 
 namespace mg
 {
-  template <class RELAX, typename VectorType>
+  template <class RelaxationType, typename VectorType>
   inline
-  SmootherRelaxation<RELAX, VectorType>::SmootherRelaxation
+  SmootherRelaxation<RelaxationType, VectorType>::SmootherRelaxation
   (const unsigned int steps,
    const bool         variable,
    const bool         symmetric,
@@ -585,20 +587,20 @@ namespace mg
   {}
 
 
-  template <class RELAX, typename VectorType>
+  template <class RelaxationType, typename VectorType>
   inline void
-  SmootherRelaxation<RELAX, VectorType>::clear ()
+  SmootherRelaxation<RelaxationType, VectorType>::clear ()
   {
-    MGLevelObject<RELAX>::clear();
+    MGLevelObject<RelaxationType>::clear();
   }
 
 
-  template <class RELAX, typename VectorType>
+  template <class RelaxationType, typename VectorType>
   template <typename MatrixType2>
   inline void
-  SmootherRelaxation<RELAX, VectorType>::initialize
+  SmootherRelaxation<RelaxationType, VectorType>::initialize
   (const MGLevelObject<MatrixType2>     &m,
-   const typename RELAX::AdditionalData &data)
+   const typename RelaxationType::AdditionalData &data)
   {
     const unsigned int min = m.min_level();
     const unsigned int max = m.max_level();
@@ -610,10 +612,10 @@ namespace mg
   }
 
 
-  template <class RELAX, typename VectorType>
+  template <class RelaxationType, typename VectorType>
   template <typename MatrixType2, class DATA>
   inline void
-  SmootherRelaxation<RELAX, VectorType>::initialize
+  SmootherRelaxation<RelaxationType, VectorType>::initialize
   (const MGLevelObject<MatrixType2> &m,
    const MGLevelObject<DATA>        &data)
   {
@@ -627,11 +629,11 @@ namespace mg
   }
 
 
-  template <class RELAX, typename VectorType>
+  template <class RelaxationType, typename VectorType>
   inline void
-  SmootherRelaxation<RELAX, VectorType>::smooth (const unsigned int level,
-                                                 VectorType         &u,
-                                                 const VectorType   &rhs) const
+  SmootherRelaxation<RelaxationType, VectorType>::smooth (const unsigned int  level,
+                                                          VectorType         &u,
+                                                          const VectorType   &rhs) const
   {
     unsigned int maxlevel = this->max_level();
     unsigned int steps2 = this->steps;
@@ -657,15 +659,15 @@ namespace mg
   }
 
 
-  template <class RELAX, typename VectorType>
+  template <class RelaxationType, typename VectorType>
   inline
   std::size_t
-  SmootherRelaxation<RELAX, VectorType>::
+  SmootherRelaxation<RelaxationType, VectorType>::
   memory_consumption () const
   {
     return sizeof(*this)
-           -sizeof(MGLevelObject<RELAX>)
-           + MGLevelObject<RELAX>::memory_consumption()
+           -sizeof(MGLevelObject<RelaxationType>)
+           + MGLevelObject<RelaxationType>::memory_consumption()
            + this->vector_memory.memory_consumption();
   }
 }
@@ -673,9 +675,9 @@ namespace mg
 
 //----------------------------------------------------------------------//
 
-template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType, class RelaxationType, typename VectorType>
 inline
-MGSmootherRelaxation<MatrixType, RELAX, VectorType>::MGSmootherRelaxation
+MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::MGSmootherRelaxation
 (const unsigned int steps,
  const bool         variable,
  const bool         symmetric,
@@ -686,9 +688,9 @@ MGSmootherRelaxation<MatrixType, RELAX, VectorType>::MGSmootherRelaxation
 
 
 
-template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType, class RelaxationType, typename VectorType>
 inline void
-MGSmootherRelaxation<MatrixType, RELAX, VectorType>::clear ()
+MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::clear ()
 {
   smoothers.clear();
 
@@ -699,12 +701,12 @@ MGSmootherRelaxation<MatrixType, RELAX, VectorType>::clear ()
 }
 
 
-template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType, class RelaxationType, typename VectorType>
 template <typename MatrixType2>
 inline void
-MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
+MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize
 (const MGLevelObject<MatrixType2>     &m,
- const typename RELAX::AdditionalData &data)
+ const typename RelaxationType::AdditionalData &data)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -719,10 +721,10 @@ MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
     }
 }
 
-template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType, class RelaxationType, typename VectorType>
 template <typename MatrixType2, class DATA>
 inline void
-MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
+MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize
 (const MGLevelObject<MatrixType2> &m,
  const MGLevelObject<DATA>        &data)
 {
@@ -744,10 +746,10 @@ MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
     }
 }
 
-template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType, class RelaxationType, typename VectorType>
 template <typename MatrixType2, class DATA>
 inline void
-MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
+MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize
 (const MGLevelObject<MatrixType2> &m,
  const DATA                       &data,
  const unsigned int                row,
@@ -766,10 +768,10 @@ MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
     }
 }
 
-template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType, class RelaxationType, typename VectorType>
 template <typename MatrixType2, class DATA>
 inline void
-MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
+MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize
 (const MGLevelObject<MatrixType2> &m,
  const MGLevelObject<DATA>        &data,
  const unsigned int                row,
@@ -794,9 +796,9 @@ MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
 }
 
 
-template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType, class RelaxationType, typename VectorType>
 inline void
-MGSmootherRelaxation<MatrixType, RELAX, VectorType>::smooth (const unsigned int  level,
+MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::smooth (const unsigned int  level,
     VectorType         &u,
     const VectorType   &rhs) const
 {
@@ -825,10 +827,10 @@ MGSmootherRelaxation<MatrixType, RELAX, VectorType>::smooth (const unsigned int
 
 
 
-template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType, class RelaxationType, typename VectorType>
 inline
 std::size_t
-MGSmootherRelaxation<MatrixType, RELAX, VectorType>::
+MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::
 memory_consumption () const
 {
   return sizeof(*this)