]> https://gitweb.dealii.org/ - dealii.git/commitdiff
VECTOR to VectorType, part 2
authorDavid Wells <wellsd2@rpi.edu>
Sat, 24 Oct 2015 22:58:32 +0000 (18:58 -0400)
committerDavid Wells <wellsd2@rpi.edu>
Thu, 12 Nov 2015 19:26:42 +0000 (14:26 -0500)
16 files changed:
include/deal.II/lac/eigen.h
include/deal.II/lac/identity_matrix.h
include/deal.II/lac/iterative_inverse.h
include/deal.II/lac/matrix_lib.h
include/deal.II/lac/matrix_lib.templates.h
include/deal.II/lac/precondition.h
include/deal.II/lac/solver_cg.h
include/deal.II/lac/solver_richardson.h
include/deal.II/lac/solver_selector.h
include/deal.II/lac/vector_memory.h
include/deal.II/meshworker/assembler.h
include/deal.II/meshworker/integration_info.h
include/deal.II/meshworker/simple.h
include/deal.II/meshworker/vector_selector.h
include/deal.II/meshworker/vector_selector.templates.h
include/deal.II/multigrid/multigrid.h

index 63211a2048fe10ee2e1bffcb837528d07c907495..e4c56bed90d2ae58641e457ede06349db18d08f1 100644 (file)
@@ -50,8 +50,8 @@ DEAL_II_NAMESPACE_OPEN
  *
  * @author Guido Kanschat, 2000
  */
-template <class VECTOR = Vector<double> >
-class EigenPower : private Solver<VECTOR>
+template <typename VectorType = Vector<double> >
+class EigenPower : private Solver<VectorType>
 {
 public:
   /**
@@ -82,9 +82,9 @@ public:
   /**
    * Constructor.
    */
-  EigenPower (SolverControl &cn,
-              VectorMemory<VECTOR> &mem,
-              const AdditionalData &data=AdditionalData());
+  EigenPower (SolverControl            &cn,
+              VectorMemory<VectorType> &mem,
+              const AdditionalData     &data=AdditionalData());
 
   /**
    * Virtual destructor.
@@ -101,7 +101,7 @@ public:
   void
   solve (double       &value,
          const MATRIX &A,
-         VECTOR       &x);
+         VectorType   &x);
 
 protected:
   /**
@@ -133,8 +133,8 @@ protected:
  *
  * @author Guido Kanschat, 2000, 2003
  */
-template <class VECTOR = Vector<double> >
-class EigenInverse : private Solver<VECTOR>
+template <typename VectorType = Vector<double> >
+class EigenInverse : private Solver<VectorType>
 {
 public:
   /**
@@ -177,9 +177,9 @@ public:
   /**
    * Constructor.
    */
-  EigenInverse (SolverControl &cn,
-                VectorMemory<VECTOR> &mem,
-                const AdditionalData &data=AdditionalData());
+  EigenInverse (SolverControl            &cn,
+                VectorMemory<VectorType> &mem,
+                const AdditionalData     &data=AdditionalData());
 
 
   /**
@@ -198,7 +198,7 @@ public:
   void
   solve (double       &value,
          const MATRIX &A,
-         VECTOR       &x);
+         VectorType   &x);
 
 protected:
   /**
@@ -211,39 +211,39 @@ protected:
 //---------------------------------------------------------------------------
 
 
-template <class VECTOR>
-EigenPower<VECTOR>::EigenPower (SolverControl &cn,
-                                VectorMemory<VECTOR> &mem,
-                                const AdditionalData &data)
+template <class VectorType>
+EigenPower<VectorType>::EigenPower (SolverControl            &cn,
+                                    VectorMemory<VectorType> &mem,
+                                    const AdditionalData     &data)
   :
-  Solver<VECTOR>(cn, mem),
+  Solver<VectorType>(cn, mem),
   additional_data(data)
 {}
 
 
 
-template <class VECTOR>
-EigenPower<VECTOR>::~EigenPower ()
+template <class VectorType>
+EigenPower<VectorType>::~EigenPower ()
 {}
 
 
 
-template <class VECTOR>
+template <class VectorType>
 template <class MATRIX>
 void
-EigenPower<VECTOR>::solve (double       &value,
-                           const MATRIX &A,
-                           VECTOR       &x)
+EigenPower<VectorType>::solve (double       &value,
+                               const MATRIX &A,
+                               VectorType   &x)
 {
   SolverControl::State conv=SolverControl::iterate;
 
   deallog.push("Power method");
 
-  VECTOR *Vy = this->memory.alloc ();
-  VECTOR &y = *Vy;
+  VectorType *Vy = this->memory.alloc ();
+  VectorType &y = *Vy;
   y.reinit (x);
-  VECTOR *Vr = this->memory.alloc ();
-  VECTOR &r = *Vr;
+  VectorType *Vr = this->memory.alloc ();
+  VectorType &r = *Vr;
   r.reinit (x);
 
   double length = x.l2_norm ();
@@ -305,29 +305,29 @@ EigenPower<VECTOR>::solve (double       &value,
 
 //---------------------------------------------------------------------------
 
-template <class VECTOR>
-EigenInverse<VECTOR>::EigenInverse (SolverControl &cn,
-                                    VectorMemory<VECTOR> &mem,
-                                    const AdditionalData &data)
+template <class VectorType>
+EigenInverse<VectorType>::EigenInverse (SolverControl            &cn,
+                                        VectorMemory<VectorType> &mem,
+                                        const AdditionalData     &data)
   :
-  Solver<VECTOR>(cn, mem),
+  Solver<VectorType>(cn, mem),
   additional_data(data)
 {}
 
 
 
-template <class VECTOR>
-EigenInverse<VECTOR>::~EigenInverse ()
+template <class VectorType>
+EigenInverse<VectorType>::~EigenInverse ()
 {}
 
 
 
-template <class VECTOR>
+template <class VectorType>
 template <class MATRIX>
 void
-EigenInverse<VECTOR>::solve (double       &value,
-                             const MATRIX &A,
-                             VECTOR       &x)
+EigenInverse<VectorType>::solve (double       &value,
+                                 const MATRIX &A,
+                                 VectorType   &x)
 {
   deallog.push("Wielandt");
 
@@ -339,18 +339,18 @@ EigenInverse<VECTOR>::solve (double       &value,
   // Define solver
   ReductionControl inner_control (5000, 1.e-16, 1.e-5, false, false);
   PreconditionIdentity prec;
-  SolverGMRES<VECTOR>
+  SolverGMRES<VectorType>
   solver(inner_control, this->memory);
 
   // Next step for recomputing the shift
   unsigned int goal = additional_data.start_adaption;
 
   // Auxiliary vector
-  VECTOR *Vy = this->memory.alloc ();
-  VECTOR &y = *Vy;
+  VectorType *Vy = this->memory.alloc ();
+  VectorType &y = *Vy;
   y.reinit (x);
-  VECTOR *Vr = this->memory.alloc ();
-  VECTOR &r = *Vr;
+  VectorType *Vr = this->memory.alloc ();
+  VectorType &r = *Vr;
   r.reinit (x);
 
   double length = x.l2_norm ();
index 6dae5bd6aaa1b81d3a0e307ad82cc469eaa2d985..6344c3f54182db59ce6f72b74856500947a7f9eb 100644 (file)
@@ -107,27 +107,27 @@ public:
    * Matrix-vector multiplication. For the present case, this of course
    * amounts to simply copying the input vector to the output vector.
    */
-  template <class VECTOR1, class VECTOR2>
-  void vmult (VECTOR1       &out,
-              const VECTOR2 &in) const;
+  template <typename OutVectorType, typename InVectorType>
+  void vmult (OutVectorType      &out,
+              const InVectorType &in) const;
 
   /**
    * Matrix-vector multiplication with addition to the output vector. For the
    * present case, this of course amounts to simply adding the input vector to
    * the output vector.
    */
-  template <class VECTOR1, class VECTOR2>
-  void vmult_add (VECTOR1       &out,
-                  const VECTOR2 &in) const;
+  template <typename OutVectorType, typename InVectorType>
+  void vmult_add (OutVectorType      &out,
+                  const InVectorType &in) const;
 
   /**
    * Matrix-vector multiplication with the transpose matrix. For the present
    * case, this of course amounts to simply copying the input vector to the
    * output vector.
    */
-  template <class VECTOR1, class VECTOR2>
-  void Tvmult (VECTOR1       &out,
-               const VECTOR2 &in) const;
+  template <typename OutVectorType, typename InVectorType>
+  void Tvmult (OutVectorType      &out,
+               const InVectorType &in) const;
 
 
   /**
@@ -135,9 +135,9 @@ public:
    * the output vector. For the present case, this of course amounts to simply
    * adding the input vector to the output vector.
    */
-  template <class VECTOR1, class VECTOR2>
-  void Tvmult_add (VECTOR1       &out,
-                   const VECTOR2 &in) const;
+  template <typename OutVectorType, typename InVectorType>
+  void Tvmult_add (OutVectorType      &out,
+                   const InVectorType &in) const;
 private:
 
   /**
@@ -196,11 +196,11 @@ IdentityMatrix::n () const
 
 
 
-template <class VECTOR1, class VECTOR2>
+template <typename OutVectorType, typename InVectorType>
 inline
 void
-IdentityMatrix::vmult (VECTOR1       &out,
-                       const VECTOR2 &in) const
+IdentityMatrix::vmult (OutVectorType      &out,
+                       const InVectorType &in) const
 {
   Assert (out.size() == size, ExcDimensionMismatch (out.size(), size));
   Assert (in.size() == size, ExcDimensionMismatch (in.size(), size));
@@ -210,11 +210,11 @@ IdentityMatrix::vmult (VECTOR1       &out,
 
 
 
-template <class VECTOR1, class VECTOR2>
+template <typename OutVectorType, typename InVectorType>
 inline
 void
-IdentityMatrix::vmult_add (VECTOR1       &out,
-                           const VECTOR2 &in) const
+IdentityMatrix::vmult_add (OutVectorType      &out,
+                           const InVectorType &in) const
 {
   Assert (out.size() == size, ExcDimensionMismatch (out.size(), size));
   Assert (in.size() == size, ExcDimensionMismatch (in.size(), size));
@@ -224,11 +224,11 @@ IdentityMatrix::vmult_add (VECTOR1       &out,
 
 
 
-template <class VECTOR1, class VECTOR2>
+template <typename OutVectorType, typename InVectorType>
 inline
 void
-IdentityMatrix::Tvmult (VECTOR1       &out,
-                        const VECTOR2 &in) const
+IdentityMatrix::Tvmult (OutVectorType      &out,
+                        const InVectorType &in) const
 {
   Assert (out.size() == size, ExcDimensionMismatch (out.size(), size));
   Assert (in.size() == size, ExcDimensionMismatch (in.size(), size));
@@ -238,11 +238,11 @@ IdentityMatrix::Tvmult (VECTOR1       &out,
 
 
 
-template <class VECTOR1, class VECTOR2>
+template <typename OutVectorType, typename InVectorType>
 inline
 void
-IdentityMatrix::Tvmult_add (VECTOR1       &out,
-                            const VECTOR2 &in) const
+IdentityMatrix::Tvmult_add (OutVectorType      &out,
+                            const InVectorType &in) const
 {
   Assert (out.size() == size, ExcDimensionMismatch (out.size(), size));
   Assert (in.size() == size, ExcDimensionMismatch (in.size(), size));
@@ -258,4 +258,3 @@ IdentityMatrix::Tvmult_add (VECTOR1       &out,
 DEAL_II_NAMESPACE_CLOSE
 
 #endif
-
index 0fb7db5b743dc78b7aac53d11c55b7bc49d2eb96..3fd6f6f6f048c760dcca6a5695e7cb9a7250d825 100644 (file)
@@ -101,8 +101,8 @@ public:
    * vectors given to this function have different type from the vectors used
    * by the inner solver.
    */
-  template <class VECTOR2>
-  void vmult (VECTOR2 &dst, const VECTOR2 &src) const;
+  template <class OtherVectorType>
+  void vmult (OtherVectorType &dst, const OtherVectorType &src) const;
 
   /**
    * The solver, which allows selection of the actual solver as well as
@@ -158,9 +158,9 @@ IterativeInverse<VectorType>::vmult (VectorType &dst, const VectorType &src) con
 
 
 template <typename VectorType>
-template <class VECTOR2>
+template <class OtherVectorType>
 inline void
-IterativeInverse<VectorType>::vmult (VECTOR2 &dst, const VECTOR2 &src) const
+IterativeInverse<VectorType>::vmult (OtherVectorType &dst, const OtherVectorType &src) const
 {
   Assert(matrix.get() != 0, ExcNotInitialized());
   Assert(preconditioner.get() != 0, ExcNotInitialized());
index d358d11172f697cad8ffc85e59120b1b549deae1..9ccd73b2a03853b1c9601e4ec54c95e466738241 100644 (file)
@@ -51,8 +51,8 @@ template<typename number> class SparseMatrix;
  *
  * @author Guido Kanschat, 2000, 2001, 2002, 2005
  */
-template<class VECTOR>
-class ProductMatrix : public PointerMatrixBase<VECTOR>
+template<typename VectorType>
+class ProductMatrix : public PointerMatrixBase<VectorType>
 {
 public:
   /**
@@ -65,16 +65,16 @@ public:
    * Constructor only assigning the memory pool. Matrices must be added by
    * reinit() later.
    */
-  ProductMatrix(VectorMemory<VECTOR> &mem);
+  ProductMatrix(VectorMemory<VectorType> &mem);
 
   /**
    * Constructor.  Additionally to the two constituting matrices, a memory
    * pool for the auxiliary vector must be provided.
    */
   template <class MATRIX1, class MATRIX2>
-  ProductMatrix(const MATRIX1 &m1,
-                const MATRIX2 &m2,
-                VectorMemory<VECTOR> &mem);
+  ProductMatrix (const MATRIX1            &m1,
+                 const MATRIX2            &m2,
+                 VectorMemory<VectorType> &mem);
 
   /**
    * Destructor.
@@ -92,7 +92,7 @@ public:
    */
   template <class MATRIX1, class MATRIX2>
   void initialize(const MATRIX1 &m1, const MATRIX2 &m2,
-                  VectorMemory<VECTOR> &mem);
+                  VectorMemory<VectorType> &mem);
 
   // Doc in PointerMatrixBase
   void clear();
@@ -100,44 +100,44 @@ public:
   /**
    * Matrix-vector product <i>w = m1 * m2 * v</i>.
    */
-  virtual void vmult (VECTOR       &w,
-                      const VECTOR &v) const;
+  virtual void vmult (VectorType       &w,
+                      const VectorType &v) const;
 
   /**
    * Transposed matrix-vector product <i>w = m2<sup>T</sup> * m1<sup>T</sup> *
    * v</i>.
    */
-  virtual void Tvmult (VECTOR       &w,
-                       const VECTOR &v) const;
+  virtual void Tvmult (VectorType       &w,
+                       const VectorType &v) const;
 
   /**
    * Adding matrix-vector product <i>w += m1 * m2 * v</i>
    */
-  virtual void vmult_add (VECTOR       &w,
-                          const VECTOR &v) const;
+  virtual void vmult_add (VectorType       &w,
+                          const VectorType &v) const;
 
   /**
    * Adding, transposed matrix-vector product <i>w += m2<sup>T</sup> *
    * m1<sup>T</sup> * v</i>.
    */
-  virtual void Tvmult_add (VECTOR       &w,
-                           const VECTOR &v) const;
+  virtual void Tvmult_add (VectorType       &w,
+                           const VectorType &v) const;
 
 private:
   /**
    * The left matrix of the product.
    */
-  PointerMatrixBase<VECTOR> *m1;
+  PointerMatrixBase<VectorType> *m1;
 
   /**
    * The right matrix of the product.
    */
-  PointerMatrixBase<VECTOR> *m2;
+  PointerMatrixBase<VectorType> *m2;
 
   /**
    * Memory for auxiliary vector.
    */
-  SmartPointer<VectorMemory<VECTOR>,ProductMatrix<VECTOR> > mem;
+  SmartPointer<VectorMemory<VectorType>,ProductMatrix<VectorType> > mem;
 };
 
 
@@ -154,7 +154,7 @@ private:
  *
  * @author Guido Kanschat, 2007
  */
-template<class VECTOR>
+template<typename VectorType>
 class ScaledMatrix : public Subscriptor
 {
 public:
@@ -186,18 +186,18 @@ public:
   /**
    * Matrix-vector product.
    */
-  void vmult (VECTOR &w, const VECTOR &v) const;
+  void vmult (VectorType &w, const VectorType &v) const;
 
   /**
    * Transposed matrix-vector product.
    */
-  void Tvmult (VECTOR &w, const VECTOR &v) const;
+  void Tvmult (VectorType &w, const VectorType &v) const;
 
 private:
   /**
    * The matrix.
    */
-  PointerMatrixBase<VECTOR> *m;
+  PointerMatrixBase<VectorType> *m;
   /**
    * The scaling factor;
    */
@@ -240,9 +240,9 @@ public:
    * Constructor.  Additionally to the two constituting matrices, a memory
    * pool for the auxiliary vector must be provided.
    */
-  ProductSparseMatrix(const MatrixType &m1,
-                      const MatrixType &m2,
-                      VectorMemory<VectorType> &mem);
+  ProductSparseMatrix (const MatrixType         &m1,
+                       const MatrixType         &m2,
+                       VectorMemory<VectorType> &mem);
 
   /**
    * Constructor leaving an uninitialized matrix. initialize() must be called,
@@ -250,9 +250,9 @@ public:
    */
   ProductSparseMatrix();
 
-  void initialize(const MatrixType &m1,
-                  const MatrixType &m2,
-                  VectorMemory<VectorType> &mem);
+  void initialize (const MatrixType         &m1,
+                   const MatrixType         &m2,
+                   VectorMemory<VectorType> &mem);
 
   // Doc in PointerMatrixBase
   void clear();
@@ -346,14 +346,14 @@ public:
    * Return the source vector with subtracted mean value.
    */
   template <typename number>
-  void vmult (Vector<number> &dst,
+  void vmult (Vector<number>       &dst,
               const Vector<number> &src) const;
 
   /**
    * Add source vector with subtracted mean value to dest.
    */
   template <typename number>
-  void vmult_add (Vector<number> &dst,
+  void vmult_add (Vector<number>       &dst,
                   const Vector<number> &src) const;
 
   /**
@@ -361,7 +361,7 @@ public:
    * component.
    */
   template <typename number>
-  void vmult (BlockVector<number> &dst,
+  void vmult (BlockVector<number>       &dst,
               const BlockVector<number> &src) const;
 
   /**
@@ -369,21 +369,21 @@ public:
    * subtracted.
    */
   template <typename number>
-  void vmult_add (BlockVector<number> &dst,
+  void vmult_add (BlockVector<number>       &dst,
                   const BlockVector<number> &src) const;
 
 
   /**
    * Not implemented.
    */
-  template <typename VECTOR>
-  void Tvmult(VECTOR &, const VECTOR &) const;
+  template <typename VectorType>
+  void Tvmult(VectorType &, const VectorType &) const;
 
   /**
    * Not implemented.
    */
-  template <typename VECTOR>
-  void Tvmult_add(VECTOR &, const VECTOR &) const;
+  template <typename VectorType>
+  void Tvmult_add(VectorType &, const VectorType &) const;
 
 private:
   /**
@@ -429,7 +429,7 @@ private:
  *
  * @author Guido Kanschat, 2005
  */
-template<class VECTOR>
+template<typename VectorType>
 class InverseMatrixRichardson : public Subscriptor
 {
 public:
@@ -437,8 +437,8 @@ public:
    * Constructor, initializing the solver with a control and memory object.
    * The inverted matrix and the preconditioner are added in initialize().
    */
-  InverseMatrixRichardson (SolverControl &control,
-                           VectorMemory<VECTOR> &mem);
+  InverseMatrixRichardson (SolverControl            &control,
+                           VectorMemory<VectorType> &mem);
   /**
    * Since we use two pointers, we must implement a destructor.
    */
@@ -459,43 +459,43 @@ public:
   /**
    * Execute solver.
    */
-  void vmult (VECTOR &, const VECTOR &) const;
+  void vmult (VectorType &, const VectorType &) const;
 
   /**
    * Execute solver.
    */
-  void vmult_add (VECTOR &, const VECTOR &) const;
+  void vmult_add (VectorType &, const VectorType &) const;
 
   /**
    * Execute transpose solver.
    */
-  void Tvmult (VECTOR &, const VECTOR &) const;
+  void Tvmult (VectorType &, const VectorType &) const;
 
   /**
    * Execute transpose solver.
    */
-  void Tvmult_add (VECTOR &, const VECTOR &) const;
+  void Tvmult_add (VectorType &, const VectorType &) const;
 
 private:
   /**
    * A reference to the provided VectorMemory object.
    */
-  VectorMemory<VECTOR> &mem;
+  VectorMemory<VectorType> &mem;
 
   /**
    * The solver object.
    */
-  mutable SolverRichardson<VECTOR> solver;
+  mutable SolverRichardson<VectorType> solver;
 
   /**
    * The matrix in use.
    */
-  PointerMatrixBase<VECTOR> *matrix;
+  PointerMatrixBase<VectorType> *matrix;
 
   /**
    * The preconditioner to use.
    */
-  PointerMatrixBase<VECTOR> *precondition;
+  PointerMatrixBase<VectorType> *precondition;
 };
 
 
@@ -505,43 +505,43 @@ private:
 //---------------------------------------------------------------------------
 
 
-template<class VECTOR>
+template<typename VectorType>
 inline
-ScaledMatrix<VECTOR>::ScaledMatrix()
+ScaledMatrix<VectorType>::ScaledMatrix()
   :
   m(0)
 {}
 
 
 
-template<class VECTOR>
+template<typename VectorType>
 template<class MATRIX>
 inline
-ScaledMatrix<VECTOR>::ScaledMatrix(const MATRIX &mat, const double factor)
+ScaledMatrix<VectorType>::ScaledMatrix(const MATRIX &mat, const double factor)
   :
-  m(new_pointer_matrix_base(mat, VECTOR())),
+  m(new_pointer_matrix_base(mat, VectorType())),
   factor(factor)
 {}
 
 
 
-template<class VECTOR>
+template<typename VectorType>
 template<class MATRIX>
 inline
 void
-ScaledMatrix<VECTOR>::initialize(const MATRIX &mat, const double f)
+ScaledMatrix<VectorType>::initialize(const MATRIX &mat, const double f)
 {
   if (m) delete m;
-  m = new_pointer_matrix_base(mat, VECTOR());
+  m = new_pointer_matrix_base(mat, VectorType());
   factor = f;
 }
 
 
 
-template<class VECTOR>
+template<typename VectorType>
 inline
 void
-ScaledMatrix<VECTOR>::clear()
+ScaledMatrix<VectorType>::clear()
 {
   if (m) delete m;
   m = 0;
@@ -549,28 +549,28 @@ ScaledMatrix<VECTOR>::clear()
 
 
 
-template<class VECTOR>
+template<typename VectorType>
 inline
-ScaledMatrix<VECTOR>::~ScaledMatrix()
+ScaledMatrix<VectorType>::~ScaledMatrix()
 {
   clear ();
 }
 
 
-template<class VECTOR>
+template<typename VectorType>
 inline
 void
-ScaledMatrix<VECTOR>::vmult (VECTOR &w, const VECTOR &v) const
+ScaledMatrix<VectorType>::vmult (VectorType &w, const VectorType &v) const
 {
   m->vmult(w, v);
   w *= factor;
 }
 
 
-template<class VECTOR>
+template<typename VectorType>
 inline
 void
-ScaledMatrix<VECTOR>::Tvmult (VECTOR &w, const VECTOR &v) const
+ScaledMatrix<VectorType>::Tvmult (VectorType &w, const VectorType &v) const
 {
   m->Tvmult(w, v);
   w *= factor;
@@ -579,72 +579,68 @@ ScaledMatrix<VECTOR>::Tvmult (VECTOR &w, const VECTOR &v) const
 
 //---------------------------------------------------------------------------
 
-template<class VECTOR>
-ProductMatrix<VECTOR>::ProductMatrix ()
+template<typename VectorType>
+ProductMatrix<VectorType>::ProductMatrix ()
   : m1(0), m2(0), mem(0)
 {}
 
 
-template<class VECTOR>
-ProductMatrix<VECTOR>::ProductMatrix (VectorMemory<VECTOR> &m)
+template<typename VectorType>
+ProductMatrix<VectorType>::ProductMatrix (VectorMemory<VectorType> &m)
   : m1(0), m2(0), mem(&m)
 {}
 
 
-template<class VECTOR>
+template<typename VectorType>
 template<class MATRIX1, class MATRIX2>
-ProductMatrix<VECTOR>::ProductMatrix (
-  const MATRIX1 &mat1,
-  const MATRIX2 &mat2,
-  VectorMemory<VECTOR> &m)
+ProductMatrix<VectorType>::ProductMatrix (const MATRIX1            &mat1,
+                                          const MATRIX2            &mat2,
+                                          VectorMemory<VectorType> &m)
   : mem(&m)
 {
-  m1 = new PointerMatrix<MATRIX1, VECTOR>(&mat1, typeid(*this).name());
-  m2 = new PointerMatrix<MATRIX2, VECTOR>(&mat2, typeid(*this).name());
+  m1 = new PointerMatrix<MATRIX1, VectorType>(&mat1, typeid(*this).name());
+  m2 = new PointerMatrix<MATRIX2, VectorType>(&mat2, typeid(*this).name());
 }
 
 
-template<class VECTOR>
+template<typename VectorType>
 template<class MATRIX1, class MATRIX2>
 void
-ProductMatrix<VECTOR>::reinit (
-  const MATRIX1 &mat1,
-  const MATRIX2 &mat2)
+ProductMatrix<VectorType>::reinit (const MATRIX1 &mat1, const MATRIX2 &mat2)
 {
   if (m1) delete m1;
   if (m2) delete m2;
-  m1 = new PointerMatrix<MATRIX1, VECTOR>(&mat1, typeid(*this).name());
-  m2 = new PointerMatrix<MATRIX2, VECTOR>(&mat2, typeid(*this).name());
+  m1 = new PointerMatrix<MATRIX1, VectorType>(&mat1, typeid(*this).name());
+  m2 = new PointerMatrix<MATRIX2, VectorType>(&mat2, typeid(*this).name());
 }
 
 
-template<class VECTOR>
+template<typename VectorType>
 template<class MATRIX1, class MATRIX2>
 void
-ProductMatrix<VECTOR>::initialize (
-  const MATRIX1 &mat1,
-  const MATRIX2 &mat2,
-  VectorMemory<VECTOR> &memory)
+ProductMatrix<VectorType>::initialize (const MATRIX1            &mat1,
+                                       const MATRIX2            &mat2,
+                                       VectorMemory<VectorType> &memory)
 {
   mem = &memory;
   if (m1) delete m1;
   if (m2) delete m2;
-  m1 = new PointerMatrix<MATRIX1, VECTOR>(&mat1, typeid(*this).name());
-  m2 = new PointerMatrix<MATRIX2, VECTOR>(&mat2, typeid(*this).name());
+  m1 = new PointerMatrix<MATRIX1, VectorType>(&mat1, typeid(*this).name());
+  m2 = new PointerMatrix<MATRIX2, VectorType>(&mat2, typeid(*this).name());
 }
 
 
-template<class VECTOR>
-ProductMatrix<VECTOR>::~ProductMatrix ()
+template<typename VectorType>
+ProductMatrix<VectorType>::~ProductMatrix ()
 {
   if (m1) delete m1;
   if (m2) delete m2;
 }
 
 
-template<class VECTOR>
+template<typename VectorType>
 void
-ProductMatrix<VECTOR>::clear ()
+ProductMatrix<VectorType>::clear ()
 {
   if (m1) delete m1;
   m1 = 0;
@@ -653,15 +649,15 @@ ProductMatrix<VECTOR>::clear ()
 }
 
 
-template<class VECTOR>
+template<typename VectorType>
 void
-ProductMatrix<VECTOR>::vmult (VECTOR &dst, const VECTOR &src) const
+ProductMatrix<VectorType>::vmult (VectorType &dst, const VectorType &src) const
 {
   Assert (mem != 0, ExcNotInitialized());
   Assert (m1 != 0, ExcNotInitialized());
   Assert (m2 != 0, ExcNotInitialized());
 
-  VECTOR *v = mem->alloc();
+  VectorType *v = mem->alloc();
   v->reinit(dst);
   m2->vmult (*v, src);
   m1->vmult (dst, *v);
@@ -669,15 +665,15 @@ ProductMatrix<VECTOR>::vmult (VECTOR &dst, const VECTOR &src) const
 }
 
 
-template<class VECTOR>
+template<typename VectorType>
 void
-ProductMatrix<VECTOR>::vmult_add (VECTOR &dst, const VECTOR &src) const
+ProductMatrix<VectorType>::vmult_add (VectorType &dst, const VectorType &src) const
 {
   Assert (mem != 0, ExcNotInitialized());
   Assert (m1 != 0, ExcNotInitialized());
   Assert (m2 != 0, ExcNotInitialized());
 
-  VECTOR *v = mem->alloc();
+  VectorType *v = mem->alloc();
   v->reinit(dst);
   m2->vmult (*v, src);
   m1->vmult_add (dst, *v);
@@ -685,15 +681,15 @@ ProductMatrix<VECTOR>::vmult_add (VECTOR &dst, const VECTOR &src) const
 }
 
 
-template<class VECTOR>
+template<typename VectorType>
 void
-ProductMatrix<VECTOR>::Tvmult (VECTOR &dst, const VECTOR &src) const
+ProductMatrix<VectorType>::Tvmult (VectorType &dst, const VectorType &src) const
 {
   Assert (mem != 0, ExcNotInitialized());
   Assert (m1 != 0, ExcNotInitialized());
   Assert (m2 != 0, ExcNotInitialized());
 
-  VECTOR *v = mem->alloc();
+  VectorType *v = mem->alloc();
   v->reinit(dst);
   m1->Tvmult (*v, src);
   m2->Tvmult (dst, *v);
@@ -701,15 +697,15 @@ ProductMatrix<VECTOR>::Tvmult (VECTOR &dst, const VECTOR &src) const
 }
 
 
-template<class VECTOR>
+template<typename VectorType>
 void
-ProductMatrix<VECTOR>::Tvmult_add (VECTOR &dst, const VECTOR &src) const
+ProductMatrix<VectorType>::Tvmult_add (VectorType &dst, const VectorType &src) const
 {
   Assert (mem != 0, ExcNotInitialized());
   Assert (m1 != 0, ExcNotInitialized());
   Assert (m2 != 0, ExcNotInitialized());
 
-  VECTOR *v = mem->alloc();
+  VectorType *v = mem->alloc();
   v->reinit(dst);
   m1->Tvmult (*v, src);
   m2->Tvmult_add (dst, *v);
@@ -720,34 +716,34 @@ ProductMatrix<VECTOR>::Tvmult_add (VECTOR &dst, const VECTOR &src) const
 
 //---------------------------------------------------------------------------
 
-template <class VECTOR>
+template <typename VectorType>
 inline void
-MeanValueFilter::Tvmult(VECTOR &, const VECTOR &) const
+MeanValueFilter::Tvmult(VectorType &, const VectorType &) const
 {
   Assert(false, ExcNotImplemented());
 }
 
 
-template <class VECTOR>
+template <typename VectorType>
 inline void
-MeanValueFilter::Tvmult_add(VECTOR &, const VECTOR &) const
+MeanValueFilter::Tvmult_add(VectorType &, const VectorType &) const
 {
   Assert(false, ExcNotImplemented());
 }
 
 //-----------------------------------------------------------------------//
 
-template <class VECTOR>
+template <typename VectorType>
 template <class MATRIX, class PRECONDITION>
 inline void
-InverseMatrixRichardson<VECTOR>::initialize (const MATRIX &m, const PRECONDITION &p)
+InverseMatrixRichardson<VectorType>::initialize (const MATRIX &m, const PRECONDITION &p)
 {
   if (matrix != 0)
     delete matrix;
-  matrix = new PointerMatrix<MATRIX, VECTOR>(&m);
+  matrix = new PointerMatrix<MATRIX, VectorType>(&m);
   if (precondition != 0)
     delete precondition;
-  precondition = new PointerMatrix<PRECONDITION, VECTOR>(&p);
+  precondition = new PointerMatrix<PRECONDITION, VectorType>(&p);
 }
 
 
index 16d0435a88cf2b01dd1d5f1cdd2c16e11428c1b3..3b9ade0aa47914f7d3838a52b522a82ea169b72a 100644 (file)
@@ -124,10 +124,10 @@ MeanValueFilter::vmult_add(BlockVector<number> &dst,
 //----------------------------------------------------------------------//
 
 
-template <class VECTOR>
-InverseMatrixRichardson<VECTOR>::InverseMatrixRichardson(
+template <typename VectorType>
+InverseMatrixRichardson<VectorType>::InverseMatrixRichardson(
   SolverControl &c,
-  VectorMemory<VECTOR> &m)
+  VectorMemory<VectorType> &m)
   :
   mem(m),
   solver(c,m),
@@ -136,17 +136,17 @@ InverseMatrixRichardson<VECTOR>::InverseMatrixRichardson(
 {}
 
 
-template <class VECTOR>
-InverseMatrixRichardson<VECTOR>::~InverseMatrixRichardson()
+template <typename VectorType>
+InverseMatrixRichardson<VectorType>::~InverseMatrixRichardson()
 {
   if (matrix != 0) delete matrix;
   if (precondition != 0) delete precondition;
 }
 
 
-template <class VECTOR>
+template <typename VectorType>
 void
-InverseMatrixRichardson<VECTOR>::vmult(VECTOR &dst, const VECTOR &src) const
+InverseMatrixRichardson<VectorType>::vmult(VectorType &dst, const VectorType &src) const
 {
   Assert (matrix != 0, ExcNotInitialized());
   Assert (precondition != 0, ExcNotInitialized());
@@ -156,13 +156,13 @@ InverseMatrixRichardson<VECTOR>::vmult(VECTOR &dst, const VECTOR &src) const
 
 
 
-template <class VECTOR>
+template <typename VectorType>
 void
-InverseMatrixRichardson<VECTOR>::vmult_add(VECTOR &dst, const VECTOR &src) const
+InverseMatrixRichardson<VectorType>::vmult_add(VectorType &dst, const VectorType &src) const
 {
   Assert (matrix != 0, ExcNotInitialized());
   Assert (precondition != 0, ExcNotInitialized());
-  VECTOR *aux = mem.alloc();
+  VectorType *aux = mem.alloc();
   aux->reinit(dst);
 
   solver.solve(*matrix, *aux, src, *precondition);
@@ -173,9 +173,9 @@ InverseMatrixRichardson<VECTOR>::vmult_add(VECTOR &dst, const VECTOR &src) const
 
 
 
-template <class VECTOR>
+template <typename VectorType>
 void
-InverseMatrixRichardson<VECTOR>::Tvmult(VECTOR &dst, const VECTOR &src) const
+InverseMatrixRichardson<VectorType>::Tvmult(VectorType &dst, const VectorType &src) const
 {
   Assert (matrix != 0, ExcNotInitialized());
   Assert (precondition != 0, ExcNotInitialized());
@@ -185,13 +185,13 @@ InverseMatrixRichardson<VECTOR>::Tvmult(VECTOR &dst, const VECTOR &src) const
 
 
 
-template <class VECTOR>
+template <typename VectorType>
 void
-InverseMatrixRichardson<VECTOR>::Tvmult_add(VECTOR &dst, const VECTOR &src) const
+InverseMatrixRichardson<VectorType>::Tvmult_add(VectorType &dst, const VectorType &src) const
 {
   Assert (matrix != 0, ExcNotInitialized());
   Assert (precondition != 0, ExcNotInitialized());
-  VECTOR *aux = mem.alloc();
+  VectorType *aux = mem.alloc();
   aux->reinit(dst);
 
   solver.Tsolve(*matrix, *aux, src, *precondition);
index 6c0285b23aad96d242784661ea2e1e714ca882d1..f806b60733f20da5cdd98e42c8c98439f09faa17 100644 (file)
@@ -105,28 +105,28 @@ public:
   /**
    * Apply preconditioner.
    */
-  template<class VECTOR>
-  void vmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void vmult (VectorType &, const VectorType &) const;
 
   /**
    * Apply transpose preconditioner. Since this is the identity, this function
    * is the same as vmult().
    */
-  template<class VECTOR>
-  void Tvmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void Tvmult (VectorType &, const VectorType &) const;
 
   /**
    * Apply preconditioner, adding to the previous value.
    */
-  template<class VECTOR>
-  void vmult_add (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void vmult_add (VectorType &, const VectorType &) const;
 
   /**
    * Apply transpose preconditioner, adding. Since this is the identity, this
    * function is the same as vmult_add().
    */
-  template<class VECTOR>
-  void Tvmult_add (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void Tvmult_add (VectorType &, const VectorType &) const;
 
   /**
    * This function is only present to provide the interface of a
@@ -228,27 +228,27 @@ public:
   /**
    * Apply preconditioner.
    */
-  template<class VECTOR>
-  void vmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void vmult (VectorType &, const VectorType &) const;
 
   /**
    * Apply transpose preconditioner. Since this is the identity, this function
    * is the same as vmult().
    */
-  template<class VECTOR>
-  void Tvmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void Tvmult (VectorType &, const VectorType &) const;
   /**
    * Apply preconditioner, adding to the previous value.
    */
-  template<class VECTOR>
-  void vmult_add (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void vmult_add (VectorType &, const VectorType &) const;
 
   /**
    * Apply transpose preconditioner, adding. Since this is the identity, this
    * function is the same as vmult_add().
    */
-  template<class VECTOR>
-  void Tvmult_add (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void Tvmult_add (VectorType &, const VectorType &) const;
 
   /**
    * This function is only present to provide the interface of a
@@ -333,14 +333,14 @@ private:
  *
  * @author Guido Kanschat, Wolfgang Bangerth, 1999
  */
-template<class MATRIX = SparseMatrix<double>, class VECTOR = Vector<double> >
+template<class MATRIX = SparseMatrix<double>, class VectorType = Vector<double> >
 class PreconditionUseMatrix : public Subscriptor
 {
 public:
   /**
    * Type of the preconditioning function of the matrix.
    */
-  typedef void ( MATRIX::* function_ptr)(VECTOR &, const VECTOR &) const;
+  typedef void ( MATRIX::* function_ptr)(VectorType &, const VectorType &) const;
 
   /**
    * Constructor.  This constructor stores a reference to the matrix object
@@ -354,8 +354,8 @@ public:
    * Execute preconditioning. Calls the function passed to the constructor of
    * this object with the two arguments given here.
    */
-  void vmult (VECTOR       &dst,
-              const VECTOR &src) const;
+  void vmult (VectorType       &dst,
+              const VectorType &src) const;
 
 private:
   /**
@@ -446,8 +446,8 @@ protected:
 
 /**
  * Jacobi preconditioner using matrix built-in function.  The <tt>MATRIX</tt>
- * class used is required to have a function <tt>precondition_Jacobi(VECTOR&,
- * const VECTOR&, double</tt>)
+ * class used is required to have a function <tt>precondition_Jacobi(VectorType&,
+ * const VectorType&, double</tt>)
  *
  * @code
  *     // Declare related objects
@@ -476,27 +476,27 @@ public:
   /**
    * Apply preconditioner.
    */
-  template<class VECTOR>
-  void vmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void vmult (VectorType &, const VectorType &) const;
 
   /**
    * Apply transpose preconditioner. Since this is a symmetric preconditioner,
    * this function is the same as vmult().
    */
-  template<class VECTOR>
-  void Tvmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void Tvmult (VectorType &, const VectorType &) const;
 
   /**
    * Perform one step of the preconditioned Richardson iteration.
    */
-  template<class VECTOR>
-  void step (VECTOR &x, const VECTOR &rhs) const;
+  template<class VectorType>
+  void step (VectorType &x, const VectorType &rhs) const;
 
   /**
    * Perform one transposed step of the preconditioned Richardson iteration.
    */
-  template<class VECTOR>
-  void Tstep (VECTOR &x, const VECTOR &rhs) const;
+  template<class VectorType>
+  void Tstep (VectorType &x, const VectorType &rhs) const;
 };
 
 
@@ -521,8 +521,8 @@ public:
  * is the operation implemented by step().
  *
  * The MATRIX class used is required to have functions
- * <tt>precondition_SOR(VECTOR&, const VECTOR&, double)</tt> and
- * <tt>precondition_TSOR(VECTOR&, const VECTOR&, double)</tt>.
+ * <tt>precondition_SOR(VectorType&, const VectorType&, double)</tt> and
+ * <tt>precondition_TSOR(VectorType&, const VectorType&, double)</tt>.
  *
  * @code
  *     // Declare related objects
@@ -551,34 +551,34 @@ public:
   /**
    * Apply preconditioner.
    */
-  template<class VECTOR>
-  void vmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void vmult (VectorType &, const VectorType &) const;
 
   /**
    * Apply transpose preconditioner.
    */
-  template<class VECTOR>
-  void Tvmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void Tvmult (VectorType &, const VectorType &) const;
 
   /**
    * Perform one step of the preconditioned Richardson iteration.
    */
-  template<class VECTOR>
-  void step (VECTOR &x, const VECTOR &rhs) const;
+  template<class VectorType>
+  void step (VectorType &x, const VectorType &rhs) const;
 
   /**
    * Perform one transposed step of the preconditioned Richardson iteration.
    */
-  template<class VECTOR>
-  void Tstep (VECTOR &x, const VECTOR &rhs) const;
+  template<class VectorType>
+  void Tstep (VectorType &x, const VectorType &rhs) const;
 };
 
 
 
 /**
  * SSOR preconditioner using matrix built-in function.  The <tt>MATRIX</tt>
- * class used is required to have a function <tt>precondition_SSOR(VECTOR&,
- * const VECTOR&, double)</tt>
+ * class used is required to have a function <tt>precondition_SSOR(VectorType&,
+ * const VectorType&, double)</tt>
  *
  * @code
  *     // Declare related objects
@@ -626,28 +626,28 @@ public:
   /**
    * Apply preconditioner.
    */
-  template<class VECTOR>
-  void vmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void vmult (VectorType &, const VectorType &) const;
 
   /**
    * Apply transpose preconditioner. Since this is a symmetric preconditioner,
    * this function is the same as vmult().
    */
-  template<class VECTOR>
-  void Tvmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void Tvmult (VectorType &, const VectorType &) const;
 
 
   /**
    * Perform one step of the preconditioned Richardson iteration
    */
-  template<class VECTOR>
-  void step (VECTOR &x, const VECTOR &rhs) const;
+  template<class VectorType>
+  void step (VectorType &x, const VectorType &rhs) const;
 
   /**
    * Perform one transposed step of the preconditioned Richardson iteration.
    */
-  template<class VECTOR>
-  void Tstep (VECTOR &x, const VECTOR &rhs) const;
+  template<class VectorType>
+  void Tstep (VectorType &x, const VectorType &rhs) const;
 
 private:
   /**
@@ -660,8 +660,8 @@ private:
 
 /**
  * Permuted SOR preconditioner using matrix built-in function.  The
- * <tt>MATRIX</tt> class used is required to have functions <tt>PSOR(VECTOR&,
- * const VECTOR&, double)</tt> and <tt>TPSOR(VECTOR&, const VECTOR&,
+ * <tt>MATRIX</tt> class used is required to have functions <tt>PSOR(VectorType&,
+ * const VectorType&, double)</tt> and <tt>TPSOR(VectorType&, const VectorType&,
  * double)</tt>.
  *
  * @code
@@ -767,14 +767,14 @@ public:
   /**
    * Apply preconditioner.
    */
-  template<class VECTOR>
-  void vmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void vmult (VectorType &, const VectorType &) const;
 
   /**
    * Apply transpose preconditioner.
    */
-  template<class VECTOR>
-  void Tvmult (VECTOR &, const VECTOR &) const;
+  template<class VectorType>
+  void Tvmult (VectorType &, const VectorType &) const;
 private:
   /**
    * Storage for the permutation vector.
@@ -803,7 +803,7 @@ private:
  * @author Martin Kronbichler, 2009; extension for full compatibility with
  * LinearOperator class: Jean-Paul Pelteret, 2015
  */
-template <class MATRIX=SparseMatrix<double>, class VECTOR=Vector<double> >
+template <class MATRIX=SparseMatrix<double>, class VectorType=Vector<double> >
 class PreconditionChebyshev : public Subscriptor
 {
 public:
@@ -883,7 +883,7 @@ public:
     /**
      * Stores the inverse of the diagonal of the underlying matrix.
      */
-    VECTOR matrix_diagonal_inverse;
+    VectorType matrix_diagonal_inverse;
   };
 
   PreconditionChebyshev ();
@@ -906,15 +906,15 @@ public:
    * Computes the action of the preconditioner on <tt>src</tt>, storing the
    * result in <tt>dst</tt>.
    */
-  void vmult (VECTOR       &dst,
-              const VECTOR &src) const;
+  void vmult (VectorType       &dst,
+              const VectorType &src) const;
 
   /**
    * Computes the action of the transposed preconditioner on <tt>src</tt>,
    * storing the result in <tt>dst</tt>.
    */
-  void Tvmult (VECTOR       &dst,
-               const VECTOR &src) const;
+  void Tvmult (VectorType       &dst,
+               const VectorType &src) const;
 
   /**
    * Resets the preconditioner.
@@ -938,17 +938,17 @@ private:
   /**
    * A pointer to the underlying matrix.
    */
-  SmartPointer<const MATRIX,PreconditionChebyshev<MATRIX,VECTOR> > matrix_ptr;
+  SmartPointer<const MATRIX,PreconditionChebyshev<MATRIX,VectorType> > matrix_ptr;
 
   /**
    * Internal vector used for the <tt>vmult</tt> operation.
    */
-  mutable VECTOR update1;
+  mutable VectorType update1;
 
   /**
    * Internal vector used for the <tt>vmult</tt> operation.
    */
-  mutable VECTOR update2;
+  mutable VectorType update2;
 
   /**
    * Stores the additional data provided to the initialize function.
@@ -997,34 +997,34 @@ PreconditionIdentity::initialize (
 }
 
 
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionIdentity::vmult (VECTOR &dst, const VECTOR &src) const
+PreconditionIdentity::vmult (VectorType &dst, const VectorType &src) const
 {
   dst = src;
 }
 
 
 
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionIdentity::Tvmult (VECTOR &dst, const VECTOR &src) const
+PreconditionIdentity::Tvmult (VectorType &dst, const VectorType &src) const
 {
   dst = src;
 }
 
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionIdentity::vmult_add (VECTOR &dst, const VECTOR &src) const
+PreconditionIdentity::vmult_add (VectorType &dst, const VectorType &src) const
 {
   dst.add(src);
 }
 
 
 
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionIdentity::Tvmult_add (VECTOR &dst, const VECTOR &src) const
+PreconditionIdentity::Tvmult_add (VectorType &dst, const VectorType &src) const
 {
   dst.add(src);
 }
@@ -1088,14 +1088,14 @@ PreconditionRichardson::initialize (
 
 
 
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionRichardson::vmult (VECTOR &dst, const VECTOR &src) const
+PreconditionRichardson::vmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<size_type, typename VECTOR::size_type>::value,
-    "PreconditionRichardson and VECTOR must have the same size_type.");
+    std::is_same<size_type, typename VectorType::size_type>::value,
+    "PreconditionRichardson and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   dst.equ(relaxation,src);
@@ -1103,27 +1103,27 @@ PreconditionRichardson::vmult (VECTOR &dst, const VECTOR &src) const
 
 
 
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionRichardson::Tvmult (VECTOR &dst, const VECTOR &src) const
+PreconditionRichardson::Tvmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<size_type, typename VECTOR::size_type>::value,
-    "PreconditionRichardson and VECTOR must have the same size_type.");
+    std::is_same<size_type, typename VectorType::size_type>::value,
+    "PreconditionRichardson and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   dst.equ(relaxation,src);
 }
 
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionRichardson::vmult_add (VECTOR &dst, const VECTOR &src) const
+PreconditionRichardson::vmult_add (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<size_type, typename VECTOR::size_type>::value,
-    "PreconditionRichardson and VECTOR must have the same size_type.");
+    std::is_same<size_type, typename VectorType::size_type>::value,
+    "PreconditionRichardson and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   dst.add(relaxation,src);
@@ -1131,14 +1131,14 @@ PreconditionRichardson::vmult_add (VECTOR &dst, const VECTOR &src) const
 
 
 
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionRichardson::Tvmult_add (VECTOR &dst, const VECTOR &src) const
+PreconditionRichardson::Tvmult_add (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<size_type, typename VECTOR::size_type>::value,
-    "PreconditionRichardson and VECTOR must have the same size_type.");
+    std::is_same<size_type, typename VectorType::size_type>::value,
+    "PreconditionRichardson and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   dst.add(relaxation,src);
@@ -1196,14 +1196,14 @@ PreconditionRelaxation<MATRIX>::n () const
 //---------------------------------------------------------------------------
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionJacobi<MATRIX>::vmult (VECTOR &dst, const VECTOR &src) const
+PreconditionJacobi<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionJacobi and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionJacobi and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1213,14 +1213,14 @@ PreconditionJacobi<MATRIX>::vmult (VECTOR &dst, const VECTOR &src) const
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionJacobi<MATRIX>::Tvmult (VECTOR &dst, const VECTOR &src) const
+PreconditionJacobi<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionJacobi and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionJacobi and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1230,14 +1230,14 @@ PreconditionJacobi<MATRIX>::Tvmult (VECTOR &dst, const VECTOR &src) const
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionJacobi<MATRIX>::step (VECTOR &dst, const VECTOR &src) const
+PreconditionJacobi<MATRIX>::step (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionJacobi and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionJacobi and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1247,14 +1247,14 @@ PreconditionJacobi<MATRIX>::step (VECTOR &dst, const VECTOR &src) const
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionJacobi<MATRIX>::Tstep (VECTOR &dst, const VECTOR &src) const
+PreconditionJacobi<MATRIX>::Tstep (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionJacobi and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionJacobi and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   step (dst, src);
@@ -1265,14 +1265,14 @@ PreconditionJacobi<MATRIX>::Tstep (VECTOR &dst, const VECTOR &src) const
 //---------------------------------------------------------------------------
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionSOR<MATRIX>::vmult (VECTOR &dst, const VECTOR &src) const
+PreconditionSOR<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionSOR and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1282,14 +1282,14 @@ PreconditionSOR<MATRIX>::vmult (VECTOR &dst, const VECTOR &src) const
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionSOR<MATRIX>::Tvmult (VECTOR &dst, const VECTOR &src) const
+PreconditionSOR<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionSOR and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1299,14 +1299,14 @@ PreconditionSOR<MATRIX>::Tvmult (VECTOR &dst, const VECTOR &src) const
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionSOR<MATRIX>::step (VECTOR &dst, const VECTOR &src) const
+PreconditionSOR<MATRIX>::step (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionSOR and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1316,14 +1316,14 @@ PreconditionSOR<MATRIX>::step (VECTOR &dst, const VECTOR &src) const
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionSOR<MATRIX>::Tstep (VECTOR &dst, const VECTOR &src) const
+PreconditionSOR<MATRIX>::Tstep (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionSOR and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1369,14 +1369,14 @@ PreconditionSSOR<MATRIX>::initialize (const MATRIX &rA,
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionSSOR<MATRIX>::vmult (VECTOR &dst, const VECTOR &src) const
+PreconditionSSOR<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionSSOR and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionSSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1386,14 +1386,14 @@ PreconditionSSOR<MATRIX>::vmult (VECTOR &dst, const VECTOR &src) const
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionSSOR<MATRIX>::Tvmult (VECTOR &dst, const VECTOR &src) const
+PreconditionSSOR<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionSSOR and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionSSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1403,14 +1403,14 @@ PreconditionSSOR<MATRIX>::Tvmult (VECTOR &dst, const VECTOR &src) const
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionSSOR<MATRIX>::step (VECTOR &dst, const VECTOR &src) const
+PreconditionSSOR<MATRIX>::step (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionSSOR and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionSSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1420,14 +1420,14 @@ PreconditionSSOR<MATRIX>::step (VECTOR &dst, const VECTOR &src) const
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionSSOR<MATRIX>::Tstep (VECTOR &dst, const VECTOR &src) const
+PreconditionSSOR<MATRIX>::Tstep (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionSSOR and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionSSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   step (dst, src);
@@ -1465,14 +1465,14 @@ PreconditionPSOR<MATRIX>::initialize (
 
 
 template <class MATRIX>
-template<class VECTOR>
+template <typename VectorType>
 inline void
-PreconditionPSOR<MATRIX>::vmult (VECTOR &dst, const VECTOR &src) const
+PreconditionPSOR<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionPSOR<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionPSOR and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionPSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionPSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1483,14 +1483,14 @@ PreconditionPSOR<MATRIX>::vmult (VECTOR &dst, const VECTOR &src) const
 
 
 template <class MATRIX>
-template<class VECTOR>
+template<class VectorType>
 inline void
-PreconditionPSOR<MATRIX>::Tvmult (VECTOR &dst, const VECTOR &src) const
+PreconditionPSOR<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionPSOR<MATRIX>::size_type, typename VECTOR::size_type>::value,
-    "PreconditionPSOR and VECTOR must have the same size_type.");
+    std::is_same<typename PreconditionPSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    "PreconditionPSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
   Assert (this->A!=0, ExcNotInitialized());
@@ -1515,19 +1515,19 @@ PreconditionPSOR<MATRIX>::AdditionalData::AdditionalData (
 //---------------------------------------------------------------------------
 
 
-template<class MATRIX, class VECTOR>
-PreconditionUseMatrix<MATRIX,VECTOR>::PreconditionUseMatrix(const MATRIX       &M,
-                                                            const function_ptr  method)
+template<class MATRIX, class VectorType>
+PreconditionUseMatrix<MATRIX,VectorType>::PreconditionUseMatrix(const MATRIX       &M,
+                                                                const function_ptr method)
   :
   matrix(M), precondition(method)
 {}
 
 
 
-template<class MATRIX, class VECTOR>
+template<class MATRIX, class VectorType>
 void
-PreconditionUseMatrix<MATRIX,VECTOR>::vmult (VECTOR &dst,
-                                             const VECTOR &src) const
+PreconditionUseMatrix<MATRIX,VectorType>::vmult (VectorType       &dst,
+                                                 const VectorType &src) const
 {
   (matrix.*precondition)(dst, src);
 }
@@ -1556,17 +1556,17 @@ namespace internal
     // size of the vector
 
     // generic part for non-deal.II vectors
-    template <typename VECTOR>
+    template <typename VectorType>
     inline
     void
-    vector_updates (const VECTOR &src,
-                    const VECTOR &matrix_diagonal_inverse,
-                    const bool    start_zero,
-                    const double  factor1,
-                    const double  factor2,
-                    VECTOR &update1,
-                    VECTOR &update2,
-                    VECTOR &dst)
+    vector_updates (const VectorType &src,
+                    const VectorType &matrix_diagonal_inverse,
+                    const bool       start_zero,
+                    const double     factor1,
+                    const double     factor2,
+                    VectorType       &update1,
+                    VectorType       &update2,
+                    VectorType       &dst)
     {
       if (start_zero)
         {
@@ -1728,22 +1728,22 @@ namespace internal
       VectorUpdatesRange<Number>(upd, src.local_size());
     }
 
-    template <typename VECTOR>
+    template <typename VectorType>
     struct DiagonalPreconditioner
     {
-      DiagonalPreconditioner (const VECTOR &vector)
+      DiagonalPreconditioner (const VectorType &vector)
         :
         diagonal_vector(vector)
       {}
 
-      void vmult (VECTOR &dst,
-                  const VECTOR &src) const
+      void vmult (VectorType       &dst,
+                  const VectorType &src) const
       {
         dst = src;
         dst.scale(diagonal_vector);
       }
 
-      const VECTOR &diagonal_vector;
+      const VectorType &diagonal_vector;
     };
 
     struct EigenvalueTracker
@@ -1761,9 +1761,9 @@ namespace internal
 
 
 
-template <class MATRIX, class VECTOR>
+template <class MATRIX, class VectorType>
 inline
-PreconditionChebyshev<MATRIX,VECTOR>::AdditionalData::
+PreconditionChebyshev<MATRIX,VectorType>::AdditionalData::
 AdditionalData (const unsigned int degree,
                 const double       smoothing_range,
                 const bool         nonzero_starting,
@@ -1781,26 +1781,26 @@ AdditionalData (const unsigned int degree,
 
 
 
-template <class MATRIX, class VECTOR>
+template <class MATRIX, class VectorType>
 inline
-PreconditionChebyshev<MATRIX,VECTOR>::PreconditionChebyshev ()
+PreconditionChebyshev<MATRIX,VectorType>::PreconditionChebyshev ()
   :
   is_initialized (false)
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<size_type, typename VECTOR::size_type>::value,
-    "PreconditionChebyshev and VECTOR must have the same size_type.");
+    std::is_same<size_type, typename VectorType::size_type>::value,
+    "PreconditionChebyshev and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 }
 
 
 
-template <class MATRIX, class VECTOR>
+template <class MATRIX, class VectorType>
 inline
 void
-PreconditionChebyshev<MATRIX,VECTOR>::initialize (const MATRIX &matrix,
-                                                  const AdditionalData &additional_data)
+PreconditionChebyshev<MATRIX,VectorType>::initialize (const MATRIX         &matrix,
+                                                      const AdditionalData &additional_data)
 {
   matrix_ptr = &matrix;
   data = additional_data;
@@ -1825,9 +1825,9 @@ PreconditionChebyshev<MATRIX,VECTOR>::initialize (const MATRIX &matrix,
 
       // set a very strict tolerance to force at least two iterations
       ReductionControl control (data.eig_cg_n_iterations, 1e-35, 1e-10);
-      GrowingVectorMemory<VECTOR> memory;
-      VECTOR *rhs = memory.alloc();
-      VECTOR *dummy = memory.alloc();
+      GrowingVectorMemory<VectorType> memory;
+      VectorType *rhs = memory.alloc();
+      VectorType *dummy = memory.alloc();
       rhs->reinit(data.matrix_diagonal_inverse);
       dummy->reinit(data.matrix_diagonal_inverse);
 
@@ -1842,11 +1842,11 @@ PreconditionChebyshev<MATRIX,VECTOR>::initialize (const MATRIX &matrix,
       rhs->compress(VectorOperation::insert);
 
       internal::PreconditionChebyshev::EigenvalueTracker eigenvalue_tracker;
-      SolverCG<VECTOR> solver (control, memory);
+      SolverCG<VectorType> solver (control, memory);
       solver.connect_eigenvalues_slot(std_cxx11::bind(&internal::PreconditionChebyshev::EigenvalueTracker::slot,
                                                       &eigenvalue_tracker,
                                                       std_cxx11::_1));
-      internal::PreconditionChebyshev::DiagonalPreconditioner<VECTOR>
+      internal::PreconditionChebyshev::DiagonalPreconditioner<VectorType>
       preconditioner(data.matrix_diagonal_inverse);
       try
         {
@@ -1892,11 +1892,11 @@ PreconditionChebyshev<MATRIX,VECTOR>::initialize (const MATRIX &matrix,
 
 
 
-template <class MATRIX, class VECTOR>
+template <class MATRIX, class VectorType>
 inline
 void
-PreconditionChebyshev<MATRIX,VECTOR>::vmult (VECTOR &dst,
-                                             const VECTOR &src) const
+PreconditionChebyshev<MATRIX,VectorType>::vmult (VectorType       &dst,
+                                                 const VectorType &src) const
 {
   Assert (is_initialized, ExcMessage("Preconditioner not initialized"));
   double rhok  = delta / theta,  sigma = theta / delta;
@@ -1926,11 +1926,11 @@ PreconditionChebyshev<MATRIX,VECTOR>::vmult (VECTOR &dst,
 
 
 
-template <class MATRIX, class VECTOR>
+template <class MATRIX, class VectorType>
 inline
 void
-PreconditionChebyshev<MATRIX,VECTOR>::Tvmult (VECTOR &dst,
-                                              const VECTOR &src) const
+PreconditionChebyshev<MATRIX,VectorType>::Tvmult (VectorType       &dst,
+                                                  const VectorType &src) const
 {
   Assert (is_initialized, ExcMessage("Preconditioner not initialized"));
   double rhok  = delta / theta,  sigma = theta / delta;
@@ -1960,9 +1960,9 @@ PreconditionChebyshev<MATRIX,VECTOR>::Tvmult (VECTOR &dst,
 
 
 
-template <class MATRIX, class VECTOR>
+template <class MATRIX, typename VectorType>
 inline
-void PreconditionChebyshev<MATRIX,VECTOR>::clear ()
+void PreconditionChebyshev<MATRIX,VectorType>::clear ()
 {
   is_initialized = false;
   matrix_ptr = 0;
@@ -1972,20 +1972,20 @@ void PreconditionChebyshev<MATRIX,VECTOR>::clear ()
 }
 
 
-template <class MATRIX, class VECTOR>
+template <class MATRIX, typename VectorType>
 inline
-typename PreconditionChebyshev<MATRIX,VECTOR>::size_type
-PreconditionChebyshev<MATRIX,VECTOR>::m () const
+typename PreconditionChebyshev<MATRIX,VectorType>::size_type
+PreconditionChebyshev<MATRIX,VectorType>::m () const
 {
   Assert (matrix_ptr!=0, ExcNotInitialized());
   return matrix_ptr->m();
 }
 
 
-template <class MATRIX, class VECTOR>
+template <class MATRIX, typename VectorType>
 inline
-typename PreconditionChebyshev<MATRIX,VECTOR>::size_type
-PreconditionChebyshev<MATRIX,VECTOR>::n () const
+typename PreconditionChebyshev<MATRIX,VectorType>::size_type
+PreconditionChebyshev<MATRIX,VectorType>::n () const
 {
   Assert (matrix_ptr!=0, ExcNotInitialized());
   return matrix_ptr->n();
index c11f6f52e822ebdf8ec60037345933e7061f0516..2829124fcc33ba7b2cb3aa93de1d8c650fe3bf97 100644 (file)
@@ -95,8 +95,8 @@ class PreconditionIdentity;
  *
  * @author W. Bangerth, G. Kanschat, R. Becker and F.-T. Suttmeier
  */
-template <class VECTOR = Vector<double> >
-class SolverCG : public Solver<VECTOR>
+template <typename VectorType = Vector<double> >
+class SolverCG : public Solver<VectorType>
 {
 public:
   /**
@@ -156,9 +156,9 @@ public:
   /**
    * Constructor.
    */
-  SolverCG (SolverControl        &cn,
-            VectorMemory<VECTOR> &mem,
-            const AdditionalData &data = AdditionalData());
+  SolverCG (SolverControl            &cn,
+            VectorMemory<VectorType> &mem,
+            const AdditionalData     &data = AdditionalData());
 
   /**
    * Constructor. Use an object of type GrowingVectorMemory as a default to
@@ -178,8 +178,8 @@ public:
   template <class MATRIX, class PRECONDITIONER>
   void
   solve (const MATRIX         &A,
-         VECTOR               &x,
-         const VECTOR         &b,
+         VectorType           &x,
+         const VectorType     &b,
          const PRECONDITIONER &precondition);
 
   /**
@@ -227,9 +227,9 @@ protected:
    * for a graphical output of the convergence history.
    */
   virtual void print_vectors(const unsigned int step,
-                             const VECTOR &x,
-                             const VECTOR &r,
-                             const VECTOR &d) const;
+                             const VectorType   &x,
+                             const VectorType   &r,
+                             const VectorType   &d) const;
 
   /**
    * Estimates the eigenvalues from diagonal and offdiagonal. Uses
@@ -251,9 +251,9 @@ protected:
    * Temporary vectors, allocated through the @p VectorMemory object at the
    * start of the actual solution process and deallocated at the end.
    */
-  VECTOR *Vr;
-  VECTOR *Vp;
-  VECTOR *Vz;
+  VectorType *Vr;
+  VectorType *Vp;
+  VectorType *Vz;
 
   /**
    * Within the iteration loop, the square of the residual vector is stored in
@@ -308,9 +308,9 @@ private:
 
 #ifndef DOXYGEN
 
-template <class VECTOR>
+template <typename VectorType>
 inline
-SolverCG<VECTOR>::AdditionalData::
+SolverCG<VectorType>::AdditionalData::
 AdditionalData (const bool log_coefficients,
                 const bool compute_condition_number,
                 const bool compute_all_condition_numbers,
@@ -324,9 +324,9 @@ AdditionalData (const bool log_coefficients,
 
 
 
-template <class VECTOR>
+template <typename VectorType>
 inline
-SolverCG<VECTOR>::AdditionalData::
+SolverCG<VectorType>::AdditionalData::
 AdditionalData ()
   :
   log_coefficients (false),
@@ -337,45 +337,45 @@ AdditionalData ()
 
 
 
-template <class VECTOR>
-SolverCG<VECTOR>::SolverCG (SolverControl        &cn,
-                            VectorMemory<VECTOR> &mem,
-                            const AdditionalData &data)
+template <typename VectorType>
+SolverCG<VectorType>::SolverCG (SolverControl        &cn,
+                            VectorMemory<VectorType> &mem,
+                            const AdditionalData     &data)
   :
-  Solver<VECTOR>(cn,mem),
+  Solver<VectorType>(cn,mem),
   additional_data(data)
 {}
 
 
 
-template <class VECTOR>
-SolverCG<VECTOR>::SolverCG (SolverControl        &cn,
-                            const AdditionalData &data)
+template <typename VectorType>
+SolverCG<VectorType>::SolverCG (SolverControl        &cn,
+                                const AdditionalData &data)
   :
-  Solver<VECTOR>(cn),
+  Solver<VectorType>(cn),
   additional_data(data)
 {}
 
 
 
-template <class VECTOR>
-SolverCG<VECTOR>::~SolverCG ()
+template <typename VectorType>
+SolverCG<VectorType>::~SolverCG ()
 {}
 
 
 
-template <class VECTOR>
+template <typename VectorType>
 double
-SolverCG<VECTOR>::criterion()
+SolverCG<VectorType>::criterion()
 {
   return std::sqrt(res2);
 }
 
 
 
-template <class VECTOR>
+template <typename VectorType>
 void
-SolverCG<VECTOR>::cleanup()
+SolverCG<VectorType>::cleanup()
 {
   this->memory.free(Vr);
   this->memory.free(Vp);
@@ -385,25 +385,25 @@ SolverCG<VECTOR>::cleanup()
 
 
 
-template <class VECTOR>
+template <typename VectorType>
 void
-SolverCG<VECTOR>::print_vectors(const unsigned int,
-                                const VECTOR &,
-                                const VECTOR &,
-                                const VECTOR &) const
+SolverCG<VectorType>::print_vectors(const unsigned int,
+                                    const VectorType &,
+                                    const VectorType &,
+                                    const VectorType &) const
 {}
 
 
 
-template <class VECTOR>
+template <typename VectorType>
 inline void
-SolverCG<VECTOR>::compute_eigs_and_cond(
-  const std::vector<double> &diagonal,
 const std::vector<double> &offdiagonal,
 const boost::signals2::signal<void (const std::vector<double> &)> &eigenvalues_signal,
 const boost::signals2::signal<void (double)> &cond_signal,
 const bool log_eigenvalues,
 const bool log_cond)
+SolverCG<VectorType>::compute_eigs_and_cond
+(const std::vector<double> &diagonal,
+ const std::vector<double> &offdiagonal,
+ const boost::signals2::signal<void (const std::vector<double> &)> &eigenvalues_signal,
const boost::signals2::signal<void (double)>                      &cond_signal,
const bool                log_eigenvalues,
const bool                log_cond)
 {
   //Avoid computing eigenvalues unless they are needed.
   if (!cond_signal.empty()|| !eigenvalues_signal.empty()  || log_cond ||
@@ -452,13 +452,13 @@ SolverCG<VECTOR>::compute_eigs_and_cond(
 
 
 
-template <class VECTOR>
+template <typename VectorType>
 template <class MATRIX, class PRECONDITIONER>
 void
-SolverCG<VECTOR>::solve (const MATRIX         &A,
-                         VECTOR               &x,
-                         const VECTOR         &b,
-                         const PRECONDITIONER &precondition)
+SolverCG<VectorType>::solve (const MATRIX         &A,
+                             VectorType           &x,
+                             const VectorType     &b,
+                             const PRECONDITIONER &precondition)
 {
   SolverControl::State conv=SolverControl::iterate;
 
@@ -490,9 +490,9 @@ SolverCG<VECTOR>::solve (const MATRIX         &A,
   try
     {
       // define some aliases for simpler access
-      VECTOR &g = *Vr;
-      VECTOR &d = *Vz;
-      VECTOR &h = *Vp;
+      VectorType &g = *Vr;
+      VectorType &d = *Vz;
+      VectorType &h = *Vp;
       // resize the vectors, but do not set
       // the values since they'd be overwritten
       // soon anyway.
@@ -611,21 +611,21 @@ SolverCG<VECTOR>::solve (const MATRIX         &A,
 
 
 
-template<class VECTOR>
+template<typename VectorType>
 boost::signals2::connection
-SolverCG<VECTOR>::connect_coefficients_slot(
-  const std_cxx11::function<void(double,double)> &slot)
+SolverCG<VectorType>::connect_coefficients_slot
+(const std_cxx11::function<void(double,double)> &slot)
 {
   return coefficients_signal.connect(slot);
 }
 
 
 
-template<class VECTOR>
+template<typename VectorType>
 boost::signals2::connection
-SolverCG<VECTOR>::connect_condition_number_slot(
-  const std_cxx11::function<void(double)> &slot,
 const bool every_iteration)
+SolverCG<VectorType>::connect_condition_number_slot
+(const std_cxx11::function<void(double)> &slot,
const bool                              every_iteration)
 {
   if (every_iteration)
     {
@@ -639,11 +639,11 @@ SolverCG<VECTOR>::connect_condition_number_slot(
 
 
 
-template<class VECTOR>
+template<typename VectorType>
 boost::signals2::connection
-SolverCG<VECTOR>::connect_eigenvalues_slot(
-  const std_cxx11::function<void (const std::vector<double> &)> &slot,
 const bool every_iteration)
+SolverCG<VectorType>::connect_eigenvalues_slot
+(const std_cxx11::function<void (const std::vector<double> &)> &slot,
const bool                                                    every_iteration)
 {
   if (every_iteration)
     {
index e96c3f1b9e9d834ae3e67b86216d83391386b0fa..ac8e3e1144aebc7b90257f2919edc5355ea97e93 100644 (file)
@@ -57,8 +57,8 @@ DEAL_II_NAMESPACE_OPEN
  *
  * @author Ralf Hartmann
  */
-template <class VECTOR = Vector<double> >
-class SolverRichardson : public Solver<VECTOR>
+template <class VectorType = Vector<double> >
+class SolverRichardson : public Solver<VectorType>
 {
 public:
   /**
@@ -88,9 +88,9 @@ public:
   /**
    * Constructor.
    */
-  SolverRichardson (SolverControl        &cn,
-                    VectorMemory<VECTOR> &mem,
-                    const AdditionalData &data=AdditionalData());
+  SolverRichardson (SolverControl            &cn,
+                    VectorMemory<VectorType> &mem,
+                    const AdditionalData     &data=AdditionalData());
 
   /**
    * Constructor. Use an object of type GrowingVectorMemory as a default to
@@ -110,8 +110,8 @@ public:
   template<class MATRIX, class PRECONDITIONER>
   void
   solve (const MATRIX         &A,
-         VECTOR               &x,
-         const VECTOR         &b,
+         VectorType           &x,
+         const VectorType     &b,
          const PRECONDITIONER &precondition);
 
   /**
@@ -120,8 +120,8 @@ public:
   template<class MATRIX, class PRECONDITIONER>
   void
   Tsolve (const MATRIX         &A,
-          VECTOR               &x,
-          const VECTOR         &b,
+          VectorType           &x,
+          const VectorType     &b,
           const PRECONDITIONER &precondition);
 
   /**
@@ -134,28 +134,28 @@ public:
    * vector, the residual and the update vector in each step. It can be used
    * for a graphical output of the convergence history.
    */
-  virtual void print_vectors(const unsigned int step,
-                             const VECTOR &x,
-                             const VECTOR &r,
-                             const VECTOR &d) const;
+  virtual void print_vectors (const unsigned int step,
+                              const VectorType &x,
+                              const VectorType &r,
+                              const VectorType &d) const;
 
 protected:
   /**
    * Implementation of the computation of the norm of the residual.
    */
-  virtual typename VECTOR::value_type criterion();
+  virtual typename VectorType::value_type criterion();
 
   /**
    * Residual. Temporary vector allocated through the VectorMemory object at
    * the start of the actual solution process and deallocated at the end.
    */
-  VECTOR *Vr;
+  VectorType *Vr;
   /**
    * Preconditioned residual. Temporary vector allocated through the
    * VectorMemory object at the start of the actual solution process and
    * deallocated at the end.
    */
-  VECTOR *Vd;
+  VectorType *Vd;
 
   /**
    * Control parameters.
@@ -168,7 +168,7 @@ protected:
    * convergence value, which in this class is the norm of the residual vector
    * and thus the square root of the @p res2 value.
    */
-  typename VECTOR::value_type res;
+  typename VectorType::value_type res;
 };
 
 /*@}*/
@@ -176,9 +176,9 @@ protected:
 
 #ifndef DOXYGEN
 
-template <class VECTOR>
+template <class VectorType>
 inline
-SolverRichardson<VECTOR>::AdditionalData::
+SolverRichardson<VectorType>::AdditionalData::
 AdditionalData (const double omega,
                 const bool   use_preconditioned_residual)
   :
@@ -187,39 +187,39 @@ AdditionalData (const double omega,
 {}
 
 
-template <class VECTOR>
-SolverRichardson<VECTOR>::SolverRichardson(SolverControl &cn,
-                                           VectorMemory<VECTOR> &mem,
-                                           const AdditionalData &data)
+template <class VectorType>
+SolverRichardson<VectorType>::SolverRichardson(SolverControl            &cn,
+                                               VectorMemory<VectorType> &mem,
+                                               const AdditionalData     &data)
   :
-  Solver<VECTOR> (cn,mem),
+  Solver<VectorType> (cn,mem),
   additional_data(data)
 {}
 
 
 
-template <class VECTOR>
-SolverRichardson<VECTOR>::SolverRichardson(SolverControl &cn,
-                                           const AdditionalData &data)
+template <class VectorType>
+SolverRichardson<VectorType>::SolverRichardson(SolverControl        &cn,
+                                               const AdditionalData &data)
   :
-  Solver<VECTOR> (cn),
+  Solver<VectorType> (cn),
   additional_data(data)
 {}
 
 
 
-template <class VECTOR>
-SolverRichardson<VECTOR>::~SolverRichardson()
+template <class VectorType>
+SolverRichardson<VectorType>::~SolverRichardson()
 {}
 
 
-template <class VECTOR>
+template <class VectorType>
 template <class MATRIX, class PRECONDITIONER>
 void
-SolverRichardson<VECTOR>::solve (const MATRIX         &A,
-                                 VECTOR               &x,
-                                 const VECTOR         &b,
-                                 const PRECONDITIONER &precondition)
+SolverRichardson<VectorType>::solve (const MATRIX         &A,
+                                     VectorType           &x,
+                                     const VectorType     &b,
+                                     const PRECONDITIONER &precondition)
 {
   SolverControl::State conv=SolverControl::iterate;
 
@@ -229,10 +229,10 @@ SolverRichardson<VECTOR>::solve (const MATRIX         &A,
 
   // Memory allocation
   Vr  = this->memory.alloc();
-  VECTOR &r  = *Vr;
+  VectorType &r  = *Vr;
   r.reinit(x);
   Vd  = this->memory.alloc();
-  VECTOR &d  = *Vd;
+  VectorType &d  = *Vd;
   d.reinit(x);
 
   deallog.push("Richardson");
@@ -284,13 +284,13 @@ SolverRichardson<VECTOR>::solve (const MATRIX         &A,
 }
 
 
-template <class VECTOR>
+template <class VectorType>
 template <class MATRIX, class PRECONDITIONER>
 void
-SolverRichardson<VECTOR>::Tsolve (const MATRIX         &A,
-                                  VECTOR               &x,
-                                  const VECTOR         &b,
-                                  const PRECONDITIONER &precondition)
+SolverRichardson<VectorType>::Tsolve (const MATRIX         &A,
+                                      VectorType           &x,
+                                      const VectorType     &b,
+                                      const PRECONDITIONER &precondition)
 {
   SolverControl::State conv=SolverControl::iterate;
   double last_criterion = -std::numeric_limits<double>::max();
@@ -299,10 +299,10 @@ SolverRichardson<VECTOR>::Tsolve (const MATRIX         &A,
 
   // Memory allocation
   Vr  = this->memory.alloc();
-  VECTOR &r  = *Vr;
+  VectorType &r  = *Vr;
   r.reinit(x);
   Vd  =this-> memory.alloc();
-  VECTOR &d  = *Vd;
+  VectorType &d  = *Vd;
   d.reinit(x);
 
   deallog.push("RichardsonT");
@@ -349,19 +349,19 @@ SolverRichardson<VECTOR>::Tsolve (const MATRIX         &A,
 }
 
 
-template <class VECTOR>
+template <class VectorType>
 void
-SolverRichardson<VECTOR>::print_vectors(const unsigned int,
-                                        const VECTOR &,
-                                        const VECTOR &,
-                                        const VECTOR &) const
+SolverRichardson<VectorType>::print_vectors(const unsigned int,
+                                            const VectorType &,
+                                            const VectorType &,
+                                            const VectorType &) const
 {}
 
 
 
-template <class VECTOR>
-inline typename VECTOR::value_type
-SolverRichardson<VECTOR>::criterion()
+template <class VectorType>
+inline typename VectorType::value_type
+SolverRichardson<VectorType>::criterion()
 {
   if (!additional_data.use_preconditioned_residual)
     res = Vr->l2_norm();
@@ -371,9 +371,9 @@ SolverRichardson<VECTOR>::criterion()
 }
 
 
-template <class VECTOR>
+template <class VectorType>
 inline void
-SolverRichardson<VECTOR>::set_omega (const double om)
+SolverRichardson<VectorType>::set_omega (const double om)
 {
   additional_data.omega=om;
 }
index cc135cad50e957e5491154bcf4335bfe0d009807..99591e254bb8f10a8472277b1b8e1db395669064 100644 (file)
@@ -94,14 +94,14 @@ DEAL_II_NAMESPACE_OPEN
  *
  * @author Ralf Hartmann, 1999
  */
-template <class VECTOR = Vector<double> >
+template <typename VectorType = Vector<double> >
 class SolverSelector : public Subscriptor
 {
 public:
   /**
    * A typedef for the underlying vector type
    */
-  typedef VECTOR vector_type;
+  typedef VectorType vector_type;
 
   /**
    * Constructor, filling in default values
@@ -119,10 +119,10 @@ public:
    *
    */
   template<class Matrix, class Preconditioner>
-  void solve(const Matrix &A,
-             VECTOR &x,
-             const VECTOR &b,
-             const Preconditioner &precond) const;
+  void solve (const Matrix         &A,
+              VectorType           &x,
+              const VectorType     &b,
+              const Preconditioner &precond) const;
 
   /**
    * Select a new solver. Note that all solver names used in this class are
@@ -138,37 +138,37 @@ public:
   /**
    * Set the additional data. For more info see the @p Solver class.
    */
-  void set_data(const typename SolverRichardson<VECTOR>
+  void set_data(const typename SolverRichardson<VectorType>
                 ::AdditionalData &data);
 
   /**
    * Set the additional data. For more info see the @p Solver class.
    */
-  void set_data(const typename SolverCG<VECTOR>
+  void set_data(const typename SolverCG<VectorType>
                 ::AdditionalData &data);
 
   /**
    * Set the additional data. For more info see the @p Solver class.
    */
-  void set_data(const typename SolverMinRes<VECTOR>
+  void set_data(const typename SolverMinRes<VectorType>
                 ::AdditionalData &data);
 
   /**
    * Set the additional data. For more info see the @p Solver class.
    */
-  void set_data(const typename SolverBicgstab<VECTOR>
+  void set_data(const typename SolverBicgstab<VectorType>
                 ::AdditionalData &data);
 
   /**
    * Set the additional data. For more info see the @p Solver class.
    */
-  void set_data(const typename SolverGMRES<VECTOR>
+  void set_data(const typename SolverGMRES<VectorType>
                 ::AdditionalData &data);
 
   /**
    * Set the additional data. For more info see the @p Solver class.
    */
-  void set_data(const typename SolverFGMRES<VECTOR>
+  void set_data(const typename SolverFGMRES<VectorType>
                 ::AdditionalData &data);
 
   /**
@@ -190,7 +190,7 @@ protected:
    * Stores the @p SolverControl that is needed in the constructor of each @p
    * Solver class. This can be changed with @p set_control().
    */
-  SmartPointer< SolverControl, SolverSelector< VECTOR > >     control;
+  SmartPointer< SolverControl, SolverSelector< VectorType > > control;
 
   /**
    * Stores the name of the solver.
@@ -201,92 +201,92 @@ private:
   /**
    * Stores the additional data.
    */
-  typename SolverRichardson<VECTOR>::AdditionalData richardson_data;
+  typename SolverRichardson<VectorType>::AdditionalData richardson_data;
 
   /**
    * Stores the additional data.
    */
-  typename SolverCG<VECTOR>::AdditionalData cg_data;
+  typename SolverCG<VectorType>::AdditionalData cg_data;
 
   /**
    * Stores the additional data.
    */
-  typename SolverMinRes<VECTOR>::AdditionalData minres_data;
+  typename SolverMinRes<VectorType>::AdditionalData minres_data;
 
   /**
    * Stores the additional data.
    */
-  typename SolverBicgstab<VECTOR>::AdditionalData bicgstab_data;
+  typename SolverBicgstab<VectorType>::AdditionalData bicgstab_data;
 
   /**
    * Stores the additional data.
    */
-  typename SolverGMRES<VECTOR>::AdditionalData gmres_data;
+  typename SolverGMRES<VectorType>::AdditionalData gmres_data;
 
   /**
    * Stores the additional data.
    */
-  typename SolverFGMRES<VECTOR>::AdditionalData fgmres_data;
+  typename SolverFGMRES<VectorType>::AdditionalData fgmres_data;
 };
 
 /*@}*/
 /* --------------------- Inline and template functions ------------------- */
 
 
-template <class VECTOR>
-SolverSelector<VECTOR>::SolverSelector()
+template <typename VectorType>
+SolverSelector<VectorType>::SolverSelector()
 {}
 
 
-template <class VECTOR>
-SolverSelector<VECTOR>::~SolverSelector()
+template <typename VectorType>
+SolverSelector<VectorType>::~SolverSelector()
 {}
 
 
-template <class VECTOR>
+template <typename VectorType>
 void
-SolverSelector<VECTOR>::select(const std::string &name)
+SolverSelector<VectorType>::select(const std::string &name)
 {
   solver_name = name;
 }
 
 
-template <class VECTOR>
+template <typename VectorType>
 template<class Matrix, class Preconditioner>
 void
-SolverSelector<VECTOR>::solve(const Matrix &A,
-                              VECTOR &x,
-                              const VECTOR &b,
-                              const Preconditioner &precond) const
+SolverSelector<VectorType>::solve (const Matrix         &A,
+                                   VectorType           &x,
+                                   const VectorType     &b,
+                                   const Preconditioner &precond) const
 {
   if (solver_name=="richardson")
     {
-      SolverRichardson<VECTOR> solver(*control, richardson_data);
+      SolverRichardson<VectorType> solver(*control, richardson_data);
       solver.solve(A,x,b,precond);
     }
   else if (solver_name=="cg")
     {
-      SolverCG<VECTOR> solver(*control, cg_data);
+      SolverCG<VectorType> solver(*control, cg_data);
       solver.solve(A,x,b,precond);
     }
   else if (solver_name=="minres")
     {
-      SolverMinRes<VECTOR> solver(*control, minres_data);
+      SolverMinRes<VectorType> solver(*control, minres_data);
       solver.solve(A,x,b,precond);
     }
   else if (solver_name=="bicgstab")
     {
-      SolverBicgstab<VECTOR> solver(*control, bicgstab_data);
+      SolverBicgstab<VectorType> solver(*control, bicgstab_data);
       solver.solve(A,x,b,precond);
     }
   else if (solver_name=="gmres")
     {
-      SolverGMRES<VECTOR> solver(*control, gmres_data);
+      SolverGMRES<VectorType> solver(*control, gmres_data);
       solver.solve(A,x,b,precond);
     }
   else if (solver_name=="fgmres")
     {
-      SolverFGMRES<VECTOR> solver(*control, fgmres_data);
+      SolverFGMRES<VectorType> solver(*control, fgmres_data);
       solver.solve(A,x,b,precond);
     }
   else
@@ -294,64 +294,63 @@ SolverSelector<VECTOR>::solve(const Matrix &A,
 }
 
 
-template <class VECTOR>
-void SolverSelector<VECTOR>::set_control(
-  SolverControl &ctrl)
+template <typename VectorType>
+void SolverSelector<VectorType>::set_control (SolverControl &ctrl)
 {
   control=&ctrl;
 }
 
 
-template <class VECTOR>
-std::string SolverSelector<VECTOR>::get_solver_names()
+template <typename VectorType>
+std::string SolverSelector<VectorType>::get_solver_names()
 {
   return "richardson|cg|bicgstab|gmres|fgmres|minres";
 }
 
 
-template <class VECTOR>
-void SolverSelector<VECTOR>::set_data(
-  const typename SolverGMRES<VECTOR>::AdditionalData &data)
+template <typename VectorType>
+void SolverSelector<VectorType>::set_data
+(const typename SolverGMRES<VectorType>::AdditionalData &data)
 {
   gmres_data=data;
 }
 
 
-template <class VECTOR>
-void SolverSelector<VECTOR>::set_data(
-  const typename SolverFGMRES<VECTOR>::AdditionalData &data)
+template <typename VectorType>
+void SolverSelector<VectorType>::set_data
+(const typename SolverFGMRES<VectorType>::AdditionalData &data)
 {
   fgmres_data=data;
 }
 
 
-template <class VECTOR>
-void SolverSelector<VECTOR>::set_data(
-  const typename SolverRichardson<VECTOR>::AdditionalData &data)
+template <typename VectorType>
+void SolverSelector<VectorType>::set_data
+(const typename SolverRichardson<VectorType>::AdditionalData &data)
 {
   richardson_data=data;
 }
 
 
-template <class VECTOR>
-void SolverSelector<VECTOR>::set_data(
-  const typename SolverCG<VECTOR>::AdditionalData &data)
+template <typename VectorType>
+void SolverSelector<VectorType>::set_data(
+  const typename SolverCG<VectorType>::AdditionalData &data)
 {
   cg_data=data;
 }
 
 
-template <class VECTOR>
-void SolverSelector<VECTOR>::set_data(
-  const typename SolverMinRes<VECTOR>::AdditionalData &data)
+template <typename VectorType>
+void SolverSelector<VectorType>::set_data
+(const typename SolverMinRes<VectorType>::AdditionalData &data)
 {
   minres_data=data;
 }
 
 
-template <class VECTOR>
-void SolverSelector<VECTOR>::set_data(
-  const typename SolverBicgstab<VECTOR>::AdditionalData &data)
+template <typename VectorType>
+void SolverSelector<VectorType>::set_data
+(const typename SolverBicgstab<VectorType>::AdditionalData &data)
 {
   bicgstab_data=data;
 }
index 78dca4534091e3a716ec64ac7d4af9a2e27cbf35..85473dbd7e6607ebd2ea4e7d550fa45dc55583b2 100644 (file)
@@ -67,7 +67,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * @author Guido Kanschat, 1998-2003
  */
-template<class VECTOR = dealii::Vector<double> >
+template<typename VectorType = dealii::Vector<double> >
 class VectorMemory : public Subscriptor
 {
 public:
@@ -84,13 +84,13 @@ public:
    * function should reset vectors to their proper size. The same holds for
    * the contents of vectors: they are unspecified.
    */
-  virtual VECTOR *alloc () = 0;
+  virtual VectorType *alloc () = 0;
 
   /**
    * Return a vector and indicate that it is not going to be used any further
    * by the instance that called alloc() to get a pointer to it.
    */
-  virtual void free (const VECTOR *const) = 0;
+  virtual void free (const VectorType *const) = 0;
 
   /**
    * @addtogroup Exceptions
@@ -121,7 +121,7 @@ public:
     /**
      * Constructor, automatically allocating a vector from @p mem.
      */
-    Pointer(VectorMemory<VECTOR> &mem);
+    Pointer(VectorMemory<VectorType> &mem);
     /**
      * Destructor, automatically releasing the vector from the memory #pool.
      */
@@ -130,26 +130,26 @@ public:
     /**
      * Conversion to regular pointer.
      */
-    operator VECTOR *() const;
+    operator VectorType *() const;
 
     /**
      * Dereferencing operator.
      */
-    VECTOR &operator * () const;
+    VectorType &operator * () const;
 
     /**
      * Dereferencing operator.
      */
-    VECTOR *operator -> () const;
+    VectorType *operator -> () const;
   private:
     /**
      * The memory pool used.
      */
-    SmartPointer<VectorMemory<VECTOR>,Pointer> pool;
+    SmartPointer<VectorMemory<VectorType>,Pointer> pool;
     /**
      * The pointer to the vector.
      */
-    VECTOR *v;
+    VectorType *v;
   };
 };
 
@@ -162,8 +162,8 @@ public:
  * This class allocates and deletes vectors as needed from the global heap,
  * i.e. performs no specially adapted actions for memory management.
  */
-template<class VECTOR = dealii::Vector<double> >
-class PrimitiveVectorMemory : public VectorMemory<VECTOR>
+template<typename VectorType = dealii::Vector<double> >
+class PrimitiveVectorMemory : public VectorMemory<VectorType>
 {
 public:
   /**
@@ -180,9 +180,9 @@ public:
    * For the present class, calling this function will allocate a new vector
    * on the heap and returning a pointer to it.
    */
-  virtual VECTOR *alloc ()
+  virtual VectorType *alloc ()
   {
-    return new VECTOR();
+    return new VectorType();
   }
 
   /**
@@ -193,7 +193,7 @@ public:
    * For the present class, this means that the vector is returned to the
    * global heap.
    */
-  virtual void free (const VECTOR *const v)
+  virtual void free (const VectorType *const v)
   {
     delete v;
   }
@@ -225,8 +225,8 @@ public:
  *
  * @author Guido Kanschat, 1999, 2007
  */
-template<class VECTOR = dealii::Vector<double> >
-class GrowingVectorMemory : public VectorMemory<VECTOR>
+template<typename VectorType = dealii::Vector<double> >
+class GrowingVectorMemory : public VectorMemory<VectorType>
 {
 public:
   /**
@@ -256,7 +256,7 @@ public:
    * function should reset vectors to their proper size. The same holds for
    * the contents of vectors: they are unspecified.
    */
-  virtual VECTOR *alloc ();
+  virtual VectorType *alloc ();
 
   /**
    * Return a vector and indicate that it is not going to be used any further
@@ -265,7 +265,7 @@ public:
    * For the present class, this means retaining the vector for later reuse by
    * the alloc() method.
    */
-  virtual void free (const VECTOR *const);
+  virtual void free (const VectorType *const);
 
   /**
    * Release all vectors that are not currently in use.
@@ -282,7 +282,7 @@ private:
    * Type to enter into the array. First component will be a flag telling
    * whether the vector is used, second the vector itself.
    */
-  typedef std::pair<bool, VECTOR *> entry_type;
+  typedef std::pair<bool, VectorType *> entry_type;
 
   /**
    * The class providing the actual storage for the memory pool.
@@ -347,9 +347,9 @@ private:
 /* --------------------- inline functions ---------------------- */
 
 
-template <typename VECTOR>
+template <typename VectorType>
 inline
-VectorMemory<VECTOR>::Pointer::Pointer(VectorMemory<VECTOR> &mem)
+VectorMemory<VectorType>::Pointer::Pointer(VectorMemory<VectorType> &mem)
   :
   pool(&mem, typeid(*this).name()), v(0)
 {
@@ -357,33 +357,33 @@ VectorMemory<VECTOR>::Pointer::Pointer(VectorMemory<VECTOR> &mem)
 }
 
 
-template <typename VECTOR>
+template <typename VectorType>
 inline
-VectorMemory<VECTOR>::Pointer::~Pointer()
+VectorMemory<VectorType>::Pointer::~Pointer()
 {
   pool->free(v);
 }
 
 
-template <typename VECTOR>
+template <typename VectorType>
 inline
-VectorMemory<VECTOR>::Pointer::operator VECTOR *() const
+VectorMemory<VectorType>::Pointer::operator VectorType *() const
 {
   return v;
 }
 
 
-template <typename VECTOR>
+template <typename VectorType>
 inline
-VECTOR &VectorMemory<VECTOR>::Pointer::operator * () const
+VectorType &VectorMemory<VectorType>::Pointer::operator * () const
 {
   return *v;
 }
 
 
-template <typename VECTOR>
+template <typename VectorType>
 inline
-VECTOR *VectorMemory<VECTOR>::Pointer::operator -> () const
+VectorType *VectorMemory<VectorType>::Pointer::operator -> () const
 {
   return v;
 }
index 54e8a21c8d0438333170f954fcf7e7fadab5daa3..9d1e78e04e84e0f8ebc61951e9ec61404039d0f3 100644 (file)
@@ -103,7 +103,7 @@ namespace MeshWorker
      * @ingroup MeshWorker
      * @author Guido Kanschat, 2009
      */
-    template <class VECTOR>
+    template <typename VectorType>
     class ResidualLocalBlocksToGlobalBlocks
     {
     public:
@@ -143,8 +143,8 @@ namespace MeshWorker
       /**
        * Assemble a single local residual into the global.
        */
-      void assemble(VECTOR &global,
-                    const BlockVector<double> &local,
+      void assemble(VectorType                                 &global,
+                    const BlockVector<double>                  &local,
                     const std::vector<types::global_dof_index> &dof);
 
       /**
@@ -156,12 +156,12 @@ namespace MeshWorker
        * A pointer to the object containing the block structure.
        */
       SmartPointer<const BlockInfo,
-                   ResidualLocalBlocksToGlobalBlocks<VECTOR> > block_info;
+                   ResidualLocalBlocksToGlobalBlocks<VectorType> > block_info;
       /**
        * A pointer to the object containing constraints.
        */
       SmartPointer<const ConstraintMatrix,
-                   ResidualLocalBlocksToGlobalBlocks<VECTOR> > constraints;
+                   ResidualLocalBlocksToGlobalBlocks<VectorType> > constraints;
     };
 
 
@@ -493,39 +493,39 @@ namespace MeshWorker
 
 //----------------------------------------------------------------------//
 
-    template <class VECTOR>
+    template <typename VectorType>
     inline void
-    ResidualLocalBlocksToGlobalBlocks<VECTOR>::initialize(const BlockInfo *b,
-                                                          AnyData &m)
+    ResidualLocalBlocksToGlobalBlocks<VectorType>::initialize(const BlockInfo *b,
+                                                              AnyData         &m)
     {
       block_info = b;
       residuals = m;
     }
 
-    template <class VECTOR>
+    template <typename VectorType>
     inline void
-    ResidualLocalBlocksToGlobalBlocks<VECTOR>::initialize(
-      const ConstraintMatrix &c)
+    ResidualLocalBlocksToGlobalBlocks<VectorType>::initialize
+    (const ConstraintMatrix &c)
     {
       constraints = &c;
     }
 
 
-    template <class VECTOR>
+    template <typename VectorType>
     template <class DOFINFO>
     inline void
-    ResidualLocalBlocksToGlobalBlocks<VECTOR>::initialize_info(
-      DOFINFO &info, bool) const
+    ResidualLocalBlocksToGlobalBlocks<VectorType>::initialize_info
+    (DOFINFO &info, bool) const
     {
       info.initialize_vectors(residuals.size());
     }
 
-    template <class VECTOR>
+    template <typename VectorType>
     inline void
-    ResidualLocalBlocksToGlobalBlocks<VECTOR>::assemble(
-      VECTOR &global,
-      const BlockVector<double> &local,
-      const std::vector<types::global_dof_index> &dof)
+    ResidualLocalBlocksToGlobalBlocks<VectorType>::assemble
+    (VectorType                                 &global,
+     const BlockVector<double>                  &local,
+     const std::vector<types::global_dof_index> &dof)
     {
       if (constraints == 0)
         {
@@ -549,23 +549,23 @@ namespace MeshWorker
     }
 
 
-    template <class VECTOR>
+    template <typename VectorType>
     template <class DOFINFO>
     inline void
-    ResidualLocalBlocksToGlobalBlocks<VECTOR>::assemble(
-      const DOFINFO &info)
+    ResidualLocalBlocksToGlobalBlocks<VectorType>::assemble
+    (const DOFINFO &info)
     {
       for (unsigned int i=0; i<residuals.size(); ++i)
         assemble(*residuals(i), info.vector(i), info.indices);
     }
 
 
-    template <class VECTOR>
+    template <typename VectorType>
     template <class DOFINFO>
     inline void
-    ResidualLocalBlocksToGlobalBlocks<VECTOR>::assemble(
-      const DOFINFO &info1,
-      const DOFINFO &info2)
+    ResidualLocalBlocksToGlobalBlocks<VectorType>::assemble
+    (const DOFINFO &info1,
+     const DOFINFO &info2)
     {
       for (unsigned int i=0; i<residuals.size(); ++i)
         {
index 615b22b15801fde758242bd3e3271d83cc2b4993..c516b06570848955a62b93fe7e8a7990c1b830d9 100644 (file)
@@ -36,7 +36,7 @@ namespace MeshWorker
    * Objects of this class contain one or more objects of type FEValues,
    * FEFaceValues or FESubfaceValues to be used in local integration. They are
    * stored in an array of pointers to the base classes FEValuesBase. The
-   * template parameter VECTOR allows the use of different data types for the
+   * template parameter VectorType allows the use of different data types for the
    * global system.
    *
    * Additionally, this function contains space to store the values of finite
@@ -310,12 +310,12 @@ namespace MeshWorker
      * and also set uninitialized quadrature rules to Gauss formulas, which
      * integrate polynomial bilinear forms exactly.
      */
-    template <typename VECTOR>
+    template <typename VectorType>
     void initialize(const FiniteElement<dim, spacedim> &el,
-                    const Mapping<dim, spacedim> &mapping,
-                    const AnyData &data,
-                    const VECTOR &dummy,
-                    const BlockInfo *block_info = 0);
+                    const Mapping<dim, spacedim>       &mapping,
+                    const AnyData                      &data,
+                    const VectorType                   &dummy,
+                    const BlockInfo                    *block_info = 0);
     /**
      * Initialize the IntegrationInfo objects contained.
      *
@@ -323,12 +323,12 @@ namespace MeshWorker
      * and also set uninitialized quadrature rules to Gauss formulas, which
      * integrate polynomial bilinear forms exactly.
      */
-    template <typename VECTOR>
+    template <typename VectorType>
     void initialize(const FiniteElement<dim, spacedim> &el,
-                    const Mapping<dim, spacedim> &mapping,
-                    const AnyData &data,
-                    const MGLevelObject<VECTOR> &dummy,
-                    const BlockInfo *block_info = 0);
+                    const Mapping<dim, spacedim>       &mapping,
+                    const AnyData                      &data,
+                    const MGLevelObject<VectorType>    &dummy,
+                    const BlockInfo                    *block_info = 0);
     /**
      * @name FEValues setup
      */
@@ -773,20 +773,20 @@ namespace MeshWorker
 
 
   template <int dim, int sdim>
-  template <typename VECTOR>
+  template <typename VectorType>
   void
-  IntegrationInfoBox<dim,sdim>::initialize(
-    const FiniteElement<dim,sdim> &el,
-    const Mapping<dim,sdim> &mapping,
-    const AnyData &data,
-    const VECTOR &,
-    const BlockInfo *block_info)
+  IntegrationInfoBox<dim,sdim>::initialize
+  (const FiniteElement<dim,sdim> &el,
+   const Mapping<dim,sdim>       &mapping,
+   const AnyData                 &data,
+   const VectorType              &,
+   const BlockInfo               *block_info)
   {
     initialize(el, mapping, block_info);
-    std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> > p;
+    std_cxx11::shared_ptr<VectorData<VectorType, dim, sdim> > p;
     VectorDataBase<dim,sdim> *pp;
 
-    p = std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (cell_selector));
+    p = std_cxx11::shared_ptr<VectorData<VectorType, dim, sdim> >(new VectorData<VectorType, dim, sdim> (cell_selector));
     // Public member function of parent class was not found without
     // explicit cast
     pp = &*p;
@@ -794,13 +794,13 @@ namespace MeshWorker
     cell_data = p;
     cell.initialize_data(p);
 
-    p = std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (boundary_selector));
+    p = std_cxx11::shared_ptr<VectorData<VectorType, dim, sdim> >(new VectorData<VectorType, dim, sdim> (boundary_selector));
     pp = &*p;
     pp->initialize(data);
     boundary_data = p;
     boundary.initialize_data(p);
 
-    p = std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (face_selector));
+    p = std_cxx11::shared_ptr<VectorData<VectorType, dim, sdim> >(new VectorData<VectorType, dim, sdim> (face_selector));
     pp = &*p;
     pp->initialize(data);
     face_data = p;
@@ -810,20 +810,20 @@ namespace MeshWorker
   }
 
   template <int dim, int sdim>
-  template <typename VECTOR>
+  template <typename VectorType>
   void
-  IntegrationInfoBox<dim,sdim>::initialize(
-    const FiniteElement<dim,sdim> &el,
-    const Mapping<dim,sdim> &mapping,
-    const AnyData &data,
-    const MGLevelObject<VECTOR> &,
-    const BlockInfo *block_info)
+  IntegrationInfoBox<dim,sdim>::initialize
+  (const FiniteElement<dim,sdim>   &el,
+   const Mapping<dim,sdim>         &mapping,
+   const AnyData                   &data,
+   const MGLevelObject<VectorType> &,
+   const BlockInfo                 *block_info)
   {
     initialize(el, mapping, block_info);
-    std_cxx11::shared_ptr<MGVectorData<VECTOR, dim, sdim> > p;
+    std_cxx11::shared_ptr<MGVectorData<VectorType, dim, sdim> > p;
     VectorDataBase<dim,sdim> *pp;
 
-    p = std_cxx11::shared_ptr<MGVectorData<VECTOR, dim, sdim> >(new MGVectorData<VECTOR, dim, sdim> (cell_selector));
+    p = std_cxx11::shared_ptr<MGVectorData<VectorType, dim, sdim> >(new MGVectorData<VectorType, dim, sdim> (cell_selector));
     // Public member function of parent class was not found without
     // explicit cast
     pp = &*p;
@@ -831,13 +831,13 @@ namespace MeshWorker
     cell_data = p;
     cell.initialize_data(p);
 
-    p = std_cxx11::shared_ptr<MGVectorData<VECTOR, dim, sdim> >(new MGVectorData<VECTOR, dim, sdim> (boundary_selector));
+    p = std_cxx11::shared_ptr<MGVectorData<VectorType, dim, sdim> >(new MGVectorData<VectorType, dim, sdim> (boundary_selector));
     pp = &*p;
     pp->initialize(data);
     boundary_data = p;
     boundary.initialize_data(p);
 
-    p = std_cxx11::shared_ptr<MGVectorData<VECTOR, dim, sdim> >(new MGVectorData<VECTOR, dim, sdim> (face_selector));
+    p = std_cxx11::shared_ptr<MGVectorData<VectorType, dim, sdim> >(new MGVectorData<VectorType, dim, sdim> (face_selector));
     pp = &*p;
     pp->initialize(data);
     face_data = p;
index e4ceda1cb9ee53f90e55bdf031afad243830edb6..58e6a039c285d2e5d91376dae3efa9ddc9cf00bd 100644 (file)
@@ -50,7 +50,7 @@ namespace MeshWorker
      * @ingroup MeshWorker
      * @author Guido Kanschat, 2009
      */
-    template <class VECTOR>
+    template <typename VectorType>
     class ResidualSimple
     {
     public:
@@ -115,7 +115,7 @@ namespace MeshWorker
       /**
        * A pointer to the object containing constraints.
        */
-      SmartPointer<const ConstraintMatrix,ResidualSimple<VECTOR> > constraints;
+      SmartPointer<const ConstraintMatrix,ResidualSimple<VectorType> > constraints;
     };
 
 
@@ -409,10 +409,10 @@ namespace MeshWorker
      * @ingroup MeshWorker
      * @author Guido Kanschat, 2009
      */
-    template <class MATRIX, class VECTOR>
+    template <class MATRIX, typename VectorType>
     class SystemSimple :
       private MatrixSimple<MATRIX>,
-      private ResidualSimple<VECTOR>
+      private ResidualSimple<VectorType>
     {
     public:
       /**
@@ -423,7 +423,7 @@ namespace MeshWorker
       /**
        * Store the two objects data is assembled into.
        */
-      void initialize(MATRIX &m, VECTOR &rhs);
+      void initialize(MATRIX &m, VectorType &rhs);
 
       /**
        * Initialize the constraints. After this function has been called with
@@ -462,16 +462,16 @@ namespace MeshWorker
 
 //----------------------------------------------------------------------//
 
-    template <class VECTOR>
+    template <typename VectorType>
     inline void
-    ResidualSimple<VECTOR>::initialize(AnyData &results)
+    ResidualSimple<VectorType>::initialize(AnyData &results)
     {
       residuals = results;
     }
 
-    template <class VECTOR>
+    template <typename VectorType>
     inline void
-    ResidualSimple<VECTOR>::initialize(const ConstraintMatrix &c)
+    ResidualSimple<VectorType>::initialize(const ConstraintMatrix &c)
     {
       constraints = &c;
     }
@@ -483,23 +483,23 @@ namespace MeshWorker
     {}
 
 
-    template <class VECTOR>
+    template <typename VectorType>
     template <class DOFINFO>
     inline void
-    ResidualSimple<VECTOR>::initialize_info(DOFINFO &info, bool) const
+    ResidualSimple<VectorType>::initialize_info(DOFINFO &info, bool) const
     {
       info.initialize_vectors(residuals.size());
     }
 
 
-    template <class VECTOR>
+    template <typename VectorType>
     template <class DOFINFO>
     inline void
-    ResidualSimple<VECTOR>::assemble(const DOFINFO &info)
+    ResidualSimple<VectorType>::assemble(const DOFINFO &info)
     {
       for (unsigned int k=0; k<residuals.size(); ++k)
         {
-          VECTOR *v = residuals.entry<VECTOR *>(k);
+          VectorType *v = residuals.entry<VectorType *>(k);
           if (constraints == 0)
             {
               for (unsigned int i=0; i<info.vector(k).block(0).size(); ++i)
@@ -516,15 +516,15 @@ namespace MeshWorker
         }
     }
 
-    template <class VECTOR>
+    template <typename VectorType>
     template <class DOFINFO>
     inline void
-    ResidualSimple<VECTOR>::assemble(const DOFINFO &info1,
-                                     const DOFINFO &info2)
+    ResidualSimple<VectorType>::assemble(const DOFINFO &info1,
+                                         const DOFINFO &info2)
     {
       for (unsigned int k=0; k<residuals.size(); ++k)
         {
-          VECTOR *v = residuals.entry<VECTOR *>(k);
+          VectorType *v = residuals.entry<VectorType *>(k);
           if (constraints == 0)
             {
               for (unsigned int i=0; i<info1.vector(k).block(0).size(); ++i)
@@ -1097,63 +1097,63 @@ namespace MeshWorker
 
 //----------------------------------------------------------------------//
 
-    template <class MATRIX, class VECTOR>
-    SystemSimple<MATRIX,VECTOR>::SystemSimple(double t)
+    template <class MATRIX, typename VectorType>
+    SystemSimple<MATRIX,VectorType>::SystemSimple(double t)
       :
       MatrixSimple<MATRIX>(t)
     {}
 
 
-    template <class MATRIX, class VECTOR>
+    template <class MATRIX, typename VectorType>
     inline void
-    SystemSimple<MATRIX,VECTOR>::initialize(MATRIX &m, VECTOR &rhs)
+    SystemSimple<MATRIX,VectorType>::initialize(MATRIX &m, VectorType &rhs)
     {
       AnyData data;
-      VECTOR *p = &rhs;
+      VectorType *p = &rhs;
       data.add(p, "right hand side");
 
       MatrixSimple<MATRIX>::initialize(m);
-      ResidualSimple<VECTOR>::initialize(data);
+      ResidualSimple<VectorType>::initialize(data);
     }
 
-    template <class MATRIX, class VECTOR>
+    template <class MATRIX, typename VectorType>
     inline void
-    SystemSimple<MATRIX,VECTOR>::initialize(const ConstraintMatrix &c)
+    SystemSimple<MATRIX,VectorType>::initialize(const ConstraintMatrix &c)
     {
       MatrixSimple<MATRIX>::initialize(c);
-      ResidualSimple<VECTOR>::initialize(c);
+      ResidualSimple<VectorType>::initialize(c);
     }
 
 
-    template <class MATRIX, class VECTOR>
+    template <class MATRIX, typename VectorType>
     template <class DOFINFO>
     inline void
-    SystemSimple<MATRIX,VECTOR>::initialize_info(DOFINFO &info,
-                                                 bool face) const
+    SystemSimple<MATRIX,VectorType>::initialize_info(DOFINFO &info,
+                                                     bool    face) const
     {
       MatrixSimple<MATRIX>::initialize_info(info, face);
-      ResidualSimple<VECTOR>::initialize_info(info, face);
+      ResidualSimple<VectorType>::initialize_info(info, face);
     }
 
 
-    template <class MATRIX, class VECTOR>
+    template <class MATRIX, typename VectorType>
     template <class DOFINFO>
     inline void
-    SystemSimple<MATRIX,VECTOR>::assemble(const DOFINFO &info)
+    SystemSimple<MATRIX,VectorType>::assemble(const DOFINFO &info)
     {
       MatrixSimple<MATRIX>::assemble(info);
-      ResidualSimple<VECTOR>::assemble(info);
+      ResidualSimple<VectorType>::assemble(info);
     }
 
 
-    template <class MATRIX, class VECTOR>
+    template <class MATRIX, typename VectorType>
     template <class DOFINFO>
     inline void
-    SystemSimple<MATRIX,VECTOR>::assemble(const DOFINFO &info1,
-                                          const DOFINFO &info2)
+    SystemSimple<MATRIX,VectorType>::assemble(const DOFINFO &info1,
+                                              const DOFINFO &info2)
     {
       MatrixSimple<MATRIX>::assemble(info1, info2);
-      ResidualSimple<VECTOR>::assemble(info1, info2);
+      ResidualSimple<VectorType>::assemble(info1, info2);
     }
   }
 }
index 5a4928ec5088e8c7581e06daa0ec99d002742cfd..f4ba7ff549978360265ae3081c959ea6081f8028 100644 (file)
@@ -285,9 +285,9 @@ namespace MeshWorker
    * @ingroup MeshWorker
    * @author Guido Kanschat, 2009
    */
-  template <class VECTOR, int dim, int spacedim = dim>
+  template <typename VectorType, int dim, int spacedim = dim>
   class VectorData :
-    public VectorDataBase<dim, spacedim,typename VECTOR::value_type>
+    public VectorDataBase<dim, spacedim,typename VectorType::value_type>
   {
   public:
     /**
@@ -311,12 +311,12 @@ namespace MeshWorker
      * @note Make sure the VectorSelector base class was filled with
      * reasonable data before calling this function.
      */
-    void initialize(const VECTOR *, const std::string &name);
+    void initialize(const VectorType *, const std::string &name);
 
     virtual void fill(
-      std::vector<std::vector<std::vector<typename VECTOR::value_type> > > &values,
-      std::vector<std::vector<std::vector<Tensor<1,dim,typename VECTOR::value_type> > > > &gradients,
-      std::vector<std::vector<std::vector<Tensor<2,dim,typename VECTOR::value_type> > > > &hessians,
+      std::vector<std::vector<std::vector<typename VectorType::value_type> > > &values,
+      std::vector<std::vector<std::vector<Tensor<1,dim,typename VectorType::value_type> > > > &gradients,
+      std::vector<std::vector<std::vector<Tensor<2,dim,typename VectorType::value_type> > > > &hessians,
       const FEValuesBase<dim,spacedim> &fe,
       const std::vector<types::global_dof_index> &index,
       const unsigned int component,
@@ -325,9 +325,9 @@ namespace MeshWorker
       const unsigned int size) const;
 
     virtual void mg_fill(
-      std::vector<std::vector<std::vector<typename VECTOR::value_type> > > &values,
-      std::vector<std::vector<std::vector<Tensor<1,dim,typename VECTOR::value_type> > > > &gradients,
-      std::vector<std::vector<std::vector<Tensor<2,dim,typename VECTOR::value_type> > > > &hessians,
+      std::vector<std::vector<std::vector<typename VectorType::value_type> > > &values,
+      std::vector<std::vector<std::vector<Tensor<1,dim,typename VectorType::value_type> > > > &gradients,
+      std::vector<std::vector<std::vector<Tensor<2,dim,typename VectorType::value_type> > > > &hessians,
       const FEValuesBase<dim,spacedim> &fe,
       const unsigned int level,
       const std::vector<types::global_dof_index> &index,
@@ -351,9 +351,9 @@ namespace MeshWorker
    * @ingroup MeshWorker
    * @author Guido Kanschat, 2010
    */
-  template <class VECTOR, int dim, int spacedim = dim>
+  template <typename VectorType, int dim, int spacedim = dim>
   class MGVectorData :
-    public VectorData<VECTOR, dim, spacedim>
+    public VectorData<VectorType, dim, spacedim>
   {
   public:
     /**
@@ -378,7 +378,7 @@ namespace MeshWorker
      * @note Make sure the VectorSelector base class was filled with
      * reasonable data before calling this function.
      */
-    void initialize(const MGLevelObject<VECTOR> *, const std::string &name);
+    void initialize(const MGLevelObject<VectorType> *, const std::string &name);
 
 
     /**
index b3fed888c16a322b37d43b40a3469d41728fa690..805bced4937844d58aac8058c8048b44d01aa969 100644 (file)
@@ -85,43 +85,43 @@ namespace MeshWorker
 
 //----------------------------------------------------------------------//
 
-  template <class VECTOR, int dim, int spacedim>
-  VectorData<VECTOR, dim, spacedim>::VectorData()
+  template <typename VectorType, int dim, int spacedim>
+  VectorData<VectorType, dim, spacedim>::VectorData()
   {}
 
 
-  template <class VECTOR, int dim, int spacedim>
-  VectorData<VECTOR, dim, spacedim>::VectorData(const VectorSelector &s)
+  template <typename VectorType, int dim, int spacedim>
+  VectorData<VectorType, dim, spacedim>::VectorData(const VectorSelector &s)
     :
-    VectorDataBase<dim, spacedim, typename VECTOR::value_type>(s)
+    VectorDataBase<dim, spacedim, typename VectorType::value_type>(s)
   {}
 
 
-  template <class VECTOR, int dim, int spacedim>
+  template <typename VectorType, int dim, int spacedim>
   void
-  VectorData<VECTOR, dim, spacedim>::initialize(const AnyData &d)
+  VectorData<VectorType, dim, spacedim>::initialize(const AnyData &d)
   {
     this->data = d;
     VectorSelector::initialize(d);
   }
 
 
-  template <class VECTOR, int dim, int spacedim>
+  template <typename VectorType, int dim, int spacedim>
   void
-  VectorData<VECTOR, dim, spacedim>::initialize(const VECTOR *v, const std::string &name)
+  VectorData<VectorType, dim, spacedim>::initialize(const VectorType *v, const std::string &name)
   {
-    SmartPointer<const VECTOR,VectorData<VECTOR, dim, spacedim> > p = v;
+    SmartPointer<const VectorType,VectorData<VectorType, dim, spacedim> > p = v;
     this->data.add(p, name);
     VectorSelector::initialize(this->data);
   }
 
 
-  template <class VECTOR, int dim, int spacedim>
+  template <typename VectorType, int dim, int spacedim>
   void
-  VectorData<VECTOR, dim, spacedim>::fill(
-    std::vector<std::vector<std::vector<typename VECTOR::value_type> > > &values,
-    std::vector<std::vector<std::vector<Tensor<1,dim,typename VECTOR::value_type> > > > &gradients,
-    std::vector<std::vector<std::vector<Tensor<2,dim,typename VECTOR::value_type> > > > &hessians,
+  VectorData<VectorType, dim, spacedim>::fill(
+    std::vector<std::vector<std::vector<typename VectorType::value_type> > > &values,
+    std::vector<std::vector<std::vector<Tensor<1,dim,typename VectorType::value_type> > > > &gradients,
+    std::vector<std::vector<std::vector<Tensor<2,dim,typename VectorType::value_type> > > > &hessians,
     const FEValuesBase<dim,spacedim> &fe,
     const std::vector<types::global_dof_index> &index,
     const unsigned int component,
@@ -136,30 +136,30 @@ namespace MeshWorker
     const AnyData &data = this->data;
     for (unsigned int i=0; i<this->n_values(); ++i)
       {
-        const VECTOR *src = data.read_ptr<VECTOR>(this->value_index(i));
-        VectorSlice<std::vector<std::vector<typename VECTOR::value_type> > > dst(values[i], component, n_comp);
+        const VectorType *src = data.read_ptr<VectorType>(this->value_index(i));
+        VectorSlice<std::vector<std::vector<typename VectorType::value_type> > > dst(values[i], component, n_comp);
         fe.get_function_values(*src, make_slice(index, start, size), dst, true);
       }
 
     for (unsigned int i=0; i<this->n_gradients(); ++i)
       {
-        const VECTOR *src = data.read_ptr<VECTOR>(this->gradient_index(i));
-        VectorSlice<std::vector<std::vector<Tensor<1,dim,typename VECTOR::value_type> > > > dst(gradients[i], component, n_comp);
+        const VectorType *src = data.read_ptr<VectorType>(this->gradient_index(i));
+        VectorSlice<std::vector<std::vector<Tensor<1,dim,typename VectorType::value_type> > > > dst(gradients[i], component, n_comp);
         fe.get_function_gradients(*src, make_slice(index, start, size), dst, true);
       }
 
     for (unsigned int i=0; i<this->n_hessians(); ++i)
       {
-        const VECTOR *src = data.read_ptr<VECTOR>(this->hessian_index(i));
-        VectorSlice<std::vector<std::vector<Tensor<2,dim,typename VECTOR::value_type> > > > dst(hessians[i], component, n_comp);
+        const VectorType *src = data.read_ptr<VectorType>(this->hessian_index(i));
+        VectorSlice<std::vector<std::vector<Tensor<2,dim,typename VectorType::value_type> > > > dst(hessians[i], component, n_comp);
         fe.get_function_hessians(*src, make_slice(index, start, size), dst, true);
       }
   }
 
 
-  template <class VECTOR, int dim, int spacedim>
+  template <typename VectorType, int dim, int spacedim>
   std::size_t
-  VectorData<VECTOR, dim, spacedim>::memory_consumption () const
+  VectorData<VectorType, dim, spacedim>::memory_consumption () const
   {
     std::size_t mem = VectorSelector::memory_consumption();
     mem += sizeof (this->data);
@@ -168,51 +168,52 @@ namespace MeshWorker
 
 //----------------------------------------------------------------------//
 
-  template <class VECTOR, int dim, int spacedim>
-  MGVectorData<VECTOR, dim, spacedim>::MGVectorData()
+  template <typename VectorType, int dim, int spacedim>
+  MGVectorData<VectorType, dim, spacedim>::MGVectorData()
   {}
 
 
-  template <class VECTOR, int dim, int spacedim>
-  MGVectorData<VECTOR, dim, spacedim>::MGVectorData(const VectorSelector &s)
+  template <typename VectorType, int dim, int spacedim>
+  MGVectorData<VectorType, dim, spacedim>::MGVectorData(const VectorSelector &s)
     :
-    VectorData<VECTOR, dim, spacedim>(s)
+    VectorData<VectorType, dim, spacedim>(s)
   {}
 
 
-  template <class VECTOR, int dim, int spacedim>
+  template <typename VectorType, int dim, int spacedim>
   void
-  MGVectorData<VECTOR, dim, spacedim>::initialize(const AnyData &d)
+  MGVectorData<VectorType, dim, spacedim>::initialize(const AnyData &d)
   {
     this->data = d;
     VectorSelector::initialize(d);
   }
 
 
-  template <class VECTOR, int dim, int spacedim>
+  template <typename VectorType, int dim, int spacedim>
   void
-  MGVectorData<VECTOR, dim, spacedim>::initialize(const MGLevelObject<VECTOR> *v, const std::string &name)
+  MGVectorData<VectorType, dim, spacedim>::initialize(const MGLevelObject<VectorType> *v, const std::string &name)
   {
-    SmartPointer<const MGLevelObject<VECTOR>, MGVectorData<VECTOR, dim, spacedim> >
+    SmartPointer<const MGLevelObject<VectorType>, MGVectorData<VectorType, dim, spacedim> >
     p = v;
     this->data.add(p, name);
     VectorSelector::initialize(this->data);
   }
 
 
-  template <class VECTOR, int dim, int spacedim>
+  template <typename VectorType, int dim, int spacedim>
   void
-  VectorData<VECTOR, dim, spacedim>::mg_fill(
-    std::vector<std::vector<std::vector<typename VECTOR::value_type> > > &values,
-    std::vector<std::vector<std::vector<Tensor<1,dim,typename VECTOR::value_type> > > > &gradients,
-    std::vector<std::vector<std::vector<Tensor<2,dim,typename VECTOR::value_type> > > > &hessians,
-    const FEValuesBase<dim,spacedim> &fe,
-    const unsigned int level,
-    const std::vector<types::global_dof_index> &index,
-    const unsigned int component,
-    const unsigned int n_comp,
-    const unsigned int start,
-    const unsigned int size) const
+  VectorData<VectorType, dim, spacedim>::mg_fill
+  (std::vector<std::vector<std::vector<typename VectorType::value_type> > >                &values,
+   std::vector<std::vector<std::vector<Tensor<1,dim,typename VectorType::value_type> > > > &gradients,
+   std::vector<std::vector<std::vector<Tensor<2,dim,typename VectorType::value_type> > > > &hessians,
+   const FEValuesBase<dim,spacedim>           &fe,
+   const unsigned int                         level,
+   const std::vector<types::global_dof_index> &index,
+   const unsigned int                         component,
+   const unsigned int                         n_comp,
+   const unsigned int                         start,
+   const unsigned int                         size)
+  const
   {
     AssertDimension(values.size(), this->n_values());
     AssertDimension(gradients.size(), this->n_gradients());
@@ -221,22 +222,22 @@ namespace MeshWorker
     const AnyData &data = this->data;
     for (unsigned int i=0; i<this->n_values(); ++i)
       {
-        const MGLevelObject<VECTOR> *src = data.read_ptr<MGLevelObject<VECTOR> >(this->value_index(i));
-        VectorSlice<std::vector<std::vector<typename VECTOR::value_type> > > dst(values[i], component, n_comp);
+        const MGLevelObject<VectorType> *src = data.read_ptr<MGLevelObject<VectorType> >(this->value_index(i));
+        VectorSlice<std::vector<std::vector<typename VectorType::value_type> > > dst(values[i], component, n_comp);
         fe.get_function_values((*src)[level], make_slice(index, start, size), dst, true);
       }
 
     for (unsigned int i=0; i<this->n_gradients(); ++i)
       {
-        const MGLevelObject<VECTOR> *src = data.read_ptr<MGLevelObject<VECTOR> >(this->value_index(i));
-        VectorSlice<std::vector<std::vector<Tensor<1,dim,typename VECTOR::value_type> > > > dst(gradients[i], component, n_comp);
+        const MGLevelObject<VectorType> *src = data.read_ptr<MGLevelObject<VectorType> >(this->value_index(i));
+        VectorSlice<std::vector<std::vector<Tensor<1,dim,typename VectorType::value_type> > > > dst(gradients[i], component, n_comp);
         fe.get_function_gradients((*src)[level], make_slice(index, start, size), dst, true);
       }
 
     for (unsigned int i=0; i<this->n_hessians(); ++i)
       {
-        const MGLevelObject<VECTOR> *src = data.read_ptr<MGLevelObject<VECTOR> >(this->value_index(i));
-        VectorSlice<std::vector<std::vector<Tensor<2,dim,typename VECTOR::value_type> > > > dst(hessians[i], component, n_comp);
+        const MGLevelObject<VectorType> *src = data.read_ptr<MGLevelObject<VectorType> >(this->value_index(i));
+        VectorSlice<std::vector<std::vector<Tensor<2,dim,typename VectorType::value_type> > > > dst(hessians[i], component, n_comp);
         fe.get_function_hessians((*src)[level], make_slice(index, start, size), dst, true);
       }
   }
index 8d20f15ac45b7996cb853e521749bb721d252828..df0c9d31a971593098a916daeb737ba76c720cf7 100644 (file)
@@ -330,7 +330,7 @@ private:
    */
   unsigned int debug;
 
-  template<int dim, class VECTOR2, class TRANSFER> friend class PreconditionMG;
+  template<int dim, class OtherVectorType, class TRANSFER> friend class PreconditionMG;
 };
 
 
@@ -368,35 +368,35 @@ public:
    *
    * This is the operator used by LAC iterative solvers.
    */
-  template<class VECTOR2>
-  void vmult (VECTOR2       &dst,
-              const VECTOR2 &src) const;
+  template<class OtherVectorType>
+  void vmult (OtherVectorType       &dst,
+              const OtherVectorType &src) const;
 
   /**
    * Preconditioning operator. Calls the @p vcycle function of the @p MG
    * object passed to the constructor.
    */
-  template<class VECTOR2>
-  void vmult_add (VECTOR2       &dst,
-                  const VECTOR2 &src) const;
+  template<class OtherVectorType>
+  void vmult_add (OtherVectorType       &dst,
+                  const OtherVectorType &src) const;
 
   /**
    * Tranposed preconditioning operator.
    *
    * Not implemented, but the definition may be needed.
    */
-  template<class VECTOR2>
-  void Tvmult (VECTOR2       &dst,
-               const VECTOR2 &src) const;
+  template<class OtherVectorType>
+  void Tvmult (OtherVectorType       &dst,
+               const OtherVectorType &src) const;
 
   /**
    * Tranposed preconditioning operator.
    *
    * Not implemented, but the definition may be needed.
    */
-  template<class VECTOR2>
-  void Tvmult_add (VECTOR2       &dst,
-                   const VECTOR2 &src) const;
+  template<class OtherVectorType>
+  void Tvmult_add (OtherVectorType       &dst,
+                   const OtherVectorType &src) const;
 
 private:
   /**
@@ -491,11 +491,11 @@ PreconditionMG<dim, VectorType, TRANSFER>::empty () const
 }
 
 template<int dim, typename VectorType, class TRANSFER>
-template<class VECTOR2>
+template<class OtherVectorType>
 void
-PreconditionMG<dim, VectorType, TRANSFER>::vmult (
-  VECTOR2 &dst,
 const VECTOR2 &src) const
+PreconditionMG<dim, VectorType, TRANSFER>::vmult
+(OtherVectorType       &dst,
const OtherVectorType &src) const
 {
   transfer->copy_to_mg(*dof_handler,
                        multigrid->defect,
@@ -509,11 +509,11 @@ PreconditionMG<dim, VectorType, TRANSFER>::vmult (
 
 
 template<int dim, typename VectorType, class TRANSFER>
-template<class VECTOR2>
+template<class OtherVectorType>
 void
-PreconditionMG<dim, VectorType, TRANSFER>::vmult_add (
-  VECTOR2 &dst,
 const VECTOR2 &src) const
+PreconditionMG<dim, VectorType, TRANSFER>::vmult_add
+(OtherVectorType       &dst,
const OtherVectorType &src) const
 {
   transfer->copy_to_mg(*dof_handler,
                        multigrid->defect,
@@ -526,22 +526,22 @@ PreconditionMG<dim, VectorType, TRANSFER>::vmult_add (
 
 
 template<int dim, typename VectorType, class TRANSFER>
-template<class VECTOR2>
+template<class OtherVectorType>
 void
-PreconditionMG<dim, VectorType, TRANSFER>::Tvmult (
-  VECTOR2 &,
 const VECTOR2 &) const
+PreconditionMG<dim, VectorType, TRANSFER>::Tvmult
+(OtherVectorType       &,
const OtherVectorType &) const
 {
   Assert(false, ExcNotImplemented());
 }
 
 
 template<int dim, typename VectorType, class TRANSFER>
-template<class VECTOR2>
+template<class OtherVectorType>
 void
-PreconditionMG<dim, VectorType, TRANSFER>::Tvmult_add (
-  VECTOR2 &,
 const VECTOR2 &) const
+PreconditionMG<dim, VectorType, TRANSFER>::Tvmult_add
+(OtherVectorType       &,
const OtherVectorType &) const
 {
   Assert(false, ExcNotImplemented());
 }

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

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.